summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--src/ir/subtypes.h5
-rw-r--r--src/passes/RemoveUnusedModuleElements.cpp164
-rw-r--r--test/lit/passes/remove-unused-module-elements-refs.wast1223
3 files changed, 1389 insertions, 3 deletions
diff --git a/src/ir/subtypes.h b/src/ir/subtypes.h
index c895828f1..d3a6dceaa 100644
--- a/src/ir/subtypes.h
+++ b/src/ir/subtypes.h
@@ -173,6 +173,11 @@ struct SubTypes {
}
}
+ // As above, but iterate to the maximum depth.
+ template<typename F> void iterSubTypes(HeapType type, F func) {
+ return iterSubTypes(type, std::numeric_limits<Index>::max(), func);
+ }
+
// All the types in the program. This is computed here anyhow, and can be
// useful for callers to iterate on, so it is public.
std::vector<HeapType> types;
diff --git a/src/passes/RemoveUnusedModuleElements.cpp b/src/passes/RemoveUnusedModuleElements.cpp
index 6070d8bce..95318acd2 100644
--- a/src/passes/RemoveUnusedModuleElements.cpp
+++ b/src/passes/RemoveUnusedModuleElements.cpp
@@ -40,6 +40,7 @@
#include "ir/element-utils.h"
#include "ir/intrinsics.h"
#include "ir/module-utils.h"
+#include "ir/subtypes.h"
#include "ir/utils.h"
#include "pass.h"
#include "wasm-builder.h"
@@ -56,6 +57,10 @@ enum class ModuleElementKind { Function, Global, Tag, Table, ElementSegment };
// name of the particular element.
using ModuleElement = std::pair<ModuleElementKind, Name>;
+// A pair of a struct type and a field index, together defining a field in a
+// particular type.
+using StructField = std::pair<HeapType, Index>;
+
// Visit or walk an expression to find what things are referenced.
struct ReferenceFinder : public PostWalker<ReferenceFinder> {
// Our findings are placed in these data structures, which the user of this
@@ -63,12 +68,14 @@ struct ReferenceFinder : public PostWalker<ReferenceFinder> {
std::vector<ModuleElement> elements;
std::vector<HeapType> callRefTypes;
std::vector<Name> refFuncs;
+ std::vector<StructField> structFields;
bool usesMemory = false;
// Add an item to the output data structures.
void note(ModuleElement element) { elements.push_back(element); }
void noteCallRef(HeapType type) { callRefTypes.push_back(type); }
void noteRefFunc(Name refFunc) { refFuncs.push_back(refFunc); }
+ void note(StructField structField) { structFields.push_back(structField); }
// Visitors
@@ -161,6 +168,13 @@ struct ReferenceFinder : public PostWalker<ReferenceFinder> {
note(ModuleElement(ModuleElementKind::Tag, tag));
}
}
+ void visitStructGet(StructGet* curr) {
+ if (curr->ref->type == Type::unreachable || curr->ref->type.isNull()) {
+ return;
+ }
+ auto type = curr->ref->type.getHeapType();
+ note(StructField{type, curr->index});
+ }
void visitArrayNewSeg(ArrayNewSeg* curr) {
switch (curr->op) {
case NewData:
@@ -207,7 +221,6 @@ struct Analyzer {
// If we walked the child immediately then we would make $bar used. But that
// global is only used if we actually read that field from the struct. We
// perform that analysis in readStructFields unreadStructFieldExprMap, below.
- // TODO: this is not implemented yet
std::vector<Expression*> expressionQueue;
bool usesMemory = false;
@@ -234,6 +247,17 @@ struct Analyzer {
// imports.
std::unordered_map<HeapType, std::unordered_set<Name>> uncalledRefFuncMap;
+ // Similar to calledSignatures/uncalledRefFuncMap, we store the StructFields
+ // we've seen reads from, and also expressions stored in such fields that
+ // could be read if ever we see a read of that field in the future. That is,
+ // for an expression stored into a struct field to be read, we need to both
+ // see that expression written to the field, and see some other place read
+ // that field (similar to with functions that we need to see the RefFunc and
+ // also a CallRef that can actually call it).
+ std::unordered_set<StructField> readStructFields;
+ std::unordered_map<StructField, std::vector<Expression*>>
+ unreadStructFieldExprMap;
+
Analyzer(Module* module,
const PassOptions& options,
const std::vector<ModuleElement>& roots)
@@ -261,6 +285,9 @@ struct Analyzer {
}
}
+ // We'll compute SubTypes if we need them.
+ std::optional<SubTypes> subTypes;
+
// Process expressions in the expression queue while we have any, visiting
// them (using their contents) and adding children. Returns whether we did any
// work.
@@ -286,6 +313,9 @@ struct Analyzer {
for (auto func : finder.refFuncs) {
useRefFunc(func);
}
+ for (auto structField : finder.structFields) {
+ useStructField(structField);
+ }
if (finder.usesMemory) {
usesMemory = true;
}
@@ -345,6 +375,36 @@ struct Analyzer {
}
}
+ void useStructField(StructField structField) {
+ if (!readStructFields.count(structField)) {
+ // Avoid a structured binding as the C++ spec does not allow capturing
+ // them in lambdas, which we need below.
+ auto type = structField.first;
+ auto index = structField.second;
+
+ // This is the first time we see a read of this data. Note that it is
+ // read, and also all subtypes since we might be reading from them as
+ // well.
+ if (!subTypes) {
+ subTypes = SubTypes(*module);
+ }
+ subTypes->iterSubTypes(type, [&](HeapType subType, Index depth) {
+ auto subStructField = StructField{subType, index};
+ readStructFields.insert(subStructField);
+
+ // Walk all the unread data we've queued: we queued it for the
+ // possibility of it ever being read, which just happened.
+ auto iter = unreadStructFieldExprMap.find(subStructField);
+ if (iter != unreadStructFieldExprMap.end()) {
+ for (auto* expr : iter->second) {
+ use(expr);
+ }
+ }
+ unreadStructFieldExprMap.erase(subStructField);
+ });
+ }
+ }
+
// As processExpressions, but for module elements.
bool processModule() {
bool worked = false;
@@ -399,9 +459,106 @@ struct Analyzer {
// Add the children of a used expression to be walked, if we should do so.
void scanChildren(Expression* curr) {
- for (auto* child : ChildIterator(curr)) {
- use(child);
+ // For now, the only special handling we have is fields of struct.new, which
+ // we defer walking of to when we know there is a read that can actually
+ // read them, see comments above on |expressionQueue|. We can only do that
+ // optimization in closed world (as otherwise the field might be read
+ // outside of the code we can see), and when it is reached (if it's
+ // unreachable then we don't know the type, and can defer that to DCE to
+ // remove).
+ if (!options.closedWorld || curr->type == Type::unreachable ||
+ !curr->is<StructNew>()) {
+ for (auto* child : ChildIterator(curr)) {
+ use(child);
+ }
+ return;
}
+
+ auto* new_ = curr->cast<StructNew>();
+ auto type = new_->type.getHeapType();
+
+ for (Index i = 0; i < new_->operands.size(); i++) {
+ auto* operand = new_->operands[i];
+ auto structField = StructField{type, i};
+ if (readStructFields.count(structField) ||
+ EffectAnalyzer(options, *module, operand).hasSideEffects()) {
+ // This data can be read, so just walk it. Or, this has side effects,
+ // which is tricky to reason about - the side effects must happen even
+ // if we never read the struct field - so give up and consider it used.
+ use(operand);
+ } else {
+ // This data does not need to be read now, but might be read later. Note
+ // it as unread.
+ unreadStructFieldExprMap[structField].push_back(operand);
+
+ // We also must note that anything in this operand is referenced, even
+ // if it never ends up used, so the IR remains valid.
+ addReferences(operand);
+ }
+ }
+ }
+
+ // Add references to all things appearing in an expression. This is called
+ // when we know an expression will appear in the output, which means it must
+ // remain valid IR and not refer to nonexistent things.
+ //
+ // This is only called on things without side effects (if there are such
+ // effects then we would have had to assume the worst earlier, and not get
+ // here).
+ void addReferences(Expression* curr) {
+ // Find references anywhere in this expression so we can apply them.
+ ReferenceFinder finder;
+ finder.setModule(module);
+ finder.walk(curr);
+
+ for (auto element : finder.elements) {
+ referenced.insert(element);
+
+ auto& [kind, value] = element;
+ if (kind == ModuleElementKind::Global) {
+ // Like functions, (non-imported) globals have contents. For functions,
+ // things are simple: if a function ends up with references but no uses
+ // then we can simply empty out the function (by setting its body to an
+ // unreachable). We don't have a simple way to do the same for globals,
+ // unfortunately. For now, scan the global's contents and add references
+ // as needed.
+ // TODO: We could try to empty the global out, for example, replace it
+ // with a null if it is nullable, or replace all gets of it with
+ // something else, but that is not trivial.
+ auto* global = module->getGlobal(value);
+ if (!global->imported()) {
+ // Note that infinite recursion is not a danger here since a global
+ // can only refer to previous globals.
+ addReferences(global->init);
+ }
+ }
+ }
+
+ for (auto func : finder.refFuncs) {
+ // If a function ends up referenced but not used then later down we will
+ // empty it out by replacing its body with an unreachable, which always
+ // validates. For that reason all we need to do here is mark the function
+ // as referenced - we don't need to do anything with the body.
+ //
+ // Note that it is crucial that we do not call useRefFunc() here: we are
+ // just adding a reference to the function, and not actually using the
+ // RefFunc. (Only useRefFunc() + a CallRef of the proper type are enough
+ // to make a function itself used.)
+ referenced.insert(ModuleElement(ModuleElementKind::Function, func));
+ }
+
+ if (finder.usesMemory) {
+ // TODO: We could do better here, but leave that for the full refactor
+ // here that will also add multimemory. Then this will be as simple
+ // as supporting tables here (which are just more module elements).
+ usesMemory = true;
+ }
+
+ // Note: nothing to do with |callRefTypes| and |structFields|, which only
+ // involve types. This function only cares about references to module
+ // elements like functions, globals, and tables. (References to types are
+ // handled in an entirely different way in Binaryen IR, and we don't need to
+ // worry about it.)
}
};
@@ -505,6 +662,7 @@ struct RemoveUnusedModuleElements : public Pass {
return true;
});
module->removeGlobals([&](Global* curr) {
+ // See TODO in addReferences - we may be able to do better here.
return !needed(ModuleElement(ModuleElementKind::Global, curr->name));
});
module->removeTags([&](Tag* curr) {
diff --git a/test/lit/passes/remove-unused-module-elements-refs.wast b/test/lit/passes/remove-unused-module-elements-refs.wast
index f0b90a7bb..7d430b021 100644
--- a/test/lit/passes/remove-unused-module-elements-refs.wast
+++ b/test/lit/passes/remove-unused-module-elements-refs.wast
@@ -571,3 +571,1226 @@
(func $target-keep-2 (type $A)
)
)
+
+;; Test reachability of struct fields in globals. Only fields that have actual
+;; reads need to be processed.
+(module
+ ;; CHECK: (type $void (func))
+ ;; OPEN_WORLD: (type $void (func))
+ (type $void (func))
+
+ ;; CHECK: (type $vtable (struct (field (ref $void)) (field (ref $void))))
+ ;; OPEN_WORLD: (type $vtable (struct (field (ref $void)) (field (ref $void))))
+ (type $vtable (struct_subtype (field (ref $void)) (field (ref $void)) data))
+
+ ;; CHECK: (global $vtable (ref $vtable) (struct.new $vtable
+ ;; CHECK-NEXT: (ref.func $a)
+ ;; CHECK-NEXT: (ref.func $b)
+ ;; CHECK-NEXT: ))
+ ;; OPEN_WORLD: (global $vtable (ref $vtable) (struct.new $vtable
+ ;; OPEN_WORLD-NEXT: (ref.func $a)
+ ;; OPEN_WORLD-NEXT: (ref.func $b)
+ ;; OPEN_WORLD-NEXT: ))
+ (global $vtable (ref $vtable) (struct.new $vtable
+ (ref.func $a)
+ (ref.func $b)
+ ))
+
+ (global $vtable-2 (ref $vtable) (struct.new $vtable
+ (ref.func $c)
+ (ref.func $d)
+ ))
+
+ ;; CHECK: (export "export" (func $export))
+
+ ;; CHECK: (func $export (type $void)
+ ;; CHECK-NEXT: (call $b)
+ ;; CHECK-NEXT: )
+ ;; OPEN_WORLD: (export "export" (func $export))
+
+ ;; OPEN_WORLD: (func $export (type $void)
+ ;; OPEN_WORLD-NEXT: (call $b)
+ ;; OPEN_WORLD-NEXT: )
+ (func $export (export "export")
+ ;; Call $b but not $a or $c
+ (call $b)
+ )
+
+ ;; CHECK: (func $a (type $void)
+ ;; CHECK-NEXT: (unreachable)
+ ;; CHECK-NEXT: )
+ ;; OPEN_WORLD: (func $a (type $void)
+ ;; OPEN_WORLD-NEXT: (call_ref $void
+ ;; OPEN_WORLD-NEXT: (struct.get $vtable 0
+ ;; OPEN_WORLD-NEXT: (global.get $vtable)
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: )
+ (func $a (type $void)
+ ;; $a calls field #0 in the vtable.
+ ;;
+ ;; Even though $a is in the vtable, it is dead, since the vtable is alive
+ ;; but there is no live read of field #0 - the only read is in here, which
+ ;; is basically an unreachable cycle that we can collect. We can empty out
+ ;; this function since it is dead, but we cannot remove it entirely due to
+ ;; the ref in the vtable.
+ ;;
+ ;; (In open world, however, we cannot do this, as we must assume reads of
+ ;; struct fields can occur outside of our view. That is, the vtable could be
+ ;; sent somewhere that reads field #0, which would make $a live.)
+ (call_ref $void
+ (struct.get $vtable 0
+ (global.get $vtable)
+ )
+ )
+ )
+
+ ;; CHECK: (func $b (type $void)
+ ;; CHECK-NEXT: (call_ref $void
+ ;; CHECK-NEXT: (struct.get $vtable 1
+ ;; CHECK-NEXT: (global.get $vtable)
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: )
+ ;; OPEN_WORLD: (func $b (type $void)
+ ;; OPEN_WORLD-NEXT: (call_ref $void
+ ;; OPEN_WORLD-NEXT: (struct.get $vtable 1
+ ;; OPEN_WORLD-NEXT: (global.get $vtable)
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: )
+ (func $b (type $void)
+ ;; $b calls field #1 in the vtable.
+ ;;
+ ;; As $b is called from the export, this function is not dead.
+ (call_ref $void
+ (struct.get $vtable 1
+ (global.get $vtable)
+ )
+ )
+ )
+
+ (func $c (type $void)
+ ;; $c is parallel to $a, but using vtable-2, which has no other references,
+ ;; so this is dead like $a, and can be removed entirely.
+ (call_ref $void
+ (struct.get $vtable 0
+ (global.get $vtable-2)
+ )
+ )
+ )
+
+ (func $d (type $void)
+ ;; $d is parallel to $b, but using vtable-2, which has no other references.
+ ;; This is dead, even though the struct type + index have a use (due to the
+ ;; other vtable) - there is no use of vtable-2 (except from unreachable
+ ;; places like here), so this cannot be reached.
+ (call_ref $void
+ (struct.get $vtable 0
+ (global.get $vtable-2)
+ )
+ )
+ )
+)
+
+;; Test struct.news not in globals.
+(module
+ ;; CHECK: (type $void (func))
+ ;; OPEN_WORLD: (type $void (func))
+ (type $void (func))
+
+ ;; CHECK: (type $vtable (struct (field (ref $void)) (field (ref $void))))
+ ;; OPEN_WORLD: (type $vtable (struct (field (ref $void)) (field (ref $void))))
+ (type $vtable (struct_subtype (field (ref $void)) (field (ref $void)) data))
+
+ ;; CHECK: (type $struct (struct (field (ref $vtable)) (field (ref $vtable)) (field (ref $vtable)) (field (ref $vtable))))
+ ;; OPEN_WORLD: (type $struct (struct (field (ref $vtable)) (field (ref $vtable)) (field (ref $vtable)) (field (ref $vtable))))
+ (type $struct (struct_subtype (field (ref $vtable)) (field (ref $vtable)) (field (ref $vtable)) (field (ref $vtable)) data))
+
+ ;; CHECK: (global $vtable (ref $vtable) (struct.new $vtable
+ ;; CHECK-NEXT: (ref.func $a)
+ ;; CHECK-NEXT: (ref.func $b)
+ ;; CHECK-NEXT: ))
+ ;; OPEN_WORLD: (global $vtable (ref $vtable) (struct.new $vtable
+ ;; OPEN_WORLD-NEXT: (ref.func $a)
+ ;; OPEN_WORLD-NEXT: (ref.func $b)
+ ;; OPEN_WORLD-NEXT: ))
+ (global $vtable (ref $vtable) (struct.new $vtable
+ (ref.func $a)
+ (ref.func $b)
+ ))
+
+ ;; CHECK: (elem declare func $c $d $e $f $g $h $void)
+
+ ;; CHECK: (export "func" (func $func))
+
+ ;; CHECK: (func $func (type $void)
+ ;; CHECK-NEXT: (local $ref (ref $struct))
+ ;; CHECK-NEXT: (local $vtable (ref $vtable))
+ ;; CHECK-NEXT: (local.set $ref
+ ;; CHECK-NEXT: (struct.new $struct
+ ;; CHECK-NEXT: (global.get $vtable)
+ ;; CHECK-NEXT: (struct.new $vtable
+ ;; CHECK-NEXT: (ref.func $c)
+ ;; CHECK-NEXT: (ref.func $d)
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: (local.tee $vtable
+ ;; CHECK-NEXT: (struct.new $vtable
+ ;; CHECK-NEXT: (ref.func $e)
+ ;; CHECK-NEXT: (ref.func $f)
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: (struct.new $vtable
+ ;; CHECK-NEXT: (ref.func $g)
+ ;; CHECK-NEXT: (ref.func $h)
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: (drop
+ ;; CHECK-NEXT: (block ;; (replaces something unreachable we can't emit)
+ ;; CHECK-NEXT: (drop
+ ;; CHECK-NEXT: (unreachable)
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: (drop
+ ;; CHECK-NEXT: (unreachable)
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: (unreachable)
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: (drop
+ ;; CHECK-NEXT: (struct.get $struct 0
+ ;; CHECK-NEXT: (local.get $ref)
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: (drop
+ ;; CHECK-NEXT: (struct.get $struct 1
+ ;; CHECK-NEXT: (local.get $ref)
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: (drop
+ ;; CHECK-NEXT: (struct.get $struct 2
+ ;; CHECK-NEXT: (local.get $ref)
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: (drop
+ ;; CHECK-NEXT: (struct.get $vtable 1
+ ;; CHECK-NEXT: (local.get $vtable)
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: (call_ref $void
+ ;; CHECK-NEXT: (ref.func $void)
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: )
+ ;; OPEN_WORLD: (elem declare func $c $d $e $f $g $h $void)
+
+ ;; OPEN_WORLD: (export "func" (func $func))
+
+ ;; OPEN_WORLD: (func $func (type $void)
+ ;; OPEN_WORLD-NEXT: (local $ref (ref $struct))
+ ;; OPEN_WORLD-NEXT: (local $vtable (ref $vtable))
+ ;; OPEN_WORLD-NEXT: (local.set $ref
+ ;; OPEN_WORLD-NEXT: (struct.new $struct
+ ;; OPEN_WORLD-NEXT: (global.get $vtable)
+ ;; OPEN_WORLD-NEXT: (struct.new $vtable
+ ;; OPEN_WORLD-NEXT: (ref.func $c)
+ ;; OPEN_WORLD-NEXT: (ref.func $d)
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: (local.tee $vtable
+ ;; OPEN_WORLD-NEXT: (struct.new $vtable
+ ;; OPEN_WORLD-NEXT: (ref.func $e)
+ ;; OPEN_WORLD-NEXT: (ref.func $f)
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: (struct.new $vtable
+ ;; OPEN_WORLD-NEXT: (ref.func $g)
+ ;; OPEN_WORLD-NEXT: (ref.func $h)
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: (drop
+ ;; OPEN_WORLD-NEXT: (block ;; (replaces something unreachable we can't emit)
+ ;; OPEN_WORLD-NEXT: (drop
+ ;; OPEN_WORLD-NEXT: (unreachable)
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: (drop
+ ;; OPEN_WORLD-NEXT: (unreachable)
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: (unreachable)
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: (drop
+ ;; OPEN_WORLD-NEXT: (struct.get $struct 0
+ ;; OPEN_WORLD-NEXT: (local.get $ref)
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: (drop
+ ;; OPEN_WORLD-NEXT: (struct.get $struct 1
+ ;; OPEN_WORLD-NEXT: (local.get $ref)
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: (drop
+ ;; OPEN_WORLD-NEXT: (struct.get $struct 2
+ ;; OPEN_WORLD-NEXT: (local.get $ref)
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: (drop
+ ;; OPEN_WORLD-NEXT: (struct.get $vtable 1
+ ;; OPEN_WORLD-NEXT: (local.get $vtable)
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: (call_ref $void
+ ;; OPEN_WORLD-NEXT: (ref.func $void)
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: )
+ (func $func (export "func")
+ (local $ref (ref $struct))
+ (local $vtable (ref $vtable))
+
+ (local.set $ref
+ (struct.new $struct
+ ;; Init one field using the global vtable.
+ (global.get $vtable)
+ ;; Init another field using a vtable we create here - a nested
+ ;; struct.new inside this one.
+ (struct.new $vtable
+ (ref.func $c)
+ (ref.func $d)
+ )
+ ;; Another nested one, but now there is a side effect. Everything here
+ ;; is considered to escape due to that.
+ (local.tee $vtable
+ (struct.new $vtable
+ (ref.func $e)
+ (ref.func $f)
+ )
+ )
+ ;; Another nested one. This field will not be read.
+ (struct.new $vtable
+ (ref.func $g)
+ (ref.func $h)
+ )
+ )
+ )
+
+ ;; Test that we do not assert on an unreachable struct.new.
+ (drop
+ (struct.new $vtable
+ (unreachable)
+ (unreachable)
+ )
+ )
+
+ ;; Read from all fields of $struct except for the last.
+ (drop
+ (struct.get $struct 0
+ (local.get $ref)
+ )
+ )
+ (drop
+ (struct.get $struct 1
+ (local.get $ref)
+ )
+ )
+ (drop
+ (struct.get $struct 2
+ (local.get $ref)
+ )
+ )
+
+ ;; Read from field #1 of the vtable type, but not #0.
+ (drop
+ (struct.get $vtable 1
+ (local.get $vtable)
+ )
+ )
+
+ ;; Call something of type void so we don't eliminate them all instantly.
+ (call_ref $void
+ (ref.func $void)
+ )
+ )
+
+ ;; CHECK: (func $void (type $void)
+ ;; CHECK-NEXT: (nop)
+ ;; CHECK-NEXT: )
+ ;; OPEN_WORLD: (func $void (type $void)
+ ;; OPEN_WORLD-NEXT: (nop)
+ ;; OPEN_WORLD-NEXT: )
+ (func $void (type $void)
+ ;; Helper function. This is reached via a call_ref.
+ )
+
+ ;; CHECK: (func $a (type $void)
+ ;; CHECK-NEXT: (unreachable)
+ ;; CHECK-NEXT: )
+ ;; OPEN_WORLD: (func $a (type $void)
+ ;; OPEN_WORLD-NEXT: (nop)
+ ;; OPEN_WORLD-NEXT: )
+ (func $a (type $void)
+ ;; This is unreachable (in closed world) since a reference to it only exists
+ ;; in field #0 of the vtable type, which is never read from.
+ )
+
+ ;; CHECK: (func $b (type $void)
+ ;; CHECK-NEXT: (nop)
+ ;; CHECK-NEXT: )
+ ;; OPEN_WORLD: (func $b (type $void)
+ ;; OPEN_WORLD-NEXT: (nop)
+ ;; OPEN_WORLD-NEXT: )
+ (func $b (type $void)
+ ;; This is reachable. It is in field #1, which is read, and the global
+ ;; vtable is also read, and the type $void is call_reffed.
+ )
+
+ ;; CHECK: (func $c (type $void)
+ ;; CHECK-NEXT: (unreachable)
+ ;; CHECK-NEXT: )
+ ;; OPEN_WORLD: (func $c (type $void)
+ ;; OPEN_WORLD-NEXT: (nop)
+ ;; OPEN_WORLD-NEXT: )
+ (func $c (type $void)
+ ;; Like $a, this is unreachable. That it is in a nested struct.new, and not
+ ;; in a global, does not matter.
+ )
+
+ ;; CHECK: (func $d (type $void)
+ ;; CHECK-NEXT: (nop)
+ ;; CHECK-NEXT: )
+ ;; OPEN_WORLD: (func $d (type $void)
+ ;; OPEN_WORLD-NEXT: (nop)
+ ;; OPEN_WORLD-NEXT: )
+ (func $d (type $void)
+ ;; Like $b, this is reachable. That it is in a nested struct.new, and not
+ ;; in a global, does not matter.
+ )
+
+ ;; CHECK: (func $e (type $void)
+ ;; CHECK-NEXT: (unreachable)
+ ;; CHECK-NEXT: )
+ ;; OPEN_WORLD: (func $e (type $void)
+ ;; OPEN_WORLD-NEXT: (nop)
+ ;; OPEN_WORLD-NEXT: )
+ (func $e (type $void)
+ ;; Side effects on the struct field are not enough to make this reachable:
+ ;; there is a tee on the struct.new we are in, but field #0 is still not
+ ;; read from the relevant struct.
+ )
+
+ ;; CHECK: (func $f (type $void)
+ ;; CHECK-NEXT: (nop)
+ ;; CHECK-NEXT: )
+ ;; OPEN_WORLD: (func $f (type $void)
+ ;; OPEN_WORLD-NEXT: (nop)
+ ;; OPEN_WORLD-NEXT: )
+ (func $f (type $void)
+ ;; Like $b, this is reachable (the tee does not matter).
+ )
+
+ ;; CHECK: (func $g (type $void)
+ ;; CHECK-NEXT: (unreachable)
+ ;; CHECK-NEXT: )
+ ;; OPEN_WORLD: (func $g (type $void)
+ ;; OPEN_WORLD-NEXT: (nop)
+ ;; OPEN_WORLD-NEXT: )
+ (func $g (type $void)
+ ;; This is in a struct written to a field that is never read in $struct, so
+ ;; it is unreachable.
+ )
+
+ ;; CHECK: (func $h (type $void)
+ ;; CHECK-NEXT: (unreachable)
+ ;; CHECK-NEXT: )
+ ;; OPEN_WORLD: (func $h (type $void)
+ ;; OPEN_WORLD-NEXT: (nop)
+ ;; OPEN_WORLD-NEXT: )
+ (func $h (type $void)
+ ;; This is in a struct written to a field that is never read in $struct, so
+ ;; it is unreachable.
+ )
+)
+
+;; Test side effects causing a value to "leak."
+(module
+ ;; CHECK: (type $void (func))
+ ;; OPEN_WORLD: (type $void (func))
+ (type $void (func))
+
+ ;; CHECK: (type $vtable (struct (field (ref $void)) (field (ref $void))))
+ ;; OPEN_WORLD: (type $vtable (struct (field (ref $void)) (field (ref $void))))
+ (type $vtable (struct_subtype (field (ref $void)) (field (ref $void)) data))
+
+ ;; CHECK: (elem declare func $a $b $void)
+
+ ;; CHECK: (export "func" (func $func))
+
+ ;; CHECK: (func $func (type $void)
+ ;; CHECK-NEXT: (local $vtable (ref $vtable))
+ ;; CHECK-NEXT: (local $void (ref $void))
+ ;; CHECK-NEXT: (local.set $vtable
+ ;; CHECK-NEXT: (struct.new $vtable
+ ;; CHECK-NEXT: (ref.func $a)
+ ;; CHECK-NEXT: (local.tee $void
+ ;; CHECK-NEXT: (ref.func $b)
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: (call_ref $void
+ ;; CHECK-NEXT: (ref.func $void)
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: )
+ ;; OPEN_WORLD: (elem declare func $a $b $void)
+
+ ;; OPEN_WORLD: (export "func" (func $func))
+
+ ;; OPEN_WORLD: (func $func (type $void)
+ ;; OPEN_WORLD-NEXT: (local $vtable (ref $vtable))
+ ;; OPEN_WORLD-NEXT: (local $void (ref $void))
+ ;; OPEN_WORLD-NEXT: (local.set $vtable
+ ;; OPEN_WORLD-NEXT: (struct.new $vtable
+ ;; OPEN_WORLD-NEXT: (ref.func $a)
+ ;; OPEN_WORLD-NEXT: (local.tee $void
+ ;; OPEN_WORLD-NEXT: (ref.func $b)
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: (call_ref $void
+ ;; OPEN_WORLD-NEXT: (ref.func $void)
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: )
+ (func $func (export "func")
+ (local $vtable (ref $vtable))
+ (local $void (ref $void))
+
+ ;; Init one field using a tee, and one normally.
+ (local.set $vtable
+ (struct.new $vtable
+ (ref.func $a)
+ (local.tee $void
+ (ref.func $b)
+ )
+ )
+ )
+
+ ;; Call the type so it is reachable.
+ (call_ref $void
+ (ref.func $void)
+ )
+ )
+
+ ;; CHECK: (func $void (type $void)
+ ;; CHECK-NEXT: (nop)
+ ;; CHECK-NEXT: )
+ ;; OPEN_WORLD: (func $void (type $void)
+ ;; OPEN_WORLD-NEXT: (nop)
+ ;; OPEN_WORLD-NEXT: )
+ (func $void (type $void)
+ ;; Helper function. This is reached via a call_ref.
+ )
+
+ ;; CHECK: (func $a (type $void)
+ ;; CHECK-NEXT: (unreachable)
+ ;; CHECK-NEXT: )
+ ;; OPEN_WORLD: (func $a (type $void)
+ ;; OPEN_WORLD-NEXT: (nop)
+ ;; OPEN_WORLD-NEXT: )
+ (func $a (type $void)
+ ;; This is unreachable (in closed world) because we have no reads from the
+ ;; struct field it is written in.
+ )
+
+ ;; CHECK: (func $b (type $void)
+ ;; CHECK-NEXT: (nop)
+ ;; CHECK-NEXT: )
+ ;; OPEN_WORLD: (func $b (type $void)
+ ;; OPEN_WORLD-NEXT: (nop)
+ ;; OPEN_WORLD-NEXT: )
+ (func $b (type $void)
+ ;; The local.tee makes this reachable: the value is not known to only reside
+ ;; in the struct field, so we must assume it can be used even if the struct
+ ;; field is not.
+ )
+)
+
+;; Cycles.
+(module
+ (rec
+ ;; CHECK: (type $vtable-func (func (param (ref $vtable))))
+ ;; OPEN_WORLD: (type $vtable-func (func (param (ref $vtable))))
+ (type $vtable-func (func (param (ref $vtable))))
+ ;; CHECK: (type $vtable (struct (field (ref $vtable-func)) (field (ref $vtable-func))))
+ ;; OPEN_WORLD: (type $vtable (struct (field (ref $vtable-func)) (field (ref $vtable-func))))
+ (type $vtable (struct_subtype (field (ref $vtable-func)) (field (ref $vtable-func)) data))
+ )
+
+ ;; CHECK: (type $none_=>_none (func))
+
+ ;; CHECK: (elem declare func $a $b $c $d)
+
+ ;; CHECK: (export "func" (func $func))
+
+ ;; CHECK: (func $func (type $none_=>_none)
+ ;; CHECK-NEXT: (call_ref $vtable-func
+ ;; CHECK-NEXT: (struct.new $vtable
+ ;; CHECK-NEXT: (ref.func $a)
+ ;; CHECK-NEXT: (ref.func $b)
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: (struct.get $vtable 0
+ ;; CHECK-NEXT: (struct.new $vtable
+ ;; CHECK-NEXT: (ref.func $a)
+ ;; CHECK-NEXT: (ref.func $b)
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: (drop
+ ;; CHECK-NEXT: (struct.get $vtable 0
+ ;; CHECK-NEXT: (struct.new $vtable
+ ;; CHECK-NEXT: (ref.func $c)
+ ;; CHECK-NEXT: (ref.func $d)
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: )
+ ;; OPEN_WORLD: (type $none_=>_none (func))
+
+ ;; OPEN_WORLD: (elem declare func $a $b $c $d)
+
+ ;; OPEN_WORLD: (export "func" (func $func))
+
+ ;; OPEN_WORLD: (func $func (type $none_=>_none)
+ ;; OPEN_WORLD-NEXT: (call_ref $vtable-func
+ ;; OPEN_WORLD-NEXT: (struct.new $vtable
+ ;; OPEN_WORLD-NEXT: (ref.func $a)
+ ;; OPEN_WORLD-NEXT: (ref.func $b)
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: (struct.get $vtable 0
+ ;; OPEN_WORLD-NEXT: (struct.new $vtable
+ ;; OPEN_WORLD-NEXT: (ref.func $a)
+ ;; OPEN_WORLD-NEXT: (ref.func $b)
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: (drop
+ ;; OPEN_WORLD-NEXT: (struct.get $vtable 0
+ ;; OPEN_WORLD-NEXT: (struct.new $vtable
+ ;; OPEN_WORLD-NEXT: (ref.func $c)
+ ;; OPEN_WORLD-NEXT: (ref.func $d)
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: )
+ (func $func (export "func")
+ ;; Read field 0, and call it.
+ (call_ref $vtable-func
+ (struct.new $vtable
+ (ref.func $a)
+ (ref.func $b)
+ )
+ (struct.get $vtable 0
+ ;; Duplicate the first vtable.
+ (struct.new $vtable
+ (ref.func $a)
+ (ref.func $b)
+ )
+ )
+ )
+
+ ;; Again, read field #0. No need to call it here (the call before makes the
+ ;; type used).
+ (drop
+ (struct.get $vtable 0
+ ;; Make a new vtable with new funcs.
+ (struct.new $vtable
+ (ref.func $c)
+ (ref.func $d)
+ )
+ )
+ )
+ )
+
+ ;; CHECK: (func $a (type $vtable-func) (param $vtable (ref $vtable))
+ ;; CHECK-NEXT: (call_ref $vtable-func
+ ;; CHECK-NEXT: (local.get $vtable)
+ ;; CHECK-NEXT: (struct.get $vtable 0
+ ;; CHECK-NEXT: (local.get $vtable)
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: )
+ ;; OPEN_WORLD: (func $a (type $vtable-func) (param $vtable (ref $vtable))
+ ;; OPEN_WORLD-NEXT: (call_ref $vtable-func
+ ;; OPEN_WORLD-NEXT: (local.get $vtable)
+ ;; OPEN_WORLD-NEXT: (struct.get $vtable 0
+ ;; OPEN_WORLD-NEXT: (local.get $vtable)
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: )
+ (func $a (type $vtable-func) (param $vtable (ref $vtable))
+ ;; $a calls $a or $c (using field #0).
+ ;; $a is reached from $func, so it is reachable.
+ (call_ref $vtable-func
+ (local.get $vtable)
+ (struct.get $vtable 0
+ (local.get $vtable)
+ )
+ )
+ )
+
+ ;; CHECK: (func $b (type $vtable-func) (param $vtable (ref $vtable))
+ ;; CHECK-NEXT: (unreachable)
+ ;; CHECK-NEXT: )
+ ;; OPEN_WORLD: (func $b (type $vtable-func) (param $vtable (ref $vtable))
+ ;; OPEN_WORLD-NEXT: (call_ref $vtable-func
+ ;; OPEN_WORLD-NEXT: (local.get $vtable)
+ ;; OPEN_WORLD-NEXT: (struct.get $vtable 1
+ ;; OPEN_WORLD-NEXT: (local.get $vtable)
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: )
+ (func $b (type $vtable-func) (param $vtable (ref $vtable))
+ ;; $b calls $b or $d (using field #1).
+ ;; But $b is not reached from $func, so it remains unreachable in closed
+ ;; world.
+ (call_ref $vtable-func
+ (local.get $vtable)
+ (struct.get $vtable 1
+ (local.get $vtable)
+ )
+ )
+ )
+
+ ;; CHECK: (func $c (type $vtable-func) (param $vtable (ref $vtable))
+ ;; CHECK-NEXT: (call_ref $vtable-func
+ ;; CHECK-NEXT: (local.get $vtable)
+ ;; CHECK-NEXT: (struct.get $vtable 0
+ ;; CHECK-NEXT: (local.get $vtable)
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: )
+ ;; OPEN_WORLD: (func $c (type $vtable-func) (param $vtable (ref $vtable))
+ ;; OPEN_WORLD-NEXT: (call_ref $vtable-func
+ ;; OPEN_WORLD-NEXT: (local.get $vtable)
+ ;; OPEN_WORLD-NEXT: (struct.get $vtable 0
+ ;; OPEN_WORLD-NEXT: (local.get $vtable)
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: )
+ (func $c (type $vtable-func) (param $vtable (ref $vtable))
+ ;; $c forms a cycle with $a.
+ (call_ref $vtable-func
+ (local.get $vtable)
+ (struct.get $vtable 0
+ (local.get $vtable)
+ )
+ )
+ )
+
+ ;; CHECK: (func $d (type $vtable-func) (param $vtable (ref $vtable))
+ ;; CHECK-NEXT: (unreachable)
+ ;; CHECK-NEXT: )
+ ;; OPEN_WORLD: (func $d (type $vtable-func) (param $vtable (ref $vtable))
+ ;; OPEN_WORLD-NEXT: (call_ref $vtable-func
+ ;; OPEN_WORLD-NEXT: (local.get $vtable)
+ ;; OPEN_WORLD-NEXT: (struct.get $vtable 1
+ ;; OPEN_WORLD-NEXT: (local.get $vtable)
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: )
+ (func $d (type $vtable-func) (param $vtable (ref $vtable))
+ ;; $d forms a cycle with $b.
+ (call_ref $vtable-func
+ (local.get $vtable)
+ (struct.get $vtable 1
+ (local.get $vtable)
+ )
+ )
+ )
+)
+
+;; Subtyping of struct reads.
+(module
+ ;; CHECK: (type $void (func))
+ ;; OPEN_WORLD: (type $void (func))
+ (type $void (func))
+
+ ;; CHECK: (type $struct (struct (field funcref)))
+ ;; OPEN_WORLD: (type $struct (struct (field funcref)))
+ (type $struct (struct (field funcref)))
+
+ ;; CHECK: (type $substruct (struct_subtype (field funcref) $struct))
+ ;; OPEN_WORLD: (type $substruct (struct_subtype (field funcref) $struct))
+ (type $substruct (struct_subtype (field funcref) $struct))
+
+ ;; CHECK: (type $subsubstruct (struct_subtype (field funcref) $substruct))
+ ;; OPEN_WORLD: (type $subsubstruct (struct_subtype (field funcref) $substruct))
+ (type $subsubstruct (struct_subtype (field funcref) $substruct))
+
+ ;; CHECK: (global $g (ref $struct) (struct.new $struct
+ ;; CHECK-NEXT: (ref.func $f)
+ ;; CHECK-NEXT: ))
+ ;; OPEN_WORLD: (global $g (ref $struct) (struct.new $struct
+ ;; OPEN_WORLD-NEXT: (ref.func $f)
+ ;; OPEN_WORLD-NEXT: ))
+ (global $g (ref $struct) (struct.new $struct
+ (ref.func $f)
+ ))
+
+ ;; CHECK: (global $subg (ref $substruct) (struct.new $substruct
+ ;; CHECK-NEXT: (ref.func $subf)
+ ;; CHECK-NEXT: ))
+ ;; OPEN_WORLD: (global $subg (ref $substruct) (struct.new $substruct
+ ;; OPEN_WORLD-NEXT: (ref.func $subf)
+ ;; OPEN_WORLD-NEXT: ))
+ (global $subg (ref $substruct) (struct.new $substruct
+ (ref.func $subf)
+ ))
+
+ ;; CHECK: (global $subsubg (ref $subsubstruct) (struct.new $subsubstruct
+ ;; CHECK-NEXT: (ref.func $subsubf)
+ ;; CHECK-NEXT: ))
+ ;; OPEN_WORLD: (global $subsubg (ref $subsubstruct) (struct.new $subsubstruct
+ ;; OPEN_WORLD-NEXT: (ref.func $subsubf)
+ ;; OPEN_WORLD-NEXT: ))
+ (global $subsubg (ref $subsubstruct) (struct.new $subsubstruct
+ (ref.func $subsubf)
+ ))
+
+ ;; CHECK: (elem declare func $func)
+
+ ;; CHECK: (export "func" (func $func))
+
+ ;; CHECK: (func $func (type $void)
+ ;; CHECK-NEXT: (drop
+ ;; CHECK-NEXT: (global.get $g)
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: (drop
+ ;; CHECK-NEXT: (global.get $subg)
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: (drop
+ ;; CHECK-NEXT: (global.get $subsubg)
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: (drop
+ ;; CHECK-NEXT: (struct.get $substruct 0
+ ;; CHECK-NEXT: (block (result (ref $substruct))
+ ;; CHECK-NEXT: (unreachable)
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: (call_ref $void
+ ;; CHECK-NEXT: (ref.func $func)
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: )
+ ;; OPEN_WORLD: (elem declare func $func)
+
+ ;; OPEN_WORLD: (export "func" (func $func))
+
+ ;; OPEN_WORLD: (func $func (type $void)
+ ;; OPEN_WORLD-NEXT: (drop
+ ;; OPEN_WORLD-NEXT: (global.get $g)
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: (drop
+ ;; OPEN_WORLD-NEXT: (global.get $subg)
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: (drop
+ ;; OPEN_WORLD-NEXT: (global.get $subsubg)
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: (drop
+ ;; OPEN_WORLD-NEXT: (struct.get $substruct 0
+ ;; OPEN_WORLD-NEXT: (block (result (ref $substruct))
+ ;; OPEN_WORLD-NEXT: (unreachable)
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: (call_ref $void
+ ;; OPEN_WORLD-NEXT: (ref.func $func)
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: )
+ (func $func (export "func")
+ ;; Refer to the globals.
+ (drop
+ (global.get $g)
+ )
+ (drop
+ (global.get $subg)
+ )
+ (drop
+ (global.get $subsubg)
+ )
+
+ ;; Read from $substruct's field, but not its super or subtypes.
+ (drop
+ (struct.get $substruct 0
+ (block (result (ref $substruct))
+ (unreachable)
+ )
+ )
+ )
+
+ ;; Call the function type to allow functions to be used.
+ (call_ref $void
+ (ref.func $func)
+ )
+ )
+
+ (func $void (type $void)
+ ;; Helper function. This is reached via a call_ref.
+ )
+
+ ;; CHECK: (func $f (type $void)
+ ;; CHECK-NEXT: (unreachable)
+ ;; CHECK-NEXT: )
+ ;; OPEN_WORLD: (func $f (type $void)
+ ;; OPEN_WORLD-NEXT: (nop)
+ ;; OPEN_WORLD-NEXT: )
+ (func $f (type $void)
+ ;; This is unreachable in closed world. The global it is in has a reference
+ ;; but the struct there has no reads of its field.
+ )
+
+ ;; CHECK: (func $subf (type $void)
+ ;; CHECK-NEXT: (nop)
+ ;; CHECK-NEXT: )
+ ;; OPEN_WORLD: (func $subf (type $void)
+ ;; OPEN_WORLD-NEXT: (nop)
+ ;; OPEN_WORLD-NEXT: )
+ (func $subf (type $void)
+ ;; There is a read of $substruct's field, which makes this reachable.
+ )
+
+ ;; CHECK: (func $subsubf (type $void)
+ ;; CHECK-NEXT: (nop)
+ ;; CHECK-NEXT: )
+ ;; OPEN_WORLD: (func $subsubf (type $void)
+ ;; OPEN_WORLD-NEXT: (nop)
+ ;; OPEN_WORLD-NEXT: )
+ (func $subsubf (type $void)
+ ;; There is a read of $substruct's field, which may read from any subtype,
+ ;; which makes this reachable.
+ )
+)
+
+;; Test references to global function references.
+(module
+ ;; CHECK: (type $void (func))
+ ;; OPEN_WORLD: (type $void (func))
+ (type $void (func))
+
+ ;; CHECK: (type $A (struct (field funcref)))
+ ;; OPEN_WORLD: (type $A (struct (field funcref)))
+ (type $A (struct (field funcref)))
+
+ ;; CHECK: (global $g1 (ref func) (ref.func $f1))
+ ;; OPEN_WORLD: (global $g1 (ref func) (ref.func $f1))
+ (global $g1 (ref func) (ref.func $f1))
+
+ ;; CHECK: (global $g2 (ref func) (ref.func $f2))
+ ;; OPEN_WORLD: (global $g2 (ref func) (ref.func $f2))
+ (global $g2 (ref func) (ref.func $f2))
+
+ ;; CHECK: (elem declare func $func)
+
+ ;; CHECK: (export "func" (func $func))
+
+ ;; CHECK: (func $func (type $void)
+ ;; CHECK-NEXT: (drop
+ ;; CHECK-NEXT: (global.get $g1)
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: (drop
+ ;; CHECK-NEXT: (struct.new $A
+ ;; CHECK-NEXT: (global.get $g2)
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: (call_ref $void
+ ;; CHECK-NEXT: (ref.func $func)
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: )
+ ;; OPEN_WORLD: (elem declare func $func)
+
+ ;; OPEN_WORLD: (export "func" (func $func))
+
+ ;; OPEN_WORLD: (func $func (type $void)
+ ;; OPEN_WORLD-NEXT: (drop
+ ;; OPEN_WORLD-NEXT: (global.get $g1)
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: (drop
+ ;; OPEN_WORLD-NEXT: (struct.new $A
+ ;; OPEN_WORLD-NEXT: (global.get $g2)
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: (call_ref $void
+ ;; OPEN_WORLD-NEXT: (ref.func $func)
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: )
+ (func $func (export "func")
+ ;; Refer to $g1 directly.
+ (drop
+ (global.get $g1)
+ )
+ ;; Refer to $g2 from a struct field that is never read.
+ (drop
+ (struct.new $A
+ (global.get $g2)
+ )
+ )
+
+ ;; Call the function type to allow functions to be used.
+ (call_ref $void
+ (ref.func $func)
+ )
+ )
+
+ (func $void (type $void)
+ ;; Helper function. This is reached via a call_ref.
+ )
+
+ ;; CHECK: (func $f1 (type $void)
+ ;; CHECK-NEXT: (nop)
+ ;; CHECK-NEXT: )
+ ;; OPEN_WORLD: (func $f1 (type $void)
+ ;; OPEN_WORLD-NEXT: (nop)
+ ;; OPEN_WORLD-NEXT: )
+ (func $f1 (type $void)
+ ;; The global containing this function's reference is used.
+ )
+
+ ;; CHECK: (func $f2 (type $void)
+ ;; CHECK-NEXT: (unreachable)
+ ;; CHECK-NEXT: )
+ ;; OPEN_WORLD: (func $f2 (type $void)
+ ;; OPEN_WORLD-NEXT: (nop)
+ ;; OPEN_WORLD-NEXT: )
+ (func $f2 (type $void)
+ ;; This is unreachable in closed world as the global is referred to from a
+ ;; struct field that is never read from.
+ )
+)
+
+;; As above, but now the globals are struct.news.
+(module
+ ;; CHECK: (type $A (struct (field funcref)))
+
+ ;; CHECK: (type $void (func))
+ ;; OPEN_WORLD: (type $A (struct (field funcref)))
+
+ ;; OPEN_WORLD: (type $void (func))
+ (type $void (func))
+
+ (type $A (struct (field funcref)))
+
+ ;; CHECK: (type $B (struct (field (ref $A))))
+ ;; OPEN_WORLD: (type $B (struct (field (ref $A))))
+ (type $B (struct (field (ref $A))))
+
+ ;; CHECK: (global $g (ref $A) (struct.new $A
+ ;; CHECK-NEXT: (ref.func $f)
+ ;; CHECK-NEXT: ))
+ ;; OPEN_WORLD: (global $g (ref $A) (struct.new $A
+ ;; OPEN_WORLD-NEXT: (ref.func $f)
+ ;; OPEN_WORLD-NEXT: ))
+ (global $g (ref $A) (struct.new $A
+ (ref.func $f)
+ ))
+
+ ;; CHECK: (elem declare func $func)
+
+ ;; CHECK: (export "func" (func $func))
+
+ ;; CHECK: (func $func (type $void)
+ ;; CHECK-NEXT: (drop
+ ;; CHECK-NEXT: (struct.new $B
+ ;; CHECK-NEXT: (global.get $g)
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: (call_ref $void
+ ;; CHECK-NEXT: (ref.func $func)
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: (drop
+ ;; CHECK-NEXT: (struct.get $A 0
+ ;; CHECK-NEXT: (block (result (ref $A))
+ ;; CHECK-NEXT: (unreachable)
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: )
+ ;; OPEN_WORLD: (elem declare func $func)
+
+ ;; OPEN_WORLD: (export "func" (func $func))
+
+ ;; OPEN_WORLD: (func $func (type $void)
+ ;; OPEN_WORLD-NEXT: (drop
+ ;; OPEN_WORLD-NEXT: (struct.new $B
+ ;; OPEN_WORLD-NEXT: (global.get $g)
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: (call_ref $void
+ ;; OPEN_WORLD-NEXT: (ref.func $func)
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: (drop
+ ;; OPEN_WORLD-NEXT: (struct.get $A 0
+ ;; OPEN_WORLD-NEXT: (block (result (ref $A))
+ ;; OPEN_WORLD-NEXT: (unreachable)
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: )
+ (func $func (export "func")
+ ;; Refer to $g from a struct field that is never read.
+ (drop
+ (struct.new $B
+ (global.get $g)
+ )
+ )
+
+ ;; Call the function type to allow functions to be used.
+ (call_ref $void
+ (ref.func $func)
+ )
+
+ ;; Read $A's field.
+ (drop
+ (struct.get $A 0
+ (block (result (ref $A))
+ (unreachable)
+ )
+ )
+ )
+ )
+
+ (func $void (type $void)
+ ;; Helper function. This is reached via a call_ref.
+ )
+
+ ;; CHECK: (func $f (type $void)
+ ;; CHECK-NEXT: (unreachable)
+ ;; CHECK-NEXT: )
+ ;; OPEN_WORLD: (func $f (type $void)
+ ;; OPEN_WORLD-NEXT: (nop)
+ ;; OPEN_WORLD-NEXT: )
+ (func $f (type $void)
+ ;; This is unreachable in closed world since $B's field is not read, so the
+ ;; global it is in is only referenced and not used.
+ )
+)
+
+;; As above, but read $B's field. Now $f is reachable.
+(module
+ ;; CHECK: (type $A (struct (field funcref)))
+
+ ;; CHECK: (type $void (func))
+ ;; OPEN_WORLD: (type $A (struct (field funcref)))
+
+ ;; OPEN_WORLD: (type $void (func))
+ (type $void (func))
+
+ (type $A (struct (field funcref)))
+
+ ;; CHECK: (type $B (struct (field (ref $A))))
+ ;; OPEN_WORLD: (type $B (struct (field (ref $A))))
+ (type $B (struct (field (ref $A))))
+
+ ;; CHECK: (global $g (ref $A) (struct.new $A
+ ;; CHECK-NEXT: (ref.func $f)
+ ;; CHECK-NEXT: ))
+ ;; OPEN_WORLD: (global $g (ref $A) (struct.new $A
+ ;; OPEN_WORLD-NEXT: (ref.func $f)
+ ;; OPEN_WORLD-NEXT: ))
+ (global $g (ref $A) (struct.new $A
+ (ref.func $f)
+ ))
+
+ ;; CHECK: (elem declare func $func)
+
+ ;; CHECK: (export "func" (func $func))
+
+ ;; CHECK: (func $func (type $void)
+ ;; CHECK-NEXT: (drop
+ ;; CHECK-NEXT: (struct.new $B
+ ;; CHECK-NEXT: (global.get $g)
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: (call_ref $void
+ ;; CHECK-NEXT: (ref.func $func)
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: (drop
+ ;; CHECK-NEXT: (struct.get $A 0
+ ;; CHECK-NEXT: (block (result (ref $A))
+ ;; CHECK-NEXT: (unreachable)
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: (drop
+ ;; CHECK-NEXT: (struct.get $B 0
+ ;; CHECK-NEXT: (block (result (ref $B))
+ ;; CHECK-NEXT: (unreachable)
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: )
+ ;; CHECK-NEXT: )
+ ;; OPEN_WORLD: (elem declare func $func)
+
+ ;; OPEN_WORLD: (export "func" (func $func))
+
+ ;; OPEN_WORLD: (func $func (type $void)
+ ;; OPEN_WORLD-NEXT: (drop
+ ;; OPEN_WORLD-NEXT: (struct.new $B
+ ;; OPEN_WORLD-NEXT: (global.get $g)
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: (call_ref $void
+ ;; OPEN_WORLD-NEXT: (ref.func $func)
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: (drop
+ ;; OPEN_WORLD-NEXT: (struct.get $A 0
+ ;; OPEN_WORLD-NEXT: (block (result (ref $A))
+ ;; OPEN_WORLD-NEXT: (unreachable)
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: (drop
+ ;; OPEN_WORLD-NEXT: (struct.get $B 0
+ ;; OPEN_WORLD-NEXT: (block (result (ref $B))
+ ;; OPEN_WORLD-NEXT: (unreachable)
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: )
+ ;; OPEN_WORLD-NEXT: )
+ (func $func (export "func")
+ (drop
+ (struct.new $B
+ (global.get $g)
+ )
+ )
+
+ (call_ref $void
+ (ref.func $func)
+ )
+
+ (drop
+ (struct.get $A 0
+ (block (result (ref $A))
+ (unreachable)
+ )
+ )
+ )
+
+ ;; The change in this testcase is to read $B's field.
+ (drop
+ (struct.get $B 0
+ (block (result (ref $B))
+ (unreachable)
+ )
+ )
+ )
+ )
+
+ (func $void (type $void)
+ ;; Helper function. This is reached via a call_ref.
+ )
+
+ ;; CHECK: (func $f (type $void)
+ ;; CHECK-NEXT: (nop)
+ ;; CHECK-NEXT: )
+ ;; OPEN_WORLD: (func $f (type $void)
+ ;; OPEN_WORLD-NEXT: (nop)
+ ;; OPEN_WORLD-NEXT: )
+ (func $f (type $void)
+ )
+)