Implement the table64 extension to the memory64 proposal (#1531)

* Fix new gc local.tee test

Fix validation of `local.tee` to push the local's type, not the actual
type.

* Update the spec testsuite submodule

* Implement the table64 extension to the memory64 proposal

This commit implements validation, fuzzing, printing, etc, for the
extension of the memory64 proposal that adds 64-bit tables. These tables
work similarly to memories where the index type is statically listed and
is required for all various operations. The bulk of the changes here
were to wasm-smith to generate modules with these new table
instructions.

* Fix wasm-smith processing `local.tee`

* Fix construction of `table.init` instructions

Author: alexcrichton

crates/fuzz-stats/src/bin/failed-instantiations.rs

@@ -99,6 +99,10 @@ impl State {
         let mut config = wasm_smith::Config::arbitrary(&mut u)?;
         config.allow_start_export = false;
 
+        // NB: just added "table64" support to this and wasmtime doens't
+        // implement that yet
+        config.memory64_enabled = false;
+
         // Wasmtime doesn't support these proposals yet.
         config.gc_enabled = false;
 

crates/wasm-encoder/src/core/elements.rs

@@ -17,6 +17,7 @@ use crate::{encode_section, ConstExpr, Encode, RefType, Section, SectionId};
 ///     element_type: RefType::FUNCREF,
 ///     minimum: 128,
 ///     maximum: None,
+///     table64: false,
 /// });
 ///
 /// let mut elements = ElementSection::new();

crates/wasm-encoder/src/core/tables.rs

@@ -1,4 +1,4 @@
-use crate::{encode_section, ConstExpr, Encode, RefType, Section, SectionId};
+use crate::{encode_section, ConstExpr, Encode, RefType, Section, SectionId, ValType};
 
 /// An encoder for the table section.
 ///
@@ -14,6 +14,7 @@ use crate::{encode_section, ConstExpr, Encode, RefType, Section, SectionId};
 ///     element_type: RefType::FUNCREF,
 ///     minimum: 128,
 ///     maximum: None,
+///     table64: false,
 /// });
 ///
 /// let mut module = Module::new();
@@ -80,10 +81,23 @@ impl Section for TableSection {
 pub struct TableType {
     /// The table's element type.
     pub element_type: RefType,
+    /// Whether or not this is a 64-bit table.
+    pub table64: bool,
     /// Minimum size, in elements, of this table
-    pub minimum: u32,
+    pub minimum: u64,
     /// Maximum size, in elements, of this table
-    pub maximum: Option<u32>,
+    pub maximum: Option<u64>,
+}
+
+impl TableType {
+    /// Returns the type used to index this table.
+    pub fn index_type(&self) -> ValType {
+        if self.table64 {
+            ValType::I64
+        } else {
+            ValType::I32
+        }
+    }
 }
 
 impl Encode for TableType {
@@ -92,6 +106,9 @@ impl Encode for TableType {
         if self.maximum.is_some() {
             flags |= 0b001;
         }
+        if self.table64 {
+            flags |= 0b100;
+        }
 
         self.element_type.encode(sink);
         sink.push(flags);
@@ -111,6 +128,7 @@ impl TryFrom<wasmparser::TableType> for TableType {
             element_type: table_ty.element_type.try_into()?,
             minimum: table_ty.initial,
             maximum: table_ty.maximum,
+            table64: table_ty.table64,
         })
     }
 }

crates/wasm-mutate/src/mutators/translate.rs

@@ -155,6 +155,7 @@ pub fn table_type(
         element_type: t.translate_refty(&ty.element_type)?,
         minimum: ty.initial,
         maximum: ty.maximum,
+        table64: ty.table64,
     })
 }
 

crates/wasm-smith/src/config.rs

