Module& wasm;

bool validateWeb;

bool validateGlobally;

bool quiet;

std::atomic<bool> valid;

// a stream of error test for each function. we print in the right order at

// the end, for deterministic output

// note errors are rare/unexpected, so it's ok to use a slow mutex here

std::mutex mutex;

std::unordered_map<Function*, std::unique_ptr<std::ostringstream>> outputs;

ValidationInfo(Module& wasm) : wasm(wasm) { valid.store(true); }

std::ostringstream& getStream(Function* func) {

std::unique_lock<std::mutex> lock(mutex);

auto iter = outputs.find(func);

if (iter != outputs.end()) {

return *(iter->second.get());

}

auto& ret = outputs[func] = std::make_unique<std::ostringstream>();

return *ret.get();

}

// printing and error handling support

template<typename T, typename S>

std::ostream& fail(S text, T curr, Function* func) {

valid.store(false);

auto& stream = getStream(func);

if (quiet) {

return stream;

}

auto& ret = printFailureHeader(func);

ret << text << ", on \n";

return printModuleComponent(curr, ret, wasm);

}

std::ostringstream& printFailureHeader(Function* func) {

auto& stream = getStream(func);

if (quiet) {

return stream;

}

Colors::red(stream);

if (func) {

stream << "[wasm-validator error in function ";

Colors::green(stream);

stream << func->name;

Colors::red(stream);

stream << "] ";

} else {

stream << "[wasm-validator error in module] ";

}

Colors::normal(stream);

return stream;

}

// Checking utilities.

// Returns whether the result was in fact true.

template<typename T>

bool shouldBeTrue(bool result,

T curr,

const char* text,

Function* func = nullptr) {

if (!result) {

fail("unexpected false: " + std::string(text), curr, func);

return false;

}

return true;

}

// Returns whether the result was in fact false.

template<typename T>

bool shouldBeFalse(bool result,

T curr,

const char* text,

Function* func = nullptr) {

if (result) {

fail("unexpected true: " + std::string(text), curr, func);

return false;

}

return true;

}

template<typename T, typename S>

bool shouldBeEqual(

S left, S right, T curr, const char* text, Function* func = nullptr) {

if (left != right) {

std::ostringstream ss;

ss << left << " != " << right << ": " << text;

fail(ss.str(), curr, func);

return false;

}

return true;

}

template<typename T>

bool shouldBeEqualOrFirstIsUnreachable(

Type left, Type right, T curr, const char* text, Function* func = nullptr) {

if (left != Type::unreachable && left != right) {

std::ostringstream ss;

ss << left << " != " << right << ": " << text;

fail(ss.str(), curr, func);

return false;

}

return true;

}

template<typename T, typename S>

bool shouldBeUnequal(

S left, S right, T curr, const char* text, Function* func = nullptr) {

if (left == right) {

std::ostringstream ss;

ss << left << " == " << right << ": " << text;

fail(ss.str(), curr, func);

return false;

}

return true;

}

void shouldBeIntOrUnreachable(Type ty,

Expression* curr,

const char* text,

Function* func = nullptr) {

if (!ty.isBasic()) {

fail(text, curr, func);

return;

}

switch (ty.getBasic()) {

case Type::i32:

case Type::i64:

case Type::unreachable: {

break;

}

default:

fail(text, curr, func);

}

}

// Type 'left' should be a subtype of 'right'.

bool shouldBeSubType(Type left,

Type right,

Expression* curr,

const char* text,

Function* func = nullptr) {

if (Type::isSubType(left, right)) {

return true;

}

fail(text, curr, func);

return false;

}

bool shouldBeSubTypeIgnoringShared(Type left,

Type right,

Expression* curr,

const char* text,

Function* func = nullptr) {

assert(right.isRef() && right.getHeapType().isBasic());

auto share = left.isRef() ? left.getHeapType().getShared() : Unshared;

auto ht = right.getHeapType();

auto matchedRight = Type(ht.getBasic(share), right.getNullability());

return shouldBeSubType(left, matchedRight, curr, text, func);

}

