/*

* Copyright 2017 WebAssembly Community Group participants

*

* Licensed under the Apache License, Version 2.0 (the "License");

* you may not use this file except in compliance with the License.

* You may obtain a copy of the License at

*

* http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

#include <mutex>

#include <set>

#include <sstream>

#include <unordered_set>

#include "ir/branch-utils.h"

#include "ir/features.h"

#include "ir/global-utils.h"

#include "ir/module-utils.h"

#include "ir/utils.h"

#include "support/colors.h"

#include "wasm-printing.h"

#include "wasm-validator.h"

#include "wasm.h"

namespace wasm {

// Print anything that can be streamed to an ostream

template<typename T,

typename std::enable_if<!std::is_base_of<

Expression,

typename std::remove_pointer<T>::type>::value>::type* = nullptr>

inline std::ostream& printModuleComponent(T curr, std::ostream& stream) {

stream << curr << std::endl;

return stream;

}

// Extra overload for Expressions, to print type info too

inline std::ostream& printModuleComponent(Expression* curr,

std::ostream& stream) {

WasmPrinter::printExpression(curr, stream, false, true) << std::endl;

return stream;

}

// For parallel validation, we have a helper struct for coordination

struct ValidationInfo {

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() { 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] = 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);

}

std::ostream& 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

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 result;

}

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 result;

}

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, typename S>

bool shouldBeEqualOrFirstIsUnreachable(

S left, S 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) {

switch (ty.getSingle()) {

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;

}

// Type 'left' should be a subtype of 'right', or unreachable.

bool shouldBeSubTypeOrFirstIsUnreachable(Type left,

Type right,

Expression* curr,

const char* text,

Function* func = nullptr) {

if (left == Type::unreachable) {

return true;

}

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

}

};

struct FunctionValidator : public WalkerPass<PostWalker<FunctionValidator>> {

bool isFunctionParallel() override { return true; }

Pass* create() override { return new FunctionValidator(&info); }

bool modifiesBinaryenIR() override { return false; }

ValidationInfo& info;

FunctionValidator(ValidationInfo* info) : info(*info) {}

struct BreakInfo {

enum { UnsetArity = Index(-1), PoisonArity = Index(-2) };

Type type;

Index arity;

BreakInfo() : arity(UnsetArity) {}

BreakInfo(Type type, Index arity) : type(type), arity(arity) {}

bool hasBeenSet() {

// Compare to the impossible value.

return arity != UnsetArity;

}

};

std::unordered_map<Name, BreakInfo> breakInfos;

std::set<Type> returnTypes; // types used in returns

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

// ensure that

std::unordered_set<Name> labelNames;

void noteLabelName(Name name);

public:

// visitors

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

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

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

self->breakInfos[curr->name];

}

}

void visitBlock(Block* curr);

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

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

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

self->breakInfos[curr->name];

}

}

void visitLoop(Loop* curr);

void visitIf(If* curr);

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

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

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

auto* curr = *currp;

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

self->pushTask(visitPreBlock, currp);

}

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

self->pushTask(visitPreLoop, currp);

}

}

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 visitSIMDExtract(SIMDExtract* curr);

void visitSIMDReplace(SIMDReplace* curr);

void visitSIMDShuffle(SIMDShuffle* curr);

void visitSIMDTernary(SIMDTernary* curr);

void visitSIMDShift(SIMDShift* curr);

void visitSIMDLoad(SIMDLoad* curr);

void visitMemoryInit(MemoryInit* curr);

void visitDataDrop(DataDrop* curr);

void visitMemoryCopy(MemoryCopy* curr);

void visitMemoryFill(MemoryFill* curr);

void visitBinary(Binary* curr);

void visitUnary(Unary* curr);

void visitSelect(Select* curr);

void visitDrop(Drop* curr);

void visitReturn(Return* curr);

void visitHost(Host* curr);

void visitRefIsNull(RefIsNull* curr);

void visitRefFunc(RefFunc* curr);

void visitTry(Try* curr);

void visitThrow(Throw* curr);

void visitRethrow(Rethrow* curr);

void visitBrOnExn(BrOnExn* curr);

void visitTupleMake(TupleMake* curr);

void visitTupleExtract(TupleExtract* curr);

void visitFunction(Function* curr);

// helpers

private:

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, typename S>

bool

shouldBeEqualOrFirstIsUnreachable(S left, S 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 shouldBeSubTypeOrFirstIsUnreachable(Type left,

Type right,

Expression* curr,

const char* text) {

return info.shouldBeSubTypeOrFirstIsUnreachable(

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

}

void validateAlignment(

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

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

};

void FunctionValidator::noteLabelName(Name name) {

if (!name.is()) {

return;

}

bool inserted;

std::tie(std::ignore, inserted) = labelNames.insert(name);

shouldBeTrue(

inserted,

name,

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

}

void FunctionValidator::visitBlock(Block* curr) {

if (!getModule()->features.hasMultivalue()) {

shouldBeTrue(!curr->type.isMulti(),

curr,

"Multivalue block type (multivalue is not enabled)");

}

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

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

noteLabelName(curr->name);

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

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

auto& info = iter->second;

if (info.hasBeenSet()) {

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

shouldBeTrue(info.arity != 0,

curr,

"break arities must be > 0 if block has a value");

} else {

shouldBeTrue(info.arity == 0,

curr,

"break arities must be 0 if block has no value");

}

// none or unreachable means a poison value that we should ignore - if

// consumed, it will error

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

shouldBeSubType(

info.type,

curr->type,

curr,

"block+breaks must have right type if breaks return a value");

}

if (curr->type.isConcrete() && info.arity &&

info.type != Type::unreachable) {

shouldBeSubType(

info.type,

curr->type,

curr,

"block+breaks must have right type if breaks have arity");

}

shouldBeTrue(

info.arity != BreakInfo::PoisonArity, curr, "break arities must match");

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

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

if (last == Type::none) {

shouldBeTrue(info.arity == Index(0),

curr,

"if block ends with a none, breaks cannot send a value "

"of any type");

}

}

}

breakInfos.erase(iter);

}

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 drop()ed "

"(binaryen's autodrop option might help you)") &&

!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");

}

}

void FunctionValidator::visitLoop(Loop* curr) {

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

noteLabelName(curr->name);

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

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

auto& info = iter->second;

if (info.hasBeenSet()) {

shouldBeEqual(

info.arity, Index(0), curr, "breaks to a loop cannot pass a value");

}

breakInfos.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 {

shouldBeSubTypeOrFirstIsUnreachable(

curr->body->type,

curr->type,

curr,

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

}

}

}

void FunctionValidator::visitIf(If* curr) {

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) {

shouldBeSubTypeOrFirstIsUnreachable(

curr->ifTrue->type,

curr->type,

curr,

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

shouldBeSubTypeOrFirstIsUnreachable(

curr->ifFalse->type,

curr->type,

curr,

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

} else {

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

shouldBeEqual(curr->ifTrue->type,

Type(Type::unreachable),

curr,

"unreachable if-else must have unreachable true");

shouldBeEqual(curr->ifFalse->type,

Type(Type::unreachable),

curr,

"unreachable if-else must have unreachable false");

}

}

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

shouldBeSubType(curr->ifTrue->type,

curr->type,

curr,

"if type must match concrete ifTrue");

}

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

shouldBeSubType(curr->ifFalse->type,

curr->type,

curr,

"if type must match concrete ifFalse");

}

}

}

void FunctionValidator::noteBreak(Name name,

Expression* value,

Expression* curr) {

if (value) {

shouldBeUnequal(

value->type, Type(Type::none), curr, "breaks must have a valid value");

}

noteBreak(name, value ? value->type : Type::none, curr);

}

void FunctionValidator::noteBreak(Name name, Type valueType, Expression* curr) {

Index arity = 0;

if (valueType != Type::none) {

arity = 1;

}

auto iter = breakInfos.find(name);

if (!shouldBeTrue(

iter != breakInfos.end(), curr, "all break targets must be valid")) {

return;

}

auto& info = iter->second;

if (!info.hasBeenSet()) {

info = BreakInfo(valueType, arity);

} else {

info.type = Type::getLeastUpperBound(info.type, valueType);

if (arity != info.arity) {

info.arity = BreakInfo::PoisonArity;

}

}

}

void FunctionValidator::visitBreak(Break* curr) {

noteBreak(curr->name, curr->value, curr);

if (curr->value) {

shouldBeTrue(curr->value->type != Type::none,

curr,

"break value must not have none type");

}

if (curr->condition) {

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

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

curr,

"break condition must be i32");

}

}

void FunctionValidator::visitSwitch(Switch* curr) {

for (auto& target : curr->targets) {

noteBreak(target, curr->value, curr);

}

noteBreak(curr->default_, curr->value, curr);

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

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

curr,

"br_table condition must be i32");

}

void FunctionValidator::visitCall(Call* curr) {

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

curr,

"return_call requires tail calls to be enabled");

if (!info.validateGlobally) {

return;

}

auto* target = getModule()->getFunctionOrNull(curr->target);

if (!shouldBeTrue(!!target, curr, "call target must exist")) {

return;

}

const std::vector<Type> params = target->sig.params.expand();

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

curr,

"call param number must match")) {

return;

}

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

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

params[i],

curr,

"call param types must match") &&

!info.quiet) {

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

}

}

if (curr->isReturn) {

shouldBeEqual(curr->type,

Type(Type::unreachable),

curr,

"return_call should have unreachable type");

shouldBeEqual(

getFunction()->sig.results,

target->sig.results,

curr,

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

} else {

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

bool hasUnreachableOperand = std::any_of(

curr->operands.begin(), curr->operands.end(), [](Expression* op) {

return op->type == Type::unreachable;

});

shouldBeTrue(

hasUnreachableOperand,

curr,

"calls may only be unreachable if they have unreachable operands");

} else {

shouldBeEqual(curr->type,

target->sig.results,

curr,

"call type must match callee return type");

}

}

}

void FunctionValidator::visitCallIndirect(CallIndirect* curr) {

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

curr,

"return_call_indirect requires tail calls to be enabled");

if (!info.validateGlobally) {

return;

}

const std::vector<Type>& params = curr->sig.params.expand();

shouldBeEqualOrFirstIsUnreachable(curr->target->type,

Type(Type::i32),

curr,

"indirect call target must be an i32");

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

curr,

"call param number must match")) {

return;

}

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

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

params[i],

curr,

"call param types must match") &&

!info.quiet) {

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

}

}

if (curr->isReturn) {

shouldBeEqual(curr->type,

Type(Type::unreachable),

curr,

"return_call_indirect should have unreachable type");

shouldBeEqual(

getFunction()->sig.results,

curr->sig.results,

curr,

"return_call_indirect callee return type must match caller return type");

} else {

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

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

bool hasUnreachableOperand = std::any_of(

curr->operands.begin(), curr->operands.end(), [](Expression* op) {

return op->type == Type::unreachable;

});

shouldBeTrue(hasUnreachableOperand,

curr,

"call_indirects may only be unreachable if they have "

"unreachable operands");

}

} else {

shouldBeEqual(curr->type,

curr->sig.results,

curr,

"call_indirect type must match callee return type");

}

}

}

void FunctionValidator::visitConst(Const* curr) {

shouldBeTrue(curr->type.getFeatures() <= getModule()->features,

curr,

"all used features should be allowed");

}

void FunctionValidator::visitLocalGet(LocalGet* curr) {

shouldBeTrue(curr->type.isConcrete(),

curr,

"local.get must have a valid type - check what you provided "

"when you constructed the node");

if (shouldBeTrue(curr->index < getFunction()->getNumLocals(),

curr,

"local.get index must be small enough")) {

shouldBeTrue(curr->type == getFunction()->getLocalType(curr->index),

curr,

"local.get must have proper type");

}

}

void FunctionValidator::visitLocalSet(LocalSet* curr) {

if (shouldBeTrue(curr->index < getFunction()->getNumLocals(),

curr,

"local.set index must be small enough")) {

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

if (curr->type != Type::none) { // tee is ok anyhow

shouldBeEqual(getFunction()->getLocalType(curr->index),

curr->type,

curr,

"local.set type must be correct");

}

shouldBeSubType(curr->value->type,

getFunction()->getLocalType(curr->index),

curr,

"local.set's value type must be correct");

}

}

}

void FunctionValidator::visitGlobalGet(GlobalGet* curr) {

if (!info.validateGlobally) {

return;

}

shouldBeTrue(getModule()->getGlobalOrNull(curr->name),

curr,

"global.get name must be valid");

}

void FunctionValidator::visitGlobalSet(GlobalSet* curr) {

if (!info.validateGlobally) {

return;

}

auto* global = getModule()->getGlobalOrNull(curr->name);

if (shouldBeTrue(global,

curr,

"global.set name must be valid (and not an import; imports "

"can't be modified)")) {

shouldBeTrue(global->mutable_, curr, "global.set global must be mutable");

shouldBeSubTypeOrFirstIsUnreachable(

curr->value->type,

global->type,

curr,

"global.set value must have right type");

}

}

void FunctionValidator::visitLoad(Load* curr) {

shouldBeTrue(

getModule()->memory.exists, curr, "Memory operations require a memory");

if (curr->isAtomic) {

shouldBeTrue(getModule()->features.hasAtomics(),

curr,

"Atomic operation (atomics are disabled)");

shouldBeTrue(curr->type == Type::i32 || curr->type == Type::i64 ||

curr->type == Type::unreachable,

curr,

"Atomic load should be i32 or i64");

}

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

shouldBeTrue(getModule()->features.hasSIMD(),

curr,

"SIMD operation (SIMD is disabled)");

}

shouldBeFalse(curr->isAtomic && !getModule()->memory.shared,

curr,

"Atomic operation with non-shared memory");

validateMemBytes(curr->bytes, curr->type, curr);

validateAlignment(curr->align, curr->type, curr->bytes, curr->isAtomic, curr);

shouldBeEqualOrFirstIsUnreachable(

curr->ptr->type, Type(Type::i32), curr, "load pointer type must be i32");

if (curr->isAtomic) {

shouldBeFalse(curr->signed_, curr, "atomic loads must be unsigned");

shouldBeIntOrUnreachable(

curr->type, curr, "atomic loads must be of integers");

}

}

void FunctionValidator::visitStore(Store* curr) {

shouldBeTrue(

getModule()->memory.exists, curr, "Memory operations require a memory");

if (curr->isAtomic) {

shouldBeTrue(getModule()->features.hasAtomics(),

curr,

"Atomic operation (atomics are disabled)");

shouldBeTrue(curr->valueType == Type::i32 || curr->valueType == Type::i64 ||

curr->valueType == Type::unreachable,

curr,

"Atomic store should be i32 or i64");

}

if (curr->valueType == Type::v128) {

shouldBeTrue(getModule()->features.hasSIMD(),

curr,

"SIMD operation (SIMD is disabled)");

}

shouldBeFalse(curr->isAtomic && !getModule()->memory.shared,

curr,

"Atomic operation with non-shared memory");

validateMemBytes(curr->bytes, curr->valueType, curr);

validateAlignment(

curr->align, curr->valueType, curr->bytes, curr->isAtomic, curr);

shouldBeEqualOrFirstIsUnreachable(

curr->ptr->type, Type(Type::i32), curr, "store pointer type must be i32");

shouldBeUnequal(curr->value->type,

Type(Type::none),

curr,

"store value type must not be none");

shouldBeEqualOrFirstIsUnreachable(

curr->value->type, curr->valueType, curr, "store value type must match");

if (curr->isAtomic) {

shouldBeIntOrUnreachable(

curr->valueType, curr, "atomic stores must be of integers");

}

}

void FunctionValidator::visitAtomicRMW(AtomicRMW* curr) {

shouldBeTrue(

getModule()->memory.exists, curr, "Memory operations require a memory");

shouldBeTrue(getModule()->features.hasAtomics(),

curr,

"Atomic operation (atomics are disabled)");

shouldBeFalse(!getModule()->memory.shared,

curr,

"Atomic operation with non-shared memory");

validateMemBytes(curr->bytes, curr->type, curr);

shouldBeEqualOrFirstIsUnreachable(curr->ptr->type,

Type(Type::i32),

curr,

"AtomicRMW pointer type must be i32");

shouldBeEqualOrFirstIsUnreachable(curr->type,

curr->value->type,

curr,

"AtomicRMW result type must match operand");

shouldBeIntOrUnreachable(

curr->type, curr, "Atomic operations are only valid on int types");

}

void FunctionValidator::visitAtomicCmpxchg(AtomicCmpxchg* curr) {

shouldBeTrue(

getModule()->memory.exists, curr, "Memory operations require a memory");

shouldBeTrue(getModule()->features.hasAtomics(),

curr,

"Atomic operation (atomics are disabled)");

shouldBeFalse(!getModule()->memory.shared,

curr,

"Atomic operation with non-shared memory");

validateMemBytes(curr->bytes, curr->type, curr);

shouldBeEqualOrFirstIsUnreachable(

curr->ptr->type, Type(Type::i32), curr, "cmpxchg pointer type must be i32");

if (curr->expected->type != Type::unreachable &&

curr->replacement->type != Type::unreachable) {

shouldBeEqual(curr->expected->type,

curr->replacement->type,

curr,

"cmpxchg operand types must match");

}

shouldBeEqualOrFirstIsUnreachable(curr->type,

curr->expected->type,

curr,

"Cmpxchg result type must match expected");

shouldBeEqualOrFirstIsUnreachable(

curr->type,

curr->replacement->type,

curr,

"Cmpxchg result type must match replacement");

shouldBeIntOrUnreachable(curr->expected->type,

curr,

"Atomic operations are only valid on int types");

}

void FunctionValidator::visitAtomicWait(AtomicWait* curr) {

shouldBeTrue(

getModule()->memory.exists, curr, "Memory operations require a memory");

shouldBeTrue(getModule()->features.hasAtomics(),

curr,

"Atomic operation (atomics are disabled)");

shouldBeFalse(!getModule()->memory.shared,

curr,

"Atomic operation with non-shared memory");

shouldBeEqualOrFirstIsUnreachable(

curr->type, Type(Type::i32), curr, "AtomicWait must have type i32");

shouldBeEqualOrFirstIsUnreachable(curr->ptr->type,

Type(Type::i32),

curr,

"AtomicWait pointer type must be i32");

shouldBeIntOrUnreachable(

curr->expected->type, curr, "AtomicWait expected type must be int");

shouldBeEqualOrFirstIsUnreachable(

curr->expected->type,

curr->expectedType,

curr,

"AtomicWait expected type must match operand");

shouldBeEqualOrFirstIsUnreachable(curr->timeout->type,

Type(Type::i64),

curr,

"AtomicWait timeout type must be i64");

}

void FunctionValidator::visitAtomicNotify(AtomicNotify* curr) {

shouldBeTrue(

getModule()->memory.exists, curr, "Memory operations require a memory");

shouldBeTrue(getModule()->features.hasAtomics(),

curr,

"Atomic operation (atomics are disabled)");

shouldBeFalse(!getModule()->memory.shared,

curr,

"Atomic operation with non-shared memory");

shouldBeEqualOrFirstIsUnreachable(

curr->type, Type(Type::i32), curr, "AtomicNotify must have type i32");

shouldBeEqualOrFirstIsUnreachable(curr->ptr->type,

Type(Type::i32),

curr,

"AtomicNotify pointer type must be i32");

shouldBeEqualOrFirstIsUnreachable(

curr->notifyCount->type,

Type(Type::i32),

curr,

"AtomicNotify notifyCount type must be i32");

}

void FunctionValidator::visitAtomicFence(AtomicFence* curr) {

shouldBeTrue(

getModule()->memory.exists, curr, "Memory operations require a memory");

shouldBeTrue(getModule()->features.hasAtomics(),

curr,

"Atomic operation (atomics are disabled)");

shouldBeFalse(!getModule()->memory.shared,

curr,

"Atomic operation with non-shared memory");

shouldBeTrue(curr->order == 0,

curr,

"Currently only sequentially consistent atomics are supported, "

"so AtomicFence's order should be 0");

}

void FunctionValidator::visitSIMDExtract(SIMDExtract* curr) {

shouldBeTrue(