cranelift: Add heap support to the interpreter (#3302)

* cranelift: Add heaps to interpreter

* cranelift: Add RunTest Environment mechanism to  test interpret

* cranelift: Remove unused `MemoryError`

* cranelift: Add docs for `State::resolve_global_value`

* cranelift: Rename heap tests

* cranelift: Refactor heap address resolution

* Fix typos and clarify docs (thanks @cfallin)

cranelift/interpreter/src/state.rs

@@ -3,7 +3,7 @@
 use crate::address::{Address, AddressSize};
 use cranelift_codegen::data_value::DataValue;
 use cranelift_codegen::ir::condcodes::{FloatCC, IntCC};
-use cranelift_codegen::ir::{FuncRef, Function, StackSlot, Type, Value};
+use cranelift_codegen::ir::{FuncRef, Function, GlobalValue, Heap, StackSlot, Type, Value};
 use cranelift_entity::PrimaryMap;
 use smallvec::SmallVec;
 use thiserror::Error;
@@ -67,13 +67,25 @@ pub trait State<'a, V> {
         offset: u64,
     ) -> Result<Address, MemoryError>;
     /// Computes a heap address
-    fn heap_address(&self, size: AddressSize, offset: u64) -> Result<Address, MemoryError>;
+    fn heap_address(
+        &self,
+        size: AddressSize,
+        heap: Heap,
+        offset: u64,
+    ) -> Result<Address, MemoryError>;
     /// Retrieve a value `V` from memory at the given `address`, checking if it belongs either to the
     /// stack or to one of the heaps; the number of bytes loaded corresponds to the specified [Type].
     fn checked_load(&self, address: Address, ty: Type) -> Result<V, MemoryError>;
     /// Store a value `V` into memory at the given `address`, checking if it belongs either to the
     /// stack or to one of the heaps; the number of bytes stored corresponds to the specified [Type].
     fn checked_store(&mut self, address: Address, v: V) -> Result<(), MemoryError>;
+
+    /// Given a global value, compute the final value for that global value, applying all operations
+    /// in intermediate global values.
+    fn resolve_global_value(&self, gv: GlobalValue) -> Result<V, MemoryError>;
+
+    /// Checks if an address is valid and within a known region of memory
+    fn validate_address(&self, address: &Address) -> Result<(), MemoryError>;
 }
 
 #[derive(Error, Debug)]
@@ -151,7 +163,12 @@ where
         unimplemented!()
     }
 
-    fn heap_address(&self, _size: AddressSize, _offset: u64) -> Result<Address, MemoryError> {
+    fn heap_address(
+        &self,
+        _size: AddressSize,
+        _heap: Heap,
+        _offset: u64,
+    ) -> Result<Address, MemoryError> {
         unimplemented!()
     }
 
@@ -162,4 +179,12 @@ where
     fn checked_store(&mut self, _addr: Address, _v: V) -> Result<(), MemoryError> {
         unimplemented!()
     }
+
+    fn resolve_global_value(&self, _gv: GlobalValue) -> Result<V, MemoryError> {
+        unimplemented!()
+    }
+
+    fn validate_address(&self, _addr: &Address) -> Result<(), MemoryError> {
+        unimplemented!()
+    }
 }