if (module.features.hasCustomDescriptors()) {

return;

}

for (auto type : ModuleUtils::getPublicHeapTypes(module)) {

for (auto child : type.getTypeChildren()) {

if (child.isExact()) {

std::string typeName;

if (auto it = module.typeNames.find(type);

it != module.typeNames.end()) {

typeName = '$' + it->second.name.toString();

} else {

typeName = type.toString();

}

info.fail("Exact reference in public type not allowed without custom "

"descriptors [--enable-custom-descriptors]",

typeName,

nullptr);

break;

}

}

}

std::stringstream ss;

bool first = true;

ss << '[';

(feats - wasm.features).iterFeatures([&](FeatureSet feat) {

if (first) {

first = false;

} else {

ss << " ";

}

ss << "--enable-" << feat.toString();

});

ss << ']';

return ss.str();

bool isFunctionParallel() override { return true; }

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

return std::make_unique<FunctionValidator>(*getModule(), &info);

}

bool modifiesBinaryenIR() override { return false; }

ValidationInfo& info;

FunctionValidator(Module& wasm, ValidationInfo* info) : info(*info) {

setModule(&wasm);

}

// Validate the entire module.

void validate(PassRunner* runner) { run(runner, getModule()); }

// Validate a specific expression.

void validate(Expression* curr) { walk(curr); }

// Validate a function.

void validate(Function* func) { walkFunction(func); }

// The types sent to each label on branches.

std::unordered_map<Name, std::unordered_set<Type>> breakTypes;

// The Tags and continuation result types used to resume at this label.

struct ResumeInfo {

Expression* resume;

Tag* tag;

Type contResult;

};

std::unordered_map<Name, std::vector<ResumeInfo>> resumeInfos;

std::unordered_set<Name> delegateTargetNames;

std::unordered_set<Name> rethrowTargetNames;

// Binaryen IR requires that label names must be unique - IR generators must

// ensure that

std::unordered_set<Name> labelNames;

void noteLabelName(Name name);

// visitors

void validatePoppyExpression(Expression* curr);

static void visitPoppyExpression(FunctionValidator* self,

Expression** currp) {

self->validatePoppyExpression(*currp);

}

static void visitPreBlock(FunctionValidator* self, Expression** currp) {

auto* curr = (*currp)->cast<Block>();

if (curr->name.is()) {

self->breakTypes.try_emplace(curr->name);

}

}

void visitBlock(Block* curr);

void validateNormalBlockElements(Block* curr);

void validatePoppyBlockElements(Block* curr);

static void visitPreLoop(FunctionValidator* self, Expression** currp) {

auto* curr = (*currp)->cast<Loop>();

if (curr->name.is()) {

self->breakTypes.try_emplace(curr->name);

}

}

void visitLoop(Loop* curr);

void visitIf(If* curr);

static void visitPreTry(FunctionValidator* self, Expression** currp) {

auto* curr = (*currp)->cast<Try>();

if (curr->name.is()) {

self->delegateTargetNames.insert(curr->name);

}

}

// We remove try's label before proceeding to verify catch bodies because the

// following is a validation failure:

// (try $l0

// (do ... )

// (catch $e

// (try

// (do ...)

// (delegate $l0) ;; validation failure

// )

// )

// )

// Unlike branches, if delegate's target 'catch' is located above the

// delegate, it is a validation failure.

static void visitPreCatch(FunctionValidator* self, Expression** currp) {

auto* curr = (*currp)->cast<Try>();

if (curr->name.is()) {

self->delegateTargetNames.erase(curr->name);

self->rethrowTargetNames.insert(curr->name);

}

}

// override scan to add a pre and a post check task to all nodes

