Skip to content

Account for unaddressed funcs in GlobalEffects #8644

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
stevenfontanella merged 21 commits into from
Jun 2, 2026
+328 −22
Merged

Account for unaddressed funcs in GlobalEffects #8644

Show file tree
Hide file tree
Changes from 18 commits
Commits
Show all changes
21 commits
Select commit Hold shift + click to select a range
dc53f95
LinearExecutionWalker indirect call effects
stevenfontanella May 20, 2026
3cda588
PR updates
stevenfontanella May 21, 2026
b1af020
Fix handling for throw effect with call_ref to (unreachable)
stevenfontanella May 22, 2026
4bc9ee9
Remove extra newline
stevenfontanella May 22, 2026
703dcdd
Account for addressed funcs
stevenfontanella Apr 19, 2026
bafa5f6
PR updates
stevenfontanella Apr 20, 2026
7e39398
Fix comment
stevenfontanella Apr 23, 2026
058a10c
PR updates
stevenfontanella May 6, 2026
d746b6b
WIP test updates
stevenfontanella May 20, 2026
73a7e87
Merge
stevenfontanella May 27, 2026
0af5402
Updates
stevenfontanella May 27, 2026
c88fe17
Fix test
stevenfontanella May 27, 2026
2d637dd
Updates
stevenfontanella May 27, 2026
83bb32e
Merge
stevenfontanella May 27, 2026
d3f907e
Small change
stevenfontanella May 27, 2026
7406ec2
Remove unneeded include
stevenfontanella May 27, 2026
8da03f7
PR updates
stevenfontanella May 29, 2026
0b04bf9
Add template param to resolve CTAD warning
stevenfontanella May 29, 2026
9063fe3
Merge sets on main thread
stevenfontanella May 29, 2026
5f89583
Fix some test comments
stevenfontanella May 29, 2026
d7fbc6e
Prepopulate map to avoid serialization across threads
stevenfontanella Jun 1, 2026
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
78 changes: 70 additions & 8 deletions src/passes/GlobalEffects.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -44,14 +44,71 @@ struct FuncInfo {
std::unordered_set<HeapType> indirectCalledTypes;
};

// Only funcs that are referenced may be the target of an indirect call. A
// function is referenced if:
// - It appears in a ref.func expression (this includes `elem` statements
// because of how our IR is represented).
// - It's exported, because it may flow back to us as a reference.
//
// If a function doesn't meet any of these criteria, it can't be the target of
// an indirect call and we don't need to include its effects in indirect calls.
std::unordered_set<Function*> getReferencedFuncs(Module& module,
PassRunner& passRunner) {
struct AddressedFuncsWalker : WalkerPass<PostWalker<AddressedFuncsWalker>> {
std::mutex& m;
// Guarded by `m`.
std::unordered_set<Function*>& allReferencedFuncs;

std::unordered_set<Function*> referencedFuncs;

AddressedFuncsWalker(std::mutex& m,
std::unordered_set<Function*>& allReferencedFuncs)
: m(m), allReferencedFuncs(allReferencedFuncs) {}

std::unique_ptr<Pass> create() override {
return std::make_unique<AddressedFuncsWalker>(m, allReferencedFuncs);
}

~AddressedFuncsWalker() override {
std::lock_guard<std::mutex> _(m);
allReferencedFuncs.merge(referencedFuncs);
}
Comment thread
stevenfontanella marked this conversation as resolved.
Outdated

bool isFunctionParallel() override { return true; }

void visitRefFunc(RefFunc* refFunc) {
referencedFuncs.insert(getModule()->getFunction(refFunc->func));
}
};

std::unordered_set<Function*> referencedFuncs;
std::mutex m;
AddressedFuncsWalker walker(m, referencedFuncs);
walker.run(&passRunner, &module);
walker.runOnModuleCode(&passRunner, &module);

for (const auto& export_ : module.exports) {
if (export_->kind != ExternalKind::Function) {
continue;
}

referencedFuncs.insert(module.getFunction(*export_->getInternalName()));
}

return referencedFuncs;
}

