Skip to content

Commit 94aecc2

Browse files
aheejinaheejin
authored
[wasm-split] Support table64 (#7904)
This makes wasm using table64 (included in memory64) can be used in wasm-split. To be strict we should use different data types than `Index`, which is `uint32_t`; for memory64 we use `Address` class to represent the address. But it is unlikely that table indices would ever go above `uint32_t` range, and we are not even sure if engines support that many. We can consider using `Address` for table indices, but the use of `Index` for table indices is currently not only limited to module-splitting utils, so I think we can cross that bridge when it becomes really necessary. Note that when creating a new table, we don't create it as an i64 table even if memory64 is enabled, because it is not necessary. We only deal with existing i64 tables. Fixes #7716.
1 parent 2369824 commit 94aecc2

3 files changed

Lines changed: 196 additions & 7 deletions

File tree

‎src/ir/module-splitting.cpp‎

Lines changed: 15 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -89,7 +89,7 @@ template<class F> void forEachElement(Module& module, F f) {
8989
Name base = "";
9090
Index offset = 0;
9191
if (auto* c = segment->offset->dynCast<Const>()) {
92-
offset = c->value.geti32();
92+
offset = c->value.getInteger();
9393
} else if (auto* g = segment->offset->dynCast<GlobalGet>()) {
9494
base = g->name;
9595
}
@@ -129,11 +129,15 @@ struct TableSlotManager {
129129

130130
Expression* TableSlotManager::Slot::makeExpr(Module& module) {
131131
Builder builder(module);
132-
auto makeIndex = [&]() { return builder.makeConst(int32_t(index)); };
132+
auto* table = module.getTable(tableName);
133+
auto makeIndex = [&]() {
134+
return builder.makeConst(Literal::makeFromInt32(index, table->addressType));
135+
};
133136
if (global.size()) {
134-
Expression* getBase = builder.makeGlobalGet(global, Type::i32);
137+
Expression* getBase = builder.makeGlobalGet(global, table->addressType);
138+
auto addOp = table->is64() ? AddInt64 : AddInt32;
135139
return index == 0 ? getBase
136-
: builder.makeBinary(AddInt32, getBase, makeIndex());
140+
: builder.makeBinary(addOp, getBase, makeIndex());
137141
} else {
138142
return makeIndex();
139143
}
@@ -209,7 +213,7 @@ TableSlotManager::TableSlotManager(Module& module) : module(module) {
209213
for (auto& segment : activeTableSegments) {
210214
assert(segment->offset->is<Const>() &&
211215
"Unexpected non-const segment offset with multiple segments");
212-
Index segmentBase = segment->offset->cast<Const>()->value.geti32();
216+
Index segmentBase = segment->offset->cast<Const>()->value.getInteger();
213217
if (segmentBase + segment->data.size() >= maxIndex) {
214218
maxIndex = segmentBase + segment->data.size();
215219
activeSegment = segment;
@@ -233,10 +237,13 @@ Table* TableSlotManager::makeTable() {
233237
}
234238

235239
ElementSegment* TableSlotManager::makeElementSegment() {
240+
Builder builder(module);
241+
Expression* offset =
242+
builder.makeConst(Literal::makeFromInt32(0, activeTable->addressType));
236243
return module.addElementSegment(Builder::makeElementSegment(
237244
Names::getValidElementSegmentName(module, Name::fromInt(0)),
238245
activeTable->name,
239-
Builder(module).makeConst(int32_t(0))));
246+
offset));
240247
}
241248

242249
TableSlotManager::Slot TableSlotManager::getSlot(Name func, HeapType type) {
@@ -801,7 +808,8 @@ void ModuleSplitter::setupTablePatching() {
801808
Index currBase = replacedElems.begin()->first;
802809
std::vector<Expression*> currData;
803810
auto finishSegment = [&]() {
804-
auto* offset = Builder(secondary).makeConst(int32_t(currBase));
811+
auto* offset = Builder(secondary).makeConst(
812+
Literal::makeFromInt32(currBase, secondaryTable->addressType));
805813
auto secondarySeg = std::make_unique<ElementSegment>(
806814
secondaryTable->name, offset, secondaryTable->type, currData);
807815
Name name = Names::getValidElementSegmentName(

‎test/lit/wasm-split/table64-const-offset.wast‎

Lines changed: 86 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,86 @@
1+
;; When reference types is disabled, we reuse the existing i64 table
2+
;; RUN: wasm-split %s -g -o1 %t.1.wasm -o2 %t.2.wasm --export-prefix='%' --keep-funcs=foo --enable-memory64 -v 2>&1 | filecheck %s --check-prefix CHECK
3+
;; RUN: wasm-dis %t.1.wasm | filecheck %s --check-prefix PRIMARY-NOREF
4+
;; RUN: wasm-dis %t.2.wasm | filecheck %s --check-prefix SECONDARY-NOREF
5+
;; Check whether the split files conform to memory64
6+
;; RUN: wasm-opt --enable-memory64 %t.1.wasm
7+
;; RUN: wasm-opt --enable-memory64 %t.2.wasm
8+
9+
;; When reference types is enabled, we create a new table
10+
;; RUN: wasm-split %s -g -o1 %t.1.wasm -o2 %t.2.wasm --export-prefix='%' --keep-funcs=foo --enable-memory64 --enable-reference-types -v 2>&1 | filecheck %s --check-prefix CHECK
11+
;; RUN: wasm-dis %t.1.wasm | filecheck %s --check-prefix PRIMARY-REF
12+
;; RUN: wasm-dis %t.2.wasm | filecheck %s --check-prefix SECONDARY-REF
13+
;; Check whether the split files conform to memory64
14+
;; RUN: wasm-opt --enable-memory64 --enable-reference-types %t.1.wasm
15+
;; RUN: wasm-opt --enable-memory64 --enable-reference-types %t.2.wasm
16+
17+
;; CHECK: Keeping functions: foo{{$}}
18+
;; CHECK: Splitting out functions: bar{{$}}
19+
20+
;; PRIMARY-NOREF: (module
21+
;; PRIMARY-NOREF-NEXT: (type $0 (func (param i32) (result i32)))
22+
;; PRIMARY-NOREF-NEXT: (import "placeholder" "1" (func $placeholder_1 (param i32) (result i32)))
23+
;; PRIMARY-NOREF-NEXT: (table $table i64 2 2 funcref)
24+
;; PRIMARY-NOREF-NEXT: (elem $0 (i64.const 0) $foo $placeholder_1)
25+
;; PRIMARY-NOREF-NEXT: (export "%foo" (func $foo))
26+
;; PRIMARY-NOREF-NEXT: (export "%table" (table $table))
27+
;; PRIMARY-NOREF-NEXT: (func $foo (param $0 i32) (result i32)
28+
;; PRIMARY-NOREF-NEXT: (call_indirect (type $0)
29+
;; PRIMARY-NOREF-NEXT: (i32.const 0)
30+
;; PRIMARY-NOREF-NEXT: (i64.const 1)
31+
;; PRIMARY-NOREF-NEXT: )
32+
;; PRIMARY-NOREF-NEXT: )
33+
;; PRIMARY-NOREF-NEXT: )
34+
35+
;; SECONDARY-NOREF: (module
36+
;; SECONDARY-NOREF-NEXT: (type $0 (func (param i32) (result i32)))
37+
;; SECONDARY-NOREF-NEXT: (import "primary" "%table" (table $table i64 2 2 funcref))
38+
;; SECONDARY-NOREF-NEXT: (import "primary" "%foo" (func $foo (param i32) (result i32)))
39+
;; SECONDARY-NOREF-NEXT: (elem $0 (i64.const 1) $bar)
40+
;; SECONDARY-NOREF-NEXT: (func $bar (param $0 i32) (result i32)
41+
;; SECONDARY-NOREF-NEXT: (call $foo
42+
;; SECONDARY-NOREF-NEXT: (i32.const 1)
43+
;; SECONDARY-NOREF-NEXT: )
44+
;; SECONDARY-NOREF-NEXT: )
45+
;; SECONDARY-NOREF-NEXT: )
46+
47+
;; PRIMARY-REF: (module
48+
;; PRIMARY-REF-NEXT: (type $0 (func (param i32) (result i32)))
49+
;; PRIMARY-REF-NEXT: (import "placeholder" "0" (func $placeholder_0 (param i32) (result i32)))
50+
;; PRIMARY-REF-NEXT: (table $table i64 1 1 funcref)
51+
;; PRIMARY-REF-NEXT: (table $1 1 funcref)
52+
;; PRIMARY-REF-NEXT: (elem $0 (table $table) (i64.const 0) func $foo)
53+
;; PRIMARY-REF-NEXT: (elem $1 (table $1) (i32.const 0) func $placeholder_0)
54+
;; PRIMARY-REF-NEXT: (export "%foo" (func $foo))
55+
;; PRIMARY-REF-NEXT: (export "%table" (table $table))
56+
;; PRIMARY-REF-NEXT: (export "%table_2" (table $1))
57+
;; PRIMARY-REF-NEXT: (func $foo (param $0 i32) (result i32)
58+
;; PRIMARY-REF-NEXT: (call_indirect $1 (type $0)
59+
;; PRIMARY-REF-NEXT: (i32.const 0)
60+
;; PRIMARY-REF-NEXT: (i32.const 0)
61+
;; PRIMARY-REF-NEXT: )
62+
;; PRIMARY-REF-NEXT: )
63+
;; PRIMARY-REF-NEXT: )
64+
65+
;; SECONDARY-REF: (module
66+
;; SECONDARY-REF-NEXT: (type $0 (func (param i32) (result i32)))
67+
;; SECONDARY-REF-NEXT: (import "primary" "%table_2" (table $timport$0 1 funcref))
68+
;; SECONDARY-REF-NEXT: (import "primary" "%foo" (func $foo (param i32) (result i32)))
69+
;; SECONDARY-REF-NEXT: (elem $0 (i32.const 0) $bar)
70+
;; SECONDARY-REF-NEXT: (func $bar (param $0 i32) (result i32)
71+
;; SECONDARY-REF-NEXT: (call $foo
72+
;; SECONDARY-REF-NEXT: (i32.const 1)
73+
;; SECONDARY-REF-NEXT: )
74+
;; SECONDARY-REF-NEXT: )
75+
;; SECONDARY-REF-NEXT: )
76+
77+
(module
78+
(table $table i64 1 1 funcref)
79+
(elem (i64.const 0) $foo)
80+
(func $foo (param i32) (result i32)
81+
(call $bar (i32.const 0))
82+
)
83+
(func $bar (param i32) (result i32)
84+
(call $foo (i32.const 1))
85+
)
86+
)

‎test/lit/wasm-split/table64-global-offset.wast‎

Lines changed: 95 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,95 @@
1+
;; When reference types is disabled, we reuse the existing i64 table
2+
;; RUN: wasm-split %s -g -o1 %t.1.wasm -o2 %t.2.wasm --export-prefix='%' --keep-funcs=foo --enable-memory64 -v 2>&1 | filecheck %s --check-prefix CHECK
3+
;; RUN: wasm-dis %t.1.wasm | filecheck %s --check-prefix PRIMARY-NOREF
4+
;; RUN: wasm-dis %t.2.wasm | filecheck %s --check-prefix SECONDARY-NOREF
5+
;; Check whether the split files conform to memory64
6+
;; RUN: wasm-opt --enable-memory64 %t.1.wasm
7+
;; RUN: wasm-opt --enable-memory64 %t.2.wasm
8+
9+
;; When reference types is enabled, we create a new table
10+
;; RUN: wasm-split %s -g -o1 %t.1.wasm -o2 %t.2.wasm --export-prefix='%' --keep-funcs=foo --enable-memory64 --enable-reference-types -v 2>&1 | filecheck %s --check-prefix CHECK
11+
;; RUN: wasm-dis %t.1.wasm | filecheck %s --check-prefix PRIMARY-REF
12+
;; RUN: wasm-dis %t.2.wasm | filecheck %s --check-prefix SECONDARY-REF
13+
;; Check whether the split files conform to memory64
14+
;; RUN: wasm-opt --enable-memory64 --enable-reference-types %t.1.wasm
15+
;; RUN: wasm-opt --enable-memory64 --enable-reference-types %t.2.wasm
16+
17+
;; CHECK: Keeping functions: foo{{$}}
18+
;; CHECK: Splitting out functions: bar{{$}}
19+
20+
;; PRIMARY-NOREF: (module
21+
;; PRIMARY-NOREF-NEXT: (type $0 (func (param i32) (result i32)))
22+
;; PRIMARY-NOREF-NEXT: (import "env" "g" (global $g i64))
23+
;; PRIMARY-NOREF-NEXT: (import "placeholder" "1" (func $placeholder_1 (param i32) (result i32)))
24+
;; PRIMARY-NOREF-NEXT: (table $table i64 2 2 funcref)
25+
;; PRIMARY-NOREF-NEXT: (elem $0 (global.get $g) $foo $placeholder_1)
26+
;; PRIMARY-NOREF-NEXT: (export "%foo" (func $foo))
27+
;; PRIMARY-NOREF-NEXT: (export "%table" (table $table))
28+
;; PRIMARY-NOREF-NEXT: (export "%global" (global $g))
29+
;; PRIMARY-NOREF-NEXT: (func $foo (param $0 i32) (result i32)
30+
;; PRIMARY-NOREF-NEXT: (call_indirect (type $0)
31+
;; PRIMARY-NOREF-NEXT: (i32.const 0)
32+
;; PRIMARY-NOREF-NEXT: (i64.add
33+
;; PRIMARY-NOREF-NEXT: (global.get $g)
34+
;; PRIMARY-NOREF-NEXT: (i64.const 1)
35+
;; PRIMARY-NOREF-NEXT: )
36+
;; PRIMARY-NOREF-NEXT: )
37+
;; PRIMARY-NOREF-NEXT: )
38+
;; PRIMARY-NOREF-NEXT: )
39+
40+
;; SECONDARY-NOREF: (module
41+
;; SECONDARY-NOREF-NEXT: (type $0 (func (param i32) (result i32)))
42+
;; SECONDARY-NOREF-NEXT: (import "primary" "%table" (table $table i64 2 2 funcref))
43+
;; SECONDARY-NOREF-NEXT: (import "primary" "%global" (global $g i64))
44+
;; SECONDARY-NOREF-NEXT: (import "primary" "%foo" (func $foo (param i32) (result i32)))
45+
;; SECONDARY-NOREF-NEXT: (elem $0 (global.get $g) $foo $bar)
46+
;; SECONDARY-NOREF-NEXT: (func $bar (param $0 i32) (result i32)
47+
;; SECONDARY-NOREF-NEXT: (call $foo
48+
;; SECONDARY-NOREF-NEXT: (i32.const 1)
49+
;; SECONDARY-NOREF-NEXT: )
50+
;; SECONDARY-NOREF-NEXT: )
51+
;; SECONDARY-NOREF-NEXT: )
52+
53+
;; PRIMARY-REF: (module
54+
;; PRIMARY-REF-NEXT: (type $0 (func (param i32) (result i32)))
55+
;; PRIMARY-REF-NEXT: (import "env" "g" (global $g i64))
56+
;; PRIMARY-REF-NEXT: (import "placeholder" "0" (func $placeholder_0 (param i32) (result i32)))
57+
;; PRIMARY-REF-NEXT: (table $table i64 1 1 funcref)
58+
;; PRIMARY-REF-NEXT: (table $1 1 funcref)
59+
;; PRIMARY-REF-NEXT: (elem $0 (table $table) (global.get $g) func $foo)
60+
;; PRIMARY-REF-NEXT: (elem $1 (table $1) (i32.const 0) func $placeholder_0)
61+
;; PRIMARY-REF-NEXT: (export "%foo" (func $foo))
62+
;; PRIMARY-REF-NEXT: (export "%table" (table $table))
63+
;; PRIMARY-REF-NEXT: (export "%table_2" (table $1))
64+
;; PRIMARY-REF-NEXT: (export "%global" (global $g))
65+
;; PRIMARY-REF-NEXT: (func $foo (param $0 i32) (result i32)
66+
;; PRIMARY-REF-NEXT: (call_indirect $1 (type $0)
67+
;; PRIMARY-REF-NEXT: (i32.const 0)
68+
;; PRIMARY-REF-NEXT: (i32.const 0)
69+
;; PRIMARY-REF-NEXT: )
70+
;; PRIMARY-REF-NEXT: )
71+
;; PRIMARY-REF-NEXT: )
72+
73+
;; SECONDARY-REF: (module
74+
;; SECONDARY-REF-NEXT: (type $0 (func (param i32) (result i32)))
75+
;; SECONDARY-REF-NEXT: (import "primary" "%table_2" (table $timport$0 1 funcref))
76+
;; SECONDARY-REF-NEXT: (import "primary" "%foo" (func $foo (param i32) (result i32)))
77+
;; SECONDARY-REF-NEXT: (elem $0 (i32.const 0) $bar)
78+
;; SECONDARY-REF-NEXT: (func $bar (param $0 i32) (result i32)
79+
;; SECONDARY-REF-NEXT: (call $foo
80+
;; SECONDARY-REF-NEXT: (i32.const 1)
81+
;; SECONDARY-REF-NEXT: )
82+
;; SECONDARY-REF-NEXT: )
83+
;; SECONDARY-REF-NEXT: )
84+
85+
(module
86+
(global $g (import "env" "g") i64)
87+
(table $table i64 1 1 funcref)
88+
(elem (global.get $g) $foo)
89+
(func $foo (param i32) (result i32)
90+
(call $bar (i32.const 0))
91+
)
92+
(func $bar (param i32) (result i32)
93+
(call $foo (i32.const 1))
94+
)
95+
)

0 commit comments

Comments
 (0)