Merge remote-tracking branch 'origin/main' into set-perf

Author: rtfeldman

BUILDING_FROM_SOURCE.md

@@ -76,7 +76,7 @@ To run the test suite (via `cargo test`), you additionally need to install:
 - [`valgrind`](https://www.valgrind.org/) (needs special treatment to [install on macOS](https://stackoverflow.com/a/61359781)
 Alternatively, you can use `cargo test --no-fail-fast` or `cargo test -p specific_tests` to skip over the valgrind failures & tests.
 
-For debugging LLVM IR, we use [DebugIR](https://github.com/vaivaswatha/debugir). This dependency is only required to build with the `--debug` flag, and for normal development you should be fine without it.
+For emitting LLVM IR for debugging purposes, the `--emit-llvm-ir` flag can be used.
 
 ### libxcb libraries
 

crates/cli/src/lib.rs

@@ -50,7 +50,8 @@ pub const CMD_GLUE: &str = "glue";
 pub const CMD_GEN_STUB_LIB: &str = "gen-stub-lib";
 pub const CMD_PREPROCESS_HOST: &str = "preprocess-host";
 
-pub const FLAG_DEBUG: &str = "debug";
+pub const FLAG_EMIT_LLVM_IR: &str = "emit-llvm-ir";
+pub const FLAG_PROFILING: &str = "profiling";
 pub const FLAG_BUNDLE: &str = "bundle";
 pub const FLAG_DEV: &str = "dev";
 pub const FLAG_OPTIMIZE: &str = "optimize";
@@ -102,9 +103,15 @@ pub fn build_app() -> Command {
         .action(ArgAction::SetTrue)
         .required(false);
 
-    let flag_debug = Arg::new(FLAG_DEBUG)
-        .long(FLAG_DEBUG)
-        .help("Store LLVM debug information in the generated program")
+    let flag_emit_llvm_ir = Arg::new(FLAG_EMIT_LLVM_IR)
+        .long(FLAG_EMIT_LLVM_IR)
+        .help("Emit a `.ll` file containing the LLVM IR of the program")
+        .action(ArgAction::SetTrue)
+        .required(false);
+
+    let flag_profiling = Arg::new(FLAG_PROFILING)
+        .long(FLAG_PROFILING)
+        .help("Keep debug info in the final generated program even in optmized builds")
         .action(ArgAction::SetTrue)
         .required(false);
 
@@ -163,7 +170,8 @@ pub fn build_app() -> Command {
             .arg(flag_max_threads.clone())
             .arg(flag_opt_size.clone())
             .arg(flag_dev.clone())
-            .arg(flag_debug.clone())
+            .arg(flag_emit_llvm_ir.clone())
+            .arg(flag_profiling.clone())
             .arg(flag_time.clone())
             .arg(flag_linker.clone())
             .arg(flag_prebuilt.clone())
@@ -212,7 +220,8 @@ pub fn build_app() -> Command {
             .arg(flag_max_threads.clone())
             .arg(flag_opt_size.clone())
             .arg(flag_dev.clone())
-            .arg(flag_debug.clone())
+            .arg(flag_emit_llvm_ir.clone())
+            .arg(flag_profiling.clone())
             .arg(flag_time.clone())
             .arg(flag_linker.clone())
             .arg(flag_prebuilt.clone())
@@ -234,7 +243,8 @@ pub fn build_app() -> Command {
             .arg(flag_max_threads.clone())
             .arg(flag_opt_size.clone())
             .arg(flag_dev.clone())
-            .arg(flag_debug.clone())
+            .arg(flag_emit_llvm_ir.clone())
+            .arg(flag_profiling.clone())
             .arg(flag_time.clone())
             .arg(flag_linker.clone())
             .arg(flag_prebuilt.clone())
@@ -247,7 +257,8 @@ pub fn build_app() -> Command {
             .arg(flag_max_threads.clone())
             .arg(flag_opt_size.clone())
             .arg(flag_dev.clone())
-            .arg(flag_debug.clone())
+            .arg(flag_emit_llvm_ir.clone())
+            .arg(flag_profiling.clone())
             .arg(flag_time.clone())
             .arg(flag_linker.clone())
             .arg(flag_prebuilt.clone())
@@ -376,7 +387,8 @@ pub fn build_app() -> Command {
         .arg(flag_max_threads)
         .arg(flag_opt_size)
         .arg(flag_dev)
-        .arg(flag_debug)
+        .arg(flag_emit_llvm_ir)
+        .arg(flag_profiling)
         .arg(flag_time)
         .arg(flag_linker)
         .arg(flag_prebuilt)
@@ -696,7 +708,13 @@ pub fn build(
         CodeGenBackend::Llvm(backend_mode)
     };
 
-    let emit_debug_info = matches.get_flag(FLAG_DEBUG);
+    let emit_llvm_ir = matches.get_flag(FLAG_EMIT_LLVM_IR);
+    if emit_llvm_ir && !matches!(code_gen_backend, CodeGenBackend::Llvm(_)) {
+        user_error!("Cannot emit llvm ir while using a dev backend.");
+    }
+
+    let emit_debug_info = matches.get_flag(FLAG_PROFILING)
+        || matches!(opt_level, OptLevel::Development | OptLevel::Normal);
     let emit_timings = matches.get_flag(FLAG_TIME);
 
     let threading = match matches.get_one::<usize>(FLAG_MAX_THREADS) {
@@ -745,6 +763,7 @@ pub fn build(
         backend: code_gen_backend,
         opt_level,
         emit_debug_info,
+        emit_llvm_ir,
     };
 
     let load_config = standard_load_config(&triple, build_ordering, threading);

crates/compiler/build/src/program.rs

@@ -85,6 +85,7 @@ pub struct CodeGenOptions {
     pub backend: CodeGenBackend,
     pub opt_level: OptLevel,
     pub emit_debug_info: bool,
+    pub emit_llvm_ir: bool,
 }
 
 type GenFromMono<'a> = (CodeObject, CodeGenTiming, ExpectMetadata<'a>);
@@ -101,6 +102,7 @@ pub fn gen_from_mono_module<'a>(
 ) -> GenFromMono<'a> {
     let path = roc_file_path;
     let debug = code_gen_options.emit_debug_info;
+    let emit_llvm_ir = code_gen_options.emit_llvm_ir;
     let opt = code_gen_options.opt_level;
 
     match code_gen_options.backend {
@@ -120,15 +122,23 @@ pub fn gen_from_mono_module<'a>(
             wasm_dev_stack_bytes,
             backend_mode,
         ),
-        CodeGenBackend::Llvm(backend_mode) => {
-            gen_from_mono_module_llvm(arena, loaded, path, target, opt, backend_mode, debug)
-        }
+        CodeGenBackend::Llvm(backend_mode) => gen_from_mono_module_llvm(
+            arena,
+            loaded,
+            path,
+            target,
+            opt,
+            backend_mode,
+            debug,
+            emit_llvm_ir,
+        ),
     }
 }
 
 // TODO how should imported modules factor into this? What if those use builtins too?
 // TODO this should probably use more helper functions
 // TODO make this polymorphic in the llvm functions so it can be reused for another backend.
+#[allow(clippy::too_many_arguments)]
 fn gen_from_mono_module_llvm<'a>(
     arena: &'a bumpalo::Bump,
     loaded: MonomorphizedModule<'a>,
@@ -137,6 +147,7 @@ fn gen_from_mono_module_llvm<'a>(
     opt_level: OptLevel,
     backend_mode: LlvmBackendMode,
     emit_debug_info: bool,
+    emit_llvm_ir: bool,
 ) -> GenFromMono<'a> {
     use crate::target::{self, convert_opt_level};
     use inkwell::attributes::{Attribute, AttributeLoc};
@@ -151,9 +162,6 @@ fn gen_from_mono_module_llvm<'a>(
     let context = Context::create();
     let module = arena.alloc(module_from_builtins(target, &context, "app"));
 
-    // strip Zig debug stuff
-    // module.strip_debug_info();
-
     // mark our zig-defined builtins as internal
     let app_ll_file = {
         let mut temp = PathBuf::from(roc_file_path);
@@ -245,8 +253,9 @@ fn gen_from_mono_module_llvm<'a>(
 
     env.dibuilder.finalize();
 
-    // we don't use the debug info, and it causes weird errors.
-    module.strip_debug_info();
+    if !emit_debug_info {
+        module.strip_debug_info();
+    }
 
     // Uncomment this to see the module's optimized LLVM instruction output:
     // env.module.print_to_stderr();
@@ -265,6 +274,11 @@ fn gen_from_mono_module_llvm<'a>(
         );
     }
 
+    if emit_llvm_ir {
+        eprintln!("Emitting LLVM IR to {}", &app_ll_file.display());
+        module.print_to_file(&app_ll_file).unwrap();
+    }
+
     // Uncomment this to see the module's optimized LLVM instruction output:
     // env.module.print_to_stderr();
 
@@ -359,65 +373,6 @@ fn gen_from_mono_module_llvm<'a>(
 
         assert!(bc_to_object.status.success(), "{bc_to_object:#?}");
 
-        MemoryBuffer::create_from_file(&app_o_file).expect("memory buffer creation works")
-    } else if emit_debug_info {
-        module.strip_debug_info();
-
-        let mut app_ll_dbg_file = PathBuf::from(roc_file_path);
-        app_ll_dbg_file.set_extension("dbg.ll");
-
-        let mut app_o_file = PathBuf::from(roc_file_path);
-        app_o_file.set_extension("o");
-
-        use std::process::Command;
-
-        // 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.to_str().unwrap()])
-            .output()
-        {
-            Ok(_) => {}
-            Err(error) => {
-                use std::io::ErrorKind;
-                match error.kind() {
-                    ErrorKind::NotFound => internal_error!(
-                        r"I could not find the `debugir` tool on the PATH, install it from https://github.com/vaivaswatha/debugir"
-                    ),
-                    _ => internal_error!("{:?}", error),
-                }
-            }
-        }
-
-        use target_lexicon::Architecture;
-        match target.architecture {
-            Architecture::X86_64
-            | Architecture::X86_32(_)
-            | Architecture::Aarch64(_)
-            | Architecture::Wasm32 => {
-                // write the .o file. Note that this builds the .o for the local machine,
-                // and ignores the `target_machine` entirely.
-                //
-                // different systems name this executable differently, so we shotgun for
-                // the most common ones and then give up.
-                let ll_to_object = Command::new("llc")
-                    .args([
-                        "-relocation-model=pic",
-                        "-filetype=obj",
-                        app_ll_dbg_file.to_str().unwrap(),
-                        "-o",
-                        app_o_file.to_str().unwrap(),
-                    ])
-                    .output()
-                    .unwrap();
-
-                assert!(ll_to_object.stderr.is_empty(), "{ll_to_object:#?}");
-            }
-            _ => unreachable!(),
-        }
-
         MemoryBuffer::create_from_file(&app_o_file).expect("memory buffer creation works")
     } else {
         // Emit the .o file
@@ -1326,6 +1281,7 @@ pub fn build_str_test<'a>(
         backend: CodeGenBackend::Llvm(LlvmBackendMode::Binary),
         opt_level: OptLevel::Normal,
         emit_debug_info: false,
+        emit_llvm_ir: false,
     };
 
     let emit_timings = false;

crates/compiler/builtins/bitcode/build.zig

@@ -7,7 +7,7 @@ const CrossTarget = std.zig.CrossTarget;
 const Arch = std.Target.Cpu.Arch;
 
 pub fn build(b: *Build) void {
-    // const mode = b.standardOptimizeOption(.{ .preferred_optimize_mode = .ReleaseFast });
+    // const mode = b.standardOptimizeOption(.{ .preferred_optimize_mode = .Debug });
     const mode = b.standardOptimizeOption(.{ .preferred_optimize_mode = .ReleaseFast });
 
     // Options
@@ -58,6 +58,7 @@ fn generateLlvmIrFile(
 ) void {
     const obj = b.addObject(.{ .name = object_name, .root_source_file = main_path, .optimize = mode, .target = target, .use_llvm = true });
     obj.strip = true;
+    obj.disable_stack_probing = true;
 
     // Generating the bin seems required to get zig to generate the llvm ir.
     _ = obj.getEmittedBin();
@@ -89,6 +90,7 @@ fn generateObjectFile(
     obj.strip = true;
     obj.link_function_sections = true;
     obj.force_pic = true;
+    obj.disable_stack_probing = true;
 
     const obj_file = obj.getEmittedBin();