1 /*
2 * Copyright 2016 WebAssembly Community Group participants
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 //===============================
18 // Binaryen C API implementation
19 //===============================
20
21 #include <mutex>
22
23 #include "binaryen-c.h"
24 #include "cfg/Relooper.h"
25 #include "ir/utils.h"
26 #include "pass.h"
27 #include "shell-interface.h"
28 #include "support/colors.h"
29 #include "wasm-binary.h"
30 #include "wasm-builder.h"
31 #include "wasm-interpreter.h"
32 #include "wasm-printing.h"
33 #include "wasm-s-parser.h"
34 #include "wasm-validator.h"
35 #include "wasm.h"
36 #include "wasm2js.h"
37 #include <iostream>
38 #include <sstream>
39
40 #ifdef __EMSCRIPTEN__
41 #include <emscripten.h>
42 #endif
43
44 using namespace wasm;
45
46 // Literal utilities
47
48 static_assert(sizeof(BinaryenLiteral) == sizeof(Literal),
49 "Binaryen C API literal must match wasm.h");
50
toBinaryenLiteral(Literal x)51 BinaryenLiteral toBinaryenLiteral(Literal x) {
52 BinaryenLiteral ret;
53 ret.type = x.type.getID();
54 TODO_SINGLE_COMPOUND(x.type);
55 switch (x.type.getBasic()) {
56 case Type::i32:
57 ret.i32 = x.geti32();
58 break;
59 case Type::i64:
60 ret.i64 = x.geti64();
61 break;
62 case Type::f32:
63 ret.i32 = x.reinterpreti32();
64 break;
65 case Type::f64:
66 ret.i64 = x.reinterpreti64();
67 break;
68 case Type::v128:
69 memcpy(&ret.v128, x.getv128Ptr(), 16);
70 break;
71 case Type::funcref:
72 ret.func = x.isNull() ? nullptr : x.getFunc().c_str();
73 break;
74 case Type::externref:
75 case Type::exnref:
76 case Type::anyref:
77 case Type::eqref:
78 assert(x.isNull() && "unexpected non-null reference type literal");
79 break;
80 case Type::i31ref:
81 WASM_UNREACHABLE("TODO: i31ref");
82 case Type::none:
83 case Type::unreachable:
84 WASM_UNREACHABLE("unexpected type");
85 }
86 return ret;
87 }
88
fromBinaryenLiteral(BinaryenLiteral x)89 Literal fromBinaryenLiteral(BinaryenLiteral x) {
90 switch (x.type) {
91 case Type::i32:
92 return Literal(x.i32);
93 case Type::i64:
94 return Literal(x.i64);
95 case Type::f32:
96 return Literal(x.i32).castToF32();
97 case Type::f64:
98 return Literal(x.i64).castToF64();
99 case Type::v128:
100 return Literal(x.v128);
101 case Type::funcref:
102 return Literal::makeFunc(x.func);
103 case Type::externref:
104 case Type::exnref:
105 case Type::anyref:
106 case Type::eqref:
107 return Literal::makeNull(Type(x.type));
108 case Type::i31ref:
109 WASM_UNREACHABLE("TODO: i31ref");
110 case Type::none:
111 case Type::unreachable:
112 WASM_UNREACHABLE("unexpected type");
113 }
114 WASM_UNREACHABLE("invalid type");
115 }
116
117 // Mutexes (global for now; in theory if multiple modules
118 // are used at once this should be optimized to be per-
119 // module, but likely it doesn't matter)
120
121 static std::mutex BinaryenFunctionMutex;
122
123 // Optimization options
124 static PassOptions globalPassOptions =
125 PassOptions::getWithDefaultOptimizationOptions();
126
127 extern "C" {
128
129 //
130 // ========== Module Creation ==========
131 //
132
133 // Core types
134
BinaryenTypeNone(void)135 BinaryenType BinaryenTypeNone(void) { return Type::none; }
BinaryenTypeInt32(void)136 BinaryenType BinaryenTypeInt32(void) { return Type::i32; }
BinaryenTypeInt64(void)137 BinaryenType BinaryenTypeInt64(void) { return Type::i64; }
BinaryenTypeFloat32(void)138 BinaryenType BinaryenTypeFloat32(void) { return Type::f32; }
BinaryenTypeFloat64(void)139 BinaryenType BinaryenTypeFloat64(void) { return Type::f64; }
BinaryenTypeVec128(void)140 BinaryenType BinaryenTypeVec128(void) { return Type::v128; }
BinaryenTypeFuncref(void)141 BinaryenType BinaryenTypeFuncref(void) { return Type::funcref; }
BinaryenTypeExternref(void)142 BinaryenType BinaryenTypeExternref(void) { return Type::externref; }
BinaryenTypeExnref(void)143 BinaryenType BinaryenTypeExnref(void) { return Type::exnref; }
BinaryenTypeAnyref(void)144 BinaryenType BinaryenTypeAnyref(void) { return Type::anyref; }
BinaryenTypeEqref(void)145 BinaryenType BinaryenTypeEqref(void) { return Type::eqref; }
BinaryenTypeI31ref(void)146 BinaryenType BinaryenTypeI31ref(void) { return Type::i31ref; }
BinaryenTypeUnreachable(void)147 BinaryenType BinaryenTypeUnreachable(void) { return Type::unreachable; }
BinaryenTypeAuto(void)148 BinaryenType BinaryenTypeAuto(void) { return uintptr_t(-1); }
149
BinaryenTypeCreate(BinaryenType * types,uint32_t numTypes)150 BinaryenType BinaryenTypeCreate(BinaryenType* types, uint32_t numTypes) {
151 std::vector<Type> typeVec;
152 typeVec.reserve(numTypes);
153 for (size_t i = 0; i < numTypes; ++i) {
154 typeVec.push_back(Type(types[i]));
155 }
156 return Type(typeVec).getID();
157 }
158
BinaryenTypeArity(BinaryenType t)159 uint32_t BinaryenTypeArity(BinaryenType t) { return Type(t).size(); }
160
BinaryenTypeExpand(BinaryenType t,BinaryenType * buf)161 void BinaryenTypeExpand(BinaryenType t, BinaryenType* buf) {
162 Type types(t);
163 size_t i = 0;
164 for (const auto& type : types) {
165 buf[i++] = type.getID();
166 }
167 }
168
BinaryenNone(void)169 WASM_DEPRECATED BinaryenType BinaryenNone(void) { return Type::none; }
BinaryenInt32(void)170 WASM_DEPRECATED BinaryenType BinaryenInt32(void) { return Type::i32; }
BinaryenInt64(void)171 WASM_DEPRECATED BinaryenType BinaryenInt64(void) { return Type::i64; }
BinaryenFloat32(void)172 WASM_DEPRECATED BinaryenType BinaryenFloat32(void) { return Type::f32; }
BinaryenFloat64(void)173 WASM_DEPRECATED BinaryenType BinaryenFloat64(void) { return Type::f64; }
BinaryenUndefined(void)174 WASM_DEPRECATED BinaryenType BinaryenUndefined(void) { return uint32_t(-1); }
175
176 // Expression ids
177
BinaryenInvalidId(void)178 BinaryenExpressionId BinaryenInvalidId(void) {
179 return Expression::Id::InvalidId;
180 }
BinaryenBlockId(void)181 BinaryenExpressionId BinaryenBlockId(void) { return Expression::Id::BlockId; }
BinaryenIfId(void)182 BinaryenExpressionId BinaryenIfId(void) { return Expression::Id::IfId; }
BinaryenLoopId(void)183 BinaryenExpressionId BinaryenLoopId(void) { return Expression::Id::LoopId; }
BinaryenBreakId(void)184 BinaryenExpressionId BinaryenBreakId(void) { return Expression::Id::BreakId; }
BinaryenSwitchId(void)185 BinaryenExpressionId BinaryenSwitchId(void) { return Expression::Id::SwitchId; }
BinaryenCallId(void)186 BinaryenExpressionId BinaryenCallId(void) { return Expression::Id::CallId; }
BinaryenCallIndirectId(void)187 BinaryenExpressionId BinaryenCallIndirectId(void) {
188 return Expression::Id::CallIndirectId;
189 }
BinaryenLocalGetId(void)190 BinaryenExpressionId BinaryenLocalGetId(void) {
191 return Expression::Id::LocalGetId;
192 }
BinaryenLocalSetId(void)193 BinaryenExpressionId BinaryenLocalSetId(void) {
194 return Expression::Id::LocalSetId;
195 }
BinaryenGlobalGetId(void)196 BinaryenExpressionId BinaryenGlobalGetId(void) {
197 return Expression::Id::GlobalGetId;
198 }
BinaryenGlobalSetId(void)199 BinaryenExpressionId BinaryenGlobalSetId(void) {
200 return Expression::Id::GlobalSetId;
201 }
BinaryenLoadId(void)202 BinaryenExpressionId BinaryenLoadId(void) { return Expression::Id::LoadId; }
BinaryenStoreId(void)203 BinaryenExpressionId BinaryenStoreId(void) { return Expression::Id::StoreId; }
BinaryenConstId(void)204 BinaryenExpressionId BinaryenConstId(void) { return Expression::Id::ConstId; }
BinaryenUnaryId(void)205 BinaryenExpressionId BinaryenUnaryId(void) { return Expression::Id::UnaryId; }
BinaryenBinaryId(void)206 BinaryenExpressionId BinaryenBinaryId(void) { return Expression::Id::BinaryId; }
BinaryenSelectId(void)207 BinaryenExpressionId BinaryenSelectId(void) { return Expression::Id::SelectId; }
BinaryenDropId(void)208 BinaryenExpressionId BinaryenDropId(void) { return Expression::Id::DropId; }
BinaryenReturnId(void)209 BinaryenExpressionId BinaryenReturnId(void) { return Expression::Id::ReturnId; }
BinaryenMemorySizeId(void)210 BinaryenExpressionId BinaryenMemorySizeId(void) {
211 return Expression::Id::MemorySizeId;
212 }
BinaryenMemoryGrowId(void)213 BinaryenExpressionId BinaryenMemoryGrowId(void) {
214 return Expression::Id::MemoryGrowId;
215 }
BinaryenNopId(void)216 BinaryenExpressionId BinaryenNopId(void) { return Expression::Id::NopId; }
BinaryenUnreachableId(void)217 BinaryenExpressionId BinaryenUnreachableId(void) {
218 return Expression::Id::UnreachableId;
219 }
BinaryenAtomicCmpxchgId(void)220 BinaryenExpressionId BinaryenAtomicCmpxchgId(void) {
221 return Expression::Id::AtomicCmpxchgId;
222 }
BinaryenAtomicRMWId(void)223 BinaryenExpressionId BinaryenAtomicRMWId(void) {
224 return Expression::Id::AtomicRMWId;
225 }
BinaryenAtomicWaitId(void)226 BinaryenExpressionId BinaryenAtomicWaitId(void) {
227 return Expression::Id::AtomicWaitId;
228 }
BinaryenAtomicNotifyId(void)229 BinaryenExpressionId BinaryenAtomicNotifyId(void) {
230 return Expression::Id::AtomicNotifyId;
231 }
BinaryenAtomicFenceId(void)232 BinaryenExpressionId BinaryenAtomicFenceId(void) {
233 return Expression::Id::AtomicFenceId;
234 }
BinaryenSIMDExtractId(void)235 BinaryenExpressionId BinaryenSIMDExtractId(void) {
236 return Expression::Id::SIMDExtractId;
237 }
BinaryenSIMDReplaceId(void)238 BinaryenExpressionId BinaryenSIMDReplaceId(void) {
239 return Expression::Id::SIMDReplaceId;
240 }
BinaryenSIMDShuffleId(void)241 BinaryenExpressionId BinaryenSIMDShuffleId(void) {
242 return Expression::Id::SIMDShuffleId;
243 }
BinaryenSIMDTernaryId(void)244 BinaryenExpressionId BinaryenSIMDTernaryId(void) {
245 return Expression::Id::SIMDTernaryId;
246 }
BinaryenSIMDShiftId(void)247 BinaryenExpressionId BinaryenSIMDShiftId(void) {
248 return Expression::Id::SIMDShiftId;
249 }
BinaryenSIMDLoadId(void)250 BinaryenExpressionId BinaryenSIMDLoadId(void) {
251 return Expression::Id::SIMDLoadId;
252 }
BinaryenMemoryInitId(void)253 BinaryenExpressionId BinaryenMemoryInitId(void) {
254 return Expression::Id::MemoryInitId;
255 }
BinaryenDataDropId(void)256 BinaryenExpressionId BinaryenDataDropId(void) {
257 return Expression::Id::DataDropId;
258 }
BinaryenMemoryCopyId(void)259 BinaryenExpressionId BinaryenMemoryCopyId(void) {
260 return Expression::Id::MemoryCopyId;
261 }
BinaryenMemoryFillId(void)262 BinaryenExpressionId BinaryenMemoryFillId(void) {
263 return Expression::Id::MemoryFillId;
264 }
BinaryenRefNullId(void)265 BinaryenExpressionId BinaryenRefNullId(void) {
266 return Expression::Id::RefNullId;
267 }
BinaryenRefIsNullId(void)268 BinaryenExpressionId BinaryenRefIsNullId(void) {
269 return Expression::Id::RefIsNullId;
270 }
BinaryenRefFuncId(void)271 BinaryenExpressionId BinaryenRefFuncId(void) {
272 return Expression::Id::RefFuncId;
273 }
BinaryenRefEqId(void)274 BinaryenExpressionId BinaryenRefEqId(void) { return Expression::Id::RefEqId; }
BinaryenTryId(void)275 BinaryenExpressionId BinaryenTryId(void) { return Expression::Id::TryId; }
BinaryenThrowId(void)276 BinaryenExpressionId BinaryenThrowId(void) { return Expression::Id::ThrowId; }
BinaryenRethrowId(void)277 BinaryenExpressionId BinaryenRethrowId(void) {
278 return Expression::Id::RethrowId;
279 }
BinaryenBrOnExnId(void)280 BinaryenExpressionId BinaryenBrOnExnId(void) {
281 return Expression::Id::BrOnExnId;
282 }
BinaryenTupleMakeId(void)283 BinaryenExpressionId BinaryenTupleMakeId(void) {
284 return Expression::Id::TupleMakeId;
285 }
BinaryenTupleExtractId(void)286 BinaryenExpressionId BinaryenTupleExtractId(void) {
287 return Expression::Id::TupleExtractId;
288 }
BinaryenPopId(void)289 BinaryenExpressionId BinaryenPopId(void) { return Expression::Id::PopId; }
BinaryenI31NewId(void)290 BinaryenExpressionId BinaryenI31NewId(void) { return Expression::Id::I31NewId; }
BinaryenI31GetId(void)291 BinaryenExpressionId BinaryenI31GetId(void) { return Expression::Id::I31GetId; }
BinaryenRefTestId(void)292 BinaryenExpressionId BinaryenRefTestId(void) {
293 return Expression::Id::RefTestId;
294 }
BinaryenRefCastId(void)295 BinaryenExpressionId BinaryenRefCastId(void) {
296 return Expression::Id::RefCastId;
297 }
BinaryenBrOnCastId(void)298 BinaryenExpressionId BinaryenBrOnCastId(void) {
299 return Expression::Id::BrOnCastId;
300 }
BinaryenRttCanonId(void)301 BinaryenExpressionId BinaryenRttCanonId(void) {
302 return Expression::Id::RttCanonId;
303 }
BinaryenRttSubId(void)304 BinaryenExpressionId BinaryenRttSubId(void) { return Expression::Id::RttSubId; }
BinaryenStructNewId(void)305 BinaryenExpressionId BinaryenStructNewId(void) {
306 return Expression::Id::StructNewId;
307 }
BinaryenStructGetId(void)308 BinaryenExpressionId BinaryenStructGetId(void) {
309 return Expression::Id::StructGetId;
310 }
BinaryenStructSetId(void)311 BinaryenExpressionId BinaryenStructSetId(void) {
312 return Expression::Id::StructSetId;
313 }
BinaryenArrayNewId(void)314 BinaryenExpressionId BinaryenArrayNewId(void) {
315 return Expression::Id::ArrayNewId;
316 }
BinaryenArrayGetId(void)317 BinaryenExpressionId BinaryenArrayGetId(void) {
318 return Expression::Id::ArrayGetId;
319 }
BinaryenArraySetId(void)320 BinaryenExpressionId BinaryenArraySetId(void) {
321 return Expression::Id::ArraySetId;
322 }
BinaryenArrayLenId(void)323 BinaryenExpressionId BinaryenArrayLenId(void) {
324 return Expression::Id::ArrayLenId;
325 }
326
327 // External kinds
328
BinaryenExternalFunction(void)329 BinaryenExternalKind BinaryenExternalFunction(void) {
330 return static_cast<BinaryenExternalKind>(ExternalKind::Function);
331 }
BinaryenExternalTable(void)332 BinaryenExternalKind BinaryenExternalTable(void) {
333 return static_cast<BinaryenExternalKind>(ExternalKind::Table);
334 }
BinaryenExternalMemory(void)335 BinaryenExternalKind BinaryenExternalMemory(void) {
336 return static_cast<BinaryenExternalKind>(ExternalKind::Memory);
337 }
BinaryenExternalGlobal(void)338 BinaryenExternalKind BinaryenExternalGlobal(void) {
339 return static_cast<BinaryenExternalKind>(ExternalKind::Global);
340 }
BinaryenExternalEvent(void)341 BinaryenExternalKind BinaryenExternalEvent(void) {
342 return static_cast<BinaryenExternalKind>(ExternalKind::Event);
343 }
344
345 // Features
346
BinaryenFeatureMVP(void)347 BinaryenFeatures BinaryenFeatureMVP(void) {
348 return static_cast<BinaryenFeatures>(FeatureSet::MVP);
349 }
BinaryenFeatureAtomics(void)350 BinaryenFeatures BinaryenFeatureAtomics(void) {
351 return static_cast<BinaryenFeatures>(FeatureSet::Atomics);
352 }
BinaryenFeatureBulkMemory(void)353 BinaryenFeatures BinaryenFeatureBulkMemory(void) {
354 return static_cast<BinaryenFeatures>(FeatureSet::BulkMemory);
355 }
BinaryenFeatureMutableGlobals(void)356 BinaryenFeatures BinaryenFeatureMutableGlobals(void) {
357 return static_cast<BinaryenFeatures>(FeatureSet::MutableGlobals);
358 }
BinaryenFeatureNontrappingFPToInt(void)359 BinaryenFeatures BinaryenFeatureNontrappingFPToInt(void) {
360 return static_cast<BinaryenFeatures>(FeatureSet::TruncSat);
361 }
BinaryenFeatureSignExt(void)362 BinaryenFeatures BinaryenFeatureSignExt(void) {
363 return static_cast<BinaryenFeatures>(FeatureSet::SignExt);
364 }
BinaryenFeatureSIMD128(void)365 BinaryenFeatures BinaryenFeatureSIMD128(void) {
366 return static_cast<BinaryenFeatures>(FeatureSet::SIMD);
367 }
BinaryenFeatureExceptionHandling(void)368 BinaryenFeatures BinaryenFeatureExceptionHandling(void) {
369 return static_cast<BinaryenFeatures>(FeatureSet::ExceptionHandling);
370 }
BinaryenFeatureTailCall(void)371 BinaryenFeatures BinaryenFeatureTailCall(void) {
372 return static_cast<BinaryenFeatures>(FeatureSet::TailCall);
373 }
BinaryenFeatureReferenceTypes(void)374 BinaryenFeatures BinaryenFeatureReferenceTypes(void) {
375 return static_cast<BinaryenFeatures>(FeatureSet::ReferenceTypes);
376 }
BinaryenFeatureMultivalue(void)377 BinaryenFeatures BinaryenFeatureMultivalue(void) {
378 return static_cast<BinaryenFeatures>(FeatureSet::Multivalue);
379 }
BinaryenFeatureGC(void)380 BinaryenFeatures BinaryenFeatureGC(void) {
381 return static_cast<BinaryenFeatures>(FeatureSet::GC);
382 }
BinaryenFeatureMemory64(void)383 BinaryenFeatures BinaryenFeatureMemory64(void) {
384 return static_cast<BinaryenFeatures>(FeatureSet::Memory64);
385 }
BinaryenFeatureAll(void)386 BinaryenFeatures BinaryenFeatureAll(void) {
387 return static_cast<BinaryenFeatures>(FeatureSet::All);
388 }
389
390 // Modules
391
BinaryenModuleCreate(void)392 BinaryenModuleRef BinaryenModuleCreate(void) { return new Module(); }
BinaryenModuleDispose(BinaryenModuleRef module)393 void BinaryenModuleDispose(BinaryenModuleRef module) { delete (Module*)module; }
394
395 // Literals
396
BinaryenLiteralInt32(int32_t x)397 BinaryenLiteral BinaryenLiteralInt32(int32_t x) {
398 return toBinaryenLiteral(Literal(x));
399 }
BinaryenLiteralInt64(int64_t x)400 BinaryenLiteral BinaryenLiteralInt64(int64_t x) {
401 return toBinaryenLiteral(Literal(x));
402 }
BinaryenLiteralFloat32(float x)403 BinaryenLiteral BinaryenLiteralFloat32(float x) {
404 return toBinaryenLiteral(Literal(x));
405 }
BinaryenLiteralFloat64(double x)406 BinaryenLiteral BinaryenLiteralFloat64(double x) {
407 return toBinaryenLiteral(Literal(x));
408 }
BinaryenLiteralVec128(const uint8_t x[16])409 BinaryenLiteral BinaryenLiteralVec128(const uint8_t x[16]) {
410 return toBinaryenLiteral(Literal(x));
411 }
BinaryenLiteralFloat32Bits(int32_t x)412 BinaryenLiteral BinaryenLiteralFloat32Bits(int32_t x) {
413 return toBinaryenLiteral(Literal(x).castToF32());
414 }
BinaryenLiteralFloat64Bits(int64_t x)415 BinaryenLiteral BinaryenLiteralFloat64Bits(int64_t x) {
416 return toBinaryenLiteral(Literal(x).castToF64());
417 }
418
419 // Expressions
420
BinaryenClzInt32(void)421 BinaryenOp BinaryenClzInt32(void) { return ClzInt32; }
BinaryenCtzInt32(void)422 BinaryenOp BinaryenCtzInt32(void) { return CtzInt32; }
BinaryenPopcntInt32(void)423 BinaryenOp BinaryenPopcntInt32(void) { return PopcntInt32; }
BinaryenNegFloat32(void)424 BinaryenOp BinaryenNegFloat32(void) { return NegFloat32; }
BinaryenAbsFloat32(void)425 BinaryenOp BinaryenAbsFloat32(void) { return AbsFloat32; }
BinaryenCeilFloat32(void)426 BinaryenOp BinaryenCeilFloat32(void) { return CeilFloat32; }
BinaryenFloorFloat32(void)427 BinaryenOp BinaryenFloorFloat32(void) { return FloorFloat32; }
BinaryenTruncFloat32(void)428 BinaryenOp BinaryenTruncFloat32(void) { return TruncFloat32; }
BinaryenNearestFloat32(void)429 BinaryenOp BinaryenNearestFloat32(void) { return NearestFloat32; }
BinaryenSqrtFloat32(void)430 BinaryenOp BinaryenSqrtFloat32(void) { return SqrtFloat32; }
BinaryenEqZInt32(void)431 BinaryenOp BinaryenEqZInt32(void) { return EqZInt32; }
BinaryenClzInt64(void)432 BinaryenOp BinaryenClzInt64(void) { return ClzInt64; }
BinaryenCtzInt64(void)433 BinaryenOp BinaryenCtzInt64(void) { return CtzInt64; }
BinaryenPopcntInt64(void)434 BinaryenOp BinaryenPopcntInt64(void) { return PopcntInt64; }
BinaryenNegFloat64(void)435 BinaryenOp BinaryenNegFloat64(void) { return NegFloat64; }
BinaryenAbsFloat64(void)436 BinaryenOp BinaryenAbsFloat64(void) { return AbsFloat64; }
BinaryenCeilFloat64(void)437 BinaryenOp BinaryenCeilFloat64(void) { return CeilFloat64; }
BinaryenFloorFloat64(void)438 BinaryenOp BinaryenFloorFloat64(void) { return FloorFloat64; }
BinaryenTruncFloat64(void)439 BinaryenOp BinaryenTruncFloat64(void) { return TruncFloat64; }
BinaryenNearestFloat64(void)440 BinaryenOp BinaryenNearestFloat64(void) { return NearestFloat64; }
BinaryenSqrtFloat64(void)441 BinaryenOp BinaryenSqrtFloat64(void) { return SqrtFloat64; }
BinaryenEqZInt64(void)442 BinaryenOp BinaryenEqZInt64(void) { return EqZInt64; }
BinaryenExtendSInt32(void)443 BinaryenOp BinaryenExtendSInt32(void) { return ExtendSInt32; }
BinaryenExtendUInt32(void)444 BinaryenOp BinaryenExtendUInt32(void) { return ExtendUInt32; }
BinaryenWrapInt64(void)445 BinaryenOp BinaryenWrapInt64(void) { return WrapInt64; }
BinaryenTruncSFloat32ToInt32(void)446 BinaryenOp BinaryenTruncSFloat32ToInt32(void) { return TruncSFloat32ToInt32; }
BinaryenTruncSFloat32ToInt64(void)447 BinaryenOp BinaryenTruncSFloat32ToInt64(void) { return TruncSFloat32ToInt64; }
BinaryenTruncUFloat32ToInt32(void)448 BinaryenOp BinaryenTruncUFloat32ToInt32(void) { return TruncUFloat32ToInt32; }
BinaryenTruncUFloat32ToInt64(void)449 BinaryenOp BinaryenTruncUFloat32ToInt64(void) { return TruncUFloat32ToInt64; }
BinaryenTruncSFloat64ToInt32(void)450 BinaryenOp BinaryenTruncSFloat64ToInt32(void) { return TruncSFloat64ToInt32; }
BinaryenTruncSFloat64ToInt64(void)451 BinaryenOp BinaryenTruncSFloat64ToInt64(void) { return TruncSFloat64ToInt64; }
BinaryenTruncUFloat64ToInt32(void)452 BinaryenOp BinaryenTruncUFloat64ToInt32(void) { return TruncUFloat64ToInt32; }
BinaryenTruncUFloat64ToInt64(void)453 BinaryenOp BinaryenTruncUFloat64ToInt64(void) { return TruncUFloat64ToInt64; }
BinaryenReinterpretFloat32(void)454 BinaryenOp BinaryenReinterpretFloat32(void) { return ReinterpretFloat32; }
BinaryenReinterpretFloat64(void)455 BinaryenOp BinaryenReinterpretFloat64(void) { return ReinterpretFloat64; }
BinaryenExtendS8Int32(void)456 BinaryenOp BinaryenExtendS8Int32(void) { return ExtendS8Int32; }
BinaryenExtendS16Int32(void)457 BinaryenOp BinaryenExtendS16Int32(void) { return ExtendS16Int32; }
BinaryenExtendS8Int64(void)458 BinaryenOp BinaryenExtendS8Int64(void) { return ExtendS8Int64; }
BinaryenExtendS16Int64(void)459 BinaryenOp BinaryenExtendS16Int64(void) { return ExtendS16Int64; }
BinaryenExtendS32Int64(void)460 BinaryenOp BinaryenExtendS32Int64(void) { return ExtendS32Int64; }
BinaryenConvertSInt32ToFloat32(void)461 BinaryenOp BinaryenConvertSInt32ToFloat32(void) {
462 return ConvertSInt32ToFloat32;
463 }
BinaryenConvertSInt32ToFloat64(void)464 BinaryenOp BinaryenConvertSInt32ToFloat64(void) {
465 return ConvertSInt32ToFloat64;
466 }
BinaryenConvertUInt32ToFloat32(void)467 BinaryenOp BinaryenConvertUInt32ToFloat32(void) {
468 return ConvertUInt32ToFloat32;
469 }
BinaryenConvertUInt32ToFloat64(void)470 BinaryenOp BinaryenConvertUInt32ToFloat64(void) {
471 return ConvertUInt32ToFloat64;
472 }
BinaryenConvertSInt64ToFloat32(void)473 BinaryenOp BinaryenConvertSInt64ToFloat32(void) {
474 return ConvertSInt64ToFloat32;
475 }
BinaryenConvertSInt64ToFloat64(void)476 BinaryenOp BinaryenConvertSInt64ToFloat64(void) {
477 return ConvertSInt64ToFloat64;
478 }
BinaryenConvertUInt64ToFloat32(void)479 BinaryenOp BinaryenConvertUInt64ToFloat32(void) {
480 return ConvertUInt64ToFloat32;
481 }
BinaryenConvertUInt64ToFloat64(void)482 BinaryenOp BinaryenConvertUInt64ToFloat64(void) {
483 return ConvertUInt64ToFloat64;
484 }
BinaryenPromoteFloat32(void)485 BinaryenOp BinaryenPromoteFloat32(void) { return PromoteFloat32; }
BinaryenDemoteFloat64(void)486 BinaryenOp BinaryenDemoteFloat64(void) { return DemoteFloat64; }
BinaryenReinterpretInt32(void)487 BinaryenOp BinaryenReinterpretInt32(void) { return ReinterpretInt32; }
BinaryenReinterpretInt64(void)488 BinaryenOp BinaryenReinterpretInt64(void) { return ReinterpretInt64; }
BinaryenAddInt32(void)489 BinaryenOp BinaryenAddInt32(void) { return AddInt32; }
BinaryenSubInt32(void)490 BinaryenOp BinaryenSubInt32(void) { return SubInt32; }
BinaryenMulInt32(void)491 BinaryenOp BinaryenMulInt32(void) { return MulInt32; }
BinaryenDivSInt32(void)492 BinaryenOp BinaryenDivSInt32(void) { return DivSInt32; }
BinaryenDivUInt32(void)493 BinaryenOp BinaryenDivUInt32(void) { return DivUInt32; }
BinaryenRemSInt32(void)494 BinaryenOp BinaryenRemSInt32(void) { return RemSInt32; }
BinaryenRemUInt32(void)495 BinaryenOp BinaryenRemUInt32(void) { return RemUInt32; }
BinaryenAndInt32(void)496 BinaryenOp BinaryenAndInt32(void) { return AndInt32; }
BinaryenOrInt32(void)497 BinaryenOp BinaryenOrInt32(void) { return OrInt32; }
BinaryenXorInt32(void)498 BinaryenOp BinaryenXorInt32(void) { return XorInt32; }
BinaryenShlInt32(void)499 BinaryenOp BinaryenShlInt32(void) { return ShlInt32; }
BinaryenShrUInt32(void)500 BinaryenOp BinaryenShrUInt32(void) { return ShrUInt32; }
BinaryenShrSInt32(void)501 BinaryenOp BinaryenShrSInt32(void) { return ShrSInt32; }
BinaryenRotLInt32(void)502 BinaryenOp BinaryenRotLInt32(void) { return RotLInt32; }
BinaryenRotRInt32(void)503 BinaryenOp BinaryenRotRInt32(void) { return RotRInt32; }
BinaryenEqInt32(void)504 BinaryenOp BinaryenEqInt32(void) { return EqInt32; }
BinaryenNeInt32(void)505 BinaryenOp BinaryenNeInt32(void) { return NeInt32; }
BinaryenLtSInt32(void)506 BinaryenOp BinaryenLtSInt32(void) { return LtSInt32; }
BinaryenLtUInt32(void)507 BinaryenOp BinaryenLtUInt32(void) { return LtUInt32; }
BinaryenLeSInt32(void)508 BinaryenOp BinaryenLeSInt32(void) { return LeSInt32; }
BinaryenLeUInt32(void)509 BinaryenOp BinaryenLeUInt32(void) { return LeUInt32; }
BinaryenGtSInt32(void)510 BinaryenOp BinaryenGtSInt32(void) { return GtSInt32; }
BinaryenGtUInt32(void)511 BinaryenOp BinaryenGtUInt32(void) { return GtUInt32; }
BinaryenGeSInt32(void)512 BinaryenOp BinaryenGeSInt32(void) { return GeSInt32; }
BinaryenGeUInt32(void)513 BinaryenOp BinaryenGeUInt32(void) { return GeUInt32; }
BinaryenAddInt64(void)514 BinaryenOp BinaryenAddInt64(void) { return AddInt64; }
BinaryenSubInt64(void)515 BinaryenOp BinaryenSubInt64(void) { return SubInt64; }
BinaryenMulInt64(void)516 BinaryenOp BinaryenMulInt64(void) { return MulInt64; }
BinaryenDivSInt64(void)517 BinaryenOp BinaryenDivSInt64(void) { return DivSInt64; }
BinaryenDivUInt64(void)518 BinaryenOp BinaryenDivUInt64(void) { return DivUInt64; }
BinaryenRemSInt64(void)519 BinaryenOp BinaryenRemSInt64(void) { return RemSInt64; }
BinaryenRemUInt64(void)520 BinaryenOp BinaryenRemUInt64(void) { return RemUInt64; }
BinaryenAndInt64(void)521 BinaryenOp BinaryenAndInt64(void) { return AndInt64; }
BinaryenOrInt64(void)522 BinaryenOp BinaryenOrInt64(void) { return OrInt64; }
BinaryenXorInt64(void)523 BinaryenOp BinaryenXorInt64(void) { return XorInt64; }
BinaryenShlInt64(void)524 BinaryenOp BinaryenShlInt64(void) { return ShlInt64; }
BinaryenShrUInt64(void)525 BinaryenOp BinaryenShrUInt64(void) { return ShrUInt64; }
BinaryenShrSInt64(void)526 BinaryenOp BinaryenShrSInt64(void) { return ShrSInt64; }
BinaryenRotLInt64(void)527 BinaryenOp BinaryenRotLInt64(void) { return RotLInt64; }
BinaryenRotRInt64(void)528 BinaryenOp BinaryenRotRInt64(void) { return RotRInt64; }
BinaryenEqInt64(void)529 BinaryenOp BinaryenEqInt64(void) { return EqInt64; }
BinaryenNeInt64(void)530 BinaryenOp BinaryenNeInt64(void) { return NeInt64; }
BinaryenLtSInt64(void)531 BinaryenOp BinaryenLtSInt64(void) { return LtSInt64; }
BinaryenLtUInt64(void)532 BinaryenOp BinaryenLtUInt64(void) { return LtUInt64; }
BinaryenLeSInt64(void)533 BinaryenOp BinaryenLeSInt64(void) { return LeSInt64; }
BinaryenLeUInt64(void)534 BinaryenOp BinaryenLeUInt64(void) { return LeUInt64; }
BinaryenGtSInt64(void)535 BinaryenOp BinaryenGtSInt64(void) { return GtSInt64; }
BinaryenGtUInt64(void)536 BinaryenOp BinaryenGtUInt64(void) { return GtUInt64; }
BinaryenGeSInt64(void)537 BinaryenOp BinaryenGeSInt64(void) { return GeSInt64; }
BinaryenGeUInt64(void)538 BinaryenOp BinaryenGeUInt64(void) { return GeUInt64; }
BinaryenAddFloat32(void)539 BinaryenOp BinaryenAddFloat32(void) { return AddFloat32; }
BinaryenSubFloat32(void)540 BinaryenOp BinaryenSubFloat32(void) { return SubFloat32; }
BinaryenMulFloat32(void)541 BinaryenOp BinaryenMulFloat32(void) { return MulFloat32; }
BinaryenDivFloat32(void)542 BinaryenOp BinaryenDivFloat32(void) { return DivFloat32; }
BinaryenCopySignFloat32(void)543 BinaryenOp BinaryenCopySignFloat32(void) { return CopySignFloat32; }
BinaryenMinFloat32(void)544 BinaryenOp BinaryenMinFloat32(void) { return MinFloat32; }
BinaryenMaxFloat32(void)545 BinaryenOp BinaryenMaxFloat32(void) { return MaxFloat32; }
BinaryenEqFloat32(void)546 BinaryenOp BinaryenEqFloat32(void) { return EqFloat32; }
BinaryenNeFloat32(void)547 BinaryenOp BinaryenNeFloat32(void) { return NeFloat32; }
BinaryenLtFloat32(void)548 BinaryenOp BinaryenLtFloat32(void) { return LtFloat32; }
BinaryenLeFloat32(void)549 BinaryenOp BinaryenLeFloat32(void) { return LeFloat32; }
BinaryenGtFloat32(void)550 BinaryenOp BinaryenGtFloat32(void) { return GtFloat32; }
BinaryenGeFloat32(void)551 BinaryenOp BinaryenGeFloat32(void) { return GeFloat32; }
BinaryenAddFloat64(void)552 BinaryenOp BinaryenAddFloat64(void) { return AddFloat64; }
BinaryenSubFloat64(void)553 BinaryenOp BinaryenSubFloat64(void) { return SubFloat64; }
BinaryenMulFloat64(void)554 BinaryenOp BinaryenMulFloat64(void) { return MulFloat64; }
BinaryenDivFloat64(void)555 BinaryenOp BinaryenDivFloat64(void) { return DivFloat64; }
BinaryenCopySignFloat64(void)556 BinaryenOp BinaryenCopySignFloat64(void) { return CopySignFloat64; }
BinaryenMinFloat64(void)557 BinaryenOp BinaryenMinFloat64(void) { return MinFloat64; }
BinaryenMaxFloat64(void)558 BinaryenOp BinaryenMaxFloat64(void) { return MaxFloat64; }
BinaryenEqFloat64(void)559 BinaryenOp BinaryenEqFloat64(void) { return EqFloat64; }
BinaryenNeFloat64(void)560 BinaryenOp BinaryenNeFloat64(void) { return NeFloat64; }
BinaryenLtFloat64(void)561 BinaryenOp BinaryenLtFloat64(void) { return LtFloat64; }
BinaryenLeFloat64(void)562 BinaryenOp BinaryenLeFloat64(void) { return LeFloat64; }
BinaryenGtFloat64(void)563 BinaryenOp BinaryenGtFloat64(void) { return GtFloat64; }
BinaryenGeFloat64(void)564 BinaryenOp BinaryenGeFloat64(void) { return GeFloat64; }
BinaryenAtomicRMWAdd(void)565 BinaryenOp BinaryenAtomicRMWAdd(void) { return AtomicRMWOp::Add; }
BinaryenAtomicRMWSub(void)566 BinaryenOp BinaryenAtomicRMWSub(void) { return AtomicRMWOp::Sub; }
BinaryenAtomicRMWAnd(void)567 BinaryenOp BinaryenAtomicRMWAnd(void) { return AtomicRMWOp::And; }
BinaryenAtomicRMWOr(void)568 BinaryenOp BinaryenAtomicRMWOr(void) { return AtomicRMWOp::Or; }
BinaryenAtomicRMWXor(void)569 BinaryenOp BinaryenAtomicRMWXor(void) { return AtomicRMWOp::Xor; }
BinaryenAtomicRMWXchg(void)570 BinaryenOp BinaryenAtomicRMWXchg(void) { return AtomicRMWOp::Xchg; }
BinaryenTruncSatSFloat32ToInt32(void)571 BinaryenOp BinaryenTruncSatSFloat32ToInt32(void) {
572 return TruncSatSFloat32ToInt32;
573 }
BinaryenTruncSatSFloat32ToInt64(void)574 BinaryenOp BinaryenTruncSatSFloat32ToInt64(void) {
575 return TruncSatSFloat32ToInt64;
576 }
BinaryenTruncSatUFloat32ToInt32(void)577 BinaryenOp BinaryenTruncSatUFloat32ToInt32(void) {
578 return TruncSatUFloat32ToInt32;
579 }
BinaryenTruncSatUFloat32ToInt64(void)580 BinaryenOp BinaryenTruncSatUFloat32ToInt64(void) {
581 return TruncSatUFloat32ToInt64;
582 }
BinaryenTruncSatSFloat64ToInt32(void)583 BinaryenOp BinaryenTruncSatSFloat64ToInt32(void) {
584 return TruncSatSFloat64ToInt32;
585 }
BinaryenTruncSatSFloat64ToInt64(void)586 BinaryenOp BinaryenTruncSatSFloat64ToInt64(void) {
587 return TruncSatSFloat64ToInt64;
588 }
BinaryenTruncSatUFloat64ToInt32(void)589 BinaryenOp BinaryenTruncSatUFloat64ToInt32(void) {
590 return TruncSatUFloat64ToInt32;
591 }
BinaryenTruncSatUFloat64ToInt64(void)592 BinaryenOp BinaryenTruncSatUFloat64ToInt64(void) {
593 return TruncSatUFloat64ToInt64;
594 }
BinaryenSplatVecI8x16(void)595 BinaryenOp BinaryenSplatVecI8x16(void) { return SplatVecI8x16; }
BinaryenExtractLaneSVecI8x16(void)596 BinaryenOp BinaryenExtractLaneSVecI8x16(void) { return ExtractLaneSVecI8x16; }
BinaryenExtractLaneUVecI8x16(void)597