Refactor where results of compilation are stored

cranelift/codegen/src/ir/stackslot.rs

@@ -182,7 +182,7 @@ pub struct StackLayoutInfo {
 /// Stack frame manager.
 ///
 /// Keep track of all the stack slots used by a function.
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Default)]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 pub struct StackSlots {
     /// All allocated stack slots.
@@ -202,12 +202,7 @@ pub struct StackSlots {
 impl StackSlots {
     /// Create an empty stack slot manager.
     pub fn new() -> Self {
-        Self {
-            slots: PrimaryMap::new(),
-            outgoing: Vec::new(),
-            emergency: Vec::new(),
-            layout_info: None,
-        }
+        StackSlots::default()
     }
 
     /// Clear out everything.

cranelift/entity/src/iter.rs

@@ -1,6 +1,7 @@
 //! A double-ended iterator over entity references and entities.
 
 use crate::EntityRef;
+use alloc::vec;
 use core::iter::Enumerate;
 use core::marker::PhantomData;
 use core::slice;
@@ -84,3 +85,40 @@ impl<'a, K: EntityRef, V> DoubleEndedIterator for IterMut<'a, K, V> {
 }
 
 impl<'a, K: EntityRef, V> ExactSizeIterator for IterMut<'a, K, V> {}
+
+/// Iterate over all keys in order.
+pub struct IntoIter<K: EntityRef, V> {
+    enumerate: Enumerate<vec::IntoIter<V>>,
+    unused: PhantomData<K>,
+}
+
+impl<K: EntityRef, V> IntoIter<K, V> {
+    /// Create an `IntoIter` iterator that visits the `PrimaryMap` keys and values
+    /// of `iter`.
+    pub fn new(iter: vec::IntoIter<V>) -> Self {
+        Self {
+            enumerate: iter.enumerate(),
+            unused: PhantomData,
+        }
+    }
+}
+
+impl<K: EntityRef, V> Iterator for IntoIter<K, V> {
+    type Item = (K, V);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.enumerate.next().map(|(i, v)| (K::new(i), v))
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.enumerate.size_hint()
+    }
+}
+
+impl<K: EntityRef, V> DoubleEndedIterator for IntoIter<K, V> {
+    fn next_back(&mut self) -> Option<Self::Item> {
+        self.enumerate.next_back().map(|(i, v)| (K::new(i), v))
+    }
+}
+
+impl<K: EntityRef, V> ExactSizeIterator for IntoIter<K, V> {}

cranelift/entity/src/map.rs

@@ -131,6 +131,16 @@ where
     }
 }
 
+impl<K, V> Default for SecondaryMap<K, V>
+where
+    K: EntityRef,
+    V: Clone + Default,
+{
+    fn default() -> SecondaryMap<K, V> {
+        SecondaryMap::new()
+    }
+}
+
 /// Immutable indexing into an `SecondaryMap`.
 ///
 /// All keys are permitted. Untouched entries have the default value.

cranelift/entity/src/primary.rs

@@ -1,6 +1,6 @@
 //! Densely numbered entity references as mapping keys.
 use crate::boxed_slice::BoxedSlice;
-use crate::iter::{Iter, IterMut};
+use crate::iter::{IntoIter, Iter, IterMut};
 use crate::keys::Keys;
 use crate::EntityRef;
 use alloc::boxed::Box;
@@ -150,6 +150,15 @@ where
     }
 }
 
+impl<K, V> Default for PrimaryMap<K, V>
+where
+    K: EntityRef,
+{
+    fn default() -> PrimaryMap<K, V> {
+        PrimaryMap::new()
+    }
+}
+
 /// Immutable indexing into an `PrimaryMap`.
 /// The indexed value must be in the map.
 impl<K, V> Index<K> for PrimaryMap<K, V>
@@ -173,6 +182,18 @@ where
     }
 }
 
+impl<K, V> IntoIterator for PrimaryMap<K, V>
+where
+    K: EntityRef,
+{
+    type Item = (K, V);
+    type IntoIter = IntoIter<K, V>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        IntoIter::new(self.elems.into_iter())
+    }
+}
+
 impl<'a, K, V> IntoIterator for &'a PrimaryMap<K, V>
 where
     K: EntityRef,

crates/debug/src/transform/address_transform.rs

@@ -5,8 +5,7 @@ use std::iter::FromIterator;
 use wasmtime_environ::entity::{EntityRef, PrimaryMap};
 use wasmtime_environ::ir::SourceLoc;
 use wasmtime_environ::wasm::DefinedFuncIndex;
-use wasmtime_environ::WasmFileInfo;
-use wasmtime_environ::{FunctionAddressMap, ModuleAddressMap};
+use wasmtime_environ::{CompiledFunctions, FunctionAddressMap, WasmFileInfo};
 
 pub type GeneratedAddress = usize;
 pub type WasmAddress = u64;
