Skip to content

[Parser] Parse table operations #6154

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
tlively merged 1 commit into from
Dec 12, 2023
Merged

[Parser] Parse table operations #6154

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
44 changes: 44 additions & 0 deletions src/parser/contexts.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -411,6 +411,12 @@ struct NullInstrParserCtx {
Result<> makeRefIsNull(Index) { return Ok{}; }
Result<> makeRefFunc(Index, FuncIdxT) { return Ok{}; }
Result<> makeRefEq(Index) { return Ok{}; }
Result<> makeTableGet(Index, TableIdxT*) { return Ok{}; }
Result<> makeTableSet(Index, TableIdxT*) { return Ok{}; }
Result<> makeTableSize(Index, TableIdxT*) { return Ok{}; }
Result<> makeTableGrow(Index, TableIdxT*) { return Ok{}; }
Result<> makeTableFill(Index, TableIdxT*) { return Ok{}; }
Result<> makeTableCopy(Index, TableIdxT*, TableIdxT*) { return Ok{}; }
Result<> makeThrow(Index, TagIdxT) { return Ok{}; }
template<typename HeapTypeT> Result<> makeCallRef(Index, HeapTypeT, bool) {
return Ok{};
Expand Down Expand Up @@ -1524,6 +1530,44 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx> {

Result<> makeRefEq(Index pos) { return withLoc(pos, irBuilder.makeRefEq()); }

Result<> makeTableGet(Index pos, Name* table) {
auto t = getTable(pos, table);
CHECK_ERR(t);
return withLoc(pos, irBuilder.makeTableGet(*t));
}

Result<> makeTableSet(Index pos, Name* table) {
auto t = getTable(pos, table);
CHECK_ERR(t);
return withLoc(pos, irBuilder.makeTableSet(*t));
}

Result<> makeTableSize(Index pos, Name* table) {
auto t = getTable(pos, table);
CHECK_ERR(t);
return withLoc(pos, irBuilder.makeTableSize(*t));
}

Result<> makeTableGrow(Index pos, Name* table) {
auto t = getTable(pos, table);
CHECK_ERR(t);
return withLoc(pos, irBuilder.makeTableGrow(*t));
}

Result<> makeTableFill(Index pos, Name* table) {
auto t = getTable(pos, table);
CHECK_ERR(t);
return withLoc(pos, irBuilder.makeTableFill(*t));
}

Result<> makeTableCopy(Index pos, Name* destTable, Name* srcTable) {
auto dest = getTable(pos, destTable);
CHECK_ERR(dest);
auto src = getTable(pos, srcTable);
CHECK_ERR(src);
return withLoc(pos, irBuilder.makeTableCopy(*dest, *src));
}

Result<> makeThrow(Index pos, Name tag) {
return withLoc(pos, irBuilder.makeThrow(tag));
}
Expand Down
29 changes: 23 additions & 6 deletions src/parser/parsers.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1432,27 +1432,44 @@ template<typename Ctx> Result<> makeRefEq(Ctx& ctx, Index pos) {
}

template<typename Ctx> Result<> makeTableGet(Ctx& ctx, Index pos) {
return ctx.in.err("unimplemented instruction");
auto table = maybeTableidx(ctx);
CHECK_ERR(table);
return ctx.makeTableGet(pos, table.getPtr());
}

template<typename Ctx> Result<> makeTableSet(Ctx& ctx, Index pos) {
return ctx.in.err("unimplemented instruction");
auto table = maybeTableidx(ctx);
CHECK_ERR(table);
return ctx.makeTableSet(pos, table.getPtr());
}

template<typename Ctx> Result<> makeTableSize(Ctx& ctx, Index pos) {
return ctx.in.err("unimplemented instruction");
auto table = maybeTableidx(ctx);
CHECK_ERR(table);
return ctx.makeTableSize(pos, table.getPtr());
}

template<typename Ctx> Result<> makeTableGrow(Ctx& ctx, Index pos) {
return ctx.in.err("unimplemented instruction");
auto table = maybeTableidx(ctx);
CHECK_ERR(table);
return ctx.makeTableGrow(pos, table.getPtr());
}

template<typename Ctx> Result<> makeTableFill(Ctx& ctx, Index pos) {
return ctx.in.err("unimplemented instruction");
auto table = maybeTableidx(ctx);
CHECK_ERR(table);
return ctx.makeTableFill(pos, table.getPtr());
}

template<typename Ctx> Result<> makeTableCopy(Ctx& ctx, Index pos) {
return ctx.in.err("unimplemented instruction");
auto destTable = maybeTableidx(ctx);
CHECK_ERR(destTable);
auto srcTable = maybeTableidx(ctx);
CHECK_ERR(srcTable);
if (destTable && !srcTable) {
return ctx.in.err("expected table index or identifier");
}
return ctx.makeTableCopy(pos, destTable.getPtr(), srcTable.getPtr());
}

template<typename Ctx> Result<> makeThrow(Ctx& ctx, Index pos) {
Expand Down
12 changes: 6 additions & 6 deletions src/wasm-ir-builder.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -148,12 +148,12 @@ class IRBuilder : public UnifiedExpressionVisitor<IRBuilder, Result<>> {
[[nodiscard]] Result<> makeRefIsNull();
[[nodiscard]] Result<> makeRefFunc(Name func);
[[nodiscard]] Result<> makeRefEq();
// [[nodiscard]] Result<> makeTableGet();
// [[nodiscard]] Result<> makeTableSet();
// [[nodiscard]] Result<> makeTableSize();
// [[nodiscard]] Result<> makeTableGrow();
// [[nodiscard]] Result<> makeTableFill();
// [[nodiscard]] Result<> makeTableCopy();
[[nodiscard]] Result<> makeTableGet(Name table);
[[nodiscard]] Result<> makeTableSet(Name table);
[[nodiscard]] Result<> makeTableSize(Name table);
[[nodiscard]] Result<> makeTableGrow(Name table);
[[nodiscard]] Result<> makeTableFill(Name table);
[[nodiscard]] Result<> makeTableCopy(Name destTable, Name srcTable);
[[nodiscard]] Result<> makeTry(Name label, Type type);
[[nodiscard]] Result<> makeThrow(Name tag);
// [[nodiscard]] Result<> makeRethrow();
Expand Down
2 changes: 2 additions & 0 deletions src/wasm.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1380,6 +1380,7 @@ class RefEq : public SpecificExpression<Expression::RefEqId> {

class TableGet : public SpecificExpression<Expression::TableGetId> {
public:
TableGet() = default;
TableGet(MixedArena& allocator) {}

Name table;
Expand All @@ -1391,6 +1392,7 @@ class TableGet : public SpecificExpression<Expression::TableGetId> {

class TableSet : public SpecificExpression<Expression::TableSetId> {
public:
TableSet() = default;
TableSet(MixedArena& allocator) {}

Name table;
Expand Down
42 changes: 38 additions & 4 deletions src/wasm/wasm-ir-builder.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1159,13 +1159,47 @@ Result<> IRBuilder::makeRefEq() {
return Ok{};
}

// Result<> IRBuilder::makeTableGet() {}
Result<> IRBuilder::makeTableGet(Name table) {
TableGet curr;
CHECK_ERR(visitTableGet(&curr));
auto type = wasm.getTable(table)->type;
push(builder.makeTableGet(table, curr.index, type));
return Ok{};
}

Result<> IRBuilder::makeTableSet(Name table) {
TableSet curr;
CHECK_ERR(visitTableSet(&curr));
push(builder.makeTableSet(table, curr.index, curr.value));
return Ok{};
}

Result<> IRBuilder::makeTableSize(Name table) {
push(builder.makeTableSize(table));
return Ok{};
}

// Result<> IRBuilder::makeTableSet() {}
Result<> IRBuilder::makeTableGrow(Name table) {
TableGrow curr;
CHECK_ERR(visitTableGrow(&curr));
push(builder.makeTableGrow(table, curr.value, curr.delta));
return Ok{};
}

// Result<> IRBuilder::makeTableSize() {}
Result<> IRBuilder::makeTableFill(Name table) {
TableFill curr;
CHECK_ERR(visitTableFill(&curr));
push(builder.makeTableFill(table, curr.dest, curr.value, curr.size));
return Ok{};
}

// Result<> IRBuilder::makeTableGrow() {}
Result<> IRBuilder::makeTableCopy(Name destTable, Name srcTable) {
TableCopy curr;
CHECK_ERR(visitTableCopy(&curr));
push(builder.makeTableCopy(
curr.dest, curr.source, curr.size, destTable, srcTable));
return Ok{};
}

Result<> IRBuilder::makeTry(Name label, Type type) {
auto* tryy = wasm.allocator.alloc<Try>();
Expand Down
167 changes: 166 additions & 1 deletion test/lit/wat-kitchen-sink.wast
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -292,7 +292,7 @@

;; tags
(tag)
;; CHECK: (elem declare func $ref-func)
;; CHECK: (elem declare func $ref-func $table-fill $table-grow $table-set)

;; CHECK: (tag $1)

Expand Down Expand Up @@ -2957,6 +2957,171 @@
ref.eq
)

;; CHECK: (func $table-get (type $void)
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (table.get $timport$0
;; CHECK-NEXT: (i32.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (table.get $funcs
;; CHECK-NEXT: (i32.const 1)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (table.get $table-any
;; CHECK-NEXT: (i32.const 2)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: )
(func $table-get
i32.const 0
table.get
drop
i32.const 1
table.get 1
drop
i32.const 2
table.get $table-any
drop
)

;; CHECK: (func $table-set (type $void)
;; CHECK-NEXT: (table.set $timport$0
;; CHECK-NEXT: (i32.const 0)
;; CHECK-NEXT: (ref.null nofunc)
;; CHECK-NEXT: )
;; CHECK-NEXT: (table.set $funcs
;; CHECK-NEXT: (i32.const 1)
;; CHECK-NEXT: (ref.func $table-set)
;; CHECK-NEXT: )
;; CHECK-NEXT: (table.set $table-any
;; CHECK-NEXT: (i32.const 2)
;; CHECK-NEXT: (ref.null none)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
(func $table-set
i32.const 0
ref.null func
table.set
i32.const 1
ref.func $table-set
table.set 1
i32.const 2
ref.null any
table.set $table-any
)

;; CHECK: (func $table-size (type $void)
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (table.size $timport$0)
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (table.size $funcs)
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (table.size $table-any)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
(func $table-size
table.size
drop
table.size 1
drop
table.size $table-any
drop
)

;; CHECK: (func $table-grow (type $void)
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (table.grow $timport$0
;; CHECK-NEXT: (ref.null nofunc)
;; CHECK-NEXT: (i32.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (table.grow $funcs
;; CHECK-NEXT: (ref.func $table-grow)
;; CHECK-NEXT: (i32.const 1)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (table.grow $table-any
;; CHECK-NEXT: (ref.null none)
;; CHECK-NEXT: (i32.const 2)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: )
(func $table-grow
ref.null func
i32.const 0
table.grow
drop
ref.func $table-grow
i32.const 1
table.grow 1
drop
ref.null any
i32.const 2
table.grow $table-any
drop
)

;; CHECK: (func $table-fill (type $void)
;; CHECK-NEXT: (table.fill $timport$0
;; CHECK-NEXT: (i32.const 0)
;; CHECK-NEXT: (ref.null nofunc)
;; CHECK-NEXT: (i32.const 1)
;; CHECK-NEXT: )
;; CHECK-NEXT: (table.fill $funcs
;; CHECK-NEXT: (i32.const 2)
;; CHECK-NEXT: (ref.func $table-fill)
;; CHECK-NEXT: (i32.const 3)
;; CHECK-NEXT: )
;; CHECK-NEXT: (table.fill $table-any
;; CHECK-NEXT: (i32.const 4)
;; CHECK-NEXT: (ref.null none)
;; CHECK-NEXT: (i32.const 5)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
(func $table-fill
i32.const 0
ref.null func
i32.const 1
table.fill
i32.const 2
ref.func $table-fill
i32.const 3
table.fill 1
i32.const 4
ref.null any
i32.const 5
table.fill $table-any
)

;; CHECK: (func $table-copy (type $void)
;; CHECK-NEXT: (table.copy $timport$0 $timport$0
;; CHECK-NEXT: (i32.const 0)
;; CHECK-NEXT: (i32.const 1)
;; CHECK-NEXT: (i32.const 2)
;; CHECK-NEXT: )
;; CHECK-NEXT: (table.copy $funcs $funcs
;; CHECK-NEXT: (i32.const 3)
;; CHECK-NEXT: (i32.const 4)
;; CHECK-NEXT: (i32.const 5)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
(func $table-copy
i32.const 0
i32.const 1
i32.const 2
table.copy
i32.const 3
i32.const 4
i32.const 5
table.copy 1 $funcs
Copy link
Member

@kripken kripken Dec 12, 2023

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Is it possible for just one of the tables to be specified?

Copy link
Member Author

@tlively tlively Dec 12, 2023

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

No, it's both or neither.

)

;; CHECK: (func $i31-new (type $34) (param $0 i32) (result i31ref)
;; CHECK-NEXT: (ref.i31
;; CHECK-NEXT: (local.get $0)
Expand Down