From db9124f1de0478dcac525009b6f1589b44a7edd8 Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Fri, 26 Apr 2019 16:59:41 -0700 Subject: Apply format changes from #2048 (#2059) Mass change to apply clang-format to everything. We are applying this in a PR by me so the (git) blame is all mine ;) but @aheejin did all the work to get clang-format set up and all the manual work to tidy up some things to make the output nicer in #2048 --- src/binaryen-c.cpp | 1490 +++++++++++++++++++++++++++++++++++++--------------- 1 file changed, 1079 insertions(+), 411 deletions(-) (limited to 'src/binaryen-c.cpp') diff --git a/src/binaryen-c.cpp b/src/binaryen-c.cpp index 87dd631d3..5842e5afe 100644 --- a/src/binaryen-c.cpp +++ b/src/binaryen-c.cpp @@ -21,19 +21,19 @@ #include #include "binaryen-c.h" +#include "cfg/Relooper.h" +#include "ir/function-type-utils.h" +#include "ir/utils.h" #include "pass.h" -#include "wasm.h" +#include "shell-interface.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 "cfg/Relooper.h" -#include "ir/function-type-utils.h" -#include "ir/utils.h" -#include "shell-interface.h" #ifdef __EMSCRIPTEN__ #include @@ -43,35 +43,51 @@ using namespace wasm; // Literal utilities -static_assert(sizeof(BinaryenLiteral) == sizeof(Literal), "Binaryen C API literal must match wasm.h"); +static_assert(sizeof(BinaryenLiteral) == sizeof(Literal), + "Binaryen C API literal must match wasm.h"); BinaryenLiteral toBinaryenLiteral(Literal x) { BinaryenLiteral ret; ret.type = x.type; switch (x.type) { - case Type::i32: ret.i32 = x.geti32(); break; - case Type::i64: ret.i64 = x.geti64(); break; - case Type::f32: ret.i32 = x.reinterpreti32(); break; - case Type::f64: ret.i64 = x.reinterpreti64(); break; + 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::none: - case Type::unreachable: WASM_UNREACHABLE(); + case Type::unreachable: + WASM_UNREACHABLE(); } 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::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(); + case Type::unreachable: + WASM_UNREACHABLE(); } WASM_UNREACHABLE(); } @@ -84,15 +100,18 @@ static std::mutex BinaryenFunctionMutex; static std::mutex BinaryenFunctionTypeMutex; // Optimization options -static PassOptions globalPassOptions = PassOptions::getWithDefaultOptimizationOptions(); +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"; +void traceNameOrNULL(const char* name, std::ostream& out = std::cout) { + if (name) + out << "\"" << name << "\""; + else + out << "NULL"; } std::map functionTypes; @@ -115,27 +134,29 @@ std::string getTemp() { } template -void printArg(std::ostream &setup, std::ostream& out, T arg) { +void printArg(std::ostream& setup, std::ostream& out, T arg) { out << arg; } template<> -void printArg(std::ostream &setup, std::ostream& out, BinaryenExpressionRef arg) { +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) {}; + StringLit(const char* name) : name(name){}; }; template<> -void printArg(std::ostream &setup, std::ostream& out, StringLit arg) { +void printArg(std::ostream& setup, std::ostream& out, StringLit arg) { traceNameOrNULL(arg.name, out); } template<> -void printArg(std::ostream &setup, std::ostream &out, BinaryenType arg) { +void printArg(std::ostream& setup, std::ostream& out, BinaryenType arg) { if (arg == BinaryenTypeAuto()) { out << "BinaryenTypeAuto()"; } else { @@ -144,21 +165,29 @@ void printArg(std::ostream &setup, std::ostream &out, BinaryenType arg) { } template<> -void printArg(std::ostream &setup, std::ostream &out, BinaryenLiteral arg) { +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::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; + out << "BinaryenLiteralFloat32(NAN)"; + break; } else { - out << "BinaryenLiteralFloat32(" << arg.f32 << ")"; break; + out << "BinaryenLiteralFloat32(" << arg.f32 << ")"; + break; } case Type::f64: if (std::isnan(arg.f64)) { - out << "BinaryenLiteralFloat64(NAN)"; break; + out << "BinaryenLiteralFloat64(NAN)"; + break; } else { - out << "BinaryenLiteralFloat64(" << arg.f64 << ")"; break; + out << "BinaryenLiteralFloat64(" << arg.f64 << ")"; + break; } case Type::v128: { std::string array = getTemp(); @@ -174,24 +203,28 @@ void printArg(std::ostream &setup, std::ostream &out, BinaryenLiteral arg) { break; } case Type::none: - case Type::unreachable: WASM_UNREACHABLE(); + case Type::unreachable: + WASM_UNREACHABLE(); } } template -void traceArgs(std::ostream &setup, std::ostream &out, T arg) { +void traceArgs(std::ostream& setup, std::ostream& out, T arg) { printArg(setup, out, arg); } -template -void traceArgs(std::ostream &setup, std::ostream &out, T arg, S next, Ts... rest) { +template +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 -void traceExpression(BinaryenExpressionRef expr, const char* constructor, Ts... args) { +template +void traceExpression(BinaryenExpressionRef expr, + const char* constructor, + Ts... args) { auto id = noteExpression(expr); std::stringstream setup, out; out << "expressions[" << id << "] = " << constructor << "("; @@ -235,18 +268,30 @@ WASM_DEPRECATED BinaryenType BinaryenUndefined(void) { return uint32_t(-1); } // Expression ids -BinaryenExpressionId BinaryenInvalidId(void) { return Expression::Id::InvalidId; } +BinaryenExpressionId BinaryenInvalidId(void) { + return Expression::Id::InvalidId; +} BinaryenExpressionId BinaryenBlockId(void) { return Expression::Id::BlockId; } BinaryenExpressionId BinaryenIfId(void) { return Expression::Id::IfId; } BinaryenExpressionId BinaryenLoopId(void) { return Expression::Id::LoopId; } BinaryenExpressionId BinaryenBreakId(void) { return Expression::Id::BreakId; } BinaryenExpressionId BinaryenSwitchId(void) { return Expression::Id::SwitchId; } BinaryenExpressionId BinaryenCallId(void) { return Expression::Id::CallId; } -BinaryenExpressionId BinaryenCallIndirectId(void) { return Expression::Id::CallIndirectId; } -BinaryenExpressionId BinaryenGetLocalId(void) { return Expression::Id::GetLocalId; } -BinaryenExpressionId BinaryenSetLocalId(void) { return Expression::Id::SetLocalId; } -BinaryenExpressionId BinaryenGetGlobalId(void) { return Expression::Id::GetGlobalId; } -BinaryenExpressionId BinaryenSetGlobalId(void) { return Expression::Id::SetGlobalId; } +BinaryenExpressionId BinaryenCallIndirectId(void) { + return Expression::Id::CallIndirectId; +} +BinaryenExpressionId BinaryenGetLocalId(void) { + return Expression::Id::GetLocalId; +} +BinaryenExpressionId BinaryenSetLocalId(void) { + return Expression::Id::SetLocalId; +} +BinaryenExpressionId BinaryenGetGlobalId(void) { + return Expression::Id::GetGlobalId; +} +BinaryenExpressionId BinaryenSetGlobalId(void) { + return Expression::Id::SetGlobalId; +} BinaryenExpressionId BinaryenLoadId(void) { return Expression::Id::LoadId; } BinaryenExpressionId BinaryenStoreId(void) { return Expression::Id::StoreId; } BinaryenExpressionId BinaryenConstId(void) { return Expression::Id::ConstId; } @@ -257,27 +302,63 @@ 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 BinaryenSIMDExtractId(void) { return Expression::Id::SIMDExtractId; } -BinaryenExpressionId BinaryenSIMDReplaceId(void) { return Expression::Id::SIMDReplaceId; } -BinaryenExpressionId BinaryenSIMDShuffleId(void) { return Expression::Id::SIMDShuffleId; } -BinaryenExpressionId BinaryenSIMDBitselectId(void) { return Expression::Id::SIMDBitselectId; } -BinaryenExpressionId BinaryenSIMDShiftId(void) { return Expression::Id::SIMDShiftId; } -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 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 BinaryenSIMDExtractId(void) { + return Expression::Id::SIMDExtractId; +} +BinaryenExpressionId BinaryenSIMDReplaceId(void) { + return Expression::Id::SIMDReplaceId; +} +BinaryenExpressionId BinaryenSIMDShuffleId(void) { + return Expression::Id::SIMDShuffleId; +} +BinaryenExpressionId BinaryenSIMDBitselectId(void) { + return Expression::Id::SIMDBitselectId; +} +BinaryenExpressionId BinaryenSIMDShiftId(void) { + return Expression::Id::SIMDShiftId; +} +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; +} // External kinds -BinaryenExternalKind BinaryenExternalFunction(void) { return static_cast(ExternalKind::Function); } -BinaryenExternalKind BinaryenExternalTable(void) { return static_cast(ExternalKind::Table); } -BinaryenExternalKind BinaryenExternalMemory(void) { return static_cast(ExternalKind::Memory); } -BinaryenExternalKind BinaryenExternalGlobal(void) { return static_cast(ExternalKind::Global); } +BinaryenExternalKind BinaryenExternalFunction(void) { + return static_cast(ExternalKind::Function); +} +BinaryenExternalKind BinaryenExternalTable(void) { + return static_cast(ExternalKind::Table); +} +BinaryenExternalKind BinaryenExternalMemory(void) { + return static_cast(ExternalKind::Memory); +} +BinaryenExternalKind BinaryenExternalGlobal(void) { + return static_cast(ExternalKind::Global); +} // Modules @@ -312,11 +393,17 @@ void BinaryenModuleDispose(BinaryenModuleRef module) { // Function types -BinaryenFunctionTypeRef BinaryenAddFunctionType(BinaryenModuleRef module, const char* name, BinaryenType result, BinaryenType* paramTypes, BinaryenIndex numParams) { +BinaryenFunctionTypeRef BinaryenAddFunctionType(BinaryenModuleRef module, + const char* name, + BinaryenType result, + BinaryenType* paramTypes, + BinaryenIndex numParams) { auto* wasm = (Module*)module; auto ret = make_unique(); - if (name) ret->name = name; - else ret->name = Name::fromInt(wasm->functionTypes.size()); + if (name) + ret->name = name; + else + ret->name = Name::fromInt(wasm->functionTypes.size()); ret->result = Type(result); for (BinaryenIndex i = 0; i < numParams; i++) { ret->params.push_back(Type(paramTypes[i])); @@ -326,13 +413,17 @@ BinaryenFunctionTypeRef BinaryenAddFunctionType(BinaryenModuleRef module, const std::cout << " {\n"; std::cout << " BinaryenType paramTypes[] = { "; for (BinaryenIndex i = 0; i < numParams; i++) { - if (i > 0) std::cout << ", "; + if (i > 0) + std::cout << ", "; std::cout << paramTypes[i]; } - if (numParams == 0) std::cout << "0"; // ensure the array is not empty, otherwise a compiler error on VS + if (numParams == 0) + // ensure the array is not empty, otherwise a compiler error on VS + std::cout << "0"; std::cout << " };\n"; size_t id = functionTypes.size(); - std::cout << " functionTypes[" << id << "] = BinaryenAddFunctionType(the_module, "; + std::cout << " functionTypes[" << id + << "] = BinaryenAddFunctionType(the_module, "; functionTypes[ret.get()] = id; traceNameOrNULL(name); std::cout << ", " << result << ", paramTypes, " << numParams << ");\n"; @@ -362,13 +453,27 @@ void BinaryenRemoveFunctionType(BinaryenModuleRef module, const char* name) { } } -BinaryenLiteral BinaryenLiteralInt32(int32_t x) { return toBinaryenLiteral(Literal(x)); } -BinaryenLiteral BinaryenLiteralInt64(int64_t x) { return toBinaryenLiteral(Literal(x)); } -BinaryenLiteral BinaryenLiteralFloat32(float x) { return toBinaryenLiteral(Literal(x)); } -BinaryenLiteral BinaryenLiteralFloat64(double x) { return toBinaryenLiteral(Literal(x)); } -BinaryenLiteral 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()); } +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 @@ -412,14 +517,30 @@ 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 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; } @@ -508,14 +629,30 @@ 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 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; } @@ -643,41 +780,72 @@ 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; } - -BinaryenExpressionRef BinaryenBlock(BinaryenModuleRef module, const char* name, BinaryenExpressionRef* children, BinaryenIndex numChildren, BinaryenType type) { +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; +} + +BinaryenExpressionRef BinaryenBlock(BinaryenModuleRef module, + const char* name, + BinaryenExpressionRef* children, + BinaryenIndex numChildren, + BinaryenType type) { auto* ret = ((Module*)module)->allocator.alloc(); - if (name) ret->name = name; + if (name) + ret->name = name; for (BinaryenIndex i = 0; i < numChildren; i++) { ret->list.push_back((Expression*)children[i]); } - if (type != BinaryenTypeAuto()) ret->finalize(Type(type)); - else ret->finalize(); + if (type != BinaryenTypeAuto()) + ret->finalize(Type(type)); + else + ret->finalize(); if (tracing) { std::cout << " {\n"; std::cout << " BinaryenExpressionRef children[] = { "; for (BinaryenIndex i = 0; i < numChildren; i++) { - if (i > 0) std::cout << ", "; - if (i % 6 == 5) std::cout << "\n "; // don't create hugely long lines + if (i > 0) + std::cout << ", "; + if (i % 6 == 5) + std::cout << "\n "; // don't create hugely long lines std::cout << "expressions[" << expressions[children[i]] << "]"; } - if (numChildren == 0) std::cout << "0"; // ensure the array is not empty, otherwise a compiler error on VS + if (numChildren == 0) + // ensure the array is not empty, otherwise a compiler error on VS + std::cout << "0"; std::cout << " };\n "; - traceExpression(ret, "BinaryenBlock", StringLit(name), "children", numChildren, type); + traceExpression( + ret, "BinaryenBlock", StringLit(name), "children", numChildren, type); std::cout << " }\n"; } return static_cast(ret); } -BinaryenExpressionRef BinaryenIf(BinaryenModuleRef module, BinaryenExpressionRef condition, BinaryenExpressionRef ifTrue, BinaryenExpressionRef ifFalse) { +BinaryenExpressionRef BinaryenIf(BinaryenModuleRef module, + BinaryenExpressionRef condition, + BinaryenExpressionRef ifTrue, + BinaryenExpressionRef ifFalse) { auto* ret = ((Module*)module)->allocator.alloc(); ret->condition = (Expression*)condition; ret->ifTrue = (Expression*)ifTrue; @@ -690,8 +858,11 @@ BinaryenExpressionRef BinaryenIf(BinaryenModuleRef module, BinaryenExpressionRef return static_cast(ret); } -BinaryenExpressionRef BinaryenLoop(BinaryenModuleRef module, const char* name, BinaryenExpressionRef body) { - auto* ret = Builder(*((Module*)module)).makeLoop(name ? Name(name) : Name(), (Expression*)body); +BinaryenExpressionRef BinaryenLoop(BinaryenModuleRef module, + const char* name, + BinaryenExpressionRef body) { + auto* ret = Builder(*((Module*)module)) + .makeLoop(name ? Name(name) : Name(), (Expression*)body); if (tracing) { traceExpression(ret, "BinaryenLoop", StringLit(name), body); @@ -699,8 +870,12 @@ BinaryenExpressionRef BinaryenLoop(BinaryenModuleRef module, const char* name, B return static_cast(ret); } -BinaryenExpressionRef BinaryenBreak(BinaryenModuleRef module, const char* name, BinaryenExpressionRef condition, BinaryenExpressionRef value) { - auto* ret = Builder(*((Module*)module)).makeBreak(name, (Expression*)value, (Expression*)condition); +BinaryenExpressionRef BinaryenBreak(BinaryenModuleRef module, + const char* name, + BinaryenExpressionRef condition, + BinaryenExpressionRef value) { + auto* ret = Builder(*((Module*)module)) + .makeBreak(name, (Expression*)value, (Expression*)condition); if (tracing) { traceExpression(ret, "BinaryenBreak", StringLit(name), condition, value); @@ -708,19 +883,33 @@ BinaryenExpressionRef BinaryenBreak(BinaryenModuleRef module, const char* name, return static_cast(ret); } -BinaryenExpressionRef BinaryenSwitch(BinaryenModuleRef module, const char** names, BinaryenIndex numNames, const char* defaultName, BinaryenExpressionRef condition, BinaryenExpressionRef value) { +BinaryenExpressionRef BinaryenSwitch(BinaryenModuleRef module, + const char** names, + BinaryenIndex numNames, + const char* defaultName, + BinaryenExpressionRef condition, + BinaryenExpressionRef value) { auto* ret = ((Module*)module)->allocator.alloc(); if (tracing) { std::cout << " {\n"; std::cout << " const char* names[] = { "; for (BinaryenIndex i = 0; i < numNames; i++) { - if (i > 0) std::cout << ", "; + if (i > 0) + std::cout << ", "; std::cout << "\"" << names[i] << "\""; } - if (numNames == 0) std::cout << "0"; // ensure the array is not empty, otherwise a compiler error on VS + if (numNames == 0) + std::cout << "0"; // ensure the array is not empty, otherwise a compiler + // error on VS std::cout << " };\n "; - traceExpression(ret, "BinaryenSwitch", "names", numNames, StringLit(defaultName), condition, value); + traceExpression(ret, + "BinaryenSwitch", + "names", + numNames, + StringLit(defaultName), + condition, + value); std::cout << " }\n"; } @@ -733,19 +922,31 @@ BinaryenExpressionRef BinaryenSwitch(BinaryenModuleRef module, const char** name ret->finalize(); return static_cast(ret); } -BinaryenExpressionRef BinaryenCall(BinaryenModuleRef module, const char* target, BinaryenExpressionRef* operands, BinaryenIndex numOperands, BinaryenType returnType) { +BinaryenExpressionRef BinaryenCall(BinaryenModuleRef module, + const char* target, + BinaryenExpressionRef* operands, + BinaryenIndex numOperands, + BinaryenType returnType) { auto* ret = ((Module*)module)->allocator.alloc(); if (tracing) { std::cout << " {\n"; std::cout << " BinaryenExpressionRef operands[] = { "; for (BinaryenIndex i = 0; i < numOperands; i++) { - if (i > 0) std::cout << ", "; + if (i > 0) + std::cout << ", "; std::cout << "expressions[" << expressions[operands[i]] << "]"; } - if (numOperands == 0) std::cout << "0"; // ensure the array is not empty, otherwise a compiler error on VS + if (numOperands == 0) + // ensure the array is not empty, otherwise a compiler error on VS + std::cout << "0"; std::cout << " };\n "; - traceExpression(ret, "BinaryenCall", StringLit(target), "operands", numOperands, returnType); + traceExpression(ret, + "BinaryenCall", + StringLit(target), + "operands", + numOperands, + returnType); std::cout << " }\n"; } @@ -757,7 +958,11 @@ BinaryenExpressionRef BinaryenCall(BinaryenModuleRef module, const char* target, ret->finalize(); return static_cast(ret); } -BinaryenExpressionRef BinaryenCallIndirect(BinaryenModuleRef module, BinaryenExpressionRef target, BinaryenExpressionRef* operands, BinaryenIndex numOperands, const char* type) { +BinaryenExpressionRef BinaryenCallIndirect(BinaryenModuleRef module, + BinaryenExpressionRef target, + BinaryenExpressionRef* operands, + BinaryenIndex numOperands, + const char* type) { auto* wasm = (Module*)module; auto* ret = wasm->allocator.alloc(); @@ -765,12 +970,20 @@ BinaryenExpressionRef BinaryenCallIndirect(BinaryenModuleRef module, BinaryenExp std::cout << " {\n"; std::cout << " BinaryenExpressionRef operands[] = { "; for (BinaryenIndex i = 0; i < numOperands; i++) { - if (i > 0) std::cout << ", "; + if (i > 0) + std::cout << ", "; std::cout << "expressions[" << expressions[operands[i]] << "]"; } - if (numOperands == 0) std::cout << "0"; // ensure the array is not empty, otherwise a compiler error on VS + if (numOperands == 0) + // ensure the array is not empty, otherwise a compiler error on VS + std::cout << "0"; std::cout << " };\n "; - traceExpression(ret, "BinaryenCallIndirect", target, "operands", numOperands, StringLit(type)); + traceExpression(ret, + "BinaryenCallIndirect", + target, + "operands", + numOperands, + StringLit(type)); std::cout << " }\n"; } @@ -783,7 +996,9 @@ BinaryenExpressionRef BinaryenCallIndirect(BinaryenModuleRef module, BinaryenExp ret->finalize(); return static_cast(ret); } -BinaryenExpressionRef BinaryenGetLocal(BinaryenModuleRef module, BinaryenIndex index, BinaryenType type) { +BinaryenExpressionRef BinaryenGetLocal(BinaryenModuleRef module, + BinaryenIndex index, + BinaryenType type) { auto* ret = ((Module*)module)->allocator.alloc(); if (tracing) { @@ -795,7 +1010,9 @@ BinaryenExpressionRef BinaryenGetLocal(BinaryenModuleRef module, BinaryenIndex i ret->finalize(); return static_cast(ret); } -BinaryenExpressionRef BinaryenSetLocal(BinaryenModuleRef module, BinaryenIndex index, BinaryenExpressionRef value) { +BinaryenExpressionRef BinaryenSetLocal(BinaryenModuleRef module, + BinaryenIndex index, + BinaryenExpressionRef value) { auto* ret = ((Module*)module)->allocator.alloc(); if (tracing) { @@ -808,7 +1025,9 @@ BinaryenExpressionRef BinaryenSetLocal(BinaryenModuleRef module, BinaryenIndex i ret->finalize(); return static_cast(ret); } -BinaryenExpressionRef BinaryenTeeLocal(BinaryenModuleRef module, BinaryenIndex index, BinaryenExpressionRef value) { +BinaryenExpressionRef BinaryenTeeLocal(BinaryenModuleRef module, + BinaryenIndex index, + BinaryenExpressionRef value) { auto* ret = ((Module*)module)->allocator.alloc(); if (tracing) { @@ -821,7 +1040,9 @@ BinaryenExpressionRef BinaryenTeeLocal(BinaryenModuleRef module, BinaryenIndex i ret->finalize(); return static_cast(ret); } -BinaryenExpressionRef BinaryenGetGlobal(BinaryenModuleRef module, const char* name, BinaryenType type) { +BinaryenExpressionRef BinaryenGetGlobal(BinaryenModuleRef module, + const char* name, + BinaryenType type) { auto* ret = ((Module*)module)->allocator.alloc(); if (tracing) { @@ -833,7 +1054,9 @@ BinaryenExpressionRef BinaryenGetGlobal(BinaryenModuleRef module, const char* na ret->finalize(); return static_cast(ret); } -BinaryenExpressionRef BinaryenSetGlobal(BinaryenModuleRef module, const char* name, BinaryenExpressionRef value) { +BinaryenExpressionRef BinaryenSetGlobal(BinaryenModuleRef module, + const char* name, + BinaryenExpressionRef value) { auto* ret = ((Module*)module)->allocator.alloc(); if (tracing) { @@ -845,11 +1068,18 @@ BinaryenExpressionRef BinaryenSetGlobal(BinaryenModuleRef module, const char* na ret->finalize(); return static_cast(ret); } -BinaryenExpressionRef BinaryenLoad(BinaryenModuleRef module, uint32_t bytes, int8_t signed_, uint32_t offset, uint32_t align, BinaryenType type, BinaryenExpressionRef ptr) { +BinaryenExpressionRef BinaryenLoad(BinaryenModuleRef module, + uint32_t bytes, + int8_t signed_, + uint32_t offset, + uint32_t align, + BinaryenType type, + BinaryenExpressionRef ptr) { auto* ret = ((Module*)module)->allocator.alloc(); if (tracing) { - traceExpression(ret, "BinaryenLoad", bytes, int(signed_), offset, align, type, ptr); + traceExpression( + ret, "BinaryenLoad", bytes, int(signed_), offset, align, type, ptr); } ret->isAtomic = false; ret->bytes = bytes; @@ -861,11 +1091,18 @@ BinaryenExpressionRef BinaryenLoad(BinaryenModuleRef module, uint32_t bytes, int ret->finalize(); return static_cast(ret); } -BinaryenExpressionRef BinaryenStore(BinaryenModuleRef module, uint32_t bytes, uint32_t offset, uint32_t align, BinaryenExpressionRef ptr, BinaryenExpressionRef value, BinaryenType type) { +BinaryenExpressionRef BinaryenStore(BinaryenModuleRef module, + uint32_t bytes, + uint32_t offset, + uint32_t align, + BinaryenExpressionRef ptr, + BinaryenExpressionRef value, + BinaryenType type) { auto* ret = ((Module*)module)->allocator.alloc(); if (tracing) { - traceExpression(ret, "BinaryenStore", bytes, offset, align, ptr, value, type); + traceExpression( + ret, "BinaryenStore", bytes, offset, align, ptr, value, type); } ret->isAtomic = false; ret->bytes = bytes; @@ -877,15 +1114,19 @@ BinaryenExpressionRef BinaryenStore(BinaryenModuleRef module, uint32_t bytes, ui ret->finalize(); return static_cast(ret); } -BinaryenExpressionRef BinaryenConst(BinaryenModuleRef module, BinaryenLiteral value) { +BinaryenExpressionRef BinaryenConst(BinaryenModuleRef module, + BinaryenLiteral value) { auto* ret = Builder(*((Module*)module)).makeConst(fromBinaryenLiteral(value)); if (tracing) { traceExpression(ret, "BinaryenConst", value); } return static_cast(ret); } -BinaryenExpressionRef BinaryenUnary(BinaryenModuleRef module, BinaryenOp op, BinaryenExpressionRef value) { - auto* ret = Builder(*((Module*)module)).makeUnary(UnaryOp(op), (Expression*)value); +BinaryenExpressionRef BinaryenUnary(BinaryenModuleRef module, + BinaryenOp op, + BinaryenExpressionRef value) { + auto* ret = + Builder(*((Module*)module)).makeUnary(UnaryOp(op), (Expression*)value); if (tracing) { traceExpression(ret, "BinaryenUnary", op, value); @@ -893,8 +1134,13 @@ BinaryenExpressionRef BinaryenUnary(BinaryenModuleRef module, BinaryenOp op, Bin return static_cast(ret); } -BinaryenExpressionRef BinaryenBinary(BinaryenModuleRef module, BinaryenOp op, BinaryenExpressionRef left, BinaryenExpressionRef right) { - auto* ret = Builder(*((Module*)module)).makeBinary(BinaryOp(op), (Expression*)left, (Expression*)right); +BinaryenExpressionRef BinaryenBinary(BinaryenModuleRef module, + BinaryenOp op, + BinaryenExpressionRef left, + BinaryenExpressionRef right) { + auto* ret = + Builder(*((Module*)module)) + .makeBinary(BinaryOp(op), (Expression*)left, (Expression*)right); if (tracing) { traceExpression(ret, "BinaryenBinary", op, left, right); @@ -902,7 +1148,10 @@ BinaryenExpressionRef BinaryenBinary(BinaryenModuleRef module, BinaryenOp op, Bi return static_cast(ret); } -BinaryenExpressionRef BinaryenSelect(BinaryenModuleRef module, BinaryenExpressionRef condition, BinaryenExpressionRef ifTrue, BinaryenExpressionRef ifFalse) { +BinaryenExpressionRef BinaryenSelect(BinaryenModuleRef module, + BinaryenExpressionRef condition, + BinaryenExpressionRef ifTrue, + BinaryenExpressionRef ifFalse) { auto* ret = ((Module*)module)->allocator.alloc