Fix source locations when trim-paths is being used

djolertrk · djolertrk · commit 57d355fb8ce6 · 2025-12-02T15:06:52.000+01:00
- Add lit test for it:
   $ litcheck lit run --path bin tests/lit/source-location/
 - Add HIR serialization in form of text
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Makefile.toml b/Makefile.toml
@@ -335,6 +335,7 @@ args = [
     "${CARGO_MAKE_WORKSPACE_WORKING_DIRECTORY}/bin",
     "${CARGO_MAKE_WORKSPACE_WORKING_DIRECTORY}/tests/lit/parse",
     "${CARGO_MAKE_WORKSPACE_WORKING_DIRECTORY}/tests/lit/wasm-translation",
+    "${CARGO_MAKE_WORKSPACE_WORKING_DIRECTORY}/tests/lit/source-location",
 ]
 dependencies = ["litcheck"]
 
diff --git a/frontend/wasm/src/config.rs b/frontend/wasm/src/config.rs
@@ -1,4 +1,5 @@
-use alloc::borrow::Cow;
+use alloc::{borrow::Cow, vec::Vec};
+use std::path::PathBuf;
 
 /// Configuration for the WASM translation.
 #[derive(Clone)]
@@ -8,6 +9,9 @@ pub struct WasmTranslationConfig {
     /// binary, and an override name is not specified
     pub source_name: Cow<'static, str>,
 
+    /// Path prefixes to try when resolving relative paths from trimmed DWARF debug information.
+    pub trim_path_prefixes: Vec<PathBuf>,
+
     /// If specified, overrides the module/component name with the one specified
     pub override_name: Option<Cow<'static, str>>,
 
@@ -26,6 +30,7 @@ impl core::fmt::Debug for WasmTranslationConfig {
         let world = if self.world.is_some() { "Some" } else { "None" };
         f.debug_struct("WasmTranslationConfig")
             .field("source_name", &self.source_name)
+            .field("trim_path_prefixes", &self.trim_path_prefixes)
             .field("override_name", &self.override_name)
             .field("world", &world)
             .field("generate_native_debuginfo", &self.generate_native_debuginfo)
@@ -38,6 +43,7 @@ impl Default for WasmTranslationConfig {
     fn default() -> Self {
         Self {
             source_name: Cow::Borrowed("noname"),
+            trim_path_prefixes: Vec::new(),
             override_name: None,
             world: None,
             generate_native_debuginfo: false,
diff --git a/frontend/wasm/src/module/build_ir.rs b/frontend/wasm/src/module/build_ir.rs
@@ -145,6 +145,7 @@ pub fn build_ir_module(
             &addr2line,
             context.session(),
             &mut func_validator,
+            _config,
         )?;
     }
     Ok(())
diff --git a/frontend/wasm/src/module/func_translator.rs b/frontend/wasm/src/module/func_translator.rs
@@ -69,6 +69,7 @@ impl FuncTranslator {
         addr2line: &addr2line::Context<DwarfReader<'_>>,
         session: &Session,
         func_validator: &mut FuncValidator<impl WasmModuleResources>,
+        config: &crate::WasmTranslationConfig,
     ) -> WasmResult<()> {
         let context = func.borrow().as_operation().context_rc();
         let mut op_builder = midenc_hir::OpBuilder::new(context)
@@ -110,6 +111,7 @@ impl FuncTranslator {
             addr2line,
             session,
             func_validator,
+            config,
         )?;
 
         builder.finalize();
@@ -198,6 +200,7 @@ fn parse_function_body<B: ?Sized + Builder>(
     addr2line: &addr2line::Context<DwarfReader<'_>>,
     session: &Session,
     func_validator: &mut FuncValidator<impl WasmModuleResources>,
+    config: &crate::WasmTranslationConfig,
 ) -> WasmResult<()> {
     // The control stack is initialized with a single block representing the whole function.
     debug_assert_eq!(state.control_stack.len(), 1, "State not initialized");
@@ -216,15 +219,59 @@ fn parse_function_body<B: ?Sized + Builder>(
         if let Some(loc) = addr2line.find_location(offset).into_diagnostic()? {
             if let Some(file) = loc.file {
                 let path = std::path::Path::new(file);
-                let path = path.canonicalize().unwrap_or_else(|_| path.to_path_buf());
-                if path.exists() {
-                    let source_file = session.source_manager.load_file(&path).into_diagnostic()?;
+
+                // Resolve relative paths to absolute paths
+                let resolved_path = if path.is_relative() {
+                    // Strategy 1: Try trim_path_prefixes
+                    if let Some(resolved) = config.trim_path_prefixes.iter().find_map(|prefix| {
+                        let candidate = prefix.join(path);
+                        if candidate.exists() {
+                            // Canonicalize to get absolute path
+                            candidate.canonicalize().ok()
+                        } else {
+                            None
+                        }
+                    }) {
+                        Some(resolved)
+                    }
+                    // Strategy 2: Try session.options.current_dir as fallback
+                    else {
+                        let current_dir_candidate = session.options.current_dir.join(path);
+                        if current_dir_candidate.exists() {
+                            current_dir_candidate.canonicalize().ok()
+                        } else {
+                            None
+                        }
+                    }
+                } else {
+                    // Path is absolute, but verify it exists and canonicalize it
+                    if path.exists() {
+                        path.canonicalize().ok()
+                    } else {
+                        None
+                    }
+                };
+
+                if let Some(absolute_path) = resolved_path {
+                    debug_assert!(
+                        absolute_path.is_absolute(),
+                        "resolved path should be absolute: {}",
+                        absolute_path.display()
+                    );
+                    log::debug!(target: "module-parser",
+                        "resolved source path '{}' -> '{}'",
+                        file,
+                        absolute_path.display()
+                    );
+                    let source_file =
+                        session.source_manager.load_file(&absolute_path).into_diagnostic()?;
                     let line = loc.line.and_then(LineNumber::new).unwrap_or_default();
                     let column = loc.column.and_then(ColumnNumber::new).unwrap_or_default();
                     span = source_file.line_column_to_span(line, column).unwrap_or_default();
                 } else {
                     log::debug!(target: "module-parser",
-                        "failed to locate span for instruction at offset {offset} in function {func_name}"
+                        "failed to resolve source path '{file}' for instruction at offset \
+                         {offset} in function {func_name}"
                     );
                 }
             }
diff --git a/hir/src/ir/print.rs b/hir/src/ir/print.rs
@@ -13,13 +13,15 @@ use crate::{
 pub struct OpPrintingFlags {
     pub print_entry_block_headers: bool,
     pub print_intrinsic_attributes: bool,
+    pub print_source_locations: bool,
 }
 
 impl Default for OpPrintingFlags {
     fn default() -> Self {
         Self {
             print_entry_block_headers: true,
             print_intrinsic_attributes: false,
+            print_source_locations: false,
         }
     }
 }
@@ -175,6 +177,32 @@ pub fn render_regions(op: &Operation, flags: &OpPrintingFlags) -> crate::formatt
         + const_text(";")
 }
 
+pub fn render_source_location(op: &Operation, context: &Context) -> crate::formatter::Document {
+    use crate::formatter::*;
+
+    // Check if the span is valid (not default/empty)
+    if op.span.is_unknown() {
+        return Document::Empty;
+    }
+
+    // Try to resolve the source location
+    let session = context.session();
+    if let Ok(source_file) = session.source_manager.get(op.span.source_id()) {
+        let location = source_file.location(op.span);
+        // Format: #loc("filename":line:col)
+        let filename = source_file.uri().as_str();
+        let loc_str = format!(
+            " #loc(\"{}\":{}:{})",
+            filename,
+            location.line.to_u32(),
+            location.column.to_u32()
+        );
+        return text(loc_str);
+    }
+
+    Document::Empty
+}
+
 struct OperationPrinter<'a> {
     op: &'a Operation,
     flags: &'a OpPrintingFlags,
@@ -280,6 +308,13 @@ impl PrettyPrint for OperationPrinter<'_> {
             doc + const_text(" ") + attrs
         };
 
+        // Add source location if requested
+        let doc = if self.flags.print_source_locations {
+            doc + render_source_location(self.op, self.context)
+        } else {
+            doc
+        };
+
         if self.op.has_regions() {
             doc + render_regions(self.op, self.flags)
         } else {
diff --git a/midenc-compile/Cargo.toml b/midenc-compile/Cargo.toml
@@ -26,6 +26,7 @@ std = [
 ]
 
 [dependencies]
+anyhow.workspace = true
 clap = { workspace = true, optional = true }
 log.workspace = true
 inventory.workspace = true
diff --git a/midenc-compile/src/compiler.rs b/midenc-compile/src/compiler.rs
@@ -348,6 +348,29 @@ pub struct UnstableOptions {
         arg(long, default_value_t = false, help_heading = "Passes")
     )]
     pub print_ir_after_modified: bool,
+    /// Print source location information in HIR output
+    ///
+    /// When enabled, HIR output will include #loc() annotations showing the source file,
+    /// line, and column for each operation.
+    #[cfg_attr(
+        feature = "std",
+        arg(
+            long = "print-hir-source-locations",
+            default_value_t = false,
+            help_heading = "Printers"
+        )
+    )]
+    pub print_hir_source_locations: bool,
+    /// Specify path prefixes to try when resolving relative paths from DWARF debug info
+    #[cfg_attr(
+        feature = "std",
+        arg(
+            long = "trim-path-prefix",
+            value_name = "PATH",
+            help_heading = "Debugging"
+        )
+    )]
+    pub trim_path_prefixes: Vec<PathBuf>,
 }
 
 impl CodegenOptions {
@@ -516,6 +539,8 @@ impl Compiler {
         options.print_ir_after_all = unstable.print_ir_after_all;
         options.print_ir_after_pass = unstable.print_ir_after_pass;
         options.print_ir_after_modified = unstable.print_ir_after_modified;
+        options.print_hir_source_locations = unstable.print_hir_source_locations;
+        options.trim_path_prefixes = unstable.trim_path_prefixes;
 
         // Establish --target-dir
         let target_dir = if self.target_dir.is_absolute() {
diff --git a/midenc-compile/src/stages/link.rs b/midenc-compile/src/stages/link.rs
@@ -1,12 +1,12 @@
-use alloc::{borrow::ToOwned, collections::BTreeMap, sync::Arc, vec::Vec};
+use alloc::{borrow::ToOwned, collections::BTreeMap, string::ToString, sync::Arc, vec::Vec};
 
 use midenc_frontend_wasm::FrontendOutput;
 use midenc_hir::{interner::Symbol, BuilderExt, OpBuilder, SourceSpan};
 #[cfg(feature = "std")]
 use midenc_session::Path;
 use midenc_session::{
     diagnostics::{Severity, Spanned},
-    InputType, ProjectType,
+    InputType, OutputMode, OutputType, ProjectType,
 };
 
 use super::*;
@@ -133,6 +133,7 @@ impl Stage for LinkStage {
             InputType::Stdin { name, input } => {
                 let config = wasm::WasmTranslationConfig {
                     source_name: name.file_stem().unwrap().to_owned().into(),
+                    trim_path_prefixes: context.session().options.trim_path_prefixes.clone(),
                     world: Some(world),
                     ..Default::default()
                 };
@@ -151,6 +152,22 @@ impl Stage for LinkStage {
 
         link_output.link_libraries_from(context.session())?;
 
+        // Emit HIR if requested
+        let session = context.session();
+        if session.should_emit(OutputType::Hir) {
+            use midenc_hir::{Op, OpPrinter, OpPrintingFlags};
+            let flags = OpPrintingFlags {
+                print_entry_block_headers: true,
+                print_intrinsic_attributes: false,
+                print_source_locations: session.options.print_hir_source_locations,
+            };
+            let op = link_output.component.borrow();
+            let hir_context = op.as_operation().context();
+            let doc = op.as_operation().print(&flags, hir_context);
+            let hir_str = doc.to_string();
+            session.emit(OutputMode::Text, &hir_str).into_diagnostic()?;
+        }
+
         if context.session().parse_only() {
             log::debug!("stopping compiler early (parse-only=true)");
             return Err(CompilerStopped.into());
@@ -181,8 +198,10 @@ fn parse_hir_from_wasm_file(
     let mut bytes = Vec::with_capacity(1024);
     file.read_to_end(&mut bytes).into_diagnostic()?;
     let file_name = path.file_stem().unwrap().to_str().unwrap().to_owned();
+
     let config = wasm::WasmTranslationConfig {
         source_name: file_name.into(),
+        trim_path_prefixes: context.session().options.trim_path_prefixes.clone(),
         world: Some(world),
         ..Default::default()
     };
diff --git a/midenc-session/src/emit.rs b/midenc-session/src/emit.rs
@@ -205,6 +205,25 @@ impl<T: Emit> Emit for Arc<T> {
     }
 }
 
+impl Emit for alloc::string::String {
+    fn name(&self) -> Option<Symbol> {
+        None
+    }
+
+    fn output_type(&self, _mode: OutputMode) -> OutputType {
+        OutputType::Hir
+    }
+
+    fn write_to<W: Writer>(
+        &self,
+        mut writer: W,
+        _mode: OutputMode,
+        _session: &Session,
+    ) -> anyhow::Result<()> {
+        writer.write_fmt(format_args!("{self}\n"))
+    }
+}
+
 impl Emit for miden_assembly::ast::Module {
     fn name(&self) -> Option<Symbol> {
         Some(Symbol::intern(self.path().to_string()))
diff --git a/midenc-session/src/options/mod.rs b/midenc-session/src/options/mod.rs
@@ -36,6 +36,10 @@ pub struct Options {
     pub diagnostics: DiagnosticsConfig,
     /// The current working directory of the compiler
     pub current_dir: PathBuf,
+    /// Path prefixes to try when resolving relative paths in DWARF debug info
+    pub trim_path_prefixes: Vec<PathBuf>,
+    /// Print source location information in HIR output
+    pub print_hir_source_locations: bool,
     /// Only parse inputs
     pub parse_only: bool,
     /// Only perform semantic analysis on the input
@@ -119,6 +123,8 @@ impl Options {
             color: Default::default(),
             diagnostics: Default::default(),
             current_dir,
+            trim_path_prefixes: vec![],
+            print_hir_source_locations: false,
             parse_only: false,
             analyze_only: false,
             link_only: false,
diff --git a/tests/lit/source-location/lit.suite.toml b/tests/lit/source-location/lit.suite.toml
@@ -0,0 +1,5 @@
+name = "source-location"
+patterns = ["*.wat"]
+working_dir = "../../../"
+
+[format.shtest]
diff --git a/tests/lit/source-location/test-project/Cargo.lock b/tests/lit/source-location/test-project/Cargo.lock
diff --git a/tests/lit/source-location/test-project/Cargo.toml b/tests/lit/source-location/test-project/Cargo.toml
@@ -0,0 +1,17 @@
+cargo-features = ["trim-paths"]
+
+[package]
+name = "source_location_test"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+crate-type = ["cdylib"]
+
+[profile.release]
+debug = true
+trim-paths = ["diagnostics", "object"]
+
+[profile.dev]
+debug = true
+trim-paths = ["diagnostics", "object"]
diff --git a/tests/lit/source-location/test-project/src/lib.rs b/tests/lit/source-location/test-project/src/lib.rs
diff --git a/tests/lit/source-location/test.wat b/tests/lit/source-location/test.wat

Original file line number	Diff line number	Diff line change
`@@ -335,6 +335,7 @@ args = [`
`335`	`335`	`"${CARGO_MAKE_WORKSPACE_WORKING_DIRECTORY}/bin",`
`336`	`336`	`"${CARGO_MAKE_WORKSPACE_WORKING_DIRECTORY}/tests/lit/parse",`
`337`	`337`	`"${CARGO_MAKE_WORKSPACE_WORKING_DIRECTORY}/tests/lit/wasm-translation",`
	`338`	`+ "${CARGO_MAKE_WORKSPACE_WORKING_DIRECTORY}/tests/lit/source-location",`
`338`	`339`	`]`
`339`	`340`	`dependencies = ["litcheck"]`
`340`	`341`
Original file line number	Diff line number	Diff line change
`@@ -145,6 +145,7 @@ pub fn build_ir_module(`
`145`	`145`	`&addr2line,`
`146`	`146`	`context.session(),`
`147`	`147`	`&mut func_validator,`
	`148`	`+ _config,`
`148`	`149`	`)?;`
`149`	`150`	`}`
`150`	`151`	`Ok(())`
Original file line number	Diff line number	Diff line change
`@@ -26,6 +26,7 @@ std = [`
`26`	`26`	`]`
`27`	`27`
`28`	`28`	`[dependencies]`
	`29`	`+anyhow.workspace = true`
`29`	`30`	`clap = { workspace = true, optional = true }`
`30`	`31`	`log.workspace = true`
`31`	`32`	`inventory.workspace = true`