Update Cranelift to 0.82

Author: Amanieu

Cargo.lock

@@ -15,20 +15,20 @@ edition = "2018"
 wasmer-compiler = { path = "../compiler", version = "=2.2.1", features = ["translator"], default-features = false }
 wasmer-vm = { path = "../vm", version = "=2.2.1" }
 wasmer-types = { path = "../types", version = "=2.2.1", default-features = false, features = ["std"] }
-cranelift-entity = { version = "0.76", default-features = false }
-cranelift-codegen = { version = "0.76", default-features = false, features = ["x86", "arm64"] }
-cranelift-frontend = { version = "0.76", default-features = false }
+cranelift-entity = { version = "0.82", default-features = false }
+cranelift-codegen = { version = "0.82", default-features = false, features = ["x86", "arm64"] }
+cranelift-frontend = { version = "0.82", default-features = false }
 tracing = "0.1"
 hashbrown = { version = "0.11", optional = true }
 rayon = "1.5"
 more-asserts = "0.2"
-gimli = { version = "0.25", optional = true }
+gimli = { version = "0.26", optional = true }
 smallvec = "1.6"
 loupe = "0.1"
 target-lexicon = { version = "0.12.2", default-features = false }
 
 [dev-dependencies]
-cranelift-codegen = { version = "0.76", features = ["all-arch"] }
+cranelift-codegen = { version = "0.82", features = ["all-arch"] }
 lazy_static = "1.4"
 
 [badges]

lib/compiler-cranelift/Cargo.toml

@@ -1,44 +1,26 @@
 // This file contains code from external sources.
 // Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md
 
+use cranelift_codegen::Context;
 use cranelift_codegen::MachSrcLoc;
-use cranelift_codegen::{isa, Context};
 use wasmer_compiler::{wasmparser::Range, FunctionAddressMap, InstructionAddressMap, SourceLoc};
 
 pub fn get_function_address_map<'data>(
     context: &Context,
     range: Range,
     body_len: usize,
