WIP

Author: philipc

Cargo.toml

@@ -13,9 +13,8 @@ crate-type = ["rlib", "dylib"]
 # These have to be in sync with each other
 cranelift = { git = "https://github.com/CraneStation/cranelift.git" }
 cranelift-module = { git = "https://github.com/CraneStation/cranelift.git" }
-cranelift-faerie = { git = "https://github.com/CraneStation/cranelift.git" }
+cranelift-object = { git = "https://github.com/CraneStation/cranelift.git" }
 target-lexicon = "0.4.0"
-faerie = "0.10.0"
 
 #goblin = "0.0.17"
 ar = "0.7.0"
@@ -28,11 +27,11 @@ indexmap = "1.0.2"
 object = "0.12.0"
 
 # Uncomment to use local checkout of cranelift
-#[patch."https://github.com/CraneStation/cranelift.git"]
-#cranelift = { path = "../cranelift/cranelift-umbrella" }
-#cranelift-module = { path = "../cranelift/cranelift-module" }
-#cranelift-simplejit = { path = "../cranelift/cranelift-simplejit" }
-#cranelift-faerie = { path = "../cranelift/cranelift-faerie" }
+[patch."https://github.com/CraneStation/cranelift.git"]
+cranelift = { path = "../cranelift/cranelift-umbrella" }
+cranelift-module = { path = "../cranelift/cranelift-module" }
+cranelift-simplejit = { path = "../cranelift/cranelift-simplejit" }
+cranelift-object = { path = "../cranelift/cranelift-object" }
 
 #[patch."https://github.com/gimli-rs/gimli.git"]
 #gimli = { path = "../" }
@@ -41,8 +40,8 @@ object = "0.12.0"
 cranelift-simplejit = { git = "https://github.com/CraneStation/cranelift.git" }
 
 [patch.crates-io]
-faerie = { git = "https://github.com/m4b/faerie.git" }
-object = { git = "https://github.com/gimli-rs/object.git" }
+#object = { git = "https://github.com/gimli-rs/object.git" }
+object = { path = "../object", features = ["write"] }
 
 [profile.dev.overrides."*"]
 opt-level = 3

build_sysroot/build_sysroot.sh

@@ -1,4 +1,5 @@
 #!/bin/bash
+set -x
 set -e
 cd $(dirname "$0")
 

src/base.rs

@@ -94,7 +94,7 @@ pub fn trans_fn<'a, 'clif, 'tcx: 'a, B: Backend + 'static>(
     let mut debug_context = cx
         .debug_context
         .as_mut()
-        .map(|debug_context| FunctionDebugContext::new(tcx, debug_context, mir, &name, &sig));
+        .map(|debug_context| FunctionDebugContext::new(tcx, debug_context, mir, func_id, &name, &sig));
 
     // Make FunctionBuilder
     let mut func = Function::with_name_signature(ExternalName::user(0, 0), sig);

src/debuginfo.rs

@@ -10,7 +10,9 @@ use gimli::write::{
 };
 use gimli::{Encoding, Format, LineEncoding, RunTimeEndian, SectionId};
 
-use faerie::*;
+use object::{SectionKind, RelocationKind, RelocationEncoding};
+use object::write::*;
+use cranelift_object::*;
 
 fn target_endian(tcx: TyCtxt) -> RunTimeEndian {
     use rustc::ty::layout::Endian;
@@ -73,18 +75,9 @@ enum DebugRelocName {
     Symbol(usize),
 }
 
-impl DebugReloc {
-    fn name<'a>(&self, ctx: &'a DebugContext) -> &'a str {
-        match self.name {
-            DebugRelocName::Section(id) => id.name(),
-            DebugRelocName::Symbol(index) => ctx.symbols.get_index(index).unwrap(),
-        }
-    }
-}
-
 pub struct DebugContext<'tcx> {
     endian: RunTimeEndian,
-    symbols: indexmap::IndexSet<String>,
+    symbols: indexmap::IndexSet<FuncId>,
 
     dwarf: DwarfUnit,
     unit_range_list: RangeList,
@@ -181,7 +174,7 @@ impl<'tcx> DebugContext<'tcx> {
         );
     }
 
