Fix support for floating point numbers

lib/clif-backend/src/resolver.rs

@@ -9,6 +9,7 @@ use wasmer_runtime::{
     types::{FuncIndex, Map, MapIndex},
     vm, vmcalls,
 };
+use byteorder::{LittleEndian, ByteOrder};
 
 #[allow(dead_code)]
 pub struct FuncResolverBuilder {
@@ -38,7 +39,6 @@ impl FuncResolverBuilder {
 
             ctx.compile_and_emit(isa, &mut code_buf, &mut reloc_sink, &mut trap_sink)
                 .map_err(|e| format!("compile error: {}", e.to_string()))?;
-            println!("{:?}", ctx.func);
             ctx.clear();
             // Round up each function's size to pointer alignment.
             total_size += round_up(code_buf.len(), mem::size_of::<usize>());
@@ -82,7 +82,6 @@ impl FuncResolverBuilder {
     }
 
     pub fn finalize(mut self) -> Result<FuncResolver, String> {
-        print_disassembly(&*crate::get_isa(), unsafe { &self.resolver.memory.as_slice()[0..0x22] });
         for (index, relocs) in self.relocations.iter() {
             for ref reloc in relocs {
                 let target_func_address: isize = match reloc.target {
@@ -90,12 +89,10 @@ impl FuncResolverBuilder {
                         // This will always be an internal function
                         // because imported functions are not
                         // called in this way.
-                        let ptr = self.resolver
+                        self.resolver
                             .lookup(FuncIndex::new(func_index as _))
                             .unwrap()
-                            .as_ptr();
-                        println!("in {:?} {}: {:p}", index, func_index, ptr);
-                        ptr as isize
+                            .as_ptr() as isize
                     }
                     RelocationType::CurrentMemory => vmcalls::memory_size as isize,
                     RelocationType::GrowMemory => vmcalls::memory_grow_static as isize,
@@ -121,19 +118,21 @@ impl FuncResolverBuilder {
                 // We need the address of the current function
                 // because these calls are relative.
                 let func_addr = self.resolver.lookup(index).unwrap().as_ptr();
-                println!("current func addr ({:?}) {:p}", index, func_addr);
 
                 // Determine relocation type and apply relocation.
-                println!("{:?}", reloc);
                 match reloc.reloc {
-                    Reloc::Abs8 => unsafe {
-                        let reloc_address = func_addr.add(reloc.offset as usize) as usize;
-                        let reloc_addend = reloc.addend as isize;
-                        let reloc_abs = (target_func_address as u64)
-                            .checked_add(reloc_addend as u64)
+                    Reloc::Abs8 => {
+                        let ptr_to_write = (target_func_address as u64)
+                            .checked_add(reloc.addend as u64)
                             .unwrap();
-                        println!("reloc_abs: {:#x}", reloc_address);
-                        write_unaligned(reloc_address as *mut u64, reloc_abs);
+                        let empty_space_offset = self.resolver.map[index] + reloc.offset as usize;
+                        let ptr_slice = unsafe {
+                            &mut self.resolver.memory.as_slice_mut()[empty_space_offset..empty_space_offset+8]
+                        };
+                        LittleEndian::write_u64(
+                            ptr_slice,
+                            ptr_to_write,
+                        );
                     },
                     Reloc::X86PCRel4 => unsafe {
                         let reloc_address = func_addr.offset(reloc.offset as isize) as isize;
@@ -148,8 +147,6 @@ impl FuncResolverBuilder {
             }
         }
 
-        print_disassembly(&*crate::get_isa(), unsafe { &self.resolver.memory.as_slice()[0..0x22] });
-
         unsafe {
             self.resolver
                 .memory
@@ -188,69 +185,4 @@ impl backend::FuncResolver for FuncResolver {
 #[inline]
 fn round_up(n: usize, multiple: usize) -> usize {
     (n + multiple - 1) & !(multiple - 1)
-}
-
-use capstone::prelude::*;
-use target_lexicon::Architecture;
-use std::fmt::Write;
-
-fn get_disassembler(isa: &isa::TargetIsa) -> Result<Capstone, String> {
-    let cs = match isa.triple().architecture {
-        Architecture::Riscv32 | Architecture::Riscv64 => {
-            return Err(String::from("No disassembler for RiscV"))
-        }
-        Architecture::I386 | Architecture::I586 | Architecture::I686 => Capstone::new()
-            .x86()
-            .mode(arch::x86::ArchMode::Mode32)
-            .build(),
-        Architecture::X86_64 => Capstone::new()
-            .x86()
-            .mode(arch::x86::ArchMode::Mode64)
-            .build(),
-        Architecture::Arm
-        | Architecture::Armv4t
-        | Architecture::Armv5te
-        | Architecture::Armv7
-        | Architecture::Armv7s => Capstone::new().arm().mode(arch::arm::ArchMode::Arm).build(),
-        Architecture::Thumbv6m | Architecture::Thumbv7em | Architecture::Thumbv7m => Capstone::new(
-        ).arm()
-            .mode(arch::arm::ArchMode::Thumb)
-            .build(),
-        Architecture::Aarch64 => Capstone::new()
-            .arm64()
-            .mode(arch::arm64::ArchMode::Arm)
-            .build(),
-        _ => return Err(String::from("Unknown ISA")),
-    };
-
-    cs.map_err(|err| err.to_string())
-}
-
-fn print_disassembly(isa: &isa::TargetIsa, mem: &[u8]) -> Result<(), String> {
-    let mut cs = get_disassembler(isa)?;
-
-    println!("\nDisassembly of {} bytes:", mem.len());
-    let insns = cs.disasm_all(&mem, 0x0).unwrap();
-    for i in insns.iter() {
-        let mut line = String::new();
-
-        write!(&mut line, "{:4x}:\t", i.address()).unwrap();
-
-        let mut bytes_str = String::new();
-        for b in i.bytes() {
-            write!(&mut bytes_str, "{:02x} ", b).unwrap();
-        }
-        write!(&mut line, "{:21}\t", bytes_str).unwrap();
-
-        if let Some(s) = i.mnemonic() {
-            write!(&mut line, "{}\t", s).unwrap();
-        }
-
-        if let Some(s) = i.op_str() {
-            write!(&mut line, "{}", s).unwrap();
-        }
-
-        println!("{}", line);
-    }
-    Ok(())
 }