std::map<Function*, FuncInfo> analyzeFuncs(Module& module,
const PassOptions& passOptions) {
ModuleUtils::ParallelFunctionAnalysis<FuncInfo> analysis(
module, [&](Function* func, FuncInfo& funcInfo) {
if (func->imported()) {
// Imports can do anything, so we need to assume the worst anyhow,
// which is the same as not specifying any effects for them in the
// map (which we do by not setting funcInfo.effects).
// Imports can do almost anything, so we need to assume the worst
// anyhow, which is the same as not specifying any effects for them in
// the map (which we do by not setting funcInfo.effects).
//
// TODO: We can be more precise here since imports can't mutate
// globals/tables/memories that aren't imported or exported.
return;
}

Expand Down Expand Up @@ -144,6 +201,7 @@ using CallGraph =

CallGraph buildCallGraph(const Module& module,
const std::map<Function*, FuncInfo>& funcInfos,
const std::unordered_set<Function*>& referencedFuncs,
WorldMode worldMode) {
CallGraph callGraph;
if (worldMode == WorldMode::Open) {
Expand Down Expand Up @@ -179,16 +237,18 @@ CallGraph buildCallGraph(const Module& module,
}

// Type -> Function
callGraph[caller->type.getHeapType()].insert(caller);
if (referencedFuncs.contains(caller)) {
callGraph[caller->type.getHeapType()].insert(caller);
}
}

// Type -> Type
// Do a DFS up the type heirarchy for all function implementations.
// Do a DFS up the type hierarchy for all function implementations.
// We are essentially walking up each supertype chain and adding edges from
// super -> subtype, but doing it via DFS to avoid repeated work.
Graph superTypeGraph(allFunctionTypes.begin(),
allFunctionTypes.end(),
[&callGraph](auto&& push, HeapType t) {
[&callGraph](const auto& push, HeapType t) {
// Not needed except that during lookup we expect the
// key to exist.
callGraph[t];
Expand Down Expand Up @@ -350,8 +410,10 @@ struct GenerateGlobalEffects : public Pass {
std::map<Function*, FuncInfo> funcInfos =
analyzeFuncs(*module, getPassOptions());

auto callGraph =
buildCallGraph(*module, funcInfos, getPassOptions().worldMode);
auto referencedFuncs = getReferencedFuncs(*module, *getPassRunner());

auto callGraph = buildCallGraph(
*module, funcInfos, referencedFuncs, getPassOptions().worldMode);

propagateEffects(*module,
getPassOptions(),
Expand Down
241 changes: 239 additions & 2 deletions test/lit/passes/global-effects-closed-world-simplify-locals.wast
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -4,6 +4,8 @@
;; Tests for aggregating effects from indirect calls in GlobalEffects when
;; --closed-world is true. Continued from global-effects-closed-world.wast.

;; Test that effects are aggregated from both $indirect-type-super and
;; $indirect-type-sub for indirect calls to $indirect-type-super.
(module
;; CHECK: (type $indirect-type-super (sub (func (param i32))))
(type $indirect-type-super (sub (func (param i32))))
Expand All @@ -13,6 +15,8 @@

;; CHECK: (type $2 (func (param (ref $indirect-type-super))))

;; CHECK: (type $3 (func (param (ref $indirect-type-sub))))

;; CHECK: (global $g1 (mut i32) (i32.const 0))
(global $g1 (mut i32) (i32.const 0))
;; CHECK: (global $g2 (mut i32) (i32.const 0))
Expand Down Expand Up @@ -42,7 +46,7 @@
(global.set $g2 (local.get $i32))
)

;; CHECK: (func $merges-multiple-effects (type $2) (param $ref (ref $indirect-type-super))
;; CHECK: (func $merges-effects-from-super-and-sub (type $2) (param $ref (ref $indirect-type-super))
;; CHECK-NEXT: (local $x i32)
;; CHECK-NEXT: (local $y i32)
;; CHECK-NEXT: (local $z i32)
Expand All @@ -67,7 +71,7 @@
;; CHECK-NEXT: (global.get $g3)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
(func $merges-multiple-effects (param $ref (ref $indirect-type-super))
(func $merges-effects-from-super-and-sub (param $ref (ref $indirect-type-super))
(local $x i32)
(local $y i32)
(local $z i32)
Expand All @@ -85,4 +89,237 @@
(drop (local.get $y))
(drop (local.get $z))
)

;; CHECK: (func $merges-effects-from-sub-only (type $3) (param $ref (ref $indirect-type-sub))
;; CHECK-NEXT: (local $x i32)
;; CHECK-NEXT: (local $y i32)
;; CHECK-NEXT: (local $z i32)
;; CHECK-NEXT: (nop)
;; CHECK-NEXT: (local.set $y
;; CHECK-NEXT: (global.get $g2)
;; CHECK-NEXT: )
;; CHECK-NEXT: (nop)
;; CHECK-NEXT: (call_ref $indirect-type-sub
;; CHECK-NEXT: (i32.const 1)
;; CHECK-NEXT: (local.get $ref)
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (global.get $g1)
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (local.get $y)
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (global.get $g3)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
(func $merges-effects-from-sub-only (param $ref (ref $indirect-type-sub))
(local $x i32)
(local $y i32)
(local $z i32)

(local.set $x (global.get $g1))
(local.set $y (global.get $g2))
(local.set $z (global.get $g3))

;; Similar to above but here it's impossible to reach $impl1
;; (the supertype), so $x can safely be optimized out.
(call_ref $indirect-type-sub (i32.const 1) (local.get $ref))

(drop (local.get $x))
(drop (local.get $y))
(drop (local.get $z))
)
)

;; Test different ways of referencing functions to ensure that they're included
;; in indirect effects analysis. A function is considered 'addressed' if it's:
;; - imported (tested in the next test)
;; - exported
;; - referenced in a ref.func
;; - contained in an `elem` segment
;; Imported functions are tested in the next module to avoid
;; confounding this test because imports are assumed to have all possible
;; effects.
(module
;; CHECK: (type $indirect-type (func (param i32)))
(type $indirect-type (func (param i32)))

;; CHECK: (type $1 (func))

;; CHECK: (type $2 (func (param (ref $indirect-type))))

;; CHECK: (global $g1 (mut i32) (i32.const 0))
(global $g1 (mut i32) (i32.const 0))
;; CHECK: (global $g2 (mut i32) (i32.const 0))
(global $g2 (mut i32) (i32.const 0))
;; CHECK: (global $g3 (mut i32) (i32.const 0))
(global $g3 (mut i32) (i32.const 0))
;; CHECK: (global $g4 (mut i32) (i32.const 0))
(global $g4 (mut i32) (i32.const 0))

(table 1 1 funcref)

;; CHECK: (table $0 1 1 funcref)

;; CHECK: (elem $0 (i32.const 0) $f3)

;; CHECK: (elem declare func $f2)

;; CHECK: (export "f1" (func $f1))

;; CHECK: (func $f1 (type $indirect-type) (param $i32 i32)
;; CHECK-NEXT: (global.set $g1
;; CHECK-NEXT: (local.get $i32)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
(func $f1 (export "f1") (type $indirect-type) (param $i32 i32)
(global.set $g1 (local.get $i32))
)

;; CHECK: (func $f2 (type $indirect-type) (param $i32 i32)
;; CHECK-NEXT: (global.set $g2
;; CHECK-NEXT: (local.get $i32)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
(func $f2 (type $indirect-type) (param $i32 i32)
(global.set $g2 (local.get $i32))
)
;; CHECK: (func $reference-f2 (type $1)
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (ref.func $f2)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
(func $reference-f2
(drop (ref.func $f2))
)

;; CHECK: (func $f3 (type $indirect-type) (param $i32 i32)
;; CHECK-NEXT: (global.set $g3
;; CHECK-NEXT: (local.get $i32)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
(func $f3 (type $indirect-type) (param $i32 i32)
(global.set $g3 (local.get $i32))
)
(elem (i32.const 0) $f3)

;; CHECK: (func $merges-multiple-effects (type $2) (param $ref (ref $indirect-type))
;; CHECK-NEXT: (local $l1 i32)
;; CHECK-NEXT: (local $l2 i32)
;; CHECK-NEXT: (local $l3 i32)
;; CHECK-NEXT: (local $l4 i32)
;; CHECK-NEXT: (local.set $l1
;; CHECK-NEXT: (global.get $g1)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.set $l2
;; CHECK-NEXT: (global.get $g2)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.set $l3
;; CHECK-NEXT: (global.get $g3)
;; CHECK-NEXT: )
;; CHECK-NEXT: (nop)
;; CHECK-NEXT: (call_ref $indirect-type
;; CHECK-NEXT: (i32.const 1)
;; CHECK-NEXT: (local.get $ref)
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (local.get $l1)
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (local.get $l2)
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (local.get $l3)
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (global.get $g4)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
(func $merges-multiple-effects (param $ref (ref $indirect-type))
(local $l1 i32)
(local $l2 i32)
(local $l3 i32)
(local $l4 i32)

(local.set $l1 (global.get $g1))
(local.set $l2 (global.get $g2))
(local.set $l3 (global.get $g3))
(local.set $l4 (global.get $g4))

;; This acts as a barrier for $l1, $l2, and $l3 but not $l4.
;; $ref may write to $g1 via $f1, or $g2 via $f2, $g3 via $f3 but not $g4.
;; $l4 is optimized out and the others are left alone.
(call_ref $indirect-type (i32.const 1) (local.get $ref))

(drop (local.get $l1))
(drop (local.get $l2))
(drop (local.get $l3))
(drop (local.get $l4))
)
)

(module
;; CHECK: (type $indirect-type (func (param i32)))
(type $indirect-type (func (param i32)))

;; CHECK: (type $1 (func))

;; CHECK: (type $2 (func (param (ref $indirect-type))))

;; CHECK: (import "" "" (func $imported-func (type $indirect-type) (param i32)))
(import "" "" (func $imported-func (type $indirect-type)))

;; CHECK: (global $g1 (mut i32) (i32.const 0))
(global $g1 (mut i32) (i32.const 0))
;; CHECK: (global $g2 (mut i32) (i32.const 0))
(global $g2 (mut i32) (i32.const 0))

;; CHECK: (elem declare func $imported-func)

;; CHECK: (func $reference-imported-func (type $1)
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (ref.func $imported-func)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
(func $reference-imported-func
(drop (ref.func $imported-func))
)

;; CHECK: (func $merges-multiple-effects (type $2) (param $ref (ref $indirect-type))
;; CHECK-NEXT: (local $l1 i32)
;; CHECK-NEXT: (local $l2 i32)
;; CHECK-NEXT: (local.set $l1
;; CHECK-NEXT: (global.get $g1)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.set $l2
;; CHECK-NEXT: (global.get $g2)
;; CHECK-NEXT: )
;; CHECK-NEXT: (call_ref $indirect-type
;; CHECK-NEXT: (i32.const 1)
;; CHECK-NEXT: (local.get $ref)
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (local.get $l1)
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (local.get $l2)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
(func $merges-multiple-effects (param $ref (ref $indirect-type))
(local $l1 i32)
(local $l2 i32)

(local.set $l1 (global.get $g1))
(local.set $l2 (global.get $g2))

;; This can flow to an import, so we assume that $g1 and $g2 could be
;; mutated, and nothing can be optimized.
;; TODO: Since $g1 and $g2 are not imported or exported, it's impossible for
;; an import to mutate them and we should be able to optimize anyway.
(call_ref $indirect-type (i32.const 1) (local.get $ref))

(drop (local.get $l1))
(drop (local.get $l2))
)
)
Loading
Loading