/*

* 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 "parser/wat-parser.h"

#include "pass.h"

#include "shell-interface.h"

#include "support/colors.h"

#include "support/string.h"

#include "wasm-binary.h"

#include "wasm-builder.h"

#include "wasm-interpreter.h"

#include "wasm-stack.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();

assert(x.type.isSingle());

if (x.type.isBasic()) {

switch (x.type.getBasic()) {

case Type::i32:

ret.i32 = x.geti32();

return ret;

case Type::i64:

ret.i64 = x.geti64();

return ret;

case Type::f32:

ret.i32 = x.reinterpreti32();

return ret;

case Type::f64:

ret.i64 = x.reinterpreti64();

return ret;

case Type::v128:

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

return ret;

case Type::none:

case Type::unreachable:

WASM_UNREACHABLE("unexpected type");

}

}

assert(x.type.isRef());

auto heapType = x.type.getHeapType();

if (heapType.isBasic()) {

switch (heapType.getBasic(Unshared)) {

case HeapType::i31:

WASM_UNREACHABLE("TODO: i31");

case HeapType::ext:

WASM_UNREACHABLE("TODO: extern literals");

case HeapType::any:

case HeapType::eq:

case HeapType::func:

case HeapType::cont:

case HeapType::struct_:

case HeapType::array:

case HeapType::exn:

WASM_UNREACHABLE("invalid type");

case HeapType::string:

WASM_UNREACHABLE("TODO: string literals");

case HeapType::none:

case HeapType::noext:

case HeapType::nofunc:

case HeapType::nocont:

case HeapType::noexn:

// Null.

return ret;

}

}

if (heapType.isSignature()) {

ret.func = x.getFunc().str.data();

return ret;

}

assert(x.isData());

WASM_UNREACHABLE("TODO: gc data");

}

Literal fromBinaryenLiteral(BinaryenLiteral x) {

auto type = Type(x.type);

if (type.isBasic()) {

switch (type.getBasic()) {

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

case Type::unreachable:

WASM_UNREACHABLE("unexpected type");

}

}

assert(type.isRef());

auto heapType = type.getHeapType();

if (heapType.isBasic()) {

switch (heapType.getBasic(Unshared)) {

case HeapType::i31:

WASM_UNREACHABLE("TODO: i31");

case HeapType::ext:

case HeapType::any:

WASM_UNREACHABLE("TODO: extern literals");

case HeapType::eq:

case HeapType::func:

case HeapType::cont:

case HeapType::struct_:

case HeapType::array:

case HeapType::exn:

WASM_UNREACHABLE("invalid type");

case HeapType::string:

WASM_UNREACHABLE("TODO: string literals");

case HeapType::none:

case HeapType::noext:

case HeapType::nofunc:

case HeapType::nocont:

case HeapType::noexn:

assert(type.isNullable());

return Literal::makeNull(heapType);

}

}

if (heapType.isSignature()) {

return Literal::makeFunc(Name(x.func), type);

}

assert(heapType.isData());

WASM_UNREACHABLE("TODO: gc data");

}

// 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(HeapType::func, Nullable).getID();

}

BinaryenType BinaryenTypeExternref(void) {

return Type(HeapType::ext, Nullable).getID();

}

BinaryenType BinaryenTypeAnyref(void) {

return Type(HeapType::any, Nullable).getID();

}

BinaryenType BinaryenTypeEqref(void) {

return Type(HeapType::eq, Nullable).getID();

}

BinaryenType BinaryenTypeI31ref(void) {

return Type(HeapType::i31, Nullable).getID();

}

BinaryenType BinaryenTypeStructref(void) {

return Type(HeapType::struct_, Nullable).getID();

}

BinaryenType BinaryenTypeArrayref(void) {

return Type(HeapType::array, Nullable).getID();

}

BinaryenType BinaryenTypeStringref() {

return Type(HeapType::string, Nullable).getID();

}

BinaryenType BinaryenTypeNullref() {

return Type(HeapType::none, Nullable).getID();

}

BinaryenType BinaryenTypeNullExternref(void) {

return Type(HeapType::noext, Nullable).getID();

}

BinaryenType BinaryenTypeNullFuncref(void) {

return Type(HeapType::nofunc, Nullable).getID();

}

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

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

BinaryenType BinaryenTypeCreate(BinaryenType* types, BinaryenIndex numTypes) {

std::vector<Type> typeVec;

typeVec.reserve(numTypes);

for (BinaryenIndex 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); }

// Packed types

BinaryenPackedType BinaryenPackedTypeNotPacked(void) {

return Field::PackedType::NotPacked;

}

BinaryenPackedType BinaryenPackedTypeInt8(void) {

return Field::PackedType::i8;

}

BinaryenPackedType BinaryenPackedTypeInt16(void) {

return Field::PackedType::i16;

}

// Heap types

BinaryenHeapType BinaryenHeapTypeExt() {

return static_cast<BinaryenHeapType>(HeapType::BasicHeapType::ext);

}

BinaryenHeapType BinaryenHeapTypeFunc() {

return static_cast<BinaryenHeapType>(HeapType::BasicHeapType::func);

}

BinaryenHeapType BinaryenHeapTypeAny() {

return static_cast<BinaryenHeapType>(HeapType::BasicHeapType::any);

}

BinaryenHeapType BinaryenHeapTypeEq() {

return static_cast<BinaryenHeapType>(HeapType::BasicHeapType::eq);

}

BinaryenHeapType BinaryenHeapTypeI31() {

return static_cast<BinaryenHeapType>(HeapType::BasicHeapType::i31);

}

BinaryenHeapType BinaryenHeapTypeStruct() {

return static_cast<BinaryenHeapType>(HeapType::BasicHeapType::struct_);

}

BinaryenHeapType BinaryenHeapTypeArray() {

return static_cast<BinaryenHeapType>(HeapType::BasicHeapType::array);

}

BinaryenHeapType BinaryenHeapTypeString() {

return static_cast<BinaryenHeapType>(HeapType::BasicHeapType::string);

}

BinaryenHeapType BinaryenHeapTypeNone() {

return static_cast<BinaryenHeapType>(HeapType::BasicHeapType::none);

}

BinaryenHeapType BinaryenHeapTypeNoext() {

return static_cast<BinaryenHeapType>(HeapType::BasicHeapType::noext);

}

BinaryenHeapType BinaryenHeapTypeNofunc() {

return static_cast<BinaryenHeapType>(HeapType::BasicHeapType::nofunc);

}

bool BinaryenHeapTypeIsBasic(BinaryenHeapType heapType) {

return HeapType(heapType).isBasic();

}

bool BinaryenHeapTypeIsSignature(BinaryenHeapType heapType) {

return HeapType(heapType).isSignature();

}

bool BinaryenHeapTypeIsStruct(BinaryenHeapType heapType) {

return HeapType(heapType).isStruct();

}

bool BinaryenHeapTypeIsArray(BinaryenHeapType heapType) {

return HeapType(heapType).isArray();

}

bool BinaryenHeapTypeIsBottom(BinaryenHeapType heapType) {

return HeapType(heapType).isBottom();

}

BinaryenHeapType BinaryenHeapTypeGetBottom(BinaryenHeapType heapType) {

return static_cast<BinaryenHeapType>(HeapType(heapType).getBottom());

}

bool BinaryenHeapTypeIsSubType(BinaryenHeapType left, BinaryenHeapType right) {

return HeapType::isSubType(HeapType(left), HeapType(right));

}

BinaryenIndex BinaryenStructTypeGetNumFields(BinaryenHeapType heapType) {

auto ht = HeapType(heapType);

assert(ht.isStruct());

return ht.getStruct().fields.size();

}

BinaryenType BinaryenStructTypeGetFieldType(BinaryenHeapType heapType,

BinaryenIndex index) {

auto ht = HeapType(heapType);

assert(ht.isStruct());

auto& fields = ht.getStruct().fields;

assert(index < fields.size());

return fields[index].type.getID();

}

BinaryenPackedType

BinaryenStructTypeGetFieldPackedType(BinaryenHeapType heapType,

BinaryenIndex index) {

auto ht = HeapType(heapType);

assert(ht.isStruct());

auto& fields = ht.getStruct().fields;

assert(index < fields.size());

return fields[index].packedType;

}

bool BinaryenStructTypeIsFieldMutable(BinaryenHeapType heapType,

BinaryenIndex index) {

auto ht = HeapType(heapType);

assert(ht.isStruct());

auto& fields = ht.getStruct().fields;

assert(index < fields.size());

return fields[index].mutable_;

}

BinaryenType BinaryenArrayTypeGetElementType(BinaryenHeapType heapType) {

auto ht = HeapType(heapType);

assert(ht.isArray());

return ht.getArray().element.type.getID();

}

BinaryenPackedType

BinaryenArrayTypeGetElementPackedType(BinaryenHeapType heapType) {

auto ht = HeapType(heapType);

assert(ht.isArray());

return ht.getArray().element.packedType;

}

bool BinaryenArrayTypeIsElementMutable(BinaryenHeapType heapType) {

auto ht = HeapType(heapType);

assert(ht.isArray());

return ht.getArray().element.mutable_;

}

BinaryenType BinaryenSignatureTypeGetParams(BinaryenHeapType heapType) {

auto ht = HeapType(heapType);

assert(ht.isSignature());

return ht.getSignature().params.getID();

}

BinaryenType BinaryenSignatureTypeGetResults(BinaryenHeapType heapType) {

auto ht = HeapType(heapType);

assert(ht.isSignature());

return ht.getSignature().results.getID();

}

BinaryenHeapType BinaryenTypeGetHeapType(BinaryenType type) {

return Type(type).getHeapType().getID();

}

bool BinaryenTypeIsNullable(BinaryenType type) {

return Type(type).isNullable();

}

BinaryenType BinaryenTypeFromHeapType(BinaryenHeapType heapType,

bool nullable) {

return Type(HeapType(heapType),

nullable ? Nullability::Nullable : Nullability::NonNullable)

.getID();

}

// Expression ids

BinaryenExpressionId BinaryenInvalidId(void) {

return Expression::Id::InvalidId;

}

#define DELEGATE(CLASS_TO_VISIT) \

BinaryenExpressionId Binaryen##CLASS_TO_VISIT##Id(void) { \

return Expression::Id::CLASS_TO_VISIT##Id; \

}

#include "wasm-delegations.def"

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

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

}

// MemoryOrder for atomic operations

BINARYEN_API BinaryenMemoryOrder BinaryenMemoryOrderUnordered(void) {

return static_cast<BinaryenMemoryOrder>(MemoryOrder::Unordered);

}

BINARYEN_API BinaryenMemoryOrder BinaryenMemoryOrderAcqRel(void) {

return static_cast<BinaryenMemoryOrder>(MemoryOrder::AcqRel);

}

BINARYEN_API BinaryenMemoryOrder BinaryenMemoryOrderSeqCst(void) {

return static_cast<BinaryenMemoryOrder>(MemoryOrder::SeqCst);

}

// Features

BinaryenFeatures BinaryenFeatureMVP(void) {

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

}

BinaryenFeatures BinaryenFeatureAtomics(void) {

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

}

BinaryenFeatures BinaryenFeatureMutableGlobals(void) {

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

}

BinaryenFeatures BinaryenFeatureNontrappingFPToInt(void) {

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

}

BinaryenFeatures BinaryenFeatureSIMD128(void) {

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

}

BinaryenFeatures BinaryenFeatureBulkMemory(void) {

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

}

BinaryenFeatures BinaryenFeatureSignExt(void) {

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

}

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

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

}

BinaryenFeatures BinaryenFeatureMemory64(void) {

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

}

BinaryenFeatures BinaryenFeatureRelaxedSIMD(void) {

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

}

BinaryenFeatures BinaryenFeatureExtendedConst(void) {

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

}

BinaryenFeatures BinaryenFeatureStrings(void) {

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

}

BinaryenFeatures BinaryenFeatureMultiMemory(void) {

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

}

BinaryenFeatures BinaryenFeatureStackSwitching(void) {

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

}

BinaryenFeatures BinaryenFeatureSharedEverything(void) {

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

}

BinaryenFeatures BinaryenFeatureFP16(void) {

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

}

BinaryenFeatures BinaryenFeatureBulkMemoryOpt(void) {

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

}

BinaryenFeatures BinaryenFeatureCallIndirectOverlong(void) {

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

}

BinaryenFeatures BinaryenFeatureRelaxedAtomics(void) {

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

}

BinaryenFeatures BinaryenFeatureMultibyte(void) {

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

}

BinaryenFeatures BinaryenFeatureCustomPageSizes(void) {

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

}

BinaryenFeatures BinaryenFeatureWideArithmetic(void) {

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

}

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 BinaryenAtomicRMWAdd(void) { return RMWAdd; }

BinaryenOp BinaryenAtomicRMWSub(void) { return RMWSub; }

BinaryenOp BinaryenAtomicRMWAnd(void) { return RMWAnd; }

BinaryenOp BinaryenAtomicRMWOr(void) { return RMWOr; }

BinaryenOp BinaryenAtomicRMWXor(void) { return RMWXor; }

BinaryenOp BinaryenAtomicRMWXchg(void) { return RMWXchg; }

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 BinaryenEqVecI64x2(void) { return EqVecI64x2; }

BinaryenOp BinaryenNeVecI64x2(void) { return NeVecI64x2; }

BinaryenOp BinaryenLtSVecI64x2(void) { return LtSVecI64x2; }

BinaryenOp BinaryenGtSVecI64x2(void) { return GtSVecI64x2; }

BinaryenOp BinaryenLeSVecI64x2(void) { return LeSVecI64x2; }

BinaryenOp BinaryenGeSVecI64x2(void) { return GeSVecI64x2; }

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 BinaryenRelaxedMaddVecF32x4(void) { return RelaxedMaddVecF32x4; }

BinaryenOp BinaryenRelaxedNmaddVecF32x4(void) { return RelaxedNmaddVecF32x4; }

BinaryenOp BinaryenRelaxedMaddVecF64x2(void) { return RelaxedMaddVecF64x2; }

BinaryenOp BinaryenRelaxedNmaddVecF64x2(void) { return RelaxedNmaddVecF64x2; }

BinaryenOp BinaryenLaneselectI8x16(void) { return LaneselectI8x16; }

BinaryenOp BinaryenLaneselectI16x8(void) { return LaneselectI16x8; }

BinaryenOp BinaryenLaneselectI32x4(void) { return LaneselectI32x4; }

BinaryenOp BinaryenLaneselectI64x2(void) { return LaneselectI64x2; }

BinaryenOp BinaryenDotI8x16I7x16AddSToVecI32x4(void) {

return DotI8x16I7x16AddSToVecI32x4;

}

BinaryenOp BinaryenAnyTrueVec128(void) { return AnyTrueVec128; }

BinaryenOp BinaryenAbsVecI8x16(void) { return AbsVecI8x16; }

BinaryenOp BinaryenNegVecI8x16(void) { return NegVecI8x16; }

BinaryenOp BinaryenAllTrueVecI8x16(void) { return AllTrueVecI8x16; }

BinaryenOp BinaryenBitmaskVecI8x16(void) { return BitmaskVecI8x16; }

BinaryenOp BinaryenPopcntVecI8x16(void) { return PopcntVecI8x16; }

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 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 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 BinaryenQ15MulrSatSVecI16x8(void) { return Q15MulrSatSVecI16x8; }

BinaryenOp BinaryenExtMulLowSVecI16x8(void) { return ExtMulLowSVecI16x8; }

BinaryenOp BinaryenExtMulHighSVecI16x8(void) { return ExtMulHighSVecI16x8; }

BinaryenOp BinaryenExtMulLowUVecI16x8(void) { return ExtMulLowUVecI16x8; }

BinaryenOp BinaryenExtMulHighUVecI16x8(void) { return ExtMulHighUVecI16x8; }

BinaryenOp BinaryenAbsVecI32x4(void) { return AbsVecI32x4; }

BinaryenOp BinaryenNegVecI32x4(void) { return NegVecI32x4; }

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 BinaryenExtMulLowSVecI32x4(void) { return ExtMulLowSVecI32x4; }

BinaryenOp BinaryenExtMulHighSVecI32x4(void) { return ExtMulHighSVecI32x4; }

BinaryenOp BinaryenExtMulLowUVecI32x4(void) { return ExtMulLowUVecI32x4; }

BinaryenOp BinaryenExtMulHighUVecI32x4(void) { return ExtMulHighUVecI32x4; }

BinaryenOp BinaryenAbsVecI64x2(void) { return AbsVecI64x2; }

BinaryenOp BinaryenNegVecI64x2(void) { return NegVecI64x2; }

BinaryenOp BinaryenAllTrueVecI64x2(void) { return AllTrueVecI64x2; }

BinaryenOp BinaryenBitmaskVecI64x2(void) { return BitmaskVecI64x2; }

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 BinaryenExtMulLowSVecI64x2(void) { return ExtMulLowSVecI64x2; }

BinaryenOp BinaryenExtMulHighSVecI64x2(void) { return ExtMulHighSVecI64x2; }

BinaryenOp BinaryenExtMulLowUVecI64x2(void) { return ExtMulLowUVecI64x2; }

BinaryenOp BinaryenExtMulHighUVecI64x2(void) { return ExtMulHighUVecI64x2; }

BinaryenOp BinaryenAbsVecF32x4(void) { return AbsVecF32x4; }

BinaryenOp BinaryenNegVecF32x4(void) { return NegVecF32x4; }

BinaryenOp BinaryenSqrtVecF32x4(void) { return SqrtVecF32x4; }

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

return ExtAddPairwiseSVecI8x16ToI16x8;

}

BinaryenOp BinaryenExtAddPairwiseUVecI8x16ToI16x8(void) {

return ExtAddPairwiseUVecI8x16ToI16x8;

}

BinaryenOp BinaryenExtAddPairwiseSVecI16x8ToI32x4(void) {

return ExtAddPairwiseSVecI16x8ToI32x4;

}

BinaryenOp BinaryenExtAddPairwiseUVecI16x8ToI32x4(void) {

return ExtAddPairwiseUVecI16x8ToI32x4;

}

BinaryenOp BinaryenTruncSatSVecF32x4ToVecI32x4(void) {

return TruncSatSVecF32x4ToVecI32x4;

}

BinaryenOp BinaryenTruncSatUVecF32x4ToVecI32x4(void) {

return TruncSatUVecF32x4ToVecI32x4;

}

BinaryenOp BinaryenConvertSVecI32x4ToVecF32x4(void) {

return ConvertSVecI32x4ToVecF32x4;

}

BinaryenOp BinaryenConvertUVecI32x4ToVecF32x4(void) {

return ConvertUVecI32x4ToVecF32x4;

}

BinaryenOp BinaryenLoad8SplatVec128(void) { return Load8SplatVec128; }

BinaryenOp BinaryenLoad16SplatVec128(void) { return Load16SplatVec128; }

BinaryenOp BinaryenLoad32SplatVec128(void) { return Load32SplatVec128; }

BinaryenOp BinaryenLoad64SplatVec128(void) { return Load64SplatVec128; }

BinaryenOp BinaryenLoad8x8SVec128(void) { return Load8x8SVec128; }

BinaryenOp BinaryenLoad8x8UVec128(void) { return Load8x8UVec128; }

BinaryenOp BinaryenLoad16x4SVec128(void) { return Load16x4SVec128; }

BinaryenOp BinaryenLoad16x4UVec128(void) { return Load16x4UVec128; }

BinaryenOp BinaryenLoad32x2SVec128(void) { return Load32x2SVec128; }

BinaryenOp BinaryenLoad32x2UVec128(void) { return Load32x2UVec128; }

BinaryenOp BinaryenLoad32ZeroVec128(void) { return Load32ZeroVec128; }

BinaryenOp BinaryenLoad64ZeroVec128(void) { return Load64ZeroVec128; }

BinaryenOp BinaryenLoad8LaneVec128(void) { return Load8LaneVec128; }

BinaryenOp BinaryenLoad16LaneVec128(void) { return Load16LaneVec128; }

BinaryenOp BinaryenLoad32LaneVec128(void) { return Load32LaneVec128; }

BinaryenOp BinaryenLoad64LaneVec128(void) { return Load64LaneVec128; }

BinaryenOp BinaryenStore8LaneVec128(void) { return Store8LaneVec128; }

BinaryenOp BinaryenStore16LaneVec128(void) { return Store16LaneVec128; }

BinaryenOp BinaryenStore32LaneVec128(void) { return Store32LaneVec128; }

BinaryenOp BinaryenStore64LaneVec128(void) { return Store64LaneVec128; }

BinaryenOp BinaryenNarrowSVecI16x8ToVecI8x16(void) {

return NarrowSVecI16x8ToVecI8x16;

}

BinaryenOp BinaryenNarrowUVecI16x8ToVecI8x16(void) {

return NarrowUVecI16x8ToVecI8x16;

}

BinaryenOp BinaryenNarrowSVecI32x4ToVecI16x8(void) {

return NarrowSVecI32x4ToVecI16x8;

}

BinaryenOp BinaryenNarrowUVecI32x4ToVecI16x8(void) {

return NarrowUVecI32x4ToVecI16x8;

}

BinaryenOp BinaryenExtendLowSVecI8x16ToVecI16x8(void) {

return ExtendLowSVecI8x16ToVecI16x8;

}

BinaryenOp BinaryenExtendHighSVecI8x16ToVecI16x8(void) {

return ExtendHighSVecI8x16ToVecI16x8;

}

BinaryenOp BinaryenExtendLowUVecI8x16ToVecI16x8(void) {

return ExtendLowUVecI8x16ToVecI16x8;

}

BinaryenOp BinaryenExtendHighUVecI8x16ToVecI16x8(void) {

return ExtendHighUVecI8x16ToVecI16x8;

}

BinaryenOp BinaryenExtendLowSVecI16x8ToVecI32x4(void) {

return ExtendLowSVecI16x8ToVecI32x4;

}

BinaryenOp BinaryenExtendHighSVecI16x8ToVecI32x4(void) {

return ExtendHighSVecI16x8ToVecI32x4;

}

BinaryenOp BinaryenExtendLowUVecI16x8ToVecI32x4(void) {

return ExtendLowUVecI16x8ToVecI32x4;

}

BinaryenOp BinaryenExtendHighUVecI16x8ToVecI32x4(void) {

return ExtendHighUVecI16x8ToVecI32x4;

}

BinaryenOp BinaryenExtendLowSVecI32x4ToVecI64x2(void) {

return ExtendLowSVecI32x4ToVecI64x2;

}

BinaryenOp BinaryenExtendHighSVecI32x4ToVecI64x2(void) {