static void scan(FunctionValidator* self, Expression** currp) {

auto* curr = *currp;

// Treat 'Try' specially because we need to run visitPreCatch between the

// try body and catch bodies

if (curr->is<Try>()) {

self->pushTask(doVisitTry, currp);

auto& list = curr->cast<Try>()->catchBodies;

for (int i = int(list.size()) - 1; i >= 0; i--) {

self->pushTask(scan, &list[i]);

}

self->pushTask(visitPreCatch, currp);

self->pushTask(scan, &curr->cast<Try>()->body);

self->pushTask(visitPreTry, currp);

return;

}

PostWalker<FunctionValidator>::scan(self, currp);

if (curr->is<Block>()) {

self->pushTask(visitPreBlock, currp);

}

if (curr->is<Loop>()) {

self->pushTask(visitPreLoop, currp);

}

if (auto* func = self->getFunction()) {

if (func->profile == IRProfile::Poppy) {

self->pushTask(visitPoppyExpression, currp);

}

}

// Also verify that only allowed expressions end up in the situation where

// the expression has type unreachable but there is no unreachable child.

// For example a Call with no unreachable child cannot be unreachable, but a

// Break can be.

if (curr->type == Type::unreachable) {

switch (curr->_id) {

case Expression::BreakId: {

// If there is a condition, that is already validated fully in

// visitBreak(). If there isn't a condition, then this is allowed to

// be unreachable even without an unreachable child. Either way, we

// can leave.

return;

}

case Expression::SwitchId:

case Expression::ReturnId:

case Expression::UnreachableId:

case Expression::ThrowId:

case Expression::RethrowId:

case Expression::ThrowRefId: {

// These can all be unreachable without an unreachable child.

return;

}

case Expression::CallId: {

if (curr->cast<Call>()->isReturn) {

return;

}

break;

}

case Expression::CallIndirectId: {

if (curr->cast<CallIndirect>()->isReturn) {

return;

}

break;

}

case Expression::CallRefId: {

if (curr->cast<CallRef>()->isReturn) {

return;

}

break;

}

default: {

break;

}

}

// If we reach here, then we must have an unreachable child.

bool hasUnreachableChild = false;

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

if (child->type == Type::unreachable) {

hasUnreachableChild = true;

break;

}

}

self->shouldBeTrue(hasUnreachableChild,

curr,

"unreachable instruction must have unreachable child");

}

}

void noteBreak(Name name, Expression* value, Expression* curr);

void noteBreak(Name name, Type valueType, Expression* curr);

void visitBreak(Break* curr);

void visitSwitch(Switch* curr);

void visitCall(Call* curr);

void visitCallIndirect(CallIndirect* curr);

void visitConst(Const* curr);

void visitLocalGet(LocalGet* curr);

void visitLocalSet(LocalSet* curr);

void visitGlobalGet(GlobalGet* curr);

void visitGlobalSet(GlobalSet* curr);

void visitLoad(Load* curr);

void visitStore(Store* curr);

void visitAtomicRMW(AtomicRMW* curr);

void visitAtomicCmpxchg(AtomicCmpxchg* curr);

void visitAtomicWait(AtomicWait* curr);

void visitAtomicNotify(AtomicNotify* curr);

void visitAtomicFence(AtomicFence* curr);

void visitPause(Pause* curr);

void visitSIMDExtract(SIMDExtract* curr);

void visitSIMDReplace(SIMDReplace* curr);

void visitSIMDShuffle(SIMDShuffle* curr);

void visitSIMDTernary(SIMDTernary* curr);

void visitSIMDShift(SIMDShift* curr);

void visitSIMDLoad(SIMDLoad* curr);

void visitSIMDLoadStoreLane(SIMDLoadStoreLane* curr);

void visitMemoryInit(MemoryInit* curr);

void visitDataDrop(DataDrop* curr);

void visitMemoryCopy(MemoryCopy* curr);

void visitMemoryFill(MemoryFill* curr);

