MachInst backend: pass through SourceLoc information.

This change adds SourceLoc information per instruction in a `VCode<Inst>`
container, and keeps this information up-to-date across register allocation
and branch reordering. The information is initially collected during
instruction lowering, eventually collected on the MachSection, and finally
provided to the environment that wraps the codegen crate for wasmtime.

cranelift/codegen/src/machinst/sections.rs

@@ -74,6 +74,11 @@ impl MachSections {
         sink.end_codegen();
     }
 
+    /// Get a list of source location mapping tuples in sorted-by-start-offset order.
+    pub fn get_srclocs_sorted<'a>(&'a self) -> MachSectionsSrcLocs<'a> {
+        MachSectionsSrcLocs::new(&self.sections)
+    }
+
     /// Get the total required size for these sections.
     pub fn total_size(&self) -> CodeOffset {
         if self.sections.len() == 0 {
@@ -90,6 +95,58 @@ impl MachSections {
     }
 }
 
+/// An iterator over the srclocs in each section.
+/// Returns MachSrcLocs in an order sorted by start location.
+pub struct MachSectionsSrcLocs<'a> {
+    sections: &'a [MachSection],
+    cur_section: usize,
+    cur_srcloc: usize,
+    // For validation:
+    last_offset: CodeOffset,
+}
+
+impl<'a> MachSectionsSrcLocs<'a> {
+    fn new(sections: &'a [MachSection]) -> MachSectionsSrcLocs<'a> {
+        MachSectionsSrcLocs {
+            sections,
+            cur_section: 0,
+            cur_srcloc: 0,
+            last_offset: 0,
+        }
+    }
+}
+
+impl<'a> Iterator for MachSectionsSrcLocs<'a> {
+    type Item = &'a MachSrcLoc;
+
+    fn next(&mut self) -> Option<&'a MachSrcLoc> {
+        // We simply iterate through sections and srcloc records in order. This produces a
+        // sorted order naturally because sections are in starting-offset-order, and srclocs
+        // are produced as a section is emitted into, so are in order as well.
+
+        // If we're out of sections, we're done.
+        if self.cur_section >= self.sections.len() {
+            return None;
+        }
+
+        // Otherwise, make sure we have a srcloc in the current section left to return, and
+        // advance to the next section if not. Done if we run out of sections.
+        while self.cur_srcloc >= self.sections[self.cur_section].srclocs.len() {
+            self.cur_srcloc = 0;
+            self.cur_section += 1;
+            if self.cur_section >= self.sections.len() {
+                return None;
+            }
+        }
+
+        let loc = &self.sections[self.cur_section].srclocs[self.cur_srcloc];
+        self.cur_srcloc += 1;
+        debug_assert!(loc.start >= self.last_offset);
+        self.last_offset = loc.start;
+        Some(loc)
+    }
+}
+
 /// An abstraction over MachSection and MachSectionSize: some
 /// receiver of section data.
 pub trait MachSectionOutput {
@@ -143,6 +200,12 @@ pub trait MachSectionOutput {
     /// Add a call return address record at the current offset.
     fn add_call_site(&mut self, loc: SourceLoc, opcode: Opcode);
 
+    /// Start the output for the given source-location at the current offset.
+    fn start_srcloc(&mut self, loc: SourceLoc);
+
+    /// End the output for the previously-given source-location at the current offset.
+    fn end_srcloc(&mut self);
+
     /// Align up to the given alignment.
     fn align_to(&mut self, align_to: CodeOffset) {
         assert!(align_to.is_power_of_two());
@@ -168,8 +231,13 @@ pub struct MachSection {
     pub relocs: Vec<MachReloc>,
     /// Any trap records referring to this section.
     pub traps: Vec<MachTrap>,
-    /// Any call site record referring to this section.
+    /// Any call site records referring to this section.
     pub call_sites: Vec<MachCallSite>,
+    /// Any source location mappings referring to this section.
+    pub srclocs: Vec<MachSrcLoc>,
+    /// The current source location in progress (after `start_srcloc()` and before `end_srcloc()`).
+    /// This is a (start_offset, src_loc) tuple.
+    pub cur_srcloc: Option<(CodeOffset, SourceLoc)>,
 }
 
 impl MachSection {
@@ -182,6 +250,8 @@ impl MachSection {
             relocs: vec![],
             traps: vec![],
             call_sites: vec![],
+            srclocs: vec![],
+            cur_srcloc: None,
         }
     }
 
@@ -266,6 +336,23 @@ impl MachSectionOutput for MachSection {
             opcode,
         });
     }
+
+    fn start_srcloc(&mut self, loc: SourceLoc) {
+        self.cur_srcloc = Some((self.cur_offset_from_start(), loc));
+    }
+
+    fn end_srcloc(&mut self) {
+        let (start, loc) = self
+            .cur_srcloc
+            .take()
+            .expect("end_srcloc() called without start_srcloc()");
+        let end = self.cur_offset_from_start();
+        // Skip zero-length extends.
+        debug_assert!(end >= start);
+        if end > start {
+            self.srclocs.push(MachSrcLoc { start, end, loc });
+        }
+    }
 }
 
 /// A MachSectionOutput implementation that records only size.
@@ -315,6 +402,10 @@ impl MachSectionOutput for MachSectionSize {
     fn add_trap(&mut self, _: SourceLoc, _: TrapCode) {}
 
     fn add_call_site(&mut self, _: SourceLoc, _: Opcode) {}
+
+    fn start_srcloc(&mut self, _: SourceLoc) {}
+
+    fn end_srcloc(&mut self) {}
 }
 
 /// A relocation resulting from a compilation.
@@ -352,3 +443,18 @@ pub struct MachCallSite {
     /// The call's opcode.
     pub opcode: Opcode,
 }
+
+/// A source-location mapping resulting from a compilation.
+#[derive(Clone, Debug)]
+pub struct MachSrcLoc {
+    /// The start of the region of code corresponding to a source location.
+    /// This is relative to the start of the function, not to the start of the
+    /// section.
+    pub start: CodeOffset,
+    /// The end of the region of code corresponding to a source location.
+    /// This is relative to the start of the section, not to the start of the
+    /// section.
+    pub end: CodeOffset,
+    /// The source location.
+    pub loc: SourceLoc,
+}