Method resolve_heap

winch/codegen/src/codegen/env.rs:267–315

Resolve a `HeapData` from a [MemoryIndex].

(&mut self, index: MemoryIndex)

    /// Resolve a `HeapData` from a [MemoryIndex].
    pub fn resolve_heap(&mut self, index: MemoryIndex) -> HeapData {
        let mem = self.translation.module.memories[index];
        let is_shared = mem.shared;
        match self.resolved_heaps.entry(index) {
            Occupied(entry) => *entry.get(),
            Vacant(entry) => {
                let (import_from, base_offset, current_length_offset) =
                    match self.translation.module.defined_memory_index(index) {
                        Some(defined) => {
                            if is_shared {
                                (
                                    Some(self.vmoffsets.vmctx_vmmemory_pointer(defined)),
                                    self.vmoffsets.ptr.vmmemory_definition_base().into(),
                                    self.vmoffsets
                                        .ptr
                                        .vmmemory_definition_current_length()
                                        .into(),
                                )
                            } else {
                                let owned = self.translation.module.owned_memory_index(defined);
                                (
                                    None,
                                    self.vmoffsets.vmctx_vmmemory_definition_base(owned),
                                    self.vmoffsets
                                        .vmctx_vmmemory_definition_current_length(owned),
                                )
                            }
                        }
                        None => (
                            Some(self.vmoffsets.vmctx_vmmemory_import_from(index)),
                            self.vmoffsets.ptr.vmmemory_definition_base().into(),
                            self.vmoffsets
                                .ptr
                                .vmmemory_definition_current_length()
                                .into(),
                        ),
                    };

                let memory = &self.translation.module.memories[index];

                *entry.insert(HeapData {
                    offset: base_offset,
                    import_from,
                    current_length_offset,
                    memory: *memory,
                })
            }
        }
    }

    /// Get a [`Table`] from a [`TableIndex`].
    pub fn table(&mut self, index: TableIndex) -> &Table {