summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/parser/contexts.h115
-rw-r--r--src/parser/input-impl.h4
-rw-r--r--src/parser/input.h2
-rw-r--r--src/parser/parsers.h93
-rw-r--r--src/wasm-ir-builder.h32
-rw-r--r--src/wasm.h15
-rw-r--r--src/wasm/wasm-ir-builder.cpp186
7 files changed, 394 insertions, 53 deletions
diff --git a/src/parser/contexts.h b/src/parser/contexts.h
index 15b82fe64..620d10d60 100644
--- a/src/parser/contexts.h
+++ b/src/parser/contexts.h
@@ -104,6 +104,10 @@ struct NullTypeParserCtx {
HeapTypeT makeI31() { return Ok{}; }
HeapTypeT makeStructType() { return Ok{}; }
HeapTypeT makeArrayType() { return Ok{}; }
+ HeapTypeT makeStringType() { return Ok{}; }
+ HeapTypeT makeStringViewWTF8Type() { return Ok{}; }
+ HeapTypeT makeStringViewWTF16Type() { return Ok{}; }
+ HeapTypeT makeStringViewIterType() { return Ok{}; }
TypeT makeI32() { return Ok{}; }
TypeT makeI64() { return Ok{}; }
@@ -190,6 +194,10 @@ template<typename Ctx> struct TypeParserCtx {
HeapTypeT makeI31() { return HeapType::i31; }
HeapTypeT makeStructType() { return HeapType::struct_; }
HeapTypeT makeArrayType() { return HeapType::array; }
+ HeapTypeT makeStringType() { return HeapType::string; }
+ HeapTypeT makeStringViewWTF8Type() { return HeapType::stringview_wtf8; }
+ HeapTypeT makeStringViewWTF16Type() { return HeapType::stringview_wtf16; }
+ HeapTypeT makeStringViewIterType() { return HeapType::stringview_iter; }
TypeT makeI32() { return Type::i32; }
TypeT makeI64() { return Type::i64; }
@@ -284,8 +292,9 @@ struct NullInstrParserCtx {
using FuncIdxT = Ok;
using LocalIdxT = Ok;
using TableIdxT = Ok;
- using GlobalIdxT = Ok;
using MemoryIdxT = Ok;
+ using GlobalIdxT = Ok;
+ using ElemIdxT = Ok;
using DataIdxT = Ok;
using LabelIdxT = Ok;
using TagIdxT = Ok;
@@ -310,6 +319,8 @@ struct NullInstrParserCtx {
TableIdxT getTableFromName(Name) { return Ok{}; }
MemoryIdxT getMemoryFromIdx(uint32_t) { return Ok{}; }
MemoryIdxT getMemoryFromName(Name) { return Ok{}; }
+ ElemIdxT getElemFromIdx(uint32_t) { return Ok{}; }
+ ElemIdxT getElemFromName(Name) { return Ok{}; }
DataIdxT getDataFromIdx(uint32_t) { return Ok{}; }
DataIdxT getDataFromName(Name) { return Ok{}; }
LabelIdxT getLabelFromIdx(uint32_t, bool) { return Ok{}; }
@@ -458,7 +469,7 @@ struct NullInstrParserCtx {
return Ok{};
}
template<typename HeapTypeT>
- Result<> makeArrayNewElem(Index, HeapTypeT, DataIdxT) {
+ Result<> makeArrayNewElem(Index, HeapTypeT, ElemIdxT) {
return Ok{};
}
template<typename HeapTypeT>
@@ -479,7 +490,28 @@ struct NullInstrParserCtx {
template<typename HeapTypeT> Result<> makeArrayFill(Index, HeapTypeT) {
return Ok{};
}
+ template<typename HeapTypeT>
+ Result<> makeArrayInitData(Index, HeapTypeT, DataIdxT) {
+ return Ok{};
+ }
+ template<typename HeapTypeT>
+ Result<> makeArrayInitElem(Index, HeapTypeT, ElemIdxT) {
+ return Ok{};
+ }
Result<> makeRefAs(Index, RefAsOp) { return Ok{}; }
+ Result<> makeStringNew(Index, StringNewOp, bool, MemoryIdxT*) { return Ok{}; }
+ Result<> makeStringConst(Index, std::string_view) { return Ok{}; }
+ Result<> makeStringMeasure(Index, StringMeasureOp) { return Ok{}; }
+ Result<> makeStringEncode(Index, StringEncodeOp, MemoryIdxT*) { return Ok{}; }
+ Result<> makeStringConcat(Index) { return Ok{}; }
+ Result<> makeStringEq(Index, StringEqOp) { return Ok{}; }
+ Result<> makeStringAs(Index, StringAsOp) { return Ok{}; }
+ Result<> makeStringWTF8Advance(Index) { return Ok{}; }
+ Result<> makeStringWTF16Get(Index) { return Ok{}; }
+ Result<> makeStringIterNext(Index) { return Ok{}; }
+ Result<> makeStringIterMove(Index, StringIterMoveOp) { return Ok{}; }
+ Result<> makeStringSliceWTF(Index, StringSliceWTFOp) { return Ok{}; }
+ Result<> makeStringSliceIter(Index) { return Ok{}; }
};
// Phase 1: Parse definition spans for top-level module elements and determine
@@ -968,6 +1000,7 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx> {
using GlobalIdxT = Name;
using TableIdxT = Name;
using MemoryIdxT = Name;
+ using ElemIdxT = Name;
using DataIdxT = Name;
using TagIdxT = Name;
@@ -1141,6 +1174,20 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx> {
return name;
}
+ Result<Name> getElemFromIdx(uint32_t idx) {
+ if (idx >= wasm.elementSegments.size()) {
+ return in.err("elem index out of bounds");
+ }
+ return wasm.elementSegments[idx]->name;
+ }
+
+ Result<Name> getElemFromName(Name name) {
+ if (!wasm.getElementSegmentOrNull(name)) {
+ return in.err("elem $" + name.toString() + " does not exist");
+ }
+ return name;
+ }
+
Result<Name> getDataFromIdx(uint32_t idx) {
if (idx >= wasm.dataSegments.size()) {
return in.err("data index out of bounds");
@@ -1658,9 +1705,73 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx> {
return withLoc(pos, irBuilder.makeArrayFill(type));
}
+ Result<> makeArrayInitData(Index pos, HeapType type, Name data) {
+ return withLoc(pos, irBuilder.makeArrayInitData(type, data));
+ }
+
+ Result<> makeArrayInitElem(Index pos, HeapType type, Name elem) {
+ return withLoc(pos, irBuilder.makeArrayInitElem(type, elem));
+ }
+
Result<> makeRefAs(Index pos, RefAsOp op) {
return withLoc(pos, irBuilder.makeRefAs(op));
}
+
+ Result<> makeStringNew(Index pos, StringNewOp op, bool try_, Name* mem) {
+ auto m = getMemory(pos, mem);
+ CHECK_ERR(m);
+ return withLoc(pos, irBuilder.makeStringNew(op, try_, *m));
+ }
+
+ Result<> makeStringConst(Index pos, std::string_view str) {
+ return withLoc(pos, irBuilder.makeStringConst(Name(str)));
+ }
+
+ Result<> makeStringMeasure(Index pos, StringMeasureOp op) {
+ return withLoc(pos, irBuilder.makeStringMeasure(op));
+ }
+
+ Result<> makeStringEncode(Index pos, StringEncodeOp op, Name* mem) {
+ auto m = getMemory(pos, mem);
+ CHECK_ERR(m);
+ return withLoc(pos, irBuilder.makeStringEncode(op, *m));
+ }
+
+ Result<> makeStringConcat(Index pos) {
+ return withLoc(pos, irBuilder.makeStringConcat());
+ }
+
+ Result<> makeStringEq(Index pos, StringEqOp op) {
+ return withLoc(pos, irBuilder.makeStringEq(op));
+ }
+
+ Result<> makeStringAs(Index pos, StringAsOp op) {
+ return withLoc(pos, irBuilder.makeStringAs(op));
+ }
+
+ Result<> makeStringWTF8Advance(Index pos) {
+ return withLoc(pos, irBuilder.makeStringWTF8Advance());
+ }
+
+ Result<> makeStringWTF16Get(Index pos) {
+ return withLoc(pos, irBuilder.makeStringWTF16Get());
+ }
+
+ Result<> makeStringIterNext(Index pos) {
+ return withLoc(pos, irBuilder.makeStringIterNext());
+ }
+
+ Result<> makeStringIterMove(Index pos, StringIterMoveOp op) {
+ return withLoc(pos, irBuilder.makeStringIterMove(op));
+ }
+
+ Result<> makeStringSliceWTF(Index pos, StringSliceWTFOp op) {
+ return withLoc(pos, irBuilder.makeStringSliceWTF(op));
+ }
+
+ Result<> makeStringSliceIter(Index pos) {
+ return withLoc(pos, irBuilder.makeStringSliceIter());
+ }
};
} // namespace wasm::WATParser
diff --git a/src/parser/input-impl.h b/src/parser/input-impl.h
index 7ee358f12..0f8fc2e86 100644
--- a/src/parser/input-impl.h
+++ b/src/parser/input-impl.h
@@ -226,11 +226,11 @@ inline std::optional<float> ParseInput::takeF32() {
return std::nullopt;
}
-inline std::optional<std::string_view> ParseInput::takeString() {
+inline std::optional<std::string> ParseInput::takeString() {
if (auto t = peek()) {
if (auto s = t->getString()) {
++lexer;
- return s;
+ return std::string(*s);
}
}
return {};
diff --git a/src/parser/input.h b/src/parser/input.h
index 5cb2bd471..dbf3e4868 100644
--- a/src/parser/input.h
+++ b/src/parser/input.h
@@ -59,7 +59,7 @@ struct ParseInput {
std::optional<uint8_t> takeU8();
std::optional<double> takeF64();
std::optional<float> takeF32();
- std::optional<std::string_view> takeString();
+ std::optional<std::string> takeString();
std::optional<Name> takeName();
bool takeSExprStart(std::string_view expected);
bool peekSExprStart(std::string_view expected);
diff --git a/src/parser/parsers.h b/src/parser/parsers.h
index be8db49a9..4909ad057 100644
--- a/src/parser/parsers.h
+++ b/src/parser/parsers.h
@@ -176,6 +176,8 @@ template<typename Ctx> MaybeResult<typename Ctx::MemoryIdxT> maybeMemidx(Ctx&);
template<typename Ctx> Result<typename Ctx::MemoryIdxT> memidx(Ctx&);
template<typename Ctx> MaybeResult<typename Ctx::MemoryIdxT> maybeMemuse(Ctx&);
template<typename Ctx> Result<typename Ctx::GlobalIdxT> globalidx(Ctx&);
+template<typename Ctx> Result<typename Ctx::ElemIdxT> elemidx(Ctx&);
+template<typename Ctx> Result<typename Ctx::DataIdxT> dataidx(Ctx&);
template<typename Ctx> Result<typename Ctx::LocalIdxT> localidx(Ctx&);
template<typename Ctx>
Result<typename Ctx::LabelIdxT> labelidx(Ctx&, bool inDelegate = false);
@@ -249,6 +251,18 @@ template<typename Ctx> Result<typename Ctx::HeapTypeT> heaptype(Ctx& ctx) {
if (ctx.in.takeKeyword("array"sv)) {
return ctx.makeArrayType();
}
+ if (ctx.in.takeKeyword("string"sv)) {
+ return ctx.makeStringType();
+ }
+ if (ctx.in.takeKeyword("stringview_wtf8"sv)) {
+ return ctx.makeStringViewWTF8Type();
+ }
+ if (ctx.in.takeKeyword("stringview_wtf16"sv)) {
+ return ctx.makeStringViewWTF16Type();
+ }
+ if (ctx.in.takeKeyword("stringview_iter"sv)) {
+ return ctx.makeStringViewIterType();
+ }
auto type = typeidx(ctx);
CHECK_ERR(type);
return *type;
@@ -282,7 +296,19 @@ template<typename Ctx> MaybeResult<typename Ctx::TypeT> reftype(Ctx& ctx) {
return ctx.makeRefType(ctx.makeStructType(), Nullable);
}
if (ctx.in.takeKeyword("arrayref"sv)) {
- return ctx.in.err("arrayref not yet supported");
+ return ctx.makeRefType(ctx.makeArrayType(), Nullable);
+ }
+ if (ctx.in.takeKeyword("stringref"sv)) {
+ return ctx.makeRefType(ctx.makeStringType(), Nullable);
+ }
+ if (ctx.in.takeKeyword("stringview_wtf8"sv)) {
+ return ctx.makeRefType(ctx.makeStringViewWTF8Type(), Nullable);
+ }
+ if (ctx.in.takeKeyword("stringview_wtf16"sv)) {
+ return ctx.makeRefType(ctx.makeStringViewWTF16Type(), Nullable);
+ }
+ if (ctx.in.takeKeyword("stringview_iter"sv)) {
+ return ctx.makeRefType(ctx.makeStringViewIterType(), Nullable);
}
if (!ctx.in.takeSExprStart("ref"sv)) {
@@ -1584,7 +1610,11 @@ template<typename Ctx> Result<> makeArrayNewData(Ctx& ctx, Index pos) {
}
template<typename Ctx> Result<> makeArrayNewElem(Ctx& ctx, Index pos) {
- return ctx.in.err("unimplemented instruction");
+ auto type = typeidx(ctx);
+ CHECK_ERR(type);
+ auto elem = elemidx(ctx);
+ CHECK_ERR(elem);
+ return ctx.makeArrayNewElem(pos, *type, *elem);
}
template<typename Ctx> Result<> makeArrayNewFixed(Ctx& ctx, Index pos) {
@@ -1629,11 +1659,18 @@ template<typename Ctx> Result<> makeArrayFill(Ctx& ctx, Index pos) {
}
template<typename Ctx> Result<> makeArrayInitData(Ctx& ctx, Index pos) {
- return ctx.in.err("unimplemented instruction");
+ auto type = typeidx(ctx);
+ CHECK_ERR(type);
+ auto data = dataidx(ctx);
+ CHECK_ERR(data);
+ return ctx.makeArrayInitData(pos, *type, *data);
}
template<typename Ctx> Result<> makeArrayInitElem(Ctx& ctx, Index pos) {
- return ctx.in.err("unimplemented instruction");
+ auto type = typeidx(ctx);
+ CHECK_ERR(type);
+ auto elem = elemidx(ctx);
+ return ctx.makeArrayInitElem(pos, *type, *elem);
}
template<typename Ctx> Result<> makeRefAs(Ctx& ctx, Index pos, RefAsOp op) {
@@ -1642,61 +1679,69 @@ template<typename Ctx> Result<> makeRefAs(Ctx& ctx, Index pos, RefAsOp op) {
template<typename Ctx>
Result<> makeStringNew(Ctx& ctx, Index pos, StringNewOp op, bool try_) {
- return ctx.in.err("unimplemented instruction");
+ auto mem = maybeMemidx(ctx);
+ CHECK_ERR(mem);
+ return ctx.makeStringNew(pos, op, try_, mem.getPtr());
}
template<typename Ctx> Result<> makeStringConst(Ctx& ctx, Index pos) {
- return ctx.in.err("unimplemented instruction");
+ auto str = ctx.in.takeString();
+ if (!str) {
+ return ctx.in.err("expected string");
+ }
+ return ctx.makeStringConst(pos, *str);
}
template<typename Ctx>
Result<> makeStringMeasure(Ctx& ctx, Index pos, StringMeasureOp op) {
- return ctx.in.err("unimplemented instruction");
+ return ctx.makeStringMeasure(pos, op);
}
template<typename Ctx>
Result<> makeStringEncode(Ctx& ctx, Index pos, StringEncodeOp op) {
- return ctx.in.err("unimplemented instruction");
+ auto mem = maybeMemidx(ctx);
+ CHECK_ERR(mem);
+ return ctx.makeStringEncode(pos, op, mem.getPtr());
}
template<typename Ctx> Result<> makeStringConcat(Ctx& ctx, Index pos) {
- return ctx.in.err("unimplemented instruction");
+ return ctx.makeStringConcat(pos);
}
template<typename Ctx>
Result<> makeStringEq(Ctx& ctx, Index pos, StringEqOp op) {
- return ctx.in.err("unimplemented instruction");
+ return ctx.makeStringEq(pos, op);
}
template<typename Ctx>
Result<> makeStringAs(Ctx& ctx, Index pos, StringAsOp op) {
- return ctx.in.err("unimplemented instruction");
+ return ctx.makeStringAs(pos, op);
}
template<typename Ctx> Result<> makeStringWTF8Advance(Ctx& ctx, Index pos) {
- return ctx.in.err("unimplemented instruction");
+ return ctx.makeStringWTF8Advance(pos);
}
template<typename Ctx> Result<> makeStringWTF16Get(Ctx& ctx, Index pos) {
- return ctx.in.err("unimplemented instruction");
+ return ctx.makeStringWTF16Get(pos);
}
template<typename Ctx> Result<> makeStringIterNext(Ctx& ctx, Index pos) {
- return ctx.in.err("unimplemented instruction");
+ return ctx.makeStringIterNext(pos);
}
template<typename Ctx>
Result<> makeStringIterMove(Ctx& ctx, Index pos, StringIterMoveOp op) {
- return ctx.in.err("unimplemented instruction");
+ return ctx.makeStringIterMove(pos, op);
}
template<typename Ctx>
Result<> makeStringSliceWTF(Ctx& ctx, Index pos, StringSliceWTFOp op) {
- return ctx.in.err("unimplemented instruction");
+ return ctx.makeStringSliceWTF(pos, op);
}
template<typename Ctx> Result<> makeStringSliceIter(Ctx& ctx, Index pos) {
- return ctx.in.err("unimplemented instruction");
+ return ctx.makeStringSliceIter(pos);
}
// =======
@@ -1843,8 +1888,20 @@ template<typename Ctx> Result<typename Ctx::GlobalIdxT> globalidx(Ctx& ctx) {
return ctx.in.err("expected global index or identifier");
}
+// elemidx ::= x:u32 => x
+// | v:id => x (if elems[x] = v)
+template<typename Ctx> Result<typename Ctx::ElemIdxT> elemidx(Ctx& ctx) {
+ if (auto x = ctx.in.takeU32()) {
+ return ctx.getElemFromIdx(*x);
+ }
+ if (auto id = ctx.in.takeID()) {
+ return ctx.getElemFromName(*id);
+ }
+ return ctx.in.err("expected elem index or identifier");
+}
+
// dataidx ::= x:u32 => x
-// | v:id => x (if data[x] = v)
+// | v:id => x (if datas[x] = v)
template<typename Ctx> Result<typename Ctx::DataIdxT> dataidx(Ctx& ctx) {
if (auto x = ctx.in.takeU32()) {
return ctx.getDataFromIdx(*x);
diff --git a/src/wasm-ir-builder.h b/src/wasm-ir-builder.h
index a7e36bd10..8b01977be 100644
--- a/src/wasm-ir-builder.h
+++ b/src/wasm-ir-builder.h
@@ -181,22 +181,22 @@ public:
[[nodiscard]] Result<> makeArrayLen();
[[nodiscard]] Result<> makeArrayCopy(HeapType destType, HeapType srcType);
[[nodiscard]] Result<> makeArrayFill(HeapType type);
- // [[nodiscard]] Result<> makeArrayInitData();
- // [[nodiscard]] Result<> makeArrayInitElem();
+ [[nodiscard]] Result<> makeArrayInitData(HeapType type, Name data);
+ [[nodiscard]] Result<> makeArrayInitElem(HeapType type, Name elem);
[[nodiscard]] Result<> makeRefAs(RefAsOp op);
- // [[nodiscard]] Result<> makeStringNew();
- // [[nodiscard]] Result<> makeStringConst();
- // [[nodiscard]] Result<> makeStringMeasure();
- // [[nodiscard]] Result<> makeStringEncode();
- // [[nodiscard]] Result<> makeStringConcat();
- // [[nodiscard]] Result<> makeStringEq();
- // [[nodiscard]] Result<> makeStringAs();
- // [[nodiscard]] Result<> makeStringWTF8Advance();
- // [[nodiscard]] Result<> makeStringWTF16Get();
- // [[nodiscard]] Result<> makeStringIterNext();
- // [[nodiscard]] Result<> makeStringIterMove();
- // [[nodiscard]] Result<> makeStringSliceWTF();
- // [[nodiscard]] Result<> makeStringSliceIter();
+ [[nodiscard]] Result<> makeStringNew(StringNewOp op, bool try_, Name mem);
+ [[nodiscard]] Result<> makeStringConst(Name string);
+ [[nodiscard]] Result<> makeStringMeasure(StringMeasureOp op);
+ [[nodiscard]] Result<> makeStringEncode(StringEncodeOp op, Name mem);
+ [[nodiscard]] Result<> makeStringConcat();
+ [[nodiscard]] Result<> makeStringEq(StringEqOp op);
+ [[nodiscard]] Result<> makeStringAs(StringAsOp op);
+ [[nodiscard]] Result<> makeStringWTF8Advance();
+ [[nodiscard]] Result<> makeStringWTF16Get();
+ [[nodiscard]] Result<> makeStringIterNext();
+ [[nodiscard]] Result<> makeStringIterMove(StringIterMoveOp op);
+ [[nodiscard]] Result<> makeStringSliceWTF(StringSliceWTFOp op);
+ [[nodiscard]] Result<> makeStringSliceIter();
// Private functions that must be public for technical reasons.
[[nodiscard]] Result<> visitExpression(Expression*);
@@ -213,6 +213,8 @@ public:
[[nodiscard]] Result<> visitCallIndirect(CallIndirect*);
[[nodiscard]] Result<> visitCallRef(CallRef*);
[[nodiscard]] Result<> visitThrow(Throw*);
+ [[nodiscard]] Result<> visitStringNew(StringNew*);
+ [[nodiscard]] Result<> visitStringEncode(StringEncode*);
private:
Module& wasm;
diff --git a/src/wasm.h b/src/wasm.h
index 7da80d896..ce334773a 100644
--- a/src/wasm.h
+++ b/src/wasm.h
@@ -1736,6 +1736,7 @@ public:
class ArrayInitData : public SpecificExpression<Expression::ArrayInitDataId> {
public:
+ ArrayInitData() = default;
ArrayInitData(MixedArena& allocator) {}
Name segment;
@@ -1749,6 +1750,7 @@ public:
class ArrayInitElem : public SpecificExpression<Expression::ArrayInitElemId> {
public:
+ ArrayInitElem() = default;
ArrayInitElem(MixedArena& allocator) {}
Name segment;
@@ -1774,6 +1776,7 @@ public:
class StringNew : public SpecificExpression<Expression::StringNewId> {
public:
+ StringNew() = default;
StringNew(MixedArena& allocator) {}
StringNewOp op;
@@ -1798,6 +1801,7 @@ public:
class StringConst : public SpecificExpression<Expression::StringConstId> {
public:
+ StringConst() = default;
StringConst(MixedArena& allocator) {}
// TODO: Use a different type to allow null bytes in the middle -
@@ -1810,6 +1814,7 @@ public:
class StringMeasure : public SpecificExpression<Expression::StringMeasureId> {
public:
+ StringMeasure() = default;
StringMeasure(MixedArena& allocator) {}
StringMeasureOp op;
@@ -1821,6 +1826,7 @@ public:
class StringEncode : public SpecificExpression<Expression::StringEncodeId> {
public:
+ StringEncode() = default;
StringEncode(MixedArena& allocator) {}
StringEncodeOp op;
@@ -1840,6 +1846,7 @@ public:
class StringConcat : public SpecificExpression<Expression::StringConcatId> {
public:
+ StringConcat() = default;
StringConcat(MixedArena& allocator) {}
Expression* left;
@@ -1850,6 +1857,7 @@ public:
class StringEq : public SpecificExpression<Expression::StringEqId> {
public:
+ StringEq() = default;
StringEq(MixedArena& allocator) {}
StringEqOp op;
@@ -1862,6 +1870,7 @@ public:
class StringAs : public SpecificExpression<Expression::StringAsId> {
public:
+ StringAs() = default;
StringAs(MixedArena& allocator) {}
StringAsOp op;
@@ -1874,6 +1883,7 @@ public:
class StringWTF8Advance
: public SpecificExpression<Expression::StringWTF8AdvanceId> {
public:
+ StringWTF8Advance() = default;
StringWTF8Advance(MixedArena& allocator) {}
Expression* ref;
@@ -1885,6 +1895,7 @@ public:
class StringWTF16Get : public SpecificExpression<Expression::StringWTF16GetId> {
public:
+ StringWTF16Get() = default;
StringWTF16Get(MixedArena& allocator) {}
Expression* ref;
@@ -1895,6 +1906,7 @@ public:
class StringIterNext : public SpecificExpression<Expression::StringIterNextId> {
public:
+ StringIterNext() = default;
StringIterNext(MixedArena& allocator) {}
Expression* ref;
@@ -1904,6 +1916,7 @@ public:
class StringIterMove : public SpecificExpression<Expression::StringIterMoveId> {
public:
+ StringIterMove() = default;
StringIterMove(MixedArena& allocator) {}
// Whether the movement is to advance or reverse.
@@ -1919,6 +1932,7 @@ public:
class StringSliceWTF : public SpecificExpression<Expression::StringSliceWTFId> {
public:
+ StringSliceWTF() = default;
StringSliceWTF(MixedArena& allocator) {}
StringSliceWTFOp op;
@@ -1933,6 +1947,7 @@ public:
class StringSliceIter
: public SpecificExpression<Expression::StringSliceIterId> {
public:
+ StringSliceIter() = default;
StringSliceIter(MixedArena& allocator) {}
Expression* ref;
diff --git a/src/wasm/wasm-ir-builder.cpp b/src/wasm/wasm-ir-builder.cpp
index 5301b75dc..d3f48b1c0 100644
--- a/src/wasm/wasm-ir-builder.cpp
+++ b/src/wasm/wasm-ir-builder.cpp
@@ -471,6 +471,65 @@ Result<> IRBuilder::visitThrow(Throw* curr) {
return Ok{};
}
+Result<> IRBuilder::visitStringNew(StringNew* curr) {
+ switch (curr->op) {
+ case StringNewUTF8:
+ case StringNewWTF8:
+ case StringNewLossyUTF8:
+ case StringNewWTF16: {
+ auto len = pop();
+ CHECK_ERR(len);
+ curr->length = *len;
+ break;
+ }
+ case StringNewUTF8Array:
+ case StringNewWTF8Array:
+ case StringNewLossyUTF8Array:
+ case StringNewWTF16Array: {
+ auto end = pop();
+ CHECK_ERR(end);
+ curr->end = *end;
+ auto start = pop();
+ CHECK_ERR(start);
+ curr->start = *start;
+ break;
+ }
+ case StringNewFromCodePoint:
+ break;
+ }
+ auto ptr = pop();
+ CHECK_ERR(ptr);
+ curr->ptr = *ptr;
+ return Ok{};
+}
+
+Result<> IRBuilder::visitStringEncode(StringEncode* curr) {
+ switch (curr->op) {
+ case StringEncodeUTF8Array:
+ case StringEncodeLossyUTF8Array:
+ case StringEncodeWTF8Array:
+ case StringEncodeWTF16Array: {
+ auto start = pop();
+ CHECK_ERR(start);
+ curr->start = *start;
+ }
+ [[fallthrough]];
+ case StringEncodeUTF8:
+ case StringEncodeLossyUTF8:
+ case StringEncodeWTF8:
+ case StringEncodeWTF16: {
+ auto ptr = pop();
+ CHECK_ERR(ptr);
+ curr->ptr = *ptr;
+ auto ref = pop();
+ CHECK_ERR(ref);
+ curr->ref = *ref;
+ return Ok{};
+ }
+ }
+ WASM_UNREACHABLE("unexpected op");
+}
+
Result<> IRBuilder::visitFunctionStart(Function* func) {
if (!scopeStack.empty()) {
return Err{"unexpected start of function"};
@@ -1408,9 +1467,23 @@ Result<> IRBuilder::makeArrayFill(HeapType type) {
return Ok{};
}
-// Result<> IRBuilder::makeArrayInitData() {}
+Result<> IRBuilder::makeArrayInitData(HeapType type, Name data) {
+ ArrayInitData curr;
+ CHECK_ERR(visitArrayInitData(&curr));
+ CHECK_ERR(validateTypeAnnotation(type, curr.ref));
+ push(builder.makeArrayInitData(
+ data, curr.ref, curr.index, curr.offset, curr.size));
+ return Ok{};
+}
-// Result<> IRBuilder::makeArrayInitElem() {}
+Result<> IRBuilder::makeArrayInitElem(HeapType type, Name elem) {
+ ArrayInitElem curr;
+ CHECK_ERR(visitArrayInitElem(&curr));
+ CHECK_ERR(validateTypeAnnotation(type, curr.ref));
+ push(builder.makeArrayInitElem(
+ elem, curr.ref, curr.index, curr.offset, curr.size));
+ return Ok{};
+}
Result<> IRBuilder::makeRefAs(RefAsOp op) {
RefAs curr;
@@ -1419,30 +1492,113 @@ Result<> IRBuilder::makeRefAs(RefAsOp op) {
return Ok{};
}
-// Result<> IRBuilder::makeStringNew() {}
+Result<> IRBuilder::makeStringNew(StringNewOp op, bool try_, Name mem) {
+ StringNew curr;
+ curr.op = op;
+ CHECK_ERR(visitStringNew(&curr));
+ // TODO: Store the memory in the IR.
+ switch (op) {
+ case StringNewUTF8:
+ case StringNewWTF8:
+ case StringNewLossyUTF8:
+ case StringNewWTF16:
+ push(builder.makeStringNew(op, curr.ptr, curr.length, try_));
+ return Ok{};
+ case StringNewUTF8Array:
+ case StringNewWTF8Array:
+ case StringNewLossyUTF8Array:
+ case StringNewWTF16Array:
+ push(builder.makeStringNew(op, curr.ptr, curr.start, curr.end, try_));
+ return Ok{};
+ case StringNewFromCodePoint:
+ push(builder.makeStringNew(op, curr.ptr, nullptr, try_));
+ return Ok{};
+ }
+ WASM_UNREACHABLE("unexpected op");
+}
-// Result<> IRBuilder::makeStringConst() {}
+Result<> IRBuilder::makeStringConst(Name string) {
+ push(builder.makeStringConst(string));
+ return Ok{};
+}
-// Result<> IRBuilder::makeStringMeasure() {}
+Result<> IRBuilder::makeStringMeasure(StringMeasureOp op) {
+ StringMeasure curr;
+ CHECK_ERR(visitStringMeasure(&curr));
+ push(builder.makeStringMeasure(op, curr.ref));
+ return Ok{};
+}
-// Result<> IRBuilder::makeStringEncode() {}
+Result<> IRBuilder::makeStringEncode(StringEncodeOp op, Name mem) {
+ StringEncode curr;
+ curr.op = op;
+ CHECK_ERR(visitStringEncode(&curr));
+ // TODO: Store the memory in the IR.
+ push(builder.makeStringEncode(op, curr.ref, curr.ptr, curr.start));
+ return Ok{};
+}
-// Result<> IRBuilder::makeStringConcat() {}
+Result<> IRBuilder::makeStringConcat() {
+ StringConcat curr;
+ CHECK_ERR(visitStringConcat(&curr));
+ push(builder.makeStringConcat(curr.left, curr.right));
+ return Ok{};
+}
-// Result<> IRBuilder::makeStringEq() {}
+Result<> IRBuilder::makeStringEq(StringEqOp op) {
+ StringEq curr;
+ CHECK_ERR(visitStringEq(&curr));
+ push(builder.makeStringEq(op, curr.left, curr.right));
+ return Ok{};
+}
-// Result<> IRBuilder::makeStringAs() {}
+Result<> IRBuilder::makeStringAs(StringAsOp op) {
+ StringAs curr;
+ CHECK_ERR(visitStringAs(&curr));
+ push(builder.makeStringAs(op, curr.ref));
+ return Ok{};
+}
-// Result<> IRBuilder::makeStringWTF8Advance() {}
+Result<> IRBuilder::makeStringWTF8Advance() {
+ StringWTF8Advance curr;
+ CHECK_ERR(visitStringWTF8Advance(&curr));
+ push(builder.makeStringWTF8Advance(curr.ref, curr.pos, curr.bytes));
+ return Ok{};
+}
-// Result<> IRBuilder::makeStringWTF16Get() {}
+Result<> IRBuilder::makeStringWTF16Get() {
+ StringWTF16Get curr;
+ CHECK_ERR(visitStringWTF16Get(&curr));
+ push(builder.makeStringWTF16Get(curr.ref, curr.pos));
+ return Ok{};
+}
-// Result<> IRBuilder::makeStringIterNext() {}
+Result<> IRBuilder::makeStringIterNext() {
+ StringIterNext curr;
+ CHECK_ERR(visitStringIterNext(&curr));
+ push(builder.makeStringIterNext(curr.ref));
+ return Ok{};
+}
-// Result<> IRBuilder::makeStringIterMove() {}
+Result<> IRBuilder::makeStringIterMove(StringIterMoveOp op) {
+ StringIterMove curr;
+ CHECK_ERR(visitStringIterMove(&curr));
+ push(builder.makeStringIterMove(op, curr.ref, curr.num));
+ return Ok{};
+}
-// Result<> IRBuilder::makeStringSliceWTF() {}
+Result<> IRBuilder::makeStringSliceWTF(StringSliceWTFOp op) {
+ StringSliceWTF curr;
+ CHECK_ERR(visitStringSliceWTF(&curr));
+ push(builder.makeStringSliceWTF(op, curr.ref, curr.start, curr.end));
+ return Ok{};
+}
-// Result<> IRBuilder::makeStringSliceIter() {}
+Result<> IRBuilder::makeStringSliceIter() {
+ StringSliceIter curr;
+ CHECK_ERR(visitStringSliceIter(&curr));
+ push(builder.makeStringSliceIter(curr.ref, curr.num));
+ return Ok{};
+}
} // namespace wasm
generated by cgit v1.2.3 (git 2.39.1) at 2025-08-25 19:07:26 +0000