void visitBinary(Binary* curr);

void visitWideIntAddSub(WideIntAddSub* curr);

void visitWideIntMul(WideIntMul* curr);

void visitUnary(Unary* curr);

void visitSelect(Select* curr);

void visitDrop(Drop* curr);

void visitReturn(Return* curr);

void visitMemorySize(MemorySize* curr);

void visitMemoryGrow(MemoryGrow* curr);

void visitRefNull(RefNull* curr);

void visitRefIsNull(RefIsNull* curr);

void visitRefAs(RefAs* curr);

void visitRefFunc(RefFunc* curr);

void visitRefEq(RefEq* curr);

void visitTableGet(TableGet* curr);

void visitTableSet(TableSet* curr);

void visitTableSize(TableSize* curr);

void visitTableGrow(TableGrow* curr);

void visitTableFill(TableFill* curr);

void visitTableCopy(TableCopy* curr);

void visitTableInit(TableInit* curr);

void visitElemDrop(ElemDrop* curr);

void noteDelegate(Name name, Expression* curr);

void noteRethrow(Name name, Expression* curr);

void visitTry(Try* curr);

void visitTryTable(TryTable* curr);

void visitThrow(Throw* curr);

void visitRethrow(Rethrow* curr);

void visitThrowRef(ThrowRef* curr);

void visitTupleMake(TupleMake* curr);

void visitTupleExtract(TupleExtract* curr);

void visitCallRef(CallRef* curr);

void visitRefI31(RefI31* curr);

void visitI31Get(I31Get* curr);

void visitRefTest(RefTest* curr);

void visitRefCast(RefCast* curr);

void visitRefGetDesc(RefGetDesc* curr);

void visitBrOn(BrOn* curr);

void visitStructNew(StructNew* curr);

void visitStructGet(StructGet* curr);

void visitStructSet(StructSet* curr);

void visitStructRMW(StructRMW* curr);

void visitStructCmpxchg(StructCmpxchg* curr);

void visitArrayNew(ArrayNew* curr);

template<typename ArrayNew> void visitArrayNewSegment(ArrayNew* curr);

void visitArrayNewData(ArrayNewData* curr);

void visitArrayNewElem(ArrayNewElem* curr);

void visitArrayNewFixed(ArrayNewFixed* curr);

void visitArrayGet(ArrayGet* curr);

void visitArraySet(ArraySet* curr);

void visitArrayLoad(ArrayLoad* curr);

void visitArrayStore(ArrayStore* curr);

void visitArrayLen(ArrayLen* curr);

void visitArrayCopy(ArrayCopy* curr);

void visitArrayFill(ArrayFill* curr);

template<typename ArrayInit> void visitArrayInit(ArrayInit* curr);

void visitArrayInitData(ArrayInitData* curr);

void visitArrayInitElem(ArrayInitElem* curr);

void visitArrayRMW(ArrayRMW* curr);

void visitArrayCmpxchg(ArrayCmpxchg* curr);

void visitStructWait(StructWait* curr);

void visitWaitqueueNew(WaitqueueNew* curr);

void visitWaitqueueNotify(WaitqueueNotify* curr);

void visitStringNew(StringNew* curr);

void visitStringConst(StringConst* curr);

void visitStringMeasure(StringMeasure* curr);

void visitStringEncode(StringEncode* curr);

void visitStringConcat(StringConcat* curr);

void visitStringEq(StringEq* curr);

void visitStringTest(StringTest* curr);

void visitStringWTF16Get(StringWTF16Get* curr);

void visitStringSliceWTF(StringSliceWTF* curr);

void visitContNew(ContNew* curr);

void visitContBind(ContBind* curr);

void visitSuspend(Suspend* curr);

void validateResumeHandlers(Expression* curr,

Type contResults,

const ArenaVector<Name>& tags,

const ArenaVector<Name>& labels);

