[bazel] cross language LTO (#32368)

This PR enables cross language LTO for our release builds, meaning
function calls from external C dependencies like `libdecimal` can
potentially get inlined into Rust code.

The way this works is when building our final binaries, e.g.
`environmentd` and `clusterd`, we specify the `-Clinker-plugin-lto` flag
to `rustc` which has our linker (`lld`) run the LTO passes instead of
`rustc`. At which point all of our Rust and C code has been compiled to
LLVM bitcode so to `lld` is free to optimize across languages.

This only works when building for Linux. Arguments that `rustc` passes
to the linker when targetting macOS don't seem to be supported by
`ld64.lld`? See rust-lang/rust#60059 for some
more investigation.

### Motivation

Faster runtime performance. 

### Tips for reviewer

The commits are broken down as follows:

1. Some Bazel configuration so we can detect when the cross language LTO
is requested _and_ when we're building on a Linux machine.
2. Updates to cargo-gazelle so we specify the right `rustc` flags.
Theoretically something like this could be upstreamed into `rules_rust`
which I started working on in
bazelbuild/rules_rust#3162. But for now updating
cargo-gazelle is a lot easier.
3. Running `bin/bazel gen`

### Checklist

- [ ] This PR has adequate test coverage / QA involvement has been duly
considered. ([trigger-ci for additional test/nightly
runs](https://trigger-ci.dev.materialize.com/))
- [ ] This PR has an associated up-to-date [design
doc](https://github.com/MaterializeInc/materialize/blob/main/doc/developer/design/README.md),
is a design doc
([template](https://github.com/MaterializeInc/materialize/blob/main/doc/developer/design/00000000_template.md)),
or is sufficiently small to not require a design.
  <!-- Reference the design in the description. -->
- [ ] If this PR evolves [an existing `$T ⇔ Proto$T`
mapping](https://github.com/MaterializeInc/materialize/blob/main/doc/developer/command-and-response-binary-encoding.md)
(possibly in a backwards-incompatible way), then it is tagged with a
`T-proto` label.
- [ ] If this PR will require changes to cloud orchestration or tests,
there is a companion cloud PR to account for those changes that is
tagged with the release-blocker label
([example](https://github.com/MaterializeInc/cloud/pull/5021)).
<!-- Ask in #team-cloud on Slack if you need help preparing the cloud
PR. -->
- [ ] If this PR includes major [user-facing behavior
changes](https://github.com/MaterializeInc/materialize/blob/main/doc/developer/guide-changes.md#what-changes-require-a-release-note),
I have pinged the relevant PM to schedule a changelog post.

Author: ParkMyCar

.bazelrc

@@ -170,6 +170,7 @@ build:release --compilation_mode=opt
 build:release-lto --copt=-flto=thin
 build:release-lto --linkopt=-flto=thin
 build:release-lto --@rules_rust//rust/settings:lto=thin
+build:release-lto --@//misc/bazel/platforms:xlang_lto=True
 
 # Builds from `main` or tagged builds.
 #

misc/bazel/cargo-gazelle/BUILD.bazel

@@ -90,7 +90,10 @@ rust_binary(
     lint_config = ":lints",
     proc_macro_deps = [] + all_crate_deps(proc_macro = True),
     rustc_env = {},
-    rustc_flags = ["-Copt-level=3"],
+    rustc_flags = ["-Copt-level=3"] + select({
+        "@//misc/bazel/platforms:xlang_lto_enabled": ["-Clinker-plugin-lto"],
+        "//conditions:default": [],
+    }),
     version = "0.0.0",
     deps = [":cargo_gazelle"] + all_crate_deps(normal = True),
 )

misc/bazel/cargo-gazelle/src/config.rs

@@ -13,6 +13,7 @@ use std::collections::BTreeMap;
 use guppy::graph::PackageMetadata;
 use std::sync::LazyLock;
 
+use crate::ToBazelDefinition;
 use crate::targets::{AdditiveContent, RustTestSize};
 
 const KEY_NAME: &str = "cargo-gazelle";
@@ -315,3 +316,21 @@ impl CommonConfig {
         &self.rustc_env
     }
 }
+
+/// Values that are mirrored in `/misc/bazel/platforms/BUILD.bazel`.
+#[derive(Debug, Copy, Clone)]
+pub enum ConfigSettingGroup {
+    XlangLtoEnabled,
+}
+
+impl ToBazelDefinition for ConfigSettingGroup {
+    fn format(&self, w: &mut dyn std::fmt::Write) -> Result<(), std::fmt::Error> {
+        match self {
+            ConfigSettingGroup::XlangLtoEnabled => {
+                write!(w, "\"@//misc/bazel/platforms:xlang_lto_enabled\"")?
+            }
+        }
+
+        Ok(())
+    }
+}

misc/bazel/cargo-gazelle/src/lib.rs

@@ -11,7 +11,6 @@ use std::collections::{BTreeMap, VecDeque};
 use std::fmt::{self, Debug, Write};
 use std::rc::Rc;
 
-use crate::platforms::PlatformVariant;
 use crate::targets::RustTarget;
 
 pub mod args;
@@ -510,20 +509,21 @@ impl ToBazelDefinition for Glob {
 /// ```
 #[derive(Debug)]
 pub struct Select<T> {
-    entries: BTreeMap<PlatformVariant, T>,
+    entries: BTreeMap<String, T>,
     default: T,
 }
 
 impl<T> Select<T> {
-    pub fn new<E, I>(entires: I, default: E) -> Select<T>
+    pub fn new<E, I, J>(entires: I, default: E) -> Select<T>
     where
         E: Into<T>,
-        I: IntoIterator<Item = (PlatformVariant, E)>,
+        J: ToBazelDefinition,
+        I: IntoIterator<Item = (J, E)>,
     {
         Select {
             entries: entires
                 .into_iter()
-                .map(|(variant, entry)| (variant, entry.into()))
+                .map(|(variant, entry)| (variant.to_bazel_definition(), entry.into()))
                 .collect(),
             default: default.into(),
         }
@@ -538,7 +538,7 @@ impl<T: ToBazelDefinition> ToBazelDefinition for Select<T> {
         {
             let mut w = w.indent();
             for (variant, entry) in &self.entries {
-                variant.format(&mut w)?;
+                write!(w, "{variant}")?;
                 write!(w, ": ")?;
                 entry.format(&mut w)?;
                 writeln!(w, ",")?;

misc/bazel/cargo-gazelle/src/targets.rs

@@ -21,7 +21,7 @@ use std::collections::{BTreeMap, BTreeSet};
 use std::fmt::{self, Write};
 use std::str::FromStr;
 
-use crate::config::{CrateConfig, GlobalConfig};
+use crate::config::{ConfigSettingGroup, CrateConfig, GlobalConfig};
 use crate::context::CrateContext;
 use crate::platforms::PlatformVariant;
 use crate::rules::Rule;
@@ -382,8 +382,17 @@ impl RustBinary {
         let (paths, globs) = bin_config.common().compile_data();
         let compile_data = List::new(paths).concat_other(globs.map(Glob::new));
 
+        let xlang_lto_select: Select<List<QuotedString>> = Select::new(
+            [(
+                ConfigSettingGroup::XlangLtoEnabled,
+                vec![QuotedString::new("-Clinker-plugin-lto")],
+            )],
+            vec![],
+        );
+
         let env = Dict::new(bin_config.env());
-        let rustc_flags = List::new(bin_config.common().rustc_flags());
+        let rustc_flags =
+            List::new(bin_config.common().rustc_flags()).concat_other(xlang_lto_select);
         let rustc_env = Dict::new(bin_config.common().rustc_env());
 
         Ok(Some(RustBinary {

misc/bazel/platforms/BUILD.bazel

@@ -16,7 +16,7 @@ support building Materialize for.
 """
 
 load("@bazel_skylib//lib:selects.bzl", "selects")
-load("@bazel_skylib//rules:common_settings.bzl", "string_flag")
+load("@bazel_skylib//rules:common_settings.bzl", "bool_flag", "string_flag")
 
 # A flag that we can specify on the command line to configure whether or not we
 # build with a sanitizer.
@@ -45,6 +45,28 @@ config_setting(
     flag_values = {":sanitizer": "hwaddress"},
 )
 
+bool_flag(
+    name = "xlang_lto",
+    build_setting_default = False,
+)
+
+config_setting(
+    name = "use_xlang_lto",
+    flag_values = {":xlang_lto": "True"},
+)
+
+# With our current toolchain setup, cross language LTO is only supported when building for Linux.
+#
+# See <https://github.com/rust-lang/rust/issues/60059> for macOS support.
+selects.config_setting_group(
+    name = "xlang_lto_enabled",
+    match_all = [
+        "@platforms//os:linux",
+        ":use_xlang_lto",
+    ],
+    visibility = ["//visibility:public"],
+)
+
 # We only want to use jemalloc if we're building for Linux and we're not using sanitizers.
 selects.config_setting_group(
     name = "use_jemalloc",

src/balancerd/BUILD.bazel

@@ -179,7 +179,10 @@ rust_binary(
     lint_config = ":lints",
     proc_macro_deps = [] + all_crate_deps(proc_macro = True),
     rustc_env = {},
-    rustc_flags = [],
+    rustc_flags = [] + select({
+        "@//misc/bazel/platforms:xlang_lto_enabled": ["-Clinker-plugin-lto"],
+        "//conditions:default": [],
+    }),
     version = "0.144.0-dev.0",
     deps = [
         ":mz_balancerd",

src/catalog-debug/BUILD.bazel

@@ -30,7 +30,10 @@ rust_binary(
     lint_config = ":lints",
     proc_macro_deps = [] + all_crate_deps(proc_macro = True),
     rustc_env = {},
-    rustc_flags = [],
+    rustc_flags = [] + select({
+        "@//misc/bazel/platforms:xlang_lto_enabled": ["-Clinker-plugin-lto"],
+        "//conditions:default": [],
+    }),
     version = "0.144.0-dev.0",
     deps = [
         "//src/adapter:mz_adapter",

src/clusterd/BUILD.bazel

@@ -156,7 +156,10 @@ rust_binary(
     lint_config = ":lints",
     proc_macro_deps = [] + all_crate_deps(proc_macro = True),
     rustc_env = {},
-    rustc_flags = [],
+    rustc_flags = [] + select({
+        "@//misc/bazel/platforms:xlang_lto_enabled": ["-Clinker-plugin-lto"],
+        "//conditions:default": [],
+    }),
     version = "0.144.0-dev.0",
     deps = [
         ":mz_clusterd",

src/environmentd/BUILD.bazel

@@ -793,7 +793,10 @@ rust_binary(
     lint_config = ":lints",
     proc_macro_deps = [] + all_crate_deps(proc_macro = True),
     rustc_env = {},
-    rustc_flags = [],
+    rustc_flags = [] + select({
+        "@//misc/bazel/platforms:xlang_lto_enabled": ["-Clinker-plugin-lto"],
+        "//conditions:default": [],
+    }),
     version = "0.144.0-dev.0",
     deps = [
         ":mz_environmentd",