Add GC feature flag (#3135)

dcodeIO · web-flow · commit e1d74ef2acdd · 2020-09-17T07:46:40.000+02:00
Adds the `--enable-gc` feature flag, so far enabling the `anyref` type incl. subtyping, and removes the temporary `--enable-anyref` feature flag that it replaces.
diff --git a/scripts/fuzz_opt.py b/scripts/fuzz_opt.py
@@ -404,7 +404,7 @@ def can_run(self, wasm):
                 if random.random() < 0.5:
                     return False
                 # wasm2c doesn't support most features
-                return all([x in FEATURE_OPTS for x in ['--disable-exception-handling', '--disable-simd', '--disable-threads', '--disable-bulk-memory', '--disable-nontrapping-float-to-int', '--disable-tail-call', '--disable-sign-ext', '--disable-reference-types', '--disable-multivalue', '--disable-anyref']])
+                return all([x in FEATURE_OPTS for x in ['--disable-exception-handling', '--disable-simd', '--disable-threads', '--disable-bulk-memory', '--disable-nontrapping-float-to-int', '--disable-tail-call', '--disable-sign-ext', '--disable-reference-types', '--disable-multivalue', '--disable-gc']])
 
             def run(self, wasm):
                 run([in_bin('wasm-opt'), wasm, '--emit-wasm2c-wrapper=main.c'] + FEATURE_OPTS)
@@ -504,7 +504,7 @@ def compare_before_and_after(self, before, after):
                 compare(before[vm], after[vm], 'CompareVMs between before and after: ' + vm.name)
 
     def can_run_on_feature_opts(self, feature_opts):
-        return all([x in feature_opts for x in ['--disable-simd', '--disable-reference-types', '--disable-exception-handling', '--disable-multivalue', '--disable-anyref']])
+        return all([x in feature_opts for x in ['--disable-simd', '--disable-reference-types', '--disable-exception-handling', '--disable-multivalue', '--disable-gc']])
 
 
 # Check for determinism - the same command must have the same output.
@@ -635,7 +635,7 @@ def run(self, wasm):
         return run_vm([shared.NODEJS, js_file, 'a.wasm'])
 
     def can_run_on_feature_opts(self, feature_opts):
-        return all([x in feature_opts for x in ['--disable-exception-handling', '--disable-simd', '--disable-threads', '--disable-bulk-memory', '--disable-nontrapping-float-to-int', '--disable-tail-call', '--disable-sign-ext', '--disable-reference-types', '--disable-multivalue', '--disable-anyref']])
+        return all([x in feature_opts for x in ['--disable-exception-handling', '--disable-simd', '--disable-threads', '--disable-bulk-memory', '--disable-nontrapping-float-to-int', '--disable-tail-call', '--disable-sign-ext', '--disable-reference-types', '--disable-multivalue', '--disable-gc']])
 
 
 class Asyncify(TestCaseHandler):
@@ -689,7 +689,7 @@ def do_asyncify(wasm):
         compare(before, after_asyncify, 'Asyncify (before/after_asyncify)')
 
     def can_run_on_feature_opts(self, feature_opts):
-        return all([x in feature_opts for x in ['--disable-exception-handling', '--disable-simd', '--disable-tail-call', '--disable-reference-types', '--disable-multivalue', '--disable-anyref']])
+        return all([x in feature_opts for x in ['--disable-exception-handling', '--disable-simd', '--disable-tail-call', '--disable-reference-types', '--disable-multivalue', '--disable-gc']])
 
 
 # The global list of all test case handlers
@@ -875,7 +875,7 @@ def randomize_opt_flags():
 # some features depend on other features, so if a required feature is
 # disabled, its dependent features need to be disabled as well.
 IMPLIED_FEATURE_OPTS = {
-    '--disable-reference-types': ['--disable-exception-handling', '--disable-anyref']
+    '--disable-reference-types': ['--disable-exception-handling', '--disable-gc']
 }
 
 if __name__ == '__main__':
diff --git a/src/binaryen-c.cpp b/src/binaryen-c.cpp
@@ -327,8 +327,8 @@ BinaryenFeatures BinaryenFeatureReferenceTypes(void) {
 BinaryenFeatures BinaryenFeatureMultivalue(void) {
   return static_cast<BinaryenFeatures>(FeatureSet::Multivalue);
 }
-BinaryenFeatures BinaryenFeatureAnyref(void) {
-  return static_cast<BinaryenFeatures>(FeatureSet::Anyref);
+BinaryenFeatures BinaryenFeatureGC(void) {
+  return static_cast<BinaryenFeatures>(FeatureSet::GC);
 }
 BinaryenFeatures BinaryenFeatureAll(void) {
   return static_cast<BinaryenFeatures>(FeatureSet::All);
diff --git a/src/binaryen-c.h b/src/binaryen-c.h
@@ -197,7 +197,7 @@ BINARYEN_API BinaryenFeatures BinaryenFeatureExceptionHandling(void);
 BINARYEN_API BinaryenFeatures BinaryenFeatureTailCall(void);
 BINARYEN_API BinaryenFeatures BinaryenFeatureReferenceTypes(void);
 BINARYEN_API BinaryenFeatures BinaryenFeatureMultivalue(void);
-BINARYEN_API BinaryenFeatures BinaryenFeatureAnyref(void);
+BINARYEN_API BinaryenFeatures BinaryenFeatureGC(void);
 BINARYEN_API BinaryenFeatures BinaryenFeatureAll(void);
 
 // Modules
diff --git a/src/js/binaryen.js-post.js b/src/js/binaryen.js-post.js
@@ -121,7 +121,7 @@ function initializeConstants() {
     'TailCall',
     'ReferenceTypes',
     'Multivalue',
-    'Anyref',
+    'GC',
     'All'
   ].forEach(name => {
     Module['Features'][name] = Module['_BinaryenFeature' + name]();
diff --git a/src/passes/InstrumentLocals.cpp b/src/passes/InstrumentLocals.cpp
@@ -198,7 +198,7 @@ struct InstrumentLocals : public WalkerPass<PostWalker<InstrumentLocals>> {
         addImport(
           curr, set_exnref, {Type::i32, Type::i32, Type::exnref}, Type::exnref);
       }
-      if (curr->features.hasAnyref()) {
+      if (curr->features.hasGC()) {
         addImport(
           curr, get_anyref, {Type::i32, Type::i32, Type::anyref}, Type::anyref);
         addImport(
diff --git a/src/tools/fuzzing.h b/src/tools/fuzzing.h
@@ -848,8 +848,7 @@ class TranslateToFuzzReader {
   }
 
   Expression* _makeConcrete(Type type) {
-    bool canMakeControlFlow =
-      !type.isTuple() || wasm.features.has(FeatureSet::Multivalue);
+    bool canMakeControlFlow = !type.isTuple() || wasm.features.hasMultivalue();
     using Self = TranslateToFuzzReader;
     FeatureOptions<Expression* (Self::*)(Type)> options;
     using WeightedOption = decltype(options)::WeightedOption;
@@ -2609,16 +2608,7 @@ class TranslateToFuzzReader {
   Expression* makeRefIsNull(Type type) {
     assert(type == Type::i32);
     assert(wasm.features.hasReferenceTypes());
-    SmallVector<Type, 2> options;
-    options.push_back(Type::externref);
-    options.push_back(Type::funcref);
-    if (wasm.features.hasExceptionHandling()) {
-      options.push_back(Type::exnref);
-    }
-    if (wasm.features.hasAnyref()) {
-      options.push_back(Type::anyref);
-    }
-    return builder.makeRefIsNull(make(pick(options)));
+    return builder.makeRefIsNull(make(getReferenceType()));
   }
 
   Expression* makeMemoryInit() {
@@ -2684,11 +2674,22 @@ class TranslateToFuzzReader {
         .add(FeatureSet::ReferenceTypes, Type::funcref, Type::externref)
         .add(FeatureSet::ReferenceTypes | FeatureSet::ExceptionHandling,
              Type::exnref)
-        .add(FeatureSet::ReferenceTypes | FeatureSet::Anyref, Type::anyref));
+        .add(FeatureSet::ReferenceTypes | FeatureSet::GC, Type::anyref));
   }
 
   Type getSingleConcreteType() { return pick(getSingleConcreteTypes()); }
 
+  std::vector<Type> getReferenceTypes() {
+    return items(
+      FeatureOptions<Type>()
+        .add(FeatureSet::ReferenceTypes, Type::funcref, Type::externref)
+        .add(FeatureSet::ReferenceTypes | FeatureSet::ExceptionHandling,
+             Type::exnref)
+        .add(FeatureSet::ReferenceTypes | FeatureSet::GC, Type::anyref));
+  }
+
+  Type getReferenceType() { return pick(getReferenceTypes()); }
+
   Type getTupleType() {
     std::vector<Type> elements;
     size_t numElements = 2 + upTo(MAX_TUPLE_SIZE - 1);
diff --git a/src/tools/tool-options.h b/src/tools/tool-options.h
@@ -87,7 +87,7 @@ struct ToolOptions : public Options {
       .addFeature(FeatureSet::TailCall, "tail call operations")
       .addFeature(FeatureSet::ReferenceTypes, "reference types")
       .addFeature(FeatureSet::Multivalue, "multivalue functions")
-      .addFeature(FeatureSet::Anyref, "anyref type (without GC)")
+      .addFeature(FeatureSet::GC, "garbage collection")
       .add("--no-validation",
            "-n",
            "Disables validation, assumes inputs are correct",
diff --git a/src/wasm-binary.h b/src/wasm-binary.h
@@ -383,7 +383,7 @@ extern const char* ExceptionHandlingFeature;
 extern const char* TailCallFeature;
 extern const char* ReferenceTypesFeature;
 extern const char* MultivalueFeature;
-extern const char* AnyrefFeature;
+extern const char* GCFeature;
 
 enum Subsection {
   NameModule = 0,
diff --git a/src/wasm-features.h b/src/wasm-features.h
@@ -36,7 +36,7 @@ struct FeatureSet {
     TailCall = 1 << 7,
     ReferenceTypes = 1 << 8,
     Multivalue = 1 << 9,
-    Anyref = 1 << 10,
+    GC = 1 << 10,
     All = (1 << 11) - 1
   };
 
@@ -62,8 +62,8 @@ struct FeatureSet {
         return "reference-types";
       case Multivalue:
         return "multivalue";
-      case Anyref:
-        return "anyref";
+      case GC:
+        return "gc";
       default:
         WASM_UNREACHABLE("unexpected feature");
     }
@@ -87,7 +87,7 @@ struct FeatureSet {
   bool hasTailCall() const { return (features & TailCall) != 0; }
   bool hasReferenceTypes() const { return (features & ReferenceTypes) != 0; }
   bool hasMultivalue() const { return (features & Multivalue) != 0; }
-  bool hasAnyref() const { return (features & Anyref) != 0; }
+  bool hasGC() const { return (features & GC) != 0; }
   bool hasAll() const { return (features & All) != 0; }
 
   void makeMVP() { features = MVP; }
@@ -104,7 +104,7 @@ struct FeatureSet {
   void setTailCall(bool v = true) { set(TailCall, v); }
   void setReferenceTypes(bool v = true) { set(ReferenceTypes, v); }
   void setMultivalue(bool v = true) { set(Multivalue, v); }
-  void setAnyref(bool v = true) { set(Anyref, v); }
+  void setGC(bool v = true) { set(GC, v); }
   void setAll(bool v = true) { features = v ? All : MVP; }
 
   void enable(const FeatureSet& other) { features |= other.features; }
diff --git a/src/wasm/wasm-binary.cpp b/src/wasm/wasm-binary.cpp
@@ -750,8 +750,8 @@ void WasmBinaryWriter::writeFeaturesSection() {
         return BinaryConsts::UserSections::ReferenceTypesFeature;
       case FeatureSet::Multivalue:
         return BinaryConsts::UserSections::MultivalueFeature;
-      case FeatureSet::Anyref:
-        return BinaryConsts::UserSections::AnyrefFeature;
+      case FeatureSet::GC:
+        return BinaryConsts::UserSections::GCFeature;
       default:
         WASM_UNREACHABLE("unexpected feature flag");
     }
@@ -2307,8 +2307,8 @@ void WasmBinaryBuilder::readFeatures(size_t payloadLen) {
         wasm.features.setReferenceTypes();
       } else if (name == BinaryConsts::UserSections::MultivalueFeature) {
         wasm.features.setMultivalue();
-      } else if (name == BinaryConsts::UserSections::AnyrefFeature) {
-        wasm.features.setAnyref();
+      } else if (name == BinaryConsts::UserSections::GCFeature) {
+        wasm.features.setGC();
       }
     }
   }
diff --git a/src/wasm/wasm-type.cpp b/src/wasm/wasm-type.cpp
@@ -454,7 +454,7 @@ FeatureSet Type::getFeatures() const {
       case Type::exnref:
         return FeatureSet::ReferenceTypes | FeatureSet::ExceptionHandling;
       case Type::anyref:
-        return FeatureSet::ReferenceTypes | FeatureSet::Anyref;
+        return FeatureSet::ReferenceTypes | FeatureSet::GC;
       default:
         return FeatureSet::MVP;
     }
diff --git a/src/wasm/wasm-validator.cpp b/src/wasm/wasm-validator.cpp
@@ -2478,10 +2478,10 @@ static void validateModule(Module& module, ValidationInfo& info) {
 }
 
 static void validateFeatures(Module& module, ValidationInfo& info) {
-  if (module.features.hasAnyref()) {
+  if (module.features.hasGC()) {
     info.shouldBeTrue(module.features.hasReferenceTypes(),
                       module.features,
-                      "--enable-anyref requires --enable-reference-types");
+                      "--enable-gc requires --enable-reference-types");
   }
   if (module.features.hasExceptionHandling()) { // implies exnref
     info.shouldBeTrue(
diff --git a/src/wasm/wasm.cpp b/src/wasm/wasm.cpp
@@ -45,7 +45,7 @@ const char* SIMD128Feature = "simd128";
 const char* TailCallFeature = "tail-call";
 const char* ReferenceTypesFeature = "reference-types";
 const char* MultivalueFeature = "multivalue";
-const char* AnyrefFeature = "anyref";
+const char* GCFeature = "gc";
 } // namespace UserSections
 } // namespace BinaryConsts
 
diff --git a/test/binaryen.js/kitchen-sink.js b/test/binaryen.js/kitchen-sink.js
@@ -106,7 +106,7 @@ function test_features() {
   console.log("Features.TailCall: " + binaryen.Features.TailCall);
   console.log("Features.ReferenceTypes: " + binaryen.Features.ReferenceTypes);
   console.log("Features.Multivalue: " + binaryen.Features.Multivalue);
-  console.log("Features.Anyref: " + binaryen.Features.Anyref);
+  console.log("Features.GC: " + binaryen.Features.GC);
   console.log("Features.All: " + binaryen.Features.All);
 }
 
diff --git a/test/binaryen.js/kitchen-sink.js.txt b/test/binaryen.js/kitchen-sink.js.txt
@@ -35,7 +35,7 @@ Features.ExceptionHandling: 64
 Features.TailCall: 128
 Features.ReferenceTypes: 256
 Features.Multivalue: 512
-Features.Anyref: 1024
+Features.GC: 1024
 Features.All: 2047
 InvalidId: 0
 BlockId: 1
diff --git a/test/example/c-api-kitchen-sink.c b/test/example/c-api-kitchen-sink.c
@@ -247,7 +247,7 @@ void test_features() {
   printf("BinaryenFeatureTailCall: %d\n", BinaryenFeatureTailCall());
   printf("BinaryenFeatureReferenceTypes: %d\n", BinaryenFeatureReferenceTypes());
   printf("BinaryenFeatureMultivalue: %d\n", BinaryenFeatureMultivalue());
-  printf("BinaryenFeatureAnyref: %d\n", BinaryenFeatureAnyref());
+  printf("BinaryenFeatureGC: %d\n", BinaryenFeatureGC());
   printf("BinaryenFeatureAll: %d\n", BinaryenFeatureAll());
 }
 
diff --git a/test/example/c-api-kitchen-sink.txt b/test/example/c-api-kitchen-sink.txt
@@ -21,7 +21,7 @@ BinaryenFeatureExceptionHandling: 64
 BinaryenFeatureTailCall: 128
 BinaryenFeatureReferenceTypes: 256
 BinaryenFeatureMultivalue: 512
-BinaryenFeatureAnyref: 1024
+BinaryenFeatureGC: 1024
 BinaryenFeatureAll: 2047
 (f32.neg
  (f32.const -33.61199951171875)
diff --git a/test/passes/strip-target-features_roundtrip_print-features_all-features.txt b/test/passes/strip-target-features_roundtrip_print-features_all-features.txt
@@ -8,7 +8,7 @@
 --enable-tail-call
 --enable-reference-types
 --enable-multivalue
---enable-anyref
+--enable-gc
 (module
  (type $none_=>_v128_externref (func (result v128 externref)))
  (func $foo (result v128 externref)
diff --git a/test/passes/translate-to-fuzz_all-features.txt b/test/passes/translate-to-fuzz_all-features.txt
diff --git a/test/unit/input/anyref_target_feature.wasm b/test/unit/input/anyref_target_feature.wasm
diff --git a/test/unit/input/gc_target_feature.wasm b/test/unit/input/gc_target_feature.wasm
diff --git a/test/unit/test_features.py b/test/unit/test_features.py

Original file line number	Diff line number	Diff line change
`@@ -327,8 +327,8 @@ BinaryenFeatures BinaryenFeatureReferenceTypes(void) {`
`327`	`327`	`BinaryenFeatures BinaryenFeatureMultivalue(void) {`
`328`	`328`	`return static_cast<BinaryenFeatures>(FeatureSet::Multivalue);`
`329`	`329`	`}`
`330`		`-BinaryenFeatures BinaryenFeatureAnyref(void) {`
`331`		`- return static_cast<BinaryenFeatures>(FeatureSet::Anyref);`
	`330`	`+BinaryenFeatures BinaryenFeatureGC(void) {`
	`331`	`+ return static_cast<BinaryenFeatures>(FeatureSet::GC);`
`332`	`332`	`}`
`333`	`333`	`BinaryenFeatures BinaryenFeatureAll(void) {`
`334`	`334`	`return static_cast<BinaryenFeatures>(FeatureSet::All);`
Original file line number	Diff line number	Diff line change
`@@ -198,7 +198,7 @@ struct InstrumentLocals : public WalkerPass<PostWalker<InstrumentLocals>> {`
`198`	`198`	`addImport(`
`199`	`199`	`curr, set_exnref, {Type::i32, Type::i32, Type::exnref}, Type::exnref);`
`200`	`200`	`}`
`201`		`- if (curr->features.hasAnyref()) {`
	`201`	`+ if (curr->features.hasGC()) {`
`202`	`202`	`addImport(`
`203`	`203`	`curr, get_anyref, {Type::i32, Type::i32, Type::anyref}, Type::anyref);`
`204`	`204`	`addImport(`
Original file line number	Diff line number	Diff line change
`@@ -750,8 +750,8 @@ void WasmBinaryWriter::writeFeaturesSection() {`
`750`	`750`	`return BinaryConsts::UserSections::ReferenceTypesFeature;`
`751`	`751`	`case FeatureSet::Multivalue:`
`752`	`752`	`return BinaryConsts::UserSections::MultivalueFeature;`
`753`		`- case FeatureSet::Anyref:`
`754`		`- return BinaryConsts::UserSections::AnyrefFeature;`
	`753`	`+ case FeatureSet::GC:`
	`754`	`+ return BinaryConsts::UserSections::GCFeature;`
`755`	`755`	`default:`
`756`	`756`	`WASM_UNREACHABLE("unexpected feature flag");`
`757`	`757`	`}`
`@@ -2307,8 +2307,8 @@ void WasmBinaryBuilder::readFeatures(size_t payloadLen) {`
`2307`	`2307`	`wasm.features.setReferenceTypes();`
`2308`	`2308`	`} else if (name == BinaryConsts::UserSections::MultivalueFeature) {`
`2309`	`2309`	`wasm.features.setMultivalue();`
`2310`		`- } else if (name == BinaryConsts::UserSections::AnyrefFeature) {`
`2311`		`- wasm.features.setAnyref();`
	`2310`	`+ } else if (name == BinaryConsts::UserSections::GCFeature) {`
	`2311`	`+ wasm.features.setGC();`
`2312`	`2312`	`}`
`2313`	`2313`	`}`
`2314`	`2314`	`}`