feat(llvm): Add the debug_str intrinsic function

..and add misc naming improvements.

Author: xdoardo

lib/compiler-llvm/src/object_file.rs

@@ -84,6 +84,7 @@ static LIBCALLS_ELF: phf::Map<&'static str, LibCall> = phf::phf_map! {
     "wasmer_vm_read_exception" => LibCall::ReadException,
     "wasmer_vm_dbg_usize" => LibCall::DebugUsize,
     "wasmer_eh_personality" => LibCall::EHPersonality,
+    "wasmer_vm_dbg_str" => LibCall::DebugStr,
 };
 
 static LIBCALLS_MACHO: phf::Map<&'static str, LibCall> = phf::phf_map! {
@@ -142,6 +143,7 @@ static LIBCALLS_MACHO: phf::Map<&'static str, LibCall> = phf::phf_map! {
     //
     // todo: find out if it is a bug in LLVM or it is expected.
     "___gxx_personality_v0" => LibCall::EHPersonality,
+    "_wasmer_vm_dbg_str" => LibCall::DebugStr,
 };
 
 pub fn load_object_file<F>(

lib/compiler-llvm/src/translator/code.rs

@@ -213,34 +213,51 @@ impl FuncTranslator {
                 1
             };
         let mut is_first_alloca = true;
-        let mut insert_alloca = |ty, name| -> Result<PointerValue, CompileError> {
-            let alloca = err!(alloca_builder.build_alloca(ty, name));
+        let mut insert_alloca = |ty, name: String| -> Result<PointerValue, CompileError> {
+            let alloca = err!(alloca_builder.build_alloca(ty, &name));
             if is_first_alloca {
                 alloca_builder.position_at(entry, &alloca.as_instruction_value().unwrap());
                 is_first_alloca = false;
             }
             Ok(alloca)
         };
 
+        // Uncomment to print, at the start of the function, the function name.
+        // (poor man's debugger!)
+        //let func_name_str =
+        //    err!(alloca_builder.build_global_string_ptr(&function_name, "function_name"));
+        //
+        //_ = alloca_builder.build_call(
+        //    intrinsics.debug_str,
+        //    &[
+        //        func_name_str.as_pointer_value().into(),
+        //        intrinsics
+        //            .i32_ty
+        //            .const_int(function_name.len() as _, false)
+        //            .into(),
+        //    ],
+        //    "",
+        //);
+
         for idx in 0..wasm_fn_type.params().len() {
             let ty = wasm_fn_type.params()[idx];
             let ty = type_to_llvm(&intrinsics, ty)?;
             let value = func
                 .get_nth_param((idx as u32).checked_add(first_param).unwrap())
                 .unwrap();
-            let alloca = insert_alloca(ty, "param")?;
+            let alloca = insert_alloca(ty, format!("param_{idx}"))?;
             err!(cache_builder.build_store(alloca, value));
             params.push((ty, alloca));
         }
 
         let mut locals = vec![];
         let num_locals = reader.read_local_count()?;
-        for _ in 0..num_locals {
+        for idx in 0..num_locals {
             let (count, ty) = reader.read_local_decl()?;
             let ty = err!(wptype_to_type(ty));
             let ty = type_to_llvm(&intrinsics, ty)?;
             for _ in 0..count {
-                let alloca = insert_alloca(ty, "local")?;
+                let alloca = insert_alloca(ty, format!("local_{idx}"))?;
                 err!(cache_builder.build_store(alloca, ty.const_zero()));
                 locals.push((ty, alloca));
             }
@@ -253,7 +270,7 @@ impl FuncTranslator {
 
         if g0m0_is_enabled {
             let value = self.abi.get_g0_ptr_param(&func);
-            let g0 = insert_alloca(intrinsics.i32_ty.as_basic_type_enum(), "g0")?;
+            let g0 = insert_alloca(intrinsics.i32_ty.as_basic_type_enum(), "g0".to_string())?;
             err!(cache_builder.build_store(g0, value));
             g0.set_name("g0");
             let m0 = self.abi.get_m0_ptr_param(&func);
@@ -1257,13 +1274,16 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     let ptr_in_bounds = match ptr_in_bounds {
                         Some(ptr) => ptr,
                         None => {
-                            let load_offset_end =
-                                err!(builder.build_int_add(offset, value_size_v, ""));
+                            let load_offset_end = err!(builder.build_int_add(
+                                offset,
+                                value_size_v,
+                                "load_offset_end"
+                            ));
 
                             let current_length = err!(builder.build_load(
                                 self.intrinsics.i32_ty,
                                 ptr_to_current_length,
-                                ""
+                                "current_length"
                             ))
                             .into_int_value();
                             tbaa_label(
@@ -1275,14 +1295,14 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                             let current_length = err!(builder.build_int_z_extend(
                                 current_length,
                                 intrinsics.i64_ty,
-                                ""
+                                "current_length_zextd"
                             ));
 
                             err!(builder.build_int_compare(
                                 IntPredicate::ULE,
                                 load_offset_end,
                                 current_length,
-                                "",
+                                "ptr_in_bounds",
                             ))
                         }
                     };
@@ -1327,7 +1347,7 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                         builder.position_at_end(in_bounds_continue_block);
                     }
                     let ptr_to_base =
-                        err!(builder.build_load(intrinsics.ptr_ty, ptr_to_base_ptr, ""))
+                        err!(builder.build_load(intrinsics.ptr_ty, ptr_to_base_ptr, "ptr_to_base"))
                             .into_pointer_value();
                     tbaa_label(
                         self.module,
@@ -1340,10 +1360,11 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                 MemoryCache::Static { base_ptr } => base_ptr,
             }
         };
-        let value_ptr =
-            unsafe { err!(builder.build_gep(self.intrinsics.i8_ty, base_ptr, &[offset], "")) };
+        let value_ptr = unsafe {
+            err!(builder.build_gep(self.intrinsics.i8_ty, base_ptr, &[offset], "mem_value_ptr"))
+        };
         err_nt!(builder
-            .build_bit_cast(value_ptr, ptr_ty, "")
+            .build_bit_cast(value_ptr, ptr_ty, "mem_value")
             .map(|v| v.into_pointer_value()))
     }
 
@@ -1356,9 +1377,10 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
         if align <= 1 {
             return Ok(());
         }
-        let value = err!(self
-            .builder
-            .build_ptr_to_int(ptr, self.intrinsics.i64_ty, ""));
+        let value =
+            err!(self
+                .builder
+                .build_ptr_to_int(ptr, self.intrinsics.i64_ty, "mischeck_value"));
         let and = err!(self.builder.build_and(
             value,
             self.intrinsics.i64_ty.const_int((align - 1).into(), false),
@@ -1368,15 +1390,15 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
             IntPredicate::EQ,
             and,
             self.intrinsics.i64_zero,
-            ""
+            "is_aligned"
         ));
         let aligned = err!(self.builder.build_call(
             self.intrinsics.expect_i1,
             &[
                 aligned.into(),
                 self.intrinsics.i1_ty.const_int(1, false).into(),
             ],
-            "",
+            "is_aligned_expect",
         ))
         .try_as_basic_value()
         .left()
@@ -2583,7 +2605,11 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
             // Operate on self.locals.
             Operator::LocalGet { local_index } => {
                 let (type_value, pointer_value) = self.locals[local_index as usize];
-                let v = err!(self.builder.build_load(type_value, pointer_value, ""));
+                let v = err!(self.builder.build_load(
+                    type_value,
+                    pointer_value,
+                    &format!("local_{local_index}_get")
+                ));
                 tbaa_label(
                     self.module,
                     self.intrinsics,
@@ -10022,10 +10048,11 @@ impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
                     4,
                 )?;
                 self.trap_if_misaligned(memarg, effective_address, 4)?;
-                let result =
-                    err!(self
-                        .builder
-                        .build_load(self.intrinsics.i32_ty, effective_address, ""));
+                let result = err!(self.builder.build_load(
+                    self.intrinsics.i32_ty,
+                    effective_address,
+                    "atomic_load"
+                ));
                 let load = result.as_instruction_value().unwrap();
                 self.annotate_user_memaccess(memory_index, memarg, 4, load)?;
                 load.set_atomic_ordering(AtomicOrdering::SequentiallyConsistent)

lib/compiler-llvm/src/translator/intrinsics.rs

@@ -252,6 +252,7 @@ pub struct Intrinsics<'ctx> {
 
     // Debug
     pub debug_ptr: FunctionValue<'ctx>,
+    pub debug_str: FunctionValue<'ctx>,
 
     // VM builtins.
     pub vmfunction_import_ty: StructType<'ctx>,
@@ -1041,6 +1042,11 @@ impl<'ctx> Intrinsics<'ctx> {
                 void_ty.fn_type(&[ptr_ty.into()], false),
                 None,
             ),
+            debug_str: module.add_function(
+                "wasmer_vm_dbg_str",
+                void_ty.fn_type(&[ptr_ty.into(), i32_ty.into()], false),
+                None,
+            ),
             memory_wait32: module.add_function(
                 "wasmer_vm_memory32_atomic_wait32",
                 i32_ty.fn_type(

lib/types/src/libcalls.rs

@@ -156,6 +156,8 @@ pub enum LibCall {
 
     /// debug_usize
     DebugUsize,
+    /// debug_str
+    DebugStr,
 }
 
 impl LibCall {
@@ -211,6 +213,7 @@ impl LibCall {
             Self::DeleteException => "wasmer_vm_delete_exception",
             Self::ReadException => "wasmer_vm_read_exception",
             Self::DebugUsize => "wasmer_vm_dbg_usize",
+            Self::DebugStr => "wasmer_vm_dbg_str",
         }
     }
 }

lib/types/src/vmoffsets.rs

@@ -172,9 +172,14 @@ impl VMBuiltinFunctionIndex {
         Self(35)
     }
 
+    /// Returns an index for wasm's imported `debug_str` builtin function.
+    pub const fn get_imported_debug_str_index() -> Self {
+        Self(36)
+    }
+
     /// Returns the total number of builtin functions.
     pub const fn builtin_functions_total_number() -> u32 {
-        36
+        37
     }
 
     /// Return the index as an u32 number.

lib/vm/src/libcalls.rs

@@ -693,6 +693,17 @@ pub extern "C-unwind" fn wasmer_vm_dbg_usize(value: usize) {
     }
 }
 
+/// (debug) Print a string.
+#[no_mangle]
+pub extern "C-unwind" fn wasmer_vm_dbg_str(ptr: usize, len: u32) {
+    #[allow(clippy::print_stdout)]
+    unsafe {
+        let str = std::str::from_utf8(std::slice::from_raw_parts(ptr as _, len as _))
+            .unwrap_or("wasmer_vm_dbg_str failed");
+        eprintln!("{str}");
+    }
+}
+
 /// Implementation for allocating an exception.
 #[no_mangle]
 pub extern "C-unwind" fn wasmer_vm_alloc_exception(size: usize) -> u64 {
@@ -936,5 +947,6 @@ pub fn function_pointer(libcall: LibCall) -> usize {
         LibCall::DeleteException => wasmer_vm_delete_exception as usize,
         LibCall::ReadException => wasmer_vm_read_exception as usize,
         LibCall::DebugUsize => wasmer_vm_dbg_usize as usize,
+        LibCall::DebugStr => wasmer_vm_dbg_str as usize,
     }
 }

lib/vm/src/vmcontext.rs

@@ -768,6 +768,8 @@ impl VMBuiltinFunctionsArray {
 
         ptrs[VMBuiltinFunctionIndex::get_imported_debug_usize_index().index() as usize] =
             wasmer_vm_dbg_usize as usize;
+        ptrs[VMBuiltinFunctionIndex::get_imported_debug_str_index().index() as usize] =
+            wasmer_vm_dbg_str as usize;
 
         debug_assert!(ptrs.iter().cloned().all(|p| p != 0));