/*

* Copyright 2016 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.

*/

//===============================

// Binaryen C API implementation

//===============================

#include <mutex>

#include "binaryen-c.h"

#include "pass.h"

#include "wasm.h"

#include "wasm-binary.h"

#include "wasm-builder.h"

#include "wasm-interpreter.h"

#include "wasm-printing.h"

#include "wasm-s-parser.h"

#include "wasm-validator.h"

#include "wasm2js.h"

#include "cfg/Relooper.h"

#include "ir/function-type-utils.h"

#include "ir/utils.h"

#include "shell-interface.h"

using namespace wasm;

// Literal utilities

static_assert(sizeof(BinaryenLiteral) == sizeof(Literal), "Binaryen C API literal must match wasm.h");

BinaryenLiteral toBinaryenLiteral(Literal x) {

BinaryenLiteral ret;

ret.type = x.type;

switch (x.type) {

case Type::i32: ret.i32 = x.geti32(); break;

case Type::i64: ret.i64 = x.geti64(); break;

case Type::f32: ret.i32 = x.reinterpreti32(); break;

case Type::f64: ret.i64 = x.reinterpreti64(); break;

default: abort();

}

return ret;

}

Literal fromBinaryenLiteral(BinaryenLiteral x) {

switch (x.type) {

case Type::i32: return Literal(x.i32);

case Type::i64: return Literal(x.i64);

case Type::f32: return Literal(x.i32).castToF32();

case Type::f64: return Literal(x.i64).castToF64();

default: abort();

}

}

// Mutexes (global for now; in theory if multiple modules

// are used at once this should be optimized to be per-

// module, but likely it doesn't matter)

static std::mutex BinaryenFunctionMutex;

static std::mutex BinaryenFunctionTypeMutex;

// Optimization options

static PassOptions globalPassOptions = PassOptions::getWithDefaultOptimizationOptions();

// Tracing support

static int tracing = 0;

void traceNameOrNULL(const char* name) {

if (name) std::cout << "\"" << name << "\"";

else std::cout << "NULL";

}

std::map<BinaryenFunctionTypeRef, size_t> functionTypes;

std::map<BinaryenExpressionRef, size_t> expressions;

std::map<BinaryenFunctionRef, size_t> functions;

std::map<BinaryenGlobalRef, size_t> globals;

std::map<BinaryenExportRef, size_t> exports;

std::map<RelooperBlockRef, size_t> relooperBlocks;

size_t noteExpression(BinaryenExpressionRef expression) {

auto id = expressions.size();

assert(expressions.find(expression) == expressions.end());

expressions[expression] = id;

return id;

}

