Define a "table" concept.

"Table" is to WebAssembly tables as "Heap" is to WebAssembly linear
memories.

lib/wasm/src/environ/dummy.rs

@@ -1,6 +1,7 @@
 //! "Dummy" environment for testing wasm translation.
 
 use cranelift_codegen::cursor::FuncCursor;
+use cranelift_codegen::ir::immediates::Imm64;
 use cranelift_codegen::ir::types::*;
 use cranelift_codegen::ir::{self, InstBuilder};
 use cranelift_codegen::settings;
@@ -169,7 +170,11 @@ impl<'dummy_environment> FuncEnvironment for DummyFuncEnvironment<'dummy_environ
 
     fn make_heap(&mut self, func: &mut ir::Function, _index: MemoryIndex) -> ir::Heap {
         // Create a static heap whose base address is stored at `vmctx+0`.
-        let gv = func.create_global_value(ir::GlobalValueData::VMContext { offset: 0.into() });
+        let addr = func.create_global_value(ir::GlobalValueData::VMContext { offset: 0.into() });
+        let gv = func.create_global_value(ir::GlobalValueData::Deref {
+            base: addr,
+            offset: 0.into(),
+        });
 
         func.create_heap(ir::HeapData {
             base: gv,
@@ -181,6 +186,29 @@ impl<'dummy_environment> FuncEnvironment for DummyFuncEnvironment<'dummy_environ
         })
     }
 
+    fn make_table(&mut self, func: &mut ir::Function, _index: TableIndex) -> ir::Table {
+        // Create a table whose base address is stored at `vmctx+0`.
+        let base_gv_addr =
+            func.create_global_value(ir::GlobalValueData::VMContext { offset: 0.into() });
+        let base_gv = func.create_global_value(ir::GlobalValueData::Deref {
+            base: base_gv_addr,
+            offset: 0.into(),
+        });
+        let bound_gv_addr =
+            func.create_global_value(ir::GlobalValueData::VMContext { offset: 0.into() });
+        let bound_gv = func.create_global_value(ir::GlobalValueData::Deref {
+            base: bound_gv_addr,
+            offset: 0.into(),
+        });
+
+        func.create_table(ir::TableData {
+            base_gv,
+            min_size: Imm64::new(0),
+            bound_gv,
+            element_size: Imm64::new(i64::from(self.pointer_bytes()) * 2),
+        })
+    }
+
     fn make_indirect_sig(&mut self, func: &mut ir::Function, index: SignatureIndex) -> ir::SigRef {
         // A real implementation would probably change the calling convention and add `vmctx` and
         // signature index arguments.
@@ -204,6 +232,7 @@ impl<'dummy_environment> FuncEnvironment for DummyFuncEnvironment<'dummy_environ
         &mut self,
         mut pos: FuncCursor,
         _table_index: TableIndex,
+        _table: ir::Table,
         _sig_index: SignatureIndex,
         sig_ref: ir::SigRef,
         callee: ir::Value,

lib/wasm/src/environ/spec.rs

@@ -89,6 +89,11 @@ pub trait FuncEnvironment {
         ir::Type::int(u16::from(self.triple().pointer_width().unwrap().bits())).unwrap()
     }
 
+    /// Get the size of a native pointer, in bytes.
+    fn pointer_bytes(&self) -> u8 {
+        self.triple().pointer_width().unwrap().bytes()
+    }
+
     /// Set up the necessary preamble definitions in `func` to access the global variable
     /// identified by `index`.
     ///
@@ -104,6 +109,12 @@ pub trait FuncEnvironment {
     /// The index space covers both imported and locally declared memories.
     fn make_heap(&mut self, func: &mut ir::Function, index: MemoryIndex) -> ir::Heap;
 
+    /// Set up the necessary preamble definitions in `func` to access the table identified
+    /// by `index`.
+    ///
+    /// The index space covers both imported and locally declared tables.
+    fn make_table(&mut self, func: &mut ir::Function, index: TableIndex) -> ir::Table;
+
     /// Set up a signature definition in the preamble of `func` that can be used for an indirect
     /// call with signature `index`.
     ///
@@ -141,6 +152,7 @@ pub trait FuncEnvironment {
         &mut self,
         pos: FuncCursor,
         table_index: TableIndex,
+        table: ir::Table,
         sig_index: SignatureIndex,
         sig_ref: ir::SigRef,
         callee: ir::Value,