diff options
Diffstat (limited to 'src/binaryen-c.cpp')
| -rw-r--r-- | src/binaryen-c.cpp | 2479 |
1 files changed, 194 insertions, 2285 deletions
diff --git a/src/binaryen-c.cpp b/src/binaryen-c.cpp index a9bc9e2b6..c57beeb22 100644 --- a/src/binaryen-c.cpp +++ b/src/binaryen-c.cpp @@ -116,262 +116,6 @@ static std::mutex BinaryenFunctionMutex; static PassOptions globalPassOptions = PassOptions::getWithDefaultOptimizationOptions(); -// Tracing support - -static int tracing = 0; - -void traceNameOrNULL(const char* name, std::ostream& out = std::cout) { - if (name) { - out << "\"" << name << "\""; - } else { - out << "NULL"; - } -} - -std::map<BinaryenType, size_t> types; -std::map<BinaryenExpressionRef, size_t> expressions; -std::map<BinaryenFunctionRef, size_t> functions; -std::map<BinaryenGlobalRef, size_t> globals; -std::map<BinaryenEventRef, size_t> events; -std::map<BinaryenExportRef, size_t> exports; -std::map<RelooperBlockRef, size_t> relooperBlocks; -std::map<ExpressionRunnerRef, size_t> expressionRunners; - -static bool isBasicAPIType(BinaryenType type) { - return type == BinaryenTypeAuto() || type <= Type::_last_value_type; -} - -static const char* basicAPITypeFunction(BinaryenType type) { - if (type == BinaryenTypeAuto()) { - return "BinaryenTypeAuto()"; - } - switch (type) { - case Type::none: - return "BinaryenTypeNone()"; - case Type::i32: - return "BinaryenTypeInt32()"; - case Type::i64: - return "BinaryenTypeInt64()"; - case Type::f32: - return "BinaryenTypeFloat32()"; - case Type::f64: - return "BinaryenTypeFloat64()"; - case Type::v128: - return "BinaryenTypeVec128()"; - case Type::funcref: - return "BinaryenTypeFuncref()"; - case Type::anyref: - return "BinaryenTypeAnyref()"; - case Type::nullref: - return "BinaryenTypeNullref()"; - case Type::exnref: - return "BinaryenTypeExnref()"; - case Type::unreachable: - return "BinaryenTypeUnreachable()"; - default: - WASM_UNREACHABLE("unexpected type"); - } -} - -struct TypeArg { - BinaryenType type; - TypeArg(BinaryenType type) : type(type){}; -}; - -std::ostream& operator<<(std::ostream& os, TypeArg t) { - if (isBasicAPIType(t.type)) { - return os << basicAPITypeFunction(t.type); - } else { - auto it = types.find(t.type); - assert(it != types.end()); - return os << "types[" << it->second << "]"; - } -} - -size_t noteType(BinaryenType type) { - // Basic types can be trivially rematerialized at every use - assert(!isBasicAPIType(type)); - // Unlike expressions, the same type can be created multiple times - auto it = types.find(type); - if (it != types.end()) { - return it->second; - } else { - auto id = types.size(); - types[type] = id; - return id; - } -} - -size_t noteExpression(BinaryenExpressionRef expression) { - auto id = expressions.size(); - assert(expressions.find(expression) == expressions.end()); - expressions[expression] = id; - return id; -} - -// Even though unlikely, it is possible that we are trying to use an id that is -// still in use after wrapping around, which we must prevent. -static std::unordered_set<size_t> usedExpressionRunnerIds; - -size_t noteExpressionRunner(ExpressionRunnerRef runner) { - // We would normally use the size of `expressionRunners` as the next index, - // but since we are going to delete runners the same address can become - // reused, which would result in unpredictable sizes (indexes) due to - // undefined behavior. Use a sequential id instead. - static size_t nextId = 0; - - size_t id; - do { - id = nextId++; - } while (usedExpressionRunnerIds.find(id) != usedExpressionRunnerIds.end()); - expressionRunners[runner] = id; - usedExpressionRunnerIds.insert(id); - return id; -} - -std::string getTemp() { - static size_t n = 0; - return "t" + std::to_string(n++); -} - -template<typename T> -void printArg(std::ostream& setup, std::ostream& out, T arg) { - out << arg; -} - -template<> -void printArg(std::ostream& setup, std::ostream& out, BinaryenType arg) { - out << TypeArg(arg); -} - -template<> -void printArg(std::ostream& setup, - std::ostream& out, - BinaryenExpressionRef arg) { - out << "expressions[" << expressions[arg] << "]"; -} - -struct StringLit { - const char* name; - StringLit(const char* name) : name(name){}; -}; - -template<> -void printArg(std::ostream& setup, std::ostream& out, StringLit arg) { - traceNameOrNULL(arg.name, out); -} - -template<> -void printArg(std::ostream& setup, std::ostream& out, BinaryenLiteral arg) { - switch (arg.type) { - case Type::i32: - out << "BinaryenLiteralInt32(" << arg.i32 << ")"; - break; - case Type::i64: - out << "BinaryenLiteralInt64(" << arg.i64 << ")"; - break; - case Type::f32: - if (std::isnan(arg.f32)) { - out << "BinaryenLiteralFloat32(NAN)"; - break; - } else { - out << "BinaryenLiteralFloat32(" << arg.f32 << ")"; - break; - } - case Type::f64: - if (std::isnan(arg.f64)) { - out << "BinaryenLiteralFloat64(NAN)"; - break; - } else { - out << "BinaryenLiteralFloat64(" << arg.f64 << ")"; - break; - } - case Type::v128: { - std::string array = getTemp(); - setup << "uint8_t " << array << "[] = {"; - for (size_t i = 0; i < 16; ++i) { - setup << int(arg.v128[i]); - if (i < 15) { - setup << ", "; - } - } - setup << "};\n"; - out << "BinaryenLiteralVec128(" << array << ")"; - break; - } - case Type::funcref: - out << "BinaryenLiteralFuncref(" << arg.func << ")"; - break; - case Type::nullref: - out << "BinaryenLiteralNullref()"; - break; - case Type::anyref: - case Type::exnref: - case Type::none: - case Type::unreachable: - WASM_UNREACHABLE("unexpected type"); - } -} - -template<typename T> -void traceArgs(std::ostream& setup, std::ostream& out, T arg) { - printArg(setup, out, arg); -} - -template<typename T, typename S, typename... Ts> -void traceArgs( - std::ostream& setup, std::ostream& out, T arg, S next, Ts... rest) { - printArg(setup, out, arg); - out << ", "; - traceArgs(setup, out, next, rest...); -} - -template<typename... Ts> -void traceExpression(BinaryenExpressionRef expr, - const char* constructor, - Ts... args) { - auto id = noteExpression(expr); - std::stringstream setup, out; - out << "expressions[" << id << "] = " << constructor << "("; - traceArgs(setup, out, "the_module", args...); - out << ");\n"; - if (!setup.str().empty()) { - std::cout << " {\n"; - for (std::string line; getline(setup, line);) { - std::cout << " " << line << "\n"; - } - std::cout << " " << out.str(); - std::cout << " }\n"; - } else { - std::cout << " " << out.str(); - } -} - -template<typename F> -void traceWithExpressionArray(const char* name, - BinaryenExpressionRef* exprs, - BinaryenIndex numExprs, - F body) { - std::cout << " {\n"; - std::cout << " BinaryenExpressionRef " << name << "[] = { "; - for (BinaryenIndex i = 0; i < numExprs; i++) { - if (i > 0) { - std::cout << ", "; - } - if (i % 6 == 5) { - std::cout << "\n "; // don't create hugely long lines - } - std::cout << "expressions[" << expressions[exprs[i]] << "]"; - } - if (numExprs == 0) { - // ensure the array is not empty, otherwise a compiler error on VS - std::cout << "0"; - } - std::cout << " };\n "; - body(); - std::cout << " }\n"; -} - extern "C" { // @@ -399,26 +143,7 @@ BinaryenType BinaryenTypeCreate(BinaryenType* types, uint32_t numTypes) { for (size_t i = 0; i < numTypes; ++i) { typeVec.push_back(Type(types[i])); } - Type result(typeVec); - - if (tracing && !isBasicAPIType(result.getID())) { - auto id = noteType(result.getID()); - std::string array = getTemp(); - std::cout << " {\n"; - std::cout << " BinaryenType " << array << "[] = {"; - for (size_t i = 0; i < numTypes; ++i) { - std::cout << basicAPITypeFunction(types[i]); - if (i < numTypes - 1) { - std::cout << ", "; - } - } - std::cout << "};\n"; - std::cout << " types[" << id << "] = BinaryenTypeCreate(" << array - << ", " << numTypes << ");\n"; - std::cout << " }\n"; - } - - return result.getID(); + return Type(typeVec).getID(); } uint32_t BinaryenTypeArity(BinaryenType t) { return Type(t).size(); } @@ -606,37 +331,8 @@ BinaryenFeatures BinaryenFeatureAll(void) { // Modules -BinaryenModuleRef BinaryenModuleCreate(void) { - if (tracing) { - std::cout << " the_module = BinaryenModuleCreate();\n"; - std::cout << " expressions[size_t(NULL)] = BinaryenExpressionRef(NULL);\n"; - expressions[NULL] = 0; - } - - return new Module(); -} -void BinaryenModuleDispose(BinaryenModuleRef module) { - if (tracing) { - std::cout << " BinaryenModuleDispose(the_module);\n"; - std::cout << " types.clear();\n"; - std::cout << " expressions.clear();\n"; - std::cout << " functions.clear();\n"; - std::cout << " globals.clear();\n"; - std::cout << " events.clear();\n"; - std::cout << " exports.clear();\n"; - std::cout << " relooperBlocks.clear();\n"; - std::cout << " expressionRunners.clear();\n"; - types.clear(); - expressions.clear(); - functions.clear(); - globals.clear(); - events.clear(); - exports.clear(); - relooperBlocks.clear(); - } - - delete (Module*)module; -} +BinaryenModuleRef BinaryenModuleCreate(void) { return new Module(); } +void BinaryenModuleDispose(BinaryenModuleRef module) { delete (Module*)module; } // Literals @@ -1097,14 +793,6 @@ BinaryenExpressionRef BinaryenBlock(BinaryenModuleRef module, } else { ret->finalize(); } - - if (tracing) { - traceWithExpressionArray("children", children, numChildren, [&]() { - traceExpression( - ret, "BinaryenBlock", StringLit(name), "children", numChildren, type); - }); - } - return static_cast<Expression*>(ret); } BinaryenExpressionRef BinaryenIf(BinaryenModuleRef module, @@ -1116,37 +804,22 @@ BinaryenExpressionRef BinaryenIf(BinaryenModuleRef module, ret->ifTrue = (Expression*)ifTrue; ret->ifFalse = (Expression*)ifFalse; ret->finalize(); - - if (tracing) { - traceExpression(ret, "BinaryenIf", condition, ifTrue, ifFalse); - } - return static_cast<Expression*>(ret); } 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); - } - - return static_cast<Expression*>(ret); + return static_cast<Expression*>( + Builder(*(Module*)module) + .makeLoop(name ? Name(name) : Name(), (Expression*)body)); } BinaryenExpressionRef BinaryenBreak(BinaryenModuleRef module, const char* name, BinaryenExpressionRef condition, BinaryenExpressionRef value) { - auto* ret = Builder(*(Module*)module) - .makeBreak(name, (Expression*)value, (Expression*)condition); - - if (tracing) { - traceExpression(ret, "BinaryenBreak", StringLit(name), condition, value); - } - - return static_cast<Expression*>(ret); + return static_cast<Expression*>( + Builder(*(Module*)module) + .makeBreak(name, (Expression*)value, (Expression*)condition)); } BinaryenExpressionRef BinaryenSwitch(BinaryenModuleRef module, const char** names, @@ -1155,31 +828,6 @@ BinaryenExpressionRef BinaryenSwitch(BinaryenModuleRef module, BinaryenExpressionRef condition, BinaryenExpressionRef value) { auto* ret = ((Module*)module)->allocator.alloc<Switch>(); - - if (tracing) { - std::cout << " {\n"; - std::cout << " const char* names[] = { "; - for (BinaryenIndex i = 0; i < numNames; i++) { - if (i > 0) { - std::cout << ", "; - } - std::cout << "\"" << names[i] << "\""; - } - if (numNames == 0) { - // ensure the array is not empty, otherwise a compiler error on VS - std::cout << "0"; - } - std::cout << " };\n "; - traceExpression(ret, - "BinaryenSwitch", - "names", - numNames, - StringLit(defaultName), - condition, - value); - std::cout << " }\n"; - } - for (BinaryenIndex i = 0; i < numNames; i++) { ret->targets.push_back(names[i]); } @@ -1196,18 +844,6 @@ static BinaryenExpressionRef makeBinaryenCall(BinaryenModuleRef module, BinaryenType returnType, bool isReturn) { auto* ret = ((Module*)module)->allocator.alloc<Call>(); - - if (tracing) { - traceWithExpressionArray("operands", operands, numOperands, [&]() { - traceExpression(ret, - (isReturn ? "BinaryenReturnCall" : "BinaryenCall"), - StringLit(target), - "operands", - numOperands, - returnType); - }); - } - ret->target = target; for (BinaryenIndex i = 0; i < numOperands; i++) { ret->operands.push_back((Expression*)operands[i]); @@ -1241,34 +877,7 @@ makeBinaryenCallIndirect(BinaryenModuleRef module, BinaryenType params, BinaryenType results, bool isReturn) { - auto* wasm = (Module*)module; - auto* ret = wasm->allocator.alloc<CallIndirect>(); - - if (tracing) { - std::cout << " {\n"; - std::cout << " BinaryenExpressionRef operands[] = { "; - for (BinaryenIndex i = 0; i < numOperands; i++) { - if (i > 0) { - std::cout << ", "; - } - std::cout << "expressions[" << expressions[operands[i]] << "]"; - } - if (numOperands == 0) { - // ensure the array is not empty, otherwise a compiler error on VS - std::cout << "0"; - } - std::cout << " };\n "; - traceExpression( - ret, - (isReturn ? "BinaryenReturnCallIndirect" : "BinaryenCallIndirect"), - target, - "operands", - numOperands, - params, - results); - std::cout << " }\n"; - } - + auto* ret = ((Module*)module)->allocator.alloc<CallIndirect>(); ret->target = (Expression*)target; for (BinaryenIndex i = 0; i < numOperands; i++) { ret->operands.push_back((Expression*)operands[i]); @@ -1302,11 +911,6 @@ BinaryenExpressionRef BinaryenLocalGet(BinaryenModuleRef module, BinaryenIndex index, BinaryenType type) { auto* ret = ((Module*)module)->allocator.alloc<LocalGet>(); - - if (tracing) { - traceExpression(ret, "BinaryenLocalGet", index, type); - } - ret->index = index; ret->type = Type(type); ret->finalize(); @@ -1316,11 +920,6 @@ BinaryenExpressionRef BinaryenLocalSet(BinaryenModuleRef module, BinaryenIndex index, BinaryenExpressionRef value) { auto* ret = ((Module*)module)->allocator.alloc<LocalSet>(); - - if (tracing) { - traceExpression(ret, "BinaryenLocalSet", index, value); - } - ret->index = index; ret->value = (Expression*)value; ret->makeSet(); @@ -1332,11 +931,6 @@ BinaryenExpressionRef BinaryenLocalTee(BinaryenModuleRef module, BinaryenExpressionRef value, BinaryenType type) { auto* ret = ((Module*)module)->allocator.alloc<LocalSet>(); - - if (tracing) { - traceExpression(ret, "BinaryenLocalTee", index, value, type); - } - ret->index = index; ret->value = (Expression*)value; ret->makeTee(Type(type)); @@ -1347,11 +941,6 @@ BinaryenExpressionRef BinaryenGlobalGet(BinaryenModuleRef module, const char* name, BinaryenType type) { auto* ret = ((Module*)module)->allocator.alloc<GlobalGet>(); - - if (tracing) { - traceExpression(ret, "BinaryenGlobalGet", StringLit(name), type); - } - ret->name = name; ret->type = Type(type); ret->finalize(); @@ -1361,11 +950,6 @@ BinaryenExpressionRef BinaryenGlobalSet(BinaryenModuleRef module, const char* name, BinaryenExpressionRef value) { auto* ret = ((Module*)module)->allocator.alloc<GlobalSet>(); - - if (tracing) { - traceExpression(ret, "BinaryenGlobalSet", StringLit(name), value); - } - ret->name = name; ret->value = (Expression*)value; ret->finalize(); @@ -1379,11 +963,6 @@ BinaryenExpressionRef BinaryenLoad(BinaryenModuleRef module, BinaryenType type, BinaryenExpressionRef ptr) { auto* ret = ((Module*)module)->allocator.alloc<Load>(); - - if (tracing) { - traceExpression( - ret, "BinaryenLoad", bytes, int(signed_), offset, align, type, ptr); - } ret->isAtomic = false; ret->bytes = bytes; ret->signed_ = !!signed_; @@ -1402,11 +981,6 @@ BinaryenExpressionRef BinaryenStore(BinaryenModuleRef module, BinaryenExpressionRef value, BinaryenType type) { auto* ret = ((Module*)module)->allocator.alloc<Store>(); - - if (tracing) { - traceExpression( - ret, "BinaryenStore", bytes, offset, align, ptr, value, type); - } ret->isAtomic = false; ret->bytes = bytes; ret->offset = offset; @@ -1419,37 +993,22 @@ BinaryenExpressionRef BinaryenStore(BinaryenModuleRef module, } BinaryenExpressionRef BinaryenConst(BinaryenModuleRef module, BinaryenLiteral value) { - auto* ret = Builder(*(Module*)module).makeConst(fromBinaryenLiteral(value)); - if (tracing) { - traceExpression(ret, "BinaryenConst", value); - } - return static_cast<Expression*>(ret); + return static_cast<Expression*>( + Builder(*(Module*)module).makeConst(fromBinaryenLiteral(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); - } - - return static_cast<Expression*>(ret); + return static_cast<Expression*>( + Builder(*(Module*)module).makeUnary(UnaryOp(op), (Expression*)value)); } BinaryenExpressionRef BinaryenBinary(BinaryenModuleRef module, BinaryenOp op, BinaryenExpressionRef left, BinaryenExpressionRef right) { - auto* ret = + return static_cast<Expression*>( Builder(*(Module*)module) - .makeBinary(BinaryOp(op), (Expression*)left, (Expression*)right); - - if (tracing) { - traceExpression(ret, "BinaryenBinary", op, left, right); - } - - return static_cast<Expression*>(ret); + .makeBinary(BinaryOp(op), (Expression*)left, (Expression*)right)); } BinaryenExpressionRef BinaryenSelect(BinaryenModuleRef module, BinaryenExpressionRef condition, @@ -1457,11 +1016,6 @@ BinaryenExpressionRef BinaryenSelect(BinaryenModuleRef module, BinaryenExpressionRef ifFalse, BinaryenType type) { auto* ret = ((Module*)module)->allocator.alloc<Select>(); - - if (tracing) { - traceExpression(ret, "BinaryenSelect", condition, ifTrue, ifFalse, type); - } - ret->condition = (Expression*)condition; ret->ifTrue = (Expression*)ifTrue; ret->ifFalse = (Expression*)ifFalse; @@ -1475,11 +1029,6 @@ BinaryenExpressionRef BinaryenSelect(BinaryenModuleRef module, BinaryenExpressionRef BinaryenDrop(BinaryenModuleRef module, BinaryenExpressionRef value) { auto* ret = ((Module*)module)->allocator.alloc<Drop>(); - - if (tracing) { - traceExpression(ret, "BinaryenDrop", value); - } - ret->value = (Expression*)value; ret->finalize(); return static_cast<Expression*>(ret); @@ -1487,11 +1036,6 @@ BinaryenExpressionRef BinaryenDrop(BinaryenModuleRef module, BinaryenExpressionRef BinaryenReturn(BinaryenModuleRef module, BinaryenExpressionRef value) { auto* ret = Builder(*(Module*)module).makeReturn((Expression*)value); - - if (tracing) { - traceExpression(ret, "BinaryenReturn", value); - } - return static_cast<Expression*>(ret); } BinaryenExpressionRef BinaryenHost(BinaryenModuleRef module, @@ -1500,26 +1044,6 @@ BinaryenExpressionRef BinaryenHost(BinaryenModuleRef module, BinaryenExpressionRef* operands, BinaryenIndex numOperands) { auto* ret = ((Module*)module)->allocator.alloc<Host>(); - - if (tracing) { - std::cout << " {\n"; - std::cout << " BinaryenExpressionRef operands[] = { "; - for (BinaryenIndex i = 0; i < numOperands; i++) { - if (i > 0) { - std::cout << ", "; - } - std::cout << "expressions[" << expressions[operands[i]] << "]"; - } - if (numOperands == 0) { - // ensure the array is not empty, otherwise a compiler error on VS - std::cout << "0"; - } - std::cout << " };\n "; - traceExpression( - ret, "BinaryenHost", StringLit(name), "operands", numOperands); - std::cout << " }\n"; - } - ret->op = HostOp(op); if (name) { ret->nameOperand = name; @@ -1531,36 +1055,20 @@ BinaryenExpressionRef BinaryenHost(BinaryenModuleRef module, return static_cast<Expression*>(ret); } BinaryenExpressionRef BinaryenNop(BinaryenModuleRef module) { - auto* ret = ((Module*)module)->allocator.alloc<Nop>(); - - if (tracing) { - traceExpression(ret, "BinaryenNop"); - } - - return static_cast<Expression*>(ret); + return static_cast<Expression*>(((Module*)module)->allocator.alloc<Nop>()); } BinaryenExpressionRef BinaryenUnreachable(BinaryenModuleRef module) { - auto* ret = ((Module*)module)->allocator.alloc<Unreachable>(); - - if (tracing) { - traceExpression(ret, "BinaryenUnreachable"); - } - - return static_cast<Expression*>(ret); + return static_cast<Expression*>( + ((Module*)module)->allocator.alloc<Unreachable>()); } BinaryenExpressionRef BinaryenAtomicLoad(BinaryenModuleRef module, uint32_t bytes, uint32_t offset, BinaryenType type, BinaryenExpressionRef ptr) { - auto* ret = Builder(*(Module*)module) - .makeAtomicLoad(bytes, offset, (Expression*)ptr, Type(type)); - - if (tracing) { - traceExpression(ret, "BinaryenAtomicLoad", bytes, offset, type, ptr); - } - - return static_cast<Expression*>(ret); + return static_cast<Expression*>( + Builder(*(Module*)module) + .makeAtomicLoad(bytes, offset, (Expression*)ptr, Type(type))); } BinaryenExpressionRef BinaryenAtomicStore(BinaryenModuleRef module, uint32_t bytes, @@ -1568,17 +1076,10 @@ BinaryenExpressionRef BinaryenAtomicStore(BinaryenModuleRef module, BinaryenExpressionRef ptr, BinaryenExpressionRef value, BinaryenType type) { - auto* ret = + return static_cast<Expression*>( Builder(*(Module*)module) .makeAtomicStore( - bytes, offset, (Expression*)ptr, (Expression*)value, Type(type)); - - if (tracing) { - traceExpression( - ret, "BinaryenAtomicStore", bytes, offset, ptr, value, type); - } - - return static_cast<Expression*>(ret); + bytes, offset, (Expression*)ptr, (Expression*)value, Type(type))); } BinaryenExpressionRef BinaryenAtomicRMW(BinaryenModuleRef module, BinaryenOp op, @@ -1587,20 +1088,13 @@ BinaryenExpressionRef BinaryenAtomicRMW(BinaryenModuleRef module, BinaryenExpressionRef ptr, BinaryenExpressionRef value, BinaryenType type) { - auto* ret = Builder(*(Module*)module) - .makeAtomicRMW(AtomicRMWOp(op), - bytes, - offset, - (Expression*)ptr, - (Expression*)value, - Type(type)); - - if (tracing) { - traceExpression( - ret, "BinaryenAtomicRMW", op, bytes, offset, ptr, value, type); - } - - return static_cast<Expression*>(ret); + return static_cast<Expression*>(Builder(*(Module*)module) + .makeAtomicRMW(AtomicRMWOp(op), + bytes, + offset, + (Expression*)ptr, + (Expression*)value, + Type(type))); } BinaryenExpressionRef BinaryenAtomicCmpxchg(BinaryenModuleRef module, BinaryenIndex bytes, @@ -1609,92 +1103,53 @@ BinaryenExpressionRef BinaryenAtomicCmpxchg(BinaryenModuleRef module, BinaryenExpressionRef expected, BinaryenExpressionRef replacement, BinaryenType type) { - auto* ret = Builder(*(Module*)module) - .makeAtomicCmpxchg(bytes, - offset, - (Expression*)ptr, - (Expression*)expected, - (Expression*)replacement, - Type(type)); - - if (tracing) { - traceExpression(ret, - "BinaryenAtomicCmpxchg", - bytes, - offset, - ptr, - expected, - replacement, - type); - } - - return static_cast<Expression*>(ret); + return static_cast<Expression*>(Builder(*(Module*)module) + .makeAtomicCmpxchg(bytes, + offset, + (Expression*)ptr, + (Expression*)expected, + (Expression*)replacement, + Type(type))); } BinaryenExpressionRef BinaryenAtomicWait(BinaryenModuleRef module, BinaryenExpressionRef ptr, BinaryenExpressionRef expected, BinaryenExpressionRef timeout, BinaryenType expectedType) { - auto* ret = Builder(*(Module*)module) - .makeAtomicWait((Expression*)ptr, - (Expression*)expected, - (Expression*)timeout, - Type(expectedType), - 0); - - if (tracing) { - traceExpression( - ret, "BinaryenAtomicWait", ptr, expected, timeout, expectedType); - } - - return static_cast<Expression*>(ret); + return static_cast<Expression*>(Builder(*(Module*)module) + .makeAtomicWait((Expression*)ptr, + (Expression*)expected, + (Expression*)timeout, + Type(expectedType), + 0)); } BinaryenExpressionRef BinaryenAtomicNotify(BinaryenModuleRef module, BinaryenExpressionRef ptr, BinaryenExpressionRef notifyCount) { - auto* ret = + return static_cast<Expression*>( Builder(*(Module*)module) - .makeAtomicNotify((Expression*)ptr, (Expression*)notifyCount, 0); - - if (tracing) { - traceExpression(ret, "BinaryenAtomicNotify", ptr, notifyCount); - } - - return static_cast<Expression*>(ret); + .makeAtomicNotify((Expression*)ptr, (Expression*)notifyCount, 0)); } BinaryenExpressionRef BinaryenAtomicFence(BinaryenModuleRef module) { - auto* ret = Builder(*(Module*)module).makeAtomicFence(); - - if (tracing) { - traceExpression(ret, "BinaryenAtomicFence"); - } - - return static_cast<Expression*>(ret); + return static_cast<Expression*>(Builder(*(Module*)module).makeAtomicFence()); } BinaryenExpressionRef BinaryenSIMDExtract(BinaryenModuleRef module, BinaryenOp op, BinaryenExpressionRef vec, uint8_t index) { - auto* ret = Builder(*(Module*)module) - .makeSIMDExtract(SIMDExtractOp(op), (Expression*)vec, index); - if (tracing) { - traceExpression(ret, "BinaryenSIMDExtract", op, vec, int(index)); - } - return static_cast<Expression*>(ret); + return static_cast<Expression*>( + Builder(*(Module*)module) + .makeSIMDExtract(SIMDExtractOp(op), (Expression*)vec, index)); } BinaryenExpressionRef BinaryenSIMDReplace(BinaryenModuleRef module, BinaryenOp op, BinaryenExpressionRef vec, uint8_t index, BinaryenExpressionRef value) { - auto* ret = + return static_cast<Expression*>( Builder(*(Module*)module) .makeSIMDReplace( - SIMDReplaceOp(op), (Expression*)vec, index, (Expression*)value); - if (tracing) { - traceExpression(ret, "BinaryenSIMDReplace", op, vec, int(index), value); - } - return static_cast<Expression*>(ret); + SIMDReplaceOp(op), (Expression*)vec, index, (Expression*)value)); } BinaryenExpressionRef BinaryenSIMDShuffle(BinaryenModuleRef module, BinaryenExpressionRef left, @@ -1702,111 +1157,73 @@ BinaryenExpressionRef BinaryenSIMDShuffle(BinaryenModuleRef module, const uint8_t mask_[16]) { std::array<uint8_t, 16> mask; memcpy(mask.data(), mask_, 16); - auto* ret = Builder(*(Module*)module) - .makeSIMDShuffle((Expression*)left, (Expression*)right, mask); - if (tracing) { - std::cout << " {\n"; - std::cout << " uint8_t mask[] = {"; - for (size_t i = 0; i < mask.size(); ++i) { - std::cout << int(mask[i]); - if (i < mask.size() - 1) { - std::cout << ", "; - } - } - std::cout << "};\n "; - traceExpression(ret, "BinaryenSIMDShuffle", left, right, "mask"); - std::cout << " }\n"; - } - return static_cast<Expression*>(ret); + return static_cast<Expression*>( + Builder(*(Module*)module) + .makeSIMDShuffle((Expression*)left, (Expression*)right, mask)); } BinaryenExpressionRef BinaryenSIMDTernary(BinaryenModuleRef module, BinaryenOp op, BinaryenExpressionRef a, BinaryenExpressionRef b, BinaryenExpressionRef c) { - auto* ret = + return static_cast<Expression*>( Builder(*(Module*)module) .makeSIMDTernary( - SIMDTernaryOp(op), (Expression*)a, (Expression*)b, (Expression*)c); - if (tracing) { - traceExpression(ret, "BinaryenSIMDTernary", op, a, b, c); - } - return static_cast<Expression*>(ret); + SIMDTernaryOp(op), (Expression*)a, (Expression*)b, (Expression*)c)); } BinaryenExpressionRef BinaryenSIMDShift(BinaryenModuleRef module, BinaryenOp op, BinaryenExpressionRef vec, BinaryenExpressionRef shift) { - auto* ret = + return static_cast<Expression*>( Builder(*(Module*)module) - .makeSIMDShift(SIMDShiftOp(op), (Expression*)vec, (Expression*)shift); - if (tracing) { - traceExpression(ret, "BinaryenSIMDShift", op, vec, shift); - } - return static_cast<Expression*>(ret); + .makeSIMDShift(SIMDShiftOp(op), (Expression*)vec, (Expression*)shift)); } BinaryenExpressionRef BinaryenSIMDLoad(BinaryenModuleRef module, BinaryenOp op, uint32_t offset, uint32_t align, BinaryenExpressionRef ptr) { - auto* ret = + return static_cast<Expression*>( Builder(*(Module*)module) .makeSIMDLoad( - SIMDLoadOp(op), Address(offset), Address(align), (Expression*)ptr); - if (tracing) { - traceExpression(ret, "BinaryenSIMDLoad", op, offset, align, ptr); - } - return static_cast<Expression*>(ret); + SIMDLoadOp(op), Address(offset), Address(align), (Expression*)ptr)); } BinaryenExpressionRef BinaryenMemoryInit(BinaryenModuleRef module, uint32_t segment, BinaryenExpressionRef dest, BinaryenExpressionRef offset, BinaryenExpressionRef size) { - auto* ret = + return static_cast<Expression*>( Builder(*(Module*)module) .makeMemoryInit( - segment, (Expression*)dest, (Expression*)offset, (Expression*)size); - if (tracing) { - traceExpression(ret, "BinaryenMemoryInit", segment, dest, offset, size); - } - return static_cast<Expression*>(ret); + segment, (Expression*)dest, (Expression*)offset, (Expression*)size)); } BinaryenExpressionRef BinaryenDataDrop(BinaryenModuleRef module, uint32_t segment) { - auto* ret = Builder(*(Module*)module).makeDataDrop(segment); - if (tracing) { - traceExpression(ret, "BinaryenDataDrop", segment); - } - return static_cast<Expression*>(ret); + return static_cast<Expression*>( + Builder(*(Module*)module).makeDataDrop(segment)); } BinaryenExpressionRef BinaryenMemoryCopy(BinaryenModuleRef module, BinaryenExpressionRef dest, BinaryenExpressionRef source, BinaryenExpressionRef size) { - auto* ret = Builder(*(Module*)module) - .makeMemoryCopy( - (Expression*)dest, (Expression*)source, (Expression*)size); - if (tracing) { - traceExpression(ret, "BinaryenMemoryCopy", dest, source, size); - } - return static_cast<Expression*>(ret); + return static_cast<Expression*>(Builder(*(Module*)module) + .makeMemoryCopy((Expression*)dest, + (Expression*)source, + (Expression*)size)); } BinaryenExpressionRef BinaryenMemoryFill(BinaryenModuleRef module, BinaryenExpressionRef dest, BinaryenExpressionRef value, BinaryenExpressionRef size) { - auto* ret = - Builder(*(Module*)module) - .makeMemoryFill((Expression*)dest, (Expression*)value, (Expression*)size); - if (tracing) { - traceExpression(ret, "BinaryenMemoryFill", dest, value, size); - } - return static_cast<Expression*>(ret); + return static_cast<Expression*>(Builder(*(Module*)module) + .makeMemoryFill((Expression*)dest, + (Expression*)value, + (Expression*)size)); } BinaryenExpressionRef BinaryenTupleMake(BinaryenModuleRef module, @@ -1817,77 +1234,47 @@ BinaryenExpressionRef BinaryenTupleMake(BinaryenModuleRef module, for (size_t i = 0; i < numOperands; ++i) { ops[i] = (Expression*)operands[i]; } - auto* ret = Builder(*(Module*)module).makeTupleMake(ops); - if (tracing) { - traceWithExpressionArray("operands", operands, numOperands, [&]() { - traceExpression(ret, "BinaryenTupleMake", "operands", numOperands); - }); - } - return static_cast<Expression*>(ret); + return static_cast<Expression*>(Builder(*(Module*)module).makeTupleMake(ops)); } BinaryenExpressionRef BinaryenTupleExtract(BinaryenModuleRef module, BinaryenExpressionRef tuple, BinaryenIndex index) { - auto* ret = - Builder(*(Module*)module).makeTupleExtract((Expression*)tuple, index); - if (tracing) { - traceExpression(ret, "BinaryenTupleExtract", tuple, index); - } - return ret; + return static_cast<Expression*>( + Builder(*(Module*)module).makeTupleExtract((Expression*)tuple, index)); } BinaryenExpressionRef BinaryenPush(BinaryenModuleRef module, BinaryenExpressionRef value) { - auto* ret = Builder(*(Module*)module).makePush((Expression*)value); - if (tracing) { - traceExpression(ret, "BinaryenPush", value); - } - return static_cast<Expression*>(ret); + return static_cast<Expression*>( + Builder(*(Module*)module).makePush((Expression*)value)); } BinaryenExpressionRef BinaryenPop(BinaryenModuleRef module, BinaryenType type) { - auto* ret = Builder(*(Module*)module).makePop(Type(type)); - if (tracing) { - traceExpression(ret, "BinaryenPop", type); - } - return static_cast<Expression*>(ret); + return static_cast<Expression*>( + Builder(*(Module*)module).makePop(Type(type))); } BinaryenExpressionRef BinaryenRefNull(BinaryenModuleRef module) { - auto* ret = Builder(*(Module*)module).makeRefNull(); - if (tracing) { - traceExpression(ret, "BinaryenRefNull"); - } - return static_cast<Expression*>(ret); + return static_cast<Expression*>(Builder(*(Module*)module).makeRefNull()); } BinaryenExpressionRef BinaryenRefIsNull(BinaryenModuleRef module, BinaryenExpressionRef value) { - auto* ret = Builder(*(Module*)module).makeRefIsNull((Expression*)value); - if (tracing) { - traceExpression(ret, "BinaryenRefIsNull", value); - } - return static_cast<Expression*>(ret); + return static_cast<Expression*>( + Builder(*(Module*)module).makeRefIsNull((Expression*)value)); } BinaryenExpressionRef BinaryenRefFunc(BinaryenModuleRef module, const char* func) { - auto* ret = Builder(*(Module*)module).makeRefFunc(func); - if (tracing) { - traceExpression(ret, "BinaryenRefFunc", StringLit(func)); - } - return static_cast<Expression*>(ret); + return static_cast<Expression*>(Builder(*(Module*)module).makeRefFunc(func)); } BinaryenExpressionRef BinaryenTry(BinaryenModuleRef module, BinaryenExpressionRef body, BinaryenExpressionRef catchBody) { - auto* ret = Builder(*(Module*)module) - .makeTry((Expression*)body, (Expression*)catchBody); - if (tracing) { - traceExpression(ret, "BinaryenTry", body, catchBody); - } - return static_cast<Expression*>(ret); + return static_cast<Expression*>( + Builder(*(Module*)module) + .makeTry((Expression*)body, (Expression*)catchBody)); } BinaryenExpressionRef BinaryenThrow(BinaryenModuleRef module, @@ -1898,66 +1285,36 @@ BinaryenExpressionRef BinaryenThrow(BinaryenModuleRef module, for (BinaryenIndex i = 0; i < numOperands; i++) { args.push_back((Expression*)operands[i]); } - auto* ret = Builder(*(Module*)module).makeThrow(event, args); - - if (tracing) { - traceWithExpressionArray("operands", operands, numOperands, [&]() { - traceExpression( - ret, "BinaryenThrow", StringLit(event), "operands", numOperands); - }); - } - return static_cast<Expression*>(ret); + return static_cast<Expression*>( + Builder(*(Module*)module).makeThrow(event, args)); } BinaryenExpressionRef BinaryenRethrow(BinaryenModuleRef module, BinaryenExpressionRef exnref) { - auto* ret = Builder(*(Module*)module).makeRethrow((Expression*)exnref); - if (tracing) { - traceExpression(ret, "BinaryenRethrow", exnref); - } - return static_cast<Expression*>(ret); + return static_cast<Expression*>( + Builder(*(Module*)module).makeRethrow((Expression*)exnref)); } BinaryenExpressionRef BinaryenBrOnExn(BinaryenModuleRef module, const char* name, const char* eventName, BinaryenExpressionRef exnref) { - Module* wasm = (Module*)module; + auto* wasm = (Module*)module; Event* event = wasm->getEventOrNull(eventName); assert(event && "br_on_exn's event must exist"); - auto* ret = Builder(*wasm).makeBrOnExn(name, event, (Expression*)exnref); - - if (tracing) { - traceExpression( - ret, "BinaryenBrOnExn", StringLit(name), StringLit(eventName), exnref); - } - return static_cast<Expression*>(ret); + return static_cast<Expression*>( + Builder(*wasm).makeBrOnExn(name, event, (Expression*)exnref)); } // Expression utility BinaryenExpressionId BinaryenExpressionGetId(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenExpressionGetId(expressions[" << expressions[expr] - << "]);\n"; - } - return ((Expression*)expr)->_id; } BinaryenType BinaryenExpressionGetType(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenExpressionGetType(expressions[" << expressions[expr] - << "]);\n"; - } - return ((Expression*)expr)->type.getID(); } void BinaryenExpressionPrint(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenExpressionPrint(expressions[" << expressions[expr] - << "]);\n"; - } - WasmPrinter::printExpression((Expression*)expr, std::cout); std::cout << '\n'; } @@ -1966,32 +1323,17 @@ void BinaryenExpressionPrint(BinaryenExpressionRef expr) { // Block const char* BinaryenBlockGetName(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenBlockGetName(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<Block>()); return static_cast<Block*>(expression)->name.c_str(); } BinaryenIndex BinaryenBlockGetNumChildren(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenBlockGetNumChildren(expressions[" - << expressions[expr] << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<Block>()); return static_cast<Block*>(expression)->list.size(); } BinaryenExpressionRef BinaryenBlockGetChild(BinaryenExpressionRef expr, BinaryenIndex index) { - if (tracing) { - std::cout << " BinaryenBlockGetChild(expressions[" << expressions[expr] - << "], " << index << ");\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<Block>()); assert(index < static_cast<Block*>(expression)->list.size()); @@ -1999,178 +1341,93 @@ BinaryenExpressionRef BinaryenBlockGetChild(BinaryenExpressionRef expr, } // If BinaryenExpressionRef BinaryenIfGetCondition(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenIfGetCondition(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<If>()); return static_cast<If*>(expression)->condition; } BinaryenExpressionRef BinaryenIfGetIfTrue(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenIfGetIfTrue(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<If>()); return static_cast<If*>(expression)->ifTrue; } BinaryenExpressionRef BinaryenIfGetIfFalse(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenIfGetIfFalse(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<If>()); return static_cast<If*>(expression)->ifFalse; } // Loop const char* BinaryenLoopGetName(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenLoopGetName(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<Loop>()); return static_cast<Loop*>(expression)->name.c_str(); } BinaryenExpressionRef BinaryenLoopGetBody(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenLoopGetBody(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<Loop>()); return static_cast<Loop*>(expression)->body; } // Break const char* BinaryenBreakGetName(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenBreakGetName(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<Break>()); return static_cast<Break*>(expression)->name.c_str(); } BinaryenExpressionRef BinaryenBreakGetCondition(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenBreakGetCondition(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<Break>()); return static_cast<Break*>(expression)->condition; } BinaryenExpressionRef BinaryenBreakGetValue(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenBreakGetValue(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<Break>()); return static_cast<Break*>(expression)->value; } // Switch BinaryenIndex BinaryenSwitchGetNumNames(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenSwitchGetNumNames(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<Switch>()); return static_cast<Switch*>(expression)->targets.size(); } const char* BinaryenSwitchGetName(BinaryenExpressionRef expr, BinaryenIndex index) { - if (tracing) { - std::cout << " BinaryenSwitchGetName(expressions[" << expressions[expr] - << "], " << index << ");\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<Switch>()); assert(index < static_cast<Switch*>(expression)->targets.size()); return static_cast<Switch*>(expression)->targets[index].c_str(); } const char* BinaryenSwitchGetDefaultName(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenSwitchGetDefaultName(expressions[" - << expressions[expr] << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<Switch>()); return static_cast<Switch*>(expression)->default_.c_str(); } BinaryenExpressionRef BinaryenSwitchGetCondition(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenSwitchGetCondition(expressions[" - << expressions[expr] << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<Switch>()); return static_cast<Switch*>(expression)->condition; } BinaryenExpressionRef BinaryenSwitchGetValue(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenSwitchGetValue(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<Switch>()); return static_cast<Switch*>(expression)->value; } // Call int BinaryenCallIsReturn(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenCallIsReturn(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<Call>()); return static_cast<Call*>(expression)->isReturn; } const char* BinaryenCallGetTarget(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenCallGetTarget(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<Call>()); return static_cast<Call*>(expression)->target.c_str(); } BinaryenIndex BinaryenCallGetNumOperands(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenCallGetNumOperands(expressions[" - << expressions[expr] << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<Call>()); return static_cast<Call*>(expression)->operands.size(); } BinaryenExpressionRef BinaryenCallGetOperand(BinaryenExpressionRef expr, BinaryenIndex index) { - if (tracing) { - std::cout << " BinaryenCallGetOperand(expressions[" << expressions[expr] - << "], " << index << ");\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<Call>()); assert(index < static_cast<Call*>(expression)->operands.size()); @@ -2178,43 +1435,23 @@ BinaryenExpressionRef BinaryenCallGetOperand(BinaryenExpressionRef expr, } // CallIndirect int BinaryenCallIndirectIsReturn(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenCallIndirectIsReturn(expressions[" - << expressions[expr] << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<CallIndirect>()); return static_cast<CallIndirect*>(expression)->isReturn; } BinaryenExpressionRef BinaryenCallIndirectGetTarget(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenCallIndirectGetTarget(expressions[" - << expressions[expr] << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<CallIndirect>()); return static_cast<CallIndirect*>(expression)->target; } BinaryenIndex BinaryenCallIndirectGetNumOperands(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenCallIndirectGetNumOperands(expressions[" - << expressions[expr] << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<CallIndirect>()); return static_cast<CallIndirect*>(expression)->operands.size(); } BinaryenExpressionRef BinaryenCallIndirectGetOperand(BinaryenExpressionRef expr, BinaryenIndex index) { - if (tracing) { - std::cout << " BinaryenCallIndirectGetOperand(expressions[" - << expressions[expr] << "], " << index << ");\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<CallIndirect>()); assert(index < static_cast<CallIndirect*>(expression)->operands.size()); @@ -2222,116 +1459,61 @@ BinaryenExpressionRef BinaryenCallIndirectGetOperand(BinaryenExpressionRef expr, } // LocalGet BinaryenIndex BinaryenLocalGetGetIndex(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenLocalGetGetIndex(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<LocalGet>()); return static_cast<LocalGet*>(expression)->index; } // LocalSet int BinaryenLocalSetIsTee(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenLocalSetIsTee(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<LocalSet>()); return static_cast<LocalSet*>(expression)->isTee(); } BinaryenIndex BinaryenLocalSetGetIndex(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenLocalSetGetIndex(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<LocalSet>()); return static_cast<LocalSet*>(expression)->index; } BinaryenExpressionRef BinaryenLocalSetGetValue(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenLocalSetGetValue(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<LocalSet>()); return static_cast<LocalSet*>(expression)->value; } // GlobalGet const char* BinaryenGlobalGetGetName(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenGlobalGetGetName(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<GlobalGet>()); return static_cast<GlobalGet*>(expression)->name.c_str(); } // GlobalSet const char* BinaryenGlobalSetGetName(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenGlobalSetGetName(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<GlobalSet>()); return static_cast<GlobalSet*>(expression)->name.c_str(); } BinaryenExpressionRef BinaryenGlobalSetGetValue(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenGlobalSetGetValue(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<GlobalSet>()); return static_cast<GlobalSet*>(expression)->value; } // Host BinaryenOp BinaryenHostGetOp(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenHostGetOp(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<Host>()); return static_cast<Host*>(expression)->op; } const char* BinaryenHostGetNameOperand(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenHostGetNameOperand(expressions[" - << expressions[expr] << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<Host>()); return static_cast<Host*>(expression)->nameOperand.c_str(); } BinaryenIndex BinaryenHostGetNumOperands(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenHostGetNumOperands(expressions[" - << expressions[expr] << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<Host>()); return static_cast<Host*>(expression)->operands.size(); } BinaryenExpressionRef BinaryenHostGetOperand(BinaryenExpressionRef expr, BinaryenIndex index) { - if (tracing) { - std::cout << " BinaryenHostGetOperand(expressions[" << expressions[expr] - << "], " << index << ");\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<Host>()); assert(index < static_cast<Host*>(expression)->operands.size()); @@ -2339,980 +1521,510 @@ BinaryenExpressionRef BinaryenHostGetOperand(BinaryenExpressionRef expr, } // Load int BinaryenLoadIsAtomic(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenLoadIsAtomic(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<Load>()); return static_cast<Load*>(expression)->isAtomic; } int BinaryenLoadIsSigned(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenLoadIsSigned(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<Load>()); return static_cast<Load*>(expression)->signed_; } uint32_t BinaryenLoadGetBytes(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenLoadGetBytes(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<Load>()); return static_cast<Load*>(expression)->bytes; } uint32_t BinaryenLoadGetOffset(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenLoadGetOffset(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<Load>()); return static_cast<Load*>(expression)->offset; } uint32_t BinaryenLoadGetAlign(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenLoadGetAlign(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<Load>()); return static_cast<Load*>(expression)->align; } BinaryenExpressionRef BinaryenLoadGetPtr(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenLoadGetPtr(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<Load>()); return static_cast<Load*>(expression)->ptr; } // Store int BinaryenStoreIsAtomic(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenStoreIsAtomic(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<Store>()); return static_cast<Store*>(expression)->isAtomic; } uint32_t BinaryenStoreGetBytes(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenStoreGetBytes(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<Store>()); return static_cast<Store*>(expression)->bytes; } uint32_t BinaryenStoreGetOffset(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenStoreGetOffset(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<Store>()); return static_cast<Store*>(expression)->offset; } uint32_t BinaryenStoreGetAlign(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenStoreGetAlign(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<Store>()); return static_cast<Store*>(expression)->align; } BinaryenExpressionRef BinaryenStoreGetPtr(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenStoreGetPtr(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<Store>()); return static_cast<Store*>(expression)->ptr; } BinaryenExpressionRef BinaryenStoreGetValue(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenStoreGetValue(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<Store>()); return static_cast<Store*>(expression)->value; } // Const int32_t BinaryenConstGetValueI32(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenConstGetValueI32(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<Const>()); return static_cast<Const*>(expression)->value.geti32(); } int64_t BinaryenConstGetValueI64(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenConstGetValueI64(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<Const>()); return static_cast<Const*>(expression)->value.geti64(); } int32_t BinaryenConstGetValueI64Low(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenConstGetValueI64Low(expressions[" - << expressions[expr] << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<Const>()); return (int32_t)(static_cast<Const*>(expression)->value.geti64() & 0xffffffff); } int32_t BinaryenConstGetValueI64High(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenConstGetValueI64High(expressions[" - << expressions[expr] << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<Const>()); return (int32_t)(static_cast<Const*>(expression)->value.geti64() >> 32); } float BinaryenConstGetValueF32(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenConstGetValueF32(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<Const>()); return static_cast<Const*>(expression)->value.getf32(); } double BinaryenConstGetValueF64(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenConstGetValueF64(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<Const>()); return static_cast<Const*>(expression)->value.getf64(); } void BinaryenConstGetValueV128(BinaryenExpressionRef expr, uint8_t* out) { - if (tracing) { - std::cout << " BinaryenConstGetValueV128(expressions[" << expressions[expr] - << "], " << out << ");\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<Const>()); memcpy(out, static_cast<Const*>(expression)->value.getv128().data(), 16); } // Unary BinaryenOp BinaryenUnaryGetOp(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenUnaryGetOp(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<Unary>()); return static_cast<Unary*>(expression)->op; } BinaryenExpressionRef BinaryenUnaryGetValue(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenUnaryGetValue(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<Unary>()); return static_cast<Unary*>(expression)->value; } // Binary BinaryenOp BinaryenBinaryGetOp(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenBinaryGetOp(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<Binary>()); return static_cast<Binary*>(expression)->op; } BinaryenExpressionRef BinaryenBinaryGetLeft(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenBinaryGetLeft(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<Binary>()); return static_cast<Binary*>(expression)->left; } BinaryenExpressionRef BinaryenBinaryGetRight(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenBinaryGetRight(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<Binary>()); return static_cast<Binary*>(expression)->right; } // Select BinaryenExpressionRef BinaryenSelectGetIfTrue(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenSelectGetIfTrue(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<Select>()); return static_cast<Select*>(expression)->ifTrue; } BinaryenExpressionRef BinaryenSelectGetIfFalse(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenSelectGetIfFalse(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<Select>()); return static_cast<Select*>(expression)->ifFalse; } BinaryenExpressionRef BinaryenSelectGetCondition(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenSelectGetCondition(expressions[" - << expressions[expr] << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<Select>()); return static_cast<Select*>(expression)->condition; } // Drop BinaryenExpressionRef BinaryenDropGetValue(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenDropGetValue(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<Drop>()); return static_cast<Drop*>(expression)->value; } // Return BinaryenExpressionRef BinaryenReturnGetValue(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenReturnGetValue(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<Return>()); return static_cast<Return*>(expression)->value; } // AtomicRMW BinaryenOp BinaryenAtomicRMWGetOp(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenAtomicRMWGetOp(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<AtomicRMW>()); return static_cast<AtomicRMW*>(expression)->op; } uint32_t BinaryenAtomicRMWGetBytes(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenAtomicRMWGetBytes(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<AtomicRMW>()); return static_cast<AtomicRMW*>(expression)->bytes; } uint32_t BinaryenAtomicRMWGetOffset(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenAtomicRMWGetOffset(expressions[" - << expressions[expr] << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<AtomicRMW>()); return static_cast<AtomicRMW*>(expression)->offset; } BinaryenExpressionRef BinaryenAtomicRMWGetPtr(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenAtomicRMWGetPtr(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<AtomicRMW>()); return static_cast<AtomicRMW*>(expression)->ptr; } BinaryenExpressionRef BinaryenAtomicRMWGetValue(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenAtomicRMWGetValue(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<AtomicRMW>()); return static_cast<AtomicRMW*>(expression)->value; } // AtomicCmpxchg uint32_t BinaryenAtomicCmpxchgGetBytes(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenAtomicCmpxchgGetBytes(expressions[" - << expressions[expr] << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<AtomicCmpxchg>()); return static_cast<AtomicCmpxchg*>(expression)->bytes; } uint32_t BinaryenAtomicCmpxchgGetOffset(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenAtomicCmpxchgGetOffset(expressions[" - << expressions[expr] << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<AtomicCmpxchg>()); return static_cast<AtomicCmpxchg*>(expression)->offset; } BinaryenExpressionRef BinaryenAtomicCmpxchgGetPtr(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenAtomicCmpxchgGetPtr(expressions[" - << expressions[expr] << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<AtomicCmpxchg>()); return static_cast<AtomicCmpxchg*>(expression)->ptr; } BinaryenExpressionRef BinaryenAtomicCmpxchgGetExpected(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenAtomicCmpxchgGetExpected(expressions[" - << expressions[expr] << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<AtomicCmpxchg>()); return static_cast<AtomicCmpxchg*>(expression)->expected; } BinaryenExpressionRef BinaryenAtomicCmpxchgGetReplacement(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenAtomicCmpxchgGetReplacement(expressions[" - << expressions[expr] << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<AtomicCmpxchg>()); return static_cast<AtomicCmpxchg*>(expression)->replacement; } // AtomicWait BinaryenExpressionRef BinaryenAtomicWaitGetPtr(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenAtomicWaitGetPtr(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<AtomicWait>()); return static_cast<AtomicWait*>(expression)->ptr; } BinaryenExpressionRef BinaryenAtomicWaitGetExpected(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenAtomicWaitGetExpected(expressions[" - << expressions[expr] << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<AtomicWait>()); return static_cast<AtomicWait*>(expression)->expected; } BinaryenExpressionRef BinaryenAtomicWaitGetTimeout(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenAtomicWaitGetTimeout(expressions[" - << expressions[expr] << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<AtomicWait>()); return static_cast<AtomicWait*>(expression)->timeout; } BinaryenType BinaryenAtomicWaitGetExpectedType(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenAtomicWaitGetExpectedType(expressions[" - << expressions[expr] << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<AtomicWait>()); return static_cast<AtomicWait*>(expression)->expectedType.getID(); } // AtomicNotify BinaryenExpressionRef BinaryenAtomicNotifyGetPtr(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenAtomicNotifyGetPtr(expressions[" - << expressions[expr] << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<AtomicNotify>()); return static_cast<AtomicNotify*>(expression)->ptr; } BinaryenExpressionRef BinaryenAtomicNotifyGetNotifyCount(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenAtomicNotifyGetNotifyCount(expressions[" - << expressions[expr] << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<AtomicNotify>()); return static_cast<AtomicNotify*>(expression)->notifyCount; } // AtomicFence uint8_t BinaryenAtomicFenceGetOrder(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenAtomicFenceGetOrder(expressions[" - << expressions[expr] << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<AtomicFence>()); return static_cast<AtomicFence*>(expression)->order; } // SIMDExtract BinaryenOp BinaryenSIMDExtractGetOp(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenSIMDExtractGetOp(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<SIMDExtract>()); return static_cast<SIMDExtract*>(expression)->op; } BinaryenExpressionRef BinaryenSIMDExtractGetVec(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenSIMDExtractGetVec(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<SIMDExtract>()); return static_cast<SIMDExtract*>(expression)->vec; } uint8_t BinaryenSIMDExtractGetIndex(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenSIMDExtractGetIndex(expressions[" - << expressions[expr] << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<SIMDExtract>()); return static_cast<SIMDExtract*>(expression)->index; } // SIMDReplace BinaryenOp BinaryenSIMDReplaceGetOp(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenSIMDReplaceGetOp(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<SIMDReplace>()); return static_cast<SIMDReplace*>(expression)->op; } BinaryenExpressionRef BinaryenSIMDReplaceGetVec(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenSIMDReplaceGetVec(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<SIMDReplace>()); return static_cast<SIMDReplace*>(expression)->vec; } uint8_t BinaryenSIMDReplaceGetIndex(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenSIMDReplaceGetIndex(expressions[" - << expressions[expr] << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<SIMDReplace>()); return static_cast<SIMDReplace*>(expression)->index; } BinaryenExpressionRef BinaryenSIMDReplaceGetValue(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenSIMDReplaceGetValue(expressions[" - << expressions[expr] << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<SIMDReplace>()); return static_cast<SIMDReplace*>(expression)->value; } // SIMDShuffle BinaryenExpressionRef BinaryenSIMDShuffleGetLeft(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenSIMDShuffleGetLeft(expressions[" - << expressions[expr] << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<SIMDShuffle>()); return static_cast<SIMDShuffle*>(expression)->left; } BinaryenExpressionRef BinaryenSIMDShuffleGetRight(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenSIMDShuffleGetRight(expressions[" - << expressions[expr] << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<SIMDShuffle>()); return static_cast<SIMDShuffle*>(expression)->right; } void BinaryenSIMDShuffleGetMask(BinaryenExpressionRef expr, uint8_t* mask) { - if (tracing) { - std::cout << " BinaryenSIMDShuffleGetMask(expressions[" - << expressions[expr] << "], " << mask << ");\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<SIMDShuffle>()); memcpy(mask, static_cast<SIMDShuffle*>(expression)->mask.data(), 16); } // SIMDTernary BinaryenOp BinaryenSIMDTernaryGetOp(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenSIMDTernaryOp(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<SIMDTernary>()); return static_cast<SIMDTernary*>(expression)->op; } BinaryenExpressionRef BinaryenSIMDTernaryGetA(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenSIMDTernaryGetA(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<SIMDTernary>()); return static_cast<SIMDTernary*>(expression)->a; } BinaryenExpressionRef BinaryenSIMDTernaryGetB(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenSIMDTernaryGetB(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<SIMDTernary>()); return static_cast<SIMDTernary*>(expression)->b; } BinaryenExpressionRef BinaryenSIMDTernaryGetC(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenSIMDTernaryGetC(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<SIMDTernary>()); return static_cast<SIMDTernary*>(expression)->c; } // SIMDShift BinaryenOp BinaryenSIMDShiftGetOp(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenSIMDShiftGetOp(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<SIMDShift>()); return static_cast<SIMDShift*>(expression)->op; } BinaryenExpressionRef BinaryenSIMDShiftGetVec(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenSIMDShiftGetVec(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<SIMDShift>()); return static_cast<SIMDShift*>(expression)->vec; } BinaryenExpressionRef BinaryenSIMDShiftGetShift(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenSIMDShiftGetShift(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<SIMDShift>()); return static_cast<SIMDShift*>(expression)->shift; } // SIMDLoad BinaryenOp BinaryenSIMDLoadGetOp(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenSIMDLoadGetOp(expressions[" << expressions[expr] - << "])\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<SIMDLoad>()); return static_cast<SIMDLoad*>(expression)->op; } uint32_t BinaryenSIMDLoadGetOffset(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenSIMDLoadGetOffset(expressions[" << expressions[expr] - << "])\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<SIMDLoad>()); return static_cast<SIMDLoad*>(expression)->offset; } uint32_t BinaryenSIMDLoadGetAlign(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenSIMDLoadGetAlign(expressions[" << expressions[expr] - << "])\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<SIMDLoad>()); return static_cast<SIMDLoad*>(expression)->align; } BinaryenExpressionRef BinaryenSIMDLoadGetPtr(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenSIMDLoadGetPtr(expressions[" << expressions[expr] - << "])\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<SIMDLoad>()); return static_cast<SIMDLoad*>(expression)->ptr; } // MemoryInit uint32_t BinaryenMemoryInitGetSegment(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenMemoryInitGetSegment(expressions[" - << expressions[expr] << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<MemoryInit>()); return static_cast<MemoryInit*>(expression)->segment; } BinaryenExpressionRef BinaryenMemoryInitGetDest(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenMemoryInitGetDest(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<MemoryInit>()); return static_cast<MemoryInit*>(expression)->dest; } BinaryenExpressionRef BinaryenMemoryInitGetOffset(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenMemoryInitGetOffset(expressions[" - << expressions[expr] << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<MemoryInit>()); return static_cast<MemoryInit*>(expression)->offset; } BinaryenExpressionRef BinaryenMemoryInitGetSize(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenMemoryInitGetSize(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<MemoryInit>()); return static_cast<MemoryInit*>(expression)->size; } // DataDrop uint32_t BinaryenDataDropGetSegment(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenDataDropGetSegment(expressions[" - << expressions[expr] << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<DataDrop>()); return static_cast<DataDrop*>(expression)->segment; } // MemoryCopy BinaryenExpressionRef BinaryenMemoryCopyGetDest(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenMemoryCopyGetDest(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<MemoryCopy>()); return static_cast<MemoryCopy*>(expression)->dest; } BinaryenExpressionRef BinaryenMemoryCopyGetSource(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenMemoryCopyGetSource(expressions[" - << expressions[expr] << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<MemoryCopy>()); return static_cast<MemoryCopy*>(expression)->source; } BinaryenExpressionRef BinaryenMemoryCopyGetSize(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenMemoryCopyGetSize(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<MemoryCopy>()); return static_cast<MemoryCopy*>(expression)->size; } // MemoryFill BinaryenExpressionRef BinaryenMemoryFillGetDest(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenMemoryFillGetDest(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<MemoryFill>()); return static_cast<MemoryFill*>(expression)->dest; } BinaryenExpressionRef BinaryenMemoryFillGetValue(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenMemoryFillGetValue(expressions[" - << expressions[expr] << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<MemoryFill>()); return static_cast<MemoryFill*>(expression)->value; } BinaryenExpressionRef BinaryenMemoryFillGetSize(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenMemoryFillGetSize(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<MemoryFill>()); return static_cast<MemoryFill*>(expression)->size; } // RefIsNull BinaryenExpressionRef BinaryenRefIsNullGetValue(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenRefIsNullGetValue(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<RefIsNull>()); return static_cast<RefIsNull*>(expression)->value; } // RefFunc const char* BinaryenRefFuncGetFunc(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenRefFuncGetFunc(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<RefFunc>()); return static_cast<RefFunc*>(expression)->func.c_str(); } // Try BinaryenExpressionRef BinaryenTryGetBody(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenTryGetBody(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<Try>()); return static_cast<Try*>(expression)->body; } BinaryenExpressionRef BinaryenTryGetCatchBody(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenTryGetCatchBody(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<Try>()); return static_cast<Try*>(expression)->catchBody; } // Throw const char* BinaryenThrowGetEvent(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenThrowGetEvent(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<Throw>()); return static_cast<Throw*>(expression)->event.c_str(); } BinaryenExpressionRef BinaryenThrowGetOperand(BinaryenExpressionRef expr, BinaryenIndex index) { - if (tracing) { - std::cout << " BinaryenThrowGetOperand(expressions[" << expressions[expr] - << "], " << index << ");\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<Throw>()); assert(index < static_cast<Throw*>(expression)->operands.size()); return static_cast<Throw*>(expression)->operands[index]; } BinaryenIndex BinaryenThrowGetNumOperands(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenThrowGetNumOperands(expressions[" - << expressions[expr] << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<Throw>()); return static_cast<Throw*>(expression)->operands.size(); } // Rethrow BinaryenExpressionRef BinaryenRethrowGetExnref(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenRethrowGetExnref(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<Rethrow>()); return static_cast<Rethrow*>(expression)->exnref; } // BrOnExn const char* BinaryenBrOnExnGetEvent(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenBrOnExnGetEvent(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<BrOnExn>()); return static_cast<BrOnExn*>(expression)->event.c_str(); } const char* BinaryenBrOnExnGetName(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenBrOnExnGetName(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<BrOnExn>()); return static_cast<BrOnExn*>(expression)->name.c_str(); } BinaryenExpressionRef BinaryenBrOnExnGetExnref(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenBrOnExnGetExnref(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<BrOnExn>()); return static_cast<BrOnExn*>(expression)->exnref; } // TupleMake BinaryenIndex BinaryenTupleMakeGetNumOperands(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenTupleMakeGetNumOperands(expressions[" - << expressions[expr] << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<TupleMake>()); return static_cast<TupleMake*>(expression)->operands.size(); } BinaryenExpressionRef BinaryenTupleMakeGetOperand(BinaryenExpressionRef expr, BinaryenIndex index) { - if (tracing) { - std::cout << " BinaryenTupleMakeGetOperand(expressions[" - << expressions[expr] << "], " << index << ");\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<TupleMake>()); return static_cast<TupleMake*>(expression)->operands[index]; } // TupleExtract BinaryenExpressionRef BinaryenTupleExtractGetTuple(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenTupleExtractGetTuple(expressions[" - << expressions[expr] << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<TupleExtract>()); return static_cast<TupleExtract*>(expression)->tuple; } BinaryenIndex BinaryenTupleExtractGetIndex(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenTupleExtractGetIndex(expressions[" - << expressions[expr] << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<TupleExtract>()); return static_cast<TupleExtract*>(expression)->index; } // Push BinaryenExpressionRef BinaryenPushGetValue(BinaryenExpressionRef expr) { - if (tracing) { - std::cout << " BinaryenPushGetValue(expressions[" << expressions[expr] - << "]);\n"; - } - auto* expression = (Expression*)expr; assert(expression->is<Push>()); return static_cast<Push*>(expression)->value; @@ -3327,33 +2039,7 @@ BinaryenFunctionRef BinaryenAddFunction(BinaryenModuleRef module, BinaryenType* varTypes, BinaryenIndex numVarTypes, BinaryenExpressionRef body) { - auto* wasm = (Module*)module; auto* ret = new Function; - - if (tracing) { - std::cout << " {\n"; - std::cout << " BinaryenType varTypes[] = { "; - for (BinaryenIndex i = 0; i < numVarTypes; i++) { - if (i > 0) { - std::cout << ", "; - } - std::cout << TypeArg(varTypes[i]); - } - if (numVarTypes == 0) { - // ensure the array is not empty, otherwise a compiler error on VS - std::cout << "0"; - } - std::cout << " };\n"; - auto id = functions.size(); - functions[ret] = id; - std::cout << " functions[" << id - << "] = BinaryenAddFunction(the_module, \"" << name << "\", " - << TypeArg(params) << ", " << TypeArg(results) << ", varTypes, " - << numVarTypes << ", expressions[" << expressions[body] - << "]);\n"; - std::cout << " }\n"; - } - ret->name = name; ret->sig = Signature(Type(params), Type(results)); for (BinaryenIndex i = 0; i < numVarTypes; i++) { @@ -3365,47 +2051,28 @@ BinaryenFunctionRef BinaryenAddFunction(BinaryenModuleRef module, // point where they all access and modify the module. { std::lock_guard<std::mutex> lock(BinaryenFunctionMutex); - wasm->addFunction(ret); + ((Module*)module)->addFunction(ret); } return ret; } BinaryenFunctionRef BinaryenGetFunction(BinaryenModuleRef module, const char* name) { - if (tracing) { - std::cout << " BinaryenGetFunction(the_module, \"" << name << "\");\n"; - } - - auto* wasm = (Module*)module; - return wasm->getFunction(name); + return ((Module*)module)->getFunction(name); } void BinaryenRemoveFunction(BinaryenModuleRef module, const char* name) { - if (tracing) { - std::cout << " BinaryenRemoveFunction(the_module, \"" << name << "\");\n"; - } - - auto* wasm = (Module*)module; - wasm->removeFunction(name); + ((Module*)module)->removeFunction(name); } uint32_t BinaryenGetNumFunctions(BinaryenModuleRef module) { - if (tracing) { - std::cout << " BinaryenGetNumFunctions(the_module);\n"; - } - - auto* wasm = (Module*)module; - return wasm->functions.size(); + return ((Module*)module)->functions.size(); } BinaryenFunctionRef BinaryenGetFunctionByIndex(BinaryenModuleRef module, BinaryenIndex id) { - if (tracing) { - std::cout << " BinaryenGetFunctionByIndex(the_module, " << id << ");\n"; - } - - auto* wasm = (Module*)module; - if (wasm->functions.size() <= id) { + const auto& functions = ((Module*)module)->functions; + if (functions.size() <= id) { Fatal() << "invalid function id."; } - return wasm->functions[id].get(); + return functions[id].get(); } // Globals @@ -3415,40 +2082,20 @@ BinaryenGlobalRef BinaryenAddGlobal(BinaryenModuleRef module, BinaryenType type, int8_t mutable_, BinaryenExpressionRef init) { - auto* wasm = (Module*)module; auto* ret = new Global(); - - if (tracing) { - auto id = globals.size(); - globals[ret] = id; - std::cout << " globals[" << id << "] = BinaryenAddGlobal(the_module, \"" - << name << "\", " << TypeArg(type) << ", " << int(mutable_) - << ", expressions[" << expressions[init] << "]);\n"; - } - ret->name = name; ret->type = Type(type); ret->mutable_ = !!mutable_; ret->init = (Expression*)init; - wasm->addGlobal(ret); + ((Module*)module)->addGlobal(ret); return ret; } BinaryenGlobalRef BinaryenGetGlobal(BinaryenModuleRef module, const char* name) { - if (tracing) { - std::cout << " BinaryenGetGlobal(the_module, \"" << name << "\");\n"; - } - - auto* wasm = (Module*)module; - return wasm->getGlobal(name); + return ((Module*)module)->getGlobal(name); } void BinaryenRemoveGlobal(BinaryenModuleRef module, const char* name) { - if (tracing) { - std::cout << " BinaryenRemoveGlobal(the_module, \"" << name << "\");\n"; - } - - auto* wasm = (Module*)module; - wasm->removeGlobal(name); + ((Module*)module)->removeGlobal(name); } // Events @@ -3458,36 +2105,19 @@ BinaryenEventRef BinaryenAddEvent(BinaryenModuleRef module, uint32_t attribute, BinaryenType params, BinaryenType results) { - if (tracing) { - std::cout << " BinaryenAddEvent(the_module, \"" << name << "\", " - << attribute << ", " << TypeArg(params) << ", " - << TypeArg(results) << ");\n"; - } - - auto* wasm = (Module*)module; auto* ret = new Event(); ret->name = name; ret->attribute = attribute; ret->sig = Signature(Type(params), Type(results)); - wasm->addEvent(ret); + ((Module*)module)->addEvent(ret); return ret; } BinaryenEventRef BinaryenGetEvent(BinaryenModuleRef module, const char* name) { - if (tracing) { - std::cout << " BinaryenGetEvent(the_module, \"" << name << "\");\n"; - } - - auto* wasm = (Module*)module; - return wasm->getEvent(name); + return ((Module*)module)->getEvent(name); } void BinaryenRemoveEvent(BinaryenModuleRef module, const char* name) { - if (tracing) { - std::cout << " BinaryenRemoveEvent(the_module, \"" << name << "\");\n"; - } - - auto* wasm = (Module*)module; - wasm->removeEvent(name); + ((Module*)module)->removeEvent(name); } // Imports @@ -3498,53 +2128,30 @@ void BinaryenAddFunctionImport(BinaryenModuleRef module, const char* externalBaseName, BinaryenType params, BinaryenType results) { - auto* wasm = (Module*)module; auto* ret = new Function(); - - if (tracing) { - std::cout << " BinaryenAddFunctionImport(the_module, \"" << internalName - << "\", \"" << externalModuleName << "\", \"" << externalBaseName - << "\", " << TypeArg(params) << ", " << TypeArg(results) - << ");\n"; - } - ret->name = internalName; ret->module = externalModuleName; ret->base = externalBaseName; ret->sig = Signature(Type(params), Type(results)); - wasm->addFunction(ret); + ((Module*)module)->addFunction(ret); } void BinaryenAddTableImport(BinaryenModuleRef module, const char* internalName, const char* externalModuleName, const char* externalBaseName) { - auto* wasm = (Module*)module; - - if (tracing) { - std::cout << " BinaryenAddTableImport(the_module, \"" << internalName - << "\", \"" << externalModuleName << "\", \"" << externalBaseName - << "\");\n"; - } - - wasm->table.module = externalModuleName; - wasm->table.base = externalBaseName; + auto& table = ((Module*)module)->table; + table.module = externalModuleName; + table.base = externalBaseName; } void BinaryenAddMemoryImport(BinaryenModuleRef module, const char* internalName, const char* externalModuleName, const char* externalBaseName, uint8_t shared) { - auto* wasm = (Module*)module; - - if (tracing) { - std::cout << " BinaryenAddMemoryImport(the_module, \"" << internalName - << "\", \"" << externalModuleName << "\", \"" << externalBaseName - << "\", " << int(shared) << ");\n"; - } - - wasm->memory.module = externalModuleName; - wasm->memory.base = externalBaseName; - wasm->memory.shared = shared; + auto& memory = ((Module*)module)->memory; + memory.module = externalModuleName; + memory.base = externalBaseName; + memory.shared = shared; } void BinaryenAddGlobalImport(BinaryenModuleRef module, const char* internalName, @@ -3552,21 +2159,13 @@ void BinaryenAddGlobalImport(BinaryenModuleRef module, const char* externalBaseName, BinaryenType globalType, int mutable_) { - auto* wasm = (Module*)module; auto* ret = new Global(); - - if (tracing) { - std::cout << " BinaryenAddGlobalImport(the_module, \"" << internalName - << "\", \"" << externalModuleName << "\", \"" << externalBaseName - << "\", " << TypeArg(globalType) << ", " << mutable_ << ");\n"; - } - ret->name = internalName; ret->module = externalModuleName; ret->base = externalBaseName; ret->type = Type(globalType); ret->mutable_ = mutable_ != 0; - wasm->addGlobal(ret); + ((Module*)module)->addGlobal(ret); } void BinaryenAddEventImport(BinaryenModuleRef module, const char* internalName, @@ -3575,21 +2174,12 @@ void BinaryenAddEventImport(BinaryenModuleRef module, uint32_t attribute, BinaryenType params, BinaryenType results) { - auto* wasm = (Module*)module; auto* ret = new Event(); - - if (tracing) { - std::cout << " BinaryenAddEventImport(the_module, \"" << internalName - << "\", \"" << externalModuleName << "\", \"" << externalBaseName - << "\", " << attribute << ", " << TypeArg(params) << ", " - << TypeArg(results) << ");\n"; - } - ret->name = internalName; ret->module = externalModuleName; ret->base = externalBaseName; ret->sig = Signature(Type(params), Type(results)); - wasm->addEvent(ret); + ((Module*)module)->addEvent(ret); } // Exports @@ -3602,111 +2192,55 @@ WASM_DEPRECATED BinaryenExportRef BinaryenAddExport(BinaryenModuleRef module, BinaryenExportRef BinaryenAddFunctionExport(BinaryenModuleRef module, const char* internalName, const char* externalName) { - auto* wasm = (Module*)module; auto* ret = new Export(); - - if (tracing) { - auto id = exports.size(); - exports[ret] = id; - std::cout << " exports[" << id - << "] = BinaryenAddFunctionExport(the_module, \"" << internalName - << "\", \"" << externalName << "\");\n"; - } - ret->value = internalName; ret->name = externalName; ret->kind = ExternalKind::Function; - wasm->addExport(ret); + ((Module*)module)->addExport(ret); return ret; } BinaryenExportRef BinaryenAddTableExport(BinaryenModuleRef module, const char* internalName, const char* externalName) { - auto* wasm = (Module*)module; auto* ret = new Export(); - - if (tracing) { - auto id = exports.size(); - exports[ret] = id; - std::cout << " exports[" << id - << "] = BinaryenAddTableExport(the_module, \"" << internalName - << "\", \"" << externalName << "\");\n"; - } - ret->value = internalName; ret->name = externalName; ret->kind = ExternalKind::Table; - wasm->addExport(ret); + ((Module*)module)->addExport(ret); return ret; } BinaryenExportRef BinaryenAddMemoryExport(BinaryenModuleRef module, const char* internalName, const char* externalName) { - auto* wasm = (Module*)module; auto* ret = new Export(); - - if (tracing) { - auto id = exports.size(); - exports[ret] = id; - std::cout << " exports[" << id - << "] = BinaryenAddMemoryExport(the_module, \"" << internalName - << "\", \"" << externalName << "\");\n"; - } - ret->value = internalName; ret->name = externalName; ret->kind = ExternalKind::Memory; - wasm->addExport(ret); + ((Module*)module)->addExport(ret); return ret; } BinaryenExportRef BinaryenAddGlobalExport(BinaryenModuleRef module, const char* internalName, const char* externalName) { - auto* wasm = (Module*)module; auto* ret = new Export(); - - if (tracing) { - auto id = exports.size(); - exports[ret] = id; - std::cout << " exports[" << id - << "] = BinaryenAddGlobalExport(the_module, \"" << internalName - << "\", \"" << externalName << "\");\n"; - } - ret->value = internalName; ret->name = externalName; ret->kind = ExternalKind::Global; - wasm->addExport(ret); + ((Module*)module)->addExport(ret); return ret; } BinaryenExportRef BinaryenAddEventExport(BinaryenModuleRef module, const char* internalName, const char* externalName) { - auto* wasm = (Module*)module; auto* ret = new Export(); - - if (tracing) { - auto id = exports.size(); - exports[ret] = id; - std::cout << " exports[" << id - << "] = BinaryenAddEventExport(the_module, \"" << internalName - << "\", \"" << externalName << "\");\n"; - } - ret->value = internalName; ret->name = externalName; ret->kind = ExternalKind::Event; - wasm->addExport(ret); + ((Module*)module)->addExport(ret); return ret; } void BinaryenRemoveExport(BinaryenModuleRef module, const char* externalName) { - if (tracing) { - std::cout << " BinaryenRemoveExport(the_module, \"" << externalName - << "\");\n"; - } - - auto* wasm = (Module*)module; - wasm->removeExport(externalName); + ((Module*)module)->removeExport(externalName); } // Function table. One per module @@ -3717,90 +2251,49 @@ void BinaryenSetFunctionTable(BinaryenModuleRef module, const char** funcNames, BinaryenIndex numFuncNames, BinaryenExpressionRef offset) { - if (tracing) { - std::cout << " {\n"; - std::cout << " const char* funcNames[] = { "; - for (BinaryenIndex i = 0; i < numFuncNames; i++) { - if (i > 0) { - std::cout << ", "; - } - std::cout << "\"" << funcNames[i] << "\""; - } - std::cout << " };\n"; - std::cout << " BinaryenSetFunctionTable(the_module, " << initial << ", " - << maximum << ", funcNames, " << numFuncNames << ", expressions[" - << expressions[offset] << "]);\n"; - std::cout << " }\n"; - } - - auto* wasm = (Module*)module; Table::Segment segment((Expression*)offset); for (BinaryenIndex i = 0; i < numFuncNames; i++) { segment.data.push_back(funcNames[i]); } - wasm->table.initial = initial; - wasm->table.max = maximum; - wasm->table.exists = true; - wasm->table.segments.push_back(segment); + auto& table = ((Module*)module)->table; + table.initial = initial; + table.max = maximum; + table.exists = true; + table.segments.push_back(segment); } int BinaryenIsFunctionTableImported(BinaryenModuleRef module) { - if (tracing) { - std::cout << " BinaryenIsFunctionTableImported(the_module);\n"; - } - - auto* wasm = (Module*)module; - return wasm->table.imported(); + return ((Module*)module)->table.imported(); } BinaryenIndex BinaryenGetNumFunctionTableSegments(BinaryenModuleRef module) { - if (tracing) { - std::cout << " BinaryenGetNumFunctionTableSegments(the_module);\n"; - } - - auto* wasm = (Module*)module; - return wasm->table.segments.size(); + return ((Module*)module)->table.segments.size(); } BinaryenExpressionRef BinaryenGetFunctionTableSegmentOffset(BinaryenModuleRef module, BinaryenIndex segmentId) { - if (tracing) { - std::cout << " BinaryenGetFunctionTableSegmentOffset(the_module, " - << segmentId << ");\n"; - } - - auto* wasm = (Module*)module; - if (wasm->table.segments.size() <= segmentId) { + const auto& segments = ((Module*)module)->table.segments; + if (segments.size() <= segmentId) { Fatal() << "invalid function table segment id."; } - return wasm->table.segments[segmentId].offset; + return segments[segmentId].offset; } BinaryenIndex BinaryenGetFunctionTableSegmentLength(BinaryenModuleRef module, BinaryenIndex segmentId) { - if (tracing) { - std::cout << " BinaryenGetFunctionTableSegmentLength(the_module, " - << segmentId << ");\n"; - } - - auto* wasm = (Module*)module; - if (wasm->table.segments.size() <= segmentId) { + const auto& segments = ((Module*)module)->table.segments; + if (segments.size() <= segmentId) { Fatal() << "invalid function table segment id."; } - return wasm->table.segments[segmentId].data.size(); + return segments[segmentId].data.size(); } const char* BinaryenGetFunctionTableSegmentData(BinaryenModuleRef module, BinaryenIndex segmentId, BinaryenIndex dataId) { - if (tracing) { - std::cout << " BinaryenGetFunctionTableSegmentData(the_module, " - << segmentId << ", " << dataId << ");\n"; - } - - auto* wasm = (Module*)module; - if (wasm->table.segments.size() <= segmentId || - wasm->table.segments[segmentId].data.size() <= dataId) { + const auto& segments = ((Module*)module)->table.segments; + if (segments.size() <= segmentId || + segments[segmentId].data.size() <= dataId) { Fatal() << "invalid function table segment or data id."; } - return wasm->table.segments[segmentId].data[dataId].c_str(); + return segments[segmentId].data[dataId].c_str(); } // Memory. One per module @@ -3815,74 +2308,6 @@ void BinaryenSetMemory(BinaryenModuleRef module, BinaryenIndex* segmentSizes, BinaryenIndex numSegments, uint8_t shared) { - if (tracing) { - std::cout << " {\n"; - for (BinaryenIndex i = 0; i < numSegments; i++) { - std::cout << " const char segment" << i << "[] = { "; - for (BinaryenIndex j = 0; j < segmentSizes[i]; j++) { - if (j > 0) { - std::cout << ", "; - } - std::cout << int(segments[i][j]); - } - std::cout << " };\n"; - } - std::cout << " const char* segments[] = { "; - for (BinaryenIndex i = 0; i < numSegments; i++) { - if (i > 0) { - std::cout << ", "; - } - std::cout << "segment" << i; - } - if (numSegments == 0) { - // ensure the array is not empty, otherwise a compiler error on VS - std::cout << "0"; - } - std::cout << " };\n"; - std::cout << " int8_t segmentPassive[] = { "; - for (BinaryenIndex i = 0; i < numSegments; i++) { - if (i > 0) { - std::cout << ", "; - } - std::cout << int(segmentPassive[i]); - } - if (numSegments == 0) { - // ensure the array is not empty, otherwise a compiler error on VS - std::cout << "0"; - } - std::cout << " };\n"; - std::cout << " BinaryenExpressionRef segmentOffsets[] = { "; - for (BinaryenIndex i = 0; i < numSegments; i++) { - if (i > 0) { - std::cout << ", "; - } - std::cout << "expressions[" << expressions[segmentOffsets[i]] << "]"; - } - if (numSegments == 0) { - // ensure the array is not empty, otherwise a compiler error on VS - std::cout << "0"; - } - std::cout << " };\n"; - std::cout << " BinaryenIndex segmentSizes[] = { "; - for (BinaryenIndex i = 0; i < numSegments; i++) { - if (i > 0) { - std::cout << ", "; - } - std::cout << segmentSizes[i]; - } - if (numSegments == 0) { - // ensure the array is not empty, otherwise a compiler error on VS - std::cout << "0"; - } - std::cout << " };\n"; - std::cout << " BinaryenSetMemory(the_module, " << initial << ", " - << maximum << ", "; - traceNameOrNULL(exportName); - std::cout << ", segments, segmentPassive, segmentOffsets, segmentSizes, " - << numSegments << ", " << int(shared) << ");\n"; - std::cout << " }\n"; - } - auto* wasm = (Module*)module; wasm->memory.initial = initial; wasm->memory.max = maximum; @@ -3906,20 +2331,10 @@ void BinaryenSetMemory(BinaryenModuleRef module, // Memory segments uint32_t BinaryenGetNumMemorySegments(BinaryenModuleRef module) { - if (tracing) { - std::cout << " BinaryenGetNumMemorySegments(the_module);\n"; - } - - auto* wasm = (Module*)module; - return wasm->memory.segments.size(); + return ((Module*)module)->memory.segments.size(); } uint32_t BinaryenGetMemorySegmentByteOffset(BinaryenModuleRef module, BinaryenIndex id) { - if (tracing) { - std::cout << " BinaryenGetMemorySegmentByteOffset(the_module, " << id - << ");\n"; - } - auto* wasm = (Module*)module; if (wasm->memory.segments.size() <= id) { Fatal() << "invalid segment id."; @@ -3934,7 +2349,7 @@ uint32_t BinaryenGetMemorySegmentByteOffset(BinaryenModuleRef module, return false; }; - const Memory::Segment& segment = wasm->memory.segments[id]; + const auto& segment = wasm->memory.segments[id]; int64_t ret; if (globalOffset(segment.offset, ret)) { @@ -3952,78 +2367,46 @@ uint32_t BinaryenGetMemorySegmentByteOffset(BinaryenModuleRef module, } size_t BinaryenGetMemorySegmentByteLength(BinaryenModuleRef module, BinaryenIndex id) { - if (tracing) { - std::cout << " BinaryenGetMemorySegmentByteLength(the_module, " << id - << ");\n"; - } - - auto* wasm = (Module*)module; - if (wasm->memory.segments.size() <= id) { + const auto& segments = ((Module*)module)->memory.segments; + if (segments.size() <= id) { Fatal() << "invalid segment id."; } - const Memory::Segment& segment = wasm->memory.segments[id]; - return segment.data.size(); + return segments[id].data.size(); } int BinaryenGetMemorySegmentPassive(BinaryenModuleRef module, BinaryenIndex id) { - if (tracing) { - std::cout << " BinaryenGetMemorySegmentPassive(the_module, " << id - << ");\n"; - } - - auto* wasm = (Module*)module; - if (wasm->memory.segments.size() <= id) { + const auto& segments = ((Module*)module)->memory.segments; + if (segments.size() <= id) { Fatal() << "invalid segment id."; } - const Memory::Segment& segment = wasm->memory.segments[id]; - return segment.isPassive; + return segments[id].isPassive; } void BinaryenCopyMemorySegmentData(BinaryenModuleRef module, BinaryenIndex id, char* buffer) { - if (tracing) { - std::cout << " BinaryenCopyMemorySegmentData(the_module, " << id << ", " - << static_cast<void*>(buffer) << ");\n"; - } - - auto* wasm = (Module*)module; - if (wasm->memory.segments.size() <= id) { + const auto& segments = ((Module*)module)->memory.segments; + if (segments.size() <= id) { Fatal() << "invalid segment id."; } - const Memory::Segment& segment = wasm->memory.segments[id]; + const auto& segment = segments[id]; std::copy(segment.data.cbegin(), segment.data.cend(), buffer); } // Start function. One per module void BinaryenSetStart(BinaryenModuleRef module, BinaryenFunctionRef start) { - if (tracing) { - std::cout << " BinaryenSetStart(the_module, functions[" << functions[start] - << "]);\n"; - } - - auto* wasm = (Module*)module; - wasm->addStart(((Function*)start)->name); + ((Module*)module)->addStart(((Function*)start)->name); } // Features BinaryenFeatures BinaryenModuleGetFeatures(BinaryenModuleRef module) { - if (tracing) { - std::cout << " BinaryenModuleGetFeatures(the_module);\n"; - } - auto* wasm = static_cast<Module*>(module); - return wasm->features.features; + return ((Module*)module)->features.features; } void BinaryenModuleSetFeatures(BinaryenModuleRef module, BinaryenFeatures features) { - if (tracing) { - std::cout << " BinaryenModuleSetFeatures(the_module, " << features - << ");\n"; - } - auto* wasm = static_cast<Module*>(module); - wasm->features.features = features; + ((Module*)module)->features.features = features; } // @@ -4031,10 +2414,6 @@ void BinaryenModuleSetFeatures(BinaryenModuleRef module, // BinaryenModuleRef BinaryenModuleParse(const char* text) { - if (tracing) { - std::cout << " // BinaryenModuleRead\n"; - } - auto* wasm = new Module; try { SExpressionParser parser(const_cast<char*>(text)); @@ -4048,19 +2427,11 @@ BinaryenModuleRef BinaryenModuleParse(const char* text) { } void BinaryenModulePrint(BinaryenModuleRef module) { - if (tracing) { - std::cout << " BinaryenModulePrint(the_module);\n"; - } - WasmPrinter::printModule((Module*)module); } void BinaryenModulePrintAsmjs(BinaryenModuleRef module) { - if (tracing) { - std::cout << " BinaryenModulePrintAsmjs(the_module);\n"; - } - - Module* wasm = (Module*)module; + auto* wasm = (Module*)module; Wasm2JSBuilder::Flags flags; Wasm2JSBuilder wasm2js(flags, globalPassOptions); Ref asmjs = wasm2js.processWasm(wasm); @@ -4074,99 +2445,43 @@ void BinaryenModulePrintAsmjs(BinaryenModuleRef module) { } int BinaryenModuleValidate(BinaryenModuleRef module) { - if (tracing) { - std::cout << " BinaryenModuleValidate(the_module);\n"; - } - - Module* wasm = (Module*)module; - return WasmValidator().validate(*wasm) ? 1 : 0; + return WasmValidator().validate(*(Module*)module) ? 1 : 0; } void BinaryenModuleOptimize(BinaryenModuleRef module) { - if (tracing) { - std::cout << " BinaryenModuleOptimize(the_module);\n"; - } - - Module* wasm = (Module*)module; - PassRunner passRunner(wasm); + PassRunner passRunner((Module*)module); passRunner.options = globalPassOptions; passRunner.addDefaultOptimizationPasses(); passRunner.run(); } -int BinaryenGetOptimizeLevel(void) { - if (tracing) { - std::cout << " BinaryenGetOptimizeLevel();\n"; - } - - return globalPassOptions.optimizeLevel; -} +int BinaryenGetOptimizeLevel(void) { return globalPassOptions.optimizeLevel; } void BinaryenSetOptimizeLevel(int level) { - if (tracing) { - std::cout << " BinaryenSetOptimizeLevel(" << level << ");\n"; - } - globalPassOptions.optimizeLevel = level; } -int BinaryenGetShrinkLevel(void) { - if (tracing) { - std::cout << " BinaryenGetShrinkLevel();\n"; - } - - return globalPassOptions.shrinkLevel; -} +int BinaryenGetShrinkLevel(void) { return globalPassOptions.shrinkLevel; } void BinaryenSetShrinkLevel(int level) { - if (tracing) { - std::cout << " BinaryenSetShrinkLevel(" << level << ");\n"; - } - globalPassOptions.shrinkLevel = level; } -int BinaryenGetDebugInfo(void) { - if (tracing) { - std::cout << " BinaryenGetDebugInfo();\n"; - } +int BinaryenGetDebugInfo(void) { return globalPassOptions.debugInfo; } - return globalPassOptions.debugInfo; -} - -void BinaryenSetDebugInfo(int on) { - if (tracing) { - std::cout << " BinaryenSetDebugInfo(" << on << ");\n"; - } - - globalPassOptions.debugInfo = on != 0; -} +void BinaryenSetDebugInfo(int on) { globalPassOptions.debugInfo = on != 0; } int BinaryenGetLowMemoryUnused(void) { - if (tracing) { - std::cout << " BinaryenGetLowMemoryUnused();\n"; - } - return globalPassOptions.lowMemoryUnused; } void BinaryenSetLowMemoryUnused(int on) { - if (tracing) { - std::cout << " BinaryenSetLowMemoryUnused(" << on << ");\n"; - } - globalPassOptions.lowMemoryUnused = on != 0; } const char* BinaryenGetPassArgument(const char* key) { - if (tracing) { - std::cout << " BinaryenGetPassArgument("; - traceNameOrNULL(key); - std::cout << ");\n"; - } - assert(key); - auto& args = globalPassOptions.arguments; + const auto& args = globalPassOptions.arguments; auto it = args.find(key); if (it == args.end()) { return nullptr; @@ -4176,14 +2491,6 @@ const char* BinaryenGetPassArgument(const char* key) { } void BinaryenSetPassArgument(const char* key, const char* value) { - if (tracing) { - std::cout << " BinaryenSetPassArgument("; - traceNameOrNULL(key); - std::cout << ", "; - traceNameOrNULL(value); - std::cout << ");\n"; - } - assert(key); if (value) { globalPassOptions.arguments[key] = value; @@ -4192,82 +2499,36 @@ void BinaryenSetPassArgument(const char* key, const char* value) { } } -void BinaryenClearPassArguments(void) { - if (tracing) { - std::cout << " BinaryenClearPassArguments();\n"; - } - - globalPassOptions.arguments.clear(); -} +void BinaryenClearPassArguments(void) { globalPassOptions.arguments.clear(); } BinaryenIndex BinaryenGetAlwaysInlineMaxSize(void) { - if (tracing) { - std::cout << " BinaryenGetAlwaysInlineMaxSize();\n"; - } - return globalPassOptions.inlining.alwaysInlineMaxSize; } void BinaryenSetAlwaysInlineMaxSize(BinaryenIndex size) { - if (tracing) { - std::cout << " BinaryenSetAlwaysInlineMaxSize(" << size << ");\n"; - } - globalPassOptions.inlining.alwaysInlineMaxSize = size; } BinaryenIndex BinaryenGetFlexibleInlineMaxSize(void) { - if (tracing) { - std::cout << " BinaryenGetFlexibleInlineMaxSize();\n"; - } - return globalPassOptions.inlining.flexibleInlineMaxSize; } void BinaryenSetFlexibleInlineMaxSize(BinaryenIndex size) { - if (tracing) { - std::cout << " BinaryenSetFlexibleInlineMaxSize(" << size << ");\n"; - } - globalPassOptions.inlining.flexibleInlineMaxSize = size; } BinaryenIndex BinaryenGetOneCallerInlineMaxSize(void) { - if (tracing) { - std::cout << " BinaryenGetOneCallerInlineMaxSize();\n"; - } - return globalPassOptions.inlining.oneCallerInlineMaxSize; } void BinaryenSetOneCallerInlineMaxSize(BinaryenIndex size) { - if (tracing) { - std::cout << " BinaryenSetOneCallerInlineMaxSize(" << size << ");\n"; - } - globalPassOptions.inlining.oneCallerInlineMaxSize = size; } void BinaryenModuleRunPasses(BinaryenModuleRef module, const char** passes, BinaryenIndex numPasses) { - if (tracing) { - std::cout << " {\n"; - std::cout << " const char* passes[] = { "; - for (BinaryenIndex i = 0; i < numPasses; i++) { - if (i > 0) { - std::cout << ", "; - } - std::cout << "\"" << passes[i] << "\""; - } - std::cout << " };\n"; - std::cout << " BinaryenModuleRunPasses(the_module, passes, " << numPasses - << ");\n"; - std::cout << " }\n"; - } - - Module* wasm = (Module*)module; - PassRunner passRunner(wasm); + PassRunner passRunner((Module*)module); passRunner.options = globalPassOptions; for (BinaryenIndex i = 0; i < numPasses; i++) { passRunner.add(passes[i]); @@ -4276,11 +2537,7 @@ void BinaryenModuleRunPasses(BinaryenModuleRef module, } void BinaryenModuleAutoDrop(BinaryenModuleRef module) { - if (tracing) { - std::cout << " BinaryenModuleAutoDrop(the_module);\n"; - } - - Module* wasm = (Module*)module; + auto* wasm = (Module*)module; PassRunner runner(wasm, globalPassOptions); AutoDrop().run(&runner, wasm); } @@ -4291,9 +2548,8 @@ static BinaryenBufferSizes writeModule(BinaryenModuleRef module, const char* sourceMapUrl, char* sourceMap, size_t sourceMapSize) { - Module* wasm = (Module*)module; BufferWithRandomAccess buffer; - WasmBinaryWriter writer(wasm, buffer); + WasmBinaryWriter writer((Module*)module, buffer); writer.setNamesSection(globalPassOptions.debugInfo); std::ostringstream os; if (sourceMapUrl) { @@ -4313,10 +2569,6 @@ static BinaryenBufferSizes writeModule(BinaryenModuleRef module, size_t BinaryenModuleWrite(BinaryenModuleRef module, char* output, size_t outputSize) { - if (tracing) { - std::cout << " // BinaryenModuleWrite\n"; - } - return writeModule((Module*)module, output, outputSize, nullptr, nullptr, 0) .outputBytes; } @@ -4324,11 +2576,6 @@ BinaryenModuleWrite(BinaryenModuleRef module, char* output, size_t outputSize) { size_t BinaryenModuleWriteText(BinaryenModuleRef module, char* output, size_t outputSize) { - - if (tracing) { - std::cout << " // BinaryenModuleWriteTextr\n"; - } - // use a stringstream as an std::ostream. Extract the std::string // representation, and then store in the output. std::stringstream ss; @@ -4347,10 +2594,6 @@ BinaryenBufferSizes BinaryenModuleWriteWithSourceMap(BinaryenModuleRef module, size_t outputSize, char* sourceMap, size_t sourceMapSize) { - if (tracing) { - std::cout << " // BinaryenModuleWriteWithSourceMap\n"; - } - assert(url); assert(sourceMap); return writeModule( @@ -4360,15 +2603,8 @@ BinaryenBufferSizes BinaryenModuleWriteWithSourceMap(BinaryenModuleRef module, BinaryenModuleAllocateAndWriteResult BinaryenModuleAllocateAndWrite(BinaryenModuleRef module, const char* sourceMapUrl) { - if (tracing) { - std::cout << " // BinaryenModuleAllocateAndWrite(the_module, "; - traceNameOrNULL(sourceMapUrl); - std::cout << ");\n"; - } - - Module* wasm = (Module*)module; BufferWithRandomAccess buffer; - WasmBinaryWriter writer(wasm, buffer); + WasmBinaryWriter writer((Module*)module, buffer); writer.setNamesSection(globalPassOptions.debugInfo); std::ostringstream os; if (sourceMapUrl) { @@ -4387,10 +2623,6 @@ BinaryenModuleAllocateAndWrite(BinaryenModuleRef module, } char* BinaryenModuleAllocateAndWriteText(BinaryenModuleRef module) { - if (tracing) { - std::cout << " // BinaryenModuleAllocateAndWriteText(the_module);"; - } - std::stringstream ss; WasmPrinter::printModule((Module*)module, ss); @@ -4402,10 +2634,6 @@ char* BinaryenModuleAllocateAndWriteText(BinaryenModuleRef module) { } BinaryenModuleRef BinaryenModuleRead(char* input, size_t inputSize) { - if (tracing) { - std::cout << " // BinaryenModuleRead\n"; - } - auto* wasm = new Module; std::vector<char> buffer(false); buffer.resize(inputSize); @@ -4421,38 +2649,23 @@ BinaryenModuleRef BinaryenModuleRead(char* input, size_t inputSize) { } void BinaryenModuleInterpret(BinaryenModuleRef module) { - if (tracing) { - std::cout << " BinaryenModuleInterpret(the_module);\n"; - } - - Module* wasm = (Module*)module; ShellExternalInterface interface; - ModuleInstance instance(*wasm, &interface); + ModuleInstance instance(*(Module*)module, &interface); } BinaryenIndex BinaryenModuleAddDebugInfoFileName(BinaryenModuleRef module, const char* filename) { - if (tracing) { - std::cout << " BinaryenModuleAddDebugInfoFileName(the_module, \"" - << filename << "\");\n"; - } - - Module* wasm = (Module*)module; - BinaryenIndex index = wasm->debugInfoFileNames.size(); - wasm->debugInfoFileNames.push_back(filename); + auto& debugInfoFileNames = ((Module*)module)->debugInfoFileNames; + BinaryenIndex index = debugInfoFileNames.size(); + debugInfoFileNames.push_back(filename); return index; } const char* BinaryenModuleGetDebugInfoFileName(BinaryenModuleRef module, BinaryenIndex index) { - if (tracing) { - std::cout << " BinaryenModuleGetDebugInfoFileName(the_module, \"" << index - << "\");\n"; - } - - Module* wasm = (Module*)module; - return index < wasm->debugInfoFileNames.size() - ? wasm->debugInfoFileNames.at(index).c_str() + const auto& debugInfoFileNames = ((Module*)module)->debugInfoFileNames; + return index < debugInfoFileNames.size() + ? debugInfoFileNames.at(index).c_str() : nullptr; } @@ -4461,65 +2674,29 @@ const char* BinaryenModuleGetDebugInfoFileName(BinaryenModuleRef module, // const char* BinaryenFunctionGetName(BinaryenFunctionRef func) { - if (tracing) { - std::cout << " BinaryenFunctionGetName(functions[" << functions[func] - << "]);\n"; - } - return ((Function*)func)->name.c_str(); } BinaryenType BinaryenFunctionGetParams(BinaryenFunctionRef func) { - if (tracing) { - std::cout << " BinaryenFunctionGetParams(functions[" << functions[func] - << "]);\n"; - } - return ((Function*)func)->sig.params.getID(); } BinaryenType BinaryenFunctionGetResults(BinaryenFunctionRef func) { - if (tracing) { - std::cout << " BinaryenFunctionGetResults(functions[" << functions[func] - << "]);\n"; - } - return ((Function*)func)->sig.results.getID(); } BinaryenIndex BinaryenFunctionGetNumVars(BinaryenFunctionRef func) { - if (tracing) { - std::cout << " BinaryenFunctionGetNumVars(functions[" << functions[func] - << "]);\n"; - } - return ((Function*)func)->vars.size(); } BinaryenType BinaryenFunctionGetVar(BinaryenFunctionRef func, BinaryenIndex index) { - if (tracing) { - std::cout << " BinaryenFunctionGetVar(functions[" << functions[func] - << "], " << index << ");\n"; - } - - auto* fn = (Function*)func; - assert(index < fn->vars.size()); - return fn->vars[index].getID(); + const auto& vars = ((Function*)func)->vars; + assert(index < vars.size()); + return vars[index].getID(); } BinaryenExpressionRef BinaryenFunctionGetBody(BinaryenFunctionRef func) { - if (tracing) { - std::cout << " BinaryenFunctionGetBody(functions[" << functions[func] - << "]);\n"; - } - return ((Function*)func)->body; } void BinaryenFunctionOptimize(BinaryenFunctionRef func, BinaryenModuleRef module) { - if (tracing) { - std::cout << " BinaryenFunctionOptimize(functions[" << functions[func] - << "], the_module);\n"; - } - - Module* wasm = (Module*)module; - PassRunner passRunner(wasm); + PassRunner passRunner((Module*)module); passRunner.options = globalPassOptions; passRunner.addDefaultOptimizationPasses(); passRunner.runOnFunction((Function*)func); @@ -4528,23 +2705,7 @@ void BinaryenFunctionRunPasses(BinaryenFunctionRef func, BinaryenModuleRef module, const char** passes, BinaryenIndex numPasses) { - if (tracing) { - std::cout << " {\n"; - std::cout << " const char* passes[] = { "; - for (BinaryenIndex i = 0; i < numPasses; i++) { - if (i > 0) { - std::cout << ", "; - } - std::cout << "\"" << passes[i] << "\""; - } - std::cout << " };\n"; - std::cout << " BinaryenFunctionRunPasses(functions[" << functions[func] - << ", the_module, passes, " << numPasses << ");\n"; - std::cout << " }\n"; - } - - Module* wasm = (Module*)module; - PassRunner passRunner(wasm); + PassRunner passRunner((Module*)module); passRunner.options = globalPassOptions; for (BinaryenIndex i = 0; i < numPasses; i++) { passRunner.add(passes[i]); @@ -4556,22 +2717,11 @@ void BinaryenFunctionSetDebugLocation(BinaryenFunctionRef func, BinaryenIndex fileIndex, BinaryenIndex lineNumber, BinaryenIndex columnNumber) { - if (tracing) { - std::cout << " BinaryenFunctionSetDebugLocation(functions[" - << functions[func] << "], expressions[" << expressions[expr] - << "], " << fileIndex << ", " << lineNumber << ", " - << columnNumber << ");\n"; - } - - auto* fn = (Function*)func; - auto* ex = (Expression*)expr; - Function::DebugLocation loc; loc.fileIndex = fileIndex; loc.lineNumber = lineNumber; loc.columnNumber = columnNumber; - - fn->debugLocations[ex] = loc; + ((Function*)func)->debugLocations[(Expression*)expr] = loc; } // @@ -4579,35 +2729,15 @@ void BinaryenFunctionSetDebugLocation(BinaryenFunctionRef func, // const char* BinaryenGlobalGetName(BinaryenGlobalRef global) { - if (tracing) { - std::cout << " BinaryenGlobalGetName(globals[" << globals[global] - << "]);\n"; - } - return ((Global*)global)->name.c_str(); } BinaryenType BinaryenGlobalGetType(BinaryenGlobalRef global) { - if (tracing) { - std::cout << " BinaryenGlobalGetType(globals[" << globals[global] - << "]);\n"; - } - return ((Global*)global)->type.getID(); } int BinaryenGlobalIsMutable(BinaryenGlobalRef global) { - if (tracing) { - std::cout << " BinaryenGlobalIsMutable(globals[" << globals[global] - << "]);\n"; - } - return ((Global*)global)->mutable_; } BinaryenExpressionRef BinaryenGlobalGetInitExpr(BinaryenGlobalRef global) { - if (tracing) { - std::cout << " BinaryenGlobalGetInitExpr(globals[" << globals[global] - << "]);\n"; - } - return ((Global*)global)->init; } @@ -4616,34 +2746,16 @@ BinaryenExpressionRef BinaryenGlobalGetInitExpr(BinaryenGlobalRef global) { // const char* BinaryenEventGetName(BinaryenEventRef event) { - if (tracing) { - std::cout << " BinaryenEventGetName(events[" << events[event] << "]);\n"; - } - return ((Event*)event)->name.c_str(); } int BinaryenEventGetAttribute(BinaryenEventRef event) { - if (tracing) { - std::cout << " BinaryenEventGetAttribute(events[" << events[event] - << "]);\n"; - } - return ((Event*)event)->attribute; } BinaryenType BinaryenEventGetParams(BinaryenEventRef event) { - if (tracing) { - std::cout << " BinaryenEventGetParams(events[" << events[event] << "]);\n"; - } - return ((Event*)event)->sig.params.getID(); } BinaryenType BinaryenEventGetResults(BinaryenEventRef event) { - if (tracing) { - std::cout << " BinaryenEventGetResults(events[" << events[event] - << "]);\n"; - } - return ((Event*)event)->sig.results.getID(); } @@ -4652,11 +2764,6 @@ BinaryenType BinaryenEventGetResults(BinaryenEventRef event) { // const char* BinaryenFunctionImportGetModule(BinaryenFunctionRef import) { - if (tracing) { - std::cout << " BinaryenFunctionImportGetModule(functions[" - << functions[import] << "]);\n"; - } - auto* func = (Function*)import; if (func->imported()) { return func->module.c_str(); @@ -4665,11 +2772,6 @@ const char* BinaryenFunctionImportGetModule(BinaryenFunctionRef import) { } } const char* BinaryenGlobalImportGetModule(BinaryenGlobalRef import) { - if (tracing) { - std::cout << " BinaryenGlobalImportGetModule(globals[" << globals[import] - << "]);\n"; - } - auto* global = (Global*)import; if (global->imported()) { return global->module.c_str(); @@ -4678,11 +2780,6 @@ const char* BinaryenGlobalImportGetModule(BinaryenGlobalRef import) { } } const char* BinaryenEventImportGetModule(BinaryenEventRef import) { - if (tracing) { - std::cout << " BinaryenEventImportGetModule(events[" << events[import] - << "]);\n"; - } - auto* event = (Event*)import; if (event->imported()) { return event->module.c_str(); @@ -4691,11 +2788,6 @@ const char* BinaryenEventImportGetModule(BinaryenEventRef import) { } } const char* BinaryenFunctionImportGetBase(BinaryenFunctionRef import) { - if (tracing) { - std::cout << " BinaryenFunctionImportGetBase(functions[" - << functions[import] << "]);\n"; - } - auto* func = (Function*)import; if (func->imported()) { return func->base.c_str(); @@ -4704,11 +2796,6 @@ const char* BinaryenFunctionImportGetBase(BinaryenFunctionRef import) { } } const char* BinaryenGlobalImportGetBase(BinaryenGlobalRef import) { - if (tracing) { - std::cout << " BinaryenGlobalImportGetBase(globals[" << globals[import] - << "]);\n"; - } - auto* global = (Global*)import; if (global->imported()) { return global->base.c_str(); @@ -4717,11 +2804,6 @@ const char* BinaryenGlobalImportGetBase(BinaryenGlobalRef import) { } } const char* BinaryenEventImportGetBase(BinaryenEventRef import) { - if (tracing) { - std::cout << " BinaryenEventImportGetBase(events[" << events[import] - << "]);\n"; - } - auto* event = (Event*)import; if (event->imported()) { return event->base.c_str(); @@ -4735,48 +2817,24 @@ const char* BinaryenEventImportGetBase(BinaryenEventRef import) { // BinaryenExternalKind BinaryenExportGetKind(BinaryenExportRef export_) { - if (tracing) { - std::cout << " BinaryenExportGetKind(exports[" << exports[export_] - << "]);\n"; - } - return BinaryenExternalKind(((Export*)export_)->kind); } const char* BinaryenExportGetName(BinaryenExportRef export_) { - if (tracing) { - std::cout << " BinaryenExportGetName(exports[" << exports[export_] - << "]);\n"; - } - return ((Export*)export_)->name.c_str(); } const char* BinaryenExportGetValue(BinaryenExportRef export_) { - if (tracing) { - std::cout << " BinaryenExportGetValue(exports[" << exports[export_] - << "]);\n"; - } - return ((Export*)export_)->value.c_str(); } uint32_t BinaryenGetNumExports(BinaryenModuleRef module) { - if (tracing) { - std::cout << " BinaryenGetNumExports(the_module);\n"; - } - - auto* wasm = (Module*)module; - return wasm->exports.size(); + return ((Module*)module)->exports.size(); } BinaryenExportRef BinaryenGetExportByIndex(BinaryenModuleRef module, BinaryenIndex id) { - if (tracing) { - std::cout << " BinaryenGetExportByIndex(the_module, " << id << ");\n"; - } - - auto* wasm = (Module*)module; - if (wasm->exports.size() <= id) { + const auto& exports = ((Module*)module)->exports; + if (exports.size() <= id) { Fatal() << "invalid export id."; } - return wasm->exports[id].get(); + return exports[id].get(); } // @@ -4787,27 +2845,10 @@ void BinaryenAddCustomSection(BinaryenModuleRef module, const char* name, const char* contents, BinaryenIndex contentsSize) { - if (tracing) { - std::cout << " {\n"; - std::cout << " const char contents[] = { "; - for (BinaryenIndex i = 0; i < contentsSize; i++) { - if (i > 0) { - std::cout << ", "; - } - std::cout << int(contents[i]); - } - std::cout << " };\n"; - std::cout << " BinaryenAddCustomSection(the_module, "; - traceNameOrNULL(name); - std::cout << ", contents, " << contentsSize << ");\n"; - std::cout << " }\n"; - } - - auto* wasm = (Module*)module; wasm::UserSection customSection; customSection.name = name; customSection.data = std::vector<char>(contents, contents + contentsSize); - wasm->userSections.push_back(customSection); + ((Module*)module)->userSections.push_back(customSection); } // @@ -4866,10 +2907,6 @@ BinaryenSideEffects BinaryenSideEffectAny(void) { BinaryenSideEffects BinaryenExpressionGetSideEffects(BinaryenExpressionRef expr, BinaryenFeatures features) { - if (tracing) { - std::cout << " BinaryenExpressionGetSideEffects(expressions[" - << expressions[expr] << "], " << features << ");\n"; - } return EffectAnalyzer(globalPassOptions, features, (Expression*)expr) .getSideEffects(); } @@ -4879,28 +2916,13 @@ BinaryenExpressionGetSideEffects(BinaryenExpressionRef expr, // RelooperRef RelooperCreate(BinaryenModuleRef module) { - if (tracing) { - std::cout << " the_relooper = RelooperCreate(the_module);\n"; - } - - auto* wasm = (Module*)module; - return RelooperRef(new CFG::Relooper(wasm)); + return RelooperRef(new CFG::Relooper((Module*)module)); } RelooperBlockRef RelooperAddBlock(RelooperRef relooper, BinaryenExpressionRef code) { - auto* R = (CFG::Relooper*)relooper; auto* ret = new CFG::Block((Expression*)code); - - if (tracing) { - auto id = relooperBlocks.size(); - relooperBlocks[ret] = id; - std::cout << " relooperBlocks[" << id - << "] = RelooperAddBlock(the_relooper, expressions[" - << expressions[code] << "]);\n"; - } - - R->AddBlock(ret); + ((CFG::Relooper*)relooper)->AddBlock(ret); return RelooperBlockRef(ret); } @@ -4908,32 +2930,15 @@ void RelooperAddBranch(RelooperBlockRef from, RelooperBlockRef to, BinaryenExpressionRef condition, BinaryenExpressionRef code) { - if (tracing) { - std::cout << " RelooperAddBranch(relooperBlocks[" << relooperBlocks[from] - << "], relooperBlocks[" << relooperBlocks[to] << "], expressions[" - << expressions[condition] << "], expressions[" - << expressions[code] << "]);\n"; - } - - auto* fromBlock = (CFG::Block*)from; - auto* toBlock = (CFG::Block*)to; - fromBlock->AddBranchTo(toBlock, (Expression*)condition, (Expression*)code); + ((CFG::Block*)from) + ->AddBranchTo((CFG::Block*)to, (Expression*)condition, (Expression*)code); } RelooperBlockRef RelooperAddBlockWithSwitch(RelooperRef relooper, BinaryenExpressionRef code, BinaryenExpressionRef condition) { - auto* R = (CFG::Relooper*)relooper; auto* ret = new CFG::Block((Expression*)code, (Expression*)condition); - - if (tracing) { - std::cout << " relooperBlocks[" << relooperBlocks[ret] - << "] = RelooperAddBlockWithSwitch(the_relooper, expressions[" - << expressions[code] << "], expressions[" - << expressions[condition] << "]);\n"; - } - - R->AddBlock(ret); + ((CFG::Relooper*)relooper)->AddBlock(ret); return RelooperBlockRef(ret); } @@ -4942,34 +2947,12 @@ void RelooperAddBranchForSwitch(RelooperBlockRef from, BinaryenIndex* indexes, BinaryenIndex numIndexes, BinaryenExpressionRef code) { - if (tracing) { - std::cout << " {\n"; - std::cout << " BinaryenIndex indexes[] = { "; - for (BinaryenIndex i = 0; i < numIndexes; i++) { - if (i > 0) { - std::cout << ", "; - } - std::cout << indexes[i]; - } - if (numIndexes == 0) { - // ensure the array is not empty, otherwise a compiler error on VS - std::cout << "0"; - } - std::cout << " };\n"; - std::cout << " RelooperAddBranchForSwitch(relooperBlocks[" - << relooperBlocks[from] << "], relooperBlocks[" - << relooperBlocks[to] << "], indexes, " << numIndexes - << ", expressions[" << expressions[code] << "]);\n"; - std::cout << " }\n"; - } - - auto* fromBlock = (CFG::Block*)from; - auto* toBlock = (CFG::Block*)to; std::vector<Index> values; for (Index i = 0; i < numIndexes; i++) { values.push_back(indexes[i]); } - fromBlock->AddSwitchBranchTo(toBlock, std::move(values), (Expression*)code); + ((CFG::Block*)from) + ->AddSwitchBranchTo((CFG::Block*)to, std::move(values), (Expression*)code); } BinaryenExpressionRef RelooperRenderAndDispose(RelooperRef relooper, @@ -4979,15 +2962,6 @@ BinaryenExpressionRef RelooperRenderAndDispose(RelooperRef relooper, R->Calculate((CFG::Block*)entry); CFG::RelooperBuilder builder(*R->Module, labelHelper); auto* ret = R->Render(builder); - - if (tracing) { - auto id = noteExpression(ret); - std::cout << " expressions[" << id - << "] = RelooperRenderAndDispose(the_relooper, relooperBlocks[" - << relooperBlocks[entry] << "], " << labelHelper << ");\n"; - relooperBlocks.clear(); - } - delete R; return BinaryenExpressionRef(ret); } @@ -5030,27 +3004,13 @@ ExpressionRunnerRef ExpressionRunnerCreate(BinaryenModuleRef module, ExpressionRunnerFlags flags, BinaryenIndex maxDepth, BinaryenIndex maxLoopIterations) { - auto* wasm = (Module*)module; - auto* runner = ExpressionRunnerRef( - new CExpressionRunner(wasm, flags, maxDepth, maxLoopIterations)); - if (tracing) { - auto id = noteExpressionRunner(runner); - std::cout << " expressionRunners[" << id - << "] = ExpressionRunnerCreate(the_module, " << flags << ", " - << maxDepth << ", " << maxLoopIterations << ");\n"; - } - return runner; + return static_cast<ExpressionRunnerRef>( + new CExpressionRunner((Module*)module, flags, maxDepth, maxLoopIterations)); } int ExpressionRunnerSetLocalValue(ExpressionRunnerRef runner, BinaryenIndex index, BinaryenExpressionRef value) { - if (tracing) { - std::cout << " ExpressionRunnerSetLocalValue(expressionRunners[" - << expressionRunners[runner] << "], " << index << ", expressions[" - << expressions[value] << "]);\n"; - } - auto* R = (CExpressionRunner*)runner; auto setFlow = R->visit(value); if (!setFlow.breaking()) { @@ -5063,13 +3023,6 @@ int ExpressionRunnerSetLocalValue(ExpressionRunnerRef runner, int ExpressionRunnerSetGlobalValue(ExpressionRunnerRef runner, const char* name, BinaryenExpressionRef value) { - if (tracing) { - std::cout << " ExpressionRunnerSetGlobalValue(expressionRunners[" - << expressionRunners[runner] << "], "; - traceNameOrNULL(name); - std::cout << ", expressions[" << expressions[value] << "]);\n"; - } - auto* R = (CExpressionRunner*)runner; auto setFlow = R->visit(value); if (!setFlow.breaking()) { @@ -5091,55 +3044,11 @@ ExpressionRunnerRunAndDispose(ExpressionRunnerRef runner, } } catch (CExpressionRunner::NonconstantException&) { } - - if (tracing) { - if (ret != nullptr) { - auto id = noteExpression(ret); - std::cout << " expressions[" << id << "] = "; - } else { - std::cout << " "; - } - auto id = expressionRunners[runner]; - std::cout << "ExpressionRunnerRunAndDispose(expressionRunners[" << id - << "], expressions[" << expressions[expr] << "]);\n"; - usedExpressionRunnerIds.erase(id); - } - delete R; return ret; } // -// ========= Other APIs ========= -// - -void BinaryenSetAPITracing(int on) { - tracing = on; - - if (tracing) { - std::cout << "// beginning a Binaryen API trace\n" - "#include <math.h>\n" - "#include <map>\n" - "#include \"binaryen-c.h\"\n" - "int main() {\n" - " std::map<size_t, BinaryenType> types;\n" - " std::map<size_t, BinaryenExpressionRef> expressions;\n" - " std::map<size_t, BinaryenFunctionRef> functions;\n" - " std::map<size_t, BinaryenGlobalRef> globals;\n" - " std::map<size_t, BinaryenEventRef> events;\n" - " std::map<size_t, BinaryenExportRef> exports;\n" - " std::map<size_t, RelooperBlockRef> relooperBlocks;\n" - " std::map<size_t, ExpressionRunnerRef> expressionRunners;\n" - " BinaryenModuleRef the_module = NULL;\n" - " RelooperRef the_relooper = NULL;\n"; - } else { - std::cout << " return 0;\n"; - std::cout << "}\n"; - std::cout << "// ending a Binaryen API trace\n"; - } -} - -// // ========= Utilities ========= // |