threads: add shared tables (#1649)

* threads: add `shared` tables

This change spreads `shared` attributes on to tables. As with #1480,
this does not yet turn on fuzzing for `shared` things so the only
checking is via the in-progress test suite in
`tests/local/shared-everything-threads`.

Implementing this raises an issue with the spec: the addition of
`shared` in the text format means that inline table expressions (e.g.,
`(table <type> (elem ...))`) are difficult to parse: the parser would
potentially have to look past two tokens now, `shared` and `i32|i64` to
see if a type appears that indicates we should be parsing an inline
format. There are multiple options for what to do here; I opened an
issue to figure this out at the spec level first ([#71]).

[proposal]: https://github.com/WebAssembly/shared-everything-threads
[#71]: WebAssembly/shared-everything-threads#71

* Add a 'missing-features' test for `shared` tables

* Add a negative test for indexed types

Author: abrown

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

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

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

@@ -15,6 +15,7 @@ use crate::{encode_section, ConstExpr, Encode, RefType, Section, SectionId, ValT
 ///     minimum: 128,
 ///     maximum: None,
 ///     table64: false,
+///     shared: false,
 /// });
 ///
 /// let mut module = Module::new();
@@ -87,6 +88,10 @@ pub struct TableType {
     pub minimum: u64,
     /// Maximum size, in elements, of this table
     pub maximum: Option<u64>,
+    /// Whether this table is shared or not.
+    ///
+    /// This is included the shared-everything-threads proposal.
+    pub shared: bool,
 }
 
 impl TableType {
@@ -106,6 +111,9 @@ impl Encode for TableType {
         if self.maximum.is_some() {
             flags |= 0b001;
         }
+        if self.shared {
+            flags |= 0b010;
+        }
         if self.table64 {
             flags |= 0b100;
         }

crates/wasm-encoder/src/reencode.rs

@@ -1154,6 +1154,7 @@ pub mod utils {
             minimum: table_ty.initial,
             maximum: table_ty.maximum,
             table64: table_ty.table64,
+            shared: table_ty.shared,
         })
     }
 

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

@@ -156,6 +156,7 @@ pub fn table_type(
         minimum: ty.initial,
         maximum: ty.maximum,
         table64: ty.table64,
+        shared: ty.shared,
     })
 }
 

crates/wasm-smith/src/core.rs

@@ -2542,6 +2542,7 @@ pub(crate) fn arbitrary_table_type(
         minimum,
         maximum,
         table64,
+        shared: false, // TODO: handle shared
     })
 }
 

crates/wasmparser/src/readers/core/tables.rs

@@ -68,10 +68,11 @@ impl<'a> FromReader<'a> for TableType {
         let element_type = reader.read()?;
         let pos = reader.original_position();
         let flags = reader.read_u8()?;
-        if (flags & !0b101) != 0 {
+        if (flags & !0b111) != 0 {
             bail!(pos, "invalid table resizable limits flags");
         }
         let has_max = (flags & 0b001) != 0;
+        let shared = (flags & 0b010) != 0;
         let table64 = (flags & 0b100) != 0;
         Ok(TableType {
             element_type,
@@ -88,6 +89,7 @@ impl<'a> FromReader<'a> for TableType {
             } else {
                 Some(reader.read_var_u32()?.into())
             },
+            shared,
         })
     }
 }

crates/wasmparser/src/readers/core/types.rs

@@ -1700,6 +1700,10 @@ pub struct TableType {
     /// For 32-bit tables (when `table64` is `false`) this is guaranteed to
     /// be at most `u32::MAX` for valid types.
     pub maximum: Option<u64>,
+    /// Whether this table is shared or not.
+    ///
+    /// This is included the shared-everything-threads proposal.
+    pub shared: bool,
 }
 
 impl TableType {

crates/wasmparser/src/validator.rs

@@ -1537,6 +1537,7 @@ mod tests {
                 maximum: None,
                 element_type: RefType::FUNCREF,
                 table64: false,
+                shared: false,
             }
         );
 

crates/wasmparser/src/validator/core.rs

@@ -146,7 +146,7 @@ impl ModuleState {
         offset: usize,
     ) -> Result<()> {
         self.module
-            .check_table_type(&mut table.ty, features, offset)?;
+            .check_table_type(&mut table.ty, features, types, offset)?;
 
         match &table.init {
             TableInit::RefNull => {
@@ -870,7 +870,7 @@ impl Module {
                 EntityType::Func(self.types[*type_index as usize])
             }
             TypeRef::Table(t) => {
-                self.check_table_type(t, features, offset)?;
+                self.check_table_type(t, features, types, offset)?;
                 EntityType::Table(*t)
             }
             TypeRef::Memory(t) => {
@@ -892,10 +892,11 @@ impl Module {
         &self,
         ty: &mut TableType,
         features: &WasmFeatures,
+        types: &TypeList,
         offset: usize,
     ) -> Result<()> {
-        // the `funcref` value type is allowed all the way back to the MVP, so
-        // don't check it here
+        // The `funcref` value type is allowed all the way back to the MVP, so
+        // don't check it here.
         if ty.element_type != RefType::FUNCREF {
             self.check_ref_type(&mut ty.element_type, features, offset)?
         }
@@ -914,6 +915,23 @@ impl Module {
                 offset,
             ));
         }
+
+        if ty.shared {
+            if !features.shared_everything_threads() {
+                return Err(BinaryReaderError::new(
+                    "shared tables require the shared-everything-threads proposal",
+                    offset,
+                ));
+            }
+
+            if !types.reftype_is_shared(ty.element_type) {
+                return Err(BinaryReaderError::new(
+                    "shared tables must have a shared element type",
+                    offset,
+                ));
+            }
+        }
+
         Ok(())
     }
 

crates/wasmparser/src/validator/types.rs

@@ -2834,19 +2834,23 @@ impl TypeList {
     }
 
     /// Is `ty` shared?
-    ///
-    /// This is complicated by reference types, since they may have concrete
-    /// heap types whose shared-ness must be checked by looking at the type they
-    /// point to.
     pub fn valtype_is_shared(&self, ty: ValType) -> bool {
         match ty {
             ValType::I32 | ValType::I64 | ValType::F32 | ValType::F64 | ValType::V128 => true,
-            ValType::Ref(rt) => match rt.heap_type() {
-                HeapType::Abstract { shared, .. } => shared,
-                HeapType::Concrete(index) => {
-                    self[index.as_core_type_id().unwrap()].composite_type.shared
-                }
-            },
+            ValType::Ref(rt) => self.reftype_is_shared(rt),
+        }
+    }
+
+    /// Is the reference type `ty` shared?
+    ///
+    /// This is complicated by concrete heap types whose shared-ness must be
+    /// checked by looking at the type they point to.
+    pub fn reftype_is_shared(&self, ty: RefType) -> bool {
+        match ty.heap_type() {
+            HeapType::Abstract { shared, .. } => shared,
+            HeapType::Concrete(index) => {
+                self[index.as_core_type_id().unwrap()].composite_type.shared
+            }
         }
     }