@@ -404,7 +404,7 @@ define_config! {
 
         /// The maximum, elements, of any table's initial or maximum
         /// size. Defaults to 1 million.
-        pub max_table_elements: u32 = 1_000_000,
+        pub max_table_elements: u64 = 1_000_000,
 
         /// The maximum number of tables to use. Defaults to 1.
         ///

crates/wasm-smith/src/core.rs

@@ -1887,45 +1887,60 @@ impl Module {
 
     fn arbitrary_elems(&mut self, u: &mut Unstructured) -> Result<()> {
         // Create a helper closure to choose an arbitrary offset.
-        let mut offset_global_choices = vec![];
+        let mut global_i32 = vec![];
+        let mut global_i64 = vec![];
         if !self.config.disallow_traps {
             for i in self.globals_for_const_expr(ValType::I32) {
-                offset_global_choices.push(i);
+                global_i32.push(i);
+            }
+            for i in self.globals_for_const_expr(ValType::I64) {
+                global_i64.push(i);
             }
         }
         let disallow_traps = self.config.disallow_traps;
-        let arbitrary_active_elem = |u: &mut Unstructured,
-                                     min_mem_size: u32,
-                                     table: Option<u32>,
-                                     table_ty: &TableType| {
-            let (offset, max_size_hint) = if !offset_global_choices.is_empty() && u.arbitrary()? {
-                let g = u.choose(&offset_global_choices)?;
-                (Offset::Global(*g), None)
-            } else {
-                let max_mem_size = if disallow_traps {
-                    table_ty.minimum
+        let arbitrary_active_elem =
+            |u: &mut Unstructured, min_mem_size: u64, table: Option<u32>, table_ty: &TableType| {
+                let global_choices = if table_ty.table64 {
+                    &global_i64
                 } else {
-                    u32::MAX
+                    &global_i32
                 };
-                let offset =
-                    arbitrary_offset(u, min_mem_size.into(), max_mem_size.into(), 0)? as u32;
-                let max_size_hint = if disallow_traps
-                    || (offset <= min_mem_size && u.int_in_range(0..=CHANCE_OFFSET_INBOUNDS)? != 0)
-                {
-                    Some(min_mem_size - offset)
+                let (offset, max_size_hint) = if !global_choices.is_empty() && u.arbitrary()? {
+                    let g = u.choose(&global_choices)?;
+                    (Offset::Global(*g), None)
                 } else {
-                    None
+                    let max_mem_size = if disallow_traps {
+                        table_ty.minimum
+                    } else if table_ty.table64 {
+                        u64::MAX
+                    } else {
+                        u64::from(u32::MAX)
+                    };
+                    let offset = arbitrary_offset(u, min_mem_size, max_mem_size, 0)?;
+                    let max_size_hint = if disallow_traps
+                        || (offset <= min_mem_size
+                            && u.int_in_range(0..=CHANCE_OFFSET_INBOUNDS)? != 0)
+                    {
+                        Some(min_mem_size - offset)
+                    } else {
+                        None
+                    };
+
+                    let offset = if table_ty.table64 {
+                        Offset::Const64(offset as i64)
+                    } else {
+                        Offset::Const32(offset as i32)
+                    };
+                    (offset, max_size_hint)
                 };
-                (Offset::Const32(offset as i32), max_size_hint)
+                Ok((ElementKind::Active { table, offset }, max_size_hint))
             };
-            Ok((ElementKind::Active { table, offset }, max_size_hint))
-        };
 
         // Generate a list of candidates for "kinds" of elements segments. For
         // example we can have an active segment for any existing table or
         // passive/declared segments if the right wasm features are enabled.
         type GenElemSegment<'a> =
-            dyn Fn(&mut Unstructured) -> Result<(ElementKind, Option<u32>)> + 'a;
+            dyn Fn(&mut Unstructured) -> Result<(ElementKind, Option<u64>)> + 'a;
         let mut choices: Vec<Box<GenElemSegment>> = Vec::new();
 
         // Bulk memory enables passive/declared segments, and note that the
@@ -2400,26 +2415,6 @@ impl Module {
     }
 }
 
-pub(crate) fn arbitrary_limits32(
-    u: &mut Unstructured,
-    min_minimum: Option<u32>,
-    max_minimum: u32,
-    max_required: bool,
-    max_inbounds: u32,
-) -> Result<(u32, Option<u32>)> {
-    let (min, max) = arbitrary_limits64(
-        u,
-        min_minimum.map(Into::into),
-        max_minimum.into(),
-        max_required,
-        max_inbounds.into(),
-    )?;
-    Ok((
-        u32::try_from(min).unwrap(),
-        max.map(|i| u32::try_from(i).unwrap()),
-    ))
-}
-
 pub(crate) fn arbitrary_limits64(
     u: &mut Unstructured,
     min_minimum: Option<u64>,
@@ -2485,12 +2480,13 @@ pub(crate) fn arbitrary_table_type(
     config: &Config,
     module: Option<&Module>,
 ) -> Result<TableType> {
+    let table64 = config.memory64_enabled && u.arbitrary()?;
     // We don't want to generate tables that are too large on average, so
     // keep the "inbounds" limit here a bit smaller.
     let max_inbounds = 10_000;
     let min_elements = if config.disallow_traps { Some(1) } else { None };
     let max_elements = min_elements.unwrap_or(0).max(config.max_table_elements);
-    let (minimum, maximum) = arbitrary_limits32(
+    let (minimum, maximum) = arbitrary_limits64(
         u,
         min_elements,
         max_elements,
@@ -2508,6 +2504,7 @@ pub(crate) fn arbitrary_table_type(
         element_type,
         minimum,
         maximum,
+        table64,
     })
 }