Skip to content

Commit e72969b

Browse files
stevenfontanellastevenfontanella
committed
done?
1 parent 2760fc2 commit e72969b

File tree

4 files changed

+165
-70
lines changed

4 files changed

+165
-70
lines changed

‎src/passes/GlobalEffects.cpp‎

Lines changed: 29 additions & 59 deletions
Original file line numberDiff line numberDiff line change
@@ -101,7 +101,7 @@ std::map<Function*, FuncInfo> analyzeFuncs(Module& module,
101101
} else if (auto* callIndirect = curr->dynCast<CallIndirect>()) {
102102
type = callIndirect->heapType;
103103
} else {
104-
assert(false && "Unexpected type of call");
104+
assert("Unexpected type of call");
105105
}
106106

107107
funcInfo.indirectCalledTypes.insert(type);
@@ -123,58 +123,34 @@ std::map<Function*, FuncInfo> analyzeFuncs(Module& module,
123123
return std::move(analysis.map);
124124
}
125125

126-
// Funcs that can be the target of a virtual call
127-
// These are either:
128-
// - Part of an (elem declare ...) or (elem ...) directive
129-
// - Exported, since they may flow back to us from the host
130-
std::unordered_set<Name> getFuncsWithAddress(Module& module) {
131-
std::unordered_set<Name> funcsWithAddress;
132-
for (const auto& fun : module.functions) {
133-
funcsWithAddress.insert(fun->name);
134-
}
135-
return funcsWithAddress;
136-
137-
// {
138-
// auto refFuncs = TableUtils::getFunctionsNeedingElemDeclare(module);
139-
// funcsWithAddress.insert(refFuncs.begin(), refFuncs.end());
140-
// }
141-
142-
// ElementUtils::iterAllElementFunctionNames(
143-
// &module,
144-
// [&funcsWithAddress](Name name) { funcsWithAddress.insert(name); });
145-
// for (const auto& export_ : module.exports) {
146-
// if (export_->kind == ExternalKind::Function) {
147-
// // This exported function might flow back to us even in a closed world,
148-
// // so it's essentially addressed.
149-
// funcsWithAddress.insert(export_->name);
150-
// }
151-
// }
152-
153-
// return funcsWithAddress;
154-
}
155-
156126
using CallGraphNode = std::variant<Name, HeapType>;
157127

158128
// Build a call graph for indirect and direct calls.
159129
// key (callee) -> value (caller)
160130
// Name -> Name : callee is called directly by caller
161-
// Name -> HeapType : callee is a potential target of a virtual call with this HeapType
162-
// HeapType -> Name : callee is indirectly called by caller
163-
// HeapType -> HeapType : callee is a subtype of caller
164-
165-
// TODO: only track indirect calls in closed world
166-
std::unordered_map<CallGraphNode, std::unordered_set<CallGraphNode>> buildReverseCallGraph(Module& module, const std::map<Function*, FuncInfo> funcInfos) {
131+
// Name -> HeapType : callee is a potential target of a virtual call
132+
// with this HeapType HeapType -> Name : callee is indirectly called by
133+
// caller HeapType -> HeapType : callee is a subtype of caller If we're
134+
// running in an open world, we only include Name -> Name edges.
135+
std::unordered_map<CallGraphNode, std::unordered_set<CallGraphNode>>
136+
buildReverseCallGraph(Module& module,
137+
const std::map<Function*, FuncInfo> funcInfos,
138+
bool closedWorld) {
167139
// callee : caller
168-
std::unordered_map<CallGraphNode, std::unordered_set<CallGraphNode>>
169-
callers;
140+
std::unordered_map<CallGraphNode, std::unordered_set<CallGraphNode>> callers;
170141

171-
std::unordered_set<HeapType> allIndirectCalledTypes;
142+
if (!closedWorld) {
143+
for (const auto& [func, info] : funcInfos) {
144+
// Name -> Name for direct calls
145+
for (const auto& callee : info.calledFunctions) {
146+
callers[callee].insert(func->name);
147+
}
148+
}
172149

173-
// Funcs that can be the target of a virtual call
174-
// These are either:
175-
// - Part of an (elem declare ...) or (elem ...) directive
176-
// - Exported, since they may flow back to us from the host
177-
std::unordered_set<Name> funcsWithAddress = getFuncsWithAddress(module);
150+
return callers;
151+
}
152+
153+
std::unordered_set<HeapType> allIndirectCalledTypes;
178154

179155
for (const auto& [func, info] : funcInfos) {
180156
// Name -> Name for direct calls
@@ -188,9 +164,9 @@ std::unordered_map<CallGraphNode, std::unordered_set<CallGraphNode>> buildRevers
188164
}
189165

190166
// Name -> HeapType for function types
191-
if (funcsWithAddress.contains(func->name)) {
192-
callers[func->name].insert(func->type.getHeapType());
193-
}
167+
// TODO: only look at functions that are addressable
168+
// i.e. appear in a (ref.func) or are exported
169+
callers[func->name].insert(func->type.getHeapType());
194170

195171
allIndirectCalledTypes.insert(func->type.getHeapType());
196172
}
@@ -228,7 +204,8 @@ void propagateEffects(
228204
}
229205
}
230206

