/*

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

switch (x.type.getSingle()) {

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::anyref:

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::anyref:

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

// Tracing support

static int tracing = 0;

void traceNameOrNULL(const char* name, std::ostream& out = std::cout) {

if (name) {

out << "\"" << name << "\"";

} else {

out << "NULL";

}

}

std::map<BinaryenType, size_t> types;

std::map<BinaryenExpressionRef, size_t> expressions;

std::map<BinaryenFunctionRef, size_t> functions;

std::map<BinaryenGlobalRef, size_t> globals;

std::map<BinaryenEventRef, size_t> events;

std::map<BinaryenExportRef, size_t> exports;

std::map<RelooperBlockRef, size_t> relooperBlocks;

static bool isBasicAPIType(BinaryenType type) {

return type == BinaryenTypeAuto() || type <= Type::_last_value_type;

}

static const char* basicAPITypeFunction(BinaryenType type) {

if (type == BinaryenTypeAuto()) {

return "BinaryenTypeAuto()";

}

switch (type) {

case Type::none:

return "BinaryenTypeNone()";

case Type::i32:

return "BinaryenTypeInt32()";

case Type::i64:

return "BinaryenTypeInt64()";

case Type::f32:

return "BinaryenTypeFloat32()";

case Type::f64:

return "BinaryenTypeFloat64()";

case Type::v128:

return "BinaryenTypeVec128()";

case Type::funcref:

return "BinaryenTypeFuncref()";

case Type::anyref:

return "BinaryenTypeAnyref()";

case Type::nullref:

return "BinaryenTypeNullref()";

case Type::exnref:

return "BinaryenTypeExnref()";

case Type::unreachable:

return "BinaryenTypeUnreachable()";

default:

WASM_UNREACHABLE("unexpected type");

}

}

struct TypeArg {

BinaryenType type;

TypeArg(BinaryenType type) : type(type){};

};

std::ostream& operator<<(std::ostream& os, TypeArg t) {

if (isBasicAPIType(t.type)) {

return os << basicAPITypeFunction(t.type);

} else {

auto it = types.find(t.type);

assert(it != types.end());

return os << "types[" << it->second << "]";

}

}

size_t noteType(BinaryenType type) {

// Basic types can be trivially rematerialized at every use

assert(!isBasicAPIType(type));

// Unlike expressions, the same type can be created multiple times

auto it = types.find(type);

if (it != types.end()) {

return it->second;

} else {

auto id = types.size();

types[type] = id;

return id;

}

}

size_t noteExpression(BinaryenExpressionRef expression) {

auto id = expressions.size();

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

expressions[expression] = id;

return id;

}

std::string getTemp() {

static size_t n = 0;

return "t" + std::to_string(n++);

}

template<typename T>

void printArg(std::ostream& setup, std::ostream& out, T arg) {

out << arg;

}

template<>

void printArg(std::ostream& setup, std::ostream& out, BinaryenType arg) {

out << TypeArg(arg);

}

template<>

void printArg(std::ostream& setup,

std::ostream& out,

BinaryenExpressionRef arg) {

out << "expressions[" << expressions[arg] << "]";

}

struct StringLit {

const char* name;

StringLit(const char* name) : name(name){};

};

template<>

void printArg(std::ostream& setup, std::ostream& out, StringLit arg) {

traceNameOrNULL(arg.name, out);

}

template<>

void printArg(std::ostream& setup, std::ostream& out, BinaryenLiteral arg) {

switch (arg.type) {

case Type::i32:

out << "BinaryenLiteralInt32(" << arg.i32 << ")";

break;

case Type::i64:

out << "BinaryenLiteralInt64(" << arg.i64 << ")";

break;

case Type::f32:

if (std::isnan(arg.f32)) {

out << "BinaryenLiteralFloat32(NAN)";

break;

} else {

out << "BinaryenLiteralFloat32(" << arg.f32 << ")";

break;

}

case Type::f64:

if (std::isnan(arg.f64)) {

out << "BinaryenLiteralFloat64(NAN)";

break;

} else {

out << "BinaryenLiteralFloat64(" << arg.f64 << ")";

break;

}

case Type::v128: {

std::string array = getTemp();

setup << "uint8_t " << array << "[] = {";

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

setup << int(arg.v128[i]);

if (i < 15) {

setup << ", ";

}

}

setup << "};\n";

out << "BinaryenLiteralVec128(" << array << ")";

break;

}

case Type::funcref:

out << "BinaryenLiteralFuncref(" << arg.func << ")";

break;

case Type::nullref:

out << "BinaryenLiteralNullref()";

break;

case Type::anyref:

case Type::exnref:

case Type::none:

case Type::unreachable:

WASM_UNREACHABLE("unexpected type");

}

}

template<typename T>

void traceArgs(std::ostream& setup, std::ostream& out, T arg) {

printArg(setup, out, arg);

}

template<typename T, typename S, typename... Ts>

void traceArgs(

std::ostream& setup, std::ostream& out, T arg, S next, Ts... rest) {

printArg(setup, out, arg);

out << ", ";

traceArgs(setup, out, next, rest...);

}

template<typename... Ts>

void traceExpression(BinaryenExpressionRef expr,

const char* constructor,

Ts... args) {

auto id = noteExpression(expr);

std::stringstream setup, out;

out << "expressions[" << id << "] = " << constructor << "(";

traceArgs(setup, out, "the_module", args...);

out << ");\n";

if (!setup.str().empty()) {

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

for (std::string line; getline(setup, line);) {

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

}

std::cout << " " << out.str();

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

} else {

std::cout << " " << out.str();

}

}

template<typename F>

void traceWithExpressionArray(const char* name,

BinaryenExpressionRef* exprs,

BinaryenIndex numExprs,

F body) {

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

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

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

if (i > 0) {

std::cout << ", ";

}

if (i % 6 == 5) {

std::cout << "\n "; // don't create hugely long lines

}

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

}

if (numExprs == 0) {

// ensure the array is not empty, otherwise a compiler error on VS

std::cout << "0";

}

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

body();

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

}

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 BinaryenTypeAnyref(void) { return Type::anyref; }

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

}

Type result(typeVec);

if (tracing && !isBasicAPIType(result.getID())) {

auto id = noteType(result.getID());

std::string array = getTemp();

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

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

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

std::cout << basicAPITypeFunction(types[i]);

if (i < numTypes - 1) {

std::cout << ", ";

}

}

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

std::cout << " types[" << id << "] = BinaryenTypeCreate(" << array

<< ", " << numTypes << ");\n";

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

}

return result.getID();

}

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

void BinaryenTypeExpand(BinaryenType t, BinaryenType* buf) {

const std::vector<Type>& types = Type(t).expand();

for (size_t i = 0; i < types.size(); ++i) {

buf[i] = types[i].getSingle();

}

}

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 BinaryenPushId(void) { return Expression::Id::PushId; }

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

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 << " types.clear();\n";

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

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

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

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

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

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

types.clear();

expressions.clear();

functions.clear();

globals.clear();

events.clear();

exports.clear();

relooperBlocks.clear();

}

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

}