Skip to content

Commit 09b9d87

Browse files
tlivelytlively
committed
[Parser] Parse string types and operations (#6161)
1 parent b4b58db commit 09b9d87

8 files changed

Lines changed: 805 additions & 138 deletions

File tree

‎src/parser/contexts.h‎

Lines changed: 77 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -104,6 +104,10 @@ struct NullTypeParserCtx {
104104
HeapTypeT makeI31() { return Ok{}; }
105105
HeapTypeT makeStructType() { return Ok{}; }
106106
HeapTypeT makeArrayType() { return Ok{}; }
107+
HeapTypeT makeStringType() { return Ok{}; }
108+
HeapTypeT makeStringViewWTF8Type() { return Ok{}; }
109+
HeapTypeT makeStringViewWTF16Type() { return Ok{}; }
110+
HeapTypeT makeStringViewIterType() { return Ok{}; }
107111

108112
TypeT makeI32() { return Ok{}; }
109113
TypeT makeI64() { return Ok{}; }
@@ -190,6 +194,10 @@ template<typename Ctx> struct TypeParserCtx {
190194
HeapTypeT makeI31() { return HeapType::i31; }
191195
HeapTypeT makeStructType() { return HeapType::struct_; }
192196
HeapTypeT makeArrayType() { return HeapType::array; }
197+
HeapTypeT makeStringType() { return HeapType::string; }
198+
HeapTypeT makeStringViewWTF8Type() { return HeapType::stringview_wtf8; }
199+
HeapTypeT makeStringViewWTF16Type() { return HeapType::stringview_wtf16; }
200+
HeapTypeT makeStringViewIterType() { return HeapType::stringview_iter; }
193201

194202
TypeT makeI32() { return Type::i32; }
195203
TypeT makeI64() { return Type::i64; }
@@ -491,6 +499,19 @@ struct NullInstrParserCtx {
491499
return Ok{};
492500
}
493501
Result<> makeRefAs(Index, RefAsOp) { return Ok{}; }
502+
Result<> makeStringNew(Index, StringNewOp, bool, MemoryIdxT*) { return Ok{}; }
503+
Result<> makeStringConst(Index, std::string_view) { return Ok{}; }
504+
Result<> makeStringMeasure(Index, StringMeasureOp) { return Ok{}; }
505+
Result<> makeStringEncode(Index, StringEncodeOp, MemoryIdxT*) { return Ok{}; }
506+
Result<> makeStringConcat(Index) { return Ok{}; }
507+
Result<> makeStringEq(Index, StringEqOp) { return Ok{}; }
508+
Result<> makeStringAs(Index, StringAsOp) { return Ok{}; }
509+
Result<> makeStringWTF8Advance(Index) { return Ok{}; }
510+
Result<> makeStringWTF16Get(Index) { return Ok{}; }
511+
Result<> makeStringIterNext(Index) { return Ok{}; }
512+
Result<> makeStringIterMove(Index, StringIterMoveOp) { return Ok{}; }
513+
Result<> makeStringSliceWTF(Index, StringSliceWTFOp) { return Ok{}; }
514+
Result<> makeStringSliceIter(Index) { return Ok{}; }
494515
};
495516

496517
// Phase 1: Parse definition spans for top-level module elements and determine
@@ -1695,6 +1716,62 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx> {
16951716
Result<> makeRefAs(Index pos, RefAsOp op) {
16961717
return withLoc(pos, irBuilder.makeRefAs(op));
16971718
}
1719+
1720+
Result<> makeStringNew(Index pos, StringNewOp op, bool try_, Name* mem) {
1721+
auto m = getMemory(pos, mem);
1722+
CHECK_ERR(m);
1723+
return withLoc(pos, irBuilder.makeStringNew(op, try_, *m));
1724+
}
1725+
1726+
Result<> makeStringConst(Index pos, std::string_view str) {
1727+
return withLoc(pos, irBuilder.makeStringConst(Name(str)));
1728+
}
1729+
1730+
Result<> makeStringMeasure(Index pos, StringMeasureOp op) {
1731+
return withLoc(pos, irBuilder.makeStringMeasure(op));
1732+
}
1733+
1734+
Result<> makeStringEncode(Index pos, StringEncodeOp op, Name* mem) {
1735+
auto m = getMemory(pos, mem);
1736+
CHECK_ERR(m);
1737+
return withLoc(pos, irBuilder.makeStringEncode(op, *m));
1738+
}
1739+
1740+
Result<> makeStringConcat(Index pos) {
1741+
return withLoc(pos, irBuilder.makeStringConcat());
1742+
}
1743+
1744+
Result<> makeStringEq(Index pos, StringEqOp op) {
1745+
return withLoc(pos, irBuilder.makeStringEq(op));
1746+
}
1747+
1748+
Result<> makeStringAs(Index pos, StringAsOp op) {
1749+
return withLoc(pos, irBuilder.makeStringAs(op));
1750+
}
1751+
1752+
Result<> makeStringWTF8Advance(Index pos) {
1753+
return withLoc(pos, irBuilder.makeStringWTF8Advance());
1754+
}
1755+
1756+
Result<> makeStringWTF16Get(Index pos) {
1757+
return withLoc(pos, irBuilder.makeStringWTF16Get());
1758+
}
1759+
1760+
Result<> makeStringIterNext(Index pos) {
1761+
return withLoc(pos, irBuilder.makeStringIterNext());
1762+
}
1763+
1764+
Result<> makeStringIterMove(Index pos, StringIterMoveOp op) {
1765+
return withLoc(pos, irBuilder.makeStringIterMove(op));
1766+
}
1767+
1768+
Result<> makeStringSliceWTF(Index pos, StringSliceWTFOp op) {
1769+
return withLoc(pos, irBuilder.makeStringSliceWTF(op));
1770+
}
1771+
1772+
Result<> makeStringSliceIter(Index pos) {
1773+
return withLoc(pos, irBuilder.makeStringSliceIter());
1774+
}
16981775
};
16991776

17001777
} // namespace wasm::WATParser

‎src/parser/input-impl.h‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -226,11 +226,11 @@ inline std::optional<float> ParseInput::takeF32() {
226226
return std::nullopt;
227227
}
228228

229-
inline std::optional<std::string_view> ParseInput::takeString() {
229+
inline std::optional<std::string> ParseInput::takeString() {
230230
if (auto t = peek()) {
231231
if (auto s = t->getString()) {
232232
++lexer;
233-
return s;
233+
return std::string(*s);
234234
}
235235
}
236236
return {};

‎src/parser/input.h‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -59,7 +59,7 @@ struct ParseInput {
5959
std::optional<uint8_t> takeU8();
6060
std::optional<double> takeF64();
6161
std::optional<float> takeF32();
62-
std::optional<std::string_view> takeString();
62+
std::optional<std::string> takeString();
6363
std::optional<Name> takeName();
6464
bool takeSExprStart(std::string_view expected);
6565
bool peekSExprStart(std::string_view expected);

‎src/parser/parsers.h‎

Lines changed: 46 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -251,6 +251,18 @@ template<typename Ctx> Result<typename Ctx::HeapTypeT> heaptype(Ctx& ctx) {
251251
if (ctx.in.takeKeyword("array"sv)) {
252252
return ctx.makeArrayType();
253253
}
254+
if (ctx.in.takeKeyword("string"sv)) {
255+
return ctx.makeStringType();
256+
}
257+
if (ctx.in.takeKeyword("stringview_wtf8"sv)) {
258+
return ctx.makeStringViewWTF8Type();
259+
}
260+
if (ctx.in.takeKeyword("stringview_wtf16"sv)) {
261+
return ctx.makeStringViewWTF16Type();
262+
}
263+
if (ctx.in.takeKeyword("stringview_iter"sv)) {
264+
return ctx.makeStringViewIterType();
265+
}
254266
auto type = typeidx(ctx);
255267
CHECK_ERR(type);
256268
return *type;
@@ -284,7 +296,19 @@ template<typename Ctx> MaybeResult<typename Ctx::TypeT> reftype(Ctx& ctx) {
284296
return ctx.makeRefType(ctx.makeStructType(), Nullable);
285297
}
286298
if (ctx.in.takeKeyword("arrayref"sv)) {
287-
return ctx.in.err("arrayref not yet supported");
299+
return ctx.makeRefType(ctx.makeArrayType(), Nullable);
300+
}
301+
if (ctx.in.takeKeyword("stringref"sv)) {
302+
return ctx.makeRefType(ctx.makeStringType(), Nullable);
303+
}
304+
if (ctx.in.takeKeyword("stringview_wtf8"sv)) {
305+
return ctx.makeRefType(ctx.makeStringViewWTF8Type(), Nullable);
306+
}
307+
if (ctx.in.takeKeyword("stringview_wtf16"sv)) {
308+
return ctx.makeRefType(ctx.makeStringViewWTF16Type(), Nullable);
309+
}
310+
if (ctx.in.takeKeyword("stringview_iter"sv)) {
311+
return ctx.makeRefType(ctx.makeStringViewIterType(), Nullable);
288312
}
289313

290314
if (!ctx.in.takeSExprStart("ref"sv)) {
@@ -1655,61 +1679,69 @@ template<typename Ctx> Result<> makeRefAs(Ctx& ctx, Index pos, RefAsOp op) {
16551679

16561680
template<typename Ctx>
16571681
Result<> makeStringNew(Ctx& ctx, Index pos, StringNewOp op, bool try_) {
1658-
return ctx.in.err("unimplemented instruction");
1682+
auto mem = maybeMemidx(ctx);
1683+
CHECK_ERR(mem);
1684+
return ctx.makeStringNew(pos, op, try_, mem.getPtr());
16591685
}
16601686

16611687
template<typename Ctx> Result<> makeStringConst(Ctx& ctx, Index pos) {
1662-
return ctx.in.err("unimplemented instruction");
1688+
auto str = ctx.in.takeString();
1689+
if (!str) {
1690+
return ctx.in.err("expected string");
1691+
}
1692+
return ctx.makeStringConst(pos, *str);
16631693
}
16641694

16651695
template<typename Ctx>
16661696
Result<> makeStringMeasure(Ctx& ctx, Index pos, StringMeasureOp op) {
1667-
return ctx.in.err("unimplemented instruction");
1697+
return ctx.makeStringMeasure(pos, op);
16681698
}
16691699

16701700
template<typename Ctx>
16711701
Result<> makeStringEncode(Ctx& ctx, Index pos, StringEncodeOp op) {
1672-
return ctx.in.err("unimplemented instruction");
1702+
auto mem = maybeMemidx(ctx);
1703+
CHECK_ERR(mem);
1704+
return ctx.makeStringEncode(pos, op, mem.getPtr());
16731705
}
16741706

16751707
template<typename Ctx> Result<> makeStringConcat(Ctx& ctx, Index pos) {
1676-
return ctx.in.err("unimplemented instruction");
1708+
return ctx.makeStringConcat(pos);
16771709
}
16781710

16791711
template<typename Ctx>
16801712
Result<> makeStringEq(Ctx& ctx, Index pos, StringEqOp op) {
1681-
return ctx.in.err("unimplemented instruction");
1713+
return ctx.makeStringEq(pos, op);
16821714
}
16831715

16841716
template<typename Ctx>
16851717
Result<> makeStringAs(Ctx& ctx, Index pos, StringAsOp op) {
1686-
return ctx.in.err("unimplemented instruction");
1718+
return ctx.makeStringAs(pos, op);
16871719
}
16881720

16891721
template<typename Ctx> Result<> makeStringWTF8Advance(Ctx& ctx, Index pos) {
1690-
return ctx.in.err("unimplemented instruction");
1722+
return ctx.makeStringWTF8Advance(pos);
16911723
}
16921724

16931725
template<typename Ctx> Result<> makeStringWTF16Get(Ctx& ctx, Index pos) {
1694-
return ctx.in.err("unimplemented instruction");
1726+
return ctx.makeStringWTF16Get(pos);
16951727
}
16961728

16971729
template<typename Ctx> Result<> makeStringIterNext(Ctx& ctx, Index pos) {
1698-
return ctx.in.err("unimplemented instruction");
1730+
return ctx.makeStringIterNext(pos);
16991731
}
17001732

17011733
template<typename Ctx>
17021734
Result<> makeStringIterMove(Ctx& ctx, Index pos, StringIterMoveOp op) {
1703-
return ctx.in.err("unimplemented instruction");
1735+
return ctx.makeStringIterMove(pos, op);
17041736
}
17051737

17061738
template<typename Ctx>
17071739
Result<> makeStringSliceWTF(Ctx& ctx, Index pos, StringSliceWTFOp op) {
1708-
return ctx.in.err("unimplemented instruction");
1740+
return ctx.makeStringSliceWTF(pos, op);
17091741
}
17101742

17111743
template<typename Ctx> Result<> makeStringSliceIter(Ctx& ctx, Index pos) {
1712-
return ctx.in.err("unimplemented instruction");
1744+
return ctx.makeStringSliceIter(pos);
17131745
}
17141746

17151747
// =======

‎src/wasm-ir-builder.h‎

Lines changed: 15 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -184,19 +184,19 @@ class IRBuilder : public UnifiedExpressionVisitor<IRBuilder, Result<>> {
184184
[[nodiscard]] Result<> makeArrayInitData(HeapType type, Name data);
185185
[[nodiscard]] Result<> makeArrayInitElem(HeapType type, Name elem);
186186
[[nodiscard]] Result<> makeRefAs(RefAsOp op);
187-
// [[nodiscard]] Result<> makeStringNew();
188-
// [[nodiscard]] Result<> makeStringConst();
189-
// [[nodiscard]] Result<> makeStringMeasure();
190-
// [[nodiscard]] Result<> makeStringEncode();
191-
// [[nodiscard]] Result<> makeStringConcat();
192-
// [[nodiscard]] Result<> makeStringEq();
193-
// [[nodiscard]] Result<> makeStringAs();
194-
// [[nodiscard]] Result<> makeStringWTF8Advance();
195-
// [[nodiscard]] Result<> makeStringWTF16Get();
196-
// [[nodiscard]] Result<> makeStringIterNext();
197-
// [[nodiscard]] Result<> makeStringIterMove();
198-
// [[nodiscard]] Result<> makeStringSliceWTF();
199-
// [[nodiscard]] Result<> makeStringSliceIter();
187+
[[nodiscard]] Result<> makeStringNew(StringNewOp op, bool try_, Name mem);
188+
[[nodiscard]] Result<> makeStringConst(Name string);
189+
[[nodiscard]] Result<> makeStringMeasure(StringMeasureOp op);
190+
[[nodiscard]] Result<> makeStringEncode(StringEncodeOp op, Name mem);
191+
[[nodiscard]] Result<> makeStringConcat();
192+
[[nodiscard]] Result<> makeStringEq(StringEqOp op);
193+
[[nodiscard]] Result<> makeStringAs(StringAsOp op);
194+
[[nodiscard]] Result<> makeStringWTF8Advance();
195+
[[nodiscard]] Result<> makeStringWTF16Get();
196+
[[nodiscard]] Result<> makeStringIterNext();
197+
[[nodiscard]] Result<> makeStringIterMove(StringIterMoveOp op);
198+
[[nodiscard]] Result<> makeStringSliceWTF(StringSliceWTFOp op);
199+
[[nodiscard]] Result<> makeStringSliceIter();
200200

201201
// Private functions that must be public for technical reasons.
202202
[[nodiscard]] Result<> visitExpression(Expression*);
@@ -213,6 +213,8 @@ class IRBuilder : public UnifiedExpressionVisitor<IRBuilder, Result<>> {
213213
[[nodiscard]] Result<> visitCallIndirect(CallIndirect*);
214214
[[nodiscard]] Result<> visitCallRef(CallRef*);
215215
[[nodiscard]] Result<> visitThrow(Throw*);
216+
[[nodiscard]] Result<> visitStringNew(StringNew*);
217+
[[nodiscard]] Result<> visitStringEncode(StringEncode*);
216218

217219
private:
218220
Module& wasm;

‎src/wasm.h‎

Lines changed: 13 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1776,6 +1776,7 @@ class RefAs : public SpecificExpression<Expression::RefAsId> {
17761776

17771777
class StringNew : public SpecificExpression<Expression::StringNewId> {
17781778
public:
1779+
StringNew() = default;
17791780
StringNew(MixedArena& allocator) {}
17801781

17811782
StringNewOp op;
@@ -1800,6 +1801,7 @@ class StringNew : public SpecificExpression<Expression::StringNewId> {
18001801

18011802
class StringConst : public SpecificExpression<Expression::StringConstId> {
18021803
public:
1804+
StringConst() = default;
18031805
StringConst(MixedArena& allocator) {}
18041806

18051807
// TODO: Use a different type to allow null bytes in the middle -
@@ -1812,6 +1814,7 @@ class StringConst : public SpecificExpression<Expression::StringConstId> {
18121814

18131815
class StringMeasure : public SpecificExpression<Expression::StringMeasureId> {
18141816
public:
1817+
StringMeasure() = default;
18151818
StringMeasure(MixedArena& allocator) {}
18161819

18171820
StringMeasureOp op;
@@ -1823,6 +1826,7 @@ class StringMeasure : public SpecificExpression<Expression::StringMeasureId> {
18231826

18241827
class StringEncode : public SpecificExpression<Expression::StringEncodeId> {
18251828
public:
1829+
StringEncode() = default;
18261830
StringEncode(MixedArena& allocator) {}
18271831

18281832
StringEncodeOp op;
@@ -1842,6 +1846,7 @@ class StringEncode : public SpecificExpression<Expression::StringEncodeId> {
18421846

18431847
class StringConcat : public SpecificExpression<Expression::StringConcatId> {
18441848
public:
1849+
StringConcat() = default;
18451850
StringConcat(MixedArena& allocator) {}
18461851

18471852
Expression* left;
@@ -1852,6 +1857,7 @@ class StringConcat : public SpecificExpression<Expression::StringConcatId> {
18521857

18531858
class StringEq : public SpecificExpression<Expression::StringEqId> {
18541859
public:
1860+
StringEq() = default;
18551861
StringEq(MixedArena& allocator) {}
18561862

18571863
StringEqOp op;
@@ -1864,6 +1870,7 @@ class StringEq : public SpecificExpression<Expression::StringEqId> {
18641870

18651871
class StringAs : public SpecificExpression<Expression::StringAsId> {
18661872
public:
1873+
StringAs() = default;
18671874
StringAs(MixedArena& allocator) {}
18681875

18691876
StringAsOp op;
@@ -1876,6 +1883,7 @@ class StringAs : public SpecificExpression<Expression::StringAsId> {
18761883
class StringWTF8Advance
18771884
: public SpecificExpression<Expression::StringWTF8AdvanceId> {
18781885
public:
1886+
StringWTF8Advance() = default;
18791887
StringWTF8Advance(MixedArena& allocator) {}
18801888

18811889
Expression* ref;
@@ -1887,6 +1895,7 @@ class StringWTF8Advance
18871895

18881896
class StringWTF16Get : public SpecificExpression<Expression::StringWTF16GetId> {
18891897
public:
1898+
StringWTF16Get() = default;
18901899
StringWTF16Get(MixedArena& allocator) {}
18911900

18921901
Expression* ref;
@@ -1897,6 +1906,7 @@ class StringWTF16Get : public SpecificExpression<Expression::StringWTF16GetId> {
18971906

18981907
class StringIterNext : public SpecificExpression<Expression::StringIterNextId> {
18991908
public:
1909+
StringIterNext() = default;
19001910
StringIterNext(MixedArena& allocator) {}
19011911

19021912
Expression* ref;
@@ -1906,6 +1916,7 @@ class StringIterNext : public SpecificExpression<Expression::StringIterNextId> {
19061916

19071917
class StringIterMove : public SpecificExpression<Expression::StringIterMoveId> {
19081918
public:
1919+
StringIterMove() = default;
19091920
StringIterMove(MixedArena& allocator) {}
19101921

19111922
// Whether the movement is to advance or reverse.
@@ -1921,6 +1932,7 @@ class StringIterMove : public SpecificExpression<Expression::StringIterMoveId> {
19211932

19221933
class StringSliceWTF : public SpecificExpression<Expression::StringSliceWTFId> {
19231934
public:
1935+
StringSliceWTF() = default;
19241936
StringSliceWTF(MixedArena& allocator) {}
19251937

19261938
StringSliceWTFOp op;
@@ -1935,6 +1947,7 @@ class StringSliceWTF : public SpecificExpression<Expression::StringSliceWTFId> {
19351947
class StringSliceIter
19361948
: public SpecificExpression<Expression::StringSliceIterId> {
19371949
public:
1950+
StringSliceIter() = default;
19381951
StringSliceIter(MixedArena& allocator) {}
19391952

19401953
Expression* ref;

0 commit comments

Comments
 (0)