[WIP]

Author: bjorn3

0001-WIP.patch

@@ -0,0 +1,57 @@
+From c15c3efc3d05ca93abef7e3838feb58a004ad001 Mon Sep 17 00:00:00 2001
+From: bjorn3 <bjorn3@users.noreply.github.com>
+Date: Sun, 31 Mar 2019 11:30:09 +0200
+Subject: [PATCH] [WIP]
+
+---
+ src/librustc_codegen_ssa/lib.rs | 23 +++++++++++++++++++++--
+ 1 file changed, 21 insertions(+), 2 deletions(-)
+
+diff --git a/src/librustc_codegen_ssa/lib.rs b/src/librustc_codegen_ssa/lib.rs
+index 69572733cc..9d08cf7d96 100644
+--- a/src/librustc_codegen_ssa/lib.rs
++++ b/src/librustc_codegen_ssa/lib.rs
+@@ -18,6 +18,8 @@
+ 
+ #![recursion_limit="256"]
+ 
++#![feature(rustc_private)]
++
+ //! This crate contains codegen code that is used by all codegen backends (LLVM and others).
+ //! The backend-agnostic functions of this crate use functions defined in various traits that
+ //! have to be implemented by each backends.
+@@ -27,6 +29,25 @@
+ #[macro_use] extern crate rustc_data_structures;
+ #[macro_use] extern crate syntax;
+ 
++extern crate syntax_pos;
++extern crate rustc_mir;
++extern crate libc;
++extern crate rustc_target;
++extern crate rustc_codegen_utils;
++extern crate serialize;
++extern crate rustc_errors;
++extern crate rustc_incremental;
++extern crate memmap;
++extern crate rustc_allocator;
++extern crate cc;
++extern crate rustc_apfloat;
++extern crate tempfile;
++extern crate parking_lot;
++extern crate jobserver;
++extern crate bitflags;
++extern crate num_cpus;
++extern crate rustc_fs_util;
++
+ use std::path::PathBuf;
+ use rustc::dep_graph::WorkProduct;
+ use rustc::session::config::{OutputFilenames, OutputType};
+@@ -160,5 +181,3 @@ pub struct CodegenResults {
+     pub linker_info: back::linker::LinkerInfo,
+     pub crate_info: CrateInfo,
+ }
+-
+-__build_diagnostic_array! { librustc_codegen_ssa, DIAGNOSTICS }
+-- 
+2.11.0
+

Cargo.lock

@@ -29,6 +29,8 @@ gimli = { git = "https://github.com/gimli-rs/gimli.git" }
 indexmap = "1.0.2"
 object = "0.11.0"
 
+rustc_codegen_ssa = { path = "./rustc_codegen_ssa" }
+
 # Uncomment to use local checkout of cranelift
 #[patch."https://github.com/CraneStation/cranelift.git"]
 #cranelift = { path = "../cranelift/cranelift-umbrella" }

Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "rustc_codegen_ssa"
+version = "0.1.0"
+authors = ["bjorn3 <bjorn3@users.noreply.github.com>"]
+edition = "2018"
+
+[dependencies]
+
+[lib]
+path = "../../rust/src/librustc_codegen_ssa/lib.rs"

rustc_codegen_ssa/Cargo.toml

@@ -1,26 +1,37 @@
 use std::collections::HashMap;
 use std::fs::File;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 
 use crate::prelude::*;
 
+use rustc_codegen_ssa::{METADATA_FILENAME, RLIB_BYTECODE_EXTENSION};
+use rustc_codegen_ssa::back::archive::{ArchiveBuilder, find_library};
+
 pub struct ArchiveConfig<'a> {
     pub sess: &'a Session,
     pub dst: PathBuf,
     pub src: Option<PathBuf>,
     pub lib_search_paths: Vec<PathBuf>,
 }
 
-pub struct ArchiveBuilder<'a> {
-    cfg: ArchiveConfig<'a>,
+pub struct ArArchiveBuilder<'a> {
+    config: ArchiveConfig<'a>,
     src_archive: Option<ar::Archive<File>>,
     src_entries: HashMap<String, usize>,
     builder: ar::Builder<File>,
     update_symbols: bool,
 }
 
