struct VerifyFlatness

: public PostWalker<VerifyFlatness,

UnifiedExpressionVisitor<VerifyFlatness>> {

void visitExpression(Expression* curr) {

if (Properties::isControlFlowStructure(curr)) {

verify(!curr->type.isConcrete(),

"control flow structures must not flow values");

} else if (auto* set = curr->dynCast<LocalSet>()) {

verify(!set->isTee() || set->type == Type::unreachable,

"tees are not allowed, only sets");

verify(!Properties::isControlFlowStructure(set->value),

"set values cannot be control flow");

} else {

for (auto* child : ChildIterator(curr)) {

bool isRefAsNonNull =

child->is<RefAs>() && child->cast<RefAs>()->op == RefAsNonNull;

verify(Properties::isConstantExpression(child) ||

child->is<LocalGet>() || child->is<Unreachable>() ||

isRefAsNonNull,

"instructions must only have constant expressions, local.get, "

"or unreachable as children");

}

}

}

void verify(bool condition, const char* message) {

if (!condition) {

Fatal() << "IR must be flat: run --flatten beforehand (" << message

<< ", in " << getFunction()->name << ')';

}

}

};

VerifyFlatness verifier;

verifier.walkFunction(func);

verifier.setFunction(func);

verifier.verify(!func->body->type.isConcrete(),

"function bodies must not flow values");

struct VerifyFlatness

: public WalkerPass<

PostWalker<VerifyFlatness, UnifiedExpressionVisitor<VerifyFlatness>>> {

bool isFunctionParallel() override { return true; }

bool modifiesBinaryenIR() override { return false; }

std::unique_ptr<Pass> create() override {

return std::make_unique<VerifyFlatness>();

}

void visitFunction(Function* func) { verifyFlatness(func); }

};

PassRunner runner(module);

VerifyFlatness().run(&runner, module);