WIP.

src/frontend.rs

@@ -36,7 +36,7 @@ pub fn wasm_to_ir(bytes: &[u8]) -> Result<Module<'_>> {
         gimli::LocationLists::new(extra_sections.debug_loc, extra_sections.debug_loclists);
     dwarf.ranges =
         gimli::RangeLists::new(extra_sections.debug_ranges, extra_sections.debug_rnglists);
-    let debug_map = DebugMap::from_dwarf(dwarf, &mut module.debug)?;
+    let debug_map = DebugMap::from_dwarf(dwarf, &mut module.debug, extra_sections.code_offset)?;
     module.debug_map = debug_map;
 
     Ok(module)
@@ -74,6 +74,7 @@ struct ExtraSections<'a> {
     debug_loclists: gimli::DebugLocLists<gimli::EndianSlice<'a, gimli::LittleEndian>>,
     debug_ranges: gimli::DebugRanges<gimli::EndianSlice<'a, gimli::LittleEndian>>,
     debug_rnglists: gimli::DebugRngLists<gimli::EndianSlice<'a, gimli::LittleEndian>>,
+    code_offset: u32,
 }
 
 fn handle_payload<'a>(
@@ -171,6 +172,7 @@ fn handle_payload<'a>(
             }
         }
         Payload::CodeSectionEntry(body) => {
+            extra_sections.code_offset = body.range().start as u32;
             let func_idx = Func::new(*next_func);
             *next_func += 1;
 
@@ -358,23 +360,20 @@ fn handle_payload<'a>(
 }
 
 struct DebugLocReader<'a> {
-    code_section_offset: u32,
+    code_offset: u32,
     locs: &'a [(u32, u32, SourceLoc)],
 }
 
 impl<'a> DebugLocReader<'a> {
-    fn new(module: &'a Module, offset: usize) -> Self {
+    fn new(module: &'a Module) -> Self {
         DebugLocReader {
-            code_section_offset: u32::try_from(offset).unwrap(),
+            code_offset: module.debug_map.code_offset,
             locs: &module.debug_map.tuples[..],
         }
     }
 
     fn get_loc(&mut self, offset: usize) -> SourceLoc {
-        let offset = u32::try_from(offset)
-            .unwrap()
-            .checked_sub(self.code_section_offset)
-            .unwrap();
+        let offset = u32::try_from(offset).unwrap();
         while self.locs.len() > 0 {
             let (start, len, loc) = self.locs[0];
             if offset < start {
@@ -396,8 +395,7 @@ pub(crate) fn parse_body<'a>(
 ) -> Result<FunctionBody> {
     let mut ret: FunctionBody = FunctionBody::default();
 
-    let start_offset = body.range().start;
-    let mut debug_locs = DebugLocReader::new(module, start_offset);
+    let mut debug_locs = DebugLocReader::new(module);
 
     for &param in &module.signatures[my_sig].params[..] {
         ret.locals.push(param.into());

src/ir/debug.rs

@@ -48,8 +48,10 @@ impl Debug {
 
 #[derive(Clone, Debug, Default)]
 pub struct DebugMap {
+    /// Offset of code section relative to the Wasm file start.
+    pub code_offset: u32,
     /// Each tuple is `(start, len, loc)`. The `start` offset is
-    /// relative to the Wasm code section (*not* the entire file).
+    /// relative to the code section.
     pub tuples: Vec<(u32, u32, SourceLoc)>,
 }
 
@@ -57,6 +59,7 @@ impl DebugMap {
     pub(crate) fn from_dwarf<R: gimli::Reader>(
         dwarf: gimli::Dwarf<R>,
         debug: &mut Debug,
+        code_offset: u32,
     ) -> anyhow::Result<DebugMap> {
         let ctx = addr2line::Context::from_dwarf(dwarf)?;
         let mut tuples = vec![];
@@ -65,6 +68,7 @@ impl DebugMap {
         while let Some((start, len, loc)) = locs.next() {
             let file = debug.intern_file(loc.file.unwrap_or(""));
             let loc = debug.intern_loc(file, loc.line.unwrap_or(0), loc.column.unwrap_or(0));
+            log::trace!("tuple: loc {} start {:x} len {:x}", loc, start, len);
             tuples.push((start as u32, len as u32, loc));
         }
         tuples.sort();
@@ -78,6 +82,9 @@ impl DebugMap {
             retain
         });
 
-        Ok(DebugMap { tuples })
+        Ok(DebugMap {
+            code_offset,
+            tuples,
+        })
     }
 }