Feat/singlepass dylib

lib/compiler-singlepass/src/codegen.rs

@@ -2599,17 +2599,18 @@ impl<'a, M: Machine> FuncGen<'a, M> {
                         function_index - self.module.num_imported_functions,
                     ))
                 };
-                self.machine
-                    .move_with_reloc(reloc_target, &mut self.relocations);
+                let calling_convention = self.calling_convention;
 
                 self.emit_call_native(
                     |this| {
                         let offset = this
                             .machine
                             .mark_instruction_with_trap_code(TrapCode::StackOverflow);
-                        this.machine
-                            .emit_call_register(this.machine.get_grp_for_call());
+                        let mut relocations = this
+                            .machine
+                            .emit_call_with_reloc(calling_convention, reloc_target);
                         this.machine.mark_instruction_address_end(offset);
+                        this.relocations.append(&mut relocations);
                     },
                     params.iter().copied(),
                     param_types.iter().copied(),

lib/compiler-singlepass/src/emitter_arm64.rs

@@ -1899,6 +1899,7 @@ impl EmitterARM64 for Assembler {
         let reg = reg.into_index() as u32;
         dynasm!(self ; adr X(reg), =>label);
     }
+
     fn emit_b_label(&mut self, label: Label) {
         dynasm!(self ; b =>label);
     }

lib/compiler-singlepass/src/machine.rs

@@ -1038,11 +1038,11 @@ pub trait Machine {
     );
 
     /// emit a move function address to GPR ready for call, using appropriate relocation
-    fn move_with_reloc(
+    fn emit_call_with_reloc(
         &mut self,
+        calling_convention: CallingConvention,
         reloc_target: RelocationTarget,
-        relocations: &mut Vec<Relocation>,
-    );
+    ) -> Vec<Relocation>;
     /// Add with location directly from the stack
     fn emit_binop_add64(
         &mut self,

lib/compiler-singlepass/src/machine_arm64.rs

@@ -3229,43 +3229,23 @@ impl Machine for MachineARM64 {
         unimplemented!();
     }
 
-    fn move_with_reloc(
+    fn emit_call_with_reloc(
         &mut self,
+        _calling_convention: CallingConvention,
         reloc_target: RelocationTarget,
-        relocations: &mut Vec<Relocation>,
-    ) {
-        let reloc_at = self.assembler.get_offset().0;
-        relocations.push(Relocation {
-            kind: RelocationKind::Arm64Movw0,
-            reloc_target,
-            offset: reloc_at as u32,
-            addend: 0,
-        });
-        self.assembler.emit_movz(Location::GPR(GPR::X27), 0);
-        let reloc_at = self.assembler.get_offset().0;
-        relocations.push(Relocation {
-            kind: RelocationKind::Arm64Movw1,
-            reloc_target,
-            offset: reloc_at as u32,
-            addend: 0,
-        });
-        self.assembler.emit_movk(Location::GPR(GPR::X27), 0, 16);
-        let reloc_at = self.assembler.get_offset().0;
-        relocations.push(Relocation {
-            kind: RelocationKind::Arm64Movw2,
-            reloc_target,
-            offset: reloc_at as u32,
-            addend: 0,
-        });
-        self.assembler.emit_movk(Location::GPR(GPR::X27), 0, 32);
+    ) -> Vec<Relocation> {
+        let mut relocations = vec![];
+        let next = self.get_label();
         let reloc_at = self.assembler.get_offset().0;
+        self.emit_label(next); // this is to be sure the current imm26 value is 0
+        self.assembler.emit_call_label(next);
         relocations.push(Relocation {
-            kind: RelocationKind::Arm64Movw3,
+            kind: RelocationKind::Arm64Call,
             reloc_target,
             offset: reloc_at as u32,
             addend: 0,
         });
-        self.assembler.emit_movk(Location::GPR(GPR::X27), 0, 48);
+        relocations
     }
 
     fn emit_binop_add64(&mut self, loc_a: Location, loc_b: Location, ret: Location) {

lib/compiler-singlepass/src/machine_x64.rs

@@ -3869,27 +3869,23 @@ impl Machine for MachineX86_64 {
         self.release_gpr(compare);
     }
 
-    fn move_with_reloc(
+    fn emit_call_with_reloc(
         &mut self,
+        _calling_convention: CallingConvention,
         reloc_target: RelocationTarget,
-        relocations: &mut Vec<Relocation>,
-    ) {
-        let reloc_at = self.assembler.get_offset().0 + self.assembler.arch_mov64_imm_offset();
-
+    ) -> Vec<Relocation> {
+        let mut relocations = vec![];
+        let next = self.get_label();
+        let reloc_at = self.assembler.get_offset().0 + 1; // skip E8
+        self.assembler.emit_call_label(next);
+        self.emit_label(next);
         relocations.push(Relocation {
-            kind: RelocationKind::Abs8,
+            kind: RelocationKind::X86CallPCRel4,
             reloc_target,
             offset: reloc_at as u32,
-            addend: 0,
+            addend: -4,
         });
-
-        // RAX is preserved on entry to `emit_call_native` callback.
-        // The Imm64 value is relocated by the JIT linker.
-        self.assembler.emit_mov(
-            Size::S64,
-            Location::Imm64(std::u64::MAX),
-            Location::GPR(GPR::RAX),
-        );
+        relocations
     }
 
     fn emit_binop_add64(&mut self, loc_a: Location, loc_b: Location, ret: Location) {

lib/engine-dylib/src/artifact.rs

@@ -400,11 +400,6 @@ impl DylibArtifact {
             Triple::host().to_string(),
         );
 
-        let notext = match (target_triple.operating_system, target_triple.architecture) {
-            (OperatingSystem::Linux, Architecture::X86_64) => vec!["-Wl,-z,notext"],
-            _ => vec![],
-        };
-
         let linker = engine_inner.linker().executable();
         let output = Command::new(linker)
             .arg(&filepath)
@@ -414,7 +409,6 @@ impl DylibArtifact {
             .args(&target_args)
             // .args(&wasmer_symbols)
             .arg("-shared")
-            .args(&notext)
             .args(&cross_compiling_args)
             .arg("-v")
             .output()

lib/engine-universal/src/link.rs

@@ -80,7 +80,7 @@ fn apply_relocation(
                 )
             }
             let reloc_delta = (((reloc_delta / 4) as u32) & 0x3ff_ffff)
-                | read_unaligned(reloc_address as *mut u32);
+                | (read_unaligned(reloc_address as *mut u32) & 0xfc00_0000);
             write_unaligned(reloc_address as *mut u32, reloc_delta);
         },
         RelocationKind::Arm64Movw0 => unsafe {

lib/object/src/module.rs

@@ -275,6 +275,8 @@ pub fn emit_compilation(
         let (_symbol_id, section_offset) = obj.symbol_section_and_offset(symbol_id).unwrap();
 
         for r in relocations {
+            let relocation_address = section_offset + r.offset as u64;
+
             let (relocation_kind, relocation_encoding, relocation_size) = match r.kind {
                 Reloc::Abs4 => (RelocationKind::Absolute, RelocationEncoding::Generic, 32),
                 Reloc::Abs8 => (RelocationKind::Absolute, RelocationEncoding::Generic, 64),
@@ -309,6 +311,62 @@ pub fn emit_compilation(
                     RelocationEncoding::Generic,
                     32,
                 ),
+                Reloc::Arm64Movw0 => (
+                    match obj.format() {
+                        object::BinaryFormat::Elf => {
+                            RelocationKind::Elf(elf::R_AARCH64_MOVW_UABS_G0)
+                        }
+                        fmt => panic!(
+                            "unsupported binary format {:?} for relocation {:?}",
+                            fmt,
+                            obj.format()
+                        ),
+                    },
+                    RelocationEncoding::Generic,
+                    16,
+                ),
+                Reloc::Arm64Movw1 => (
+                    match obj.format() {
+                        object::BinaryFormat::Elf => {
+                            RelocationKind::Elf(elf::R_AARCH64_MOVW_UABS_G1)
+                        }
+                        fmt => panic!(
+                            "unsupported binary format {:?} for relocation {:?}",
+                            fmt,
+                            obj.format()
+                        ),
+                    },
+                    RelocationEncoding::Generic,
+                    16,
+                ),
+                Reloc::Arm64Movw2 => (
+                    match obj.format() {
+                        object::BinaryFormat::Elf => {
+                            RelocationKind::Elf(elf::R_AARCH64_MOVW_UABS_G2)
+                        }
+                        fmt => panic!(
+                            "unsupported binary format {:?} for relocation {:?}",
+                            fmt,
+                            obj.format()
+                        ),
+                    },
+                    RelocationEncoding::Generic,
+                    16,
+                ),
+                Reloc::Arm64Movw3 => (
+                    match obj.format() {
+                        object::BinaryFormat::Elf => {
+                            RelocationKind::Elf(elf::R_AARCH64_MOVW_UABS_G3)
+                        }
+                        fmt => panic!(
+                            "unsupported binary format {:?} for relocation {:?}",
+                            fmt,
+                            obj.format()
+                        ),
+                    },
+                    RelocationEncoding::Generic,
+                    16,
+                ),
                 other => {
                     return Err(ObjectError::UnsupportedArchitecture(format!(
                         "{} (relocation: {}",
@@ -317,8 +375,6 @@ pub fn emit_compilation(
                 }
             };
 
-            let relocation_address = section_offset + r.offset as u64;
-
             match r.reloc_target {
                 RelocationTarget::LocalFunc(index) => {
                     let (_, target_symbol) = function_symbol_ids.get(index).unwrap();

tests/ignores.txt

@@ -2,7 +2,6 @@
 singlepass spec::multi_value # Singlepass has not implemented multivalue (functions that returns "structs"/"tuples")
 singlepass spec::simd # Singlepass doesn't support yet SIMD (no one asked for this feature)
 
-singlepass+dylib * # It needs to add support for PIC in Singlepass. Not implemented at the moment
 windows+dylib * # This might be trivial to fix?
 musl+dylib * # Dynamic loading not supported in Musl