Auto merge of #9118 - bjorn3:profile_codegen_backend_option, r=joshtriplett

Add a profile option to select the codegen backend

This makes it possible to compile only specific crates with a certain codegen backend.

I have tested this by compiling Bevy with cg_llvm, but one of the examples using cg_clif.

By the way I noticed that many unstable profile options are not checked when using profile overrides.

Author: bors

src/cargo/core/compiler/mod.rs

@@ -796,6 +796,7 @@ fn build_base_args(
     let bcx = cx.bcx;
     let Profile {
         ref opt_level,
+        codegen_backend,
         codegen_units,
         debuginfo,
         debug_assertions,
@@ -860,6 +861,10 @@ fn build_base_args(
         }
     }
 
+    if let Some(backend) = codegen_backend {
+        cmd.arg("-Z").arg(&format!("codegen-backend={}", backend));
+    }
+
     if let Some(n) = codegen_units {
         cmd.arg("-C").arg(&format!("codegen-units={}", n));
     }

src/cargo/core/features.rs

@@ -402,6 +402,9 @@ features! {
 
     // Allow to specify per-package targets (compile kinds)
     (unstable, per_package_target, "", "reference/unstable.html#per-package-target"),
+
+    // Allow to specify which codegen backend should be used.
+    (unstable, codegen_backend, "", "reference/unstable.html#codegen-backend"),
 }
 
 pub struct Feature {

src/cargo/core/profiles.rs

@@ -565,6 +565,9 @@ fn merge_profile(profile: &mut Profile, toml: &TomlProfile) {
         Some(StringOrBool::String(ref n)) => profile.lto = Lto::Named(InternedString::new(n)),
         None => {}
     }
+    if toml.codegen_backend.is_some() {
+        profile.codegen_backend = toml.codegen_backend;
+    }
     if toml.codegen_units.is_some() {
         profile.codegen_units = toml.codegen_units;
     }
@@ -626,6 +629,8 @@ pub struct Profile {
     pub root: ProfileRoot,
     pub lto: Lto,
     // `None` means use rustc default.
+    pub codegen_backend: Option<InternedString>,
+    // `None` means use rustc default.
     pub codegen_units: Option<u32>,
     pub debuginfo: Option<u32>,
     pub split_debuginfo: Option<InternedString>,
@@ -644,6 +649,7 @@ impl Default for Profile {
             opt_level: InternedString::new("0"),
             root: ProfileRoot::Debug,
             lto: Lto::Bool(false),
+            codegen_backend: None,
             codegen_units: None,
             debuginfo: None,
             debug_assertions: false,
@@ -670,6 +676,7 @@ compact_debug! {
                 opt_level
                 lto
                 root
+                codegen_backend
                 codegen_units
                 debuginfo
                 split_debuginfo
@@ -757,6 +764,7 @@ impl Profile {
         (
             self.opt_level,
             self.lto,
+            self.codegen_backend,
             self.codegen_units,
             self.debuginfo,
             self.split_debuginfo,

src/cargo/util/toml/mod.rs

@@ -433,6 +433,7 @@ pub enum U32OrBool {
 pub struct TomlProfile {
     pub opt_level: Option<TomlOptLevel>,
     pub lto: Option<StringOrBool>,
+    pub codegen_backend: Option<InternedString>,
     pub codegen_units: Option<u32>,
     pub debug: Option<U32OrBool>,
     pub split_debuginfo: Option<String>,
@@ -491,12 +492,12 @@ impl TomlProfile {
     ) -> CargoResult<()> {
         if let Some(ref profile) = self.build_override {
             features.require(Feature::profile_overrides())?;
-            profile.validate_override("build-override")?;
+            profile.validate_override("build-override", features)?;
         }
         if let Some(ref packages) = self.package {
             features.require(Feature::profile_overrides())?;
             for profile in packages.values() {
-                profile.validate_override("package")?;
+                profile.validate_override("package", features)?;
             }
         }
 
@@ -562,6 +563,18 @@ impl TomlProfile {
         if self.strip.is_some() {
             features.require(Feature::strip())?;
         }
+
+        if let Some(codegen_backend) = &self.codegen_backend {
+            features.require(Feature::codegen_backend())?;
+            if codegen_backend.contains(|c: char| !c.is_ascii_alphanumeric() && c != '_') {
+                bail!(
+                    "`profile.{}.codegen-backend` setting of `{}` is not a valid backend name.",
+                    name,
+                    codegen_backend,
+                );
+            }
+        }
+
         Ok(())
     }
 
@@ -642,7 +655,7 @@ impl TomlProfile {
         Ok(())
     }
 
-    fn validate_override(&self, which: &str) -> CargoResult<()> {
+    fn validate_override(&self, which: &str, features: &Features) -> CargoResult<()> {
         if self.package.is_some() {
             bail!("package-specific profiles cannot be nested");
         }
@@ -658,6 +671,9 @@ impl TomlProfile {
         if self.rpath.is_some() {
             bail!("`rpath` may not be specified in a `{}` profile", which)
         }
+        if self.codegen_backend.is_some() {
+            features.require(Feature::codegen_backend())?;
+        }
         Ok(())
     }
 
@@ -671,6 +687,10 @@ impl TomlProfile {
             self.lto = Some(v.clone());
         }
 
+        if let Some(v) = profile.codegen_backend {
+            self.codegen_backend = Some(v);
+        }
+
         if let Some(v) = profile.codegen_units {
             self.codegen_units = Some(v);
         }

src/doc/src/reference/unstable.md

@@ -1406,3 +1406,21 @@ environment variables.
 The `rust-version` field in `Cargo.toml` has been stabilized in the 1.56 release.
 See the [rust-version field](manifest.html#the-rust-version-field) for more
 information on using the `rust-version` field and the `--ignore-rust-version` option.
+
+### codegen-backend
+
+The `codegen-backend` feature makes it possible to select the codegen backend used by rustc using a
+profile.
+
+Example:
+
+```toml
+[package]
+name = "foo"
+
+[dependencies]
+serde = "1.0.117"
+
+[profile.dev.package.foo]
+codegen-backend = "cranelift"
+```