-    pub fn emit(&mut self, artifact: &mut Artifact) {
+    pub fn emit(&mut self, product: &mut ObjectProduct) {
         let unit_range_list_id = self.dwarf.unit.ranges.add(self.unit_range_list.clone());
         let root = self.dwarf.unit.root();
         let root = self.dwarf.unit.get_mut(root);
@@ -193,30 +186,39 @@ impl<'tcx> DebugContext<'tcx> {
         let mut sections = Sections::new(WriterRelocate::new(self));
         self.dwarf.write(&mut sections).unwrap();
 
+        let mut map = HashMap::new();
         let _: Result<()> = sections.for_each_mut(|id, section| {
             if !section.writer.slice().is_empty() {
-                artifact
-                    .declare_with(id.name(), Decl::section(SectionKind::Debug), section.writer.take())
-                    .unwrap();
+                let segment = product.object.segment_name(StandardSegment::Debug).to_vec();
+                let name = id.name().as_bytes().to_vec();
+                let data = section.writer.take();
+                let section_id = product.object.add_section(segment, name, SectionKind::Debug);
+                product.object.section_mut(section_id).set_data(data, 1);
+                let symbol_id = product.object.section_symbol(section_id);
+                map.insert(id, (section_id, symbol_id));
             }
             Ok(())
         });
 
         let _: Result<()> = sections.for_each(|id, section| {
-            for reloc in &section.relocs {
-                artifact
-                    .link_with(
-                        faerie::Link {
-                            from: id.name(),
-                            to: reloc.name(self),
-                            at: u64::from(reloc.offset),
-                        },
-                        faerie::Reloc::Debug {
-                            size: reloc.size,
-                            addend: reloc.addend as i32,
-                        },
-                    )
-                    .expect("faerie relocation error");
+            if let Some((section_id, _)) = map.get(&id) {
+                for reloc in &section.relocs {
+                    let symbol = match reloc.name {
+                        DebugRelocName::Section(id) => map.get(&id).unwrap().1,
+                        DebugRelocName::Symbol(id) => {
+                            let func_id = *self.symbols.get_index(id).unwrap();
+                            product.function_symbol(func_id)
+                        }
+                    };
+                    product.object.add_relocation(*section_id, Relocation {
+                        offset: u64::from(reloc.offset),
+                        symbol,
+                        kind: RelocationKind::Absolute,
+                        encoding: RelocationEncoding::Generic,
+                        size: reloc.size * 8,
+                        addend: reloc.addend,
+                    }).unwrap();
+                }
             }
             Ok(())
         });
@@ -235,10 +237,11 @@ impl<'a, 'tcx> FunctionDebugContext<'a, 'tcx> {
         tcx: TyCtxt<'tcx>,
         debug_context: &'a mut DebugContext<'tcx>,
         mir: &Body,
+        func_id: FuncId,
         name: &str,
         _sig: &Signature,
     ) -> Self {
-        let (symbol, _) = debug_context.symbols.insert_full(name.to_string());
+        let (symbol, _) = debug_context.symbols.insert_full(func_id);
 
         // FIXME: add to appropriate scope intead of root
         let scope = debug_context.dwarf.unit.root();

src/driver.rs

@@ -9,7 +9,7 @@ use rustc::session::config::{DebugInfo, OutputType};
 use rustc_codegen_ssa::back::linker::LinkerInfo;
 use rustc_codegen_ssa::CrateInfo;
 
-use cranelift_faerie::*;
+use cranelift_object::*;
 
 use crate::prelude::*;
 
@@ -102,11 +102,11 @@ fn run_aot(
     log: &mut Option<File>,
 ) -> Box<CodegenResults> {
     let new_module = |name: String| {
-        let module: Module<FaerieBackend> = Module::new(
-            FaerieBuilder::new(
+        let module: Module<ObjectBackend> = Module::new(
+            ObjectBuilder::new(
                 crate::build_isa(tcx.sess),
                 name + ".o",
-                FaerieTrapCollection::Disabled,
+                ObjectTrapCollection::Disabled,
                 cranelift_module::default_libcall_names(),
             )
             .unwrap(),
@@ -117,19 +117,19 @@ fn run_aot(
 
     let emit_module = |name: &str,
                        kind: ModuleKind,
-                       mut module: Module<FaerieBackend>,
+                       mut module: Module<ObjectBackend>,
                        debug: Option<DebugContext>| {
         module.finalize_definitions();
-        let mut artifact = module.finish().artifact;
+        let mut product = module.finish();
 
         if let Some(mut debug) = debug {
-            debug.emit(&mut artifact);
+            debug.emit(&mut product);
         }
 
         let tmp_file = tcx
             .output_filenames(LOCAL_CRATE)
             .temp_path(OutputType::Object, Some(name));
-        let obj = artifact.emit().unwrap();
+        let obj = product.emit().unwrap();
         std::fs::write(&tmp_file, obj).unwrap();
         CompiledModule {
             name: name.to_string(),
@@ -140,22 +140,22 @@ fn run_aot(
         }
     };
 
-    let mut faerie_module = new_module("some_file".to_string());
+    let mut object_module = new_module("some_file".to_string());
 
     let mut debug = if tcx.sess.opts.debuginfo != DebugInfo::None
         // macOS debuginfo doesn't work yet (see #303)
         && !tcx.sess.target.target.options.is_like_osx
     {
         let debug = DebugContext::new(
             tcx,
-            faerie_module.target_config().pointer_type().bytes() as u8,
+            object_module.target_config().pointer_type().bytes() as u8,
         );
         Some(debug)
     } else {
         None
     };
 
-    codegen_cgus(tcx, &mut faerie_module, &mut debug, log);
+    codegen_cgus(tcx, &mut object_module, &mut debug, log);
 
     tcx.sess.abort_if_errors();
 
@@ -175,15 +175,17 @@ fn run_aot(
             .as_str()
             .to_string();
 
-        let mut metadata_artifact =
-            faerie::Artifact::new(crate::build_isa(tcx.sess).triple().clone(), metadata_cgu_name.clone());
-        crate::metadata::write_metadata(tcx, &mut metadata_artifact);
+        let triple = crate::build_isa(tcx.sess).triple().clone();
+        let mut metadata_object = 
+            object::write::Object::new(triple.binary_format, triple.architecture);
+        metadata_object.add_file_symbol(metadata_cgu_name.as_bytes().to_vec());
+        crate::metadata::write_metadata(tcx, &mut metadata_object);
 
         let tmp_file = tcx
             .output_filenames(LOCAL_CRATE)
             .temp_path(OutputType::Metadata, Some(&metadata_cgu_name));
 
-        let obj = metadata_artifact.emit().unwrap();
+        let obj = metadata_object.write().unwrap();
         std::fs::write(&tmp_file, obj).unwrap();
 
         Some(CompiledModule {
@@ -202,7 +204,7 @@ fn run_aot(
         modules: vec![emit_module(
             "dummy_name",
             ModuleKind::Regular,
-            faerie_module,
+            object_module,
             debug,
         )],
         allocator_module: if created_alloc_shim {

src/metadata.rs

@@ -50,7 +50,7 @@ impl MetadataLoader for CraneliftMetadataLoader {
 // Adapted from https://github.com/rust-lang/rust/blob/da573206f87b5510de4b0ee1a9c044127e409bd3/src/librustc_codegen_llvm/base.rs#L47-L112
 pub fn write_metadata(
     tcx: TyCtxt<'_>,
-    artifact: &mut faerie::Artifact
+    object: &mut object::write::Object
 ) -> EncodedMetadata {
     use std::io::Write;
     use flate2::Compression;
@@ -90,17 +90,23 @@ pub fn write_metadata(
     DeflateEncoder::new(&mut compressed, Compression::fast())
         .write_all(&metadata.raw_data).unwrap();
 
-    artifact.declare(".rustc", faerie::Decl::section(faerie::SectionKind::Data)).unwrap();
-    artifact.define_with_symbols(".rustc", compressed, {
-        let mut map = std::collections::BTreeMap::new();
-        // FIXME implement faerie elf backend section custom symbols
-        // For MachO this is necessary to prevent the linker from throwing away the .rustc section,
-        // but for ELF it isn't.
-        if tcx.sess.target.target.options.is_like_osx {
-            map.insert(rustc::middle::exported_symbols::metadata_symbol_name(tcx), 0);
-        }
-        map
-    }).unwrap();
+    let segment = object.segment_name(object::write::StandardSegment::Data).to_vec();
+    let section_id = object.add_section(segment, b".rustc".to_vec(), object::SectionKind::Data);
+    let offset = object.append_section_data(section_id, &compressed, 1);
+    // FIXME implement faerie elf backend section custom symbols
+    // For MachO this is necessary to prevent the linker from throwing away the .rustc section,
+    // but for ELF it isn't.
+    if tcx.sess.target.target.options.is_like_osx {
+        object.add_symbol(object::write::Symbol {
+            name: rustc::middle::exported_symbols::metadata_symbol_name(tcx).into_bytes(),
+            value: offset,
+            size: compressed.len() as u64,
+            kind: object::SymbolKind::Data,
+            scope: object::SymbolScope::Compilation,
+            weak: false,
+            section: Some(section_id),
+        });
+    }
 
     metadata
 }

test.sh

@@ -1,6 +1,8 @@
 #!/bin/bash
 source config.sh
 
+set -x
+
 rm -r target/out || true
 mkdir -p target/out/clif