Merge pull request rust-lang#495 from bjorn3/use_cg_clif_link

Use cg clif link

Author: bjorn3

Cargo.lock

@@ -38,5 +38,8 @@ indexmap = "1.0.2"
 #[patch."https://github.com/gimli-rs/gimli.git"]
 #gimli = { path = "../" }
 
+[patch.crates-io]
+ar = { git = "https://github.com/bjorn3/rust-ar.git", branch = "non_multiple_of_two_identifiers_gnu_format" }
+
 [profile.dev.overrides."*"]
 opt-level = 3

Cargo.toml

@@ -13,6 +13,7 @@ alloc_system = { path = "./alloc_system" }
 
 [patch.crates-io]
 rustc-std-workspace-core = { path = "./sysroot_src/src/tools/rustc-std-workspace-core" }
+rustc-std-workspace-alloc = { path = "./rustc-std-workspace-alloc" }
 compiler_builtins = { path = "./compiler_builtins" }
 
 [profile.release]

build_sysroot/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "rustc-std-workspace-alloc"
+version = "1.0.0"
+authors = ["Alex Crichton <[email protected]>"]
+license = 'MIT/Apache-2.0'
+description = """
+Hack for the compiler's own build system
+"""
+edition = "2018"
+
+[lib]
+path = "lib.rs"
+
+[dependencies]
+alloc = { path = "../sysroot_src/src/liballoc" }

build_sysroot/rustc-std-workspace-alloc/Cargo.toml

@@ -0,0 +1,5 @@
+#![feature(no_core)]
+#![no_core]
+#![deny(rust_2018_idioms)]
+
+pub use ::alloc::*;

build_sysroot/rustc-std-workspace-alloc/lib.rs

@@ -1,4 +1,4 @@
-#![feature(start, box_syntax, alloc_system, core_intrinsics, alloc, alloc_prelude, alloc_error_handler)]
+#![feature(start, box_syntax, alloc_system, core_intrinsics, alloc_prelude, alloc_error_handler)]
 #![no_std]
 
 extern crate alloc;

example/alloc_example.rs

@@ -1,4 +1,3 @@
-use std::collections::HashMap;
 use std::fs::File;
 use std::path::{Path, PathBuf};
 
@@ -8,12 +7,14 @@ use rustc_codegen_ssa::{METADATA_FILENAME, RLIB_BYTECODE_EXTENSION};
 use rustc_codegen_ssa::back::archive::{ArchiveBuilder, find_library};
 
 struct ArchiveConfig<'a> {
-    pub sess: &'a Session,
-    pub dst: PathBuf,
-    pub src: Option<PathBuf>,
-    pub lib_search_paths: Vec<PathBuf>,
+    sess: &'a Session,
+    dst: PathBuf,
+    src: Option<PathBuf>,
+    lib_search_paths: Vec<PathBuf>,
+    use_gnu_style_archive: bool,
 }
 
