diff options
Diffstat (limited to 'src')
30 files changed, 106 insertions, 99 deletions
diff --git a/src/binaryen-c.cpp b/src/binaryen-c.cpp index 72b0e26ca..6beb2b97c 100644 --- a/src/binaryen-c.cpp +++ b/src/binaryen-c.cpp @@ -1825,16 +1825,16 @@ BinaryenExpressionRef BinaryenArrayNew(BinaryenModuleRef module, Builder(*(Module*)module) .makeArrayNew(HeapType(type), (Expression*)size, (Expression*)init)); } -BinaryenExpressionRef BinaryenArrayInit(BinaryenModuleRef module, - BinaryenHeapType type, - BinaryenExpressionRef* values, - BinaryenIndex numValues) { +BinaryenExpressionRef BinaryenArrayNewFixed(BinaryenModuleRef module, + BinaryenHeapType type, + BinaryenExpressionRef* values, + BinaryenIndex numValues) { std::vector<Expression*> vals; for (BinaryenIndex i = 0; i < numValues; i++) { vals.push_back((Expression*)values[i]); } return static_cast<Expression*>( - Builder(*(Module*)module).makeArrayInit(HeapType(type), vals)); + Builder(*(Module*)module).makeArrayNewFixed(HeapType(type), vals)); } BinaryenExpressionRef BinaryenArrayGet(BinaryenModuleRef module, BinaryenExpressionRef ref, @@ -4293,52 +4293,56 @@ void BinaryenArrayNewSetSize(BinaryenExpressionRef expr, assert(sizeExpr); static_cast<ArrayNew*>(expression)->size = (Expression*)sizeExpr; } -// ArrayInit -BinaryenIndex BinaryenArrayInitGetNumValues(BinaryenExpressionRef expr) { +// ArrayNewFixed +BinaryenIndex BinaryenArrayNewFixedGetNumValues(BinaryenExpressionRef expr) { auto* expression = (Expression*)expr; - assert(expression->is<ArrayInit>()); - return static_cast<ArrayInit*>(expression)->values.size(); + assert(expression->is<ArrayNewFixed>()); + return static_cast<ArrayNewFixed*>(expression)->values.size(); } -BinaryenExpressionRef BinaryenArrayInitGetValueAt(BinaryenExpressionRef expr, - BinaryenIndex index) { +BinaryenExpressionRef +BinaryenArrayNewFixedGetValueAt(BinaryenExpressionRef expr, + BinaryenIndex index) { auto* expression = (Expression*)expr; - assert(expression->is<ArrayInit>()); - assert(index < static_cast<ArrayInit*>(expression)->values.size()); - return static_cast<ArrayInit*>(expression)->values[index]; + assert(expression->is<ArrayNewFixed>()); + assert(index < static_cast<ArrayNewFixed*>(expression)->values.size()); + return static_cast<ArrayNewFixed*>(expression)->values[index]; } -void BinaryenArrayInitSetValueAt(BinaryenExpressionRef expr, - BinaryenIndex index, - BinaryenExpressionRef valueExpr) { +void BinaryenArrayNewFixedSetValueAt(BinaryenExpressionRef expr, + BinaryenIndex index, + BinaryenExpressionRef valueExpr) { auto* expression = (Expression*)expr; - assert(expression->is<ArrayInit>()); - assert(index < static_cast<ArrayInit*>(expression)->values.size()); + assert(expression->is<ArrayNewFixed>()); + assert(index < static_cast<ArrayNewFixed*>(expression)->values.size()); assert(valueExpr); - static_cast<ArrayInit*>(expression)->values[index] = (Expression*)valueExpr; + static_cast<ArrayNewFixed*>(expression)->values[index] = + (Expression*)valueExpr; } -BinaryenIndex BinaryenArrayInitAppendValue(BinaryenExpressionRef expr, - BinaryenExpressionRef valueExpr) { +BinaryenIndex +BinaryenArrayNewFixedAppendValue(BinaryenExpressionRef expr, + BinaryenExpressionRef valueExpr) { auto* expression = (Expression*)expr; - assert(expression->is<ArrayInit>()); + assert(expression->is<ArrayNewFixed>()); assert(valueExpr); - auto& list = static_cast<ArrayInit*>(expression)->values; + auto& list = static_cast<ArrayNewFixed*>(expression)->values; auto index = list.size(); list.push_back((Expression*)valueExpr); return index; } -void BinaryenArrayInitInsertValueAt(BinaryenExpressionRef expr, - BinaryenIndex index, - BinaryenExpressionRef valueExpr) { +void BinaryenArrayNewFixedInsertValueAt(BinaryenExpressionRef expr, + BinaryenIndex index, + BinaryenExpressionRef valueExpr) { auto* expression = (Expression*)expr; - assert(expression->is<ArrayInit>()); + assert(expression->is<ArrayNewFixed>()); assert(valueExpr); - static_cast<ArrayInit*>(expression) + static_cast<ArrayNewFixed*>(expression) ->values.insertAt(index, (Expression*)valueExpr); } -BinaryenExpressionRef BinaryenArrayInitRemoveValueAt(BinaryenExpressionRef expr, - BinaryenIndex index) { +BinaryenExpressionRef +BinaryenArrayNewFixedRemoveValueAt(BinaryenExpressionRef expr, + BinaryenIndex index) { auto* expression = (Expression*)expr; - assert(expression->is<ArrayInit>()); - return static_cast<ArrayInit*>(expression)->values.removeAt(index); + assert(expression->is<ArrayNewFixed>()); + return static_cast<ArrayNewFixed*>(expression)->values.removeAt(index); } // ArrayGet BinaryenExpressionRef BinaryenArrayGetGetRef(BinaryenExpressionRef expr) { diff --git a/src/binaryen-c.h b/src/binaryen-c.h index 94743d259..1a54e311c 100644 --- a/src/binaryen-c.h +++ b/src/binaryen-c.h @@ -1081,10 +1081,10 @@ BINARYEN_API BinaryenExpressionRef BinaryenArrayNew(BinaryenModuleRef module, // TODO: BinaryenArrayNewSeg BINARYEN_API BinaryenExpressionRef -BinaryenArrayInit(BinaryenModuleRef module, - BinaryenHeapType type, - BinaryenExpressionRef* values, - BinaryenIndex numValues); +BinaryenArrayNewFixed(BinaryenModuleRef module, + BinaryenHeapType type, + BinaryenExpressionRef* values, + BinaryenIndex numValues); BINARYEN_API BinaryenExpressionRef BinaryenArrayGet(BinaryenModuleRef module, BinaryenExpressionRef ref, BinaryenExpressionRef index, @@ -2453,23 +2453,24 @@ BinaryenArrayNewGetSize(BinaryenExpressionRef expr); BINARYEN_API void BinaryenArrayNewSetSize(BinaryenExpressionRef expr, BinaryenExpressionRef sizeExpr); -// ArrayInit +// ArrayNewFixed BINARYEN_API BinaryenIndex -BinaryenArrayInitGetNumValues(BinaryenExpressionRef expr); -BINARYEN_API BinaryenExpressionRef -BinaryenArrayInitGetValueAt(BinaryenExpressionRef expr, BinaryenIndex index); -BINARYEN_API void BinaryenArrayInitSetValueAt(BinaryenExpressionRef expr, - BinaryenIndex index, - BinaryenExpressionRef valueExpr); -BINARYEN_API BinaryenIndex BinaryenArrayInitAppendValue( +BinaryenArrayNewFixedGetNumValues(BinaryenExpressionRef expr); +BINARYEN_API BinaryenExpressionRef BinaryenArrayNewFixedGetValueAt( + BinaryenExpressionRef expr, BinaryenIndex index); +BINARYEN_API void +BinaryenArrayNewFixedSetValueAt(BinaryenExpressionRef expr, + BinaryenIndex index, + BinaryenExpressionRef valueExpr); +BINARYEN_API BinaryenIndex BinaryenArrayNewFixedAppendValue( BinaryenExpressionRef expr, BinaryenExpressionRef valueExpr); BINARYEN_API void -BinaryenArrayInitInsertValueAt(BinaryenExpressionRef expr, - BinaryenIndex index, - BinaryenExpressionRef valueExpr); -BINARYEN_API BinaryenExpressionRef -BinaryenArrayInitRemoveValueAt(BinaryenExpressionRef expr, BinaryenIndex index); +BinaryenArrayNewFixedInsertValueAt(BinaryenExpressionRef expr, + BinaryenIndex index, + BinaryenExpressionRef valueExpr); +BINARYEN_API BinaryenExpressionRef BinaryenArrayNewFixedRemoveValueAt( + BinaryenExpressionRef expr, BinaryenIndex index); // ArrayGet diff --git a/src/gen-s-parser.inc b/src/gen-s-parser.inc index 6bb1ed7dd..0022296a4 100644 --- a/src/gen-s-parser.inc +++ b/src/gen-s-parser.inc @@ -36,7 +36,7 @@ switch (buf[0]) { } } case 'i': - if (op == "array.init_static"sv) { return makeArrayInitStatic(s); } + if (op == "array.init_static"sv) { return makeArrayNewFixedStatic(s); } goto parse_error; case 'l': if (op == "array.len"sv) { return makeArrayLen(s); } @@ -3637,7 +3637,7 @@ switch (buf[0]) { } case 'i': if (op == "array.init_static"sv) { - auto ret = makeArrayInitStatic(ctx, pos); + auto ret = makeArrayNewFixedStatic(ctx, pos); CHECK_ERR(ret); return *ret; } diff --git a/src/ir/ReFinalize.cpp b/src/ir/ReFinalize.cpp index a5651c6b6..9c4946342 100644 --- a/src/ir/ReFinalize.cpp +++ b/src/ir/ReFinalize.cpp @@ -165,7 +165,7 @@ void ReFinalize::visitStructGet(StructGet* curr) { curr->finalize(); } void ReFinalize::visitStructSet(StructSet* curr) { curr->finalize(); } void ReFinalize::visitArrayNew(ArrayNew* curr) { curr->finalize(); } void ReFinalize::visitArrayNewSeg(ArrayNewSeg* curr) { curr->finalize(); } -void ReFinalize::visitArrayInit(ArrayInit* curr) { curr->finalize(); } +void ReFinalize::visitArrayNewFixed(ArrayNewFixed* curr) { curr->finalize(); } void ReFinalize::visitArrayGet(ArrayGet* curr) { curr->finalize(); } void ReFinalize::visitArraySet(ArraySet* curr) { curr->finalize(); } void ReFinalize::visitArrayLen(ArrayLen* curr) { curr->finalize(); } diff --git a/src/ir/cost.h b/src/ir/cost.h index 11c179d40..3e12318b6 100644 --- a/src/ir/cost.h +++ b/src/ir/cost.h @@ -639,7 +639,7 @@ struct CostAnalyzer : public OverriddenVisitor<CostAnalyzer, CostType> { CostType visitArrayNewSeg(ArrayNewSeg* curr) { return 4 + visit(curr->offset) + visit(curr->size); } - CostType visitArrayInit(ArrayInit* curr) { + CostType visitArrayNewFixed(ArrayNewFixed* curr) { CostType ret = 4; for (auto* child : curr->values) { ret += visit(child); diff --git a/src/ir/effects.h b/src/ir/effects.h index 4ea577f7a..59ef8bace 100644 --- a/src/ir/effects.h +++ b/src/ir/effects.h @@ -760,7 +760,7 @@ private: // segments. parent.implicitTrap = true; } - void visitArrayInit(ArrayInit* curr) {} + void visitArrayNewFixed(ArrayNewFixed* curr) {} void visitArrayGet(ArrayGet* curr) { if (curr->ref->type.isNull()) { parent.trap = true; diff --git a/src/ir/module-utils.cpp b/src/ir/module-utils.cpp index 9dfc5f123..a6d2633ff 100644 --- a/src/ir/module-utils.cpp +++ b/src/ir/module-utils.cpp @@ -69,7 +69,7 @@ struct CodeScanner counts.note(curr->type); } else if (curr->is<ArrayNewSeg>()) { counts.note(curr->type); - } else if (curr->is<ArrayInit>()) { + } else if (curr->is<ArrayNewFixed>()) { counts.note(curr->type); } else if (auto* cast = curr->dynCast<RefCast>()) { counts.note(cast->type); diff --git a/src/ir/possible-contents.cpp b/src/ir/possible-contents.cpp index cf30cd917..d292529dc 100644 --- a/src/ir/possible-contents.cpp +++ b/src/ir/possible-contents.cpp @@ -910,7 +910,7 @@ struct InfoCollector } WASM_UNREACHABLE("unexpected op"); } - void visitArrayInit(ArrayInit* curr) { + void visitArrayNewFixed(ArrayNewFixed* curr) { if (curr->type == Type::unreachable) { return; } diff --git a/src/ir/properties.cpp b/src/ir/properties.cpp index b5d2df952..8aef0baaa 100644 --- a/src/ir/properties.cpp +++ b/src/ir/properties.cpp @@ -30,7 +30,7 @@ bool isGenerative(Expression* curr, FeatureSet features) { bool generative = false; void visitStructNew(StructNew* curr) { generative = true; } void visitArrayNew(ArrayNew* curr) { generative = true; } - void visitArrayInit(ArrayInit* curr) { generative = true; } + void visitArrayNewFixed(ArrayNewFixed* curr) { generative = true; } } scanner; scanner.walk(curr); return scanner.generative; diff --git a/src/ir/properties.h b/src/ir/properties.h index fb0065948..43f74ceb8 100644 --- a/src/ir/properties.h +++ b/src/ir/properties.h @@ -455,8 +455,9 @@ bool isGenerative(Expression* curr, FeatureSet features); inline bool isValidInConstantExpression(Expression* expr, FeatureSet features) { if (isSingleConstantExpression(expr) || expr->is<GlobalGet>() || - expr->is<StructNew>() || expr->is<ArrayNew>() || expr->is<ArrayInit>() || - expr->is<I31New>() || expr->is<StringConst>()) { + expr->is<StructNew>() || expr->is<ArrayNew>() || + expr->is<ArrayNewFixed>() || expr->is<I31New>() || + expr->is<StringConst>()) { return true; } diff --git a/src/js/binaryen.js-post.js b/src/js/binaryen.js-post.js index 3fe73f179..8c0b7873c 100644 --- a/src/js/binaryen.js-post.js +++ b/src/js/binaryen.js-post.js @@ -115,7 +115,7 @@ function initializeConstants() { 'StructGet', 'StructSet', 'ArrayNew', - 'ArrayInit', + 'ArrayNewFixed', 'ArrayGet', 'ArraySet', 'ArrayLen', diff --git a/src/passes/Precompute.cpp b/src/passes/Precompute.cpp index 5fff7710b..18139de3f 100644 --- a/src/passes/Precompute.cpp +++ b/src/passes/Precompute.cpp @@ -155,8 +155,8 @@ public: } return getHeapCreationFlow(flow, curr); } - Flow visitArrayInit(ArrayInit* curr) { - auto flow = Super::visitArrayInit(curr); + Flow visitArrayNewFixed(ArrayNewFixed* curr) { + auto flow = Super::visitArrayNewFixed(curr); if (flow.breaking()) { return flow; } diff --git a/src/passes/Print.cpp b/src/passes/Print.cpp index f7cfb7746..85fd2c21a 100644 --- a/src/passes/Print.cpp +++ b/src/passes/Print.cpp @@ -2285,7 +2285,7 @@ struct PrintExpressionContents TypeNamePrinter(o, wasm).print(curr->type.getHeapType()); o << ' ' << curr->segment; } - void visitArrayInit(ArrayInit* curr) { + void visitArrayNewFixed(ArrayNewFixed* curr) { if (printUnreachableReplacement(curr)) { return; } @@ -2895,7 +2895,7 @@ struct PrintSExpression : public UnifiedExpressionVisitor<PrintSExpression> { void visitArrayNewSeg(ArrayNewSeg* curr) { maybePrintUnreachableReplacement(curr, curr->type); } - void visitArrayInit(ArrayInit* curr) { + void visitArrayNewFixed(ArrayNewFixed* curr) { maybePrintUnreachableReplacement(curr, curr->type); } void visitArraySet(ArraySet* curr) { diff --git a/src/passes/TypeSSA.cpp b/src/passes/TypeSSA.cpp index 17f166a9e..9e3a57815 100644 --- a/src/passes/TypeSSA.cpp +++ b/src/passes/TypeSSA.cpp @@ -68,7 +68,7 @@ struct NewFinder : public PostWalker<NewFinder> { void visitStructNew(StructNew* curr) { news.push_back(curr); } void visitArrayNew(ArrayNew* curr) { news.push_back(curr); } void visitArrayNewSeg(ArrayNewSeg* curr) { news.push_back(curr); } - void visitArrayInit(ArrayInit* curr) { news.push_back(curr); } + void visitArrayNewFixed(ArrayNewFixed* curr) { news.push_back(curr); } }; struct TypeSSA : public Pass { @@ -289,7 +289,7 @@ struct TypeSSA : public Pass { } else if (curr->is<ArrayNewSeg>()) { // TODO: If the element segment is immutable perhaps we could inspect it. return true; - } else if (auto* arrayInit = curr->dynCast<ArrayInit>()) { + } else if (auto* arrayInit = curr->dynCast<ArrayNewFixed>()) { // All the items must be interesting for us to consider this interesting, // as we only track a single value for all indexes in the array, so one // boring value means it is all boring. diff --git a/src/tools/fuzzing/fuzzing.cpp b/src/tools/fuzzing/fuzzing.cpp index bb3a76766..6e728d3a6 100644 --- a/src/tools/fuzzing/fuzzing.cpp +++ b/src/tools/fuzzing/fuzzing.cpp @@ -2099,7 +2099,7 @@ Expression* TranslateToFuzzReader::makeConstBasicRef(Type type) { // --nominal mode. static HeapType trivialArray = HeapType(Array(Field(Field::PackedType::i8, Immutable))); - return builder.makeArrayInit(trivialArray, {}); + return builder.makeArrayNewFixed(trivialArray, {}); } case HeapType::string: return builder.makeStringConst(std::to_string(upTo(1024))); diff --git a/src/tools/wasm-ctor-eval.cpp b/src/tools/wasm-ctor-eval.cpp index 13e2d5767..00bceac8f 100644 --- a/src/tools/wasm-ctor-eval.cpp +++ b/src/tools/wasm-ctor-eval.cpp @@ -613,7 +613,7 @@ public: init = builder.makeStructNew(heapType, args); } else if (heapType.isArray()) { // TODO: for repeated identical values, can use ArrayNew - init = builder.makeArrayInit(heapType, args); + init = builder.makeArrayNewFixed(heapType, args); } else { WASM_UNREACHABLE("bad gc type"); } diff --git a/src/wasm-binary.h b/src/wasm-binary.h index a5b4202a0..1e86252a1 100644 --- a/src/wasm-binary.h +++ b/src/wasm-binary.h @@ -1110,7 +1110,7 @@ enum ASTNodes { ArrayLenAnnotated = 0x17, ArrayCopy = 0x18, ArrayLen = 0x19, - ArrayInitStatic = 0x1a, + ArrayNewFixedStatic = 0x1a, ArrayNew = 0x1b, ArrayNewDefault = 0x1c, ArrayNewData = 0x1d, @@ -1718,7 +1718,7 @@ public: bool maybeVisitStructSet(Expression*& out, uint32_t code); bool maybeVisitArrayNew(Expression*& out, uint32_t code); bool maybeVisitArrayNewSeg(Expression*& out, uint32_t code); - bool maybeVisitArrayInit(Expression*& out, uint32_t code); + bool maybeVisitArrayNewFixed(Expression*& out, uint32_t code); bool maybeVisitArrayGet(Expression*& out, uint32_t code); bool maybeVisitArraySet(Expression*& out, uint32_t code); bool maybeVisitArrayLen(Expression*& out, uint32_t code); diff --git a/src/wasm-builder.h b/src/wasm-builder.h index 5592273da..8d4235357 100644 --- a/src/wasm-builder.h +++ b/src/wasm-builder.h @@ -948,9 +948,9 @@ public: ret->finalize(); return ret; } - ArrayInit* makeArrayInit(HeapType type, - const std::vector<Expression*>& values) { - auto* ret = wasm.allocator.alloc<ArrayInit>(); + ArrayNewFixed* makeArrayNewFixed(HeapType type, + const std::vector<Expression*>& values) { + auto* ret = wasm.allocator.alloc<ArrayNewFixed>(); ret->values.set(values); ret->type = Type(type, NonNullable); ret->finalize(); diff --git a/src/wasm-delegations-fields.def b/src/wasm-delegations-fields.def index e3ec30a40..92ab4c9d3 100644 --- a/src/wasm-delegations-fields.def +++ b/src/wasm-delegations-fields.def @@ -672,10 +672,10 @@ switch (DELEGATE_ID) { DELEGATE_END(ArrayNewSeg); break; } - case Expression::Id::ArrayInitId: { - DELEGATE_START(ArrayInit); - DELEGATE_FIELD_CHILD_VECTOR(ArrayInit, values); - DELEGATE_END(ArrayInit); + case Expression::Id::ArrayNewFixedId: { + DELEGATE_START(ArrayNewFixed); + DELEGATE_FIELD_CHILD_VECTOR(ArrayNewFixed, values); + DELEGATE_END(ArrayNewFixed); break; } case Expression::Id::ArrayGetId: { diff --git a/src/wasm-delegations.def b/src/wasm-delegations.def index d2b5dfa2e..922bb7c87 100644 --- a/src/wasm-delegations.def +++ b/src/wasm-delegations.def @@ -78,7 +78,7 @@ DELEGATE(StructGet); DELEGATE(StructSet); DELEGATE(ArrayNew); DELEGATE(ArrayNewSeg); -DELEGATE(ArrayInit); +DELEGATE(ArrayNewFixed); DELEGATE(ArrayGet); DELEGATE(ArraySet); DELEGATE(ArrayLen); diff --git a/src/wasm-interpreter.h b/src/wasm-interpreter.h index 4615e8625..8e82bdf80 100644 --- a/src/wasm-interpreter.h +++ b/src/wasm-interpreter.h @@ -1635,8 +1635,8 @@ public: curr->type.getHeapType()); } Flow visitArrayNewSeg(ArrayNewSeg* curr) { WASM_UNREACHABLE("unimp"); } - Flow visitArrayInit(ArrayInit* curr) { - NOTE_ENTER("ArrayInit"); + Flow visitArrayNewFixed(ArrayNewFixed* curr) { + NOTE_ENTER("ArrayNewFixed"); Index num = curr->values.size(); if (num >= ArrayLimit) { hostLimit("allocation failure"); diff --git a/src/wasm-s-parser.h b/src/wasm-s-parser.h index d6a9c86d6..a52915441 100644 --- a/src/wasm-s-parser.h +++ b/src/wasm-s-parser.h @@ -297,7 +297,7 @@ private: Expression* makeStructSet(Element& s); Expression* makeArrayNew(Element& s, bool default_); Expression* makeArrayNewSeg(Element& s, ArrayNewSegOp op); - Expression* makeArrayInitStatic(Element& s); + Expression* makeArrayNewFixedStatic(Element& s); Expression* makeArrayGet(Element& s, bool signed_ = false); Expression* makeArraySet(Element& s); Expression* makeArrayLen(Element& s); diff --git a/src/wasm.h b/src/wasm.h index eec68ebd5..0f188f7b0 100644 --- a/src/wasm.h +++ b/src/wasm.h @@ -717,7 +717,7 @@ public: StructSetId, ArrayNewId, ArrayNewSegId, - ArrayInitId, + ArrayNewFixedId, ArrayGetId, ArraySetId, ArrayLenId, @@ -1615,9 +1615,9 @@ public: void finalize(); }; -class ArrayInit : public SpecificExpression<Expression::ArrayInitId> { +class ArrayNewFixed : public SpecificExpression<Expression::ArrayNewFixedId> { public: - ArrayInit(MixedArena& allocator) : values(allocator) {} + ArrayNewFixed(MixedArena& allocator) : values(allocator) {} ExpressionList values; diff --git a/src/wasm/wasm-binary.cpp b/src/wasm/wasm-binary.cpp index bb6f082f8..e5e05bacc 100644 --- a/src/wasm/wasm-binary.cpp +++ b/src/wasm/wasm-binary.cpp @@ -3987,7 +3987,7 @@ BinaryConsts::ASTNodes WasmBinaryBuilder::readExpression(Expression*& curr) { if (maybeVisitArrayNewSeg(curr, opcode)) { break; } - if (maybeVisitArrayInit(curr, opcode)) { + if (maybeVisitArrayNewFixed(curr, opcode)) { break; } if (maybeVisitArrayGet(curr, opcode)) { @@ -7109,15 +7109,16 @@ bool WasmBinaryBuilder::maybeVisitArrayNewSeg(Expression*& out, uint32_t code) { return false; } -bool WasmBinaryBuilder::maybeVisitArrayInit(Expression*& out, uint32_t code) { - if (code == BinaryConsts::ArrayInitStatic) { +bool WasmBinaryBuilder::maybeVisitArrayNewFixed(Expression*& out, + uint32_t code) { + if (code == BinaryConsts::ArrayNewFixedStatic) { auto heapType = getIndexedHeapType(); auto size = getU32LEB(); std::vector<Expression*> values(size); for (size_t i = 0; i < size; i++) { values[size - i - 1] = popNonVoidExpression(); } - out = Builder(wasm).makeArrayInit(heapType, values); + out = Builder(wasm).makeArrayNewFixed(heapType, values); return true; } return false; diff --git a/src/wasm/wasm-s-parser.cpp b/src/wasm/wasm-s-parser.cpp index 6bbd82476..4f4b28754 100644 --- a/src/wasm/wasm-s-parser.cpp +++ b/src/wasm/wasm-s-parser.cpp @@ -2925,14 +2925,14 @@ Expression* SExpressionWasmBuilder::makeArrayNewSeg(Element& s, return Builder(wasm).makeArrayNewSeg(op, heapType, seg, offset, size); } -Expression* SExpressionWasmBuilder::makeArrayInitStatic(Element& s) { +Expression* SExpressionWasmBuilder::makeArrayNewFixedStatic(Element& s) { auto heapType = parseHeapType(*s[1]); size_t i = 2; std::vector<Expression*> values; while (i < s.size()) { values.push_back(parseExpression(*s[i++])); } - return Builder(wasm).makeArrayInit(heapType, values); + return Builder(wasm).makeArrayNewFixed(heapType, values); } Expression* SExpressionWasmBuilder::makeArrayGet(Element& s, bool signed_) { diff --git a/src/wasm/wasm-stack.cpp b/src/wasm/wasm-stack.cpp index 1c12718ce..3f53e3dde 100644 --- a/src/wasm/wasm-stack.cpp +++ b/src/wasm/wasm-stack.cpp @@ -2193,9 +2193,9 @@ void BinaryInstWriter::visitArrayNewSeg(ArrayNewSeg* curr) { o << U32LEB(curr->segment); } -void BinaryInstWriter::visitArrayInit(ArrayInit* curr) { +void BinaryInstWriter::visitArrayNewFixed(ArrayNewFixed* curr) { o << int8_t(BinaryConsts::GCPrefix); - o << U32LEB(BinaryConsts::ArrayInitStatic); + o << U32LEB(BinaryConsts::ArrayNewFixedStatic); parent.writeIndexedHeapType(curr->type.getHeapType()); o << U32LEB(curr->values.size()); } diff --git a/src/wasm/wasm-validator.cpp b/src/wasm/wasm-validator.cpp index a56f26be3..33e737ae1 100644 --- a/src/wasm/wasm-validator.cpp +++ b/src/wasm/wasm-validator.cpp @@ -456,7 +456,7 @@ public: void visitStructSet(StructSet* curr); void visitArrayNew(ArrayNew* curr); void visitArrayNewSeg(ArrayNewSeg* curr); - void visitArrayInit(ArrayInit* curr); + void visitArrayNewFixed(ArrayNewFixed* curr); void visitArrayGet(ArrayGet* curr); void visitArraySet(ArraySet* curr); void visitArrayLen(ArrayLen* curr); @@ -2774,7 +2774,7 @@ void FunctionValidator::visitArrayNewSeg(ArrayNewSeg* curr) { } } -void FunctionValidator::visitArrayInit(ArrayInit* curr) { +void FunctionValidator::visitArrayNewFixed(ArrayNewFixed* curr) { shouldBeTrue(getModule()->features.hasGC(), curr, "array.init requires gc [--enable-gc]"); diff --git a/src/wasm/wasm.cpp b/src/wasm/wasm.cpp index f58aaf0da..54e9dd142 100644 --- a/src/wasm/wasm.cpp +++ b/src/wasm/wasm.cpp @@ -1063,7 +1063,7 @@ void ArrayNewSeg::finalize() { } } -void ArrayInit::finalize() { +void ArrayNewFixed::finalize() { for (auto* value : values) { if (value->type == Type::unreachable) { type = Type::unreachable; diff --git a/src/wasm/wat-parser.cpp b/src/wasm/wat-parser.cpp index 1408ffe0d..ee48d7262 100644 --- a/src/wasm/wat-parser.cpp +++ b/src/wasm/wat-parser.cpp @@ -2365,7 +2365,7 @@ Result<typename Ctx::InstrT> makeArrayNew(Ctx&, Index, bool default_); template<typename Ctx> Result<typename Ctx::InstrT> makeArrayNewSeg(Ctx&, Index, ArrayNewSegOp op); template<typename Ctx> -Result<typename Ctx::InstrT> makeArrayInitStatic(Ctx&, Index); +Result<typename Ctx::InstrT> makeArrayNewFixedStatic(Ctx&, Index); template<typename Ctx> Result<typename Ctx::InstrT> makeArrayGet(Ctx&, Index, bool signed_ = false); template<typename Ctx> Result<typename Ctx::InstrT> makeArraySet(Ctx&, Index); @@ -3525,7 +3525,7 @@ makeArrayNewSeg(Ctx& ctx, Index pos, ArrayNewSegOp op) { } template<typename Ctx> -Result<typename Ctx::InstrT> makeArrayInitStatic(Ctx& ctx, Index pos) { +Result<typename Ctx::InstrT> makeArrayNewFixedStatic(Ctx& ctx, Index pos) { return ctx.in.err("unimplemented instruction"); } diff --git a/src/wasm2js.h b/src/wasm2js.h index 45721bd75..03cde4347 100644 --- a/src/wasm2js.h +++ b/src/wasm2js.h @@ -2303,7 +2303,7 @@ Ref Wasm2JSBuilder::processFunctionBody(Module* m, unimplemented(curr); WASM_UNREACHABLE("unimp"); } - Ref visitArrayInit(ArrayInit* curr) { + Ref visitArrayNewFixed(ArrayNewFixed* curr) { unimplemented(curr); WASM_UNREACHABLE("unimp"); } |