summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/binaryen-c.cpp86
-rw-r--r--src/binaryen-c.h39
-rw-r--r--src/gen-s-parser.inc367
-rw-r--r--src/ir/child-typer.h41
-rw-r--r--src/ir/cost.h6
-rw-r--r--src/ir/effects.h36
-rw-r--r--src/js/binaryen.js-post.js14
-rw-r--r--src/parser/contexts.h48
-rw-r--r--src/parser/parsers.h33
-rw-r--r--src/passes/Precompute.cpp6
-rw-r--r--src/passes/Print.cpp53
-rw-r--r--src/passes/StringLowering.cpp11
-rw-r--r--src/tools/fuzzing/fuzzing.cpp5
-rw-r--r--src/wasm-binary.h15
-rw-r--r--src/wasm-builder.h31
-rw-r--r--src/wasm-delegations-fields.def8
-rw-r--r--src/wasm-interpreter.h35
-rw-r--r--src/wasm-ir-builder.h4
-rw-r--r--src/wasm-s-parser.h2
-rw-r--r--src/wasm.h44
-rw-r--r--src/wasm/wasm-binary.cpp111
-rw-r--r--src/wasm/wasm-ir-builder.cpp73
-rw-r--r--src/wasm/wasm-s-parser.cpp33
-rw-r--r--src/wasm/wasm-stack.cpp65
-rw-r--r--src/wasm/wasm-validator.cpp42
-rw-r--r--src/wasm/wasm.cpp9
26 files changed, 215 insertions, 1002 deletions
diff --git a/src/binaryen-c.cpp b/src/binaryen-c.cpp
index a9a21bc14..f60e5ec59 100644
--- a/src/binaryen-c.cpp
+++ b/src/binaryen-c.cpp
@@ -1019,12 +1019,6 @@ BinaryenOp BinaryenBrOnNull(void) { return BrOnNull; }
BinaryenOp BinaryenBrOnNonNull(void) { return BrOnNonNull; }
BinaryenOp BinaryenBrOnCast(void) { return BrOnCast; }
BinaryenOp BinaryenBrOnCastFail(void) { return BrOnCastFail; };
-BinaryenOp BinaryenStringNewUTF8(void) { return StringNewUTF8; }
-BinaryenOp BinaryenStringNewWTF8(void) { return StringNewWTF8; }
-BinaryenOp BinaryenStringNewLossyUTF8(void) { return StringNewLossyUTF8; }
-BinaryenOp BinaryenStringNewWTF16(void) { return StringNewWTF16; }
-BinaryenOp BinaryenStringNewUTF8Array(void) { return StringNewUTF8Array; }
-BinaryenOp BinaryenStringNewWTF8Array(void) { return StringNewWTF8Array; }
BinaryenOp BinaryenStringNewLossyUTF8Array(void) {
return StringNewLossyUTF8Array;
}
@@ -1033,18 +1027,10 @@ BinaryenOp BinaryenStringNewFromCodePoint(void) {
return StringNewFromCodePoint;
}
BinaryenOp BinaryenStringMeasureUTF8(void) { return StringMeasureUTF8; }
-BinaryenOp BinaryenStringMeasureWTF8(void) { return StringMeasureWTF8; }
BinaryenOp BinaryenStringMeasureWTF16(void) { return StringMeasureWTF16; }
-BinaryenOp BinaryenStringMeasureIsUSV(void) { return StringMeasureIsUSV; }
-BinaryenOp BinaryenStringEncodeUTF8(void) { return StringEncodeUTF8; }
-BinaryenOp BinaryenStringEncodeLossyUTF8(void) { return StringEncodeLossyUTF8; }
-BinaryenOp BinaryenStringEncodeWTF8(void) { return StringEncodeWTF8; }
-BinaryenOp BinaryenStringEncodeWTF16(void) { return StringEncodeWTF16; }
-BinaryenOp BinaryenStringEncodeUTF8Array(void) { return StringEncodeUTF8Array; }
BinaryenOp BinaryenStringEncodeLossyUTF8Array(void) {
return StringEncodeLossyUTF8Array;
}
-BinaryenOp BinaryenStringEncodeWTF8Array(void) { return StringEncodeWTF8Array; }
BinaryenOp BinaryenStringEncodeWTF16Array(void) {
return StringEncodeWTF16Array;
}
@@ -1848,19 +1834,11 @@ BinaryenExpressionRef BinaryenArrayCopy(BinaryenModuleRef module,
BinaryenExpressionRef BinaryenStringNew(BinaryenModuleRef module,
BinaryenOp op,
BinaryenExpressionRef ptr,
- BinaryenExpressionRef length,
BinaryenExpressionRef start,
- BinaryenExpressionRef end,
- bool try_) {
+ BinaryenExpressionRef end) {
Builder builder(*(Module*)module);
- return static_cast<Expression*>(
- length ? builder.makeStringNew(
- StringNewOp(op), (Expression*)ptr, (Expression*)length, try_)
- : builder.makeStringNew(StringNewOp(op),
- (Expression*)ptr,
- (Expression*)start,
- (Expression*)end,
- try_));
+ return static_cast<Expression*>(builder.makeStringNew(
+ StringNewOp(op), (Expression*)ptr, (Expression*)start, (Expression*)end));
}
BinaryenExpressionRef BinaryenStringConst(BinaryenModuleRef module,
const char* name) {
@@ -4444,29 +4422,17 @@ void BinaryenStringNewSetOp(BinaryenExpressionRef expr, BinaryenOp op) {
assert(expression->is<StringNew>());
static_cast<StringNew*>(expression)->op = StringNewOp(op);
}
-BinaryenExpressionRef BinaryenStringNewGetPtr(BinaryenExpressionRef expr) {
- auto* expression = (Expression*)expr;
- assert(expression->is<StringNew>());
- return static_cast<StringNew*>(expression)->ptr;
-}
-void BinaryenStringNewSetPtr(BinaryenExpressionRef expr,
- BinaryenExpressionRef ptrExpr) {
+BinaryenExpressionRef BinaryenStringNewGetRef(BinaryenExpressionRef expr) {
auto* expression = (Expression*)expr;
assert(expression->is<StringNew>());
- assert(ptrExpr);
- static_cast<StringNew*>(expression)->ptr = (Expression*)ptrExpr;
+ return static_cast<StringNew*>(expression)->ref;
}
-BinaryenExpressionRef BinaryenStringNewGetLength(BinaryenExpressionRef expr) {
- auto* expression = (Expression*)expr;
- assert(expression->is<StringNew>());
- return static_cast<StringNew*>(expression)->length;
-}
-void BinaryenStringNewSetLength(BinaryenExpressionRef expr,
- BinaryenExpressionRef lengthExpr) {
+void BinaryenStringNewSetRef(BinaryenExpressionRef expr,
+ BinaryenExpressionRef refExpr) {
auto* expression = (Expression*)expr;
assert(expression->is<StringNew>());
- // may be null (linear memory only)
- static_cast<StringNew*>(expression)->length = (Expression*)lengthExpr;
+ assert(refExpr);
+ static_cast<StringNew*>(expression)->ref = (Expression*)refExpr;
}
BinaryenExpressionRef BinaryenStringNewGetStart(BinaryenExpressionRef expr) {
auto* expression = (Expression*)expr;
@@ -4492,16 +4458,6 @@ void BinaryenStringNewSetEnd(BinaryenExpressionRef expr,
// may be null (GC only)
static_cast<StringNew*>(expression)->end = (Expression*)endExpr;
}
-void BinaryenStringNewSetTry(BinaryenExpressionRef expr, bool try_) {
- auto* expression = (Expression*)expr;
- assert(expression->is<StringNew>());
- static_cast<StringNew*>(expression)->try_ = try_;
-}
-bool BinaryenStringNewIsTry(BinaryenExpressionRef expr) {
- auto* expression = (Expression*)expr;
- assert(expression->is<StringNew>());
- return static_cast<StringNew*>(expression)->try_;
-}
// StringConst
const char* BinaryenStringConstGetString(BinaryenExpressionRef expr) {
auto* expression = (Expression*)expr;
@@ -4549,29 +4505,29 @@ void BinaryenStringEncodeSetOp(BinaryenExpressionRef expr, BinaryenOp op) {
assert(expression->is<StringEncode>());
static_cast<StringEncode*>(expression)->op = StringEncodeOp(op);
}
-BinaryenExpressionRef BinaryenStringEncodeGetRef(BinaryenExpressionRef expr) {
+BinaryenExpressionRef BinaryenStringEncodeGetStr(BinaryenExpressionRef expr) {
auto* expression = (Expression*)expr;
assert(expression->is<StringEncode>());
- return static_cast<StringEncode*>(expression)->ref;
+ return static_cast<StringEncode*>(expression)->str;
}
-void BinaryenStringEncodeSetRef(BinaryenExpressionRef expr,
- BinaryenExpressionRef refExpr) {
+void BinaryenStringEncodeSetStr(BinaryenExpressionRef expr,
+ BinaryenExpressionRef strExpr) {
auto* expression = (Expression*)expr;
assert(expression->is<StringEncode>());
- assert(refExpr);
- static_cast<StringEncode*>(expression)->ref = (Expression*)refExpr;
+ assert(strExpr);
+ static_cast<StringEncode*>(expression)->str = (Expression*)strExpr;
}
-BinaryenExpressionRef BinaryenStringEncodeGetPtr(BinaryenExpressionRef expr) {
+BinaryenExpressionRef BinaryenStringEncodeGetArray(BinaryenExpressionRef expr) {
auto* expression = (Expression*)expr;
assert(expression->is<StringEncode>());
- return static_cast<StringEncode*>(expression)->ptr;
+ return static_cast<StringEncode*>(expression)->array;
}
-void BinaryenStringEncodeSetPtr(BinaryenExpressionRef expr,
- BinaryenExpressionRef ptrExpr) {
+void BinaryenStringEncodeSetArray(BinaryenExpressionRef expr,
+ BinaryenExpressionRef arrayExpr) {
auto* expression = (Expression*)expr;
assert(expression->is<StringEncode>());
- assert(ptrExpr);
- static_cast<StringEncode*>(expression)->ptr = (Expression*)ptrExpr;
+ assert(arrayExpr);
+ static_cast<StringEncode*>(expression)->array = (Expression*)arrayExpr;
}
BinaryenExpressionRef BinaryenStringEncodeGetStart(BinaryenExpressionRef expr) {
auto* expression = (Expression*)expr;
diff --git a/src/binaryen-c.h b/src/binaryen-c.h
index f01b4c3be..3f2cab20c 100644
--- a/src/binaryen-c.h
+++ b/src/binaryen-c.h
@@ -682,26 +682,12 @@ BINARYEN_API BinaryenOp BinaryenBrOnNull(void);
BINARYEN_API BinaryenOp BinaryenBrOnNonNull(void);
BINARYEN_API BinaryenOp BinaryenBrOnCast(void);
BINARYEN_API BinaryenOp BinaryenBrOnCastFail(void);
-BINARYEN_API BinaryenOp BinaryenStringNewUTF8(void);
-BINARYEN_API BinaryenOp BinaryenStringNewWTF8(void);
-BINARYEN_API BinaryenOp BinaryenStringNewLossyUTF8(void);
-BINARYEN_API BinaryenOp BinaryenStringNewWTF16(void);
-BINARYEN_API BinaryenOp BinaryenStringNewUTF8Array(void);
-BINARYEN_API BinaryenOp BinaryenStringNewWTF8Array(void);
BINARYEN_API BinaryenOp BinaryenStringNewLossyUTF8Array(void);
BINARYEN_API BinaryenOp BinaryenStringNewWTF16Array(void);
BINARYEN_API BinaryenOp BinaryenStringNewFromCodePoint(void);
BINARYEN_API BinaryenOp BinaryenStringMeasureUTF8(void);
-BINARYEN_API BinaryenOp BinaryenStringMeasureWTF8(void);
BINARYEN_API BinaryenOp BinaryenStringMeasureWTF16(void);
-BINARYEN_API BinaryenOp BinaryenStringMeasureIsUSV(void);
-BINARYEN_API BinaryenOp BinaryenStringEncodeUTF8(void);
-BINARYEN_API BinaryenOp BinaryenStringEncodeLossyUTF8(void);
-BINARYEN_API BinaryenOp BinaryenStringEncodeWTF8(void);
-BINARYEN_API BinaryenOp BinaryenStringEncodeWTF16(void);
-BINARYEN_API BinaryenOp BinaryenStringEncodeUTF8Array(void);
BINARYEN_API BinaryenOp BinaryenStringEncodeLossyUTF8Array(void);
-BINARYEN_API BinaryenOp BinaryenStringEncodeWTF8Array(void);
BINARYEN_API BinaryenOp BinaryenStringEncodeWTF16Array(void);
BINARYEN_API BinaryenOp BinaryenStringEqEqual(void);
BINARYEN_API BinaryenOp BinaryenStringEqCompare(void);
@@ -1092,11 +1078,9 @@ BinaryenArrayCopy(BinaryenModuleRef module,
BINARYEN_API BinaryenExpressionRef
BinaryenStringNew(BinaryenModuleRef module,
BinaryenOp op,
- BinaryenExpressionRef ptr,
- BinaryenExpressionRef length,
+ BinaryenExpressionRef ref,
BinaryenExpressionRef start,
- BinaryenExpressionRef end,
- bool try_);
+ BinaryenExpressionRef end);
BINARYEN_API BinaryenExpressionRef BinaryenStringConst(BinaryenModuleRef module,
const char* name);
BINARYEN_API BinaryenExpressionRef BinaryenStringMeasure(
@@ -2522,14 +2506,10 @@ BINARYEN_API BinaryenOp BinaryenStringNewGetOp(BinaryenExpressionRef expr);
BINARYEN_API void BinaryenStringNewSetOp(BinaryenExpressionRef expr,
BinaryenOp op);
BINARYEN_API BinaryenExpressionRef
-BinaryenStringNewGetPtr(BinaryenExpressionRef expr);
-BINARYEN_API void BinaryenStringNewSetPtr(BinaryenExpressionRef expr,
+BinaryenStringNewGetRef(BinaryenExpressionRef expr);
+BINARYEN_API void BinaryenStringNewSetRef(BinaryenExpressionRef expr,
BinaryenExpressionRef ptrExpr);
BINARYEN_API BinaryenExpressionRef
-BinaryenStringNewGetLength(BinaryenExpressionRef expr);
-BINARYEN_API void BinaryenStringNewSetLength(BinaryenExpressionRef expr,
- BinaryenExpressionRef lengthExpr);
-BINARYEN_API BinaryenExpressionRef
BinaryenStringNewGetStart(BinaryenExpressionRef expr);
BINARYEN_API void BinaryenStringNewSetStart(BinaryenExpressionRef expr,
BinaryenExpressionRef startExpr);
@@ -2539,7 +2519,6 @@ BINARYEN_API void BinaryenStringNewSetEnd(BinaryenExpressionRef expr,
BinaryenExpressionRef endExpr);
BINARYEN_API void BinaryenStringNewSetTry(BinaryenExpressionRef expr,
bool try_);
-BINARYEN_API bool BinaryenStringNewIsTry(BinaryenExpressionRef expr);
// StringConst
@@ -2564,13 +2543,13 @@ BINARYEN_API BinaryenOp BinaryenStringEncodeGetOp(BinaryenExpressionRef expr);
BINARYEN_API void BinaryenStringEncodeSetOp(BinaryenExpressionRef expr,
BinaryenOp op);
BINARYEN_API BinaryenExpressionRef
-BinaryenStringEncodeGetRef(BinaryenExpressionRef expr);
-BINARYEN_API void BinaryenStringEncodeSetRef(BinaryenExpressionRef expr,
+BinaryenStringEncodeGetStr(BinaryenExpressionRef expr);
+BINARYEN_API void BinaryenStringEncodeSetStr(BinaryenExpressionRef expr,
BinaryenExpressionRef refExpr);
BINARYEN_API BinaryenExpressionRef
-BinaryenStringEncodeGetPtr(BinaryenExpressionRef expr);
-BINARYEN_API void BinaryenStringEncodeSetPtr(BinaryenExpressionRef expr,
- BinaryenExpressionRef ptrExpr);
+BinaryenStringEncodeGetArray(BinaryenExpressionRef expr);
+BINARYEN_API void BinaryenStringEncodeSetArray(BinaryenExpressionRef expr,
+ BinaryenExpressionRef ptrExpr);
BINARYEN_API BinaryenExpressionRef
BinaryenStringEncodeGetStart(BinaryenExpressionRef expr);
BINARYEN_API void BinaryenStringEncodeSetStart(BinaryenExpressionRef expr,
diff --git a/src/gen-s-parser.inc b/src/gen-s-parser.inc
index b76a26ea1..a451805db 100644
--- a/src/gen-s-parser.inc
+++ b/src/gen-s-parser.inc
@@ -3098,55 +3098,12 @@ switch (buf[0]) {
switch (buf[8]) {
case 'n': {
switch (buf[14]) {
- case 'l': {
- switch (buf[24]) {
- case '\0':
- if (op == "string.encode_lossy_utf8"sv) { return makeStringEncode(s, StringEncodeLossyUTF8); }
- goto parse_error;
- case '_':
- if (op == "string.encode_lossy_utf8_array"sv) { return makeStringEncode(s, StringEncodeLossyUTF8Array); }
- goto parse_error;
- default: goto parse_error;
- }
- }
- case 'u': {
- switch (buf[18]) {
- case '\0':
- if (op == "string.encode_utf8"sv) { return makeStringEncode(s, StringEncodeUTF8); }
- goto parse_error;
- case '_':
- if (op == "string.encode_utf8_array"sv) { return makeStringEncode(s, StringEncodeUTF8Array); }
- goto parse_error;
- default: goto parse_error;
- }
- }
- case 'w': {
- switch (buf[17]) {
- case '1': {
- switch (buf[19]) {
- case '\0':
- if (op == "string.encode_wtf16"sv) { return makeStringEncode(s, StringEncodeWTF16); }
- goto parse_error;
- case '_':
- if (op == "string.encode_wtf16_array"sv) { return makeStringEncode(s, StringEncodeWTF16Array); }
- goto parse_error;
- default: goto parse_error;
- }
- }
- case '8': {
- switch (buf[18]) {
- case '\0':
- if (op == "string.encode_wtf8"sv) { return makeStringEncode(s, StringEncodeWTF8); }
- goto parse_error;
- case '_':
- if (op == "string.encode_wtf8_array"sv) { return makeStringEncode(s, StringEncodeWTF8Array); }
- goto parse_error;
- default: goto parse_error;
- }
- }
- default: goto parse_error;
- }
- }
+ case 'l':
+ if (op == "string.encode_lossy_utf8_array"sv) { return makeStringEncode(s, StringEncodeLossyUTF8Array); }
+ goto parse_error;
+ case 'w':
+ if (op == "string.encode_wtf16_array"sv) { return makeStringEncode(s, StringEncodeWTF16Array); }
+ goto parse_error;
default: goto parse_error;
}
}
@@ -3157,100 +3114,27 @@ switch (buf[0]) {
}
}
case 'f':
- if (op == "string.from_code_point"sv) { return makeStringNew(s, StringNewFromCodePoint, false); }
- goto parse_error;
- case 'h':
- if (op == "string.hash"sv) { return makeStringMeasure(s, StringMeasureHash); }
- goto parse_error;
- case 'i':
- if (op == "string.is_usv_sequence"sv) { return makeStringMeasure(s, StringMeasureIsUSV); }
+ if (op == "string.from_code_point"sv) { return makeStringNew(s, StringNewFromCodePoint); }
goto parse_error;
case 'm': {
switch (buf[15]) {
case 'u':
if (op == "string.measure_utf8"sv) { return makeStringMeasure(s, StringMeasureUTF8); }
goto parse_error;
- case 'w': {
- switch (buf[18]) {
- case '1':
- if (op == "string.measure_wtf16"sv) { return makeStringMeasure(s, StringMeasureWTF16); }
- goto parse_error;
- case '8':
- if (op == "string.measure_wtf8"sv) { return makeStringMeasure(s, StringMeasureWTF8); }
- goto parse_error;
- default: goto parse_error;
- }
- }
+ case 'w':
+ if (op == "string.measure_wtf16"sv) { return makeStringMeasure(s, StringMeasureWTF16); }
+ goto parse_error;
default: goto parse_error;
}
}
case 'n': {
switch (buf[11]) {
- case 'l': {
- switch (buf[21]) {
- case '\0':
- if (op == "string.new_lossy_utf8"sv) { return makeStringNew(s, StringNewLossyUTF8, false); }
- goto parse_error;
- case '_':
- if (op == "string.new_lossy_utf8_array"sv) { return makeStringNew(s, StringNewLossyUTF8Array, false); }
- goto parse_error;
- default: goto parse_error;
- }
- }
- case 'u': {
- switch (buf[15]) {
- case '\0':
- if (op == "string.new_utf8"sv) { return makeStringNew(s, StringNewUTF8, false); }
- goto parse_error;
- case '_': {
- switch (buf[16]) {
- case 'a': {
- switch (buf[21]) {
- case '\0':
- if (op == "string.new_utf8_array"sv) { return makeStringNew(s, StringNewUTF8Array, false); }
- goto parse_error;
- case '_':
- if (op == "string.new_utf8_array_try"sv) { return makeStringNew(s, StringNewUTF8Array, true); }
- goto parse_error;
- default: goto parse_error;
- }
- }
- case 't':
- if (op == "string.new_utf8_try"sv) { return makeStringNew(s, StringNewUTF8, true); }
- goto parse_error;
- default: goto parse_error;
- }
- }
- default: goto parse_error;
- }
- }
- case 'w': {
- switch (buf[14]) {
- case '1': {
- switch (buf[16]) {
- case '\0':
- if (op == "string.new_wtf16"sv) { return makeStringNew(s, StringNewWTF16, false); }
- goto parse_error;
- case '_':
- if (op == "string.new_wtf16_array"sv) { return makeStringNew(s, StringNewWTF16Array, false); }
- goto parse_error;
- default: goto parse_error;
- }
- }
- case '8': {
- switch (buf[15]) {
- case '\0':
- if (op == "string.new_wtf8"sv) { return makeStringNew(s, StringNewWTF8, false); }
- goto parse_error;
- case '_':
- if (op == "string.new_wtf8_array"sv) { return makeStringNew(s, StringNewWTF8Array, false); }
- goto parse_error;
- default: goto parse_error;
- }
- }
- default: goto parse_error;
- }
- }
+ case 'l':
+ if (op == "string.new_lossy_utf8_array"sv) { return makeStringNew(s, StringNewLossyUTF8Array); }
+ goto parse_error;
+ case 'w':
+ if (op == "string.new_wtf16_array"sv) { return makeStringNew(s, StringNewWTF16Array); }
+ goto parse_error;
default: goto parse_error;
}
}
@@ -8205,79 +8089,18 @@ switch (buf[0]) {
switch (buf[8]) {
case 'n': {
switch (buf[14]) {
- case 'l': {
- switch (buf[24]) {
- case '\0':
- if (op == "string.encode_lossy_utf8"sv) {
- CHECK_ERR(makeStringEncode(ctx, pos, annotations, StringEncodeLossyUTF8));
- return Ok{};
- }
- goto parse_error;
- case '_':
- if (op == "string.encode_lossy_utf8_array"sv) {
- CHECK_ERR(makeStringEncode(ctx, pos, annotations, StringEncodeLossyUTF8Array));
- return Ok{};
- }
- goto parse_error;
- default: goto parse_error;
- }
- }
- case 'u': {
- switch (buf[18]) {
- case '\0':
- if (op == "string.encode_utf8"sv) {
- CHECK_ERR(makeStringEncode(ctx, pos, annotations, StringEncodeUTF8));
- return Ok{};
- }
- goto parse_error;
- case '_':
- if (op == "string.encode_utf8_array"sv) {
- CHECK_ERR(makeStringEncode(ctx, pos, annotations, StringEncodeUTF8Array));
- return Ok{};
- }
- goto parse_error;
- default: goto parse_error;
+ case 'l':
+ if (op == "string.encode_lossy_utf8_array"sv) {
+ CHECK_ERR(makeStringEncode(ctx, pos, annotations, StringEncodeLossyUTF8Array));
+ return Ok{};
}
- }
- case 'w': {
- switch (buf[17]) {
- case '1': {
- switch (buf[19]) {
- case '\0':
- if (op == "string.encode_wtf16"sv) {
- CHECK_ERR(makeStringEncode(ctx, pos, annotations, StringEncodeWTF16));
- return Ok{};
- }
- goto parse_error;
- case '_':
- if (op == "string.encode_wtf16_array"sv) {
- CHECK_ERR(makeStringEncode(ctx, pos, annotations, StringEncodeWTF16Array));
- return Ok{};
- }
- goto parse_error;
- default: goto parse_error;
- }
- }
- case '8': {
- switch (buf[18]) {
- case '\0':
- if (op == "string.encode_wtf8"sv) {
- CHECK_ERR(makeStringEncode(ctx, pos, annotations, StringEncodeWTF8));
- return Ok{};
- }
- goto parse_error;
- case '_':
- if (op == "string.encode_wtf8_array"sv) {
- CHECK_ERR(makeStringEncode(ctx, pos, annotations, StringEncodeWTF8Array));
- return Ok{};
- }
- goto parse_error;
- default: goto parse_error;
- }
- }
- default: goto parse_error;
+ goto parse_error;
+ case 'w':
+ if (op == "string.encode_wtf16_array"sv) {
+ CHECK_ERR(makeStringEncode(ctx, pos, annotations, StringEncodeWTF16Array));
+ return Ok{};
}
- }
+ goto parse_error;
default: goto parse_error;
}
}
@@ -8292,19 +8115,7 @@ switch (buf[0]) {
}
case 'f':
if (op == "string.from_code_point"sv) {
- CHECK_ERR(makeStringNew(ctx, pos, annotations, StringNewFromCodePoint, false));
- return Ok{};
- }
- goto parse_error;
- case 'h':
- if (op == "string.hash"sv) {
- CHECK_ERR(makeStringMeasure(ctx, pos, annotations, StringMeasureHash));
- return Ok{};
- }
- goto parse_error;
- case 'i':
- if (op == "string.is_usv_sequence"sv) {
- CHECK_ERR(makeStringMeasure(ctx, pos, annotations, StringMeasureIsUSV));
+ CHECK_ERR(makeStringNew(ctx, pos, annotations, StringNewFromCodePoint));
return Ok{};
}
goto parse_error;
@@ -8316,123 +8127,29 @@ switch (buf[0]) {
return Ok{};
}
goto parse_error;
- case 'w': {
- switch (buf[18]) {
- case '1':
- if (op == "string.measure_wtf16"sv) {
- CHECK_ERR(makeStringMeasure(ctx, pos, annotations, StringMeasureWTF16));
- return Ok{};
- }
- goto parse_error;
- case '8':
- if (op == "string.measure_wtf8"sv) {
- CHECK_ERR(makeStringMeasure(ctx, pos, annotations, StringMeasureWTF8));
- return Ok{};
- }
- goto parse_error;
- default: goto parse_error;
+ case 'w':
+ if (op == "string.measure_wtf16"sv) {
+ CHECK_ERR(makeStringMeasure(ctx, pos, annotations, StringMeasureWTF16));
+ return Ok{};
}
- }
+ goto parse_error;
default: goto parse_error;
}
}
case 'n': {
switch (buf[11]) {
- case 'l': {
- switch (buf[21]) {
- case '\0':
- if (op == "string.new_lossy_utf8"sv) {
- CHECK_ERR(makeStringNew(ctx, pos, annotations, StringNewLossyUTF8, false));
- return Ok{};
- }
- goto parse_error;
- case '_':
- if (op == "string.new_lossy_utf8_array"sv) {
- CHECK_ERR(makeStringNew(ctx, pos, annotations, StringNewLossyUTF8Array, false));
- return Ok{};
- }
- goto parse_error;
- default: goto parse_error;
- }
- }
- case 'u': {
- switch (buf[15]) {
- case '\0':
- if (op == "string.new_utf8"sv) {
- CHECK_ERR(makeStringNew(ctx, pos, annotations, StringNewUTF8, false));
- return Ok{};
- }
- goto parse_error;
- case '_': {
- switch (buf[16]) {
- case 'a': {
- switch (buf[21]) {
- case '\0':
- if (op == "string.new_utf8_array"sv) {
- CHECK_ERR(makeStringNew(ctx, pos, annotations, StringNewUTF8Array, false));
- return Ok{};
- }
- goto parse_error;
- case '_':
- if (op == "string.new_utf8_array_try"sv) {
- CHECK_ERR(makeStringNew(ctx, pos, annotations, StringNewUTF8Array, true));
- return Ok{};
- }
- goto parse_error;
- default: goto parse_error;
- }
- }
- case 't':
- if (op == "string.new_utf8_try"sv) {
- CHECK_ERR(makeStringNew(ctx, pos, annotations, StringNewUTF8, true));
- return Ok{};
- }
- goto parse_error;
- default: goto parse_error;
- }
- }
- default: goto parse_error;
+ case 'l':
+ if (op == "string.new_lossy_utf8_array"sv) {
+ CHECK_ERR(makeStringNew(ctx, pos, annotations, StringNewLossyUTF8Array));
+ return Ok{};
}
- }
- case 'w': {
- switch (buf[14]) {
- case '1': {
- switch (buf[16]) {
- case '\0':
- if (op == "string.new_wtf16"sv) {
- CHECK_ERR(makeStringNew(ctx, pos, annotations, StringNewWTF16, false));
- return Ok{};
- }
- goto parse_error;
- case '_':
- if (op == "string.new_wtf16_array"sv) {
- CHECK_ERR(makeStringNew(ctx, pos, annotations, StringNewWTF16Array, false));
- return Ok{};
- }
- goto parse_error;
- default: goto parse_error;
- }
- }
- case '8': {
- switch (buf[15]) {
- case '\0':
- if (op == "string.new_wtf8"sv) {
- CHECK_ERR(makeStringNew(ctx, pos, annotations, StringNewWTF8, false));
- return Ok{};
- }
- goto parse_error;
- case '_':
- if (op == "string.new_wtf8_array"sv) {
- CHECK_ERR(makeStringNew(ctx, pos, annotations, StringNewWTF8Array, false));
- return Ok{};
- }
- goto parse_error;
- default: goto parse_error;
- }
- }
- default: goto parse_error;
+ goto parse_error;
+ case 'w':
+ if (op == "string.new_wtf16_array"sv) {
+ CHECK_ERR(makeStringNew(ctx, pos, annotations, StringNewWTF16Array));
+ return Ok{};
}
- }
+ goto parse_error;
default: goto parse_error;
}
}
diff --git a/src/ir/child-typer.h b/src/ir/child-typer.h
index e015f3db8..7c09dddb0 100644
--- a/src/ir/child-typer.h
+++ b/src/ir/child-typer.h
@@ -962,27 +962,17 @@ template<typename Subtype> struct ChildTyper : OverriddenVisitor<Subtype> {
void visitStringNew(StringNew* curr,
std::optional<HeapType> ht = std::nullopt) {
switch (curr->op) {
- case StringNewUTF8:
- case StringNewWTF8:
- case StringNewLossyUTF8:
- case StringNewWTF16:
- // TODO: This should be notePointer, but we don't have a memory.
- note(&curr->ptr, Type::i32);
- note(&curr->length, Type::i32);
- return;
- case StringNewUTF8Array:
- case StringNewWTF8Array:
case StringNewLossyUTF8Array:
case StringNewWTF16Array:
if (!ht) {
- ht = curr->ptr->type.getHeapType();
+ ht = curr->ref->type.getHeapType();
}
- note(&curr->ptr, Type(*ht, Nullable));
+ note(&curr->ref, Type(*ht, Nullable));
note(&curr->start, Type::i32);
note(&curr->end, Type::i32);
return;
case StringNewFromCodePoint:
- note(&curr->ptr, Type::i32);
+ note(&curr->ref, Type::i32);
return;
}
WASM_UNREACHABLE("unexpected op");
@@ -996,27 +986,12 @@ template<typename Subtype> struct ChildTyper : OverriddenVisitor<Subtype> {
void visitStringEncode(StringEncode* curr,
std::optional<HeapType> ht = std::nullopt) {
- note(&curr->ref, Type(HeapType::string, Nullable));
- switch (curr->op) {
- case StringEncodeUTF8:
- case StringEncodeLossyUTF8:
- case StringEncodeWTF8:
- case StringEncodeWTF16:
- // TODO: This should be notePointer, but we don't have a memory.
- note(&curr->ptr, Type::i32);
- return;
- case StringEncodeUTF8Array:
- case StringEncodeLossyUTF8Array:
- case StringEncodeWTF8Array:
- case StringEncodeWTF16Array:
- if (!ht) {
- ht = curr->ptr->type.getHeapType();
- }
- note(&curr->ptr, Type(*ht, Nullable));
- note(&curr->start, Type::i32);
- return;
+ if (!ht) {
+ ht = curr->array->type.getHeapType();
}
- WASM_UNREACHABLE("unexpected op");
+ note(&curr->str, Type(HeapType::string, Nullable));
+ note(&curr->array, Type(*ht, Nullable));
+ note(&curr->start, Type::i32);
}
void visitStringConcat(StringConcat* curr) {
diff --git a/src/ir/cost.h b/src/ir/cost.h
index 8af68dbf1..6622561b8 100644
--- a/src/ir/cost.h
+++ b/src/ir/cost.h
@@ -689,15 +689,15 @@ struct CostAnalyzer : public OverriddenVisitor<CostAnalyzer, CostType> {
}
CostType visitRefAs(RefAs* curr) { return 1 + visit(curr->value); }
CostType visitStringNew(StringNew* curr) {
- return 8 + visit(curr->ptr) + maybeVisit(curr->length) +
- maybeVisit(curr->start) + maybeVisit(curr->end);
+ return 8 + visit(curr->ref) + maybeVisit(curr->start) +
+ maybeVisit(curr->end);
}
CostType visitStringConst(StringConst* curr) { return 4; }
CostType visitStringMeasure(StringMeasure* curr) {
return 6 + visit(curr->ref);
}
CostType visitStringEncode(StringEncode* curr) {
- return 6 + visit(curr->ref) + visit(curr->ptr);
+ return 6 + visit(curr->str) + visit(curr->array) + visit(curr->start);
}
CostType visitStringConcat(StringConcat* curr) {
return 10 + visit(curr->left) + visit(curr->right);
diff --git a/src/ir/effects.h b/src/ir/effects.h
index 87b77601f..28de83850 100644
--- a/src/ir/effects.h
+++ b/src/ir/effects.h
@@ -941,23 +941,10 @@ private:
// cycle may be needed in some cases.
}
void visitStringNew(StringNew* curr) {
- // traps when out of bounds in linear memory or ref is null
+ // traps when ref is null
parent.implicitTrap = true;
- switch (curr->op) {
- case StringNewUTF8:
- case StringNewWTF8:
- case StringNewLossyUTF8:
- case StringNewWTF16:
- parent.readsMemory = true;
- break;
- case StringNewUTF8Array:
- case StringNewWTF8Array:
- case StringNewLossyUTF8Array:
- case StringNewWTF16Array:
- parent.readsArray = true;
- break;
- default: {
- }
+ if (curr->op != StringNewFromCodePoint) {
+ parent.readsArray = true;
}
}
void visitStringConst(StringConst* curr) {}
@@ -968,22 +955,7 @@ private:
void visitStringEncode(StringEncode* curr) {
// traps when ref is null or we write out of bounds.
parent.implicitTrap = true;
- switch (curr->op) {
- case StringEncodeUTF8:
- case StringEncodeLossyUTF8:
- case StringEncodeWTF8:
- case StringEncodeWTF16:
- parent.writesMemory = true;
- break;
- case StringEncodeUTF8Array:
- case StringEncodeLossyUTF8Array:
- case StringEncodeWTF8Array:
- case StringEncodeWTF16Array:
- parent.writesArray = true;
- break;
- default: {
- }
- }
+ parent.writesArray = true;
}
void visitStringConcat(StringConcat* curr) {
// traps when an input is null.
diff --git a/src/js/binaryen.js-post.js b/src/js/binaryen.js-post.js
index 86a6e8df9..8d7bd6d7f 100644
--- a/src/js/binaryen.js-post.js
+++ b/src/js/binaryen.js-post.js
@@ -568,26 +568,12 @@ function initializeConstants() {
'BrOnNonNull',
'BrOnCast',
'BrOnCastFail',
- 'StringNewUTF8',
- 'StringNewWTF8',
- 'StringNewLossyUTF8',
- 'StringNewWTF16',
- 'StringNewUTF8Array',
- 'StringNewWTF8Array',
'StringNewLossyUTF8Array',
'StringNewWTF16Array',
'StringNewFromCodePoint',
'StringMeasureUTF8',
- 'StringMeasureWTF8',
'StringMeasureWTF16',
- 'StringMeasureIsUSV',
- 'StringEncodeUTF8',
- 'StringEncodeLossyUTF8',
- 'StringEncodeWTF8',
- 'StringEncodeWTF16',
- 'StringEncodeUTF8Array',
'StringEncodeLossyUTF8Array',
- 'StringEncodeWTF8Array',
'StringEncodeWTF16Array',
'StringEqEqual',
'StringEqCompare'
diff --git a/src/parser/contexts.h b/src/parser/contexts.h
index b32e32a15..2243c6065 100644
--- a/src/parser/contexts.h
+++ b/src/parser/contexts.h
@@ -772,8 +772,7 @@ struct NullInstrParserCtx {
Result<> makeRefAs(Index, const std::vector<Annotation>&, RefAsOp) {
return Ok{};
}
- Result<> makeStringNew(
- Index, const std::vector<Annotation>&, StringNewOp, bool, MemoryIdxT*) {
+ Result<> makeStringNew(Index, const std::vector<Annotation>&, StringNewOp) {
return Ok{};
}
Result<>
@@ -784,10 +783,8 @@ struct NullInstrParserCtx {
makeStringMeasure(Index, const std::vector<Annotation>&, StringMeasureOp) {
return Ok{};
}
- Result<> makeStringEncode(Index,
- const std::vector<Annotation>&,
- StringEncodeOp,
- MemoryIdxT*) {
+ Result<>
+ makeStringEncode(Index, const std::vector<Annotation>&, StringEncodeOp) {
return Ok{};
}
Result<> makeStringConcat(Index, const std::vector<Annotation>&) {
@@ -2478,24 +2475,8 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx> {
Result<> makeStringNew(Index pos,
const std::vector<Annotation>& annotations,
- StringNewOp op,
- bool try_,
- Name* mem) {
- Name memName;
- switch (op) {
- case StringNewUTF8:
- case StringNewWTF8:
- case StringNewLossyUTF8:
- case StringNewWTF16: {
- auto m = getMemory(pos, mem);
- CHECK_ERR(m);
- memName = *m;
- break;
- }
- default:
- break;
- }
- return withLoc(pos, irBuilder.makeStringNew(op, try_, memName));
+ StringNewOp op) {
+ return withLoc(pos, irBuilder.makeStringNew(op));
}
Result<> makeStringConst(Index pos,
@@ -2518,23 +2499,8 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx> {
Result<> makeStringEncode(Index pos,
const std::vector<Annotation>& annotations,
- StringEncodeOp op,
- Name* mem) {
- Name memName;
- switch (op) {
- case StringEncodeUTF8:
- case StringEncodeLossyUTF8:
- case StringEncodeWTF8:
- case StringEncodeWTF16: {
- auto m = getMemory(pos, mem);
- CHECK_ERR(m);
- memName = *m;
- break;
- }
- default:
- break;
- }
- return withLoc(pos, irBuilder.makeStringEncode(op, memName));
+ StringEncodeOp op) {
+ return withLoc(pos, irBuilder.makeStringEncode(op));
}
Result<> makeStringConcat(Index pos,
diff --git a/src/parser/parsers.h b/src/parser/parsers.h
index 60d3f0391..88600fec3 100644
--- a/src/parser/parsers.h
+++ b/src/parser/parsers.h
@@ -266,8 +266,8 @@ Result<> makeArrayInitElem(Ctx&, Index, const std::vector<Annotation>&);
template<typename Ctx>
Result<> makeRefAs(Ctx&, Index, const std::vector<Annotation>&, RefAsOp op);
template<typename Ctx>
-Result<> makeStringNew(
- Ctx&, Index, const std::vector<Annotation>&, StringNewOp op, bool try_);
+Result<>
+makeStringNew(Ctx&, Index, const std::vector<Annotation>&, StringNewOp op);
template<typename Ctx>
Result<> makeStringConst(Ctx&, Index, const std::vector<Annotation>&);
template<typename Ctx>
@@ -2336,20 +2336,8 @@ template<typename Ctx>
Result<> makeStringNew(Ctx& ctx,
Index pos,
const std::vector<Annotation>& annotations,
- StringNewOp op,
- bool try_) {
- switch (op) {
- case StringNewUTF8:
- case StringNewWTF8:
- case StringNewLossyUTF8:
- case StringNewWTF16: {
- auto mem = maybeMemidx(ctx);
- CHECK_ERR(mem);
- return ctx.makeStringNew(pos, annotations, op, try_, mem.getPtr());
- }
- default:
- return ctx.makeStringNew(pos, annotations, op, try_, nullptr);
- }
+ StringNewOp op) {
+ return ctx.makeStringNew(pos, annotations, op);
}
template<typename Ctx>
@@ -2376,18 +2364,7 @@ Result<> makeStringEncode(Ctx& ctx,
Index pos,
const std::vector<Annotation>& annotations,
StringEncodeOp op) {
- switch (op) {
- case StringEncodeUTF8:
- case StringEncodeLossyUTF8:
- case StringEncodeWTF8:
- case StringEncodeWTF16: {
- auto mem = maybeMemidx(ctx);
- CHECK_ERR(mem);
- return ctx.makeStringEncode(pos, annotations, op, mem.getPtr());
- }
- default:
- return ctx.makeStringEncode(pos, annotations, op, nullptr);
- }
+ return ctx.makeStringEncode(pos, annotations, op);
}
template<typename Ctx>
diff --git a/src/passes/Precompute.cpp b/src/passes/Precompute.cpp
index 4f9ad046d..295d86b40 100644
--- a/src/passes/Precompute.cpp
+++ b/src/passes/Precompute.cpp
@@ -203,9 +203,9 @@ public:
// string.encode_wtf16_array is effectively an Array read operation, so
// just like ArrayGet above we must check for immutability.
- auto ptrType = curr->ptr->type;
- if (ptrType.isRef()) {
- auto heapType = ptrType.getHeapType();
+ auto refType = curr->ref->type;
+ if (refType.isRef()) {
+ auto heapType = refType.getHeapType();
if (heapType.isArray()) {
if (heapType.getArray().element.mutable_ == Immutable) {
return Super::visitStringNew(curr);
diff --git a/src/passes/Print.cpp b/src/passes/Print.cpp
index ab5e0db90..c57ab29c3 100644
--- a/src/passes/Print.cpp
+++ b/src/passes/Print.cpp
@@ -2237,32 +2237,6 @@ struct PrintExpressionContents
}
void visitStringNew(StringNew* curr) {
switch (curr->op) {
- case StringNewUTF8:
- if (!curr->try_) {
- printMedium(o, "string.new_utf8");
- } else {
- printMedium(o, "string.new_utf8_try");
- }
- break;
- case StringNewWTF8:
- printMedium(o, "string.new_wtf8");
- break;
- case StringNewLossyUTF8:
- printMedium(o, "string.new_lossy_utf8");
- break;
- case StringNewWTF16:
- printMedium(o, "string.new_wtf16");
- break;
- case StringNewUTF8Array:
- if (!curr->try_) {
- printMedium(o, "string.new_utf8_array");
- } else {
- printMedium(o, "string.new_utf8_array_try");
- }
- break;
- case StringNewWTF8Array:
- printMedium(o, "string.new_wtf8_array");
- break;
case StringNewLossyUTF8Array:
printMedium(o, "string.new_lossy_utf8_array");
break;
@@ -2291,45 +2265,18 @@ struct PrintExpressionContents
case StringMeasureUTF8:
printMedium(o, "string.measure_utf8");
break;
- case StringMeasureWTF8:
- printMedium(o, "string.measure_wtf8");
- break;
case StringMeasureWTF16:
printMedium(o, "string.measure_wtf16");
break;
- case StringMeasureIsUSV:
- printMedium(o, "string.is_usv_sequence");
- break;
- case StringMeasureHash:
- printMedium(o, "string.hash");
- break;
default:
WASM_UNREACHABLE("invalid string.measure*");
}
}
void visitStringEncode(StringEncode* curr) {
switch (curr->op) {
- case StringEncodeUTF8:
- printMedium(o, "string.encode_utf8");
- break;
- case StringEncodeLossyUTF8:
- printMedium(o, "string.encode_lossy_utf8");
- break;
- case StringEncodeWTF8:
- printMedium(o, "string.encode_wtf8");
- break;
- case StringEncodeWTF16:
- printMedium(o, "string.encode_wtf16");
- break;
- case StringEncodeUTF8Array:
- printMedium(o, "string.encode_utf8_array");
- break;
case StringEncodeLossyUTF8Array:
printMedium(o, "string.encode_lossy_utf8_array");
break;
- case StringEncodeWTF8Array:
- printMedium(o, "string.encode_wtf8_array");
- break;
case StringEncodeWTF16Array:
printMedium(o, "string.encode_wtf16_array");
break;
diff --git a/src/passes/StringLowering.cpp b/src/passes/StringLowering.cpp
index 27f4e9c07..9903f090e 100644
--- a/src/passes/StringLowering.cpp
+++ b/src/passes/StringLowering.cpp
@@ -375,12 +375,12 @@ struct StringLowering : public StringGathering {
switch (curr->op) {
case StringNewWTF16Array:
replaceCurrent(builder.makeCall(lowering.fromCharCodeArrayImport,
- {curr->ptr, curr->start, curr->end},
+ {curr->ref, curr->start, curr->end},
lowering.nnExt));
return;
case StringNewFromCodePoint:
replaceCurrent(builder.makeCall(
- lowering.fromCodePointImport, {curr->ptr}, lowering.nnExt));
+ lowering.fromCodePointImport, {curr->ref}, lowering.nnExt));
return;
default:
WASM_UNREACHABLE("TODO: all of string.new*");
@@ -397,9 +397,10 @@ struct StringLowering : public StringGathering {
Builder builder(*getModule());
switch (curr->op) {
case StringEncodeWTF16Array:
- replaceCurrent(builder.makeCall(lowering.intoCharCodeArrayImport,
- {curr->ref, curr->ptr, curr->start},
- Type::i32));
+ replaceCurrent(
+ builder.makeCall(lowering.intoCharCodeArrayImport,
+ {curr->str, curr->array, curr->start},
+ Type::i32));
return;
default:
WASM_UNREACHABLE("TODO: all of string.encode*");
diff --git a/src/tools/fuzzing/fuzzing.cpp b/src/tools/fuzzing/fuzzing.cpp
index d6f8e0f12..1b1d2cb01 100644
--- a/src/tools/fuzzing/fuzzing.cpp
+++ b/src/tools/fuzzing/fuzzing.cpp
@@ -2754,13 +2754,12 @@ Expression* TranslateToFuzzReader::makeStringNewArray() {
auto* array = makeTrappingRefUse(getArrayTypeForString());
auto* start = make(Type::i32);
auto* end = make(Type::i32);
- return builder.makeStringNew(StringNewWTF16Array, array, start, end, false);
+ return builder.makeStringNew(StringNewWTF16Array, array, start, end);
}
Expression* TranslateToFuzzReader::makeStringNewCodePoint() {
auto codePoint = make(Type::i32);
- return builder.makeStringNew(
- StringNewFromCodePoint, codePoint, nullptr, false);
+ return builder.makeStringNew(StringNewFromCodePoint, codePoint);
}
Expression* TranslateToFuzzReader::makeStringConst() {
diff --git a/src/wasm-binary.h b/src/wasm-binary.h
index 449c03699..71de2f915 100644
--- a/src/wasm-binary.h
+++ b/src/wasm-binary.h
@@ -1121,37 +1121,22 @@ enum ASTNodes {
// stringref opcodes
- StringNewUTF8 = 0x80,
- StringNewWTF16 = 0x81,
StringConst = 0x82,
StringMeasureUTF8 = 0x83,
- StringMeasureWTF8 = 0x84,
StringMeasureWTF16 = 0x85,
- StringEncodeUTF8 = 0x86,
- StringEncodeWTF16 = 0x87,
StringConcat = 0x88,
StringEq = 0x89,
StringIsUSV = 0x8a,
- StringNewLossyUTF8 = 0x8b,
- StringNewWTF8 = 0x8c,
- StringEncodeLossyUTF8 = 0x8d,
- StringEncodeWTF8 = 0x8e,
- StringNewUTF8Try = 0x8f,
StringAsWTF16 = 0x98,
StringViewWTF16GetCodePoint = 0x9a,
StringViewWTF16Slice = 0x9c,
StringCompare = 0xa8,
StringFromCodePoint = 0xa9,
StringHash = 0xaa,
- StringNewUTF8Array = 0xb0,
StringNewWTF16Array = 0xb1,
- StringEncodeUTF8Array = 0xb2,
StringEncodeWTF16Array = 0xb3,
StringNewLossyUTF8Array = 0xb4,
- StringNewWTF8Array = 0xb5,
StringEncodeLossyUTF8Array = 0xb6,
- StringEncodeWTF8Array = 0xb7,
- StringNewUTF8ArrayTry = 0xb8,
// typed continuation opcodes
ContNew = 0xe0,
diff --git a/src/wasm-builder.h b/src/wasm-builder.h
index 784521c73..8f86b3647 100644
--- a/src/wasm-builder.h
+++ b/src/wasm-builder.h
@@ -1086,28 +1086,15 @@ public:
return ret;
}
StringNew* makeStringNew(StringNewOp op,
- Expression* ptr,
- Expression* length,
- bool try_) {
- auto* ret = wasm.allocator.alloc<StringNew>();
- ret->op = op;
- ret->ptr = ptr;
- ret->length = length;
- ret->try_ = try_;
- ret->finalize();
- return ret;
- }
- StringNew* makeStringNew(StringNewOp op,
- Expression* ptr,
- Expression* start,
- Expression* end,
- bool try_) {
+ Expression* ref,
+ Expression* start = nullptr,
+ Expression* end = nullptr) {
+ assert((start && end) != (op == StringNewFromCodePoint));
auto* ret = wasm.allocator.alloc<StringNew>();
ret->op = op;
- ret->ptr = ptr;
+ ret->ref = ref;
ret->start = start;
ret->end = end;
- ret->try_ = try_;
ret->finalize();
return ret;
}
@@ -1125,13 +1112,13 @@ public:
return ret;
}
StringEncode* makeStringEncode(StringEncodeOp op,
- Expression* ref,
- Expression* ptr,
+ Expression* str,
+ Expression* array,
Expression* start = nullptr) {
auto* ret = wasm.allocator.alloc<StringEncode>();
ret->op = op;
- ret->ref = ref;
- ret->ptr = ptr;
+ ret->str = str;
+ ret->array = array;
ret->start = start;
ret->finalize();
return ret;
diff --git a/src/wasm-delegations-fields.def b/src/wasm-delegations-fields.def
index 898c3a361..03d46020e 100644
--- a/src/wasm-delegations-fields.def
+++ b/src/wasm-delegations-fields.def
@@ -714,11 +714,9 @@ DELEGATE_FIELD_CASE_END(RefAs)
DELEGATE_FIELD_CASE_START(StringNew)
DELEGATE_FIELD_INT(StringNew, op)
-DELEGATE_FIELD_INT(StringNew, try_)
DELEGATE_FIELD_OPTIONAL_CHILD(StringNew, end)
DELEGATE_FIELD_OPTIONAL_CHILD(StringNew, start)
-DELEGATE_FIELD_OPTIONAL_CHILD(StringNew, length)
-DELEGATE_FIELD_CHILD(StringNew, ptr)
+DELEGATE_FIELD_CHILD(StringNew, ref)
DELEGATE_FIELD_CASE_END(StringNew)
DELEGATE_FIELD_CASE_START(StringConst)
@@ -733,8 +731,8 @@ DELEGATE_FIELD_CASE_END(StringMeasure)
DELEGATE_FIELD_CASE_START(StringEncode)
DELEGATE_FIELD_INT(StringEncode, op)
DELEGATE_FIELD_OPTIONAL_CHILD(StringEncode, start)
-DELEGATE_FIELD_CHILD(StringEncode, ptr)
-DELEGATE_FIELD_CHILD(StringEncode, ref)
+DELEGATE_FIELD_CHILD(StringEncode, array)
+DELEGATE_FIELD_CHILD(StringEncode, str)
DELEGATE_FIELD_CASE_END(StringEncode)
DELEGATE_FIELD_CASE_START(StringConcat)
diff --git a/src/wasm-interpreter.h b/src/wasm-interpreter.h
index bd7d78a6e..fa129f14a 100644
--- a/src/wasm-interpreter.h
+++ b/src/wasm-interpreter.h
@@ -1866,7 +1866,7 @@ public:
WASM_UNREACHABLE("unimplemented ref.as_*");
}
Flow visitStringNew(StringNew* curr) {
- Flow ptr = visit(curr->ptr);
+ Flow ptr = visit(curr->ref);
if (ptr.breaking()) {
return ptr;
}
@@ -1976,39 +1976,38 @@ public:
return Flow(NONCONSTANT_FLOW);
}
- Flow ref = visit(curr->ref);
- if (ref.breaking()) {
- return ref;
+ Flow str = visit(curr->str);
+ if (str.breaking()) {
+ return str;
}
- // TODO: "WTF-16 position treatment", as in stringview_wtf16.slice?
- Flow ptr = visit(curr->ptr);
- if (ptr.breaking()) {
- return ptr;
+ Flow array = visit(curr->array);
+ if (array.breaking()) {
+ return array;
}
Flow start = visit(curr->start);
if (start.breaking()) {
return start;
}
- auto refData = ref.getSingleValue().getGCData();
- auto ptrData = ptr.getSingleValue().getGCData();
- if (!refData || !ptrData) {
+ auto strData = str.getSingleValue().getGCData();
+ auto arrayData = array.getSingleValue().getGCData();
+ if (!strData || !arrayData) {
trap("null ref");
}
auto startVal = start.getSingleValue().getUnsigned();
- auto& refValues = refData->values;
- auto& ptrValues = ptrData->values;
+ auto& strValues = strData->values;
+ auto& arrayValues = arrayData->values;
size_t end;
- if (std::ckd_add<size_t>(&end, startVal, refValues.size()) ||
- end > ptrValues.size()) {
+ if (std::ckd_add<size_t>(&end, startVal, strValues.size()) ||
+ end > arrayValues.size()) {
trap("oob");
}
- for (Index i = 0; i < refValues.size(); i++) {
- ptrValues[startVal + i] = refValues[i];
+ for (Index i = 0; i < strValues.size(); i++) {
+ arrayValues[startVal + i] = strValues[i];
}
- return Literal(int32_t(refData->values.size()));
+ return Literal(int32_t(strData->values.size()));
}
Flow visitStringEq(StringEq* curr) {
NOTE_ENTER("StringEq");
diff --git a/src/wasm-ir-builder.h b/src/wasm-ir-builder.h
index 17ec28f2f..16c3b7570 100644
--- a/src/wasm-ir-builder.h
+++ b/src/wasm-ir-builder.h
@@ -206,10 +206,10 @@ public:
[[nodiscard]] Result<> makeArrayInitData(HeapType type, Name data);
[[nodiscard]] Result<> makeArrayInitElem(HeapType type, Name elem);
[[nodiscard]] Result<> makeRefAs(RefAsOp op);
- [[nodiscard]] Result<> makeStringNew(StringNewOp op, bool try_, Name mem);
+ [[nodiscard]] Result<> makeStringNew(StringNewOp op);
[[nodiscard]] Result<> makeStringConst(Name string);
[[nodiscard]] Result<> makeStringMeasure(StringMeasureOp op);
- [[nodiscard]] Result<> makeStringEncode(StringEncodeOp op, Name mem);
+ [[nodiscard]] Result<> makeStringEncode(StringEncodeOp op);
[[nodiscard]] Result<> makeStringConcat();
[[nodiscard]] Result<> makeStringEq(StringEqOp op);
[[nodiscard]] Result<> makeStringWTF8Advance();
diff --git a/src/wasm-s-parser.h b/src/wasm-s-parser.h
index cfd21661d..fe2bda1c7 100644
--- a/src/wasm-s-parser.h
+++ b/src/wasm-s-parser.h
@@ -315,7 +315,7 @@ private:
Expression* makeArrayInitElem(Element& s);
Expression* makeRefAs(Element& s, RefAsOp op);
Expression* makeRefAsNonNull(Element& s);
- Expression* makeStringNew(Element& s, StringNewOp op, bool try_);
+ Expression* makeStringNew(Element& s, StringNewOp op);
Expression* makeStringConst(Element& s);
Expression* makeStringMeasure(Element& s, StringMeasureOp op);
Expression* makeStringEncode(Element& s, StringEncodeOp op);
diff --git a/src/wasm.h b/src/wasm.h
index e39d3d527..ebb5a04f6 100644
--- a/src/wasm.h
+++ b/src/wasm.h
@@ -573,36 +573,18 @@ enum BrOnOp {
};
enum StringNewOp {
- // Linear memory
- StringNewUTF8,
- StringNewWTF8,
- StringNewLossyUTF8,
- StringNewWTF16,
- // GC
- StringNewUTF8Array,
- StringNewWTF8Array,
StringNewLossyUTF8Array,
StringNewWTF16Array,
- // Other
StringNewFromCodePoint,
};
enum StringMeasureOp {
StringMeasureUTF8,
- StringMeasureWTF8,
StringMeasureWTF16,
- StringMeasureIsUSV,
- StringMeasureHash,
};
enum StringEncodeOp {
- StringEncodeUTF8,
- StringEncodeLossyUTF8,
- StringEncodeWTF8,
- StringEncodeWTF16,
- StringEncodeUTF8Array,
StringEncodeLossyUTF8Array,
- StringEncodeWTF8Array,
StringEncodeWTF16Array,
};
@@ -1799,21 +1781,14 @@ public:
StringNewOp op;
- // In linear memory variations this is the pointer in linear memory. In the
- // GC variations this is an Array. In from_codepoint this is the code point.
- Expression* ptr;
-
- // Used only in linear memory variations.
- Expression* length = nullptr;
+ // In the GC variations this is an Array. In from_codepoint this is the code
+ // point.
+ Expression* ref;
// Used only in GC variations.
Expression* start = nullptr;
Expression* end = nullptr;
- // The "try" variants will return null if an encoding error happens, rather
- // than trap.
- bool try_ = false;
-
void finalize();
};
@@ -1848,16 +1823,9 @@ public:
StringEncode(MixedArena& allocator) {}
StringEncodeOp op;
-
- Expression* ref;
-
- // In linear memory variations this is the pointer in linear memory. In the
- // GC variations this is an Array.
- Expression* ptr;
-
- // Used only in GC variations, where it is the index in |ptr| to start
- // encoding from.
- Expression* start = nullptr;
+ Expression* str;
+ Expression* array;
+ Expression* start;
void finalize();
};
diff --git a/src/wasm/wasm-binary.cpp b/src/wasm/wasm-binary.cpp
index c8dd7bace..befafde59 100644
--- a/src/wasm/wasm-binary.cpp
+++ b/src/wasm/wasm-binary.cpp
@@ -7501,77 +7501,21 @@ bool WasmBinaryReader::maybeVisitArrayInit(Expression*& out, uint32_t code) {
bool WasmBinaryReader::maybeVisitStringNew(Expression*& out, uint32_t code) {
StringNewOp op;
- Expression* length = nullptr;
- Expression* start = nullptr;
- Expression* end = nullptr;
- bool try_ = false;
- if (code == BinaryConsts::StringNewUTF8) {
- // FIXME: the memory index should be an LEB like all other places
- if (getInt8() != 0) {
- throwError("Unexpected nonzero memory index");
- }
- op = StringNewUTF8;
- length = popNonVoidExpression();
- } else if (code == BinaryConsts::StringNewLossyUTF8) {
- // FIXME: the memory index should be an LEB like all other places
- if (getInt8() != 0) {
- throwError("Unexpected nonzero memory index");
- }
- op = StringNewLossyUTF8;
- length = popNonVoidExpression();
- } else if (code == BinaryConsts::StringNewWTF8) {
- // FIXME: the memory index should be an LEB like all other places
- if (getInt8() != 0) {
- throwError("Unexpected nonzero memory index");
- }
- op = StringNewWTF8;
- length = popNonVoidExpression();
- } else if (code == BinaryConsts::StringNewUTF8Try) {
- // FIXME: the memory index should be an LEB like all other places
- if (getInt8() != 0) {
- throwError("Unexpected nonzero memory index");
- }
- op = StringNewUTF8;
- try_ = true;
- length = popNonVoidExpression();
- } else if (code == BinaryConsts::StringNewWTF16) {
- if (getInt8() != 0) {
- throwError("Unexpected nonzero memory index");
- }
- op = StringNewWTF16;
- length = popNonVoidExpression();
- } else if (code == BinaryConsts::StringNewUTF8Array) {
- op = StringNewUTF8Array;
- end = popNonVoidExpression();
- start = popNonVoidExpression();
- } else if (code == BinaryConsts::StringNewLossyUTF8Array) {
+ if (code == BinaryConsts::StringNewLossyUTF8Array) {
op = StringNewLossyUTF8Array;
- end = popNonVoidExpression();
- start = popNonVoidExpression();
- } else if (code == BinaryConsts::StringNewWTF8Array) {
- op = StringNewWTF8Array;
- end = popNonVoidExpression();
- start = popNonVoidExpression();
- } else if (code == BinaryConsts::StringNewUTF8ArrayTry) {
- op = StringNewUTF8Array;
- try_ = true;
- end = popNonVoidExpression();
- start = popNonVoidExpression();
} else if (code == BinaryConsts::StringNewWTF16Array) {
op = StringNewWTF16Array;
- end = popNonVoidExpression();
- start = popNonVoidExpression();
} else if (code == BinaryConsts::StringFromCodePoint) {
- op = StringNewFromCodePoint;
+ out = Builder(wasm).makeStringNew(StringNewFromCodePoint,
+ popNonVoidExpression());
+ return true;
} else {
return false;
}
- auto* ptr = popNonVoidExpression();
- if (length) {
- out = Builder(wasm).makeStringNew(op, ptr, length, try_);
- } else {
- out = Builder(wasm).makeStringNew(op, ptr, start, end, try_);
- }
+ Expression* end = popNonVoidExpression();
+ Expression* start = popNonVoidExpression();
+ auto* ref = popNonVoidExpression();
+ out = Builder(wasm).makeStringNew(op, ref, start, end);
return true;
}
@@ -7605,14 +7549,8 @@ bool WasmBinaryReader::maybeVisitStringMeasure(Expression*& out,
StringMeasureOp op;
if (code == BinaryConsts::StringMeasureUTF8) {
op = StringMeasureUTF8;
- } else if (code == BinaryConsts::StringMeasureWTF8) {
- op = StringMeasureWTF8;
} else if (code == BinaryConsts::StringMeasureWTF16) {
op = StringMeasureWTF16;
- } else if (code == BinaryConsts::StringIsUSV) {
- op = StringMeasureIsUSV;
- } else if (code == BinaryConsts::StringHash) {
- op = StringMeasureHash;
} else {
return false;
}
@@ -7623,43 +7561,14 @@ bool WasmBinaryReader::maybeVisitStringMeasure(Expression*& out,
bool WasmBinaryReader::maybeVisitStringEncode(Expression*& out, uint32_t code) {
StringEncodeOp op;
- Expression* start = nullptr;
- // TODO: share this code with string.measure?
- if (code == BinaryConsts::StringEncodeUTF8) {
- if (getInt8() != 0) {
- throwError("Unexpected nonzero memory index");
- }
- op = StringEncodeUTF8;
- } else if (code == BinaryConsts::StringEncodeLossyUTF8) {
- if (getInt8() != 0) {
- throwError("Unexpected nonzero memory index");
- }
- op = StringEncodeLossyUTF8;
- } else if (code == BinaryConsts::StringEncodeWTF8) {
- if (getInt8() != 0) {
- throwError("Unexpected nonzero memory index");
- }
- op = StringEncodeWTF8;
- } else if (code == BinaryConsts::StringEncodeWTF16) {
- if (getInt8() != 0) {
- throwError("Unexpected nonzero memory index");
- }
- op = StringEncodeWTF16;
- } else if (code == BinaryConsts::StringEncodeUTF8Array) {
- op = StringEncodeUTF8Array;
- start = popNonVoidExpression();
- } else if (code == BinaryConsts::StringEncodeLossyUTF8Array) {
+ if (code == BinaryConsts::StringEncodeLossyUTF8Array) {
op = StringEncodeLossyUTF8Array;
- start = popNonVoidExpression();
- } else if (code == BinaryConsts::StringEncodeWTF8Array) {
- op = StringEncodeWTF8Array;
- start = popNonVoidExpression();
} else if (code == BinaryConsts::StringEncodeWTF16Array) {
op = StringEncodeWTF16Array;
- start = popNonVoidExpression();
} else {
return false;
}
+ auto* start = popNonVoidExpression();
auto* ptr = popNonVoidExpression();
auto* ref = popNonVoidExpression();
out = Builder(wasm).makeStringEncode(op, ref, ptr, start);
diff --git a/src/wasm/wasm-ir-builder.cpp b/src/wasm/wasm-ir-builder.cpp
index a4b7becf8..bf737bbd6 100644
--- a/src/wasm/wasm-ir-builder.cpp
+++ b/src/wasm/wasm-ir-builder.cpp
@@ -1804,35 +1804,21 @@ Result<> IRBuilder::makeRefAs(RefAsOp op) {
return Ok{};
}
-Result<> IRBuilder::makeStringNew(StringNewOp op, bool try_, Name mem) {
+Result<> IRBuilder::makeStringNew(StringNewOp op) {
StringNew curr;
curr.op = op;
- // TODO: Store the memory in the IR.
- switch (op) {
- case StringNewUTF8:
- case StringNewWTF8:
- case StringNewLossyUTF8:
- case StringNewWTF16:
- CHECK_ERR(visitStringNew(&curr));
- push(builder.makeStringNew(op, curr.ptr, curr.length, try_));
- return Ok{};
- case StringNewUTF8Array:
- case StringNewWTF8Array:
- case StringNewLossyUTF8Array:
- case StringNewWTF16Array:
- // There's no type annotation on these instructions due to a bug in the
- // stringref proposal, so we just fudge it and pass `array` instead of a
- // defined heap type. This will allow us to pop a child with an invalid
- // array type, but that's just too bad.
- CHECK_ERR(ChildPopper{*this}.visitStringNew(&curr, HeapType::array));
- push(builder.makeStringNew(op, curr.ptr, curr.start, curr.end, try_));
- return Ok{};
- case StringNewFromCodePoint:
- CHECK_ERR(visitStringNew(&curr));
- push(builder.makeStringNew(op, curr.ptr, nullptr, try_));
- return Ok{};
- }
- WASM_UNREACHABLE("unexpected op");
+ if (op == StringNewFromCodePoint) {
+ CHECK_ERR(visitStringNew(&curr));
+ push(builder.makeStringNew(op, curr.ref));
+ return Ok{};
+ }
+ // There's no type annotation on these instructions due to a bug in the
+ // stringref proposal, so we just fudge it and pass `array` instead of a
+ // defined heap type. This will allow us to pop a child with an invalid
+ // array type, but that's just too bad.
+ CHECK_ERR(ChildPopper{*this}.visitStringNew(&curr, HeapType::array));
+ push(builder.makeStringNew(op, curr.ref, curr.start, curr.end));
+ return Ok{};
}
Result<> IRBuilder::makeStringConst(Name string) {
@@ -1848,33 +1834,16 @@ Result<> IRBuilder::makeStringMeasure(StringMeasureOp op) {
return Ok{};
}
-Result<> IRBuilder::makeStringEncode(StringEncodeOp op, Name mem) {
+Result<> IRBuilder::makeStringEncode(StringEncodeOp op) {
StringEncode curr;
curr.op = op;
- // TODO: Store the memory in the IR.
- switch (op) {
- case StringEncodeUTF8:
- case StringEncodeLossyUTF8:
- case StringEncodeWTF8:
- case StringEncodeWTF16: {
- CHECK_ERR(visitStringEncode(&curr));
- push(builder.makeStringEncode(op, curr.ref, curr.ptr, curr.start));
- return Ok{};
- }
- case StringEncodeUTF8Array:
- case StringEncodeLossyUTF8Array:
- case StringEncodeWTF8Array:
- case StringEncodeWTF16Array: {
- // There's no type annotation on these instructions due to a bug in the
- // stringref proposal, so we just fudge it and pass `array` instead of a
- // defined heap type. This will allow us to pop a child with an invalid
- // array type, but that's just too bad.
- CHECK_ERR(ChildPopper{*this}.visitStringEncode(&curr, HeapType::array));
- push(builder.makeStringEncode(op, curr.ref, curr.ptr, curr.start));
- return Ok{};
- }
- }
- WASM_UNREACHABLE("unexpected op");
+ // There's no type annotation on these instructions due to a bug in the
+ // stringref proposal, so we just fudge it and pass `array` instead of a
+ // defined heap type. This will allow us to pop a child with an invalid
+ // array type, but that's just too bad.
+ CHECK_ERR(ChildPopper{*this}.visitStringEncode(&curr, HeapType::array));
+ push(builder.makeStringEncode(op, curr.str, curr.array, curr.start));
+ return Ok{};
}
Result<> IRBuilder::makeStringConcat() {
diff --git a/src/wasm/wasm-s-parser.cpp b/src/wasm/wasm-s-parser.cpp
index 978ea6a9b..f9eae14b8 100644
--- a/src/wasm/wasm-s-parser.cpp
+++ b/src/wasm/wasm-s-parser.cpp
@@ -3301,30 +3301,13 @@ Expression* SExpressionWasmBuilder::makeRefAs(Element& s, RefAsOp op) {
return Builder(wasm).makeRefAs(op, value);
}
-Expression*
-SExpressionWasmBuilder::makeStringNew(Element& s, StringNewOp op, bool try_) {
- Expression* length = nullptr;
- if (op == StringNewWTF8) {
- length = parseExpression(s[2]);
- return Builder(wasm).makeStringNew(op, parseExpression(s[1]), length, try_);
- } else if (op == StringNewUTF8 || op == StringNewLossyUTF8 ||
- op == StringNewWTF16) {
- length = parseExpression(s[2]);
- return Builder(wasm).makeStringNew(op, parseExpression(s[1]), length, try_);
- } else if (op == StringNewWTF8Array) {
- auto* start = parseExpression(s[2]);
- auto* end = parseExpression(s[3]);
- return Builder(wasm).makeStringNew(
- op, parseExpression(s[1]), start, end, try_);
- } else if (op == StringNewUTF8Array || op == StringNewLossyUTF8Array ||
- op == StringNewWTF16Array) {
+Expression* SExpressionWasmBuilder::makeStringNew(Element& s, StringNewOp op) {
+ if (op == StringNewLossyUTF8Array || op == StringNewWTF16Array) {
auto* start = parseExpression(s[2]);
auto* end = parseExpression(s[3]);
- return Builder(wasm).makeStringNew(
- op, parseExpression(s[1]), start, end, try_);
+ return Builder(wasm).makeStringNew(op, parseExpression(s[1]), start, end);
} else if (op == StringNewFromCodePoint) {
- return Builder(wasm).makeStringNew(
- op, parseExpression(s[1]), nullptr, try_);
+ return Builder(wasm).makeStringNew(op, parseExpression(s[1]));
} else {
throw SParseException("bad string.new op", s);
}
@@ -3350,13 +3333,9 @@ Expression* SExpressionWasmBuilder::makeStringMeasure(Element& s,
Expression* SExpressionWasmBuilder::makeStringEncode(Element& s,
StringEncodeOp op) {
- Expression* start = nullptr;
- if (op == StringEncodeWTF8Array || op == StringEncodeUTF8Array ||
- op == StringEncodeLossyUTF8Array || op == StringEncodeWTF16Array) {
- start = parseExpression(s[3]);
- }
+
return Builder(wasm).makeStringEncode(
- op, parseExpression(s[1]), parseExpression(s[2]), start);
+ op, parseExpression(s[1]), parseExpression(s[2]), parseExpression(s[3]));
}
Expression* SExpressionWasmBuilder::makeStringConcat(Element& s) {
diff --git a/src/wasm/wasm-stack.cpp b/src/wasm/wasm-stack.cpp
index a817e5294..1d7fe5255 100644
--- a/src/wasm/wasm-stack.cpp
+++ b/src/wasm/wasm-stack.cpp
@@ -2298,7 +2298,7 @@ void BinaryInstWriter::visitRefAs(RefAs* curr) {
}
void BinaryInstWriter::visitStringNew(StringNew* curr) {
- if (curr->ptr->type.isNull()) {
+ if (curr->ref->type.isNull()) {
// This is a bottom type, so this is an array-receiving operation that does
// not receive an array. The spec allows this, but V8 does not, see
// https://github.com/WebAssembly/stringref/issues/66
@@ -2308,36 +2308,6 @@ void BinaryInstWriter::visitStringNew(StringNew* curr) {
}
o << int8_t(BinaryConsts::GCPrefix);
switch (curr->op) {
- case StringNewUTF8:
- if (!curr->try_) {
- o << U32LEB(BinaryConsts::StringNewUTF8);
- } else {
- o << U32LEB(BinaryConsts::StringNewUTF8Try);
- }
- o << int8_t(0); // Memory index.
- break;
- case StringNewWTF8:
- o << U32LEB(BinaryConsts::StringNewWTF8);
- o << int8_t(0); // Memory index.
- break;
- case StringNewLossyUTF8:
- o << U32LEB(BinaryConsts::StringNewLossyUTF8);
- o << int8_t(0); // Memory index.
- break;
- case StringNewWTF16:
- o << U32LEB(BinaryConsts::StringNewWTF16);
- o << int8_t(0); // Memory index.
- break;
- case StringNewUTF8Array:
- if (!curr->try_) {
- o << U32LEB(BinaryConsts::StringNewUTF8Array);
- } else {
- o << U32LEB(BinaryConsts::StringNewUTF8ArrayTry);
- }
- break;
- case StringNewWTF8Array:
- o << U32LEB(BinaryConsts::StringNewWTF8Array);
- break;
case StringNewLossyUTF8Array:
o << U32LEB(BinaryConsts::StringNewLossyUTF8Array);
break;
@@ -2363,56 +2333,25 @@ void BinaryInstWriter::visitStringMeasure(StringMeasure* curr) {
case StringMeasureUTF8:
o << U32LEB(BinaryConsts::StringMeasureUTF8);
break;
- case StringMeasureWTF8:
- o << U32LEB(BinaryConsts::StringMeasureWTF8);
- break;
case StringMeasureWTF16:
o << U32LEB(BinaryConsts::StringMeasureWTF16);
break;
- case StringMeasureIsUSV:
- o << U32LEB(BinaryConsts::StringIsUSV);
- break;
- case StringMeasureHash:
- o << U32LEB(BinaryConsts::StringHash);
- break;
default:
WASM_UNREACHABLE("invalid string.new*");
}
}
void BinaryInstWriter::visitStringEncode(StringEncode* curr) {
- if (curr->ptr->type.isNull()) {
+ if (curr->str->type.isNull()) {
// See visitStringNew.
emitUnreachable();
return;
}
o << int8_t(BinaryConsts::GCPrefix);
switch (curr->op) {
- case StringEncodeUTF8:
- o << U32LEB(BinaryConsts::StringEncodeUTF8);
- o << int8_t(0); // Memory index.
- break;
- case StringEncodeLossyUTF8:
- o << U32LEB(BinaryConsts::StringEncodeLossyUTF8);
- o << int8_t(0); // Memory index.
- break;
- case StringEncodeWTF8:
- o << U32LEB(BinaryConsts::StringEncodeWTF8);
- o << int8_t(0); // Memory index.
- break;
- case StringEncodeWTF16:
- o << U32LEB(BinaryConsts::StringEncodeWTF16);
- o << int8_t(0); // Memory index.
- break;
- case StringEncodeUTF8Array:
- o << U32LEB(BinaryConsts::StringEncodeUTF8Array);
- break;
case StringEncodeLossyUTF8Array:
o << U32LEB(BinaryConsts::StringEncodeLossyUTF8Array);
break;
- case StringEncodeWTF8Array:
- o << U32LEB(BinaryConsts::StringEncodeWTF8Array);
- break;
case StringEncodeWTF16Array:
o << U32LEB(BinaryConsts::StringEncodeWTF16Array);
break;
diff --git a/src/wasm/wasm-validator.cpp b/src/wasm/wasm-validator.cpp
index e9bee8e08..bf7ebc620 100644
--- a/src/wasm/wasm-validator.cpp
+++ b/src/wasm/wasm-validator.cpp
@@ -3248,37 +3248,43 @@ void FunctionValidator::visitStringNew(StringNew* curr) {
"string operations require reference-types [--enable-strings]");
switch (curr->op) {
+ case StringNewLossyUTF8Array:
case StringNewWTF16Array: {
- auto ptrType = curr->ptr->type;
- if (ptrType == Type::unreachable) {
+ auto refType = curr->ref->type;
+ if (refType == Type::unreachable) {
return;
}
- if (!shouldBeTrue(ptrType.isRef(),
- curr,
- "string.new_wtf16_array input must have string type")) {
+ if (!shouldBeTrue(
+ refType.isRef(), curr, "string.new input must have array type")) {
return;
}
- auto ptrHeapType = ptrType.getHeapType();
- if (!shouldBeTrue(ptrHeapType.isBottom() || ptrHeapType.isArray(),
+ auto heapType = refType.getHeapType();
+ if (!shouldBeTrue(heapType.isBottom() || heapType.isArray(),
curr,
- "string.new_wtf16_array input must be array")) {
+ "string.new input must have array type")) {
return;
}
+ shouldBeEqualOrFirstIsUnreachable(curr->start->type,
+ Type(Type::i32),
+ curr,
+ "string.new start must be i32");
shouldBeEqualOrFirstIsUnreachable(
- curr->start->type,
- Type(Type::i32),
- curr,
- "string.new_wtf16_array start must be i32");
+ curr->end->type, Type(Type::i32), curr, "string.new end must be i32");
+ return;
+ }
+ case StringNewFromCodePoint:
shouldBeEqualOrFirstIsUnreachable(
- curr->end->type,
+ curr->ref->type,
Type(Type::i32),
curr,
- "string.new_wtf16_array end must be i32");
- break;
- }
- default: {
- }
+ "string.from_code_point code point must be i32");
+ shouldBeTrue(
+ !curr->start, curr, "string.from_code_point should not have start");
+ shouldBeTrue(
+ !curr->end, curr, "string.from_code_point should not have end");
+ return;
}
+ WASM_UNREACHABLE("unexpected op");
}
void FunctionValidator::visitStringConst(StringConst* curr) {
diff --git a/src/wasm/wasm.cpp b/src/wasm/wasm.cpp
index 22ea4d86f..a4b9da21b 100644
--- a/src/wasm/wasm.cpp
+++ b/src/wasm/wasm.cpp
@@ -1244,13 +1244,12 @@ void RefAs::finalize() {
}
void StringNew::finalize() {
- if (ptr->type == Type::unreachable ||
- (length && length->type == Type::unreachable) ||
+ if (ref->type == Type::unreachable ||
(start && start->type == Type::unreachable) ||
(end && end->type == Type::unreachable)) {
type = Type::unreachable;
} else {
- type = Type(HeapType::string, try_ ? Nullable : NonNullable);
+ type = Type(HeapType::string, NonNullable);
}
}
@@ -1265,8 +1264,8 @@ void StringMeasure::finalize() {
}
void StringEncode::finalize() {
- if (ref->type == Type::unreachable || ptr->type == Type::unreachable ||
- (start && start->type == Type::unreachable)) {
+ if (str->type == Type::unreachable || array->type == Type::unreachable ||
+ start->type == Type::unreachable) {
type = Type::unreachable;
} else {
type = Type::i32;
generated by cgit v1.2.3 (git 2.39.1) at 2025-07-03 19:45:29 +0000