231-
auto propagate = [&](const CallGraphNode& calleeNode, const CallGraphNode& callerNode) {
207+
auto propagate = [&](const CallGraphNode& calleeNode,
208+
const CallGraphNode& callerNode) {
232209
if (!std::get_if<Name>(&calleeNode) || !std::get_if<Name>(&callerNode)) {
233210
return;
234211
}
@@ -276,6 +253,7 @@ void propagateEffects(
276253
continue;
277254
}
278255

256+
// TODO: handle exact refs here
279257
for (const CallGraphNode& callerCaller : callerCallers->second) {
280258
work.push(std::pair(callee, callerCaller));
281259
}
@@ -289,16 +267,8 @@ struct GenerateGlobalEffects : public Pass {
289267

290268
// callee : caller
291269
std::unordered_map<CallGraphNode, std::unordered_set<CallGraphNode>>
292-
callers = buildReverseCallGraph(*module, funcInfos);
293-
294-
// for (const auto& [callee, callers] : callers) {
295-
// for (const auto& caller : callers) {
296-
// const auto* calleeName = std::get_if<Name>(&callee);
297-
// const auto* callerName = std::get_if<Name>(&caller);
298-
// if (!calleeName || !callerName) continue;
299-
// std::cout<<*calleeName<<"\t\t->\t\t"<<*callerName<<"\n";
300-
// }
301-
// }
270+
callers =
271+
buildReverseCallGraph(*module, funcInfos, getPassOptions().closedWorld);
302272

303273
propagateEffects(*module, callers, funcInfos);
304274

‎test/lit/passes/global-effects-closed-world.wast‎

Lines changed: 61 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -155,6 +155,56 @@
155155
)
156156
)
157157

158+
;; Same as above but this time our reference is the exact supertype
159+
;; So we know not to aggregate effects from the subtype.
160+
;; TODO: this case doesn't optimize today. Add exact ref support in the pass.
161+
(module
162+
;; CHECK: (type $super (sub (struct)))
163+
(type $super (sub (struct)))
164+
;; CHECK: (type $sub (sub $super (struct)))
165+
(type $sub (sub $super (struct)))
166+
167+
;; Supertype
168+
;; CHECK: (type $func-with-sub-param (sub (func (param (ref $sub)))))
169+
(type $func-with-sub-param (sub (func (param (ref $sub)))))
170+
;; Subtype
171+
;; CHECK: (type $func-with-super-param (sub $func-with-sub-param (func (param (ref $super)))))
172+
(type $func-with-super-param (sub $func-with-sub-param (func (param (ref $super)))))
173+
174+
;; CHECK: (func $nop-with-supertype (type $func-with-sub-param) (param $0 (ref $sub))
175+
;; CHECK-NEXT: (nop)
176+
;; CHECK-NEXT: )
177+
(func $nop-with-supertype (export "nop-with-supertype") (type $func-with-sub-param) (param (ref $sub))
178+
)
179+
180+
;; CHECK: (func $effectful-with-subtype (type $func-with-super-param) (param $0 (ref $super))
181+
;; CHECK-NEXT: (unreachable)
182+
;; CHECK-NEXT: )
183+
(func $effectful-with-subtype (export "effectful-with-subtype") (type $func-with-super-param) (param (ref $super))
184+
(unreachable)
185+
)
186+
187+
;; CHECK: (func $calls-ref-with-subtype (type $3) (param $func (ref (exact $func-with-sub-param))) (param $sub (ref $sub))
188+
;; CHECK-NEXT: (call_ref $func-with-sub-param
189+
;; CHECK-NEXT: (local.get $sub)
190+
;; CHECK-NEXT: (local.get $func)
191+
;; CHECK-NEXT: )
192+
;; CHECK-NEXT: )
193+
(func $calls-ref-with-subtype (param $func (ref (exact $func-with-sub-param))) (param $sub (ref $sub))
194+
(call_ref $func-with-sub-param (local.get $sub) (local.get $func))
195+
)
196+
197+
;; CHECK: (func $f (type $3) (param $func (ref (exact $func-with-sub-param))) (param $sub (ref $sub))
198+
;; CHECK-NEXT: (call $calls-ref-with-subtype
199+
;; CHECK-NEXT: (local.get $func)
200+
;; CHECK-NEXT: (local.get $sub)
201+
;; CHECK-NEXT: )
202+
;; CHECK-NEXT: )
203+
(func $f (param $func (ref (exact $func-with-sub-param))) (param $sub (ref $sub))
204+
(call $calls-ref-with-subtype (local.get $func) (local.get $sub))
205+
)
206+
)
207+
158208
(module
159209
;; CHECK: (type $only-has-effects-in-not-addressable-function (func (param i32)))
160210
(type $only-has-effects-in-not-addressable-function (func (param i32)))
@@ -183,9 +233,15 @@
183233
)
184234

185235
;; CHECK: (func $f (type $1) (param $ref (ref $only-has-effects-in-not-addressable-function))
186-
;; CHECK-NEXT: (nop)
236+
;; CHECK-NEXT: (call $calls-type-with-effects-but-not-addressable
237+
;; CHECK-NEXT: (local.get $ref)
238+
;; CHECK-NEXT: )
187239
;; CHECK-NEXT: )
188240
(func $f (param $ref (ref $only-has-effects-in-not-addressable-function))
241+
;; The type $has-effects-but-not-exported doesn't have an address because
242+
;; it's not exported and it's never the target of a ref.func.
243+
;; We should be able to determine that $ref can only point to $nop
244+
;; TODO: Only aggregate effects from functions that are addressed.
189245
(call $calls-type-with-effects-but-not-addressable (local.get $ref))
190246
)
191247
)
@@ -255,7 +311,9 @@
255311
)
256312

