Add the GC canonical option (#2182)

* Add the GC canonical option

Disallow using the `core-type` option without `gc`.

* require cm-gc feature

* fix test expectations

Author: fitzgen

crates/wasm-encoder/src/component/canonicals.rs

@@ -29,6 +29,8 @@ pub enum CanonicalOption {
     Callback(u32),
     /// The core function type to lower a component function into.
     CoreType(u32),
+    /// Use the GC variant of the canonical ABI.
+    Gc,
 }
 
 impl Encode for CanonicalOption {
@@ -60,6 +62,9 @@ impl Encode for CanonicalOption {
                 sink.push(0x08);
                 idx.encode(sink);
             }
+            Self::Gc => {
+                sink.push(0x09);
+            }
         }
     }
 }

crates/wasm-encoder/src/reencode/component.rs

@@ -1393,6 +1393,7 @@ pub mod component_utils {
             wasmparser::CanonicalOption::CoreType(u) => {
                 crate::component::CanonicalOption::CoreType(reencoder.type_index(u)?)
             }
+            wasmparser::CanonicalOption::Gc => crate::component::CanonicalOption::Gc,
         })
     }
 

crates/wasmparser/src/readers/component/canonicals.rs

@@ -30,6 +30,8 @@ pub enum CanonicalOption {
     Callback(u32),
     /// The core function type to lower this component function to.
     CoreType(u32),
+    /// Use the GC version of the canonical ABI.
+    Gc,
 }
 
 /// Represents a canonical function in a WebAssembly component.
@@ -404,6 +406,7 @@ impl<'a> FromReader<'a> for CanonicalOption {
             0x06 => CanonicalOption::Async,
             0x07 => CanonicalOption::Callback(reader.read_var_u32()?),
             0x08 => CanonicalOption::CoreType(reader.read_var_u32()?),
+            0x09 => CanonicalOption::Gc,
             x => return reader.invalid_leading_byte(x, "canonical option"),
         })
     }

crates/wasmparser/src/validator/component.rs

@@ -239,6 +239,7 @@ pub(crate) struct CanonicalOptions {
     pub(crate) post_return: Option<u32>,
     pub(crate) concurrency: Concurrency,
     pub(crate) core_type: Option<CoreTypeId>,
+    pub(crate) gc: bool,
 }
 
 impl CanonicalOptions {
@@ -304,6 +305,13 @@ impl CanonicalOptions {
             );
         }
 
+        if self.gc && self.core_type.is_none() {
+            bail!(
+                offset,
+                "cannot specify `gc` without also specifying a `core-type` for lowerings"
+            )
+        }
+
         Ok(self)
     }
 
@@ -2334,7 +2342,8 @@ impl ComponentState {
                 CanonicalOption::PostReturn(_) => "post-return",
                 CanonicalOption::Async => "async",
                 CanonicalOption::Callback(_) => "callback",
-                CanonicalOption::CoreType(_) => "core type",
+                CanonicalOption::CoreType(_) => "core-type",
+                CanonicalOption::Gc => "gc",
             }
         }
 
@@ -2345,6 +2354,7 @@ impl ComponentState {
         let mut is_async = false;
         let mut callback = None;
         let mut core_type = None;
+        let mut gc = false;
 
         for option in options {
             match option {
@@ -2475,6 +2485,21 @@ impl ComponentState {
                         }
                     };
                 }
+                CanonicalOption::Gc => {
+                    if gc {
+                        return Err(BinaryReaderError::new(
+                            "canonical option `gc` is specified more than once",
+                            offset,
+                        ));
+                    }
+                    if !self.features.cm_gc() {
+                        return Err(BinaryReaderError::new(
+                            "canonical option `gc` requires the `cm-gc` feature",
+                            offset,
+                        ));
+                    }
+                    gc = true;
+                }
             }
         }
 
@@ -2489,12 +2514,17 @@ impl ComponentState {
             (true, callback, false) => Concurrency::Async { callback },
         };
 
+        if !gc && core_type.is_some() {
+            bail!(offset, "cannot specify `core-type` without `gc`")
+        }
+
         Ok(CanonicalOptions {
             memory,
             realloc,
             post_return,
             concurrency,
             core_type,
+            gc,
         })
     }
 

crates/wasmprinter/src/component.rs

@@ -835,6 +835,7 @@ impl Printer<'_, '_> {
                     self.print_idx(&state.core.type_names, *idx)?;
                     self.end_group()?;
                 }
+                CanonicalOption::Gc => self.result.write_str("gc")?,
             }
         }
         Ok(())

crates/wast/src/component/binary.rs

@@ -976,6 +976,7 @@ impl From<&CanonOpt<'_>> for wasm_encoder::CanonicalOption {
             CanonOpt::Async => Self::Async,
             CanonOpt::Callback(f) => Self::Callback(f.idx.into()),
             CanonOpt::CoreType(t) => Self::CoreType(t.idx.into()),
+            CanonOpt::Gc => Self::Gc,
         }
     }
 }

crates/wast/src/component/func.rs

@@ -951,6 +951,8 @@ pub enum CanonOpt<'a> {
     Callback(CoreItemRef<'a, kw::func>),
     /// Lower this component function into the specified core function type.
     CoreType(CoreItemRef<'a, kw::r#type>),
+    /// Use the GC variant of the canonical ABI.
+    Gc,
 }
 
 impl Default for kw::r#type {
@@ -974,6 +976,9 @@ impl<'a> Parse<'a> for CanonOpt<'a> {
         } else if l.peek::<kw::r#async>()? {
             parser.parse::<kw::r#async>()?;
             Ok(Self::Async)
+        } else if l.peek::<kw::gc>()? {
+            parser.parse::<kw::gc>()?;
+            Ok(Self::Gc)
         } else if l.peek::<LParen>()? {
             parser.parens(|parser| {
                 let mut l = parser.lookahead1();
@@ -1015,6 +1020,7 @@ impl Peek for CanonOpt<'_> {
             || kw::string_utf16::peek(cursor)?
             || kw::string_latin1_utf16::peek(cursor)?
             || kw::r#async::peek(cursor)?
+            || kw::gc::peek(cursor)?
             || match cursor.lparen()? {
                 Some(next) => {
                     kw::memory::peek(next)?

crates/wast/src/component/resolve.rs

@@ -481,7 +481,8 @@ impl<'a> Resolver<'a> {
                 CanonOpt::StringUtf8
                 | CanonOpt::StringUtf16
                 | CanonOpt::StringLatin1Utf16
-                | CanonOpt::Async => {}
+                | CanonOpt::Async
+                | CanonOpt::Gc => {}
                 CanonOpt::Memory(r) => self.core_item_ref(r)?,
                 CanonOpt::Realloc(r) | CanonOpt::PostReturn(r) | CanonOpt::Callback(r) => {
                     self.core_item_ref(r)?

crates/wast/src/lib.rs

@@ -545,6 +545,7 @@ pub mod kw {
     custom_keyword!(with);
     custom_keyword!(core);
     custom_keyword!(core_type = "core-type");
+    custom_keyword!(gc);
     custom_keyword!(true_ = "true");
     custom_keyword!(false_ = "false");
     custom_keyword!(language);