threads: add shared globals (#1480)

abrown · web-flow · commit 371014147eea · 2024-04-01T13:37:05.000Z
* threads: add `shared` globals This change allows wasm-tools to encode and decode `shared` global types as a part of the [shared-everything-threads] proposal. It includes some initial fuzzing support, though it all should be turned off by default. [shared-everything-threads]: https://github.com/WebAssembly/shared-everything-threads * review: remove wit-component TODOs * review: use enclosed parser variable * review: avoid shared-everything-threads in wasm-smith for now * review: emit new 'malformed' message * review: add imports to test * review: add 'missing-features' tests
diff --git a/crates/fuzz-stats/src/bin/failed-instantiations.rs b/crates/fuzz-stats/src/bin/failed-instantiations.rs
@@ -102,7 +102,7 @@ impl State {
         let mut config = wasm_smith::Config::arbitrary(&mut u)?;
         config.allow_start_export = false;
 
-        // Wasmtime doesn't support this proposal yet.
+        // Wasmtime doesn't support these proposals yet.
         config.gc_enabled = false;
 
         let mut wasm = wasm_smith::Module::new(config, &mut u)?;
diff --git a/crates/wasm-encoder/src/core/globals.rs b/crates/wasm-encoder/src/core/globals.rs
@@ -14,6 +14,7 @@ use crate::{encode_section, ConstExpr, Encode, Section, SectionId, ValType};
 ///     GlobalType {
 ///         val_type: ValType::I32,
 ///         mutable: false,
+///         shared: false,
 ///     },
 ///     &ConstExpr::i32_const(42),
 /// );
@@ -80,12 +81,21 @@ pub struct GlobalType {
     pub val_type: ValType,
     /// Whether this global is mutable or not.
     pub mutable: bool,
+    /// Whether this global is shared or not.
+    pub shared: bool,
 }
 
 impl Encode for GlobalType {
     fn encode(&self, sink: &mut Vec<u8>) {
         self.val_type.encode(sink);
-        sink.push(self.mutable as u8);
+        let mut flag = 0;
+        if self.mutable {
+            flag |= 0b01;
+        }
+        if self.shared {
+            flag |= 0b10;
+        }
+        sink.push(flag);
     }
 }
 
@@ -96,6 +106,7 @@ impl TryFrom<wasmparser::GlobalType> for GlobalType {
         Ok(GlobalType {
             val_type: global_ty.content_type.try_into()?,
             mutable: global_ty.mutable,
+            shared: global_ty.shared,
         })
     }
 }
diff --git a/crates/wasm-mutate/src/mutators/peephole.rs b/crates/wasm-mutate/src/mutators/peephole.rs
@@ -309,6 +309,7 @@ impl PeepholeMutator {
                                     index: _,
                                     tpe: ty,
                                     mutable,
+                                    shared,
                                 } => {
                                     let (init, ty) = match ty {
                                         PrimitiveTypeInfo::I32 => {
@@ -329,8 +330,9 @@ impl PeepholeMutator {
                                         _ => unreachable!("Not valid for globals"),
                                     };
                                     let ty = wasm_encoder::GlobalType {
-                                        mutable: *mutable,
                                         val_type: ty,
+                                        mutable: *mutable,
+                                        shared: *shared,
                                     };
                                     // Add to globals
                                     new_global_section.global(ty, &init);
diff --git a/crates/wasm-mutate/src/mutators/peephole/eggsy/encoder/expr2wasm.rs b/crates/wasm-mutate/src/mutators/peephole/eggsy/encoder/expr2wasm.rs
@@ -23,6 +23,8 @@ pub enum ResourceRequest {
         tpe: PrimitiveTypeInfo,
         /// If its mutable
         mutable: bool,
+        /// If its shared
+        shared: bool,
     },
     // TODO add other needed resources here, for example, needed locals, needed
     // memory etc. Notice that how this resources are translated to Wasm code,
@@ -363,6 +365,7 @@ pub fn expr2wasm(
                             index: global_idx as usize,
                             tpe: PrimitiveTypeInfo::I32,
                             mutable: true,
+                            shared: false,
                         };
                         resources.push(request);
 
@@ -375,6 +378,7 @@ pub fn expr2wasm(
                             index: global_idx as usize,
                             tpe: PrimitiveTypeInfo::I64,
                             mutable: true,
+                            shared: false,
                         };
                         resources.push(request);
 
@@ -387,6 +391,7 @@ pub fn expr2wasm(
                             index: global_idx as usize,
                             tpe: PrimitiveTypeInfo::F32,
                             mutable: true,
+                            shared: false,
                         };
                         resources.push(request);
 
@@ -399,6 +404,7 @@ pub fn expr2wasm(
                             index: global_idx as usize,
                             tpe: PrimitiveTypeInfo::F64,
                             mutable: true,
+                            shared: false,
                         };
                         resources.push(request);
 
diff --git a/crates/wasm-mutate/src/mutators/translate.rs b/crates/wasm-mutate/src/mutators/translate.rs
@@ -170,6 +170,7 @@ pub fn global_type(
     Ok(wasm_encoder::GlobalType {
         val_type: t.translate_ty(&ty.content_type)?,
         mutable: ty.mutable,
+        shared: ty.shared,
     })
 }
 
diff --git a/crates/wasm-smith/src/component.rs b/crates/wasm-smith/src/component.rs
@@ -952,6 +952,7 @@ impl ComponentBuilder {
         Ok(crate::core::GlobalType {
             val_type: self.arbitrary_core_valtype(u)?,
             mutable: u.arbitrary()?,
+            shared: false,
         })
     }
 
diff --git a/crates/wasm-smith/src/core.rs b/crates/wasm-smith/src/core.rs
@@ -1424,6 +1424,7 @@ impl Module {
         Ok(GlobalType {
             val_type: self.arbitrary_valtype(u)?,
             mutable: u.arbitrary()?,
+            shared: false,
         })
     }
 
@@ -1756,6 +1757,7 @@ impl Module {
                         GlobalType {
                             val_type: convert_val_type(&global_type.content_type),
                             mutable: global_type.mutable,
+                            shared: global_type.shared,
                         },
                         u,
                     )?,
diff --git a/crates/wasm-smith/src/core/code_builder.rs b/crates/wasm-smith/src/core/code_builder.rs
@@ -870,6 +870,7 @@ impl CodeBuilderAllocations {
             module.globals.push(GlobalType {
                 val_type: ty,
                 mutable: true,
+                shared: false,
             });
             module.defined_globals.push((global_idx, init));
 
diff --git a/crates/wasm-smith/src/core/terminate.rs b/crates/wasm-smith/src/core/terminate.rs
@@ -23,6 +23,7 @@ impl Module {
         self.globals.push(GlobalType {
             val_type: ValType::I32,
             mutable: true,
+            shared: false,
         });
         self.defined_globals
             .push((fuel_global, ConstExpr::i32_const(default_fuel as i32)));
diff --git a/crates/wasmparser/src/readers/core/globals.rs b/crates/wasmparser/src/readers/core/globals.rs
@@ -37,13 +37,15 @@ impl<'a> FromReader<'a> for Global<'a> {
 
 impl<'a> FromReader<'a> for GlobalType {
     fn from_reader(reader: &mut BinaryReader<'a>) -> Result<Self> {
+        let content_type = reader.read()?;
+        let flags = reader.read_u8()?;
+        if flags > 0b11 {
+            bail!(reader.original_position() - 1, "malformed global flags")
+        }
         Ok(GlobalType {
-            content_type: reader.read()?,
-            mutable: match reader.read_u8()? {
-                0x00 => false,
-                0x01 => true,
-                _ => bail!(reader.original_position() - 1, "malformed mutability",),
-            },
+            content_type,
+            mutable: (flags & 0b01) > 0,
+            shared: (flags & 0b10) > 0,
         })
     }
 }
diff --git a/crates/wasmparser/src/readers/core/types.rs b/crates/wasmparser/src/readers/core/types.rs
@@ -1505,6 +1505,8 @@ pub struct GlobalType {
     pub content_type: ValType,
     /// Whether or not the global is mutable.
     pub mutable: bool,
+    /// Whether or not the global is shared.
+    pub shared: bool,
 }
 
 /// Represents a tag kind.
diff --git a/crates/wasmparser/src/validator.rs b/crates/wasmparser/src/validator.rs
@@ -1533,7 +1533,8 @@ mod tests {
             types.global_at(0),
             GlobalType {
                 content_type: ValType::I32,
-                mutable: true
+                mutable: true,
+                shared: false
             }
         );
 
diff --git a/crates/wasmparser/src/validator/core.rs b/crates/wasmparser/src/validator/core.rs
@@ -1027,6 +1027,12 @@ impl Module {
         features: &WasmFeatures,
         offset: usize,
     ) -> Result<()> {
+        if ty.shared && !features.shared_everything_threads {
+            return Err(BinaryReaderError::new(
+                "shared globals require the shared-everything-threads proposal",
+                offset,
+            ));
+        }
         self.check_value_type(&mut ty.content_type, features, offset)
     }
 
diff --git a/crates/wasmprinter/src/lib.rs b/crates/wasmprinter/src/lib.rs
@@ -1104,8 +1104,14 @@ impl Printer {
             self.print_name(&state.core.global_names, state.core.globals)?;
             self.result.push(' ');
         }
-        if ty.mutable {
-            self.result.push_str("(mut ");
+        if ty.shared || ty.mutable {
+            self.result.push('(');
+            if ty.shared {
+                self.result.push_str("shared ");
+            }
+            if ty.mutable {
+                self.result.push_str("mut ");
+            }
             self.print_valtype(state, ty.content_type)?;
             self.result.push(')');
         } else {
diff --git a/crates/wasmprinter/tests/all.rs b/crates/wasmprinter/tests/all.rs
@@ -277,3 +277,17 @@ fn no_panic_non_func_type() {
     .unwrap();
     wasmprinter::print_bytes(&bytes).unwrap();
 }
+
+#[test]
+fn shared_global() {
+    const MODULE: &str = r#"
+    (module
+        (global (;0;) (shared f32))
+    )"#;
+    let bytes = wat::parse_str(MODULE).unwrap();
+    let result = wasmprinter::print_bytes(&bytes).unwrap();
+    assert_eq!(
+        result.replace(" ", "").trim(),
+        MODULE.replace(" ", "").trim()
+    );
+}
diff --git a/crates/wast/src/component/binary.rs b/crates/wast/src/component/binary.rs
@@ -661,6 +661,7 @@ impl From<core::GlobalType<'_>> for wasm_encoder::GlobalType {
         Self {
             val_type: ty.ty.into(),
             mutable: ty.mutable,
+            shared: ty.shared,
         }
     }
 }
diff --git a/crates/wast/src/core/binary.rs b/crates/wast/src/core/binary.rs
@@ -493,11 +493,14 @@ impl Encode for MemoryType {
 impl<'a> Encode for GlobalType<'a> {
     fn encode(&self, e: &mut Vec<u8>) {
         self.ty.encode(e);
+        let mut flags = 0;
         if self.mutable {
-            e.push(0x01);
-        } else {
-            e.push(0x00);
+            flags |= 0b01;
+        }
+        if self.shared {
+            flags |= 0b10;
         }
+        e.push(flags);
     }
 }
 
diff --git a/crates/wast/src/core/types.rs b/crates/wast/src/core/types.rs
@@ -368,22 +368,35 @@ pub struct GlobalType<'a> {
     pub ty: ValType<'a>,
     /// Whether or not the global is mutable or not.
     pub mutable: bool,
+    /// Whether or not the global is shared.
+    pub shared: bool,
 }
 
 impl<'a> Parse<'a> for GlobalType<'a> {
     fn parse(parser: Parser<'a>) -> Result<Self> {
-        if parser.peek2::<kw::r#mut>()? {
+        if parser.peek2::<kw::shared>()? || parser.peek2::<kw::r#mut>()? {
             parser.parens(|p| {
-                p.parse::<kw::r#mut>()?;
+                let mut shared = false;
+                let mut mutable = false;
+                if p.peek::<kw::shared>()? {
+                    p.parse::<kw::shared>()?;
+                    shared = true;
+                }
+                if p.peek::<kw::r#mut>()? {
+                    p.parse::<kw::r#mut>()?;
+                    mutable = true;
+                }
                 Ok(GlobalType {
-                    ty: parser.parse()?,
-                    mutable: true,
+                    ty: p.parse()?,
+                    mutable,
+                    shared,
                 })
             })
         } else {
             Ok(GlobalType {
                 ty: parser.parse()?,
                 mutable: false,
+                shared: false,
             })
         }
     }
diff --git a/crates/wit-component/src/gc.rs b/crates/wit-component/src/gc.rs
@@ -615,8 +615,9 @@ impl<'a> Module<'a> {
         for (i, global) in self.live_globals() {
             map.globals.push(i);
             let ty = wasm_encoder::GlobalType {
-                mutable: global.ty.mutable,
                 val_type: map.valty(global.ty.content_type),
+                mutable: global.ty.mutable,
+                shared: global.ty.shared,
             };
             match &global.def {
                 Definition::Import(m, n) => {
diff --git a/crates/wit-component/src/linking.rs b/crates/wit-component/src/linking.rs
@@ -300,6 +300,7 @@ fn make_env_module<'a>(
                             EntityType::Global(wasm_encoder::GlobalType {
                                 val_type: ty.ty.into(),
                                 mutable: ty.mutable,
+                                shared: ty.shared,
                             })
                         }
                     },
@@ -348,6 +349,7 @@ fn make_env_module<'a>(
                 wasm_encoder::GlobalType {
                     val_type: ValType::I32,
                     mutable,
+                    shared: false,
                 },
                 &const_u32(value),
             );
@@ -575,6 +577,7 @@ fn make_init_module(
                     wasm_encoder::GlobalType {
                         val_type: ValType::I32,
                         mutable,
+                        shared: false,
                     },
                 );
                 get_and_increment(&mut global_count)
@@ -788,6 +791,7 @@ fn find_offset_exporter<'a>(
         ty: Type::Global(GlobalType {
             ty: ValueType::I32,
             mutable: false,
+            shared: false,
         }),
     };
 
@@ -896,6 +900,7 @@ fn resolve_symbols<'a>(
                         ty: Type::Global(GlobalType {
                             ty: ValueType::I32,
                             mutable: false,
+                            shared: false,
                         }),
                     },
                     flags: SymbolFlags::empty(),
diff --git a/crates/wit-component/src/linking/metadata.rs b/crates/wit-component/src/linking/metadata.rs
@@ -89,6 +89,7 @@ impl TryFrom<&FuncType> for FunctionType {
 pub struct GlobalType {
     pub ty: ValueType,
     pub mutable: bool,
+    pub shared: bool,
 }
 
 impl fmt::Display for GlobalType {
@@ -472,9 +473,11 @@ impl<'a> Metadata<'a> {
                                     TypeRef::Global(wasmparser::GlobalType {
                                         content_type,
                                         mutable,
+                                        shared,
                                     }) => Type::Global(GlobalType {
                                         ty: content_type.try_into()?,
                                         mutable,
+                                        shared,
                                     }),
                                     TypeRef::Func(ty) => Type::Function(FunctionType::try_from(
                                         &types[usize::try_from(ty).unwrap()],
@@ -537,6 +540,7 @@ impl<'a> Metadata<'a> {
                                         Type::Global(GlobalType {
                                             ty: ValueType::try_from(ty.content_type)?,
                                             mutable: ty.mutable,
+                                            shared: ty.shared,
                                         })
                                     }
                                     kind => {
diff --git a/tests/cli/dump/alias2.wat.stdout b/tests/cli/dump/alias2.wat.stdout
diff --git a/tests/cli/dump/module-types.wat.stdout b/tests/cli/dump/module-types.wat.stdout
diff --git a/tests/cli/dump/simple.wat.stdout b/tests/cli/dump/simple.wat.stdout
diff --git a/tests/local/missing-features/globals.wast b/tests/local/missing-features/globals.wast
diff --git a/tests/local/shared-everything-threads/global.wast b/tests/local/shared-everything-threads/global.wast
diff --git a/tests/roundtrip.rs b/tests/roundtrip.rs
diff --git a/tests/snapshots/local/missing-features/globals.wast.json b/tests/snapshots/local/missing-features/globals.wast.json
diff --git a/tests/snapshots/local/shared-everything-threads/global.wast.json b/tests/snapshots/local/shared-everything-threads/global.wast.json
diff --git a/tests/snapshots/local/shared-everything-threads/global.wast/0.print b/tests/snapshots/local/shared-everything-threads/global.wast/0.print

Original file line number	Diff line number	Diff line change
`@@ -170,6 +170,7 @@ pub fn global_type(`
`170`	`170`	`Ok(wasm_encoder::GlobalType {`
`171`	`171`	`val_type: t.translate_ty(&ty.content_type)?,`
`172`	`172`	`mutable: ty.mutable,`
	`173`	`+ shared: ty.shared,`
`173`	`174`	`})`
`174`	`175`	`}`
`175`	`176`
Original file line number	Diff line number	Diff line change
`@@ -952,6 +952,7 @@ impl ComponentBuilder {`
`952`	`952`	`Ok(crate::core::GlobalType {`
`953`	`953`	`val_type: self.arbitrary_core_valtype(u)?,`
`954`	`954`	`mutable: u.arbitrary()?,`
	`955`	`+ shared: false,`
`955`	`956`	`})`
`956`	`957`	`}`
`957`	`958`