void visitResume(Resume* curr);

void visitResumeThrow(ResumeThrow* curr);

void visitStackSwitch(StackSwitch* curr);

void visitFunction(Function* curr);

// helpers

std::ostream& getStream() { return info.getStream(getFunction()); }

template<typename T>

bool shouldBeTrue(bool result, T curr, const char* text) {

return info.shouldBeTrue(result, curr, text, getFunction());

}

template<typename T>

bool shouldBeFalse(bool result, T curr, const char* text) {

return info.shouldBeFalse(result, curr, text, getFunction());

}

template<typename T, typename S>

bool shouldBeEqual(S left, S right, T curr, const char* text) {

return info.shouldBeEqual(left, right, curr, text, getFunction());

}

template<typename T>

bool shouldBeEqualOrFirstIsUnreachable(Type left,

Type right,

T curr,

const char* text) {

return info.shouldBeEqualOrFirstIsUnreachable(

left, right, curr, text, getFunction());

}

template<typename T, typename S>

bool shouldBeUnequal(S left, S right, T curr, const char* text) {

return info.shouldBeUnequal(left, right, curr, text, getFunction());

}

void shouldBeIntOrUnreachable(Type ty, Expression* curr, const char* text) {

return info.shouldBeIntOrUnreachable(ty, curr, text, getFunction());

}

bool

shouldBeSubType(Type left, Type right, Expression* curr, const char* text) {

return info.shouldBeSubType(left, right, curr, text, getFunction());

}

bool shouldBeSubTypeIgnoringShared(Type left,

Type right,

Expression* curr,

const char* text) {

return info.shouldBeSubTypeIgnoringShared(left, right, curr, text);

}

void validateOffset(Address offset, Memory* mem, Expression* curr);

void validateAlignment(

size_t align, Type type, Index bytes, bool isAtomic, Expression* curr);

void validateMemBytes(uint8_t bytes, Type type, Expression* curr);

template<typename T> void validateReturnCall(T* curr) {

shouldBeTrue(!curr->isReturn || getModule()->features.hasTailCall(),

curr,

"return_call* requires tail calls [--enable-tail-call]");

}

// |printable| is the expression to print in case of an error. That may differ

// from |curr| which we are validating.

template<typename T>

void validateCallParamsAndResult(T* curr,

HeapType sigType,

Expression* printable) {

if (!shouldBeTrue(sigType.isSignature(),

printable,

"Heap type must be a signature type")) {

return;

}

auto sig = sigType.getSignature();

if (!shouldBeTrue(curr->operands.size() == sig.params.size(),

printable,

"call* param number must match")) {

return;

}

size_t i = 0;

for (const auto& param : sig.params) {

if (!shouldBeSubType(curr->operands[i]->type,

param,

printable,

"call param types must match") &&

!info.quiet) {

getStream() << "(on argument " << i << ")\n";

}

++i;

}

if (curr->isReturn) {

shouldBeEqual(curr->type,

Type(Type::unreachable),

printable,

"return_call* should have unreachable type");

auto* func = getFunction();

if (!shouldBeTrue(!!func, curr, "function not defined")) {

return;

}

shouldBeSubType(

sig.results,

func->getResults(),

printable,

"return_call* callee return type must match caller return type");

} else {

shouldBeEqualOrFirstIsUnreachable(

curr->type,

sig.results,

printable,

"call* type must match callee return type");

}

}

// In the common case, we use |curr| as |printable|.

template<typename T>

void validateCallParamsAndResult(T* curr, HeapType sigType) {

validateCallParamsAndResult(curr, sigType, curr);

}

if (!name.is()) {

return;

}

auto [_, inserted] = labelNames.insert(name);

shouldBeTrue(

inserted,

name,

"names in Binaryen IR must be unique - IR generators must ensure that");