+#[derive(Debug)]
 enum ArchiveEntry {
     FromArchive { archive_index: usize, entry_index: usize },
     File(File),
@@ -22,7 +23,9 @@ enum ArchiveEntry {
 pub struct ArArchiveBuilder<'a> {
     config: ArchiveConfig<'a>,
     src_archives: Vec<ar::Archive<File>>,
-    entries: HashMap<String, ArchiveEntry>,
+    // Don't use `HashMap` here, as the order is important. `rust.metadata.bin` must always be at
+    // the end of an archive for linkers to not get confused.
+    entries: Vec<(String, ArchiveEntry)>,
     update_symbols: bool,
 }
 
@@ -34,25 +37,27 @@ impl<'a> ArchiveBuilder<'a> for ArArchiveBuilder<'a> {
             dst: output.to_path_buf(),
             src: input.map(|p| p.to_path_buf()),
             lib_search_paths: archive_search_paths(sess),
+            // FIXME test for linux and System V derivatives instead
+            use_gnu_style_archive: !sess.target.target.options.is_like_osx,
         };
 
         let (src_archives, entries) = if let Some(src) = &config.src {
             let mut archive = ar::Archive::new(File::open(src).unwrap());
-            let mut entries = HashMap::new();
+            let mut entries = Vec::new();
 
             let mut i = 0;
             while let Some(entry) = archive.next_entry() {
                 let entry = entry.unwrap();
-                entries.insert(
+                entries.push((
                     String::from_utf8(entry.header().identifier().to_vec()).unwrap(),
                     ArchiveEntry::FromArchive { archive_index: 0, entry_index: i },
-                );
+                ));
                 i += 1;
             }
 
             (vec![archive], entries)
         } else {
-            (vec![], HashMap::new())
+            (vec![], Vec::new())
         };
 
         ArArchiveBuilder {
@@ -64,22 +69,22 @@ impl<'a> ArchiveBuilder<'a> for ArArchiveBuilder<'a> {
     }
 
     fn src_files(&mut self) -> Vec<String> {
-        self.entries.keys().cloned().collect()
+        self.entries.iter().map(|(name, _)| name.clone()).collect()
     }
 
     fn remove_file(&mut self, name: &str) {
-        let file = self.entries.remove(name);
-        assert!(
-            file.is_some(),
-            "Tried to remove file not existing in src archive",
-        );
+        let index = self.entries
+            .iter()
+            .position(|(entry_name, _)| entry_name == name)
+            .expect("Tried to remove file not existing in src archive");
+        self.entries.remove(index);
     }
 
     fn add_file(&mut self, file: &Path) {
-        self.entries.insert(
+        self.entries.push((
             file.file_name().unwrap().to_str().unwrap().to_string(),
             ArchiveEntry::File(File::open(file).unwrap()),
-        );
+        ));
     }
 
     fn add_native_library(&mut self, name: &str) {
@@ -119,24 +124,44 @@ impl<'a> ArchiveBuilder<'a> for ArArchiveBuilder<'a> {
     }
 
     fn build(mut self) {
-        let mut builder = ar::Builder::new(File::create(&self.config.dst).unwrap());
+        enum BuilderKind {
+            Bsd(ar::Builder<File>),
+            Gnu(ar::GnuBuilder<File>),
+        }
+
+        let archive_file = File::create(&self.config.dst).unwrap();
+        let mut builder = if self.config.use_gnu_style_archive {
+            BuilderKind::Gnu(ar::GnuBuilder::new(
+                archive_file,
+                self.entries.iter().map(|(name, _)| name.as_bytes().to_vec()).collect(),
+            ))
+        } else {
+            BuilderKind::Bsd(ar::Builder::new(archive_file))
+        };
 
         // Add all files
         for (entry_name, entry) in self.entries.into_iter() {
             match entry {
                 ArchiveEntry::FromArchive { archive_index, entry_index } => {
                     let entry = self.src_archives[archive_index].jump_to_entry(entry_index).unwrap();
                     let orig_header = entry.header();
+
                     let mut header =
                         ar::Header::new(orig_header.identifier().to_vec(), orig_header.size());
                     header.set_mtime(orig_header.mtime());
                     header.set_uid(orig_header.uid());
                     header.set_gid(orig_header.gid());
                     header.set_mode(orig_header.mode());
-                    builder.append(&header, entry).unwrap();
+                    match builder {
+                        BuilderKind::Bsd(ref mut builder) => builder.append(&header, entry).unwrap(),
+                        BuilderKind::Gnu(ref mut builder) => builder.append(&header, entry).unwrap(),
+                    }
                 }
                 ArchiveEntry::File(mut file) => {
-                    builder.append_file(entry_name.as_bytes(), &mut file).unwrap();
+                    match builder {
+                        BuilderKind::Bsd(ref mut builder) => builder.append_file(entry_name.as_bytes(), &mut file).unwrap(),
+                        BuilderKind::Gnu(ref mut builder) => builder.append_file(entry_name.as_bytes(), &mut file).unwrap(),
+                    }
                 }
             }
         }
@@ -169,10 +194,10 @@ impl<'a> ArArchiveBuilder<'a> {
             let entry = entry.unwrap();
             let file_name = String::from_utf8(entry.header().identifier().to_vec()).unwrap();
             if !skip(&file_name) {
-                self.entries.insert(
+                self.entries.push((
                     file_name,
                     ArchiveEntry::FromArchive { archive_index, entry_index: i },
-                );
+                ));
             }
             i += 1;
         }

src/archive.rs

@@ -28,7 +28,6 @@ use rustc::util::common::ErrorReported;
 use rustc_codegen_ssa::back::linker::LinkerInfo;
 use rustc_codegen_ssa::CrateInfo;
 use rustc_codegen_utils::codegen_backend::CodegenBackend;
-use rustc_codegen_utils::link::out_filename;
 use rustc_mir::monomorphize::partitioning::CodegenUnitExt;
 
 use cranelift::codegen::settings;
@@ -46,8 +45,6 @@ mod common;
 mod constant;
 mod debuginfo;
 mod intrinsics;
-mod link;
-mod link_copied;
 mod linkage;
 mod main_shim;
 mod metadata;
@@ -343,13 +340,13 @@ impl CodegenBackend for CraneliftCodegenBackend {
                 } else {
                     None
                 },
-                metadata_module: CompiledModule {
+                metadata_module: Some(CompiledModule {
                     name: "dummy_metadata".to_string(),
                     kind: ModuleKind::Metadata,
                     object: None,
                     bytecode: None,
                     bytecode_compressed: None,
-                },
+                }),
                 crate_hash: tcx.crate_hash(LOCAL_CRATE),
                 metadata,
                 windows_subsystem: None, // Windows is not yet supported
@@ -366,20 +363,21 @@ impl CodegenBackend for CraneliftCodegenBackend {
         _dep_graph: &DepGraph,
         outputs: &OutputFilenames,
     ) -> Result<(), ErrorReported> {
-        let res = *res
+        use rustc_codegen_ssa::back::link::link_binary;
+
+        let codegen_results = *res
             .downcast::<CodegenResults>()
             .expect("Expected CraneliftCodegenBackend's CodegenResult, found Box<Any>");
 
-        for &crate_type in sess.crate_types.borrow().iter() {
-            let output_name = out_filename(sess, crate_type, &outputs, &res.crate_name.as_str());
-            match crate_type {
-                CrateType::Rlib => link::link_rlib(sess, &res, output_name),
-                CrateType::Dylib | CrateType::Executable => {
-                    link::link_natively(sess, crate_type, &res, &output_name);
-                }
-                _ => sess.fatal(&format!("Unsupported crate type: {:?}", crate_type)),
-            }
-        }
+        let target_cpu = ::target_lexicon::HOST.to_string();
+        link_binary::<crate::archive::ArArchiveBuilder<'_>>(
+            sess,
+            &codegen_results,
+            outputs,
+            &codegen_results.crate_name.as_str(),
+            &target_cpu,
+        );
+
         Ok(())
     }
 }