-impl<'a> ArchiveBuilder<'a> {
-    pub fn new(cfg: ArchiveConfig<'a>) -> Self {
+impl<'a> ArchiveBuilder<'a> for ArArchiveBuilder<'a> {
+    fn new(sess: &'a Session, output: &Path, input: Option<&Path>) -> Self {
+        use rustc_codegen_ssa::back::link::archive_search_paths;
+        let cfg = ArchiveConfig {
+            sess,
+            dst: output.to_path_buf(),
+            src: input.map(|p| p.to_path_buf()),
+            lib_search_paths: archive_search_paths(sess),
+        };
+
         let (src_archive, src_entries) = if let Some(src) = &cfg.src {
             let mut archive = ar::Archive::new(File::open(src).unwrap());
             let mut entries = HashMap::new();
@@ -42,32 +53,68 @@ impl<'a> ArchiveBuilder<'a> {
 
         let builder = ar::Builder::new(File::create(&cfg.dst).unwrap());
 
-        ArchiveBuilder {
-            cfg,
+        ArArchiveBuilder {
+            config: cfg,
             src_archive,
             src_entries,
             builder,
             update_symbols: false,
         }
     }
 
-    pub fn src_files(&self) -> Vec<String> {
+    fn src_files(&mut self) -> Vec<String> {
         self.src_entries.keys().cloned().collect()
     }
 
-    pub fn remove_file(&mut self, name: &str) {
+    fn remove_file(&mut self, name: &str) {
         let file = self.src_entries.remove(name);
         assert!(
             file.is_some(),
             "Tried to remove file not existing in src archive",
         );
     }
 
-    pub fn update_symbols(&mut self) {
+    fn add_file(&mut self, file: &Path) {
+        self.builder.append_path(file).unwrap();
+    }
+
+    fn add_native_library(&mut self, name: &str) {
+        let location = find_library(name, &self.config.lib_search_paths, self.config.sess);
+        self.add_archive(&location, |_| false).unwrap_or_else(|e| {
+            panic!("failed to add native library {}: {}", location.to_string_lossy(), e);
+        });
+    }
+
+    fn add_rlib(&mut self, rlib: &Path, name: &str, lto: bool, skip_objects: bool) -> std::io::Result<()> {
+        let obj_start = name.to_owned();
+
+        self.add_archive(rlib, move |fname: &str| {
+            // Ignore bytecode/metadata files, no matter the name.
+            if fname.ends_with(RLIB_BYTECODE_EXTENSION) || fname == METADATA_FILENAME {
+                return true;
+            }
+
+            // Don't include Rust objects if LTO is enabled
+            if lto && fname.starts_with(&obj_start) && fname.ends_with(".o") {
+                return true;
+            }
+
+            // Otherwise if this is *not* a rust object and we're skipping
+            // objects then skip this file
+            if skip_objects && (!fname.starts_with(&obj_start) || !fname.ends_with(".o")) {
+                return true;
+            }
+
+            // ok, don't skip this
+            return false;
+        })
+    }
+
+    fn update_symbols(&mut self) {
         self.update_symbols = true;
     }
 
-    pub fn build(mut self) {
+    fn build(mut self) {
         // Add files from original archive
         if let Some(mut src_archive) = self.src_archive {
             for (_entry_name, entry_idx) in self.src_entries.into_iter() {
@@ -88,7 +135,7 @@ impl<'a> ArchiveBuilder<'a> {
 
         // Run ranlib to be able to link the archive
         let status = std::process::Command::new("ranlib")
-            .arg(self.cfg.dst)
+            .arg(self.config.dst)
             .status()
             .expect("Couldn't run ranlib");
         assert!(
@@ -98,3 +145,28 @@ impl<'a> ArchiveBuilder<'a> {
         );
     }
 }
+
+impl<'a> ArArchiveBuilder<'a> {
+    fn add_archive<F>(&mut self, archive: &Path, mut skip: F) -> std::io::Result<()>
+        where F: FnMut(&str) -> bool + 'static
+    {
+        let mut archive = ar::Archive::new(std::fs::File::open(archive)?);
+        while let Some(entry) = archive.next_entry() {
+            let entry = entry?;
+            let orig_header = entry.header();
+
+            if skip(std::str::from_utf8(orig_header.identifier()).unwrap()) {
+                continue;
+            }
+
+            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());
+            self.builder.append(&header, entry).unwrap();
+        }
+        Ok(())
+    }
+}

src/archive.rs

@@ -47,8 +47,6 @@ mod common;
 mod constant;
 mod debuginfo;
 mod intrinsics;
-mod link;
-mod link_copied;
 mod linkage;
 mod main_shim;
 mod metadata;
@@ -389,20 +387,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(())
     }
 }