if (curr->type == Type::unreachable) {

shouldBeTrue(StackUtils::mayBeUnreachable(curr),

curr,

"Only control flow structures and unreachable polymorphic"

" instructions may be unreachable in Poppy IR");

}

if (Properties::isControlFlowStructure(curr)) {

// Check that control flow children (except If conditions) are blocks

if (auto* if_ = curr->dynCast<If>()) {

shouldBeTrue(

if_->condition->is<Pop>(), curr, "Expected condition to be a Pop");

shouldBeTrue(if_->ifTrue->is<Block>(),

curr,

"Expected control flow child to be a block");

shouldBeTrue(!if_->ifFalse || if_->ifFalse->is<Block>(),

curr,

"Expected control flow child to be a block");

} else if (!curr->is<Block>()) {

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

shouldBeTrue(child->is<Block>(),

curr,

"Expected control flow child to be a block");

}

}

} else {

// Check that all children are Pops

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

shouldBeTrue(child->is<Pop>(), curr, "Unexpected non-Pop child");

}

}

auto feats = curr->type.getFeatures();

if (!shouldBeTrue(feats.isSubsetOf(getModule()->features),

curr,

"Block type requires additional features")) {

getStream() << getMissingFeaturesList(*getModule(), feats) << '\n';

}

// if we are break'ed to, then the value must be right for us

if (curr->name.is()) {

noteLabelName(curr->name);

auto iter = breakTypes.find(curr->name);

assert(iter != breakTypes.end()); // we set it ourselves

for (Type breakType : iter->second) {

if (breakType == Type::none && curr->type == Type::unreachable) {

// We allow empty breaks to unreachable blocks.

continue;

}

shouldBeSubType(breakType,

curr->type,

curr,

"break type must be a subtype of the target block type");

}

breakTypes.erase(iter);

// Check the tags of resume handlers that target this block as well.

if (auto it = resumeInfos.find(curr->name); it != resumeInfos.end()) {

for (const auto& [resume, tag_, contResult] : it->second) {

// TODO: Captured structured references are a C++20 extension.

const auto& tag = tag_;

// The tag's params must match the block results, except for the last

// result, which must be a continuation type whose parameters match the

// tag's results and whose results must be matched by the resumed

// continuation's results.

auto printHandler = [&]() {

if (!info.quiet) {

getStream() << "at (on " << tag->name << ' ' << curr->name << ")\n";

}

};

if (!shouldBeEqual(tag->params().size() + 1,

curr->type.size(),

resume,

"mismatched resume handler tag and label arities")) {

printHandler();

break;

}

for (Index i = 0; i < tag->params().size(); ++i) {

if (!shouldBeSubType(tag->params()[i],

curr->type[i],

resume,

"tag type does not match label type")) {

if (info.quiet) {

getStream() << "at index " << i << "\n";

}

break;

}

}

Type cont = curr->type[curr->type.size() - 1];

if (!shouldBeTrue(cont.isContinuation(),

resume,

"resume handler branches to label that does not take "

"a continuation")) {

printHandler();

break;

}

auto contSig = cont.getHeapType().getContinuation().type.getSignature();

if (!shouldBeSubType(contSig.params,

tag->results(),

resume,

"new continuation parameters do not match "

"expected suspension results")) {

printHandler();

}

if (!shouldBeSubType(contResult,

contSig.results,

resume,

"resumed continuation results do not match new "

"continuation results")) {

printHandler();

}

}

resumeInfos.erase(it);

}

}

auto* func = getFunction();

if (!shouldBeTrue(!!func, curr, "function not defined")) {

return;

}

switch (func->profile) {

case IRProfile::Normal:

validateNormalBlockElements(curr);

break;

case IRProfile::Poppy:

validatePoppyBlockElements(curr);

break;

}