@@ -187,11 +186,12 @@ fn build_function_lookup(
 }
 
 fn build_function_addr_map(
-    at: &ModuleAddressMap,
+    funcs: &CompiledFunctions,
     code_section_offset: u64,
 ) -> PrimaryMap<DefinedFuncIndex, FunctionMap> {
     let mut map = PrimaryMap::new();
-    for (_, ft) in at {
+    for (_, f) in funcs {
+        let ft = &f.address_map;
         let mut fn_map = Vec::new();
         for t in &ft.instructions {
             if t.srcloc.is_default() {
@@ -447,11 +447,12 @@ impl<'a> Iterator for TransformRangeIter<'a> {
 }
 
 impl AddressTransform {
-    pub fn new(at: &ModuleAddressMap, wasm_file: &WasmFileInfo) -> Self {
+    pub fn new(funcs: &CompiledFunctions, wasm_file: &WasmFileInfo) -> Self {
         let code_section_offset = wasm_file.code_section_offset;
 
         let mut func = BTreeMap::new();
-        for (i, ft) in at {
+        for (i, f) in funcs {
+            let ft = &f.address_map;
             let (fn_start, fn_end, lookup) = build_function_lookup(ft, code_section_offset);
 
             func.insert(
@@ -465,7 +466,7 @@ impl AddressTransform {
             );
         }
 
-        let map = build_function_addr_map(at, code_section_offset);
+        let map = build_function_addr_map(funcs, code_section_offset);
         let func = Vec::from_iter(func.into_iter());
         AddressTransform { map, func }
     }
@@ -606,8 +607,8 @@ mod tests {
     use std::iter::FromIterator;
     use wasmtime_environ::entity::PrimaryMap;
     use wasmtime_environ::ir::SourceLoc;
-    use wasmtime_environ::WasmFileInfo;
-    use wasmtime_environ::{FunctionAddressMap, InstructionAddressMap, ModuleAddressMap};
+    use wasmtime_environ::{CompiledFunction, WasmFileInfo};
+    use wasmtime_environ::{CompiledFunctions, FunctionAddressMap, InstructionAddressMap};
 
     #[test]
     fn test_get_wasm_code_offset() {
@@ -640,8 +641,11 @@ mod tests {
         }
     }
 
-    fn create_simple_module(func: FunctionAddressMap) -> ModuleAddressMap {
-        PrimaryMap::from_iter(vec![func])
+    fn create_simple_module(address_map: FunctionAddressMap) -> CompiledFunctions {
+        PrimaryMap::from_iter(vec![CompiledFunction {
+            address_map,
+            ..Default::default()
+        }])
     }
 
     #[test]

crates/debug/src/transform/expression.rs

@@ -601,6 +601,7 @@ mod tests {
     use super::compile_expression;
     use super::{AddressTransform, FunctionFrameInfo, ValueLabel, ValueLabelsRanges};
     use gimli::{self, Encoding, EndianSlice, Expression, RunTimeEndian};
+    use wasmtime_environ::CompiledFunction;
 
     macro_rules! expression {
         ($($i:literal),*) => {
@@ -689,23 +690,26 @@ mod tests {
         use wasmtime_environ::{FunctionAddressMap, InstructionAddressMap};
         let mut module_map = PrimaryMap::new();
         let code_section_offset: u32 = 100;
-        module_map.push(FunctionAddressMap {
-            instructions: vec![
-                InstructionAddressMap {
-                    srcloc: SourceLoc::new(code_section_offset + 12),
-                    code_offset: 5,
-                    code_len: 3,
-                },
-                InstructionAddressMap {
-                    srcloc: SourceLoc::new(code_section_offset + 17),
-                    code_offset: 15,
-                    code_len: 8,
-                },
-            ],
-            start_srcloc: SourceLoc::new(code_section_offset + 10),
-            end_srcloc: SourceLoc::new(code_section_offset + 20),
-            body_offset: 0,
-            body_len: 30,
+        module_map.push(CompiledFunction {
+            address_map: FunctionAddressMap {
+                instructions: vec![
+                    InstructionAddressMap {
+                        srcloc: SourceLoc::new(code_section_offset + 12),
+                        code_offset: 5,
+                        code_len: 3,
+                    },
+                    InstructionAddressMap {
+                        srcloc: SourceLoc::new(code_section_offset + 17),
+                        code_offset: 15,
+                        code_len: 8,
+                    },
+                ],
+                start_srcloc: SourceLoc::new(code_section_offset + 10),
+                end_srcloc: SourceLoc::new(code_section_offset + 20),
+                body_offset: 0,
+                body_len: 30,
+            },
+            ..Default::default()
         });
         let fi = WasmFileInfo {
             code_section_offset: code_section_offset.into(),

crates/debug/src/transform/mod.rs

@@ -10,8 +10,7 @@ use gimli::{
 use std::collections::HashSet;
 use thiserror::Error;
 use wasmtime_environ::isa::TargetIsa;
-use wasmtime_environ::DebugInfoData;
-use wasmtime_environ::{ModuleAddressMap, ModuleVmctxInfo, ValueLabelsRanges};
+use wasmtime_environ::{CompiledFunctions, DebugInfoData, ModuleMemoryOffset};
 
 pub use address_transform::AddressTransform;
 
@@ -50,11 +49,10 @@ where
 pub fn transform_dwarf(
     isa: &dyn TargetIsa,
     di: &DebugInfoData,
-    at: &ModuleAddressMap,
-    vmctx_info: &ModuleVmctxInfo,
-    ranges: &ValueLabelsRanges,
+    funcs: &CompiledFunctions,
+    memory_offset: &ModuleMemoryOffset,
 ) -> Result<write::Dwarf, Error> {
-    let addr_tr = AddressTransform::new(at, &di.wasm_file);
+    let addr_tr = AddressTransform::new(funcs, &di.wasm_file);
     let reachable = build_dependencies(&di.dwarf, &addr_tr)?.get_reachable();
 
     let context = DebugInputContext {
@@ -90,9 +88,9 @@ pub fn transform_dwarf(
             unit,
             &context,
             &addr_tr,
-            &ranges,
+            funcs,
+            memory_offset,
             out_encoding,
-            &vmctx_info,
             &mut out_units,
             &mut out_strings,
             &mut translated,
@@ -107,8 +105,8 @@ pub fn transform_dwarf(
     generate_simulated_dwarf(
         &addr_tr,
         di,
-        &vmctx_info,
-        &ranges,
+        memory_offset,
+        funcs,
         &translated,
         out_encoding,
         &mut out_units,

crates/debug/src/transform/simulate.rs

@@ -11,9 +11,9 @@ use wasmparser::Type as WasmType;
 use wasmtime_environ::entity::EntityRef;
 use wasmtime_environ::isa::TargetIsa;
 use wasmtime_environ::wasm::{get_vmctx_value_label, DefinedFuncIndex};
-use wasmtime_environ::WasmFileInfo;
-use wasmtime_environ::{DebugInfoData, FunctionMetadata};
-use wasmtime_environ::{ModuleVmctxInfo, ValueLabelsRanges};
+use wasmtime_environ::{
+    CompiledFunctions, DebugInfoData, FunctionMetadata, ModuleMemoryOffset, WasmFileInfo,
+};
 
 const PRODUCER_NAME: &str = "wasmtime";
 
@@ -120,9 +120,9 @@ fn add_wasm_types(
     unit: &mut write::Unit,
     root_id: write::UnitEntryId,
     out_strings: &mut write::StringTable,
-    vmctx_info: &ModuleVmctxInfo,
+    memory_offset: &ModuleMemoryOffset,
 ) -> WasmTypesDieRefs {
-    let (_wp_die_id, vmctx_die_id) = add_internal_types(unit, root_id, out_strings, vmctx_info);
+    let (_wp_die_id, vmctx_die_id) = add_internal_types(unit, root_id, out_strings, memory_offset);
 
     macro_rules! def_type {
         ($id:literal, $size:literal, $enc:path) => {{
@@ -280,8 +280,8 @@ fn check_invalid_chars_in_path(path: PathBuf) -> Option<PathBuf> {
 pub fn generate_simulated_dwarf(
     addr_tr: &AddressTransform,
     di: &DebugInfoData,
-    vmctx_info: &ModuleVmctxInfo,
-    ranges: &ValueLabelsRanges,
+    memory_offset: &ModuleMemoryOffset,
+    funcs: &CompiledFunctions,
     translated: &HashSet<DefinedFuncIndex>,
     out_encoding: gimli::Encoding,
     out_units: &mut write::UnitTable,
@@ -342,7 +342,7 @@ pub fn generate_simulated_dwarf(
         (unit, root_id, name_id)
     };
 
-    let wasm_types = add_wasm_types(unit, root_id, out_strings, vmctx_info);
+    let wasm_types = add_wasm_types(unit, root_id, out_strings, memory_offset);
 
     for (i, map) in addr_tr.map().iter() {
         let index = i.index();
@@ -389,7 +389,7 @@ pub fn generate_simulated_dwarf(
             write::AttributeValue::Udata(wasm_offset),
         );
 
-        if let Some(frame_info) = get_function_frame_info(vmctx_info, i, ranges) {
+        if let Some(frame_info) = get_function_frame_info(memory_offset, funcs, i) {
             let source_range = addr_tr.func_source_range(i);
             generate_vars(
                 unit,