Address some rustc inconsistency issues

We noticed when building rustc multiple time in a roll, some files
will not be consistent across the build despite the fact that they
are built from same source under the same environment. This patch
addresses the inconsistency issue we found on libunwind.a by sorting
the order of the files passed to the linker. This patch also adds
a passthrough of "SOURCE_DATE_EPOCH" env arg from bootstrap to cargo
to partially address the inconsistency on the cargo binary.

Author: zeroomega

src/bootstrap/src/core/build_steps/compile.rs

@@ -2228,11 +2228,20 @@ impl Step for Assemble {
         let rustc_libdir = builder.rustc_libdir(target_compiler);
         t!(fs::create_dir_all(&rustc_libdir));
         let src_libdir = builder.sysroot_target_libdir(build_compiler, host);
-        for f in builder.read_dir(&src_libdir) {
-            let filename = f.file_name().into_string().unwrap();
+        let mut files = builder.read_dir(&src_libdir)
+            .map(|entry| {
+                entry
+                    .path()
+                    .canonicalize()
+                    .unwrap()
+            })
+            .collect::<Vec<_>>();
+        files.sort();
+        for f in files {
+            let filename = f.file_name().unwrap().to_os_string().into_string().unwrap();
 
             let is_proc_macro = proc_macros.contains(&filename);
-            let is_dylib_or_debug = is_dylib(&f.path()) || is_debug_info(&filename);
+            let is_dylib_or_debug = is_dylib(&f) || is_debug_info(&filename);
 
             // If we link statically to stdlib, do not copy the libstd dynamic library file
             // FIXME: Also do this for Windows once incremental post-optimization stage0 tests
@@ -2248,7 +2257,7 @@ impl Step for Assemble {
             };
 
             if is_dylib_or_debug && can_be_rustc_dynamic_dep && !is_proc_macro {
-                builder.copy_link(&f.path(), &rustc_libdir.join(&filename), FileType::Regular);
+                builder.copy_link(&f, &rustc_libdir.join(&filename), FileType::Regular);
             }
         }
 
@@ -2376,15 +2385,19 @@ pub fn run_cargo(
     let mut deps = Vec::new();
     let mut toplevel = Vec::new();
     let ok = stream_cargo(builder, cargo, tail_args, &mut |msg| {
-        let (filenames, crate_types) = match msg {
+        let (filenames_vec, crate_types) = match msg {
             CargoMessage::CompilerArtifact {
                 filenames,
                 target: CargoTarget { crate_types },
                 ..
-            } => (filenames, crate_types),
+            } => {
+                let mut f: Vec<String> = filenames.into_iter().map(|s| s.into_owned()).collect();
+                f.sort(); // Sort the filenames
+                (f, crate_types)
+            },
             _ => return,
         };
-        for filename in filenames {
+        for filename in filenames_vec {
             // Skip files like executables
             let mut keep = false;
             if filename.ends_with(".lib")

src/bootstrap/src/core/build_steps/llvm.rs

@@ -1528,8 +1528,18 @@ impl Step for Libunwind {
 
         // FIXME: https://github.com/alexcrichton/cc-rs/issues/545#issuecomment-679242845
         let mut count = 0;
-        for entry in fs::read_dir(&out_dir).unwrap() {
-            let file = entry.unwrap().path().canonicalize().unwrap();
+        let mut files = fs::read_dir(&out_dir)
+            .unwrap()
+            .map(|entry| {
+                entry
+                    .unwrap()
+                    .path()
+                    .canonicalize()
+                    .unwrap()
+            })
+            .collect::<Vec<_>>();
+        files.sort();
+        for file in files {
             if file.is_file() && file.extension() == Some(OsStr::new("o")) {
                 // Object file name without the hash prefix is "Unwind-EHABI", "Unwind-seh" or "libunwind".
                 let base_name = unhashed_basename(&file);

src/bootstrap/src/core/builder/cargo.rs

@@ -1269,6 +1269,16 @@ impl Builder<'_> {
             if self.link_std_into_rustc_driver(target) { "1" } else { "0" },
         );
 
+        // Crates like openssl will record current timestamp at build time.
+        // The current timestamp can be override by SOURCE_DATE_EPOCH
+        // environment variable.
+        // Pass through SOURCE_DATE_EPOCH environment variable to allow
+        // some crates to be reproducible.
+        let source_date_epoch_env = "SOURCE_DATE_EPOCH";
+        if let Ok(var) = std::env::var(&source_date_epoch_env) {
+            cargo.env(&source_date_epoch_env, &var);
+        }
+
         // When building incrementally we default to a lower ThinLTO import limit
         // (unless explicitly specified otherwise). This will produce a somewhat
         // slower code but give way better compile times.