if (curr->list.size() > 1) {

for (Index i = 0; i < curr->list.size() - 1; i++) {

if (!shouldBeTrue(

!curr->list[i]->type.isConcrete(),

curr,

"non-final block elements returning a value must be dropped") &&

!info.quiet) {

getStream() << "(on index " << i << ":\n"

<< curr->list[i] << "\n), type: " << curr->list[i]->type

<< "\n";

}

}

}

if (curr->list.size() > 0) {

auto backType = curr->list.back()->type;

if (!curr->type.isConcrete()) {

shouldBeFalse(backType.isConcrete(),

curr,

"if block is not returning a value, final element should "

"not flow out a value");

} else {

if (backType.isConcrete()) {

shouldBeSubType(

backType,

curr->type,

curr,

"block with value and last element with value must match types");

} else {

shouldBeUnequal(

backType,

Type(Type::none),

curr,

"block with value must not have last element that is none");

}

}

}

if (curr->type.isConcrete()) {

shouldBeTrue(

curr->list.size() > 0, curr, "block with a value must not be empty");

}

StackSignature blockSig;

for (size_t i = 0; i < curr->list.size(); ++i) {

Expression* expr = curr->list[i];

if (!shouldBeTrue(

!expr->is<Pop>(), expr, "Unexpected top-level pop in block")) {

return;

}

StackSignature sig(expr);

if (!shouldBeTrue(blockSig.composes(sig),

curr,

"block element has incompatible type") &&

!info.quiet) {

getStream() << "(on index " << i << ":\n"

<< expr << "\n), required: " << sig.params << ", available: ";

if (blockSig.kind == StackSignature::Polymorphic) {

getStream() << "polymorphic, ";

}

getStream() << blockSig.results << "\n";

return;

}

blockSig += sig;

}

if (curr->type == Type::unreachable) {

shouldBeTrue(blockSig.kind == StackSignature::Polymorphic,

curr,

"unreachable block should have unreachable element");

} else {

if (!shouldBeTrue(

StackSignature::isSubType(

blockSig,

StackSignature(Type::none, curr->type, StackSignature::Fixed)),

curr,

"block contents should satisfy block type") &&

!info.quiet) {

getStream() << "contents: " << blockSig.results

<< (blockSig.kind == StackSignature::Polymorphic

? " [polymorphic]"

: "")

<< "\n"

<< "expected: " << curr->type << "\n";

}

}

if (curr->name.is()) {

noteLabelName(curr->name);

auto iter = breakTypes.find(curr->name);

assert(iter != breakTypes.end()); // we set it ourselves

for (Type breakType : iter->second) {

shouldBeEqual(breakType,

Type(Type::none),

curr,

"breaks to a loop cannot pass a value");

}

breakTypes.erase(iter);

}

if (curr->type == Type::none) {

shouldBeFalse(curr->body->type.isConcrete(),

curr,

"bad body for a loop that has no value");

}

// When there are multiple instructions within a loop, they are wrapped in a

// Block internally, so visitBlock can take care of verification. Here we

// check cases when there is only one instruction in a Loop.

if (!curr->body->is<Block>()) {

if (!curr->type.isConcrete()) {

shouldBeFalse(curr->body->type.isConcrete(),

curr,

"if loop is not returning a value, final element should "

"not flow out a value");

} else {

shouldBeSubType(curr->body->type,

curr->type,

curr,

"loop with value and body must match types");

}

}

shouldBeTrue(curr->condition->type == Type::unreachable ||

curr->condition->type == Type::i32,

curr,

"if condition must be valid");

if (!curr->ifFalse) {

shouldBeFalse(curr->ifTrue->type.isConcrete(),

curr,

"if without else must not return a value in body");

if (curr->condition->type != Type::unreachable) {

shouldBeEqual(curr->type,

Type(Type::none),

curr,

"if without else and reachable condition must be none");

}

} else {

if (curr->type != Type::unreachable) {

shouldBeSubType(curr->ifTrue->type,

curr->type,

curr,

"returning if-else's true must have right type");

shouldBeSubType(curr->ifFalse->type,