extern "C" {

//

// ========== Module Creation ==========

//

// Core types

BinaryenType BinaryenTypeNone(void) { return none; }

BinaryenType BinaryenTypeInt32(void) { return i32; }

BinaryenType BinaryenTypeInt64(void) { return i64; }

BinaryenType BinaryenTypeFloat32(void) { return f32; }

BinaryenType BinaryenTypeFloat64(void) { return f64; }

BinaryenType BinaryenTypeUnreachable(void) { return unreachable; }

BinaryenType BinaryenTypeAuto(void) { return uint32_t(-1); }

WASM_DEPRECATED BinaryenType BinaryenNone(void) { return none; }

WASM_DEPRECATED BinaryenType BinaryenInt32(void) { return i32; }

WASM_DEPRECATED BinaryenType BinaryenInt64(void) { return i64; }

WASM_DEPRECATED BinaryenType BinaryenFloat32(void) { return f32; }

WASM_DEPRECATED BinaryenType BinaryenFloat64(void) { return f64; }

WASM_DEPRECATED BinaryenType BinaryenUndefined(void) { return uint32_t(-1); }

// Expression ids

BinaryenExpressionId BinaryenInvalidId(void) { return Expression::Id::InvalidId; }

BinaryenExpressionId BinaryenBlockId(void) { return Expression::Id::BlockId; }

BinaryenExpressionId BinaryenIfId(void) { return Expression::Id::IfId; }

BinaryenExpressionId BinaryenLoopId(void) { return Expression::Id::LoopId; }

BinaryenExpressionId BinaryenBreakId(void) { return Expression::Id::BreakId; }

BinaryenExpressionId BinaryenSwitchId(void) { return Expression::Id::SwitchId; }

BinaryenExpressionId BinaryenCallId(void) { return Expression::Id::CallId; }

BinaryenExpressionId BinaryenCallIndirectId(void) { return Expression::Id::CallIndirectId; }

BinaryenExpressionId BinaryenGetLocalId(void) { return Expression::Id::GetLocalId; }

BinaryenExpressionId BinaryenSetLocalId(void) { return Expression::Id::SetLocalId; }

BinaryenExpressionId BinaryenGetGlobalId(void) { return Expression::Id::GetGlobalId; }

BinaryenExpressionId BinaryenSetGlobalId(void) { return Expression::Id::SetGlobalId; }

BinaryenExpressionId BinaryenLoadId(void) { return Expression::Id::LoadId; }

BinaryenExpressionId BinaryenStoreId(void) { return Expression::Id::StoreId; }

BinaryenExpressionId BinaryenConstId(void) { return Expression::Id::ConstId; }

BinaryenExpressionId BinaryenUnaryId(void) { return Expression::Id::UnaryId; }

BinaryenExpressionId BinaryenBinaryId(void) { return Expression::Id::BinaryId; }

BinaryenExpressionId BinaryenSelectId(void) { return Expression::Id::SelectId; }

BinaryenExpressionId BinaryenDropId(void) { return Expression::Id::DropId; }

BinaryenExpressionId BinaryenReturnId(void) { return Expression::Id::ReturnId; }

BinaryenExpressionId BinaryenHostId(void) { return Expression::Id::HostId; }

BinaryenExpressionId BinaryenNopId(void) { return Expression::Id::NopId; }

BinaryenExpressionId BinaryenUnreachableId(void) { return Expression::Id::UnreachableId; }

BinaryenExpressionId BinaryenAtomicCmpxchgId(void) { return Expression::Id::AtomicCmpxchgId; }

BinaryenExpressionId BinaryenAtomicRMWId(void) { return Expression::Id::AtomicRMWId; }

BinaryenExpressionId BinaryenAtomicWaitId(void) { return Expression::Id::AtomicWaitId; }

BinaryenExpressionId BinaryenAtomicWakeId(void) { return Expression::Id::AtomicWakeId; }

// External kinds

BinaryenExternalKind BinaryenExternalFunction(void) { return static_cast<BinaryenExternalKind>(ExternalKind::Function); }

BinaryenExternalKind BinaryenExternalTable(void) { return static_cast<BinaryenExternalKind>(ExternalKind::Table); }

BinaryenExternalKind BinaryenExternalMemory(void) { return static_cast<BinaryenExternalKind>(ExternalKind::Memory); }

BinaryenExternalKind BinaryenExternalGlobal(void) { return static_cast<BinaryenExternalKind>(ExternalKind::Global); }

// Modules

BinaryenModuleRef BinaryenModuleCreate(void) {

if (tracing) {

std::cout << " the_module = BinaryenModuleCreate();\n";

std::cout << " expressions[size_t(NULL)] = BinaryenExpressionRef(NULL);\n";

expressions[NULL] = 0;

}

return new Module();

}

void BinaryenModuleDispose(BinaryenModuleRef module) {

if (tracing) {

std::cout << " BinaryenModuleDispose(the_module);\n";

std::cout << " functionTypes.clear();\n";

std::cout << " expressions.clear();\n";

std::cout << " functions.clear();\n";

std::cout << " globals.clear();\n";

std::cout << " exports.clear();\n";

std::cout << " relooperBlocks.clear();\n";

functionTypes.clear();

expressions.clear();

functions.clear();

globals.clear();

exports.clear();

relooperBlocks.clear();

}

delete (Module*)module;

}

// Function types

BinaryenFunctionTypeRef BinaryenAddFunctionType(BinaryenModuleRef module, const char* name, BinaryenType result, BinaryenType* paramTypes, BinaryenIndex numParams) {

auto* wasm = (Module*)module;

auto* ret = new FunctionType;

if (name) ret->name = name;

else ret->name = Name::fromInt(wasm->functionTypes.size());

ret->result = Type(result);

for (BinaryenIndex i = 0; i < numParams; i++) {

ret->params.push_back(Type(paramTypes[i]));

}

// Lock. This can be called from multiple threads at once, and is a

// point where they all access and modify the module.

{

std::lock_guard<std::mutex> lock(BinaryenFunctionTypeMutex);

wasm->addFunctionType(ret);

}

if (tracing) {

std::cout << " {\n";

std::cout << " BinaryenType paramTypes[] = { ";

for (BinaryenIndex i = 0; i < numParams; i++) {

if (i > 0) std::cout << ", ";

std::cout << paramTypes[i];

}

if (numParams == 0) std::cout << "0"; // ensure the array is not empty, otherwise a compiler error on VS

std::cout << " };\n";

size_t id = functionTypes.size();

std::cout << " functionTypes[" << id << "] = BinaryenAddFunctionType(the_module, ";

functionTypes[ret] = id;

traceNameOrNULL(name);

std::cout << ", " << result << ", paramTypes, " << numParams << ");\n";

std::cout << " }\n";

}

return ret;

}

void BinaryenRemoveFunctionType(BinaryenModuleRef module, const char* name) {

if (tracing) {

std::cout << " BinaryenRemoveFunctionType(the_module, ";

traceNameOrNULL(name);

std::cout << ");\n";

}

auto* wasm = (Module*)module;

assert(name != NULL);

// Lock. This can be called from multiple threads at once, and is a

// point where they all access and modify the module.

{

std::lock_guard<std::mutex> lock(BinaryenFunctionTypeMutex);

wasm->removeFunctionType(name);

}

}

BinaryenLiteral BinaryenLiteralInt32(int32_t x) { return toBinaryenLiteral(Literal(x)); }

BinaryenLiteral BinaryenLiteralInt64(int64_t x) { return toBinaryenLiteral(Literal(x)); }

BinaryenLiteral BinaryenLiteralFloat32(float x) { return toBinaryenLiteral(Literal(x)); }

BinaryenLiteral BinaryenLiteralFloat64(double x) { return toBinaryenLiteral(Literal(x)); }

BinaryenLiteral BinaryenLiteralFloat32Bits(int32_t x) { return toBinaryenLiteral(Literal(x).castToF32()); }

BinaryenLiteral BinaryenLiteralFloat64Bits(int64_t x) { return toBinaryenLiteral(Literal(x).castToF64()); }

// Expressions

BinaryenOp BinaryenClzInt32(void) { return ClzInt32; }

BinaryenOp BinaryenCtzInt32(void) { return CtzInt32; }

BinaryenOp BinaryenPopcntInt32(void) { return PopcntInt32; }

BinaryenOp BinaryenNegFloat32(void) { return NegFloat32; }

BinaryenOp BinaryenAbsFloat32(void) { return AbsFloat32; }

BinaryenOp BinaryenCeilFloat32(void) { return CeilFloat32; }

BinaryenOp BinaryenFloorFloat32(void) { return FloorFloat32; }

BinaryenOp BinaryenTruncFloat32(void) { return TruncFloat32; }

BinaryenOp BinaryenNearestFloat32(void) { return NearestFloat32; }

BinaryenOp BinaryenSqrtFloat32(void) { return SqrtFloat32; }

BinaryenOp BinaryenEqZInt32(void) { return EqZInt32; }

BinaryenOp BinaryenClzInt64(void) { return ClzInt64; }

BinaryenOp BinaryenCtzInt64(void) { return CtzInt64; }

BinaryenOp BinaryenPopcntInt64(void) { return PopcntInt64; }

BinaryenOp BinaryenNegFloat64(void) { return NegFloat64; }

BinaryenOp BinaryenAbsFloat64(void) { return AbsFloat64; }

BinaryenOp BinaryenCeilFloat64(void) { return CeilFloat64; }

BinaryenOp BinaryenFloorFloat64(void) { return FloorFloat64; }

BinaryenOp BinaryenTruncFloat64(void) { return TruncFloat64; }

BinaryenOp BinaryenNearestFloat64(void) { return NearestFloat64; }

BinaryenOp BinaryenSqrtFloat64(void) { return SqrtFloat64; }

BinaryenOp BinaryenEqZInt64(void) { return EqZInt64; }

BinaryenOp BinaryenExtendSInt32(void) { return ExtendSInt32; }

BinaryenOp BinaryenExtendUInt32(void) { return ExtendUInt32; }

BinaryenOp BinaryenWrapInt64(void) { return WrapInt64; }

BinaryenOp BinaryenTruncSFloat32ToInt32(void) { return TruncSFloat32ToInt32; }

BinaryenOp BinaryenTruncSFloat32ToInt64(void) { return TruncSFloat32ToInt64; }

BinaryenOp BinaryenTruncUFloat32ToInt32(void) { return TruncUFloat32ToInt32; }

BinaryenOp BinaryenTruncUFloat32ToInt64(void) { return TruncUFloat32ToInt64; }

BinaryenOp BinaryenTruncSFloat64ToInt32(void) { return TruncSFloat64ToInt32; }

BinaryenOp BinaryenTruncSFloat64ToInt64(void) { return TruncSFloat64ToInt64; }

BinaryenOp BinaryenTruncUFloat64ToInt32(void) { return TruncUFloat64ToInt32; }

BinaryenOp BinaryenTruncUFloat64ToInt64(void) { return TruncUFloat64ToInt64; }

BinaryenOp BinaryenReinterpretFloat32(void) { return ReinterpretFloat32; }

BinaryenOp BinaryenReinterpretFloat64(void) { return ReinterpretFloat64; }

BinaryenOp BinaryenExtendS8Int32(void) { return ExtendS8Int32; }

BinaryenOp BinaryenExtendS16Int32(void) { return ExtendS16Int32; }

BinaryenOp BinaryenExtendS8Int64(void) { return ExtendS8Int64; }

BinaryenOp BinaryenExtendS16Int64(void) { return ExtendS16Int64; }

BinaryenOp BinaryenExtendS32Int64(void) { return ExtendS32Int64; }

BinaryenOp BinaryenConvertSInt32ToFloat32(void) { return ConvertSInt32ToFloat32; }

BinaryenOp BinaryenConvertSInt32ToFloat64(void) { return ConvertSInt32ToFloat64; }

BinaryenOp BinaryenConvertUInt32ToFloat32(void) { return ConvertUInt32ToFloat32; }

BinaryenOp BinaryenConvertUInt32ToFloat64(void) { return ConvertUInt32ToFloat64; }

BinaryenOp BinaryenConvertSInt64ToFloat32(void) { return ConvertSInt64ToFloat32; }

BinaryenOp BinaryenConvertSInt64ToFloat64(void) { return ConvertSInt64ToFloat64; }

BinaryenOp BinaryenConvertUInt64ToFloat32(void) { return ConvertUInt64ToFloat32; }

BinaryenOp BinaryenConvertUInt64ToFloat64(void) { return ConvertUInt64ToFloat64; }

BinaryenOp BinaryenPromoteFloat32(void) { return PromoteFloat32; }

BinaryenOp BinaryenDemoteFloat64(void) { return DemoteFloat64; }

BinaryenOp BinaryenReinterpretInt32(void) { return ReinterpretInt32; }

BinaryenOp BinaryenReinterpretInt64(void) { return ReinterpretInt64; }

BinaryenOp BinaryenAddInt32(void) { return AddInt32; }

BinaryenOp BinaryenSubInt32(void) { return SubInt32; }

BinaryenOp BinaryenMulInt32(void) { return MulInt32; }

BinaryenOp BinaryenDivSInt32(void) { return DivSInt32; }

BinaryenOp BinaryenDivUInt32(void) { return DivUInt32; }

BinaryenOp BinaryenRemSInt32(void) { return RemSInt32; }

BinaryenOp BinaryenRemUInt32(void) { return RemUInt32; }

BinaryenOp BinaryenAndInt32(void) { return AndInt32; }

BinaryenOp BinaryenOrInt32(void) { return OrInt32; }

BinaryenOp BinaryenXorInt32(void) { return XorInt32; }

BinaryenOp BinaryenShlInt32(void) { return ShlInt32; }

BinaryenOp BinaryenShrUInt32(void) { return ShrUInt32; }

BinaryenOp BinaryenShrSInt32(void) { return ShrSInt32; }

BinaryenOp BinaryenRotLInt32(void) { return RotLInt32; }

BinaryenOp BinaryenRotRInt32(void) { return RotRInt32; }

BinaryenOp BinaryenEqInt32(void) { return EqInt32; }

BinaryenOp BinaryenNeInt32(void) { return NeInt32; }

BinaryenOp BinaryenLtSInt32(void) { return LtSInt32; }

BinaryenOp BinaryenLtUInt32(void) { return LtUInt32; }

BinaryenOp BinaryenLeSInt32(void) { return LeSInt32; }

BinaryenOp BinaryenLeUInt32(void) { return LeUInt32; }

BinaryenOp BinaryenGtSInt32(void) { return GtSInt32; }

BinaryenOp BinaryenGtUInt32(void) { return GtUInt32; }

BinaryenOp BinaryenGeSInt32(void) { return GeSInt32; }

BinaryenOp BinaryenGeUInt32(void) { return GeUInt32; }

BinaryenOp BinaryenAddInt64(void) { return AddInt64; }

BinaryenOp BinaryenSubInt64(void) { return SubInt64; }

BinaryenOp BinaryenMulInt64(void) { return MulInt64; }

BinaryenOp BinaryenDivSInt64(void) { return DivSInt64; }

BinaryenOp BinaryenDivUInt64(void) { return DivUInt64; }

BinaryenOp BinaryenRemSInt64(void) { return RemSInt64; }

BinaryenOp BinaryenRemUInt64(void) { return RemUInt64; }

BinaryenOp BinaryenAndInt64(void) { return AndInt64; }

BinaryenOp BinaryenOrInt64(void) { return OrInt64; }

BinaryenOp BinaryenXorInt64(void) { return XorInt64; }

BinaryenOp BinaryenShlInt64(void) { return ShlInt64; }

BinaryenOp BinaryenShrUInt64(void) { return ShrUInt64; }

BinaryenOp BinaryenShrSInt64(void) { return ShrSInt64; }

BinaryenOp BinaryenRotLInt64(void) { return RotLInt64; }

BinaryenOp BinaryenRotRInt64(void) { return RotRInt64; }

BinaryenOp BinaryenEqInt64(void) { return EqInt64; }

BinaryenOp BinaryenNeInt64(void) { return NeInt64; }

BinaryenOp BinaryenLtSInt64(void) { return LtSInt64; }

BinaryenOp BinaryenLtUInt64(void) { return LtUInt64; }

BinaryenOp BinaryenLeSInt64(void) { return LeSInt64; }

BinaryenOp BinaryenLeUInt64(void) { return LeUInt64; }

BinaryenOp BinaryenGtSInt64(void) { return GtSInt64; }

BinaryenOp BinaryenGtUInt64(void) { return GtUInt64; }

BinaryenOp BinaryenGeSInt64(void) { return GeSInt64; }

BinaryenOp BinaryenGeUInt64(void) { return GeUInt64; }

BinaryenOp BinaryenAddFloat32(void) { return AddFloat32; }

BinaryenOp BinaryenSubFloat32(void) { return SubFloat32; }

BinaryenOp BinaryenMulFloat32(void) { return MulFloat32; }

BinaryenOp BinaryenDivFloat32(void) { return DivFloat32; }

BinaryenOp BinaryenCopySignFloat32(void) { return CopySignFloat32; }

BinaryenOp BinaryenMinFloat32(void) { return MinFloat32; }

BinaryenOp BinaryenMaxFloat32(void) { return MaxFloat32; }

BinaryenOp BinaryenEqFloat32(void) { return EqFloat32; }

BinaryenOp BinaryenNeFloat32(void) { return NeFloat32; }

BinaryenOp BinaryenLtFloat32(void) { return LtFloat32; }

BinaryenOp BinaryenLeFloat32(void) { return LeFloat32; }

BinaryenOp BinaryenGtFloat32(void) { return GtFloat32; }

BinaryenOp BinaryenGeFloat32(void) { return GeFloat32; }

BinaryenOp BinaryenAddFloat64(void) { return AddFloat64; }

BinaryenOp BinaryenSubFloat64(void) { return SubFloat64; }

BinaryenOp BinaryenMulFloat64(void) { return MulFloat64; }

BinaryenOp BinaryenDivFloat64(void) { return DivFloat64; }

BinaryenOp BinaryenCopySignFloat64(void) { return CopySignFloat64; }

BinaryenOp BinaryenMinFloat64(void) { return MinFloat64; }

BinaryenOp BinaryenMaxFloat64(void) { return MaxFloat64; }

BinaryenOp BinaryenEqFloat64(void) { return EqFloat64; }

BinaryenOp BinaryenNeFloat64(void) { return NeFloat64; }

BinaryenOp BinaryenLtFloat64(void) { return LtFloat64; }

BinaryenOp BinaryenLeFloat64(void) { return LeFloat64; }

BinaryenOp BinaryenGtFloat64(void) { return GtFloat64; }

BinaryenOp BinaryenGeFloat64(void) { return GeFloat64; }

BinaryenOp BinaryenCurrentMemory(void) { return CurrentMemory; }

BinaryenOp BinaryenGrowMemory(void) { return GrowMemory; }

BinaryenOp BinaryenAtomicRMWAdd(void) { return AtomicRMWOp::Add; }

BinaryenOp BinaryenAtomicRMWSub(void) { return AtomicRMWOp::Sub; }

BinaryenOp BinaryenAtomicRMWAnd(void) { return AtomicRMWOp::And; }

BinaryenOp BinaryenAtomicRMWOr(void) { return AtomicRMWOp::Or; }

BinaryenOp BinaryenAtomicRMWXor(void) { return AtomicRMWOp::Xor; }

BinaryenOp BinaryenAtomicRMWXchg(void) { return AtomicRMWOp::Xchg; }

BinaryenExpressionRef BinaryenBlock(BinaryenModuleRef module, const char* name, BinaryenExpressionRef* children, BinaryenIndex numChildren, BinaryenType type) {

auto* ret = ((Module*)module)->allocator.alloc<Block>();

if (name) ret->name = name;

for (BinaryenIndex i = 0; i < numChildren; i++) {

ret->list.push_back((Expression*)children[i]);

}

if (type != BinaryenTypeAuto()) ret->finalize(Type(type));

else ret->finalize();

if (tracing) {

std::cout << " {\n";

std::cout << " BinaryenExpressionRef children[] = { ";

for (BinaryenIndex i = 0; i < numChildren; i++) {

if (i > 0) std::cout << ", ";

if (i % 6 == 5) std::cout << "\n "; // don't create hugely long lines

std::cout << "expressions[" << expressions[children[i]] << "]";

}

if (numChildren == 0) std::cout << "0"; // ensure the array is not empty, otherwise a compiler error on VS

std::cout << " };\n";

auto id = noteExpression(ret);

std::cout << " expressions[" << id << "] = BinaryenBlock(the_module, ";

traceNameOrNULL(name);

std::cout << ", children, " << numChildren << ", ";

if (type == BinaryenTypeAuto()) std::cout << "BinaryenTypeAuto()";

else std::cout << type;

std::cout << ");\n";

std::cout << " }\n";

}

return static_cast<Expression*>(ret);

}

BinaryenExpressionRef BinaryenIf(BinaryenModuleRef module, BinaryenExpressionRef condition, BinaryenExpressionRef ifTrue, BinaryenExpressionRef ifFalse) {

auto* ret = ((Module*)module)->allocator.alloc<If>();

ret->condition = (Expression*)condition;

ret->ifTrue = (Expression*)ifTrue;

ret->ifFalse = (Expression*)ifFalse;

ret->finalize();

if (tracing) {

auto id = noteExpression(ret);

std::cout << " expressions[" << id << "] = BinaryenIf(the_module, expressions[" << expressions[condition] << "], expressions[" << expressions[ifTrue] << "], expressions[" << expressions[ifFalse] << "]);\n";

}

return static_cast<Expression*>(ret);

}

BinaryenExpressionRef BinaryenLoop(BinaryenModuleRef module, const char* name, BinaryenExpressionRef body) {

auto* ret = Builder(*((Module*)module)).makeLoop(name ? Name(name) : Name(), (Expression*)body);

if (tracing) {

auto id = noteExpression(ret);

std::cout << " expressions[" << id << "] = BinaryenLoop(the_module, ";

traceNameOrNULL(name);

std::cout << ", expressions[" << expressions[body] << "]);\n";

}

return static_cast<Expression*>(ret);

}

BinaryenExpressionRef BinaryenBreak(BinaryenModuleRef module, const char* name, BinaryenExpressionRef condition, BinaryenExpressionRef value) {

auto* ret = Builder(*((Module*)module)).makeBreak(name, (Expression*)value, (Expression*)condition);

if (tracing) {

auto id = noteExpression(ret);

std::cout << " expressions[" << id << "] = BinaryenBreak(the_module, \"" << name << "\", expressions[" << expressions[condition] << "], expressions[" << expressions[value] << "]);\n";

}

return static_cast<Expression*>(ret);

}

BinaryenExpressionRef BinaryenSwitch(BinaryenModuleRef module, const char** names, BinaryenIndex numNames, const char* defaultName, BinaryenExpressionRef condition, BinaryenExpressionRef value) {

auto* ret = ((Module*)module)->allocator.alloc<Switch>();

if (tracing) {

std::cout << " {\n";

std::cout << " const char* names[] = { ";

for (BinaryenIndex i = 0; i < numNames; i++) {

if (i > 0) std::cout << ", ";

std::cout << "\"" << names[i] << "\"";

}

if (numNames == 0) std::cout << "0"; // ensure the array is not empty, otherwise a compiler error on VS

std::cout << " };\n";

auto id = noteExpression(ret);

std::cout << " expressions[" << id << "] = BinaryenSwitch(the_module, names, " << numNames << ", \"" << defaultName << "\", expressions[" << expressions[condition] << "], expressions[" << expressions[value] << "]);\n";

std::cout << " }\n";

}

for (BinaryenIndex i = 0; i < numNames; i++) {

ret->targets.push_back(names[i]);

}

ret->default_ = defaultName;

ret->condition = (Expression*)condition;

ret->value = (Expression*)value;

ret->finalize();

return static_cast<Expression*>(ret);

}

BinaryenExpressionRef BinaryenCall(BinaryenModuleRef module, const char* target, BinaryenExpressionRef* operands, BinaryenIndex numOperands, BinaryenType returnType) {

auto* ret = ((Module*)module)->allocator.alloc<Call>();

if (tracing) {

std::cout << " {\n";

std::cout << " BinaryenExpressionRef operands[] = { ";

for (BinaryenIndex i = 0; i < numOperands; i++) {

if (i > 0) std::cout << ", ";

std::cout << "expressions[" << expressions[operands[i]] << "]";

}

if (numOperands == 0) std::cout << "0"; // ensure the array is not empty, otherwise a compiler error on VS

std::cout << " };\n";

auto id = noteExpression(ret);

std::cout << " expressions[" << id << "] = BinaryenCall(the_module, \"" << target << "\", operands, " << numOperands << ", " << returnType << ");\n";

std::cout << " }\n";

}

ret->target = target;

for (BinaryenIndex i = 0; i < numOperands; i++) {

ret->operands.push_back((Expression*)operands[i]);

}

ret->type = Type(returnType);

ret->finalize();

return static_cast<Expression*>(ret);

}

BinaryenExpressionRef BinaryenCallIndirect(BinaryenModuleRef module, BinaryenExpressionRef target, BinaryenExpressionRef* operands, BinaryenIndex numOperands, const char* type) {

auto* wasm = (Module*)module;

auto* ret = wasm->allocator.alloc<CallIndirect>();

if (tracing) {

std::cout << " {\n";

std::cout << " BinaryenExpressionRef operands[] = { ";

for (BinaryenIndex i = 0; i < numOperands; i++) {

if (i > 0) std::cout << ", ";

std::cout << "expressions[" << expressions[operands[i]] << "]";

}

if (numOperands == 0) std::cout << "0"; // ensure the array is not empty, otherwise a compiler error on VS

std::cout << " };\n";

auto id = noteExpression(ret);

std::cout << " expressions[" << id << "] = BinaryenCallIndirect(the_module, expressions[" << expressions[target] << "], operands, " << numOperands << ", \"" << type << "\");\n";

std::cout << " }\n";

}

ret->target = (Expression*)target;

for (BinaryenIndex i = 0; i < numOperands; i++) {

ret->operands.push_back((Expression*)operands[i]);

}

ret->fullType = type;

ret->type = wasm->getFunctionType(ret->fullType)->result;

ret->finalize();

return static_cast<Expression*>(ret);

}

BinaryenExpressionRef BinaryenGetLocal(BinaryenModuleRef module, BinaryenIndex index, BinaryenType type) {

auto* ret = ((Module*)module)->allocator.alloc<GetLocal>();

if (tracing) {

auto id = noteExpression(ret);

std::cout << " expressions[" << id << "] = BinaryenGetLocal(the_module, " << index << ", " << type << ");\n";

}

ret->index = index;

ret->type = Type(type);

ret->finalize();

return static_cast<Expression*>(ret);

}

BinaryenExpressionRef BinaryenSetLocal(BinaryenModuleRef module, BinaryenIndex index, BinaryenExpressionRef value) {

auto* ret = ((Module*)module)->allocator.alloc<SetLocal>();

if (tracing) {

auto id = noteExpression(ret);

std::cout << " expressions[" << id << "] = BinaryenSetLocal(the_module, " << index << ", expressions[" << expressions[value] << "]);\n";

}

ret->index = index;

ret->value = (Expression*)value;

ret->setTee(false);

ret->finalize();

return static_cast<Expression*>(ret);

}

BinaryenExpressionRef BinaryenTeeLocal(BinaryenModuleRef module, BinaryenIndex index, BinaryenExpressionRef value) {

auto* ret = ((Module*)module)->allocator.alloc<SetLocal>();

if (tracing) {

auto id = noteExpression(ret);

std::cout << " expressions[" << id << "] = BinaryenTeeLocal(the_module, " << index << ", expressions[" << expressions[value] << "]);\n";

}

ret->index = index;

ret->value = (Expression*)value;

ret->setTee(true);

ret->finalize();

return static_cast<Expression*>(ret);

}

BinaryenExpressionRef BinaryenGetGlobal(BinaryenModuleRef module, const char* name, BinaryenType type) {

auto* ret = ((Module*)module)->allocator.alloc<GetGlobal>();

if (tracing) {

auto id = noteExpression(ret);

std::cout << " expressions[" << id << "] = BinaryenGetGlobal(the_module, \"" << name << "\", " << type << ");\n";

}

ret->name = name;

ret->type = Type(type);

ret->finalize();

return static_cast<Expression*>(ret);

}

BinaryenExpressionRef BinaryenSetGlobal(BinaryenModuleRef module, const char* name, BinaryenExpressionRef value) {

auto* ret = ((Module*)module)->allocator.alloc<SetGlobal>();

if (tracing) {

auto id = noteExpression(ret);

std::cout << " expressions[" << id << "] = BinaryenSetGlobal(the_module, \"" << name << "\", expressions[" << expressions[value] << "]);\n";

}

ret->name = name;

ret->value = (Expression*)value;

ret->finalize();

return static_cast<Expression*>(ret);

}

BinaryenExpressionRef BinaryenLoad(BinaryenModuleRef module, uint32_t bytes, int8_t signed_, uint32_t offset, uint32_t align, BinaryenType type, BinaryenExpressionRef ptr) {

auto* ret = ((Module*)module)->allocator.alloc<Load>();

if (tracing) {

auto id = noteExpression(ret);

std::cout << " expressions[" << id << "] = BinaryenLoad(the_module, " << bytes << ", " << int(signed_) << ", " << offset << ", " << align << ", " << type << ", expressions[" << expressions[ptr] << "]);\n";

}

ret->isAtomic = false;

ret->bytes = bytes;

ret->signed_ = !!signed_;

ret->offset = offset;

ret->align = align ? align : bytes;

ret->type = Type(type);

ret->ptr = (Expression*)ptr;

ret->finalize();

return static_cast<Expression*>(ret);

}

BinaryenExpressionRef BinaryenStore(BinaryenModuleRef module, uint32_t bytes, uint32_t offset, uint32_t align, BinaryenExpressionRef ptr, BinaryenExpressionRef value, BinaryenType type) {

auto* ret = ((Module*)module)->allocator.alloc<Store>();

if (tracing) {

auto id = noteExpression(ret);

std::cout << " expressions[" << id << "] = BinaryenStore(the_module, " << bytes << ", " << offset << ", " << align << ", expressions[" << expressions[ptr] << "], expressions[" << expressions[value] << "], " << type << ");\n";

}

ret->isAtomic = false;

ret->bytes = bytes;

ret->offset = offset;

ret->align = align ? align : bytes;

ret->ptr = (Expression*)ptr;

ret->value = (Expression*)value;

ret->valueType = Type(type);

ret->finalize();

return static_cast<Expression*>(ret);

}

BinaryenExpressionRef BinaryenConst(BinaryenModuleRef module, BinaryenLiteral value) {

auto* ret = Builder(*((Module*)module)).makeConst(fromBinaryenLiteral(value));

if (tracing) {

auto id = noteExpression(ret);

switch (value.type) {

case Type::i32: std::cout << " expressions[" << id << "] = BinaryenConst(the_module, BinaryenLiteralInt32(" << value.i32 << "));\n"; break;

case Type::i64: std::cout << " expressions[" << id << "] = BinaryenConst(the_module, BinaryenLiteralInt64(" << value.i64 << "));\n"; break;

case Type::f32: {

std::cout << " expressions[" << id << "] = BinaryenConst(the_module, BinaryenLiteralFloat32(";

if (std::isnan(value.f32)) std::cout << "NAN";

else std::cout << value.f32;

std::cout << "));\n";

break;

}

case Type::f64: {

std::cout << " expressions[" << id << "] = BinaryenConst(the_module, BinaryenLiteralFloat64(";

if (std::isnan(value.f64)) std::cout << "NAN";

else std::cout << value.f64;

std::cout << "));\n";

break;

}

default: WASM_UNREACHABLE();

}

}

return static_cast<Expression*>(ret);

}

BinaryenExpressionRef BinaryenUnary(BinaryenModuleRef module, BinaryenOp op, BinaryenExpressionRef value) {

auto* ret = Builder(*((Module*)module)).makeUnary(UnaryOp(op), (Expression*)value);

if (tracing) {

auto id = noteExpression(ret);

std::cout << " expressions[" << id << "] = BinaryenUnary(the_module, " << op << ", expressions[" << expressions[value] << "]);\n";

}

return static_cast<Expression*>(ret);

}

BinaryenExpressionRef BinaryenBinary(BinaryenModuleRef module, BinaryenOp op, BinaryenExpressionRef left, BinaryenExpressionRef right) {

auto* ret = Builder(*((Module*)module)).makeBinary(BinaryOp(op), (Expression*)left, (Expression*)right);

if (tracing) {

auto id = noteExpression(ret);

std::cout << " expressions[" << id << "] = BinaryenBinary(the_module, " << op << ", expressions[" << expressions[left] << "], expressions[" << expressions[right] << "]);\n";

}

return static_cast<Expression*>(ret);

}

BinaryenExpressionRef BinaryenSelect(BinaryenModuleRef module, BinaryenExpressionRef condition, BinaryenExpressionRef ifTrue, BinaryenExpressionRef ifFalse) {

auto* ret = ((Module*)module)->allocator.alloc<Select>();

if (tracing) {

auto id = noteExpression(ret);

std::cout << " expressions[" << id << "] = BinaryenSelect(the_module, expressions[" << expressions[condition] << "], expressions[" << expressions[ifTrue] << "], expressions[" << expressions[ifFalse] << "]);\n";

}

ret->condition = (Expression*)condition;

ret->ifTrue = (Expression*)ifTrue;

ret->ifFalse = (Expression*)ifFalse;

ret->finalize();

return static_cast<Expression*>(ret);

}

BinaryenExpressionRef BinaryenDrop(BinaryenModuleRef module, BinaryenExpressionRef value) {

auto* ret = ((Module*)module)->allocator.alloc<Drop>();

if (tracing) {

auto id = noteExpression(ret);

std::cout << " expressions[" << id << "] = BinaryenDrop(the_module, expressions[" << expressions[value] << "]);\n";

}

ret->value = (Expression*)value;

ret->finalize();

return static_cast<Expression*>(ret);

}

BinaryenExpressionRef BinaryenReturn(BinaryenModuleRef module, BinaryenExpressionRef value) {

auto* ret = Builder(*((Module*)module)).makeReturn((Expression*)value);

if (tracing) {

auto id = noteExpression(ret);

std::cout << " expressions[" << id << "] = BinaryenReturn(the_module, expressions[" << expressions[value] << "]);\n";

}

return static_cast<Expression*>(ret);

}

BinaryenExpressionRef BinaryenHost(BinaryenModuleRef module, BinaryenOp op, const char* name, BinaryenExpressionRef* operands, BinaryenIndex numOperands) {

auto* ret = ((Module*)module)->allocator.alloc<Host>();

if (tracing) {

std::cout << " {\n";

std::cout << " BinaryenExpressionRef operands[] = { ";

for (BinaryenIndex i = 0; i < numOperands; i++) {

if (i > 0) std::cout << ", ";

std::cout << "expressions[" << expressions[operands[i]] << "]";

}

if (numOperands == 0) std::cout << "0"; // ensure the array is not empty, otherwise a compiler error on VS

std::cout << " };\n";

auto id = noteExpression(ret);

std::cout << " expressions[" << id << "] = BinaryenHost(the_module, " << op << ", \"" << name << "\", operands, " << numOperands << ");\n";

std::cout << " }\n";

}

ret->op = HostOp(op);

if (name) ret->nameOperand = name;

for (BinaryenIndex i = 0; i < numOperands; i++) {

ret->operands.push_back((Expression*)operands[i]);

}

ret->finalize();

return static_cast<Expression*>(ret);

}

BinaryenExpressionRef BinaryenNop(BinaryenModuleRef module) {

auto* ret = ((Module*)module)->allocator.alloc<Nop>();

if (tracing) {

auto id = noteExpression(ret);

std::cout << " expressions[" << id << "] = BinaryenNop(the_module);\n";

}

return static_cast<Expression*>(ret);

}

BinaryenExpressionRef BinaryenUnreachable(BinaryenModuleRef module) {

auto* ret = ((Module*)module)->allocator.alloc<Unreachable>();

if (tracing) {

auto id = noteExpression(ret);

std::cout << " expressions[" << id << "] = BinaryenUnreachable(the_module);\n";

}

return static_cast<Expression*>(ret);

}

BinaryenExpressionRef BinaryenAtomicLoad(BinaryenModuleRef module, uint32_t bytes, uint32_t offset, BinaryenType type, BinaryenExpressionRef ptr) {

auto* ret = Builder(*((Module*)module)).makeAtomicLoad(bytes, offset, (Expression*)ptr, Type(type));

if (tracing) {

auto id = noteExpression(ret);

std::cout << " expressions[" << id << "] = BinaryenAtomicLoad(the_module, " << bytes << ", " << offset << ", " << type << ", expressions[" << expressions[ptr] << "]);\n";

}

return static_cast<Expression*>(ret);

}

BinaryenExpressionRef BinaryenAtomicStore(BinaryenModuleRef module, uint32_t bytes, uint32_t offset, BinaryenExpressionRef ptr, BinaryenExpressionRef value, BinaryenType type) {

auto* ret = Builder(*((Module*)module)).makeAtomicStore(bytes, offset, (Expression*)ptr, (Expression*)value, Type(type));

if (tracing) {

auto id = noteExpression(ret);

std::cout << " expressions[" << id << "] = BinaryenAtomicStore(the_module, " << bytes << ", " << offset << ", expressions[" << expressions[ptr] << "], expressions[" << expressions[value] << "], " << type << ");\n";

}

return static_cast<Expression*>(ret);

}

BinaryenExpressionRef BinaryenAtomicRMW(BinaryenModuleRef module, BinaryenOp op, BinaryenIndex bytes, BinaryenIndex offset, BinaryenExpressionRef ptr, BinaryenExpressionRef value, BinaryenType type) {

auto* ret = Builder(*((Module*)module)).makeAtomicRMW(AtomicRMWOp(op), bytes, offset, (Expression*)ptr, (Expression*)value, Type(type));

if (tracing) {

auto id = noteExpression(ret);

std::cout << " expressions[" << id << "] = BinaryenAtomicRMW(the_module, " << op << ", " << bytes << ", " << offset << ", expressions[" << expressions[ptr] << "], expressions[" << expressions[value] << "], " << type << ");\n";

}

return static_cast<Expression*>(ret);

}

BinaryenExpressionRef BinaryenAtomicCmpxchg(BinaryenModuleRef module, BinaryenIndex bytes, BinaryenIndex offset, BinaryenExpressionRef ptr, BinaryenExpressionRef expected, BinaryenExpressionRef replacement, BinaryenType type) {

auto* ret = Builder(*((Module*)module)).makeAtomicCmpxchg(bytes, offset, (Expression*)ptr, (Expression*)expected, (Expression*)replacement, Type(type));

if (tracing) {

auto id = noteExpression(ret);

std::cout << " expressions[" << id << "] = BinaryenAtomicCmpxchg(the_module, " << bytes << ", " << offset << ", expressions[" << expressions[ptr] << "], expressions[" << expressions[expected] << "], expressions[" << expressions[replacement] << "], " << type << ");\n";

}

return static_cast<Expression*>(ret);

}

BinaryenExpressionRef BinaryenAtomicWait(BinaryenModuleRef module, BinaryenExpressionRef ptr, BinaryenExpressionRef expected, BinaryenExpressionRef timeout, BinaryenType expectedType) {

auto* ret = Builder(*((Module*)module)).makeAtomicWait((Expression*)ptr, (Expression*)expected, (Expression*)timeout, Type(expectedType), 0);

if (tracing) {

auto id = noteExpression(ret);

std::cout << " expressions[" << id << "] = BinaryenAtomicWait(the_module, expressions[" << expressions[ptr] << "], expressions[" << expressions[expected] << "], expressions[" << expressions[timeout] << "], " << expectedType << ");\n";

}

return static_cast<Expression*>(ret);

}

BinaryenExpressionRef BinaryenAtomicWake(BinaryenModuleRef module, BinaryenExpressionRef ptr, BinaryenExpressionRef wakeCount) {

auto* ret = Builder(*((Module*)module)).makeAtomicWake((Expression*)ptr, (Expression*)wakeCount, 0);

if (tracing) {

auto id = noteExpression(ret);

std::cout << " expressions[" << id << "] = BinaryenAtomicWake(the_module, expressions[" << expressions[ptr] << "], expressions[" << expressions[wakeCount] << "]);\n";

}

return static_cast<Expression*>(ret);

}

// Expression utility

BinaryenExpressionId BinaryenExpressionGetId(BinaryenExpressionRef expr) {

if (tracing) {

std::cout << " BinaryenExpressionGetId(expressions[" << expressions[expr] << "]);\n";

}

return ((Expression*)expr)->_id;

}

BinaryenType BinaryenExpressionGetType(BinaryenExpressionRef expr) {

if (tracing) {

std::cout << " BinaryenExpressionGetType(expressions[" << expressions[expr] << "]);\n";

}

return ((Expression*)expr)->type;

}

void BinaryenExpressionPrint(BinaryenExpressionRef expr) {

if (tracing) {

std::cout << " BinaryenExpressionPrint(expressions[" << expressions[expr] << "]);\n";

}

WasmPrinter::printExpression((Expression*)expr, std::cout);

std::cout << '\n';

}

// Specific expression utility

// Block

const char* BinaryenBlockGetName(BinaryenExpressionRef expr) {

if (tracing) {

std::cout << " BinaryenBlockGetName(expressions[" << expressions[expr] << "]);\n";

}

auto* expression = (Expression*)expr;

assert(expression->is<Block>());

return static_cast<Block*>(expression)->name.c_str();

}

BinaryenIndex BinaryenBlockGetNumChildren(BinaryenExpressionRef expr) {

if (tracing) {

std::cout << " BinaryenBlockGetNumChildren(expressions[" << expressions[expr] << "]);\n";

}

auto* expression = (Expression*)expr;

assert(expression->is<Block>());

return static_cast<Block*>(expression)->list.size();

}

BinaryenExpressionRef BinaryenBlockGetChild(BinaryenExpressionRef expr, BinaryenIndex index) {

if (tracing) {

std::cout << " BinaryenBlockGetChild(expressions[" << expressions[expr] << "], " << index << ");\n";

}

auto* expression = (Expression*)expr;

assert(expression->is<Block>());

assert(index < static_cast<Block*>(expression)->list.size());

return static_cast<Block*>(expression)->list[index];

}

// If

BinaryenExpressionRef BinaryenIfGetCondition(BinaryenExpressionRef expr) {

if (tracing) {

std::cout << " BinaryenIfGetCondition(expressions[" << expressions[expr] << "]);\n";

}

auto* expression = (Expression*)expr;

assert(expression->is<If>());

return static_cast<If*>(expression)->condition;

}

BinaryenExpressionRef BinaryenIfGetIfTrue(BinaryenExpressionRef expr) {

if (tracing) {

std::cout << " BinaryenIfGetIfTrue(expressions[" << expressions[expr] << "]);\n";

}

auto* expression = (Expression*)expr;

assert(expression->is<If>());

return static_cast<If*>(expression)->ifTrue;

}

BinaryenExpressionRef BinaryenIfGetIfFalse(BinaryenExpressionRef expr) {

if (tracing) {

std::cout << " BinaryenIfGetIfFalse(expressions[" << expressions[expr] << "]);\n";

}

auto* expression = (Expression*)expr;

assert(expression->is<If>());

return static_cast<If*>(expression)->ifFalse;

}

// Loop

const char* BinaryenLoopGetName(BinaryenExpressionRef expr) {

if (tracing) {

std::cout << " BinaryenLoopGetName(expressions[" << expressions[expr] << "]);\n";

}

auto* expression = (Expression*)expr;

assert(expression->is<Loop>());

return static_cast<Loop*>(expression)->name.c_str();

}

BinaryenExpressionRef BinaryenLoopGetBody(BinaryenExpressionRef expr) {

if (tracing) {

std::cout << " BinaryenLoopGetBody(expressions[" << expressions[expr] << "]);\n";

}

auto* expression = (Expression*)expr;

assert(expression->is<Loop>());

return static_cast<Loop*>(expression)->body;

}

// Break

const char* BinaryenBreakGetName(BinaryenExpressionRef expr) {

if (tracing) {

std::cout << " BinaryenBreakGetName(expressions[" << expressions[expr] << "]);\n";

}

auto* expression = (Expression*)expr;

assert(expression->is<Break>());

return static_cast<Break*>(expression)->name.c_str();

}

BinaryenExpressionRef BinaryenBreakGetCondition(BinaryenExpressionRef expr) {

if (tracing) {

std::cout << " BinaryenBreakGetCondition(expressions[" << expressions[expr] << "]);\n";

}

auto* expression = (Expression*)expr;

assert(expression->is<Break>());

return static_cast<Break*>(expression)->condition;

}

BinaryenExpressionRef BinaryenBreakGetValue(BinaryenExpressionRef expr) {

if (tracing) {

std::cout << " BinaryenBreakGetValue(expressions[" << expressions[expr] << "]);\n";

}

auto* expression = (Expression*)expr;

assert(expression->is<Break>());

return static_cast<Break*>(expression)->value;

}

// Switch

BinaryenIndex BinaryenSwitchGetNumNames(BinaryenExpressionRef expr) {

if (tracing) {

std::cout << " BinaryenSwitchGetNumNames(expressions[" << expressions[expr] << "]);\n";

}

auto* expression = (Expression*)expr;

assert(expression->is<Switch>());

return static_cast<Switch*>(expression)->targets.size();

}

const char* BinaryenSwitchGetName(BinaryenExpressionRef expr, BinaryenIndex index) {

if (tracing) {

std::cout << " BinaryenSwitchGetName(expressions[" << expressions[expr] << "], " << index << ");\n";

}

auto* expression = (Expression*)expr;

assert(expression->is<Switch>());

assert(index < static_cast<Switch*>(expression)->targets.size());

return static_cast<Switch*>(expression)->targets[index].c_str();

}

const char* BinaryenSwitchGetDefaultName(BinaryenExpressionRef expr) {

if (tracing) {

std::cout << " BinaryenSwitchGetDefaultName(expressions[" << expressions[expr] << "]);\n";

}

auto* expression = (Expression*)expr;

assert(expression->is<Switch>());

return static_cast<Switch*>(expression)->default_.c_str();

}

BinaryenExpressionRef BinaryenSwitchGetCondition(BinaryenExpressionRef expr) {

if (tracing) {

std::cout << " BinaryenSwitchGetCondition(expressions[" << expressions[expr] << "]);\n";

}

auto* expression = (Expression*)expr;

assert(expression->is<Switch>());

return static_cast<Switch*>(expression)->condition;

}

BinaryenExpressionRef BinaryenSwitchGetValue(BinaryenExpressionRef expr) {

if (tracing) {

std::cout << " BinaryenSwitchGetValue(expressions[" << expressions[expr] << "]);\n";

}