Merge pull request #3407 from rtfeldman/dylib-roc-benchmarks

Dylib roc benchmarks

crates/compiler/test_gen/src/helpers/llvm.rs

@@ -246,39 +246,84 @@ fn create_llvm_module<'a>(
     (main_fn_name, delayed_errors.join("\n"), env.module)
 }
 
+#[derive(Debug, Clone, Copy)]
+pub struct HelperConfig {
+    pub is_gen_test: bool,
+    pub ignore_problems: bool,
+    pub add_debug_info: bool,
+    pub opt_level: OptLevel,
+}
+
 #[allow(dead_code)]
 #[inline(never)]
 pub fn helper<'a>(
     arena: &'a bumpalo::Bump,
+    config: HelperConfig,
     src: &str,
-    is_gen_test: bool,
-    ignore_problems: bool,
     context: &'a inkwell::context::Context,
 ) -> (&'static str, String, Library) {
     let target = target_lexicon::Triple::host();
 
-    let opt_level = if cfg!(debug_assertions) {
-        OptLevel::Normal
-    } else {
-        OptLevel::Optimize
-    };
-
     let (main_fn_name, delayed_errors, module) = create_llvm_module(
         arena,
         src,
-        is_gen_test,
-        ignore_problems,
+        config.is_gen_test,
+        config.ignore_problems,
         context,
         &target,
-        opt_level,
+        config.opt_level,
     );
 
-    let lib = llvm_module_to_dylib(module, &target, opt_level)
-        .expect("Error loading compiled dylib for test");
+    let res_lib = if config.add_debug_info {
+        let module = annotate_with_debug_info(module, context);
+        llvm_module_to_dylib(&module, &target, config.opt_level)
+    } else {
+        llvm_module_to_dylib(module, &target, config.opt_level)
+    };
+
+    let lib = res_lib.expect("Error loading compiled dylib for test");
 
     (main_fn_name, delayed_errors, lib)
 }
 
