Bug 1488205 - Remove gc_feature_opt_in from reftypes-only tests. r=jseward
authorLars T Hansen <lhansen@mozilla.com>
Fri, 01 Mar 2019 14:17:18 +0100
changeset 462771 80c1ab6a0f32412c406d1eb581ea667d023f8742
parent 462770 f84b1b428d4298326511fbdb527c0029e5cdf638
child 462772 8085449bd4261f957dff79032f75d95b94fab787
push id112328
push userlhansen@mozilla.com
push dateThu, 07 Mar 2019 08:55:15 +0000
treeherdermozilla-inbound@8085449bd426 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersjseward
bugs1488205
milestone67.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1488205 - Remove gc_feature_opt_in from reftypes-only tests. r=jseward Differential Revision: https://phabricator.services.mozilla.com/D21691
js/src/jit-test/tests/wasm/gc/anyref-boxing.js
js/src/jit-test/tests/wasm/gc/anyref-global-postbarrier.js
js/src/jit-test/tests/wasm/gc/anyref-global-prebarrier.js
js/src/jit-test/tests/wasm/gc/anyref-val-tracing.js
js/src/jit-test/tests/wasm/gc/anyref.js
js/src/jit-test/tests/wasm/gc/debugger.js
js/src/jit-test/tests/wasm/gc/disabled.js
js/src/jit-test/tests/wasm/gc/gc-feature-opt-in.js
js/src/jit-test/tests/wasm/gc/ion-and-baseline.js
js/src/jit-test/tests/wasm/gc/ref-restrict.js
js/src/jit-test/tests/wasm/gc/stackmaps1.js
js/src/jit-test/tests/wasm/gc/stackmaps2.js
js/src/jit-test/tests/wasm/gc/stackmaps3.js
js/src/jit-test/tests/wasm/gc/tables-generalized.js
js/src/jit-test/tests/wasm/gc/tables-multiple.js
js/src/jit-test/tests/wasm/gc/tables-stress.js
--- a/js/src/jit-test/tests/wasm/gc/anyref-boxing.js
+++ b/js/src/jit-test/tests/wasm/gc/anyref-boxing.js
@@ -53,32 +53,30 @@ for (let v of VALUES)
 
 // Set via initialization, then read via get_global and returned
 
 for (let v of VALUES)
 {
     let g = new WebAssembly.Global({value: "anyref"}, v);
     let ins = wasmEvalText(
         `(module
-           (gc_feature_opt_in 3)
            (import $glob "m" "g" (global anyref))
            (func (export "f") (result anyref)
              (get_global $glob)))`,
         {m:{g}});
     assertEq(ins.exports.f(), v);
 }
 
 // Set via set_global, then read via 'value'
 
 for (let v of VALUES)
 {
     let g = new WebAssembly.Global({value: "anyref", mutable: true});
     let ins = wasmEvalText(
         `(module
-           (gc_feature_opt_in 3)
            (import $glob "m" "g" (global (mut anyref)))
            (func (export "f") (param $v anyref)
              (set_global $glob (get_local $v))))`,
         {m:{g}});
     ins.exports.f(v);
     assertEq(g.value, v);
 }
 
@@ -107,33 +105,31 @@ for (let v of VALUES)
 
 // write with table.set, read with .get()
 
 for (let v of VALUES)
 {
     let t = new WebAssembly.Table({element: "anyref", initial: 10});
     let ins = wasmEvalText(
         `(module
-           (gc_feature_opt_in 3)
            (import $t "m" "t" (table 10 anyref))
            (func (export "f") (param $v anyref)
              (table.set $t (i32.const 3) (get_local $v))))`,
         {m:{t}});
     ins.exports.f(v);
     assertEq(t.get(3), v);
 }
 
 // write with .set(), read with table.get
 
 for (let v of VALUES)
 {
     let t = new WebAssembly.Table({element: "anyref", initial: 10});
     let ins = wasmEvalText(
         `(module
-           (gc_feature_opt_in 3)
            (import $t "m" "t" (table 10 anyref))
            (func (export "f") (result anyref)
              (table.get $t (i32.const 3))))`,
         {m:{t}});
     t.set(3, v);
     assertEq(ins.exports.f(), v);
 }
 