257313
;; CHECK: (func $f (type $1) (param $ref (ref $t))
258-
;; CHECK-NEXT: (nop)
314+
;; CHECK-NEXT: (call $indirect-calls
315+
;; CHECK-NEXT: (local.get $ref)
316+
;; CHECK-NEXT: )
259317
;; CHECK-NEXT: )
260318
(func $f (param $ref (ref $t))
261319
;; $indirect-calls might end up calling an imported function,
@@ -264,5 +322,5 @@
264322
)
265323
)
266324

267-
;; TODO exact types
325+
268326
;; TODO functions that are referenced other ways besides exporting

‎test/lit/passes/global-effects-eh-legacy.wast‎

Lines changed: 16 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -327,6 +327,22 @@
327327
;; WITHOUT-NEXT: (call $return-call-ref-throw-and-catch)
328328
;; WITHOUT-NEXT: )
329329
;; INCLUDE: (func $call-return-call-throw-and-catch (type $void)
330+
;; INCLUDE-NEXT: (try
331+
;; INCLUDE-NEXT: (do
332+
;; INCLUDE-NEXT: (call $return-call-indirect-throw-and-catch)
333+
;; INCLUDE-NEXT: )
334+
;; INCLUDE-NEXT: (catch_all
335+
;; INCLUDE-NEXT: (nop)
336+
;; INCLUDE-NEXT: )
337+
;; INCLUDE-NEXT: )
338+
;; INCLUDE-NEXT: (try
339+
;; INCLUDE-NEXT: (do
340+
;; INCLUDE-NEXT: (call $return-call-ref-throw-and-catch)
341+
;; INCLUDE-NEXT: )
342+
;; INCLUDE-NEXT: (catch_all
343+
;; INCLUDE-NEXT: (nop)
344+
;; INCLUDE-NEXT: )
345+
;; INCLUDE-NEXT: )
330346
;; INCLUDE-NEXT: (call $return-call-throw-and-catch)
331347
;; INCLUDE-NEXT: (call $return-call-indirect-throw-and-catch)
332348
;; INCLUDE-NEXT: (call $return-call-ref-throw-and-catch)

‎test/lit/passes/global-effects.wast‎

Lines changed: 59 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -13,14 +13,23 @@
1313
;; INCLUDE: (type $void (func))
1414
(type $void (func))
1515

16-
;; WITHOUT: (type $1 (func (result i32)))
16+
;; WITHOUT: (type $indirect-type (func (param f32)))
17+
;; INCLUDE: (type $indirect-type (func (param f32)))
18+
(type $indirect-type (func (param f32)))
1719

18-
;; WITHOUT: (type $2 (func (param i32)))
20+
21+
;; WITHOUT: (type $2 (func (param (ref $indirect-type))))
22+
23+
;; WITHOUT: (type $3 (func (result i32)))
24+
25+
;; WITHOUT: (type $4 (func (param i32)))
1926

2027
;; WITHOUT: (import "a" "b" (func $import (type $void)))
21-
;; INCLUDE: (type $1 (func (result i32)))
28+
;; INCLUDE: (type $2 (func (param (ref $indirect-type))))
2229

23-
;; INCLUDE: (type $2 (func (param i32)))
30+
;; INCLUDE: (type $3 (func (result i32)))
31+
32+
;; INCLUDE: (type $4 (func (param i32)))
2433

2534
;; INCLUDE: (import "a" "b" (func $import (type $void)))
2635
(import "a" "b" (func $import))
@@ -150,7 +159,7 @@
150159
(call $unreachable)
151160
)
152161

