/*

* 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 "cfg/Relooper.h"

#include "ir/utils.h"

#include "pass.h"

#include "shell-interface.h"

#include "support/colors.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 "wasm.h"

#include "wasm2js.h"

#include <iostream>

#include <sstream>

#ifdef __EMSCRIPTEN__

#include <emscripten.h>

#endif

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.getID();

TODO_SINGLE_COMPOUND(x.type);

switch (x.type.getBasic()) {

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;

case Type::v128:

memcpy(&ret.v128, x.getv128Ptr(), 16);

break;

case Type::funcref:

ret.func = x.getFunc().c_str();

break;

case Type::nullref:

break;

case Type::externref:

case Type::exnref:

case Type::none:

case Type::unreachable:

WASM_UNREACHABLE("unexpected type");

}

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();

case Type::v128:

return Literal(x.v128);

case Type::funcref:

return Literal::makeFuncref(x.func);

case Type::nullref:

return Literal::makeNullref();

case Type::externref:

case Type::exnref:

case Type::none:

case Type::unreachable:

WASM_UNREACHABLE("unexpected type");

}

WASM_UNREACHABLE("invalid type");

}

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

// Optimization options

static PassOptions globalPassOptions =

PassOptions::getWithDefaultOptimizationOptions();

extern "C" {

//

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

//

// Core types

BinaryenType BinaryenTypeNone(void) { return Type::none; }

BinaryenType BinaryenTypeInt32(void) { return Type::i32; }

BinaryenType BinaryenTypeInt64(void) { return Type::i64; }

BinaryenType BinaryenTypeFloat32(void) { return Type::f32; }

BinaryenType BinaryenTypeFloat64(void) { return Type::f64; }

BinaryenType BinaryenTypeVec128(void) { return Type::v128; }

BinaryenType BinaryenTypeFuncref(void) { return Type::funcref; }

BinaryenType BinaryenTypeExternref(void) { return Type::externref; }

BinaryenType BinaryenTypeNullref(void) { return Type::nullref; }

BinaryenType BinaryenTypeExnref(void) { return Type::exnref; }

BinaryenType BinaryenTypeUnreachable(void) { return Type::unreachable; }

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

BinaryenType BinaryenTypeCreate(BinaryenType* types, uint32_t numTypes) {

std::vector<Type> typeVec;

typeVec.reserve(numTypes);

for (size_t i = 0; i < numTypes; ++i) {

typeVec.push_back(Type(types[i]));

}

return Type(typeVec).getID();

}

uint32_t BinaryenTypeArity(BinaryenType t) { return Type(t).size(); }

void BinaryenTypeExpand(BinaryenType t, BinaryenType* buf) {

Type types(t);

size_t i = 0;

for (const auto& type : types) {

buf[i++] = type.getID();

}

}

WASM_DEPRECATED BinaryenType BinaryenNone(void) { return Type::none; }

WASM_DEPRECATED BinaryenType BinaryenInt32(void) { return Type::i32; }

WASM_DEPRECATED BinaryenType BinaryenInt64(void) { return Type::i64; }

WASM_DEPRECATED BinaryenType BinaryenFloat32(void) { return Type::f32; }

WASM_DEPRECATED BinaryenType BinaryenFloat64(void) { return Type::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 BinaryenLocalGetId(void) {

return Expression::Id::LocalGetId;

}

BinaryenExpressionId BinaryenLocalSetId(void) {

return Expression::Id::LocalSetId;

}

BinaryenExpressionId BinaryenGlobalGetId(void) {

return Expression::Id::GlobalGetId;

}

BinaryenExpressionId BinaryenGlobalSetId(void) {

return Expression::Id::GlobalSetId;

}

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 BinaryenAtomicNotifyId(void) {

return Expression::Id::AtomicNotifyId;

}

BinaryenExpressionId BinaryenAtomicFenceId(void) {

return Expression::Id::AtomicFenceId;

}

BinaryenExpressionId BinaryenSIMDExtractId(void) {

return Expression::Id::SIMDExtractId;

}

BinaryenExpressionId BinaryenSIMDReplaceId(void) {

return Expression::Id::SIMDReplaceId;

}

BinaryenExpressionId BinaryenSIMDShuffleId(void) {

return Expression::Id::SIMDShuffleId;

}

BinaryenExpressionId BinaryenSIMDTernaryId(void) {

return Expression::Id::SIMDTernaryId;

}

BinaryenExpressionId BinaryenSIMDShiftId(void) {

return Expression::Id::SIMDShiftId;

}

BinaryenExpressionId BinaryenSIMDLoadId(void) {

return Expression::Id::SIMDLoadId;

}

BinaryenExpressionId BinaryenMemoryInitId(void) {

return Expression::Id::MemoryInitId;

}

BinaryenExpressionId BinaryenDataDropId(void) {

return Expression::Id::DataDropId;

}

BinaryenExpressionId BinaryenMemoryCopyId(void) {

return Expression::Id::MemoryCopyId;

}

BinaryenExpressionId BinaryenMemoryFillId(void) {

return Expression::Id::MemoryFillId;

}

BinaryenExpressionId BinaryenRefNullId(void) {

return Expression::Id::RefNullId;

}

BinaryenExpressionId BinaryenRefIsNullId(void) {

return Expression::Id::RefIsNullId;

}

BinaryenExpressionId BinaryenRefFuncId(void) {

return Expression::Id::RefFuncId;

}

BinaryenExpressionId BinaryenTryId(void) { return Expression::Id::TryId; }

BinaryenExpressionId BinaryenThrowId(void) { return Expression::Id::ThrowId; }

BinaryenExpressionId BinaryenRethrowId(void) {

return Expression::Id::RethrowId;

}

BinaryenExpressionId BinaryenBrOnExnId(void) {

return Expression::Id::BrOnExnId;

}

BinaryenExpressionId BinaryenTupleMakeId(void) {

return Expression::Id::TupleMakeId;

}

BinaryenExpressionId BinaryenTupleExtractId(void) {

return Expression::Id::TupleExtractId;

}

BinaryenExpressionId BinaryenPopId(void) { return Expression::Id::PopId; }

// 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);

}

BinaryenExternalKind BinaryenExternalEvent(void) {

return static_cast<BinaryenExternalKind>(ExternalKind::Event);

}

// Features

BinaryenFeatures BinaryenFeatureMVP(void) {

return static_cast<BinaryenFeatures>(FeatureSet::MVP);

}

BinaryenFeatures BinaryenFeatureAtomics(void) {

return static_cast<BinaryenFeatures>(FeatureSet::Atomics);

}

BinaryenFeatures BinaryenFeatureBulkMemory(void) {

return static_cast<BinaryenFeatures>(FeatureSet::BulkMemory);

}

BinaryenFeatures BinaryenFeatureMutableGlobals(void) {

return static_cast<BinaryenFeatures>(FeatureSet::MutableGlobals);

}

BinaryenFeatures BinaryenFeatureNontrappingFPToInt(void) {

return static_cast<BinaryenFeatures>(FeatureSet::TruncSat);

}

BinaryenFeatures BinaryenFeatureSignExt(void) {

return static_cast<BinaryenFeatures>(FeatureSet::SignExt);

}

BinaryenFeatures BinaryenFeatureSIMD128(void) {

return static_cast<BinaryenFeatures>(FeatureSet::SIMD);

}

BinaryenFeatures BinaryenFeatureExceptionHandling(void) {

return static_cast<BinaryenFeatures>(FeatureSet::ExceptionHandling);

}

BinaryenFeatures BinaryenFeatureTailCall(void) {

return static_cast<BinaryenFeatures>(FeatureSet::TailCall);

}

BinaryenFeatures BinaryenFeatureReferenceTypes(void) {

return static_cast<BinaryenFeatures>(FeatureSet::ReferenceTypes);

}

BinaryenFeatures BinaryenFeatureMultivalue(void) {

return static_cast<BinaryenFeatures>(FeatureSet::Multivalue);

}

BinaryenFeatures BinaryenFeatureAll(void) {

return static_cast<BinaryenFeatures>(FeatureSet::All);

}

// Modules

BinaryenModuleRef BinaryenModuleCreate(void) { return new Module(); }

void BinaryenModuleDispose(BinaryenModuleRef module) { delete (Module*)module; }

// Literals

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 BinaryenLiteralVec128(const uint8_t x[16]) {

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 BinaryenMemorySize(void) { return MemorySize; }

BinaryenOp BinaryenMemoryGrow(void) { return MemoryGrow; }

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

BinaryenOp BinaryenTruncSatSFloat32ToInt32(void) {

return TruncSatSFloat32ToInt32;

}

BinaryenOp BinaryenTruncSatSFloat32ToInt64(void) {

return TruncSatSFloat32ToInt64;

}

BinaryenOp BinaryenTruncSatUFloat32ToInt32(void) {

return TruncSatUFloat32ToInt32;

}

BinaryenOp BinaryenTruncSatUFloat32ToInt64(void) {

return TruncSatUFloat32ToInt64;

}

BinaryenOp BinaryenTruncSatSFloat64ToInt32(void) {

return TruncSatSFloat64ToInt32;

}

BinaryenOp BinaryenTruncSatSFloat64ToInt64(void) {

return TruncSatSFloat64ToInt64;

}

BinaryenOp BinaryenTruncSatUFloat64ToInt32(void) {

return TruncSatUFloat64ToInt32;

}

BinaryenOp BinaryenTruncSatUFloat64ToInt64(void) {

return TruncSatUFloat64ToInt64;

}

BinaryenOp BinaryenSplatVecI8x16(void) { return SplatVecI8x16; }

BinaryenOp BinaryenExtractLaneSVecI8x16(void) { return ExtractLaneSVecI8x16; }

BinaryenOp BinaryenExtractLaneUVecI8x16(void) { return ExtractLaneUVecI8x16; }

BinaryenOp BinaryenReplaceLaneVecI8x16(void) { return ReplaceLaneVecI8x16; }

BinaryenOp BinaryenSplatVecI16x8(void) { return SplatVecI16x8; }

BinaryenOp BinaryenExtractLaneSVecI16x8(void) { return ExtractLaneSVecI16x8; }

BinaryenOp BinaryenExtractLaneUVecI16x8(void) { return ExtractLaneUVecI16x8; }

BinaryenOp BinaryenReplaceLaneVecI16x8(void) { return ReplaceLaneVecI16x8; }

BinaryenOp BinaryenSplatVecI32x4(void) { return SplatVecI32x4; }

BinaryenOp BinaryenExtractLaneVecI32x4(void) { return ExtractLaneVecI32x4; }

BinaryenOp BinaryenReplaceLaneVecI32x4(void) { return ReplaceLaneVecI32x4; }

BinaryenOp BinaryenSplatVecI64x2(void) { return SplatVecI64x2; }

BinaryenOp BinaryenExtractLaneVecI64x2(void) { return ExtractLaneVecI64x2; }

BinaryenOp BinaryenReplaceLaneVecI64x2(void) { return ReplaceLaneVecI64x2; }

BinaryenOp BinaryenSplatVecF32x4(void) { return SplatVecF32x4; }

BinaryenOp BinaryenExtractLaneVecF32x4(void) { return ExtractLaneVecF32x4; }

BinaryenOp BinaryenReplaceLaneVecF32x4(void) { return ReplaceLaneVecF32x4; }

BinaryenOp BinaryenSplatVecF64x2(void) { return SplatVecF64x2; }

BinaryenOp BinaryenExtractLaneVecF64x2(void) { return ExtractLaneVecF64x2; }

BinaryenOp BinaryenReplaceLaneVecF64x2(void) { return ReplaceLaneVecF64x2; }

BinaryenOp BinaryenEqVecI8x16(void) { return EqVecI8x16; }

BinaryenOp BinaryenNeVecI8x16(void) { return NeVecI8x16; }

BinaryenOp BinaryenLtSVecI8x16(void) { return LtSVecI8x16; }

BinaryenOp BinaryenLtUVecI8x16(void) { return LtUVecI8x16; }

BinaryenOp BinaryenGtSVecI8x16(void) { return GtSVecI8x16; }

BinaryenOp BinaryenGtUVecI8x16(void) { return GtUVecI8x16; }

BinaryenOp BinaryenLeSVecI8x16(void) { return LeSVecI8x16; }

BinaryenOp BinaryenLeUVecI8x16(void) { return LeUVecI8x16; }

BinaryenOp BinaryenGeSVecI8x16(void) { return GeSVecI8x16; }

BinaryenOp BinaryenGeUVecI8x16(void) { return GeUVecI8x16; }

BinaryenOp BinaryenEqVecI16x8(void) { return EqVecI16x8; }

BinaryenOp BinaryenNeVecI16x8(void) { return NeVecI16x8; }

BinaryenOp BinaryenLtSVecI16x8(void) { return LtSVecI16x8; }

BinaryenOp BinaryenLtUVecI16x8(void) { return LtUVecI16x8; }

BinaryenOp BinaryenGtSVecI16x8(void) { return GtSVecI16x8; }

BinaryenOp BinaryenGtUVecI16x8(void) { return GtUVecI16x8; }

BinaryenOp BinaryenLeSVecI16x8(void) { return LeSVecI16x8; }

BinaryenOp BinaryenLeUVecI16x8(void) { return LeUVecI16x8; }

BinaryenOp BinaryenGeSVecI16x8(void) { return GeSVecI16x8; }

BinaryenOp BinaryenGeUVecI16x8(void) { return GeUVecI16x8; }

BinaryenOp BinaryenEqVecI32x4(void) { return EqVecI32x4; }

BinaryenOp BinaryenNeVecI32x4(void) { return NeVecI32x4; }

BinaryenOp BinaryenLtSVecI32x4(void) { return LtSVecI32x4; }

BinaryenOp BinaryenLtUVecI32x4(void) { return LtUVecI32x4; }

BinaryenOp BinaryenGtSVecI32x4(void) { return GtSVecI32x4; }

BinaryenOp BinaryenGtUVecI32x4(void) { return GtUVecI32x4; }

BinaryenOp BinaryenLeSVecI32x4(void) { return LeSVecI32x4; }

BinaryenOp BinaryenLeUVecI32x4(void) { return LeUVecI32x4; }

BinaryenOp BinaryenGeSVecI32x4(void) { return GeSVecI32x4; }

BinaryenOp BinaryenGeUVecI32x4(void) { return GeUVecI32x4; }

BinaryenOp BinaryenEqVecF32x4(void) { return EqVecF32x4; }

BinaryenOp BinaryenNeVecF32x4(void) { return NeVecF32x4; }

BinaryenOp BinaryenLtVecF32x4(void) { return LtVecF32x4; }

BinaryenOp BinaryenGtVecF32x4(void) { return GtVecF32x4; }

BinaryenOp BinaryenLeVecF32x4(void) { return LeVecF32x4; }

BinaryenOp BinaryenGeVecF32x4(void) { return GeVecF32x4; }

BinaryenOp BinaryenEqVecF64x2(void) { return EqVecF64x2; }

BinaryenOp BinaryenNeVecF64x2(void) { return NeVecF64x2; }

BinaryenOp BinaryenLtVecF64x2(void) { return LtVecF64x2; }

BinaryenOp BinaryenGtVecF64x2(void) { return GtVecF64x2; }

BinaryenOp BinaryenLeVecF64x2(void) { return LeVecF64x2; }

BinaryenOp BinaryenGeVecF64x2(void) { return GeVecF64x2; }

BinaryenOp BinaryenNotVec128(void) { return NotVec128; }

BinaryenOp BinaryenAndVec128(void) { return AndVec128; }

BinaryenOp BinaryenOrVec128(void) { return OrVec128; }

BinaryenOp BinaryenXorVec128(void) { return XorVec128; }

BinaryenOp BinaryenAndNotVec128(void) { return AndNotVec128; }

BinaryenOp BinaryenBitselectVec128(void) { return Bitselect; }

BinaryenOp BinaryenAbsVecI8x16(void) { return AbsVecI8x16; }

BinaryenOp BinaryenNegVecI8x16(void) { return NegVecI8x16; }

BinaryenOp BinaryenAnyTrueVecI8x16(void) { return AnyTrueVecI8x16; }

BinaryenOp BinaryenAllTrueVecI8x16(void) { return AllTrueVecI8x16; }

BinaryenOp BinaryenBitmaskVecI8x16(void) { return BitmaskVecI8x16; }

BinaryenOp BinaryenShlVecI8x16(void) { return ShlVecI8x16; }

BinaryenOp BinaryenShrSVecI8x16(void) { return ShrSVecI8x16; }

BinaryenOp BinaryenShrUVecI8x16(void) { return ShrUVecI8x16; }

BinaryenOp BinaryenAddVecI8x16(void) { return AddVecI8x16; }

BinaryenOp BinaryenAddSatSVecI8x16(void) { return AddSatSVecI8x16; }

BinaryenOp BinaryenAddSatUVecI8x16(void) { return AddSatUVecI8x16; }

BinaryenOp BinaryenSubVecI8x16(void) { return SubVecI8x16; }

BinaryenOp BinaryenSubSatSVecI8x16(void) { return SubSatSVecI8x16; }

BinaryenOp BinaryenSubSatUVecI8x16(void) { return SubSatUVecI8x16; }

BinaryenOp BinaryenMulVecI8x16(void) { return MulVecI8x16; }

BinaryenOp BinaryenMinSVecI8x16(void) { return MinSVecI8x16; }

BinaryenOp BinaryenMinUVecI8x16(void) { return MinUVecI8x16; }

BinaryenOp BinaryenMaxSVecI8x16(void) { return MaxSVecI8x16; }

BinaryenOp BinaryenMaxUVecI8x16(void) { return MaxUVecI8x16; }

BinaryenOp BinaryenAvgrUVecI8x16(void) { return AvgrUVecI8x16; }

BinaryenOp BinaryenAbsVecI16x8(void) { return AbsVecI16x8; }

BinaryenOp BinaryenNegVecI16x8(void) { return NegVecI16x8; }

BinaryenOp BinaryenAnyTrueVecI16x8(void) { return AnyTrueVecI16x8; }

BinaryenOp BinaryenAllTrueVecI16x8(void) { return AllTrueVecI16x8; }

BinaryenOp BinaryenBitmaskVecI16x8(void) { return BitmaskVecI16x8; }

BinaryenOp BinaryenShlVecI16x8(void) { return ShlVecI16x8; }

BinaryenOp BinaryenShrSVecI16x8(void) { return ShrSVecI16x8; }

BinaryenOp BinaryenShrUVecI16x8(void) { return ShrUVecI16x8; }

BinaryenOp BinaryenAddVecI16x8(void) { return AddVecI16x8; }

BinaryenOp BinaryenAddSatSVecI16x8(void) { return AddSatSVecI16x8; }

BinaryenOp BinaryenAddSatUVecI16x8(void) { return AddSatUVecI16x8; }

BinaryenOp BinaryenSubVecI16x8(void) { return SubVecI16x8; }

BinaryenOp BinaryenSubSatSVecI16x8(void) { return SubSatSVecI16x8; }

BinaryenOp BinaryenSubSatUVecI16x8(void) { return SubSatUVecI16x8; }

BinaryenOp BinaryenMulVecI16x8(void) { return MulVecI16x8; }

BinaryenOp BinaryenMinSVecI16x8(void) { return MinSVecI16x8; }

BinaryenOp BinaryenMinUVecI16x8(void) { return MinUVecI16x8; }

BinaryenOp BinaryenMaxSVecI16x8(void) { return MaxSVecI16x8; }

BinaryenOp BinaryenMaxUVecI16x8(void) { return MaxUVecI16x8; }

BinaryenOp BinaryenAvgrUVecI16x8(void) { return AvgrUVecI16x8; }

BinaryenOp BinaryenAbsVecI32x4(void) { return AbsVecI32x4; }

BinaryenOp BinaryenNegVecI32x4(void) { return NegVecI32x4; }

BinaryenOp BinaryenAnyTrueVecI32x4(void) { return AnyTrueVecI32x4; }

BinaryenOp BinaryenAllTrueVecI32x4(void) { return AllTrueVecI32x4; }

BinaryenOp BinaryenBitmaskVecI32x4(void) { return BitmaskVecI32x4; }

BinaryenOp BinaryenShlVecI32x4(void) { return ShlVecI32x4; }

BinaryenOp BinaryenShrSVecI32x4(void) { return ShrSVecI32x4; }

BinaryenOp BinaryenShrUVecI32x4(void) { return ShrUVecI32x4; }

BinaryenOp BinaryenAddVecI32x4(void) { return AddVecI32x4; }

BinaryenOp BinaryenSubVecI32x4(void) { return SubVecI32x4; }

BinaryenOp BinaryenMulVecI32x4(void) { return MulVecI32x4; }

BinaryenOp BinaryenMinSVecI32x4(void) { return MinSVecI32x4; }

BinaryenOp BinaryenMinUVecI32x4(void) { return MinUVecI32x4; }

BinaryenOp BinaryenMaxSVecI32x4(void) { return MaxSVecI32x4; }

BinaryenOp BinaryenMaxUVecI32x4(void) { return MaxUVecI32x4; }

BinaryenOp BinaryenDotSVecI16x8ToVecI32x4(void) {

return DotSVecI16x8ToVecI32x4;

}

BinaryenOp BinaryenNegVecI64x2(void) { return NegVecI64x2; }

BinaryenOp BinaryenAnyTrueVecI64x2(void) { return AnyTrueVecI64x2; }

BinaryenOp BinaryenAllTrueVecI64x2(void) { return AllTrueVecI64x2; }

BinaryenOp BinaryenShlVecI64x2(void) { return ShlVecI64x2; }

BinaryenOp BinaryenShrSVecI64x2(void) { return ShrSVecI64x2; }

BinaryenOp BinaryenShrUVecI64x2(void) { return ShrUVecI64x2; }

BinaryenOp BinaryenAddVecI64x2(void) { return AddVecI64x2; }

BinaryenOp BinaryenSubVecI64x2(void) { return SubVecI64x2; }

BinaryenOp BinaryenMulVecI64x2(void) { return MulVecI64x2; }

BinaryenOp BinaryenAbsVecF32x4(void) { return AbsVecF32x4; }

BinaryenOp BinaryenNegVecF32x4(void) { return NegVecF32x4; }

BinaryenOp BinaryenSqrtVecF32x4(void) { return SqrtVecF32x4; }

BinaryenOp BinaryenQFMAVecF32x4(void) { return QFMAF32x4; }

BinaryenOp BinaryenQFMSVecF32x4(void) { return QFMSF32x4; }

BinaryenOp BinaryenAddVecF32x4(void) { return AddVecF32x4; }

BinaryenOp BinaryenSubVecF32x4(void) { return SubVecF32x4; }

BinaryenOp BinaryenMulVecF32x4(void) { return MulVecF32x4; }

BinaryenOp BinaryenDivVecF32x4(void) { return DivVecF32x4; }

BinaryenOp BinaryenMinVecF32x4(void) { return MinVecF32x4; }

BinaryenOp BinaryenMaxVecF32x4(void) { return MaxVecF32x4; }

BinaryenOp BinaryenPMinVecF32x4(void) { return PMinVecF32x4; }

BinaryenOp BinaryenCeilVecF32x4(void) { return CeilVecF32x4; }

BinaryenOp BinaryenFloorVecF32x4(void) { return FloorVecF32x4; }

BinaryenOp BinaryenTruncVecF32x4(void) { return TruncVecF32x4; }

BinaryenOp BinaryenNearestVecF32x4(void) { return NearestVecF32x4; }

BinaryenOp BinaryenPMaxVecF32x4(void) { return PMaxVecF32x4; }

BinaryenOp BinaryenAbsVecF64x2(void) { return AbsVecF64x2; }

BinaryenOp BinaryenNegVecF64x2(void) { return NegVecF64x2; }

BinaryenOp BinaryenSqrtVecF64x2(void) { return SqrtVecF64x2; }

BinaryenOp BinaryenQFMAVecF64x2(void) { return QFMAF64x2; }

BinaryenOp BinaryenQFMSVecF64x2(void) { return QFMSF64x2; }

BinaryenOp BinaryenAddVecF64x2(void) { return AddVecF64x2; }

BinaryenOp BinaryenSubVecF64x2(void) { return SubVecF64x2; }

BinaryenOp BinaryenMulVecF64x2(void) { return MulVecF64x2; }

BinaryenOp BinaryenDivVecF64x2(void) { return DivVecF64x2; }

BinaryenOp BinaryenMinVecF64x2(void) { return MinVecF64x2; }

BinaryenOp BinaryenMaxVecF64x2(void) { return MaxVecF64x2; }

BinaryenOp BinaryenPMinVecF64x2(void) { return PMinVecF64x2; }

BinaryenOp BinaryenPMaxVecF64x2(void) { return PMaxVecF64x2; }

BinaryenOp BinaryenCeilVecF64x2(void) { return CeilVecF64x2; }

BinaryenOp BinaryenFloorVecF64x2(void) { return FloorVecF64x2; }

BinaryenOp BinaryenTruncVecF64x2(void) { return TruncVecF64x2; }

BinaryenOp BinaryenNearestVecF64x2(void) { return NearestVecF64x2; }

BinaryenOp BinaryenTruncSatSVecF32x4ToVecI32x4(void) {

return TruncSatSVecF32x4ToVecI32x4;

}

BinaryenOp BinaryenTruncSatUVecF32x4ToVecI32x4(void) {

return TruncSatUVecF32x4ToVecI32x4;

}

BinaryenOp BinaryenTruncSatSVecF64x2ToVecI64x2(void) {

return TruncSatSVecF64x2ToVecI64x2;

}

BinaryenOp BinaryenTruncSatUVecF64x2ToVecI64x2(void) {

return TruncSatUVecF64x2ToVecI64x2;

}

BinaryenOp BinaryenConvertSVecI32x4ToVecF32x4(void) {

return ConvertSVecI32x4ToVecF32x4;

}

BinaryenOp BinaryenConvertUVecI32x4ToVecF32x4(void) {

return ConvertUVecI32x4ToVecF32x4;

}

BinaryenOp BinaryenConvertSVecI64x2ToVecF64x2(void) {

return ConvertSVecI64x2ToVecF64x2;

}

BinaryenOp BinaryenConvertUVecI64x2ToVecF64x2(void) {

return ConvertUVecI64x2ToVecF64x2;

}

BinaryenOp BinaryenLoadSplatVec8x16(void) { return LoadSplatVec8x16; }

BinaryenOp BinaryenLoadSplatVec16x8(void) { return LoadSplatVec16x8; }

BinaryenOp BinaryenLoadSplatVec32x4(void) { return LoadSplatVec32x4; }

BinaryenOp BinaryenLoadSplatVec64x2(void) { return LoadSplatVec64x2; }

BinaryenOp BinaryenLoadExtSVec8x8ToVecI16x8(void) {

return LoadExtSVec8x8ToVecI16x8;

}

BinaryenOp BinaryenLoadExtUVec8x8ToVecI16x8(void) {

return LoadExtUVec8x8ToVecI16x8;

}

BinaryenOp BinaryenLoadExtSVec16x4ToVecI32x4(void) {

return LoadExtSVec16x4ToVecI32x4;

}

BinaryenOp BinaryenLoadExtUVec16x4ToVecI32x4(void) {

return LoadExtUVec16x4ToVecI32x4;

}

BinaryenOp BinaryenLoadExtSVec32x2ToVecI64x2(void) {

return LoadExtSVec32x2ToVecI64x2;

}

BinaryenOp BinaryenLoadExtUVec32x2ToVecI64x2(void) {

return LoadExtUVec32x2ToVecI64x2;

}

BinaryenOp BinaryenNarrowSVecI16x8ToVecI8x16(void) {

return NarrowSVecI16x8ToVecI8x16;

}

BinaryenOp BinaryenNarrowUVecI16x8ToVecI8x16(void) {

return NarrowUVecI16x8ToVecI8x16;

}

BinaryenOp BinaryenNarrowSVecI32x4ToVecI16x8(void) {

return NarrowSVecI32x4ToVecI16x8;

}

BinaryenOp BinaryenNarrowUVecI32x4ToVecI16x8(void) {

return NarrowUVecI32x4ToVecI16x8;

}

BinaryenOp BinaryenWidenLowSVecI8x16ToVecI16x8(void) {

return WidenLowSVecI8x16ToVecI16x8;

}

BinaryenOp BinaryenWidenHighSVecI8x16ToVecI16x8(void) {

return WidenHighSVecI8x16ToVecI16x8;

}

BinaryenOp BinaryenWidenLowUVecI8x16ToVecI16x8(void) {

return WidenLowUVecI8x16ToVecI16x8;

}

BinaryenOp BinaryenWidenHighUVecI8x16ToVecI16x8(void) {

return WidenHighUVecI8x16ToVecI16x8;

}

BinaryenOp BinaryenWidenLowSVecI16x8ToVecI32x4(void) {

return WidenLowSVecI16x8ToVecI32x4;

}

BinaryenOp BinaryenWidenHighSVecI16x8ToVecI32x4(void) {

return WidenHighSVecI16x8ToVecI32x4;

}

BinaryenOp BinaryenWidenLowUVecI16x8ToVecI32x4(void) {

return WidenLowUVecI16x8ToVecI32x4;

}

BinaryenOp BinaryenWidenHighUVecI16x8ToVecI32x4(void) {

return WidenHighUVecI16x8ToVecI32x4;

}

BinaryenOp BinaryenSwizzleVec8x16(void) { return SwizzleVec8x16; }

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();

}

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();

return static_cast<Expression*>(ret);

}

BinaryenExpressionRef BinaryenLoop(BinaryenModuleRef module,

const char* name,

BinaryenExpressionRef body) {

return static_cast<Expression*>(

Builder(*(Module*)module)

.makeLoop(name ? Name(name) : Name(), (Expression*)body));

}

BinaryenExpressionRef BinaryenBreak(BinaryenModuleRef module,

const char* name,

BinaryenExpressionRef condition,

BinaryenExpressionRef value) {

return static_cast<Expression*>(

Builder(*(Module*)module)

.makeBreak(name, (Expression*)value, (Expression*)condition));

}

BinaryenExpressionRef BinaryenSwitch(BinaryenModuleRef module,

const char** names,

BinaryenIndex numNames,

const char* defaultName,

BinaryenExpressionRef condition,

BinaryenExpressionRef value) {

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

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

}

static BinaryenExpressionRef makeBinaryenCall(BinaryenModuleRef module,

const char* target,

BinaryenExpressionRef* operands,

BinaryenIndex numOperands,

BinaryenType returnType,

bool isReturn) {

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

ret->target = target;

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

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

}

ret->type = Type(returnType);

ret->isReturn = isReturn;

ret->finalize();

return static_cast<Expression*>(ret);

}

BinaryenExpressionRef BinaryenCall(BinaryenModuleRef module,

const char* target,

BinaryenExpressionRef* operands,

BinaryenIndex numOperands,

BinaryenType returnType) {

return makeBinaryenCall(

module, target, operands, numOperands, returnType, false);

}

BinaryenExpressionRef BinaryenReturnCall(BinaryenModuleRef module,

const char* target,

BinaryenExpressionRef* operands,

BinaryenIndex numOperands,

BinaryenType returnType) {

return makeBinaryenCall(

module, target, operands, numOperands, returnType, true);

}

static BinaryenExpressionRef

makeBinaryenCallIndirect(BinaryenModuleRef module,

BinaryenExpressionRef target,

BinaryenExpressionRef* operands,

BinaryenIndex numOperands,

BinaryenType params,

BinaryenType results,

bool isReturn) {

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

ret->target = (Expression*)target;

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

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

}

ret->sig = Signature(Type(params), Type(results));

ret->type = Type(results);

ret->isReturn = isReturn;

ret->finalize();

return static_cast<Expression*>(ret);

}

BinaryenExpressionRef BinaryenCallIndirect(BinaryenModuleRef module,

BinaryenExpressionRef target,

BinaryenExpressionRef* operands,

BinaryenIndex numOperands,

BinaryenType params,

BinaryenType results) {

return makeBinaryenCallIndirect(

module, target, operands, numOperands, params, results, false);

}

BinaryenExpressionRef

BinaryenReturnCallIndirect(BinaryenModuleRef module,

BinaryenExpressionRef target,

BinaryenExpressionRef* operands,

BinaryenIndex numOperands,

BinaryenType params,

BinaryenType results) {

return makeBinaryenCallIndirect(

module, target, operands, numOperands, params, results, true);

}

BinaryenExpressionRef BinaryenLocalGet(BinaryenModuleRef module,

BinaryenIndex index,

BinaryenType type) {

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

ret->index = index;

ret->type = Type(type);

ret->finalize();

return static_cast<Expression*>(ret);

}

BinaryenExpressionRef BinaryenLocalSet(BinaryenModuleRef module,

BinaryenIndex index,

BinaryenExpressionRef value) {

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

ret->index = index;

ret->value = (Expression*)value;

ret->makeSet();

ret->finalize();

return static_cast<Expression*>(ret);

}

BinaryenExpressionRef BinaryenLocalTee(BinaryenModuleRef module,

BinaryenIndex index,

BinaryenExpressionRef value,

BinaryenType type) {

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

ret->index = index;

ret->value = (Expression*)value;

ret->makeTee(Type(type));

ret->finalize();

return static_cast<Expression*>(ret);

}

BinaryenExpressionRef BinaryenGlobalGet(BinaryenModuleRef module,

const char* name,

BinaryenType type) {

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

ret->name = name;

ret->type = Type(type);

ret->finalize();

return static_cast<Expression*>(ret);

}

BinaryenExpressionRef BinaryenGlobalSet(BinaryenModuleRef module,

const char* name,

BinaryenExpressionRef value) {

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

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>();

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>();

ret->isAtomic = false;

ret->bytes = bytes;

ret->offset = offset;