+fn annotate_with_debug_info<'ctx>(
+    module: &Module<'ctx>,
+    context: &'ctx inkwell::context::Context,
+) -> Module<'ctx> {
+    use std::process::Command;
+
+    let app_ll_file = "/tmp/roc-debugir.ll";
+    let app_dbg_ll_file = "/tmp/roc-debugir.dbg.ll";
+    let app_bc_file = "/tmp/roc-debugir.bc";
+
+    // write the ll code to a file, so we can modify it
+    module.print_to_file(&app_ll_file).unwrap();
+
+    // run the debugir https://github.com/vaivaswatha/debugir tool
+    match Command::new("debugir")
+        .args(&["-instnamer", app_ll_file])
+        .output()
+    {
+        Ok(_) => {}
+        Err(error) => {
+            use std::io::ErrorKind;
+            match error.kind() {
+                ErrorKind::NotFound => panic!(
+                    r"I could not find the `debugir` tool on the PATH, install it from https://github.com/vaivaswatha/debugir"
+                ),
+                _ => panic!("{:?}", error),
+            }
+        }
+    }
+
+    Command::new("llvm-as")
+        .args(&[app_dbg_ll_file, "-o", app_bc_file])
+        .output()
+        .unwrap();
+
+    inkwell::module::Module::parse_bitcode_from_path(&app_bc_file, context).unwrap()
+}
+
 fn wasm32_target_tripple() -> Triple {
     use target_lexicon::{Architecture, BinaryFormat};
 
@@ -513,13 +558,26 @@ macro_rules! assert_llvm_evals_to {
         use bumpalo::Bump;
         use inkwell::context::Context;
         use roc_gen_llvm::run_jit_function;
+        use roc_mono::ir::OptLevel;
 
         let arena = Bump::new();
         let context = Context::create();
 
-        let is_gen_test = true;
+        let opt_level = if cfg!(debug_assertions) {
+            OptLevel::Normal
+        } else {
+            OptLevel::Optimize
+        };
+
+        let config = $crate::helpers::llvm::HelperConfig {
+            is_gen_test: true,
+            add_debug_info: false,
+            ignore_problems: $ignore_problems,
+            opt_level,
+        };
+
         let (main_fn_name, errors, lib) =
-            $crate::helpers::llvm::helper(&arena, $src, is_gen_test, $ignore_problems, &context);
+            $crate::helpers::llvm::helper(&arena, config, $src, &context);
 
         let transform = |success| {
             let expected = $expected;

crates/compiler/test_gen/src/helpers/mod.rs

@@ -1,5 +1,7 @@
 extern crate bumpalo;
 
+pub mod platform_functions;
+
 #[cfg(feature = "gen-dev")]
 pub mod dev;
 pub mod from_wasmer_memory;

crates/compiler/test_gen/src/helpers/platform_functions.rs

@@ -0,0 +1,54 @@
+use core::ffi::c_void;
+
+/// # Safety
+/// The Roc application needs this.
+#[no_mangle]
+pub unsafe fn roc_alloc(size: usize, _alignment: u32) -> *mut c_void {
+    libc::malloc(size)
+}
+
+/// # Safety
+/// The Roc application needs this.
+#[no_mangle]
+pub unsafe fn roc_memcpy(dest: *mut c_void, src: *const c_void, bytes: usize) -> *mut c_void {
+    libc::memcpy(dest, src, bytes)
+}
+
+/// # Safety
+/// The Roc application needs this.
+#[no_mangle]
+pub unsafe fn roc_realloc(
+    c_ptr: *mut c_void,
+    new_size: usize,
+    _old_size: usize,
+    _alignment: u32,
+) -> *mut c_void {
+    libc::realloc(c_ptr, new_size)
+}
+
+/// # Safety
+/// The Roc application needs this.
+#[no_mangle]
+pub unsafe fn roc_dealloc(c_ptr: *mut c_void, _alignment: u32) {
+    libc::free(c_ptr)
+}
+
+/// # Safety
+/// The Roc application needs this.
+#[no_mangle]
+pub unsafe fn roc_panic(c_ptr: *mut c_void, tag_id: u32) {
+    use roc_gen_llvm::llvm::build::PanicTagId;
+
+    use std::ffi::CStr;
+    use std::os::raw::c_char;
+
+    match PanicTagId::try_from(tag_id) {
+        Ok(PanicTagId::NullTerminatedString) => {
+            let slice = CStr::from_ptr(c_ptr as *const c_char);
+            let string = slice.to_str().unwrap();
+            eprintln!("Roc hit a panic: {}", string);
+            std::process::exit(1);
+        }
+        Err(_) => unreachable!(),
+    }
+}

crates/compiler/test_gen/src/tests.rs

@@ -22,57 +22,4 @@ pub mod wasm_str;
 #[cfg(feature = "gen-wasm")]
 pub mod wasm_linking;
 
-use core::ffi::c_void;
-
-/// # Safety
-/// The Roc application needs this.
-#[no_mangle]
-pub unsafe fn roc_alloc(size: usize, _alignment: u32) -> *mut c_void {
-    libc::malloc(size)
-}
-
-/// # Safety
-/// The Roc application needs this.
-#[no_mangle]
-pub unsafe fn roc_memcpy(dest: *mut c_void, src: *const c_void, bytes: usize) -> *mut c_void {
-    libc::memcpy(dest, src, bytes)
-}
-
-/// # Safety
-/// The Roc application needs this.
-#[no_mangle]
-pub unsafe fn roc_realloc(
-    c_ptr: *mut c_void,
-    new_size: usize,
-    _old_size: usize,
-    _alignment: u32,
-) -> *mut c_void {
-    libc::realloc(c_ptr, new_size)
-}
-
-/// # Safety
-/// The Roc application needs this.
-#[no_mangle]
-pub unsafe fn roc_dealloc(c_ptr: *mut c_void, _alignment: u32) {
-    libc::free(c_ptr)
-}
-
-/// # Safety
-/// The Roc application needs this.
-#[no_mangle]
-pub unsafe fn roc_panic(c_ptr: *mut c_void, tag_id: u32) {
-    use roc_gen_llvm::llvm::build::PanicTagId;
-
-    use std::ffi::CStr;
-    use std::os::raw::c_char;
-
-    match PanicTagId::try_from(tag_id) {
-        Ok(PanicTagId::NullTerminatedString) => {
-            let slice = CStr::from_ptr(c_ptr as *const c_char);
-            let string = slice.to_str().unwrap();
-            eprintln!("Roc hit a panic: {}", string);
-            std::process::exit(1);
-        }
-        Err(_) => unreachable!(),
-    }
-}
+pub use helpers::platform_functions::*;