Add target-feature=[+-]crt-included.

This is supposed to support optionally using the system copy of musl
libc instead of the included one if supported. This currently only
affects the start files, which is enough to allow building rustc on musl
targets.

Author: mixi

config.toml.example

@@ -392,6 +392,14 @@
 # only use static libraries. If unset, the target's default linkage is used.
 #crt-static = false
 
+# Force using the included C standard library for this target. If this target
+# is a host for rustc, this will also affect the linkage of the compiler
+# itself. This is useful for building rustc on targets that normally only use
+# the included C runtime. If unset, the target's default is used. This only
+# works if the linker for the target is targeting the corresponding C standard
+# library.
+#crt-included = true
+
 # The root location of the MUSL installation directory. The library directory
 # will also need to contain libunwind.a for an unwinding implementation. Note
 # that this option only makes sense for MUSL targets that produce statically

src/bootstrap/bin/rustc.rs

@@ -235,13 +235,28 @@ fn main() {
             }
         }
 
+        let mut target_features = Vec::new();
+
         if let Ok(s) = env::var("RUSTC_CRT_STATIC") {
             if s == "true" {
-                cmd.arg("-C").arg("target-feature=+crt-static");
+                target_features.push("+crt-static");
             }
             if s == "false" {
-                cmd.arg("-C").arg("target-feature=-crt-static");
+                target_features.push("-crt-static");
+            }
+        }
+
+        if let Ok(s) = env::var("RUSTC_CRT_INCLUDED") {
+            if s == "true" {
+                target_features.push("+crt-included");
             }
+            if s == "false" {
+                target_features.push("-crt-included");
+            }
+        }
+
+        if !target_features.is_empty() {
+            cmd.arg("-C").arg(format!("target-feature={}", target_features.join(",")));
         }
 
         // When running miri tests, we need to generate MIR for all libraries

src/bootstrap/builder.rs

@@ -663,6 +663,10 @@ impl<'a> Builder<'a> {
             cargo.env("RUSTC_CRT_STATIC", x.to_string());
         }
 
+        if let Some(x) = self.crt_included(target) {
+            cargo.env("RUSTC_CRT_INCLUDED", x.to_string());
+        }
+
         // Enable usage of unstable features
         cargo.env("RUSTC_BOOTSTRAP", "1");
         self.add_rust_test_threads(&mut cargo);

src/bootstrap/config.rs