153-
;; WITHOUT: (func $unimportant-effects (type $1) (result i32)
162+
;; WITHOUT: (func $unimportant-effects (type $3) (result i32)
154163
;; WITHOUT-NEXT: (local $x i32)
155164
;; WITHOUT-NEXT: (local.set $x
156165
;; WITHOUT-NEXT: (i32.const 100)
@@ -159,7 +168,7 @@
159168
;; WITHOUT-NEXT: (local.get $x)
160169
;; WITHOUT-NEXT: )
161170
;; WITHOUT-NEXT: )
162-
;; INCLUDE: (func $unimportant-effects (type $1) (result i32)
171+
;; INCLUDE: (func $unimportant-effects (type $3) (result i32)
163172
;; INCLUDE-NEXT: (local $x i32)
164173
;; INCLUDE-NEXT: (local.set $x
165174
;; INCLUDE-NEXT: (i32.const 100)
@@ -380,7 +389,7 @@
380389
)
381390
)
382391

383-
;; WITHOUT: (func $call-throw-or-unreachable-and-catch (type $2) (param $x i32)
392+
;; WITHOUT: (func $call-throw-or-unreachable-and-catch (type $4) (param $x i32)
384393
;; WITHOUT-NEXT: (block $tryend
385394
;; WITHOUT-NEXT: (try_table (catch_all $tryend)
386395
;; WITHOUT-NEXT: (if
@@ -395,7 +404,7 @@
395404
;; WITHOUT-NEXT: )
396405
;; WITHOUT-NEXT: )
397406
;; WITHOUT-NEXT: )
398-
;; INCLUDE: (func $call-throw-or-unreachable-and-catch (type $2) (param $x i32)
407+
;; INCLUDE: (func $call-throw-or-unreachable-and-catch (type $4) (param $x i32)
399408
;; INCLUDE-NEXT: (block $tryend
400409
;; INCLUDE-NEXT: (try_table (catch_all $tryend)
401410
;; INCLUDE-NEXT: (if
@@ -473,4 +482,46 @@
473482
(call $cycle-with-unknown-call)
474483
(call $import)
475484
)
485+
486+
;; WITHOUT: (func $nop-indirect (type $indirect-type) (param $0 f32)
487+
;; WITHOUT-NEXT: (nop)
488+
;; WITHOUT-NEXT: )
489+
;; INCLUDE: (func $nop-indirect (type $indirect-type) (param $0 f32)
490+
;; INCLUDE-NEXT: (nop)
491+
;; INCLUDE-NEXT: )
492+
(func $nop-indirect (type $indirect-type) (param f32)
493+
)
494+
495+
;; WITHOUT: (func $unknown-indirect-call (type $2) (param $ref (ref $indirect-type))
496+
;; WITHOUT-NEXT: (call_ref $indirect-type
497+
;; WITHOUT-NEXT: (f32.const 1)
498+
;; WITHOUT-NEXT: (local.get $ref)
499+
;; WITHOUT-NEXT: )
500+
;; WITHOUT-NEXT: )
501+
;; INCLUDE: (func $unknown-indirect-call (type $2) (param $ref (ref $indirect-type))
502+
;; INCLUDE-NEXT: (call_ref $indirect-type
503+
;; INCLUDE-NEXT: (f32.const 1)
504+
;; INCLUDE-NEXT: (local.get $ref)
505+
;; INCLUDE-NEXT: )
506+
;; INCLUDE-NEXT: )
507+
(func $unknown-indirect-call (param $ref (ref $indirect-type))
508+
(call_ref $indirect-type (f32.const 1) (local.get $ref))
509+
)
510+
511+
;; WITHOUT: (func $calls-unknown-indirect-call (type $2) (param $ref (ref $indirect-type))
512+
;; WITHOUT-NEXT: (call $unknown-indirect-call
513+
;; WITHOUT-NEXT: (local.get $ref)
514+
;; WITHOUT-NEXT: )
515+
;; WITHOUT-NEXT: )
516+
;; INCLUDE: (func $calls-unknown-indirect-call (type $2) (param $ref (ref $indirect-type))
517+
;; INCLUDE-NEXT: (call $unknown-indirect-call
518+
;; INCLUDE-NEXT: (local.get $ref)
519+
;; INCLUDE-NEXT: )
520+
;; INCLUDE-NEXT: )
521+
(func $calls-unknown-indirect-call (param $ref (ref $indirect-type))
522+
;; In a closed world, we could determine that the ref can only possibly be
523+
;; $nop-direct and optimize it out. See global-effects-closed-world.wast
524+
;; for related tests.
525+
(call $unknown-indirect-call (local.get $ref))
526+
)
476527
)

0 commit comments

Comments
 (0)