diff --git a/scripts/gen-s-parser.py b/scripts/gen-s-parser.py index 113eaeaa1c0..451430cc9d8 100755 --- a/scripts/gen-s-parser.py +++ b/scripts/gen-s-parser.py @@ -622,6 +622,7 @@ ("string.encode_wtf8", "makeStringEncode(s, StringEncodeWTF8)"), ("string.encode_wtf16", "makeStringEncode(s, StringEncodeWTF16)"), ("string.concat", "makeStringConcat(s)"), + ("string.eq", "makeStringEq(s)"), ] diff --git a/src/gen-s-parser.inc b/src/gen-s-parser.inc index be1ab85e7bc..9c3fa90e4b3 100644 --- a/src/gen-s-parser.inc +++ b/src/gen-s-parser.inc @@ -3141,12 +3141,20 @@ switch (op[0]) { } } case 'e': { - switch (op[17]) { - case '1': - if (strcmp(op, "string.encode_wtf16") == 0) { return makeStringEncode(s, StringEncodeWTF16); } - goto parse_error; - case '8': - if (strcmp(op, "string.encode_wtf8") == 0) { return makeStringEncode(s, StringEncodeWTF8); } + switch (op[8]) { + case 'n': { + switch (op[17]) { + case '1': + if (strcmp(op, "string.encode_wtf16") == 0) { return makeStringEncode(s, StringEncodeWTF16); } + goto parse_error; + case '8': + if (strcmp(op, "string.encode_wtf8") == 0) { return makeStringEncode(s, StringEncodeWTF8); } + goto parse_error; + default: goto parse_error; + } + } + case 'q': + if (strcmp(op, "string.eq") == 0) { return makeStringEq(s); } goto parse_error; default: goto parse_error; } diff --git a/src/ir/ReFinalize.cpp b/src/ir/ReFinalize.cpp index 102d701b901..f509ab2619e 100644 --- a/src/ir/ReFinalize.cpp +++ b/src/ir/ReFinalize.cpp @@ -177,6 +177,7 @@ void ReFinalize::visitStringConst(StringConst* curr) { curr->finalize(); } void ReFinalize::visitStringMeasure(StringMeasure* curr) { curr->finalize(); } void ReFinalize::visitStringEncode(StringEncode* curr) { curr->finalize(); } void ReFinalize::visitStringConcat(StringConcat* curr) { curr->finalize(); } +void ReFinalize::visitStringEq(StringEq* curr) { curr->finalize(); } void ReFinalize::visitFunction(Function* curr) { // we may have changed the body from unreachable to none, which might be bad diff --git a/src/ir/cost.h b/src/ir/cost.h index 2dcf7c456a2..ea07e61097c 100644 --- a/src/ir/cost.h +++ b/src/ir/cost.h @@ -684,6 +684,10 @@ struct CostAnalyzer : public OverriddenVisitor { CostType visitStringConcat(StringConcat* curr) { return 10 + visit(curr->left) + visit(curr->right); } + CostType visitStringEq(StringEq* curr) { + // "3" is chosen since strings might or might not be interned in the engine. + return 3 + visit(curr->left) + visit(curr->right); + } private: CostType nullCheckCost(Expression* ref) { diff --git a/src/ir/effects.h b/src/ir/effects.h index dbd1bb48f90..0dd0902b104 100644 --- a/src/ir/effects.h +++ b/src/ir/effects.h @@ -746,6 +746,7 @@ class EffectAnalyzer { // traps when an input is null. parent.implicitTrap = true; } + void visitStringEq(StringEq* curr) {} }; public: diff --git a/src/ir/possible-contents.cpp b/src/ir/possible-contents.cpp index 21eadc50be6..7db493f0002 100644 --- a/src/ir/possible-contents.cpp +++ b/src/ir/possible-contents.cpp @@ -693,6 +693,10 @@ struct InfoCollector // TODO: optimize when possible addRoot(curr); } + void visitStringEq(StringEq* curr) { + // TODO: optimize when possible + addRoot(curr); + } // TODO: Model which throws can go to which catches. For now, anything thrown // is sent to the location of that tag, and any catch of that tag can diff --git a/src/passes/Print.cpp b/src/passes/Print.cpp index dc02144538a..cf4e6c9e97b 100644 --- a/src/passes/Print.cpp +++ b/src/passes/Print.cpp @@ -2275,6 +2275,7 @@ struct PrintExpressionContents void visitStringConcat(StringConcat* curr) { printMedium(o, "string.concat"); } + void visitStringEq(StringEq* curr) { printMedium(o, "string.eq"); } }; // Prints an expression in s-expr format, including both the diff --git a/src/wasm-binary.h b/src/wasm-binary.h index 6734d3bd6a4..f89391186a8 100644 --- a/src/wasm-binary.h +++ b/src/wasm-binary.h @@ -1145,6 +1145,7 @@ enum ASTNodes { StringEncodeWTF8 = 0x86, StringEncodeWTF16 = 0x87, StringConcat = 0x88, + StringEq = 0x89, }; enum MemoryAccess { @@ -1730,6 +1731,7 @@ class WasmBinaryBuilder { bool maybeVisitStringMeasure(Expression*& out, uint32_t code); bool maybeVisitStringEncode(Expression*& out, uint32_t code); bool maybeVisitStringConcat(Expression*& out, uint32_t code); + bool maybeVisitStringEq(Expression*& out, uint32_t code); void visitSelect(Select* curr, uint8_t code); void visitReturn(Return* curr); void visitMemorySize(MemorySize* curr); diff --git a/src/wasm-builder.h b/src/wasm-builder.h index b9bb2f7aa6a..507aa510b78 100644 --- a/src/wasm-builder.h +++ b/src/wasm-builder.h @@ -1027,6 +1027,13 @@ class Builder { ret->finalize(); return ret; } + StringEq* makeStringEq(Expression* left, Expression* right) { + auto* ret = wasm.allocator.alloc(); + ret->left = left; + ret->right = right; + ret->finalize(); + return ret; + } // Additional helpers diff --git a/src/wasm-delegations-fields.def b/src/wasm-delegations-fields.def index 7f450b16de6..0ac154726b1 100644 --- a/src/wasm-delegations-fields.def +++ b/src/wasm-delegations-fields.def @@ -749,6 +749,13 @@ switch (DELEGATE_ID) { DELEGATE_END(StringConcat); break; } + case Expression::Id::StringEqId: { + DELEGATE_START(StringEq); + DELEGATE_FIELD_CHILD(StringEq, right); + DELEGATE_FIELD_CHILD(StringEq, left); + DELEGATE_END(StringEq); + break; + } } #undef DELEGATE_ID diff --git a/src/wasm-delegations.def b/src/wasm-delegations.def index 7802c63fbad..c5cfa693271 100644 --- a/src/wasm-delegations.def +++ b/src/wasm-delegations.def @@ -90,5 +90,6 @@ DELEGATE(StringConst); DELEGATE(StringMeasure); DELEGATE(StringEncode); DELEGATE(StringConcat); +DELEGATE(StringEq); #undef DELEGATE diff --git a/src/wasm-interpreter.h b/src/wasm-interpreter.h index 05de81256ec..02c95957dc3 100644 --- a/src/wasm-interpreter.h +++ b/src/wasm-interpreter.h @@ -1970,6 +1970,9 @@ class ExpressionRunner : public OverriddenVisitor { Flow visitStringConcat(StringConcat* curr) { WASM_UNREACHABLE("unimplemented string.concat"); } + Flow visitStringEq(StringEq* curr) { + WASM_UNREACHABLE("unimplemented string.eq"); + } virtual void trap(const char* why) { WASM_UNREACHABLE("unimp"); } diff --git a/src/wasm-s-parser.h b/src/wasm-s-parser.h index 9eb4a2085c8..777d33e308f 100644 --- a/src/wasm-s-parser.h +++ b/src/wasm-s-parser.h @@ -308,6 +308,7 @@ class SExpressionWasmBuilder { Expression* makeStringMeasure(Element& s, StringMeasureOp op); Expression* makeStringEncode(Element& s, StringEncodeOp op); Expression* makeStringConcat(Element& s); + Expression* makeStringEq(Element& s); // Helper functions Type parseOptionalResultType(Element& s, Index& i); diff --git a/src/wasm.h b/src/wasm.h index 957d2d36801..41eaf328af0 100644 --- a/src/wasm.h +++ b/src/wasm.h @@ -702,6 +702,7 @@ class Expression { StringMeasureId, StringEncodeId, StringConcatId, + StringEqId, NumExpressionIds }; Id _id; @@ -1725,6 +1726,16 @@ class StringConcat : public SpecificExpression { void finalize(); }; +class StringEq : public SpecificExpression { +public: + StringEq(MixedArena& allocator) {} + + Expression* left; + Expression* right; + + void finalize(); +}; + // Globals struct Named { diff --git a/src/wasm/wasm-binary.cpp b/src/wasm/wasm-binary.cpp index 5aa5948fe85..ef564db6e14 100644 --- a/src/wasm/wasm-binary.cpp +++ b/src/wasm/wasm-binary.cpp @@ -3933,6 +3933,9 @@ BinaryConsts::ASTNodes WasmBinaryBuilder::readExpression(Expression*& curr) { if (maybeVisitStringConcat(curr, opcode)) { break; } + if (maybeVisitStringEq(curr, opcode)) { + break; + } if (opcode == BinaryConsts::RefIsFunc || opcode == BinaryConsts::RefIsData || opcode == BinaryConsts::RefIsI31) { @@ -7234,6 +7237,16 @@ bool WasmBinaryBuilder::maybeVisitStringConcat(Expression*& out, return true; } +bool WasmBinaryBuilder::maybeVisitStringEq(Expression*& out, uint32_t code) { + if (code != BinaryConsts::StringEq) { + return false; + } + auto* right = popNonVoidExpression(); + auto* left = popNonVoidExpression(); + out = Builder(wasm).makeStringEq(left, right); + return true; +} + void WasmBinaryBuilder::visitRefAs(RefAs* curr, uint8_t code) { BYN_TRACE("zz node: RefAs\n"); switch (code) { diff --git a/src/wasm/wasm-s-parser.cpp b/src/wasm/wasm-s-parser.cpp index fe52864d86f..ecb8c243209 100644 --- a/src/wasm/wasm-s-parser.cpp +++ b/src/wasm/wasm-s-parser.cpp @@ -2995,6 +2995,11 @@ Expression* SExpressionWasmBuilder::makeStringConcat(Element& s) { parseExpression(s[2])); } +Expression* SExpressionWasmBuilder::makeStringEq(Element& s) { + return Builder(wasm).makeStringEq(parseExpression(s[1]), + parseExpression(s[2])); +} + // converts an s-expression string representing binary data into an output // sequence of raw bytes this appends to data, which may already contain // content. diff --git a/src/wasm/wasm-stack.cpp b/src/wasm/wasm-stack.cpp index 6596cccc7d2..9a5db2928df 100644 --- a/src/wasm/wasm-stack.cpp +++ b/src/wasm/wasm-stack.cpp @@ -2304,6 +2304,10 @@ void BinaryInstWriter::visitStringConcat(StringConcat* curr) { o << int8_t(BinaryConsts::GCPrefix) << U32LEB(BinaryConsts::StringConcat); } +void BinaryInstWriter::visitStringEq(StringEq* curr) { + o << int8_t(BinaryConsts::GCPrefix) << U32LEB(BinaryConsts::StringEq); +} + void BinaryInstWriter::emitScopeEnd(Expression* curr) { assert(!breakStack.empty()); breakStack.pop_back(); diff --git a/src/wasm/wasm.cpp b/src/wasm/wasm.cpp index d3b1c215112..5e316d4f4f5 100644 --- a/src/wasm/wasm.cpp +++ b/src/wasm/wasm.cpp @@ -1208,6 +1208,14 @@ void StringConcat::finalize() { } } +void StringEq::finalize() { + if (left->type == Type::unreachable || right->type == Type::unreachable) { + type = Type::unreachable; + } else { + type = Type::i32; + } +} + size_t Function::getNumParams() { return getParams().size(); } size_t Function::getNumVars() { return vars.size(); } diff --git a/src/wasm2js.h b/src/wasm2js.h index c6b5cbb6c41..f8179379d9d 100644 --- a/src/wasm2js.h +++ b/src/wasm2js.h @@ -2323,6 +2323,10 @@ Ref Wasm2JSBuilder::processFunctionBody(Module* m, unimplemented(curr); WASM_UNREACHABLE("unimp"); } + Ref visitStringEq(StringEq* curr) { + unimplemented(curr); + WASM_UNREACHABLE("unimp"); + } Ref visitRefAs(RefAs* curr) { unimplemented(curr); WASM_UNREACHABLE("unimp"); diff --git a/test/lit/strings.wast b/test/lit/strings.wast index 64974d0051d..687de8e3dab 100644 --- a/test/lit/strings.wast +++ b/test/lit/strings.wast @@ -7,12 +7,12 @@ (module ;; CHECK: (type $ref?|string|_=>_none (func (param stringref))) + ;; CHECK: (type $ref?|string|_ref?|string|_=>_none (func (param stringref stringref))) + ;; CHECK: (type $ref?|string|_ref?|stringview_wtf8|_ref?|stringview_wtf16|_ref?|stringview_iter|_ref?|string|_ref?|stringview_wtf8|_ref?|stringview_wtf16|_ref?|stringview_iter|_ref|string|_ref|stringview_wtf8|_ref|stringview_wtf16|_ref|stringview_iter|_=>_none (func (param stringref stringview_wtf8 stringview_wtf16 stringview_iter stringref stringview_wtf8 stringview_wtf16 stringview_iter (ref string) (ref stringview_wtf8) (ref stringview_wtf16) (ref stringview_iter)))) ;; CHECK: (type $none_=>_none (func)) - ;; CHECK: (type $ref?|string|_ref?|string|_=>_none (func (param stringref stringref))) - ;; CHECK: (global $string-const stringref (string.const "string in a global")) (global $string-const stringref (string.const "string in a global")) @@ -204,4 +204,25 @@ ) ) ) + + ;; CHECK: (func $string.eq (param $a stringref) (param $b stringref) + ;; CHECK-NEXT: (drop + ;; CHECK-NEXT: (i32.eqz + ;; CHECK-NEXT: (string.eq + ;; CHECK-NEXT: (local.get $a) + ;; CHECK-NEXT: (local.get $b) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: ) + (func $string.eq (param $a stringref) (param $b stringref) + (drop + (i32.eqz ;; validate the output is an i32 + (string.eq + (local.get $a) + (local.get $b) + ) + ) + ) + ) )