@@ -162,6 +162,7 @@ pub struct Target {
     pub linker: Option<PathBuf>,
     pub ndk: Option<PathBuf>,
     pub crt_static: Option<bool>,
+    pub crt_included: Option<bool>,
     pub musl_root: Option<PathBuf>,
     pub qemu_rootfs: Option<PathBuf>,
     pub no_std: bool,
@@ -320,6 +321,7 @@ struct TomlTarget {
     linker: Option<String>,
     android_ndk: Option<String>,
     crt_static: Option<bool>,
+    crt_included: Option<bool>,
     musl_root: Option<String>,
     qemu_rootfs: Option<String>,
 }
@@ -557,6 +559,7 @@ impl Config {
                 target.ar = cfg.ar.clone().map(PathBuf::from);
                 target.linker = cfg.linker.clone().map(PathBuf::from);
                 target.crt_static = cfg.crt_static.clone();
+                target.crt_included = cfg.crt_included.clone();
                 target.musl_root = cfg.musl_root.clone().map(PathBuf::from);
                 target.qemu_rootfs = cfg.qemu_rootfs.clone().map(PathBuf::from);
 

src/bootstrap/lib.rs

@@ -741,6 +741,11 @@ impl Build {
         }
     }
 
+    /// Returns if this target should use the included libc when linking
+    fn crt_included(&self, target: Interned<String>) -> Option<bool> {
+        self.config.target_config.get(&target).and_then(|t| t.crt_included)
+    }
+
     /// Returns the "musl root" for this `target`, if defined
     fn musl_root(&self, target: Interned<String>) -> Option<&Path> {
         self.config.target_config.get(&target)

src/librustc/session/mod.rs

@@ -657,6 +657,27 @@ impl Session {
         }
     }
 
+    pub fn crt_included(&self) -> bool {
+        // If the target does not opt in to crt-included support, use its default.
+        if self.target.target.options.crt_included_respected {
+            self.crt_included_feature()
+        } else {
+            self.target.target.options.crt_included_default
+        }
+    }
+
+    pub fn crt_included_feature(&self) -> bool {
+        let requested_features = self.opts.cg.target_feature.split(',');
+        let found_negative = requested_features.clone().any(|r| r == "-crt-included");
+        let found_positive = requested_features.clone().any(|r| r == "+crt-included");
+
+        if self.target.target.options.crt_included_default {
+            !found_negative
+        } else {
+            found_positive
+        }
+    }
+
     pub fn must_not_eliminate_frame_pointers(&self) -> bool {
         self.opts.debuginfo != DebugInfoLevel::NoDebugInfo
             || !self.target.target.options.eliminate_frame_pointer

src/librustc_target/spec/linux_musl_base.rs

@@ -15,7 +15,7 @@ pub fn opts() -> TargetOptions {
 
     // Make sure that the linker/gcc really don't pull in anything, including
     // default objects, libs, etc.
-    base.pre_link_args.get_mut(&LinkerFlavor::Gcc).unwrap().push("-nostdlib".to_string());
+    base.pre_link_args_crt.insert(LinkerFlavor::Gcc, vec!["-nostdlib".to_string()]);
 
     // At least when this was tested, the linker would not add the
     // `GNU_EH_FRAME` program header to executables generated, which is required
@@ -55,14 +55,20 @@ pub fn opts() -> TargetOptions {
     //
     // Each target directory for musl has these object files included in it so
     // they'll be included from there.
-    base.pre_link_objects_exe.push("crt1.o".to_string());
-    base.pre_link_objects_exe.push("crti.o".to_string());
-    base.post_link_objects.push("crtn.o".to_string());
+    base.pre_link_objects_exe_crt.push("crt1.o".to_string());
+    base.pre_link_objects_exe_crt.push("crti.o".to_string());
+    base.post_link_objects_crt.push("crtn.o".to_string());
 
     // These targets statically link libc by default
     base.crt_static_default = true;
     // These targets allow the user to choose between static and dynamic linking.
     base.crt_static_respected = true;
 
+    // These targets support using an included libc instead of the system one
+    // when linking.
+    base.crt_included_default = true;
+    // These targets can use the libc included with our standard library.
+    base.crt_included_respected = true;
+
     base
 }

src/librustc_target/spec/mod.rs

@@ -420,20 +420,23 @@ pub struct TargetOptions {
     /// Linker to invoke
     pub linker: Option<String>,
 
-    /// Linker arguments that are unconditionally passed *before* any
-    /// user-defined libraries.
-    pub pre_link_args: LinkArgs,
+    /// Linker arguments that are passed *before* any user-defined libraries.
+    pub pre_link_args: LinkArgs, // ... unconditionally
+    pub pre_link_args_crt: LinkArgs, // ... with included-crt enabled
     /// Objects to link before all others, always found within the
     /// sysroot folder.
     pub pre_link_objects_exe: Vec<String>, // ... when linking an executable
     pub pre_link_objects_dll: Vec<String>, // ... when linking a dylib
+    pub pre_link_objects_exe_crt: Vec<String>, // ... when linking an executable with included-crt
+                                               // enabled
     /// Linker arguments that are unconditionally passed after any
     /// user-defined but before post_link_objects.  Standard platform
     /// libraries that should be always be linked to, usually go here.
     pub late_link_args: LinkArgs,
     /// Objects to link after all others, always found within the
     /// sysroot folder.
-    pub post_link_objects: Vec<String>,
+    pub post_link_objects: Vec<String>, // ... unconditionally
+    pub post_link_objects_crt: Vec<String>, // ... with included-crt enabled
     /// Linker arguments that are unconditionally passed *after* any
     /// user-defined libraries.
     pub post_link_args: LinkArgs,
@@ -578,6 +581,11 @@ pub struct TargetOptions {
     /// Whether or not crt-static is respected by the compiler (or is a no-op).
     pub crt_static_respected: bool,
 
+    /// Whether or not the CRT can be replaced with an included one.
+    pub crt_included_default: bool,
+    /// Whether or not the included-crt is respected by the compiler (or is a no-op).
+    pub crt_included_respected: bool,
+
     /// Whether or not stack probes (__rust_probestack) are enabled
     pub stack_probes: bool,
 
@@ -633,6 +641,7 @@ impl Default for TargetOptions {
             is_builtin: false,
             linker: option_env!("CFG_DEFAULT_LINKER").map(|s| s.to_string()),
             pre_link_args: LinkArgs::new(),
+            pre_link_args_crt: LinkArgs::new(),
             post_link_args: LinkArgs::new(),
             asm_args: Vec::new(),
             cpu: "generic".to_string(),
@@ -667,7 +676,9 @@ impl Default for TargetOptions {
             relro_level: RelroLevel::None,
             pre_link_objects_exe: Vec::new(),
             pre_link_objects_dll: Vec::new(),
+            pre_link_objects_exe_crt: Vec::new(),
             post_link_objects: Vec::new(),
+            post_link_objects_crt: Vec::new(),
             late_link_args: LinkArgs::new(),
             link_env: Vec::new(),
             archive_format: "gnu".to_string(),
@@ -684,6 +695,8 @@ impl Default for TargetOptions {
             crt_static_allows_dylibs: false,
             crt_static_default: false,
             crt_static_respected: false,
+            crt_included_default: false,
+            crt_included_respected: false,
             stack_probes: false,
             min_global_align: None,
             default_codegen_units: None,
@@ -886,10 +899,13 @@ impl Target {
         key!(is_builtin, bool);
         key!(linker, optional);
         key!(pre_link_args, link_args);
+        key!(pre_link_args_crt, link_args);
         key!(pre_link_objects_exe, list);
         key!(pre_link_objects_dll, list);
+        key!(pre_link_objects_exe_crt, list);
         key!(late_link_args, link_args);
         key!(post_link_objects, list);
+        key!(post_link_objects_crt, list);
         key!(post_link_args, link_args);
         key!(link_env, env);
         key!(asm_args, list);
@@ -936,6 +952,8 @@ impl Target {
         key!(crt_static_allows_dylibs, bool);
         key!(crt_static_default, bool);
         key!(crt_static_respected, bool);
+        key!(crt_included_default, bool);
+        key!(crt_included_respected, bool);
         key!(stack_probes, bool);
         key!(min_global_align, Option<u64>);
         key!(default_codegen_units, Option<u64>);
@@ -1091,10 +1109,13 @@ impl ToJson for Target {
         target_option_val!(is_builtin);
         target_option_val!(linker);
         target_option_val!(link_args - pre_link_args);
+        target_option_val!(link_args - pre_link_args_crt);
         target_option_val!(pre_link_objects_exe);
         target_option_val!(pre_link_objects_dll);
+        target_option_val!(pre_link_objects_exe_crt);
         target_option_val!(link_args - late_link_args);
         target_option_val!(post_link_objects);
+        target_option_val!(post_link_objects_crt);
         target_option_val!(link_args - post_link_args);
         target_option_val!(env - link_env);
         target_option_val!(asm_args);
@@ -1141,6 +1162,8 @@ impl ToJson for Target {
         target_option_val!(crt_static_allows_dylibs);
         target_option_val!(crt_static_default);
         target_option_val!(crt_static_respected);
+        target_option_val!(crt_included_default);
+        target_option_val!(crt_included_respected);
         target_option_val!(stack_probes);
         target_option_val!(min_global_align);
         target_option_val!(default_codegen_units);

src/librustc_trans/back/link.rs

@@ -621,6 +621,11 @@ fn link_natively(sess: &Session,
     if let Some(args) = sess.target.target.options.pre_link_args.get(&flavor) {
         cmd.args(args);
     }
+    if let Some(args) = sess.target.target.options.pre_link_args_crt.get(&flavor) {
+        if sess.crt_included() {
+            cmd.args(args);
+        }
+    }
     if let Some(ref args) = sess.opts.debugging_opts.pre_link_args {
         cmd.args(args);
     }
@@ -635,6 +640,12 @@ fn link_natively(sess: &Session,
         cmd.arg(root.join(obj));
     }
 
+    if crate_type == config::CrateTypeExecutable && sess.crt_included() {
+        for obj in &sess.target.target.options.pre_link_objects_exe_crt {
+            cmd.arg(root.join(obj));
+        }
+    }
+
     if sess.target.target.options.is_like_emscripten {
         cmd.arg("-s");
         cmd.arg(if sess.panic_strategy() == PanicStrategy::Abort {
@@ -656,6 +667,11 @@ fn link_natively(sess: &Session,
     for obj in &sess.target.target.options.post_link_objects {
         cmd.arg(root.join(obj));
     }
+    if sess.crt_included() {
+        for obj in &sess.target.target.options.post_link_objects_crt {
+            cmd.arg(root.join(obj));
+        }
+    }
     if let Some(args) = sess.target.target.options.post_link_args.get(&flavor) {
         cmd.args(args);
     }

src/librustc_trans/back/write.rs

@@ -126,6 +126,7 @@ pub fn write_output_file(
 fn target_feature(sess: &Session) -> String {
     let rustc_features = [
         "crt-static",
+        "crt-included",
     ];
     let requested_features = sess.opts.cg.target_feature.split(',');
     let llvm_features = requested_features.filter(|f| {