crate-ify compiler-rt into compiler-builtins

libcompiler-rt.a is dead, long live libcompiler-builtins.rlib

This commit moves the logic that used to build libcompiler-rt.a into a
compiler-builtins crate on top of the core crate and below the std crate.
This new crate still compiles the compiler-rt instrinsics using gcc-rs
but produces an .rlib instead of a static library.

Also, with this commit rustc no longer passes -lcompiler-rt to the
linker. This effectively makes the "no-compiler-rt" field of target
specifications a no-op. Users of `no_std` will have to explicitly add
the compiler-builtins crate to their crate dependency graph *if* they
need the compiler-rt intrinsics. Users of the `std` have to do nothing
extra as the std crate depends on compiler-builtins.

Finally, this a step towards lazy compilation of std with Cargo as the
compiler-rt intrinsics can now be built by Cargo instead of having to
be supplied by the user by some other method.

closes #34400

5 files changed, 17 insertions, 419 deletions

diff --git a/src/bootstrap/clean.rs b/src/bootstrap/clean.rs
index a466e2e6897..a1e286e162f 100644
--- a/src/bootstrap/clean.rs
+++ b/src/bootstrap/clean.rs
@@ -28,7 +28,6 @@ pub fn clean(build: &Build) {
 
         let out = build.out.join(host);
 
-        rm_rf(build, &out.join("compiler-rt"));
         rm_rf(build, &out.join("doc"));
 
         for stage in 0..4 {
diff --git a/src/bootstrap/compile.rs b/src/bootstrap/compile.rs
index e87669ba08c..60bf52a514c 100644
--- a/src/bootstrap/compile.rs
+++ b/src/bootstrap/compile.rs
@@ -35,13 +35,23 @@ pub fn std<'a>(build: &'a Build, target: &str, compiler: &Compiler<'a>) {
     println!("Building stage{} std artifacts ({} -> {})", compiler.stage,
              compiler.host, target);
 
-    // Move compiler-rt into place as it'll be required by the compiler when
-    // building the standard library to link the dylib of libstd
     let libdir = build.sysroot_libdir(compiler, target);
     let _ = fs::remove_dir_all(&libdir);
     t!(fs::create_dir_all(&libdir));
-    copy(&build.compiler_rt_built.borrow()[target],
-         &libdir.join(staticlib("compiler-rt", target)));
+    // FIXME(stage0) remove this `if` after the next snapshot
+    // The stage0 compiler still passes the `-lcompiler-rt` flag to the linker but now `bootstrap`
+    // never builds a `libcopmiler-rt.a`! We'll fill the hole by simply copying stage0's
+    // `libcompiler-rt.a` to where the stage1's one is expected (though we could as well just use
+    // an empty `.a` archive). Note that the symbols of that stage0 `libcompiler-rt.a` won't make
+    // it to the final binary because now `libcore.rlib` also contains the symbols that
+    // `libcompiler-rt.a` provides. Since that rlib appears first in the linker arguments, its
+    // symbols are used instead of `libcompiler-rt.a`'s.
+    if compiler.stage == 0 {
+        let rtlib = &staticlib("compiler-rt", target);
+        let src = build.rustc.parent().unwrap().parent().unwrap().join("lib").join("rustlib")
+            .join(target).join("lib").join(rtlib);
+        copy(&src, &libdir.join(rtlib));
+    }
 
     // Some platforms have startup objects that may be required to produce the
     // libstd dynamic library, for example.
@@ -83,12 +93,10 @@ pub fn std_link(build: &Build,
 
     // If we're linking one compiler host's output into another, then we weren't
     // called from the `std` method above. In that case we clean out what's
-    // already there and then also link compiler-rt into place.
+    // already there.
     if host != compiler.host {
         let _ = fs::remove_dir_all(&libdir);
         t!(fs::create_dir_all(&libdir));
-        copy(&build.compiler_rt_built.borrow()[target],
-             &libdir.join(staticlib("compiler-rt", target)));
     }
     add_to_sysroot(&out_dir, &libdir);
 
diff --git a/src/bootstrap/lib.rs b/src/bootstrap/lib.rs
index 94c14f7ea25..4beba5c8852 100644
--- a/src/bootstrap/lib.rs
+++ b/src/bootstrap/lib.rs
@@ -28,7 +28,6 @@ extern crate rustc_serialize;
 extern crate toml;
 extern crate regex;
 
-use std::cell::RefCell;
 use std::collections::HashMap;
 use std::env;
 use std::fs::{self, File};
@@ -131,7 +130,6 @@ pub struct Build {
     // Runtime state filled in later on
     cc: HashMap<String, (gcc::Tool, Option<PathBuf>)>,
     cxx: HashMap<String, gcc::Tool>,
-    compiler_rt_built: RefCell<HashMap<String, PathBuf>>,
 }
 
 /// The various "modes" of invoking Cargo.
@@ -198,7 +196,6 @@ impl Build {
             package_vers: String::new(),
             cc: HashMap::new(),
             cxx: HashMap::new(),
-            compiler_rt_built: RefCell::new(HashMap::new()),
             gdb_version: None,
             lldb_version: None,
             lldb_python_dir: None,
@@ -252,9 +249,6 @@ impl Build {
                 Llvm { _dummy } => {
                     native::llvm(self, target.target);
                 }
-                CompilerRt { _dummy } => {
-                    native::compiler_rt(self, target.target);
-                }
                 TestHelpers { _dummy } => {
                     native::test_helpers(self, target.target);
                 }
@@ -839,11 +833,6 @@ impl Build {
         }
     }
 
-    /// Root output directory for compiler-rt compiled for `target`
-    fn compiler_rt_out(&self, target: &str) -> PathBuf {
-        self.out.join(target).join("compiler-rt")
-    }
-
     /// Root output directory for rust_test_helpers library compiled for
     /// `target`
     fn test_helpers_out(&self, target: &str) -> PathBuf {
diff --git a/src/bootstrap/native.rs b/src/bootstrap/native.rs
index a4518d6ed76..df6408e5fe1 100644
--- a/src/bootstrap/native.rs
+++ b/src/bootstrap/native.rs
@@ -27,7 +27,7 @@ use cmake;
 use gcc;
 
 use Build;
-use util::{staticlib, up_to_date};
+use util::up_to_date;
 
 /// Compile LLVM for `target`.
 pub fn llvm(build: &Build, target: &str) {
@@ -131,401 +131,6 @@ fn check_llvm_version(build: &Build, llvm_config: &Path) {
     panic!("\n\nbad LLVM version: {}, need >=3.5\n\n", version)
 }
 
-/// Compiles the `compiler-rt` library, or at least the builtins part of it.
-///
-/// Note that while compiler-rt has a build system associated with it, we
-/// specifically don't use it here. The compiler-rt build system, written in
-/// CMake, is actually *very* difficult to work with in terms of getting it to
-/// compile on all the relevant platforms we want it to compile on. In the end
-/// it became so much pain to work with local patches, work around the oddities
-/// of the build system, etc, that we're just building everything by hand now.
-///
-/// In general compiler-rt is just a bunch of intrinsics that are in practice
-/// *very* stable. We just need to make sure that all the relevant functions and
-/// such are compiled somewhere and placed in an object file somewhere.
-/// Eventually, these should all be written in Rust!
-///
-/// So below you'll find a listing of every single file in the compiler-rt repo
-/// that we're compiling. We just reach in and compile with the `gcc` crate
-/// which should have all the relevant flags and such already configured.
-///
-/// The risk here is that if we update compiler-rt we may need to compile some
-/// new intrinsics, but to be honest we surely don't use all of the intrinsics
-/// listed below today so the likelihood of us actually needing a new intrinsic
-/// is quite low. The failure case is also just that someone reports a link
-/// error (if any) and then we just add it to the list. Overall, that cost is
-/// far far less than working with compiler-rt's build system over time.
-pub fn compiler_rt(build: &Build, target: &str) {
-    let build_dir = build.compiler_rt_out(target);
-    let output = build_dir.join(staticlib("compiler-rt", target));
-    build.compiler_rt_built.borrow_mut().insert(target.to_string(),
-                                                output.clone());
-    t!(fs::create_dir_all(&build_dir));
-
-    let mut cfg = gcc::Config::new();
-    cfg.cargo_metadata(false)
-       .out_dir(&build_dir)
-       .target(target)
-       .host(&build.config.build)
-       .opt_level(2)
-       .debug(false);
-
-    if target.contains("msvc") {
-        // Don't pull in extra libraries on MSVC
-        cfg.flag("/Zl");
-
-        // Emulate C99 and C++11's __func__ for MSVC prior to 2013 CTP
-        cfg.define("__func__", Some("__FUNCTION__"));
-    } else {
-        // Turn off various features of gcc and such, mostly copying
-        // compiler-rt's build system already
-        cfg.flag("-fno-builtin");
-        cfg.flag("-fvisibility=hidden");
-        cfg.flag("-fomit-frame-pointer");
-        cfg.flag("-ffreestanding");
-    }
-
-    let mut sources = vec![
-        "absvdi2.c",
-        "absvsi2.c",
-        "adddf3.c",
-        "addsf3.c",
-        "addvdi3.c",
-        "addvsi3.c",
-        "apple_versioning.c",
-        "ashldi3.c",
-        "ashrdi3.c",
-        "clear_cache.c",
-        "clzdi2.c",
-        "clzsi2.c",
-        "cmpdi2.c",
-        "comparedf2.c",
-        "comparesf2.c",
-        "ctzdi2.c",
-        "ctzsi2.c",
-        "divdc3.c",
-        "divdf3.c",
-        "divdi3.c",
-        "divmoddi4.c",
-        "divmodsi4.c",
-        "divsc3.c",
-        "divsf3.c",
-        "divsi3.c",
-        "divxc3.c",
-        "extendsfdf2.c",
-        "extendhfsf2.c",
-        "ffsdi2.c",
-        "fixdfdi.c",
-        "fixdfsi.c",
-        "fixsfdi.c",
-        "fixsfsi.c",
-        "fixunsdfdi.c",
-        "fixunsdfsi.c",
-        "fixunssfdi.c",
-        "fixunssfsi.c",
-        "fixunsxfdi.c",
-        "fixunsxfsi.c",
-        "fixxfdi.c",
-        "floatdidf.c",
-        "floatdisf.c",
-        "floatdixf.c",
-        "floatsidf.c",
-        "floatsisf.c",
-        "floatundidf.c",
-        "floatundisf.c",
-        "floatundixf.c",
-        "floatunsidf.c",
-        "floatunsisf.c",
-        "int_util.c",
-        "lshrdi3.c",
-        "moddi3.c",
-        "modsi3.c",
-        "muldc3.c",
-        "muldf3.c",
-        "muldi3.c",
-        "mulodi4.c",
-        "mulosi4.c",
-        "muloti4.c",
-        "mulsc3.c",
-        "mulsf3.c",
-        "mulvdi3.c",
-        "mulvsi3.c",
-        "mulxc3.c",
-        "negdf2.c",
-        "negdi2.c",
-        "negsf2.c",
-        "negvdi2.c",
-        "negvsi2.c",
-        "paritydi2.c",
-        "paritysi2.c",
-        "popcountdi2.c",
-        "popcountsi2.c",
-        "powidf2.c",
-        "powisf2.c",
-        "powixf2.c",
-        "subdf3.c",
-        "subsf3.c",
-        "subvdi3.c",
-        "subvsi3.c",
-        "truncdfhf2.c",
-        "truncdfsf2.c",
-        "truncsfhf2.c",
-        "ucmpdi2.c",
-        "udivdi3.c",
-        "udivmoddi4.c",
-        "udivmodsi4.c",
-        "udivsi3.c",
-        "umoddi3.c",
-        "umodsi3.c",
-    ];
-
-    if !target.contains("ios") {
-        sources.extend(vec![
-            "absvti2.c",
-            "addtf3.c",
-            "addvti3.c",
-            "ashlti3.c",
-            "ashrti3.c",
-            "clzti2.c",
-            "cmpti2.c",
-            "ctzti2.c",
-            "divtf3.c",
-            "divti3.c",
-            "ffsti2.c",
-            "fixdfti.c",
-            "fixsfti.c",
-            "fixunsdfti.c",
-            "fixunssfti.c",
-            "fixunsxfti.c",
-            "fixxfti.c",
-            "floattidf.c",
-            "floattisf.c",
-            "floattixf.c",
-            "floatuntidf.c",
-            "floatuntisf.c",
-            "floatuntixf.c",
-            "lshrti3.c",
-            "modti3.c",
-            "multf3.c",
-            "multi3.c",
-            "mulvti3.c",
-            "negti2.c",
-            "negvti2.c",
-            "parityti2.c",
-            "popcountti2.c",
-            "powitf2.c",
-            "subtf3.c",
-            "subvti3.c",
-            "trampoline_setup.c",
-            "ucmpti2.c",
-            "udivmodti4.c",
-            "udivti3.c",
-            "umodti3.c",
-        ]);
-    }
-
-    if target.contains("apple") {
-        sources.extend(vec![
-            "atomic_flag_clear.c",
-            "atomic_flag_clear_explicit.c",
-            "atomic_flag_test_and_set.c",
-            "atomic_flag_test_and_set_explicit.c",
-            "atomic_signal_fence.c",
-            "atomic_thread_fence.c",
-        ]);
-    }
-
-    if !target.contains("windows") {
-        sources.push("emutls.c");
-    }
-
-    if target.contains("msvc") {
-        if target.contains("x86_64") {
-            sources.extend(vec![
-                "x86_64/floatdidf.c",
-                "x86_64/floatdisf.c",
-                "x86_64/floatdixf.c",
-            ]);
-        }
-    } else {
-        if !target.contains("freebsd") {
-            sources.push("gcc_personality_v0.c");
-        }
-
-        if target.contains("x86_64") {
-            sources.extend(vec![
-                "x86_64/chkstk.S",
-                "x86_64/chkstk2.S",
-                "x86_64/floatdidf.c",
-                "x86_64/floatdisf.c",
-                "x86_64/floatdixf.c",
-                "x86_64/floatundidf.S",
-                "x86_64/floatundisf.S",
-                "x86_64/floatundixf.S",
-            ]);
-        }
-
-        if target.contains("i386") ||
-           target.contains("i586") ||
-           target.contains("i686") {
-            sources.extend(vec![
-                "i386/ashldi3.S",
-                "i386/ashrdi3.S",
-                "i386/chkstk.S",
-                "i386/chkstk2.S",
-                "i386/divdi3.S",
-                "i386/floatdidf.S",
-                "i386/floatdisf.S",
-                "i386/floatdixf.S",
-                "i386/floatundidf.S",
-                "i386/floatundisf.S",
-                "i386/floatundixf.S",
-                "i386/lshrdi3.S",
-                "i386/moddi3.S",
-                "i386/muldi3.S",
-                "i386/udivdi3.S",
-                "i386/umoddi3.S",
-            ]);
-        }
-    }
-
-    if target.contains("arm") && !target.contains("ios") {
-        sources.extend(vec![
-            "arm/aeabi_cdcmp.S",
-            "arm/aeabi_cdcmpeq_check_nan.c",
-            "arm/aeabi_cfcmp.S",
-            "arm/aeabi_cfcmpeq_check_nan.c",
-            "arm/aeabi_dcmp.S",
-            "arm/aeabi_div0.c",
-            "arm/aeabi_drsub.c",
-            "arm/aeabi_fcmp.S",
-            "arm/aeabi_frsub.c",
-            "arm/aeabi_idivmod.S",
-            "arm/aeabi_ldivmod.S",
-            "arm/aeabi_memcmp.S",
-            "arm/aeabi_memcpy.S",
-            "arm/aeabi_memmove.S",
-            "arm/aeabi_memset.S",
-            "arm/aeabi_uidivmod.S",
-            "arm/aeabi_uldivmod.S",
-            "arm/bswapdi2.S",
-            "arm/bswapsi2.S",
-            "arm/clzdi2.S",
-            "arm/clzsi2.S",
-            "arm/comparesf2.S",
-            "arm/divmodsi4.S",
-            "arm/divsi3.S",
-            "arm/modsi3.S",
-            "arm/switch16.S",
-            "arm/switch32.S",
-            "arm/switch8.S",
-            "arm/switchu8.S",
-            "arm/sync_synchronize.S",
-            "arm/udivmodsi4.S",
-            "arm/udivsi3.S",
-            "arm/umodsi3.S",
-        ]);
-    }
-
-    if target.contains("armv7") {
-        sources.extend(vec![
-            "arm/sync_fetch_and_add_4.S",
-            "arm/sync_fetch_and_add_8.S",
-            "arm/sync_fetch_and_and_4.S",
-            "arm/sync_fetch_and_and_8.S",
-            "arm/sync_fetch_and_max_4.S",
-            "arm/sync_fetch_and_max_8.S",
-            "arm/sync_fetch_and_min_4.S",
-            "arm/sync_fetch_and_min_8.S",
-            "arm/sync_fetch_and_nand_4.S",
-            "arm/sync_fetch_and_nand_8.S",
-            "arm/sync_fetch_and_or_4.S",
-            "arm/sync_fetch_and_or_8.S",
-            "arm/sync_fetch_and_sub_4.S",
-            "arm/sync_fetch_and_sub_8.S",
-            "arm/sync_fetch_and_umax_4.S",
-            "arm/sync_fetch_and_umax_8.S",
-            "arm/sync_fetch_and_umin_4.S",
-            "arm/sync_fetch_and_umin_8.S",
-            "arm/sync_fetch_and_xor_4.S",
-            "arm/sync_fetch_and_xor_8.S",
-        ]);
-    }
-
-    if target.contains("eabihf") {
-        sources.extend(vec![
-            "arm/adddf3vfp.S",
-            "arm/addsf3vfp.S",
-            "arm/divdf3vfp.S",
-            "arm/divsf3vfp.S",
-            "arm/eqdf2vfp.S",
-            "arm/eqsf2vfp.S",
-            "arm/extendsfdf2vfp.S",
-            "arm/fixdfsivfp.S",
-            "arm/fixsfsivfp.S",
-            "arm/fixunsdfsivfp.S",
-            "arm/fixunssfsivfp.S",
-            "arm/floatsidfvfp.S",
-            "arm/floatsisfvfp.S",
-            "arm/floatunssidfvfp.S",
-            "arm/floatunssisfvfp.S",
-            "arm/gedf2vfp.S",
-            "arm/gesf2vfp.S",
-            "arm/gtdf2vfp.S",
-            "arm/gtsf2vfp.S",
-            "arm/ledf2vfp.S",
-            "arm/lesf2vfp.S",
-            "arm/ltdf2vfp.S",
-            "arm/ltsf2vfp.S",
-            "arm/muldf3vfp.S",
-            "arm/mulsf3vfp.S",
-            "arm/negdf2vfp.S",
-            "arm/negsf2vfp.S",
-            "arm/nedf2vfp.S",
-            "arm/nesf2vfp.S",
-            "arm/restore_vfp_d8_d15_regs.S",
-            "arm/save_vfp_d8_d15_regs.S",
-            "arm/subdf3vfp.S",
-            "arm/subsf3vfp.S",
-            "arm/truncdfsf2vfp.S",
-            "arm/unorddf2vfp.S",
-            "arm/unordsf2vfp.S",
-        ]);
-    }
-
-    if target.contains("aarch64") {
-        sources.extend(vec![
-            "comparetf2.c",
-            "extenddftf2.c",
-            "extendsftf2.c",
-            "fixtfdi.c",
-            "fixtfsi.c",
-            "fixtfti.c",
-            "fixunstfdi.c",
-            "fixunstfsi.c",
-            "fixunstfti.c",
-            "floatditf.c",
-            "floatsitf.c",
-            "floatunditf.c",
-            "floatunsitf.c",
-            "multc3.c",
-            "trunctfdf2.c",
-            "trunctfsf2.c",
-        ]);
-    }
-
-    let mut out_of_date = false;
-    for src in sources {
-        let src = build.src.join("src/compiler-rt/lib/builtins").join(src);
-        out_of_date = out_of_date || !up_to_date(&src, &output);
-        cfg.file(src);
-    }
-    if !out_of_date {
-        return
-    }
-    cfg.compile("libcompiler-rt.a");
-}
-
 /// Compiles the `rust_test_helpers.c` library which we used in various
 /// `run-pass` test suites for ABI testing.
 pub fn test_helpers(build: &Build, target: &str) {
diff --git a/src/bootstrap/step.rs b/src/bootstrap/step.rs
index 12929664886..5f391b70fbe 100644
--- a/src/bootstrap/step.rs
+++ b/src/bootstrap/step.rs
@@ -82,7 +82,6 @@ macro_rules! targets {
             // There aren't really any parameters to this, but empty structs
             // with braces are unstable so we just pick something that works.
             (llvm, Llvm { _dummy: () }),
-            (compiler_rt, CompilerRt { _dummy: () }),
             (test_helpers, TestHelpers { _dummy: () }),
             (debugger_scripts, DebuggerScripts { stage: u32 }),
 
@@ -334,8 +333,7 @@ impl<'a> Step<'a> {
                 vec![self.libstd(compiler)]
             }
             Source::Libstd { compiler } => {
-                vec![self.compiler_rt(()),
-                     self.rustc(compiler.stage).target(compiler.host)]
+                vec![self.rustc(compiler.stage).target(compiler.host)]
             }
             Source::LibrustcLink { compiler, host } => {
                 vec![self.librustc(compiler),
@@ -348,7 +346,6 @@ impl<'a> Step<'a> {
                 vec![self.libstd(compiler),
                      self.target(host).rustc(compiler.stage)]
             }
-            Source::CompilerRt { _dummy } => Vec::new(),
             Source::Llvm { _dummy } => Vec::new(),
             Source::TestHelpers { _dummy } => Vec::new(),
             Source::DebuggerScripts { stage: _ } => Vec::new(),