cranelift: Add virtual addresses to cranelift interpreter

Adds a  Virtual Addressing scheme that was discussed as a better
alternative to returning the real addresses.

The virtual addresses are split into 4 regions (stack, heap, tables and
global values), and the address itself is composed of an `entry` field
and an `offset` field. In general the `entry` field corresponds to the
instance of the resource (e.g. table5 is entry 5) and the `offset` field
is a byte offset inside that entry.

There is one exception to this which is the stack, where due to only
having one stack, the whole address is an offset field.

The number of bits in entry vs offset fields is variable with respect to
the `region` and the address size (32bits vs 64bits). This is done
because with 32 bit addresses we would have to compromise on heap size,
or have a small number of global values / tables. With 64 bit addresses
we do not have to compromise on this, but we need to support 32 bit
addresses.

Author: afonso360

cranelift/codegen/src/ir/trapcode.rs

@@ -20,6 +20,9 @@ pub enum TrapCode {
     /// A store was performed to an unmapped address
     OutOfBoundsStore,
 
+    /// An operation was performed with an invalid address
+    InvalidAddress,
+
     /// A `heap_addr` instruction detected an out-of-bounds error.
     ///
     /// Note that not all out-of-bounds heap accesses are reported this way;
@@ -64,6 +67,7 @@ impl Display for TrapCode {
         use self::TrapCode::*;
         let identifier = match *self {
             StackOverflow => "stk_ovf",
+            InvalidAddress => "invalid_addr",
             OutOfBoundsLoad => "oob_load",
             OutOfBoundsStore => "oob_store",
             HeapOutOfBounds => "heap_oob",
@@ -89,6 +93,7 @@ impl FromStr for TrapCode {
         use self::TrapCode::*;
         match s {
             "stk_ovf" => Ok(StackOverflow),
+            "invalid_addr" => Ok(InvalidAddress),
             "oob_load" => Ok(OutOfBoundsLoad),
             "oob_store" => Ok(OutOfBoundsStore),
             "heap_oob" => Ok(HeapOutOfBounds),
@@ -113,8 +118,9 @@ mod tests {
     use alloc::string::ToString;
 
     // Everything but user-defined codes.
-    const CODES: [TrapCode; 13] = [
+    const CODES: [TrapCode; 14] = [
         TrapCode::StackOverflow,
+        TrapCode::InvalidAddress,
         TrapCode::OutOfBoundsLoad,
         TrapCode::OutOfBoundsStore,
         TrapCode::HeapOutOfBounds,

cranelift/filetests/filetests/runtests/stack-addr-32.clif

@@ -0,0 +1,85 @@
+test interpret
+
+function %stack_addr_iadd(i64) -> b1 {
+    ss0 = explicit_slot 16
+
+block0(v0: i64):
+    v1 = stack_addr.i32 ss0
+    v2 = iadd_imm.i32 v1, 8
+
+    stack_store.i64 v0, ss0+8
+    v3 = load.i64 v2
+
+    v5 = iadd_imm.i64 v0, 20
+    store.i64 v5, v2
+    v6 = stack_load.i64 ss0+8
+
+    v7 = icmp eq v0, v3
+    v8 = icmp eq v5, v6
+    v9 = band v7, v8
+    return v9
+}
+; run: %stack_addr_iadd(0) == true
+; run: %stack_addr_iadd(1) == true
+; run: %stack_addr_iadd(-1) == true
+
+
+function %stack_addr_32(i64) -> b1 {
+    ss0 = explicit_slot 24
+
+block0(v0: i64):
+    v1 = stack_addr.i32 ss0
+    stack_store.i64 v0, ss0
+    v2 = load.i64 v1
+    v3 = icmp eq v0, v2
+
+    v4 = stack_addr.i32 ss0+8
+    store.i64 v0, v4
+    v5 = stack_load.i64 ss0+8
+    v6 = icmp eq v0, v5
+
+    v7 = stack_addr.i32 ss0+16
+    store.i64 v0, v7
+    v8 = load.i64 v7
+    v9 = icmp eq v0, v8
+
+    v10 = band v3, v6
+    v11 = band v10, v9
+    return v11
+}
+; run: %stack_addr_32(0) == true
+; run: %stack_addr_32(1) == true
+; run: %stack_addr_32(-1) == true
+
+
+
+function %addr32_64(i64) -> b1 {
+    ss0 = explicit_slot 16
+
+block0(v0: i64):
+    v1 = stack_addr.i32 ss0+8
+    v2 = stack_addr.i64 ss0+8
+
+    store.i64 v0, v1
+    v3 = load.i64 v2
+
+    v4 = icmp eq v3, v0
+
+    return v4
+}
+; run: %addr32_64(0) == true
+; run: %addr32_64(1) == true
+; run: %addr32_64(-1) == true
+
+
+function %multi_slot_different_addrs() -> b1 {
+    ss0 = explicit_slot 8
+    ss1 = explicit_slot 8
+
+block0:
+    v0 = stack_addr.i32 ss0
+    v1 = stack_addr.i32 ss1
+    v2 = icmp ne v0, v1
+    return v2
+}
+; run: %multi_slot_diffe() == true

cranelift/filetests/filetests/runtests/stack-addr-64.clif

@@ -0,0 +1,56 @@
+test interpret
+test run
+target x86_64 machinst
+target s390x
+target aarch64
+
+
+function %stack_addr_iadd(i64) -> b1 {
+    ss0 = explicit_slot 16
+
+block0(v0: i64):
+    v1 = stack_addr.i64 ss0
+    v2 = iadd_imm.i64 v1, 8
+
+    stack_store.i64 v0, ss0+8
+    v3 = load.i64 v2
+
+    v5 = iadd_imm.i64 v0, 20
+    store.i64 v5, v2
+    v6 = stack_load.i64 ss0+8
+
+    v7 = icmp eq v0, v3
+    v8 = icmp eq v5, v6
+    v9 = band v7, v8
+    return v9
+}
+; run: %stack_addr_iadd(0) == true
+; run: %stack_addr_iadd(1) == true
+; run: %stack_addr_iadd(-1) == true
+
+function %stack_addr_64(i64) -> b1 {
+    ss0 = explicit_slot 24
+
+block0(v0: i64):
+    v1 = stack_addr.i64 ss0
+    stack_store.i64 v0, ss0
+    v2 = load.i64 v1
+    v3 = icmp eq v0, v2
+
+    v4 = stack_addr.i64 ss0+8
+    store.i64 v0, v4
+    v5 = stack_load.i64 ss0+8
+    v6 = icmp eq v0, v5
+
+    v7 = stack_addr.i64 ss0+16
+    store.i64 v0, v7
+    v8 = load.i64 v7
+    v9 = icmp eq v0, v8
+
+    v10 = band v3, v6
+    v11 = band v10, v9
+    return v11
+}
+; run: %stack_addr_64(0) == true
+; run: %stack_addr_64(1) == true
+; run: %stack_addr_64(-1) == true

cranelift/filetests/filetests/runtests/stack.clif

@@ -55,33 +55,6 @@ block0(v0: i64):
 ; run: %offset_unaligned(-1) == -1
 
 
-function %stack_addr(i64) -> b1 {
-    ss0 = explicit_slot 24
-
-block0(v0: i64):
-    v1 = stack_addr.i64 ss0
-    stack_store.i64 v0, ss0
-    v2 = load.i64 v1
-    v3 = icmp eq v0, v2
-
-    v4 = stack_addr.i64 ss0+8
-    store.i64 v0, v4
-    v5 = stack_load.i64 ss0+8
-    v6 = icmp eq v0, v5
-
-    v7 = stack_addr.i64 ss0+16
-    store.i64 v0, v7
-    v8 = load.i64 v7
-    v9 = icmp eq v0, v8
-
-    v10 = band v3, v6
-    v11 = band v10, v9
-    return v11
-}
-; run: %stack_addr(0) == true
-; run: %stack_addr(1) == true
-; run: %stack_addr(-1) == true
-
 
 function %multi_slot_stack(i64, i64) -> i64 {
     ss0 = explicit_slot 8
@@ -99,18 +72,6 @@ block0(v0: i64, v1: i64):
 ; run: %multi_slot_stack(1, 2) == 3
 
 
-function %multi_slot_different_addrs() -> b1 {
-    ss0 = explicit_slot 8
-    ss1 = explicit_slot 8
-
-block0:
-    v0 = stack_addr.i64 ss0
-    v1 = stack_addr.i64 ss1
-    v2 = icmp ne v0, v1
-    return v2
-}
-; run: %multi_slot_diffe() == true
-
 
 function %multi_slot_out_of_bounds_writes(i8, i64) -> i8, i64 {
     ss0 = explicit_slot 1