@@ -141,17 +137,16 @@ for (let v of VALUES)
 // them.
 
 for (let v of VALUES)
 {
     let returner = function () { return v; };
     let receiver = function (w) { assertEq(w, v); };
     let ins = wasmEvalText(
         `(module
-           (gc_feature_opt_in 3)
            (import $returner "m" "returner" (func (result anyref)))
            (import $receiver "m" "receiver" (func (param anyref)))
            (func (export "test_returner") (result anyref)
              (call $returner))
            (func (export "test_receiver") (param $v anyref)
              (call $receiver (get_local $v))))`,
         {m:{returner, receiver}});
     assertEq(ins.exports.test_returner(), v);
--- a/js/src/jit-test/tests/wasm/gc/anyref-global-postbarrier.js
+++ b/js/src/jit-test/tests/wasm/gc/anyref-global-postbarrier.js
@@ -5,37 +5,34 @@ const { startProfiling, endProfiling, as
 // Dummy constructor.
 function Baguette(calories) {
     this.calories = calories;
 }
 
 // Ensure the baseline compiler sync's before the postbarrier.
 (function() {
     wasmEvalText(`(module
-        (gc_feature_opt_in 3)
         (global (mut anyref) (ref.null))
         (func (export "f")
             get_global 0
             ref.null
             set_global 0
             set_global 0
         )
     )`).exports.f();
 })();
 
 let exportsPlain = wasmEvalText(`(module
-    (gc_feature_opt_in 3)
     (global i32 (i32.const 42))
     (global $g (mut anyref) (ref.null))
     (func (export "set") (param anyref) get_local 0 set_global $g)
     (func (export "get") (result anyref) get_global $g)
 )`).exports;
 
 let exportsObj = wasmEvalText(`(module
-    (gc_feature_opt_in 3)
     (global $g (export "g") (mut anyref) (ref.null))
     (func (export "set") (param anyref) get_local 0 set_global $g)
     (func (export "get") (result anyref) get_global $g)
 )`).exports;
 
 // 7 => Generational GC zeal.
 gczeal(7, 1);
 
--- a/js/src/jit-test/tests/wasm/gc/anyref-global-prebarrier.js
+++ b/js/src/jit-test/tests/wasm/gc/anyref-global-prebarrier.js
@@ -5,17 +5,16 @@
 
 opts = getJitCompilerOptions();
 if (opts['ion.enable'] || opts['baseline.enable'])
   quit();
 
 const { startProfiling, endProfiling, assertEqPreciseStacks, isSingleStepProfilingEnabled } = WasmHelpers;
 
 let e = wasmEvalText(`(module
-    (gc_feature_opt_in 3)
     (global $g (mut anyref) (ref.null))
     (func (export "set") (param anyref) get_local 0 set_global $g)
 )`).exports;
 
 let obj = { field: null };
 
 // GCZeal mode 4 implies that prebarriers are being verified at many
 // locations in the interpreter, during interrupt checks, etc. It can be ultra
--- a/js/src/jit-test/tests/wasm/gc/anyref-val-tracing.js
+++ b/js/src/jit-test/tests/wasm/gc/anyref-val-tracing.js
@@ -1,13 +1,12 @@
 // |jit-test| skip-if: !wasmReftypesEnabled()
 
 gczeal(14, 1);
 let { exports } = wasmEvalText(`(module
-    (gc_feature_opt_in 3)
     (global $anyref (import "glob" "anyref") anyref)
     (func (export "get") (result anyref) get_global $anyref)
 )`, {
     glob: {
         anyref: { sentinel: "lol" },
     }
 });
 assertEq(exports.get().sentinel, "lol");
--- a/js/src/jit-test/tests/wasm/gc/anyref.js
+++ b/js/src/jit-test/tests/wasm/gc/anyref.js
@@ -5,67 +5,63 @@ function Baguette(calories) {
     this.calories = calories;
 }
 
 // Type checking.
 
 const { validate, CompileError } = WebAssembly;
 
 assertErrorMessage(() => wasmEvalText(`(module
-    (gc_feature_opt_in 3)
     (func (result anyref)
         i32.const 42
     )
 )`), CompileError, mismatchError('i32', 'anyref'));
 
 assertErrorMessage(() => wasmEvalText(`(module
-    (gc_feature_opt_in 3)
     (func (result anyref)
         i32.const 0
         ref.null
         i32.const 42
         select
     )
 )`), CompileError, /select operand types/);
 
 assertErrorMessage(() => wasmEvalText(`(module
-    (gc_feature_opt_in 3)
     (func (result i32)
         ref.null
         if
             i32.const 42
         end
     )
 )`), CompileError, mismatchError('nullref', 'i32'));
 
 
 // Basic compilation tests.
 
 let simpleTests = [
-    "(module (gc_feature_opt_in 3) (func (drop (ref.null))))",
-    "(module (gc_feature_opt_in 3) (func $test (local anyref)))",
-    "(module (gc_feature_opt_in 3) (func $test (param anyref)))",
-    "(module (gc_feature_opt_in 3) (func $test (result anyref) (ref.null)))",
-    "(module (gc_feature_opt_in 3) (func $test (block anyref (unreachable)) unreachable))",
-    "(module (gc_feature_opt_in 3) (func $test (local anyref) (result i32) (ref.is_null (get_local 0))))",
-    `(module (gc_feature_opt_in 3) (import "a" "b" (param anyref)))`,
-    `(module (gc_feature_opt_in 3) (import "a" "b" (result anyref)))`,
-    `(module (gc_feature_opt_in 3) (global anyref (ref.null)))`,
-    `(module (gc_feature_opt_in 3) (global (mut anyref) (ref.null)))`,
+    "(module (func (drop (ref.null))))",
+    "(module (func $test (local anyref)))",
+    "(module (func $test (param anyref)))",
+    "(module (func $test (result anyref) (ref.null)))",
+    "(module (func $test (block anyref (unreachable)) unreachable))",
+    "(module (func $test (local anyref) (result i32) (ref.is_null (get_local 0))))",
+    `(module (import "a" "b" (param anyref)))`,
+    `(module (import "a" "b" (result anyref)))`,
+    `(module (global anyref (ref.null)))`,
+    `(module (global (mut anyref) (ref.null)))`,
 ];
 
 for (let src of simpleTests) {
     wasmEvalText(src, {a:{b(){}}});
     assertEq(validate(wasmTextToBinary(src)), true);
 }
 
 // Basic behavioral tests.
 
 let { exports } = wasmEvalText(`(module
-    (gc_feature_opt_in 3)
     (func (export "is_null") (result i32)
         ref.null
         ref.is_null
     )
 
     (func $sum (result i32) (param i32)
         get_local 0
         i32.const 42
@@ -93,17 +89,16 @@ let { exports } = wasmEvalText(`(module
 
 assertEq(exports.is_null(), 1);
 assertEq(exports.is_null_spill(), 1);
 assertEq(exports.is_null_local(), 1);
 
 // Anyref param and result in wasm functions.
 
 exports = wasmEvalText(`(module
-    (gc_feature_opt_in 3)
     (func (export "is_null") (result i32) (param $ref anyref)
         get_local $ref
         ref.is_null
     )
 
     (func (export "ref_or_null") (result anyref) (param $ref anyref) (param $selector i32)
         get_local $ref
         ref.null
@@ -151,33 +146,31 @@ assertEq(ref.calories, baguette.calories
 
 ref = exports.nested(baguette, 0);
 assertEq(ref, baguette);
 assertEq(ref.calories, baguette.calories);
 
 // Make sure grow-memory isn't blocked by the lack of gc.
 (function() {
     assertEq(wasmEvalText(`(module
-    (gc_feature_opt_in 3)
     (memory 0 64)
     (func (export "f") (param anyref) (result i32)
         i32.const 10
         memory.grow
         drop
         memory.size
     )
 )`).exports.f({}), 10);
 })();
 
 // More interesting use cases about control flow joins.
 
 function assertJoin(body) {
     let val = { i: -1 };
     assertEq(wasmEvalText(`(module
-        (gc_feature_opt_in 3)
         (func (export "test") (param $ref anyref) (param $i i32) (result anyref)
             ${body}
         )
     )`).exports.test(val), val);
     assertEq(val.i, -1);
 }
 
 assertJoin("(block anyref get_local $ref)");
@@ -234,17 +227,16 @@ assertJoin(`(block $out anyref (block $u
     i32.add
     tee_local $i
     br_table $unreachable $out
     ) unreachable))
 `);
 
 let x = { i: 42 }, y = { f: 53 };
 exports = wasmEvalText(`(module
-    (gc_feature_opt_in 3)
     (func (export "test") (param $lhs anyref) (param $rhs anyref) (param $i i32) (result anyref)
         get_local $lhs
         get_local $rhs
         get_local $i
         select
     )
 )`).exports;
 
@@ -289,17 +281,16 @@ let imports = {
         },
         ret() {
             return imports.myBaguette;
         }
     }
 };
 
 exports = wasmEvalText(`(module
-    (gc_feature_opt_in 3)
     (import $ret "funcs" "ret" (result anyref))
     (import $param "funcs" "param" (param anyref))
 
     (func (export "param") (param $x anyref) (param $y anyref)
         get_local $y
         get_local $x
         call $param
         call $param
@@ -318,17 +309,16 @@ imports.myBaguette = null;
 assertEq(exports.ret(), null);
 
 imports.myBaguette = new Baguette(1337);
 assertEq(exports.ret(), imports.myBaguette);
 
 // Check lazy stubs generation.
 
 exports = wasmEvalText(`(module
-    (gc_feature_opt_in 3)
     (import $mirror "funcs" "mirror" (param anyref) (result anyref))
     (import $augment "funcs" "augment" (param anyref) (result anyref))
 
     (global $count_f (mut i32) (i32.const 0))
     (global $count_g (mut i32) (i32.const 0))
 
     (func $f (param $param anyref) (result anyref)
         i32.const 1
@@ -402,35 +392,34 @@ assertEq(x.i, 24);
 assertEq(x.newProp, "hello");
 assertEq(exports.count_f(), 1);
 assertEq(exports.count_g(), 1);
 
 // Globals.
 
 // Anyref globals in wasm modules.
 
-assertErrorMessage(() => wasmEvalText(`(module (gc_feature_opt_in 3) (global (import "glob" "anyref") anyref))`, { glob: { anyref: new WebAssembly.Global({ value: 'i32' }, 42) } }),
+assertErrorMessage(() => wasmEvalText(`(module (global (import "glob" "anyref") anyref))`, { glob: { anyref: new WebAssembly.Global({ value: 'i32' }, 42) } }),
     WebAssembly.LinkError,
     /imported global type mismatch/);
 
-assertErrorMessage(() => wasmEvalText(`(module (gc_feature_opt_in 3) (global (import "glob" "i32") i32))`, { glob: { i32: {} } }),
+assertErrorMessage(() => wasmEvalText(`(module (global (import "glob" "i32") i32))`, { glob: { i32: {} } }),
     WebAssembly.LinkError,
     /import object field 'i32' is not a Number/);
 
 imports = {
     constants: {
         imm_null: null,
         imm_bread: new Baguette(321),
         mut_null: new WebAssembly.Global({ value: "anyref", mutable: true }, null),
         mut_bread: new WebAssembly.Global({ value: "anyref", mutable: true }, new Baguette(123))
     }
 };
 
 exports = wasmEvalText(`(module
-    (gc_feature_opt_in 3)
     (global $g_imp_imm_null  (import "constants" "imm_null") anyref)
     (global $g_imp_imm_bread (import "constants" "imm_bread") anyref)
 
     (global $g_imp_mut_null   (import "constants" "mut_null") (mut anyref))
     (global $g_imp_mut_bread  (import "constants" "mut_bread") (mut anyref))
 
     (global $g_imm_null     anyref (ref.null))
     (global $g_imm_getglob  anyref (get_global $g_imp_imm_bread))
--- a/js/src/jit-test/tests/wasm/gc/debugger.js
+++ b/js/src/jit-test/tests/wasm/gc/debugger.js
@@ -1,23 +1,22 @@
 // |jit-test| skip-if: !wasmReftypesEnabled() || !wasmDebuggingIsSupported()
 
 (function() {
     let g = newGlobal({newCompartment: true});
     let dbg = new Debugger(g);
-    g.eval(`o = new WebAssembly.Instance(new WebAssembly.Module(wasmTextToBinary('(module (gc_feature_opt_in 3) (func (result anyref) (param anyref) get_local 0) (export "" 0))')));`);
+    g.eval(`o = new WebAssembly.Instance(new WebAssembly.Module(wasmTextToBinary('(module (func (result anyref) (param anyref) get_local 0) (export "" 0))')));`);
 })();
 
 (function() {
     var g = newGlobal({newCompartment: true});
     g.parent = this;
 
     let src = `
       (module
-        (gc_feature_opt_in 3)
         (func (export "func") (result anyref) (param $ref anyref)
             get_local $ref
         )
       )
     `;
 
     g.eval(`
         var obj = { somekey: 'somevalue' };
--- a/js/src/jit-test/tests/wasm/gc/disabled.js
+++ b/js/src/jit-test/tests/wasm/gc/disabled.js
@@ -1,24 +1,24 @@
 // |jit-test| skip-if: wasmReftypesEnabled()
 
 const { CompileError, validate } = WebAssembly;
 
 const UNRECOGNIZED_OPCODE_OR_BAD_TYPE = /unrecognized opcode|(Structure|reference) types not enabled|invalid inline block type/;
 
 let simpleTests = [
-    "(module (gc_feature_opt_in 3) (func (drop (ref.null))))",
-    "(module (gc_feature_opt_in 3) (func $test (local anyref)))",
-    "(module (gc_feature_opt_in 3) (func $test (param anyref)))",
-    "(module (gc_feature_opt_in 3) (func $test (result anyref) (ref.null)))",
-    "(module (gc_feature_opt_in 3) (func $test (block anyref (unreachable)) unreachable))",
-    "(module (gc_feature_opt_in 3) (func $test (local anyref) (result i32) (ref.is_null (get_local 0))))",
-    `(module (gc_feature_opt_in 3) (import "a" "b" (param anyref)))`,
-    `(module (gc_feature_opt_in 3) (import "a" "b" (result anyref)))`,
-    `(module (gc_feature_opt_in 3) (type $s (struct)))`,
+    "(module (func (drop (ref.null))))",
+    "(module (func $test (local anyref)))",
+    "(module (func $test (param anyref)))",
+    "(module (func $test (result anyref) (ref.null)))",
+    "(module (func $test (block anyref (unreachable)) unreachable))",
+    "(module (func $test (local anyref) (result i32) (ref.is_null (get_local 0))))",
+    `(module (import "a" "b" (param anyref)))`,
+    `(module (import "a" "b" (result anyref)))`,
+    `(module (type $s (struct)))`,
 ];
 
 // Two distinct failure modes:
 //
 // - if we have no compiled-in support for wasm-gc we'll get a syntax error when
 //   parsing the test programs that use ref types and structures.
 //
 // - if we have compiled-in support for wasm-gc, then there are several cases
--- a/js/src/jit-test/tests/wasm/gc/gc-feature-opt-in.js
+++ b/js/src/jit-test/tests/wasm/gc/gc-feature-opt-in.js
@@ -41,88 +41,77 @@ assertErrorMessage(() => new WebAssembly
                    /GC feature version.*no longer supported by this engine/);
 
 assertErrorMessage(() => new WebAssembly.Module(wasmTextToBinary(
     `(module
       (gc_feature_opt_in ${SOME_FUTURE_VERSION}))`)),
                    WebAssembly.CompileError,
                    /GC feature version is unknown/);
 
-// Parameters of ref type are only available if we opt in.
+// Parameters of anyref type are available regardless of whether we opt in.
 
 new WebAssembly.Module(wasmTextToBinary(
     `(module
       (gc_feature_opt_in ${CURRENT_VERSION})
       (type (func (param anyref))))`));
 
-assertErrorMessage(() => new WebAssembly.Module(wasmTextToBinary(
+new WebAssembly.Module(wasmTextToBinary(
     `(module
-      (type (func (param anyref))))`)),
-                   WebAssembly.CompileError,
-                   /reference types not enabled/);
+      (type (func (param anyref))))`));
 
 // Ditto returns
 
 new WebAssembly.Module(wasmTextToBinary(
     `(module
       (gc_feature_opt_in ${CURRENT_VERSION})
       (type (func (result anyref))))`));
 
-assertErrorMessage(() => new WebAssembly.Module(wasmTextToBinary(
+new WebAssembly.Module(wasmTextToBinary(
     `(module
-      (type (func (result anyref))))`)),
-                   WebAssembly.CompileError,
-                   /reference types not enabled/);
+      (type (func (result anyref))))`));
 
 // Ditto locals
 
 new WebAssembly.Module(wasmTextToBinary(
     `(module
       (gc_feature_opt_in ${CURRENT_VERSION})
       (func (result i32)
        (local anyref)
        (i32.const 0)))`));
 
-assertErrorMessage(() => new WebAssembly.Module(wasmTextToBinary(
+new WebAssembly.Module(wasmTextToBinary(
     `(module
       (func (result i32)
        (local anyref)
-       (i32.const 0)))`)),
-                   WebAssembly.CompileError,
-                   /reference types not enabled/);
+       (i32.const 0)))`));
 
 // Ditto globals
 
 new WebAssembly.Module(wasmTextToBinary(
     `(module
       (gc_feature_opt_in ${CURRENT_VERSION})
       (global (mut anyref) (ref.null)))`));
 
-assertErrorMessage(() => new WebAssembly.Module(wasmTextToBinary(
+new WebAssembly.Module(wasmTextToBinary(
     `(module
-      (global (mut anyref) (ref.null)))`)),
-                   WebAssembly.CompileError,
-                   /reference types not enabled/);
+      (global (mut anyref) (ref.null)))`));
 
-// Ref instructions are only available if we opt in.
+// ref.null and ref.is_null are available whetehr we opt in or not, but ref.eq
+// only if we opt in
 //
 // When testing these we need to avoid struct types or parameters, locals,
 // returns, or globals of ref type, or guards on those will preempt the guards
 // on the instructions.
 
-assertErrorMessage(() => new WebAssembly.Module(wasmTextToBinary(
+new WebAssembly.Module(wasmTextToBinary(
     `(module
-      (func ref.null))`)),
-                   WebAssembly.CompileError,
-                   /unrecognized opcode/);
+      (func (result anyref) ref.null))`));
 
-assertErrorMessage(() => new WebAssembly.Module(wasmTextToBinary(
+new WebAssembly.Module(wasmTextToBinary(
     `(module
-      (func ref.is_null))`)),
-                   WebAssembly.CompileError,
-                   /unrecognized opcode/);
+      (func (param anyref) (result i32) (ref.is_null (local.get 0))))`));
 
 assertErrorMessage(() => new WebAssembly.Module(wasmTextToBinary(
     `(module
       (func ref.eq))`)),
                    WebAssembly.CompileError,
                    /unrecognized opcode/);
 
--- a/js/src/jit-test/tests/wasm/gc/ion-and-baseline.js
+++ b/js/src/jit-test/tests/wasm/gc/ion-and-baseline.js
@@ -15,18 +15,16 @@
 // Ion can't talk about references yet *but* we can call indirect from Ion to a
 // baseline module that has exported a function that accepts or returns anyref,
 // without the caller knowing this or having to declare it.  All such calls
 // should fail in an orderly manner with a type mismatch, at the point of the
 // call.
 
 var refmod = new WebAssembly.Module(wasmTextToBinary(
     `(module
-      (gc_feature_opt_in 3)
-
       (import $tbl "" "tbl" (table 4 funcref))
       (import $print "" "print" (func (param i32)))
 
       (type $htype (func (param anyref)))
       (type $itype (func (result anyref)))
 
       (elem (i32.const 0) $f $g)
 
--- a/js/src/jit-test/tests/wasm/gc/ref-restrict.js
+++ b/js/src/jit-test/tests/wasm/gc/ref-restrict.js
@@ -54,65 +54,61 @@ assertErrorMessage(() => wasmCompile(
       (gc_feature_opt_in 3)
       (type $box (struct (field $x i32)))
       (func (export "f") (param (ref $box)) (unreachable)))`),
                    WebAssembly.CompileError,
                    /cannot expose reference type/);
 
 assertEq(typeof wasmCompile(
     `(module
-      (gc_feature_opt_in 3)
       (func (export "f") (param anyref) (unreachable)))`),
          "object");
 
 // Exported function can't return ref result, but anyref is OK.
 
 assertErrorMessage(() => wasmCompile(
     `(module
       (gc_feature_opt_in 3)
       (type $box (struct (field $x i32)))
       (func (export "f") (result (ref $box)) (ref.null)))`),
                    WebAssembly.CompileError,
                    /cannot expose reference type/);
 
 assertEq(typeof wasmCompile(
     `(module
-      (gc_feature_opt_in 3)
       (func (export "f") (result anyref) (ref.null)))`),
          "object");
 
 // Imported function can't take ref parameter, but anyref is OK.
 
 assertErrorMessage(() => wasmCompile(
     `(module
       (gc_feature_opt_in 3)
       (type $box (struct (field $x i32)))
       (import "m" "f" (param (ref $box))))`),
                    WebAssembly.CompileError,
                    /cannot expose reference type/);
 
 assertEq(typeof wasmCompile(
     `(module
-      (gc_feature_opt_in 3)
       (import "m" "f" (param anyref)))`),
          "object");
 
 // Imported function can't return ref type, but anyref is OK.
 
 assertErrorMessage(() => wasmCompile(
     `(module
       (gc_feature_opt_in 3)
       (type $box (struct (field $x i32)))
       (import "m" "f" (param i32) (result (ref $box))))`),
                    WebAssembly.CompileError,
                    /cannot expose reference type/);
 
 assertEq(typeof wasmCompile(
     `(module
-      (gc_feature_opt_in 3)
       (import "m" "f" (param i32) (result anyref)))`),
          "object");
 
 // Imported global can't be of Ref type (irrespective of mutability), though anyref is OK.
 
 assertErrorMessage(() => wasmCompile(
     `(module
       (gc_feature_opt_in 3)
@@ -126,23 +122,21 @@ assertErrorMessage(() => wasmCompile(
       (gc_feature_opt_in 3)
       (type $box (struct (field $val i32)))
       (import "m" "g" (global (ref $box))))`),
                    WebAssembly.CompileError,
                    /cannot expose reference type/);
 
 assertEq(typeof wasmCompile(
     `(module
-      (gc_feature_opt_in 3)
       (import "m" "g" (global (mut anyref))))`),
          "object");
 
 assertEq(typeof wasmCompile(
     `(module
-      (gc_feature_opt_in 3)
       (import "m" "g" (global anyref)))`),
          "object");
 
 // Exported global can't be of Ref type (irrespective of mutability), though anyref is OK.
 
 assertErrorMessage(() => wasmCompile(
     `(module
       (gc_feature_opt_in 3)
@@ -156,23 +150,21 @@ assertErrorMessage(() => wasmCompile(
       (gc_feature_opt_in 3)
       (type $box (struct (field $val i32)))
       (global $boxg (export "box") (ref $box) (ref.null)))`),
                    WebAssembly.CompileError,
                    /cannot expose reference type/);
 
 assertEq(typeof wasmCompile(
     `(module
-      (gc_feature_opt_in 3)
       (global $boxg (export "box") (mut anyref) (ref.null)))`),
          "object");
 
 assertEq(typeof wasmCompile(
     `(module
-      (gc_feature_opt_in 3)
       (global $boxg (export "box") anyref (ref.null)))`),
          "object");
 
 // Exported table cannot reference functions that are exposed for Ref, but anyref is OK.
 
 assertErrorMessage(() => wasmCompile(
     `(module
       (gc_feature_opt_in 3)
@@ -190,25 +182,23 @@ assertErrorMessage(() => wasmCompile(
       (table (export "tbl") 1 funcref)
       (elem (i32.const 0) $f1)
       (func $f1 (result (ref $box)) (ref.null)))`),
                    WebAssembly.CompileError,
                    /cannot expose reference type/);
 
 assertEq(typeof wasmCompile(
     `(module
-      (gc_feature_opt_in 3)
       (table (export "tbl") 1 funcref)
       (elem (i32.const 0) $f1)
       (func $f1 (param anyref) (unreachable)))`),
          "object");
 
 assertEq(typeof wasmCompile(
     `(module
-      (gc_feature_opt_in 3)
       (table (export "tbl") 1 funcref)
       (elem (i32.const 0) $f1)
       (func $f1 (result anyref) (ref.null)))`),
          "object");
 
 // Imported table cannot reference functions that are exposed for Ref, though anyref is OK.
 
 assertErrorMessage(() => wasmCompile(
@@ -228,25 +218,23 @@ assertErrorMessage(() => wasmCompile(
       (import "m" "tbl" (table 1 funcref))
       (elem (i32.const 0) $f1)
       (func $f1 (result (ref $box)) (ref.null)))`),
                    WebAssembly.CompileError,
                    /cannot expose reference type/);
 
 assertEq(typeof wasmCompile(
     `(module
-      (gc_feature_opt_in 3)
       (import "m" "tbl" (table 1 funcref))
       (elem (i32.const 0) $f1)
       (func $f1 (param anyref) (unreachable)))`),
          "object");
 
 assertEq(typeof wasmCompile(
     `(module
-      (gc_feature_opt_in 3)
       (import "m" "tbl" (table 1 funcref))
       (elem (i32.const 0) $f1)
       (func $f1 (result anyref) (ref.null)))`),
          "object");
 
 // Can't call via exported table with type that is exposed for Ref, though anyref is OK.
 
 assertErrorMessage(() => wasmCompile(
@@ -268,26 +256,24 @@ assertErrorMessage(() => wasmCompile(
       (table (export "tbl") 1 funcref)
       (func (param i32) (result (ref $box))
        (call_indirect $fn (get_local 0))))`),
                    WebAssembly.CompileError,
                    /cannot expose reference type/);
 
 assertEq(typeof wasmCompile(
     `(module
-      (gc_feature_opt_in 3)
       (type $fn (func (param anyref)))
       (table (export "tbl") 1 funcref)
       (func (param i32)
        (call_indirect $fn (ref.null) (get_local 0))))`),
          "object");
 
 assertEq(typeof wasmCompile(
     `(module
-      (gc_feature_opt_in 3)
       (type $fn (func (result anyref)))
       (table (export "tbl") 1 funcref)
       (func (param i32) (result anyref)
        (call_indirect $fn (get_local 0))))`),
          "object");
 
 // Can't call via imported table with type that is exposed for Ref, though anyref is OK.
 
@@ -310,26 +296,24 @@ assertErrorMessage(() => wasmCompile(
       (import "m" "tbl" (table 1 funcref))
       (func (param i32) (result (ref $box))
        (call_indirect $fn (get_local 0))))`),
                    WebAssembly.CompileError,
                    /cannot expose reference type/);
 
 assertEq(typeof wasmCompile(
     `(module
-      (gc_feature_opt_in 3)
       (type $fn (func (param anyref)))
       (import "m" "tbl" (table 1 funcref))
       (func (param i32)
        (call_indirect $fn (ref.null) (get_local 0))))`),
          "object");
 
 assertEq(typeof wasmCompile(
     `(module
-      (gc_feature_opt_in 3)
       (type $fn (func (result anyref)))
       (import "m" "tbl" (table 1 funcref))
       (func (param i32) (result anyref)
        (call_indirect $fn (get_local 0))))`),
          "object");
 
 // We can call via a private table with a type that is exposed for Ref.
 
--- a/js/src/jit-test/tests/wasm/gc/stackmaps1.js
+++ b/js/src/jit-test/tests/wasm/gc/stackmaps1.js
@@ -12,17 +12,16 @@
 // Eventually fn0 will trigger GC and we expect the chain of resulting frames
 // to be traced correctly.  fn2, fn1 and fn0 have some ref-typed args, so
 // there will be traceable stack words to follow, in the sequence of frames.
 
 const {Module,Instance} = WebAssembly;
 
 let t =
   `(module
-     (gc_feature_opt_in 3)
      (import $check3 "" "check3" (func (param anyref) (param anyref) (param anyref)))
      (type $typeOfFn0
            (func (result i32) (param i32) (param anyref) (param i32)
                               (param anyref) (param anyref) (param i32)))
      (table 1 1 funcref)
      (elem (i32.const 0) $fn0)
 
      (import $alloc "" "alloc" (func (result anyref)))
--- a/js/src/jit-test/tests/wasm/gc/stackmaps2.js
+++ b/js/src/jit-test/tests/wasm/gc/stackmaps2.js
@@ -23,17 +23,16 @@
 // slow).
 
 const {Module,Instance} = WebAssembly;
 
 const DEBUG = false;
 
 let t =
   `(module
-     (gc_feature_opt_in 3)
      (type $typeOfFn0
            (func (result i32) (param i32) (param anyref) (param i32)
                               (param anyref) (param anyref) (param i32)))
      (table 1 1 funcref)
      (elem (i32.const 0) $fn0)
 
      (import $alloc "" "alloc" (func (result anyref)))
      (import $quitp "" "quitp" (func (result i32)))
--- a/js/src/jit-test/tests/wasm/gc/stackmaps3.js
+++ b/js/src/jit-test/tests/wasm/gc/stackmaps3.js
@@ -19,17 +19,16 @@
 // implementation works.
 
 const {Module,Instance} = WebAssembly;
 
 const DEBUG = false;
 
 let t =
   `(module
-     (gc_feature_opt_in 3)
      (import $mkCons "" "mkCons" (func (result anyref)
                                        (param anyref) (param anyref)))
      (import $mkBoxedInt "" "mkBoxedInt" (func (result anyref)))
 
      (func $mkNil (result anyref)
        ref.null
      )
 
--- a/js/src/jit-test/tests/wasm/gc/tables-generalized.js
+++ b/js/src/jit-test/tests/wasm/gc/tables-generalized.js
@@ -3,53 +3,48 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // General table management in wasm
 
 // Wasm: Create table-of-anyref
 
 new WebAssembly.Module(wasmTextToBinary(
     `(module
-       (gc_feature_opt_in 3)
        (table 10 anyref))`));
 
 // Wasm: Import table-of-anyref
 // JS: create table-of-anyref
 
 new WebAssembly.Instance(new WebAssembly.Module(wasmTextToBinary(
     `(module
-       (gc_feature_opt_in 3)
        (table (import "m" "t") 10 anyref))`)),
                          {m:{t: new WebAssembly.Table({element:"anyref", initial:10})}});
 
 new WebAssembly.Instance(new WebAssembly.Module(wasmTextToBinary(
     `(module
-       (gc_feature_opt_in 3)
        (import "m" "t" (table 10 anyref)))`)),
                          {m:{t: new WebAssembly.Table({element:"anyref", initial:10})}});
 
 // Wasm: Export table-of-anyref, initial values shall be null
 
 {
     let ins = new WebAssembly.Instance(new WebAssembly.Module(wasmTextToBinary(
     `(module
-       (gc_feature_opt_in 3)
        (table (export "t") 10 anyref))`)));
     let t = ins.exports.t;
     assertEq(t.length, 10);
     for (let i=0; i < t.length; i++)
         assertEq(t.get(0), null);
 }
 
 // JS: Exported table can be grown, and values are preserved
 
 {
     let ins = new WebAssembly.Instance(new WebAssembly.Module(wasmTextToBinary(
     `(module
-       (gc_feature_opt_in 3)
        (table (export "t") 10 anyref))`)));
     let t = ins.exports.t;
     let objs = [{}, {}, {}, {}, {}, {}, {}, {}, {}, {}];
     for (let i in objs)
         t.set(i, objs[i]);
     ins.exports.t.grow(10);
     assertEq(ins.exports.t.length, 20);
     for (let i in objs)
@@ -57,17 +52,16 @@ new WebAssembly.Instance(new WebAssembly
 }
 
 // Wasm: table.copy between tables of anyref (currently source and destination
 // are both table zero)
 
 {
     let ins = new WebAssembly.Instance(new WebAssembly.Module(wasmTextToBinary(
     `(module
-       (gc_feature_opt_in 3)
        (table (export "t") 10 anyref)
        (func (export "f")
          (table.copy (i32.const 5) (i32.const 0) (i32.const 3))))`)));
     let t = ins.exports.t;
     let objs = [{}, {}, {}, {}, {}, {}, {}, {}, {}, {}];
     for (let i in objs)
         t.set(i, objs[i]);
     ins.exports.f();
@@ -82,52 +76,48 @@ new WebAssembly.Instance(new WebAssembly
     assertEq(t.get(8), objs[8]);
     assertEq(t.get(9), objs[9]);
 }
 
 // Wasm: element segments targeting table-of-anyref is forbidden
 
 assertErrorMessage(() => new WebAssembly.Module(wasmTextToBinary(
     `(module
-       (gc_feature_opt_in 3)
        (func $f1 (result i32) (i32.const 0))
        (table 10 anyref)
        (elem (i32.const 0) $f1))`)),
                    WebAssembly.CompileError,
                    /only tables of 'funcref' may have element segments/);
 
 // Wasm: table.init on table-of-anyref is forbidden
 
 assertErrorMessage(() => new WebAssembly.Module(wasmTextToBinary(
     `(module
-       (gc_feature_opt_in 3)
        (func $f1 (result i32) (i32.const 0))
        (table 10 anyref)
        (elem passive $f1)
        (func
          (table.init 0 (i32.const 0) (i32.const 0) (i32.const 0))))`)),
                    WebAssembly.CompileError,
                    /only tables of 'funcref' may have element segments/);
 
 // Wasm: table types must match at link time
 
 assertErrorMessage(
     () => new WebAssembly.Instance(new WebAssembly.Module(wasmTextToBinary(
     `(module
-       (gc_feature_opt_in 3)
        (import "m" "t" (table 10 anyref)))`)),
                                    {m:{t: new WebAssembly.Table({element:"funcref", initial:10})}}),
     WebAssembly.LinkError,
     /imported table type mismatch/);
 
 // call_indirect cannot reference table-of-anyref
 
 assertErrorMessage(() => new WebAssembly.Module(wasmTextToBinary(
     `(module
-       (gc_feature_opt_in 3)
        (table 10 anyref)
        (type $t (func (param i32) (result i32)))
        (func (result i32)
          (call_indirect $t (i32.const 37))))`)),
                    WebAssembly.CompileError,
                    /indirect calls must go through a table of 'funcref'/);
 
 ///////////////////////////////////////////////////////////////////////////
@@ -165,33 +155,31 @@ function dummy() { return 37 }
 // table.get and table.set
 
 // table.get in bounds - returns right value type & value
 // table.get out of bounds - fails
 
 {
     let ins = wasmEvalText(
         `(module
-           (gc_feature_opt_in 3)
            (table (export "t") 10 anyref)
            (func (export "f") (param i32) (result anyref)
               (table.get (get_local 0))))`);
     let x = {};
     ins.exports.t.set(0, x);
     assertEq(ins.exports.f(0), x);
     assertEq(ins.exports.f(1), null);
     assertErrorMessage(() => ins.exports.f(10), RangeError, /index out of bounds/);
     assertErrorMessage(() => ins.exports.f(-5), RangeError, /index out of bounds/);
 }
 
 // table.get with non-i32 index - fails validation
 
 assertErrorMessage(() => new WebAssembly.Module(wasmTextToBinary(
     `(module
-       (gc_feature_opt_in 3)
        (table 10 anyref)
        (func (export "f") (param f64) (result anyref)
          (table.get (get_local 0))))`)),
                    WebAssembly.CompileError,
                    /type mismatch/);
 
 // table.get on table of funcref - fails validation because funcref is not expressible
 // Both with and without anyref support
@@ -201,17 +189,16 @@ assertErrorMessage(() => new WebAssembly
        (table 10 funcref)
        (func (export "f") (param i32)
          (drop (table.get (get_local 0)))))`)),
                    WebAssembly.CompileError,
                    /table.get only on tables of anyref/);
 
 assertErrorMessage(() => new WebAssembly.Module(wasmTextToBinary(
     `(module
-       (gc_feature_opt_in 3)
        (table 10 funcref)
        (func (export "f") (param i32)
          (drop (table.get (get_local 0)))))`)),
                    WebAssembly.CompileError,
                    /table.get only on tables of anyref/);
 
 // table.get when there are no tables - fails validation
 
@@ -224,17 +211,16 @@ assertErrorMessage(() => new WebAssembly
 
 // table.set in bounds with i32 x anyref - works, no value generated
 // table.set with null - works
 // table.set out of bounds - fails
 
 {
     let ins = wasmEvalText(
         `(module
-           (gc_feature_opt_in 3)
            (table (export "t") 10 anyref)
            (func (export "set_anyref") (param i32) (param anyref)
              (table.set (get_local 0) (get_local 1)))
            (func (export "set_null") (param i32)
              (table.set (get_local 0) (ref.null))))`);
     let x = {};
     ins.exports.set_anyref(3, x);
     assertEq(ins.exports.t.get(3), x);
@@ -244,66 +230,59 @@ assertErrorMessage(() => new WebAssembly
     assertErrorMessage(() => ins.exports.set_anyref(10, x), RangeError, /index out of bounds/);
     assertErrorMessage(() => ins.exports.set_anyref(-1, x), RangeError, /index out of bounds/);
 }
 
 // table.set with non-i32 index - fails validation
 
 assertErrorMessage(() => new WebAssembly.Module(wasmTextToBinary(
     `(module
-       (gc_feature_opt_in 3)
        (table 10 anyref)
        (func (export "f") (param f64)
          (table.set (get_local 0) (ref.null))))`)),
                    WebAssembly.CompileError,
                    /type mismatch/);
 
 // table.set with non-anyref value - fails validation
 
 assertErrorMessage(() => new WebAssembly.Module(wasmTextToBinary(
     `(module
-       (gc_feature_opt_in 3)
        (table 10 anyref)
        (func (export "f") (param f64)
          (table.set (i32.const 0) (get_local 0))))`)),
                    WebAssembly.CompileError,
                    /type mismatch/);
 
 // table.set on table of funcref - fails validation
-// We need the gc_feature_opt_in here because of the anyref parameter; if we change
-// that to some other type, it's the validation of that type that fails us.
 
 assertErrorMessage(() => new WebAssembly.Module(wasmTextToBinary(
     `(module
-      (gc_feature_opt_in 3)
       (table 10 funcref)
       (func (export "f") (param anyref)
        (table.set (i32.const 0) (get_local 0))))`)),
                    WebAssembly.CompileError,
                    /table.set only on tables of anyref/);
 
 // table.set when there are no tables - fails validation
 
 assertErrorMessage(() => new WebAssembly.Module(wasmTextToBinary(
     `(module
-      (gc_feature_opt_in 3)
       (func (export "f") (param anyref)
        (table.set (i32.const 0) (get_local 0))))`)),
                    WebAssembly.CompileError,
                    /table index out of range for table.set/);
 
 // we can grow table of anyref
 // table.grow with zero delta - always works even at maximum
 // table.grow with delta - works and returns correct old value
 // table.grow with delta at upper limit - fails
 // table.grow with negative delta - fails
 
 let ins = wasmEvalText(
     `(module
-      (gc_feature_opt_in 3)
       (table (export "t") 10 20 anyref)
       (func (export "grow") (param i32) (result i32)
        (table.grow (get_local 0) (ref.null))))`);
 assertEq(ins.exports.grow(0), 10);
 assertEq(ins.exports.t.length, 10);
 assertEq(ins.exports.grow(1), 10);
 assertEq(ins.exports.t.length, 11);
 assertEq(ins.exports.t.get(10), null);
@@ -322,67 +301,62 @@ assertEq(ins.exports.t.length, 20);
 assertEq(ins.exports.grow(-1), -1);
 assertEq(ins.exports.t.length, 20)
 
 // Special case for private tables without a maximum
 
 {
     let ins = wasmEvalText(
         `(module
-          (gc_feature_opt_in 3)
           (table 10 anyref)
           (func (export "grow") (param i32) (result i32)
            (table.grow (get_local 0) (ref.null))))`);
     assertEq(ins.exports.grow(0), 10);
     assertEq(ins.exports.grow(1), 10);
     assertEq(ins.exports.grow(9), 11);
     assertEq(ins.exports.grow(0), 20);
 }
 
 // Can't grow table of funcref yet
 
 assertErrorMessage(() => wasmEvalText(
     `(module
-      (gc_feature_opt_in 3)     ;; Required because of the 'anyref' null value below
       (table $t 2 funcref)
       (func $f
        (drop (table.grow (i32.const 1) (ref.null)))))`),
                    WebAssembly.CompileError,
                    /table.grow only on tables of anyref/);
 
 // table.grow with non-i32 argument - fails validation
 
 assertErrorMessage(() => new WebAssembly.Module(wasmTextToBinary(
     `(module
-       (gc_feature_opt_in 3)
        (table 10 anyref)
        (func (export "f") (param f64)
         (table.grow (get_local 0) (ref.null))))`)),
                    WebAssembly.CompileError,
                    /type mismatch/);
 
 // table.grow when there are no tables - fails validation
 
 assertErrorMessage(() => new WebAssembly.Module(wasmTextToBinary(
     `(module
-       (gc_feature_opt_in 3)
        (func (export "f") (param i32)
         (table.grow (get_local 0) (ref.null))))`)),
                    WebAssembly.CompileError,
                    /table index out of range for table.grow/);
 
 // table.size on table of anyref
 
 for (let visibility of ['', '(export "t")', '(import "m" "t")']) {
     let exp = {m:{t: new WebAssembly.Table({element:"anyref",
                                             initial: 10,
                                             maximum: 20})}};
     let ins = wasmEvalText(
         `(module
-          (gc_feature_opt_in 3)
           (table ${visibility} 10 20 anyref)
           (func (export "grow") (param i32) (result i32)
            (table.grow (get_local 0) (ref.null)))
           (func (export "size") (result i32)
            (table.size)))`,
         exp);
     assertEq(ins.exports.grow(0), 10);
     assertEq(ins.exports.size(), 10);
--- a/js/src/jit-test/tests/wasm/gc/tables-multiple.js
+++ b/js/src/jit-test/tests/wasm/gc/tables-multiple.js
@@ -5,17 +5,16 @@
 
 ///////////////////////////////////////////////////////////////////////////
 //
 // Positive tests
 
 // - multiple local tables of misc type: syntax, validation, instantiation
 // - element segments can point to a table
 // - call-indirect can specify a table and will use it
-// - be sure to test table stuff w/o gc_feature_opt_in so that we get ion coverage too
 
 var ins = wasmEvalText(
     `(module
       (table $t1 2 funcref)
       (table $t2 2 funcref)
       (type $ftype (func (param i32) (result i32)))
       (elem $t1 (i32.const 0) $f1 $f2)
       (elem $t2 (i32.const 0) $f3 $f4)
@@ -38,17 +37,16 @@ assertEq(ins.g(0, 10), 13);
 assertEq(ins.g(1, 10), 14);
 
 // - export multiple tables.
 //   note the first and third tables make the export list not start at zero,
 //   and make it sparse
 
 var ins = wasmEvalText(
     `(module
-      (gc_feature_opt_in 3)
       (table $t0 (import "m" "t") 2 funcref)
       (table $t1 (export "t1") 2 funcref)
       (table 1 anyref)
       (table $t2 (export "t2") 3 funcref))`,
     {m:{t: new WebAssembly.Table({element:"funcref", initial:2})}}).exports;
 
 assertEq(ins.t1 instanceof WebAssembly.Table, true);
 assertEq(ins.t1.length, 2);
@@ -59,18 +57,16 @@ assertEq(ins.t2.length, 3);
 // - table.get and table.set can point to a table
 
 var exp = {m:{t0: new WebAssembly.Table({element:"funcref", initial:2}),
               t1: new WebAssembly.Table({element:"anyref", initial:3}),
               t2: new WebAssembly.Table({element:"funcref", initial:4}),
               t3: new WebAssembly.Table({element:"anyref", initial:5})}};
 var ins = wasmEvalText(
     `(module
-      (gc_feature_opt_in 3)
-
       (table $t0 (import "m" "t0") 2 funcref)
       (type $id_i32_t (func (param i32) (result i32)))
       (func $id_i32 (param i32) (result i32) (get_local 0))
       (elem $t0 (i32.const 1) $id_i32)
 
       (table $t1 (import "m" "t1") 3 anyref)
 
       (table $t2 (import "m" "t2") 4 funcref)
@@ -108,18 +104,16 @@ assertEq(exp.m.t3.get(4), x);
 // - table.grow can point to a table
 // - growing a table grows the right table but not the others
 // - table.size on tables other than table 0
 
 var exp = {m:{t0: new WebAssembly.Table({element:"anyref", initial:2}),
               t1: new WebAssembly.Table({element:"anyref", initial:3})}};
 var ins = wasmEvalText(
     `(module
-      (gc_feature_opt_in 3)
-
       (table $t0 (import "m" "t0") 2 anyref)
       (table $t1 (import "m" "t1") 3 anyref)
       (func (export "f") (result i32)
        (table.grow $t1 (i32.const 5) (ref.null)))
       (func (export "size0") (result i32)
        (table.size $t0))
       (func (export "size1") (result i32)
        (table.size $t1)))`,
@@ -131,35 +125,32 @@ assertEq(ins.exports.size0(), 2);
 assertEq(ins.exports.size1(), 8);
 
 // - table.copy can point to tables
 
 var exp = {m:{t0: new WebAssembly.Table({element:"anyref", initial:2}),
               t1: new WebAssembly.Table({element:"anyref", initial:3})}};
 var ins = wasmEvalText(
     `(module
-      (gc_feature_opt_in 3)
-
       (table $t0 (import "m" "t0") 2 anyref)
       (table $t1 (import "m" "t1") 3 anyref)
       (func (export "f") (param $dest i32) (param $src i32) (param $len i32)
        (table.copy $t1 (get_local $dest) $t0 (get_local $src) (get_local $len))))`,
     exp);
 
 exp.m.t0.set(0, {x:0});
 exp.m.t0.set(1, {x:1});
 ins.exports.f(1, 0, 2);
 assertEq(exp.m.t1.get(1), exp.m.t0.get(0));
 assertEq(exp.m.t1.get(2), exp.m.t0.get(1));
 
 // - the table.copy syntax makes sense even in the non-parenthesized case
 
 var ins = wasmEvalText(
     `(module
-      (gc_feature_opt_in 3)
       (table $t0 2 anyref)
       (table $t1 2 anyref)
       (func (export "copy") (param $dest i32) (param $src i32) (param $len i32)
        get_local $dest
        get_local $src
        get_local $len
        table.copy $t1 $t0)
       (func (export "set") (param $n i32) (param $v anyref)
@@ -180,17 +171,16 @@ assertEq(ins.exports.get(1), values[1]);
 // in effect forces a representation for the function in the local table that
 // captures the function's instance, at the latest at the time the copy is
 // executed.
 //
 // In the case where the function is imported, it comes from a different module.
 //
 // Also tests:
 // - local tables can be exported and re-imported in another module
-// - table.copy between tables of funcref is possible without gc_feature_opt_in
 
 var arg = 4;
 for (let [x,y,result,init] of [['(export "t")', '', arg*13, true],
                                ['', '(export "t")', arg*13, true],
                                ['(import "m" "t")', '', arg*13, true],
                                ['', '(import "m" "t")', arg-11, false]])
 {
     var otherins = wasmEvalText(
@@ -224,17 +214,16 @@ for (let [x,y,result,init] of [['(export
 // - test the (import "m" "t" (table ...)) syntax
 // - if table is grown from JS, wasm can observe the growth
 
 var tbl = new WebAssembly.Table({element:"anyref", initial:1});
 var exp = {m: {t0: tbl, t1:tbl}};
 
 var ins = wasmEvalText(
     `(module
-      (gc_feature_opt_in 3)
       (import $t0 "m" "t0" (table 1 anyref))
       (import $t1 "m" "t1" (table 1 anyref))
       (table $t2 (export "t2") 1 funcref)
       (func (export "f") (result i32)
        (table.grow $t0 (i32.const 1) (ref.null)))
       (func (export "g") (result i32)
        (table.grow $t1 (i32.const 1) (ref.null)))
       (func (export "size") (result i32)
@@ -245,17 +234,16 @@ assertEq(ins.exports.f(), 1);
 assertEq(ins.exports.g(), 2);
 assertEq(ins.exports.f(), 3);
 assertEq(ins.exports.g(), 4);
 assertEq(tbl.length, 5);
 ins.exports.t2.grow(3);
 assertEq(ins.exports.size(), 4);
 
 // - table.init on tables other than table 0
-// - gc_feature_opt_in not required for table.init on table(funcref) even with multiple tables
 
 var ins = wasmEvalText(
     `(module
       (table $t0 2 funcref)
       (table $t1 2 funcref)
       (elem passive $f0 $f1) ;; 0
       (type $ftype (func (param i32) (result i32)))
       (func $f0 (param i32) (result i32)
@@ -328,67 +316,61 @@ assertErrorMessage(() => ins2.exports.do
 ///////////////////////////////////////////////////////////////////////////
 //
 // Negative tests
 
 // Table index (statically) out of bounds
 
 assertErrorMessage(() => wasmEvalText(
     `(module
-      (gc_feature_opt_in 3)
       (table $t0 2 anyref)
       (table $t1 2 anyref)
       (func $f (result anyref)
        (table.get 2 (i32.const 0))))`),
                    WebAssembly.CompileError,
                    /table index out of range for table.get/);
 
 assertErrorMessage(() => wasmEvalText(
     `(module
-      (gc_feature_opt_in 3)
       (table $t0 2 anyref)
       (table $t1 2 anyref)
       (func $f (param anyref)
        (table.set 2 (i32.const 0) (get_local 0))))`),
                    WebAssembly.CompileError,
                    /table index out of range for table.set/);
 
 assertErrorMessage(() => wasmEvalText(
     `(module
-      (gc_feature_opt_in 3)
       (table $t0 2 anyref)
       (table $t1 2 anyref)
       (func $f (param anyref)
        (table.copy 0 (i32.const 0) 2 (i32.const 0) (i32.const 2))))`),
                    WebAssembly.CompileError,
                    /table index out of range for table.copy/);
 
 assertErrorMessage(() => wasmEvalText(
     `(module
-      (gc_feature_opt_in 3)
       (table $t0 2 anyref)
       (table $t1 2 anyref)
       (func $f (param anyref)
        (table.copy 2 (i32.const 0) 0 (i32.const 0) (i32.const 2))))`),
                    WebAssembly.CompileError,
                    /table index out of range for table.copy/);
 
 assertErrorMessage(() => wasmEvalText(
     `(module
-      (gc_feature_opt_in 3)
       (table $t0 2 anyref)
       (table $t1 2 anyref)
       (func $f (result i32)
        (table.size 2)))`),
                    WebAssembly.CompileError,
                    /table index out of range for table.size/);
 
 assertErrorMessage(() => wasmEvalText(
     `(module
-      (gc_feature_opt_in 3)
       (table $t0 2 anyref)
       (table $t1 2 anyref)
       (func $f (result i32)
        (table.grow 2 (i32.const 1) (ref.null))))`),
                    WebAssembly.CompileError,
                    /table index out of range for table.grow/);
 
 assertErrorMessage(() => wasmEvalText(
--- a/js/src/jit-test/tests/wasm/gc/tables-stress.js
+++ b/js/src/jit-test/tests/wasm/gc/tables-stress.js
@@ -1,14 +1,13 @@
 // |jit-test| skip-if: !wasmReftypesEnabled()
 
 for ( let prefix of ['', '(table $prefix 0 32 funcref)']) {
     let mod = new WebAssembly.Module(wasmTextToBinary(
     `(module
-       (gc_feature_opt_in 3)
        ${prefix}
        (table $tbl 0 anyref)
        (import $item "m" "item" (func (result anyref)))
        (func (export "run") (param $numiters i32)
          (local $i i32)
          (local $j i32)
          (local $last i32)
          (local $iters i32)