-    isa: &dyn isa::TargetIsa,
 ) -> FunctionAddressMap {
     let mut instructions = Vec::new();
 
-    if let Some(ref mcr) = &context.mach_compile_result {
-        // New-style backend: we have a `MachCompileResult` that will give us `MachSrcLoc` mapping
-        // tuples.
-        for &MachSrcLoc { start, end, loc } in mcr.buffer.get_srclocs_sorted() {
-            instructions.push(InstructionAddressMap {
-                srcloc: SourceLoc::new(loc.bits()),
-                code_offset: start as usize,
-                code_len: (end - start) as usize,
-            });
-        }
-    } else {
-        let func = &context.func;
-        let mut blocks = func.layout.blocks().collect::<Vec<_>>();
-        blocks.sort_by_key(|block| func.offsets[*block]); // Ensure inst offsets always increase
-
-        let encinfo = isa.encoding_info();
-        for block in blocks {
-            for (offset, inst, size) in func.inst_offsets(block, &encinfo) {
-                let srcloc = func.srclocs[inst];
-                instructions.push(InstructionAddressMap {
-                    srcloc: SourceLoc::new(srcloc.bits()),
-                    code_offset: offset as usize,
-                    code_len: size as usize,
-                });
-            }
-        }
+    // New-style backend: we have a `MachCompileResult` that will give us `MachSrcLoc` mapping
+    // tuples.
+    let mcr = context.mach_compile_result.as_ref().unwrap();
+    for &MachSrcLoc { start, end, loc } in mcr.buffer.get_srclocs_sorted() {
+        instructions.push(InstructionAddressMap {
+            srcloc: SourceLoc::new(loc.bits()),
+            code_offset: start as usize,
+            code_len: (end - start) as usize,
+        });
     }
 
     // Generate artificial srcloc for function start/end to identify boundary

lib/compiler-cranelift/src/address_map.rs

@@ -5,32 +5,35 @@ use crate::config::Cranelift;
 #[cfg(feature = "unwind")]
 use crate::dwarf::WriterRelocate;
 use crate::func_environ::{get_function_name, FuncEnvironment};
-use crate::sink::{RelocSink, TrapSink};
 use crate::trampoline::{
     make_trampoline_dynamic_function, make_trampoline_function_call, FunctionBuilderContext,
 };
 use crate::translator::{
-    compiled_function_unwind_info, signature_to_cranelift_ir, transform_jump_table,
-    CraneliftUnwindInfo, FuncTranslator,
+    compiled_function_unwind_info, irlibcall_to_libcall, irreloc_to_relocationkind,
+    signature_to_cranelift_ir, CraneliftUnwindInfo, FuncTranslator,
 };
-use cranelift_codegen::ir;
+use cranelift_codegen::ir::ExternalName;
 use cranelift_codegen::print_errors::pretty_error;
-use cranelift_codegen::{binemit, Context};
+use cranelift_codegen::{ir, MachReloc};
+use cranelift_codegen::{Context, MachTrap};
 #[cfg(feature = "unwind")]
 use gimli::write::{Address, EhFrame, FrameTable};
 use loupe::MemoryUsage;
 use rayon::prelude::{IntoParallelRefIterator, ParallelIterator};
 use std::sync::Arc;
-use wasmer_compiler::CompileError;
-use wasmer_compiler::{CallingConvention, ModuleTranslationState, Target};
+use wasmer_compiler::{
+    CallingConvention, ModuleTranslationState, RelocationTarget, Target, TrapInformation,
+};
 use wasmer_compiler::{
     Compilation, CompileModuleInfo, CompiledFunction, CompiledFunctionFrameInfo,
     CompiledFunctionUnwindInfo, Compiler, Dwarf, FunctionBinaryReader, FunctionBody,
     FunctionBodyData, MiddlewareBinaryReader, ModuleMiddleware, ModuleMiddlewareChain,
     SectionIndex,
 };
+use wasmer_compiler::{CompileError, Relocation};
 use wasmer_types::entity::{EntityRef, PrimaryMap};
-use wasmer_types::{FunctionIndex, LocalFunctionIndex, SignatureIndex};
+use wasmer_types::{FunctionIndex, LocalFunctionIndex, ModuleInfo, SignatureIndex};
+use wasmer_vm::TrapCode;
 
 /// A compiler that compiles a WebAssembly module with Cranelift, translating the Wasm to Cranelift IR,
 /// optimizing it and then translating to assembly.
@@ -66,7 +69,10 @@ impl Compiler for CraneliftCompiler {
         module_translation_state: &ModuleTranslationState,
         function_body_inputs: PrimaryMap<LocalFunctionIndex, FunctionBodyData<'_>>,
     ) -> Result<Compilation, CompileError> {
-        let isa = self.config().isa(target);
+        let isa = self
+            .config()
+            .isa(target)
+            .map_err(|error| CompileError::Codegen(error.to_string()))?;
         let frontend_config = isa.frontend_config();
         let memory_styles = &compile_info.memory_styles;
         let table_styles = &compile_info.table_styles;
@@ -139,20 +145,24 @@ impl Compiler for CraneliftCompiler {
                 )?;
 
                 let mut code_buf: Vec<u8> = Vec::new();
-                let mut reloc_sink = RelocSink::new(&module, func_index);
-                let mut trap_sink = TrapSink::new();
-                let mut stackmap_sink = binemit::NullStackMapSink {};
                 context
-                    .compile_and_emit(
-                        &*isa,
-                        &mut code_buf,
-                        &mut reloc_sink,
-                        &mut trap_sink,
-                        &mut stackmap_sink,
-                    )
-                    .map_err(|error| {
-                        CompileError::Codegen(pretty_error(&context.func, Some(&*isa), error))
-                    })?;
+                    .compile_and_emit(&*isa, &mut code_buf)
+                    .map_err(|error| CompileError::Codegen(pretty_error(&context.func, error)))?;
+
+                let result = context.mach_compile_result.as_ref().unwrap();
+                let func_relocs = result
+                    .buffer
+                    .relocs()
+                    .into_iter()
+                    .map(|r| mach_reloc_to_reloc(module, r))
+                    .collect::<Vec<_>>();
+
+                let traps = result
+                    .buffer
+                    .traps()
+                    .into_iter()
+                    .map(mach_trap_to_trap)
+                    .collect::<Vec<_>>();
 
                 let (unwind_info, fde) = match compiled_function_unwind_info(&*isa, &context)? {
                     #[cfg(feature = "unwind")]
@@ -182,23 +192,16 @@ impl Compiler for CraneliftCompiler {
                 };
 
                 let range = reader.range();
-                let address_map = get_function_address_map(&context, range, code_buf.len(), &*isa);
-
-                // We transform the Cranelift JumpTable's into compiler JumpTables
-                let func_jt_offsets = transform_jump_table(context.func.jt_offsets);
+                let address_map = get_function_address_map(&context, range, code_buf.len());
 
                 Ok((
                     CompiledFunction {
                         body: FunctionBody {
                             body: code_buf,
                             unwind_info,
                         },
-                        jt_offsets: func_jt_offsets,
-                        relocations: reloc_sink.func_relocs,
-                        frame_info: CompiledFunctionFrameInfo {
-                            address_map,
-                            traps: trap_sink.traps,
-                        },
+                        relocations: func_relocs,
+                        frame_info: CompiledFunctionFrameInfo { address_map, traps },
                     },
                     fde,
                 ))
@@ -262,3 +265,63 @@ impl Compiler for CraneliftCompiler {
         ))
     }
 }
+
+fn mach_reloc_to_reloc(module: &ModuleInfo, reloc: &MachReloc) -> Relocation {
+    let &MachReloc {
+        offset,
+        srcloc: _,
+        kind,
+        ref name,
+        addend,
+    } = reloc;
+    let reloc_target = if let ExternalName::User { namespace, index } = *name {
+        debug_assert_eq!(namespace, 0);
+        RelocationTarget::LocalFunc(
+            module
+                .local_func_index(FunctionIndex::from_u32(index))
+                .expect("The provided function should be local"),
+        )
+    } else if let ExternalName::LibCall(libcall) = *name {
+        RelocationTarget::LibCall(irlibcall_to_libcall(libcall))
+    } else {
+        panic!("unrecognized external name")
+    };
+    Relocation {
+        kind: irreloc_to_relocationkind(kind),
+        reloc_target,
+        offset,
+        addend,
+    }
+}
+
+fn mach_trap_to_trap(trap: &MachTrap) -> TrapInformation {
+    let &MachTrap {
+        offset,
+        srcloc: _,
+        code,
+    } = trap;
+    TrapInformation {
+        code_offset: offset,
+        trap_code: translate_ir_trapcode(code),
+    }
+}
+
+/// Translates the Cranelift IR TrapCode into generic Trap Code
+fn translate_ir_trapcode(trap: ir::TrapCode) -> TrapCode {
+    match trap {
+        ir::TrapCode::StackOverflow => TrapCode::StackOverflow,
+        ir::TrapCode::HeapOutOfBounds => TrapCode::HeapAccessOutOfBounds,
+        ir::TrapCode::HeapMisaligned => TrapCode::HeapMisaligned,
+        ir::TrapCode::TableOutOfBounds => TrapCode::TableAccessOutOfBounds,
+        ir::TrapCode::IndirectCallToNull => TrapCode::IndirectCallToNull,
+        ir::TrapCode::BadSignature => TrapCode::BadSignature,
+        ir::TrapCode::IntegerOverflow => TrapCode::IntegerOverflow,
+        ir::TrapCode::IntegerDivisionByZero => TrapCode::IntegerDivisionByZero,
+        ir::TrapCode::BadConversionToInteger => TrapCode::BadConversionToInteger,
+        ir::TrapCode::UnreachableCodeReached => TrapCode::UnreachableCodeReached,
+        ir::TrapCode::Interrupt => unimplemented!("Interrupts not supported"),
+        ir::TrapCode::User(_user_code) => unimplemented!("User trap code not supported"),
+        // ir::TrapCode::Interrupt => TrapCode::Interrupt,
+        // ir::TrapCode::User(user_code) => TrapCode::User(user_code),
+    }
+}