[wasm-gc] Rename array.new_fixed_static -> array.new_fixed

This is a left-over of the removal of the dynamic (rtt-based)
variants.

Bug: v8:7748
Change-Id: I93bb74a72543a5697f1102d283c7d65c6be99466
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/3856577
Commit-Queue: Jakob Kummerow <jkummerow@chromium.org>
Auto-Submit: Matthias Liedtke <mliedtke@chromium.org>
Reviewed-by: Jakob Kummerow <jkummerow@chromium.org>
Cr-Commit-Position: refs/heads/main@{#82746}

src/wasm/function-body-decoder-impl.h

@@ -2006,7 +2006,7 @@ class WasmDecoder : public Decoder {
             if (io) io->TypeIndex(imm);
             return length + imm.length;
           }
-          case kExprArrayNewFixedStatic: {
+          case kExprArrayNewFixed: {
             ArrayIndexImmediate<validate> array_imm(decoder, pc + length);
             IndexImmediate<validate> length_imm(
                 decoder, pc + length + array_imm.length, "array length");
@@ -2290,7 +2290,7 @@ class WasmDecoder : public Decoder {
             CHECK(Validate(pc + 2, imm));
             return {imm.struct_type->field_count(), 1};
           }
-          case kExprArrayNewFixedStatic: {
+          case kExprArrayNewFixed: {
             ArrayIndexImmediate<validate> array_imm(this, pc + 2);
             IndexImmediate<validate> length_imm(this, pc + 2 + array_imm.length,
                                                 "array length");
@@ -4607,7 +4607,7 @@ class WasmFullDecoder : public WasmDecoder<validate, decoding_mode> {
         Drop(5);
         return opcode_length + dst_imm.length + src_imm.length;
       }
-      case kExprArrayNewFixedStatic: {
+      case kExprArrayNewFixed: {
         ArrayIndexImmediate<validate> array_imm(this,
                                                 this->pc_ + opcode_length);
         if (!this->Validate(this->pc_ + opcode_length, array_imm)) return 0;

src/wasm/wasm-init-expr.cc

@@ -40,7 +40,7 @@ ValueType WasmInitExpr::type(const WasmModule* module,
       return ValueType::RefNull(immediate().heap_type);
     case kStructNew:
     case kStructNewDefault:
-    case kArrayNewFixedStatic:
+    case kArrayNewFixed:
       return ValueType::Ref(immediate().index);
     case kI31New:
       return kWasmI31Ref.AsNonNull();

src/wasm/wasm-init-expr.h

@@ -38,7 +38,7 @@ class WasmInitExpr : public ZoneObject {
     kRefFuncConst,
     kStructNew,
     kStructNewDefault,
-    kArrayNewFixedStatic,
+    kArrayNewFixed,
     kI31New,
     kStringConst,
   };
@@ -108,9 +108,9 @@ class WasmInitExpr : public ZoneObject {
     return expr;
   }
 
-  static WasmInitExpr ArrayNewFixedStatic(uint32_t index,
-                                          ZoneVector<WasmInitExpr>* elements) {
-    WasmInitExpr expr(kArrayNewFixedStatic, elements);
+  static WasmInitExpr ArrayNewFixed(uint32_t index,
+                                    ZoneVector<WasmInitExpr>* elements) {
+    WasmInitExpr expr(kArrayNewFixed, elements);
     expr.immediate_.index = index;
     return expr;
   }
@@ -162,7 +162,7 @@ class WasmInitExpr : public ZoneObject {
           if (operands()[i] != other.operands()[i]) return false;
         }
         return true;
-      case kArrayNewFixedStatic:
+      case kArrayNewFixed:
         if (immediate().index != other.immediate().index) return false;
         if (operands()->size() != other.operands()->size()) return false;
         for (uint32_t i = 0; i < operands()->size(); i++) {

src/wasm/wasm-module-builder.cc

@@ -549,14 +549,14 @@ void WriteInitializerExpressionWithEnd(ZoneBuffer* buffer,
       buffer->write_u8(static_cast<uint8_t>(opcode));
       buffer->write_u32v(init.immediate().index);
       break;
-    case WasmInitExpr::kArrayNewFixedStatic: {
-      static_assert((kExprArrayNewFixedStatic >> 8) == kGCPrefix);
-      static_assert((kExprArrayNewFixedStatic & 0x80) == 0);
+    case WasmInitExpr::kArrayNewFixed: {
+      static_assert((kExprArrayNewFixed >> 8) == kGCPrefix);
+      static_assert((kExprArrayNewFixed & 0x80) == 0);
       for (const WasmInitExpr& operand : *init.operands()) {
         WriteInitializerExpressionWithEnd(buffer, operand, kWasmBottom);
       }
       buffer->write_u8(kGCPrefix);
-      buffer->write_u8(static_cast<uint8_t>(kExprArrayNewFixedStatic));
+      buffer->write_u8(static_cast<uint8_t>(kExprArrayNewFixed));
       buffer->write_u32v(init.immediate().index);
       buffer->write_u32v(static_cast<uint32_t>(init.operands()->size()));
       break;

src/wasm/wasm-opcodes.h

@@ -697,7 +697,7 @@ bool V8_EXPORT_PRIVATE IsJSCompatibleSignature(const FunctionSig* sig,
   V(ArrayLen, 0xfb17, _, "array.len")                                          \
   V(ArrayCopy, 0xfb18, _,                                                      \
     "array.copy") /* not standardized - V8 experimental */                     \
-  V(ArrayNewFixedStatic, 0xfb1a, _, "array.new_fixed_static")                  \
+  V(ArrayNewFixed, 0xfb1a, _, "array.new_fixed")                               \
   V(ArrayNew, 0xfb1b, _, "array.new")                                          \
   V(ArrayNewDefault, 0xfb1c, _, "array.new_default")                           \
   V(ArrayNewDataStatic, 0xfb1d, _, "array.new_data_static")                    \

test/cctest/wasm/test-gc.cc

@@ -841,17 +841,17 @@ WASM_COMPILED_EXEC_TEST(WasmBasicArray) {
       {WASM_ARRAY_NEW_DEFAULT(type_index, WASM_I32V(2)), WASM_DROP,
        WASM_ARRAY_NEW(type_index, WASM_I32V(42), WASM_I32V(2)), kExprEnd});
 
-  const byte kInit = tester.DefineFunction(
-      &sig_q_v, {},
-      {WASM_ARRAY_NEW_FIXED_STATIC(type_index, 3, WASM_I32V(10), WASM_I32V(20),
-                                   WASM_I32V(30)),
-       kExprEnd});
+  const byte kInit =
+      tester.DefineFunction(&sig_q_v, {},
+                            {WASM_ARRAY_NEW_FIXED(type_index, 3, WASM_I32V(10),
+                                                  WASM_I32V(20), WASM_I32V(30)),
+                             kExprEnd});
 
   const byte kImmutable = tester.DefineFunction(
       tester.sigs.i_v(), {},
       {WASM_ARRAY_GET(immut_type_index,
-                      WASM_ARRAY_NEW_FIXED_STATIC(immut_type_index, 2,
-                                                  WASM_I32V(42), WASM_I32V(43)),
+                      WASM_ARRAY_NEW_FIXED(immut_type_index, 2, WASM_I32V(42),
+                                           WASM_I32V(43)),
                       WASM_I32V(0)),
        kExprEnd});
 

test/common/wasm/wasm-macro-gen.h

@@ -574,8 +574,8 @@ inline uint16_t ExtractPrefixedOpcodeBytes(WasmOpcode opcode) {
   dst_array, dst_index, src_array, src_index, length,                      \
       WASM_GC_OP(kExprArrayCopy), static_cast<byte>(dst_idx),              \
       static_cast<byte>(src_idx)
-#define WASM_ARRAY_NEW_FIXED_STATIC(index, length, ...)                        \
-  __VA_ARGS__, WASM_GC_OP(kExprArrayNewFixedStatic), static_cast<byte>(index), \
+#define WASM_ARRAY_NEW_FIXED(index, length, ...)                         \
+  __VA_ARGS__, WASM_GC_OP(kExprArrayNewFixed), static_cast<byte>(index), \
       static_cast<byte>(length)
 
 #define WASM_I31_NEW(val) val, WASM_GC_OP(kExprI31New)

test/fuzzer/wasm-compile.cc

@@ -2410,7 +2410,7 @@ WasmInitExpr GenerateInitExpr(Zone* zone, WasmModuleBuilder* builder,
             elements->push_back(GenerateInitExpr(
                 zone, builder, builder->GetArrayType(index)->element_type(),
                 num_struct_and_array_types));
-            return WasmInitExpr::ArrayNewFixedStatic(index, elements);
+            return WasmInitExpr::ArrayNewFixed(index, elements);
           }
           if (builder->IsSignature(index)) {
             // Transform from signature index to function index.

test/fuzzer/wasm-fuzzer-common.cc

@@ -445,7 +445,7 @@ class InitExprInterface {
                      const ArrayIndexImmediate<validate>& imm,
                      const base::Vector<Value>& elements, const Value& rtt,
                      Value* result) {
-    os_ << "kGCPrefix, kExprArrayNewFixedStatic, " << index(imm.index)
+    os_ << "kGCPrefix, kExprArrayNewFixed, " << index(imm.index)
         << index(static_cast<uint32_t>(elements.size()));
   }
 

test/inspector/debugger/wasm-gc-anyref.js

@@ -74,7 +74,7 @@ async function instantiateWasm() {
     kExprLocalSet, 0,
     // Set local anyref_local2 to new array.
     ...wasmI32Const(21),
-    kGCPrefix, kExprArrayNewFixedStatic, array_type, 1,
+    kGCPrefix, kExprArrayNewFixed, array_type, 1,
     kExprLocalSet, 1,
     kExprNop,
   ];

test/mjsunit/wasm/gc-experimental-string-conversions.js

@@ -14,7 +14,7 @@ builder.addFunction('getHelloArray', makeSig([], [kWasmArrayRef]))
     .addBody([
       ...wasmI32Const(72), ...wasmI32Const(69), ...wasmI32Const(76),
       ...wasmI32Const(76), ...wasmI32Const(79),
-      kGCPrefix, kExprArrayNewFixedStatic, i16Array, 5
+      kGCPrefix, kExprArrayNewFixed, i16Array, 5
     ])
     .exportFunc();
 

test/mjsunit/wasm/reference-globals.js

@@ -200,7 +200,7 @@ d8.file.execute("test/mjsunit/wasm/wasm-module-builder.js");
   var global = builder.addGlobal(
       wasmRefType(array_index), false,
       [kExprGlobalGet, global0.index, ...wasmI32Const(element1_value),
-       kGCPrefix, kExprArrayNewFixedStatic, array_index, 2]);
+       kGCPrefix, kExprArrayNewFixed, array_index, 2]);
 
   builder.addFunction("get_element", kSig_i_i)
     .addBody([
@@ -235,7 +235,7 @@ d8.file.execute("test/mjsunit/wasm/wasm-module-builder.js");
       [kExprGlobalGet, global0.index, kExprRefNull, struct_index,
        ...wasmI32Const(element2_value),
        kGCPrefix, kExprStructNew, struct_index,
-       kGCPrefix, kExprArrayNewFixedStatic, array_index, 3]);
+       kGCPrefix, kExprArrayNewFixed, array_index, 3]);
 
   builder.addFunction("element0", kSig_i_v)
     .addBody([
@@ -345,7 +345,7 @@ d8.file.execute("test/mjsunit/wasm/wasm-module-builder.js");
       wasmRefType(array_index), true,
       [...values.flatMap(
         value => [...wasmI32Const(value), kGCPrefix, kExprI31New]),
-       kGCPrefix, kExprArrayNewFixedStatic, array_index, 5]);
+       kGCPrefix, kExprArrayNewFixed, array_index, 5]);
 
   for (signed of [true, false]) {
     builder.addFunction(`get_${signed ? "s" : "u"}`, kSig_i_i)

test/mjsunit/wasm/reference-table-js-interop.js

@@ -135,7 +135,7 @@ for (let [typeName, type] of Object.entries(tableTypes)) {
   builder.addFunction("createArray", creatorSig)
     .addBody([
       kExprI32Const, 12,
-      kGCPrefix, kExprArrayNewFixedStatic, array, 1
+      kGCPrefix, kExprArrayNewFixed, array, 1
     ])
     .exportFunc();
 

test/mjsunit/wasm/reference-tables.js

@@ -154,7 +154,7 @@ d8.file.execute('test/mjsunit/wasm/wasm-module-builder.js');
   builder.addActiveElementSegment(
     table, wasmI32Const(0),
     [[...wasmI32Const(111), ...wasmI32Const(222),
-      kGCPrefix, kExprArrayNewFixedStatic, array_type, 2],
+      kGCPrefix, kExprArrayNewFixed, array_type, 2],
      [...wasmI32Const(-31), kGCPrefix, kExprI31New],
      [...wasmI32Const(10), kGCPrefix, kExprStructNew, struct_type],
      [kExprRefNull, kEqRefCode]],

test/mjsunit/wasm/wasm-gc-externalize-internalize.js

@@ -135,14 +135,14 @@ let instance = (() => {
     builder.addFunction('array_producer', makeSig([kWasmI32], [kWasmEqRef]))
     .addBody([
       kExprLocalGet, 0,
-      kGCPrefix, kExprArrayNewFixedStatic, array, 1])
+      kGCPrefix, kExprArrayNewFixed, array, 1])
     .exportFunc();
 
     builder.addFunction('array_externalize',
                         makeSig([kWasmI32], [kWasmExternRef]))
     .addBody([
       kExprLocalGet, 0,
-      kGCPrefix, kExprArrayNewFixedStatic, array, 1,
+      kGCPrefix, kExprArrayNewFixed, array, 1,
       kGCPrefix, kExprExternExternalize,
     ])
     .exportFunc();

test/mjsunit/wasm/wasm-module-builder.js

@@ -498,7 +498,7 @@ let kExprArrayGetU = 0x15;
 let kExprArraySet = 0x16;
 let kExprArrayLen = 0x17;
 let kExprArrayCopy = 0x18;
-let kExprArrayNewFixedStatic = 0x1a;
+let kExprArrayNewFixed = 0x1a;
 let kExprArrayNew = 0x1b;
 let kExprArrayNewDefault = 0x1c;
 let kExprArrayNewDataStatic = 0x1d;

test/unittests/wasm/function-body-decoder-unittest.cc

@@ -4190,10 +4190,10 @@ TEST_F(FunctionBodyDecoderTest, GCArray) {
   // Allocating and reading is OK:
   ExpectValidates(
       sigs.i_v(),
-      {WASM_ARRAY_GET(immutable_array_type_index,
-                      WASM_ARRAY_NEW_FIXED_STATIC(immutable_array_type_index, 1,
-                                                  WASM_I32V(42)),
-                      WASM_I32V(0))});
+      {WASM_ARRAY_GET(
+          immutable_array_type_index,
+          WASM_ARRAY_NEW_FIXED(immutable_array_type_index, 1, WASM_I32V(42)),
+          WASM_I32V(0))});
   // Writing fails:
   ExpectFailure(&sig_v_r2,
                 {WASM_ARRAY_SET(immutable_array_type_index, WASM_LOCAL_GET(0),

test/unittests/wasm/module-decoder-unittest.cc

@@ -35,8 +35,8 @@ namespace module_decoder_unittest {
 #define WASM_INIT_EXPR_GLOBAL(index) WASM_GLOBAL_GET(index), kExprEnd
 #define WASM_INIT_EXPR_STRUCT_NEW(index, ...) \
   WASM_STRUCT_NEW(index, __VA_ARGS__), kExprEnd
-#define WASM_INIT_EXPR_ARRAY_NEW_FIXED_STATIC(index, length, ...) \
-  WASM_ARRAY_NEW_FIXED_STATIC(index, length, __VA_ARGS__), kExprEnd
+#define WASM_INIT_EXPR_ARRAY_NEW_FIXED(index, length, ...) \
+  WASM_ARRAY_NEW_FIXED(index, length, __VA_ARGS__), kExprEnd
 
 #define REF_NULL_ELEMENT kExprRefNull, kFuncRefCode, kExprEnd
 #define REF_FUNC_ELEMENT(v) kExprRefFunc, U32V_1(v), kExprEnd
@@ -836,24 +836,24 @@ TEST_F(WasmModuleVerifyTest, ArrayNewFixedInitExpr) {
       SECTION(Type, ENTRY_COUNT(1), WASM_ARRAY_DEF(kI16Code, true)),
       SECTION(Global, ENTRY_COUNT(1),  // --
               kRefCode, 0, 0,          // type, mutability
-              WASM_INIT_EXPR_ARRAY_NEW_FIXED_STATIC(
-                  0, 3, WASM_I32V(10), WASM_I32V(20), WASM_I32V(30)))};
+              WASM_INIT_EXPR_ARRAY_NEW_FIXED(0, 3, WASM_I32V(10), WASM_I32V(20),
+                                             WASM_I32V(30)))};
   EXPECT_VERIFIES(basic);
 
   static const byte basic_static[] = {
       SECTION(Type, ENTRY_COUNT(1), WASM_ARRAY_DEF(kI16Code, true)),
       SECTION(Global, ENTRY_COUNT(1),  // --
               kRefCode, 0, 0,          // type, mutability
-              WASM_INIT_EXPR_ARRAY_NEW_FIXED_STATIC(
-                  0, 3, WASM_I32V(10), WASM_I32V(20), WASM_I32V(30)))};
+              WASM_INIT_EXPR_ARRAY_NEW_FIXED(0, 3, WASM_I32V(10), WASM_I32V(20),
+                                             WASM_I32V(30)))};
   EXPECT_VERIFIES(basic_static);
 
   static const byte basic_immutable[] = {
       SECTION(Type, ENTRY_COUNT(1), WASM_ARRAY_DEF(kI32Code, false)),
       SECTION(Global, ENTRY_COUNT(1),  // --
               kRefCode, 0, 0,          // type, mutability
-              WASM_INIT_EXPR_ARRAY_NEW_FIXED_STATIC(
-                  0, 3, WASM_I32V(10), WASM_I32V(20), WASM_I32V(30)))};
+              WASM_INIT_EXPR_ARRAY_NEW_FIXED(0, 3, WASM_I32V(10), WASM_I32V(20),
+                                             WASM_I32V(30)))};
   EXPECT_VERIFIES(basic_immutable);
 
   static const byte type_error[] = {
@@ -862,30 +862,30 @@ TEST_F(WasmModuleVerifyTest, ArrayNewFixedInitExpr) {
               WASM_ARRAY_DEF(WASM_SEQ(kRefCode, 0), true)),
       SECTION(Global, ENTRY_COUNT(1),  // --
               kRefCode, 1, 0,          // type, mutability
-              WASM_INIT_EXPR_ARRAY_NEW_FIXED_STATIC(0, 1, WASM_I32V(42)))};
+              WASM_INIT_EXPR_ARRAY_NEW_FIXED(0, 1, WASM_I32V(42)))};
   EXPECT_FAILURE_WITH_MSG(
       type_error,
       "type error in constant expression[0] (expected (ref 1), got (ref 0))");
 
   static const byte subexpr_type_error[] = {
       SECTION(Type, ENTRY_COUNT(1), WASM_ARRAY_DEF(kI64Code, true)),
-      SECTION(Global, ENTRY_COUNT(1),  // --
-              kRefCode, 0, 0,          // type, mutability
-              WASM_INIT_EXPR_ARRAY_NEW_FIXED_STATIC(0, 2, WASM_I64V(42),
-                                                    WASM_I32V(142)))};
+      SECTION(
+          Global, ENTRY_COUNT(1),  // --
+          kRefCode, 0, 0,          // type, mutability
+          WASM_INIT_EXPR_ARRAY_NEW_FIXED(0, 2, WASM_I64V(42), WASM_I32V(142)))};
   EXPECT_FAILURE_WITH_MSG(subexpr_type_error,
-                          "array.new_fixed_static[1] expected type i64, found "
+                          "array.new_fixed[1] expected type i64, found "
                           "i32.const of type i32");
 
   static const byte length_error[] = {
       SECTION(Type, ENTRY_COUNT(1), WASM_ARRAY_DEF(kI16Code, true)),
       SECTION(Global, ENTRY_COUNT(1),  // --
               kRefCode, 0, 0,          // type, mutability
-              WASM_INIT_EXPR_ARRAY_NEW_FIXED_STATIC(
-                  0, 10, WASM_I32V(10), WASM_I32V(20), WASM_I32V(30)))};
+              WASM_INIT_EXPR_ARRAY_NEW_FIXED(0, 10, WASM_I32V(10),
+                                             WASM_I32V(20), WASM_I32V(30)))};
   EXPECT_FAILURE_WITH_MSG(length_error,
                           "not enough arguments on the stack for "
-                          "array.new_fixed_static (need 11, got 4)");
+                          "array.new_fixed (need 11, got 4)");
 }
 
 TEST_F(WasmModuleVerifyTest, EmptyStruct) {
@@ -1039,7 +1039,7 @@ TEST_F(WasmModuleVerifyTest, TypeCanonicalization) {
               kWasmArrayTypeCode, kI32Code, 0),
       SECTION(Global,                          // --
               ENTRY_COUNT(1), kRefCode, 0, 0,  // Type, mutability
-              WASM_ARRAY_NEW_FIXED_STATIC(1, 1, WASM_I32V(10)),
+              WASM_ARRAY_NEW_FIXED(1, 1, WASM_I32V(10)),
               kExprEnd)  // initial value
   };
 
@@ -1056,7 +1056,7 @@ TEST_F(WasmModuleVerifyTest, TypeCanonicalization) {
               kWasmStructTypeCode, ENTRY_COUNT(0)),
       SECTION(Global,                          // --
               ENTRY_COUNT(1), kRefCode, 0, 0,  // Type, mutability
-              WASM_ARRAY_NEW_FIXED_STATIC(1, 1, WASM_I32V(10)),
+              WASM_ARRAY_NEW_FIXED(1, 1, WASM_I32V(10)),
               kExprEnd)  // initial value
   };