From f4b7df08b27a2fe000424524957cf9cf10041193 Mon Sep 17 00:00:00 2001 From: Daniel Wirtz Date: Wed, 20 Dec 2017 20:46:14 +0100 Subject: Add getters for various specific expression fields to C/JS (#1332) --- src/binaryen-c.cpp | 1128 +++++++++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 1018 insertions(+), 110 deletions(-) (limited to 'src/binaryen-c.cpp') diff --git a/src/binaryen-c.cpp b/src/binaryen-c.cpp index bd7528fb9..c91825882 100644 --- a/src/binaryen-c.cpp +++ b/src/binaryen-c.cpp @@ -82,6 +82,8 @@ void traceNameOrNULL(const char *name) { std::map functionTypes; std::map expressions; std::map functions; +std::map imports; +std::map exports; std::map relooperBlocks; size_t noteExpression(BinaryenExpressionRef expression) { @@ -99,12 +101,20 @@ extern "C" { // Core types -BinaryenType BinaryenNone(void) { return none; } -BinaryenType BinaryenInt32(void) { return i32; } -BinaryenType BinaryenInt64(void) { return i64; } -BinaryenType BinaryenFloat32(void) { return f32; } -BinaryenType BinaryenFloat64(void) { return f64; } -BinaryenType BinaryenUndefined(void) { return uint32_t(-1); } +BinaryenType BinaryenTypeNone(void) { return none; } +BinaryenType BinaryenTypeInt32(void) { return i32; } +BinaryenType BinaryenTypeInt64(void) { return i64; } +BinaryenType BinaryenTypeFloat32(void) { return f32; } +BinaryenType BinaryenTypeFloat64(void) { return f64; } +BinaryenType BinaryenTypeUnreachable(void) { return unreachable; } +BinaryenType BinaryenTypeAuto(void) { return uint32_t(-1); } + +WASM_DEPRECATED BinaryenType BinaryenNone(void) { return none; } +WASM_DEPRECATED BinaryenType BinaryenInt32(void) { return i32; } +WASM_DEPRECATED BinaryenType BinaryenInt64(void) { return i64; } +WASM_DEPRECATED BinaryenType BinaryenFloat32(void) { return f32; } +WASM_DEPRECATED BinaryenType BinaryenFloat64(void) { return f64; } +WASM_DEPRECATED BinaryenType BinaryenUndefined(void) { return uint32_t(-1); } // Expression ids @@ -161,6 +171,8 @@ void BinaryenModuleDispose(BinaryenModuleRef module) { std::cout << " functionTypes.clear();\n"; std::cout << " expressions.clear();\n"; std::cout << " functions.clear();\n"; + std::cout << " imports.clear();\n"; + std::cout << " exports.clear();\n"; std::cout << " relooperBlocks.clear();\n"; functionTypes.clear(); expressions.clear(); @@ -359,7 +371,7 @@ BinaryenExpressionRef BinaryenBlock(BinaryenModuleRef module, const char* name, for (BinaryenIndex i = 0; i < numChildren; i++) { ret->list.push_back((Expression*)children[i]); } - if (type != BinaryenUndefined()) ret->finalize(WasmType(type)); + if (type != BinaryenTypeAuto()) ret->finalize(WasmType(type)); else ret->finalize(); if (tracing) { @@ -375,7 +387,7 @@ BinaryenExpressionRef BinaryenBlock(BinaryenModuleRef module, const char* name, std::cout << " expressions[" << id << "] = BinaryenBlock(the_module, "; traceNameOrNULL(name); std::cout << ", children, " << numChildren << ", "; - if (type == BinaryenUndefined()) std::cout << "BinaryenUndefined()"; + if (type == BinaryenTypeAuto()) std::cout << "BinaryenTypeAuto()"; else std::cout << type; std::cout << ");\n"; std::cout << " }\n"; @@ -706,11 +718,22 @@ BinaryenExpressionRef BinaryenReturn(BinaryenModuleRef module, BinaryenExpressio return static_cast(ret); } BinaryenExpressionRef BinaryenHost(BinaryenModuleRef module, BinaryenOp op, const char* name, BinaryenExpressionRef* operands, BinaryenIndex numOperands) { + auto* ret = ((Module*)module)->allocator.alloc(); + if (tracing) { - std::cout << " TODO: host...\n"; + 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) std::cout << "0"; // ensure the array is not empty, otherwise a compiler error on VS + std::cout << " };\n"; + auto id = noteExpression(ret); + std::cout << " expressions[" << id << "] = BinaryenHost(the_module, " << op << ", \"" << name << "\", operands, " << numOperands << ");\n"; + std::cout << " }\n"; } - auto* ret = ((Module*)module)->allocator.alloc(); ret->op = HostOp(op); if (name) ret->nameOperand = name; for (BinaryenIndex i = 0; i < numOperands; i++) { @@ -723,160 +746,860 @@ BinaryenExpressionRef BinaryenNop(BinaryenModuleRef module) { auto* ret = ((Module*)module)->allocator.alloc(); if (tracing) { - auto id = noteExpression(ret); - std::cout << " expressions[" << id << "] = BinaryenNop(the_module);\n"; + auto id = noteExpression(ret); + std::cout << " expressions[" << id << "] = BinaryenNop(the_module);\n"; + } + + return static_cast(ret); +} +BinaryenExpressionRef BinaryenUnreachable(BinaryenModuleRef module) { + auto* ret = ((Module*)module)->allocator.alloc(); + + if (tracing) { + auto id = noteExpression(ret); + std::cout << " expressions[" << id << "] = BinaryenUnreachable(the_module);\n"; + } + + return static_cast(ret); +} +BinaryenExpressionRef BinaryenAtomicLoad(BinaryenModuleRef module, uint32_t bytes, uint32_t offset, BinaryenType type, BinaryenExpressionRef ptr) { + auto* ret = Builder(*((Module*)module)).makeAtomicLoad(bytes, offset, (Expression*)ptr, WasmType(type)); + + if (tracing) { + auto id = noteExpression(ret); + std::cout << " expressions[" << id << "] = BinaryenAtomicLoad(the_module, " << bytes << ", " << offset << ", " << type << ", expressions[" << expressions[ptr] << "]);\n"; + } + + return static_cast(ret); +} +BinaryenExpressionRef BinaryenAtomicStore(BinaryenModuleRef module, uint32_t bytes, uint32_t offset, BinaryenExpressionRef ptr, BinaryenExpressionRef value, BinaryenType type) { + auto* ret = Builder(*((Module*)module)).makeAtomicStore(bytes, offset, (Expression*)ptr, (Expression*)value, WasmType(type)); + + if (tracing) { + auto id = noteExpression(ret); + std::cout << " expressions[" << id << "] = BinaryenAtomicStore(the_module, " << bytes << ", " << offset << ", expressions[" << expressions[ptr] << "], expressions[" << expressions[value] << "], " << type << ");\n"; + } + + return static_cast(ret); +} +BinaryenExpressionRef BinaryenAtomicRMW(BinaryenModuleRef module, BinaryenOp op, BinaryenIndex bytes, BinaryenIndex offset, BinaryenExpressionRef ptr, BinaryenExpressionRef value, BinaryenType type) { + auto* ret = Builder(*((Module*)module)).makeAtomicRMW(AtomicRMWOp(op), bytes, offset, (Expression*)ptr, (Expression*)value, WasmType(type)); + + if (tracing) { + auto id = noteExpression(ret); + std::cout << " expressions[" << id << "] = BinaryenAtomicRMW(the_module, " << op << ", " << bytes << ", " << offset << ", expressions[" << expressions[ptr] << "], expressions[" << expressions[value] << "], " << type << ");\n"; + } + + return static_cast(ret); +} +BinaryenExpressionRef BinaryenAtomicCmpxchg(BinaryenModuleRef module, BinaryenIndex bytes, BinaryenIndex offset, BinaryenExpressionRef ptr, BinaryenExpressionRef expected, BinaryenExpressionRef replacement, BinaryenType type) { + auto* ret = Builder(*((Module*)module)).makeAtomicCmpxchg(bytes, offset, (Expression*)ptr, (Expression*)expected, (Expression*)replacement, WasmType(type)); + + if (tracing) { + auto id = noteExpression(ret); + std::cout << " expressions[" << id << "] = BinaryenAtomicCmpxchg(the_module, " << bytes << ", " << offset << ", expressions[" << expressions[ptr] << "], expressions[" << expressions[expected] << "], expressions[" << expressions[replacement] << "], " << type << ");\n"; + } + + return static_cast(ret); +} +BinaryenExpressionRef BinaryenAtomicWait(BinaryenModuleRef module, BinaryenExpressionRef ptr, BinaryenExpressionRef expected, BinaryenExpressionRef timeout, BinaryenType expectedType) { + auto* ret = Builder(*((Module*)module)).makeAtomicWait((Expression*)ptr, (Expression*)expected, (Expression*)timeout, WasmType(expectedType)); + + if (tracing) { + auto id = noteExpression(ret); + std::cout << " expressions[" << id << "] = BinaryenAtomicWait(the_module, expressions[" << expressions[ptr] << "], expressions[" << expressions[expected] << "], expressions[" << expressions[timeout] << "], " << expectedType << ");\n"; + } + + return static_cast(ret); +} +BinaryenExpressionRef BinaryenAtomicWake(BinaryenModuleRef module, BinaryenExpressionRef ptr, BinaryenExpressionRef wakeCount) { + auto* ret = Builder(*((Module*)module)).makeAtomicWake((Expression*)ptr, (Expression*)wakeCount); + + if (tracing) { + auto id = noteExpression(ret); + std::cout << " expressions[" << id << "] = BinaryenAtomicWake(the_module, expressions[" << expressions[ptr] << "], expressions[" << expressions[wakeCount] << "]);\n"; + } + + return static_cast(ret); +} + +// 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; +} +void BinaryenExpressionPrint(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenExpressionPrint(expressions[" << expressions[expr] << "]);\n"; + } + + WasmPrinter::printExpression((Expression*)expr, std::cout); + std::cout << '\n'; +} + +// Specific expression utility + +// Block +const char* BinaryenBlockGetName(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenBlockGetName(expressions[" << expressions[expr] << "]);\n"; + } + + auto* expression = (Expression*)expr; + assert(expression->is()); + return static_cast(expression)->name.c_str(); +} +BinaryenIndex BinaryenBlockGetNumChildren(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenBlockGetNumChildren(expressions[" << expressions[expr] << "]);\n"; + } + + auto* expression = (Expression*)expr; + assert(expression->is()); + return static_cast(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()); + assert(index < static_cast(expression)->list.size()); + return static_cast(expression)->list[index]; +} +// If +BinaryenExpressionRef BinaryenIfGetCondition(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenIfGetCondition(expressions[" << expressions[expr] << "]);\n"; + } + + auto* expression = (Expression*)expr; + assert(expression->is()); + return static_cast(expression)->condition; +} +BinaryenExpressionRef BinaryenIfGetIfTrue(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenIfGetIfTrue(expressions[" << expressions[expr] << "]);\n"; + } + + auto* expression = (Expression*)expr; + assert(expression->is()); + return static_cast(expression)->ifTrue; +} +BinaryenExpressionRef BinaryenIfGetIfFalse(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenIfGetIfFalse(expressions[" << expressions[expr] << "]);\n"; + } + + auto* expression = (Expression*)expr; + assert(expression->is()); + return static_cast(expression)->ifFalse; +} +// Loop +const char* BinaryenLoopGetName(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenLoopGetName(expressions[" << expressions[expr] << "]);\n"; + } + + auto* expression = (Expression*)expr; + assert(expression->is()); + return static_cast(expression)->name.c_str(); +} +BinaryenExpressionRef BinaryenLoopGetBody(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenLoopGetBody(expressions[" << expressions[expr] << "]);\n"; + } + + auto* expression = (Expression*)expr; + assert(expression->is()); + return static_cast(expression)->body; +} +// Break +const char* BinaryenBreakGetName(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenBreakGetName(expressions[" << expressions[expr] << "]);\n"; + } + + auto* expression = (Expression*)expr; + assert(expression->is()); + return static_cast(expression)->name.c_str(); +} +BinaryenExpressionRef BinaryenBreakGetCondition(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenBreakGetCondition(expressions[" << expressions[expr] << "]);\n"; + } + + auto* expression = (Expression*)expr; + assert(expression->is()); + return static_cast(expression)->condition; +} +BinaryenExpressionRef BinaryenBreakGetValue(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenBreakGetValue(expressions[" << expressions[expr] << "]);\n"; + } + + auto* expression = (Expression*)expr; + assert(expression->is()); + return static_cast(expression)->value; +} +// Switch +BinaryenIndex BinaryenSwitchGetNumNames(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenSwitchGetNumNames(expressions[" << expressions[expr] << "]);\n"; + } + + auto* expression = (Expression*)expr; + assert(expression->is()); + return static_cast(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()); + assert(index < static_cast(expression)->targets.size()); + return static_cast(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()); + return static_cast(expression)->default_.c_str(); +} +BinaryenExpressionRef BinaryenSwitchGetCondition(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenSwitchGetCondition(expressions[" << expressions[expr] << "]);\n"; + } + + auto* expression = (Expression*)expr; + assert(expression->is()); + return static_cast(expression)->condition; +} +BinaryenExpressionRef BinaryenSwitchGetValue(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenSwitchGetValue(expressions[" << expressions[expr] << "]);\n"; + } + + auto* expression = (Expression*)expr; + assert(expression->is()); + return static_cast(expression)->value; +} +// Call +const char* BinaryenCallGetTarget(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenCallGetTarget(expressions[" << expressions[expr] << "]);\n"; + } + + auto* expression = (Expression*)expr; + assert(expression->is()); + return static_cast(expression)->target.c_str(); +} +BinaryenIndex BinaryenCallGetNumOperands(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenCallGetNumOperands(expressions[" << expressions[expr] << "]);\n"; + } + + auto* expression = (Expression*)expr; + assert(expression->is()); + return static_cast(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()); + assert(index < static_cast(expression)->operands.size()); + return static_cast(expression)->operands[index]; +} +// CallImport +const char* BinaryenCallImportGetTarget(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenCallImportGetTarget(expressions[" << expressions[expr] << "]);\n"; + } + + auto* expression = (Expression*)expr; + assert(expression->is()); + return static_cast(expression)->target.c_str(); +} +BinaryenIndex BinaryenCallImportGetNumOperands(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenCallImportGetNumOperands(expressions[" << expressions[expr] << "]);\n"; + } + + auto* expression = (Expression*)expr; + assert(expression->is()); + return static_cast(expression)->operands.size(); +} +BinaryenExpressionRef BinaryenCallImportGetOperand(BinaryenExpressionRef expr, BinaryenIndex index) { + if (tracing) { + std::cout << " BinaryenCallImportGetOperand(expressions[" << expressions[expr] << "], " << index << ");\n"; + } + + auto* expression = (Expression*)expr; + assert(expression->is()); + assert(index < static_cast(expression)->operands.size()); + return static_cast(expression)->operands[index]; +} +// CallIndirect +BinaryenExpressionRef BinaryenCallIndirectGetTarget(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenCallIndirectGetTarget(expressions[" << expressions[expr] << "]);\n"; + } + + auto* expression = (Expression*)expr; + assert(expression->is()); + return static_cast(expression)->target; +} +BinaryenIndex BinaryenCallIndirectGetNumOperands(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenCallIndirectGetNumOperands(expressions[" << expressions[expr] << "]);\n"; + } + + auto* expression = (Expression*)expr; + assert(expression->is()); + return static_cast(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()); + assert(index < static_cast(expression)->operands.size()); + return static_cast(expression)->operands[index]; +} +// GetLocal +BinaryenIndex BinaryenGetLocalGetIndex(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenGetLocalGetIndex(expressions[" << expressions[expr] << "]);\n"; + } + + auto* expression = (Expression*)expr; + assert(expression->is()); + return static_cast(expression)->index; +} +// SetLocal +int BinaryenSetLocalIsTee(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenSetLocalIsTee(expressions[" << expressions[expr] << "]);\n"; + } + + auto* expression = (Expression*)expr; + assert(expression->is()); + return static_cast(expression)->isTee(); +} +BinaryenIndex BinaryenSetLocalGetIndex(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenSetLocalGetIndex(expressions[" << expressions[expr] << "]);\n"; + } + + auto* expression = (Expression*)expr; + assert(expression->is()); + return static_cast(expression)->index; +} +BinaryenExpressionRef BinaryenSetLocalGetValue(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenSetLocalGetValue(expressions[" << expressions[expr] << "]);\n"; + } + + auto* expression = (Expression*)expr; + assert(expression->is()); + return static_cast(expression)->value; +} +// GetGlobal +const char* BinaryenGetGlobalGetName(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenGetGlobalGetName(expressions[" << expressions[expr] << "]);\n"; + } + + auto* expression = (Expression*)expr; + assert(expression->is()); + return static_cast(expression)->name.c_str(); +} +// SetGlobal +const char* BinaryenSetGlobalGetName(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenSetGlobalGetName(expressions[" << expressions[expr] << "]);\n"; + } + + auto* expression = (Expression*)expr; + assert(expression->is()); + return static_cast(expression)->name.c_str(); +} +BinaryenExpressionRef BinaryenSetGlobalGetValue(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenSetGlobalGetValue(expressions[" << expressions[expr] << "]);\n"; + } + + auto* expression = (Expression*)expr; + assert(expression->is()); + return static_cast(expression)->value; +} +// Host +BinaryenOp BinaryenHostGetOp(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenHostGetOp(expressions[" << expressions[expr] << "]);\n"; + } + + auto* expression = (Expression*)expr; + assert(expression->is()); + return static_cast(expression)->op; +} +const char* BinaryenHostGetNameOperand(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenHostGetNameOperand(expressions[" << expressions[expr] << "]);\n"; + } + + auto* expression = (Expression*)expr; + assert(expression->is()); + return static_cast(expression)->nameOperand.c_str(); +} +BinaryenIndex BinaryenHostGetNumOperands(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenHostGetNumOperands(expressions[" << expressions[expr] << "]);\n"; + } + + auto* expression = (Expression*)expr; + assert(expression->is()); + return static_cast(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()); + assert(index < static_cast(expression)->operands.size()); + return static_cast(expression)->operands[index]; +} +// Load +int BinaryenLoadIsAtomic(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenLoadIsAtomic(expressions[" << expressions[expr] << "]);\n"; + } + + auto* expression = (Expression*)expr; + assert(expression->is()); + return static_cast(expression)->isAtomic; +} +int BinaryenLoadIsSigned(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenLoadIsSigned(expressions[" << expressions[expr] << "]);\n"; + } + + auto* expression = (Expression*)expr; + assert(expression->is()); + return static_cast(expression)->signed_; +} +uint32_t BinaryenLoadGetBytes(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenLoadGetBytes(expressions[" << expressions[expr] << "]);\n"; + } + + auto* expression = (Expression*)expr; + assert(expression->is()); + return static_cast(expression)->bytes; +} +uint32_t BinaryenLoadGetOffset(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenLoadGetOffset(expressions[" << expressions[expr] << "]);\n"; + } + + auto* expression = (Expression*)expr; + assert(expression->is()); + return static_cast(expression)->offset; +} +uint32_t BinaryenLoadGetAlign(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenLoadGetAlign(expressions[" << expressions[expr] << "]);\n"; + } + + auto* expression = (Expression*)expr; + assert(expression->is()); + return static_cast(expression)->align; +} +BinaryenExpressionRef BinaryenLoadGetPtr(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenLoadGetPtr(expressions[" << expressions[expr] << "]);\n"; + } + + auto* expression = (Expression*)expr; + assert(expression->is()); + return static_cast(expression)->ptr; +} +// Store +int BinaryenStoreIsAtomic(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenStoreIsAtomic(expressions[" << expressions[expr] << "]);\n"; + } + + auto* expression = (Expression*)expr; + assert(expression->is()); + return static_cast(expression)->isAtomic; +} +uint32_t BinaryenStoreGetBytes(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenStoreGetBytes(expressions[" << expressions[expr] << "]);\n"; + } + + auto* expression = (Expression*)expr; + assert(expression->is()); + return static_cast(expression)->bytes; +} +uint32_t BinaryenStoreGetOffset(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenStoreGetOffset(expressions[" << expressions[expr] << "]);\n"; + } + + auto* expression = (Expression*)expr; + assert(expression->is()); + return static_cast(expression)->offset; +} +uint32_t BinaryenStoreGetAlign(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenStoreGetAlign(expressions[" << expressions[expr] << "]);\n"; + } + + auto* expression = (Expression*)expr; + assert(expression->is()); + return static_cast(expression)->align; +} +BinaryenExpressionRef BinaryenStoreGetPtr(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenStoreGetPtr(expressions[" << expressions[expr] << "]);\n"; + } + + auto* expression = (Expression*)expr; + assert(expression->is()); + return static_cast(expression)->ptr; +} +BinaryenExpressionRef BinaryenStoreGetValue(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenStoreGetValue(expressions[" << expressions[expr] << "]);\n"; + } + + auto* expression = (Expression*)expr; + assert(expression->is()); + return static_cast(expression)->value; +} +// Const +int32_t BinaryenConstGetValueI32(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenConstGetValueI32(expressions[" << expressions[expr] << "]);\n"; + } + + auto* expression = (Expression*)expr; + assert(expression->is()); + return static_cast(expression)->value.geti32(); +} +int64_t BinaryenConstGetValueI64(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenConstGetValueI64(expressions[" << expressions[expr] << "]);\n"; + } + + auto* expression = (Expression*)expr; + assert(expression->is()); + return static_cast(expression)->value.geti64(); +} +int32_t BinaryenConstGetValueI64Low(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenConstGetValueI64Low(expressions[" << expressions[expr] << "]);\n"; + } + + auto* expression = (Expression*)expr; + assert(expression->is()); + return (int32_t)(static_cast(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()); + return (int32_t)(static_cast(expression)->value.geti64() >> 32); +} +float BinaryenConstGetValueF32(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenConstGetValueF32(expressions[" << expressions[expr] << "]);\n"; + } + + auto* expression = (Expression*)expr; + assert(expression->is()); + return static_cast(expression)->value.getf32(); +} +double BinaryenConstGetValueF64(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenConstGetValueF64(expressions[" << expressions[expr] << "]);\n"; + } + + auto* expression = (Expression*)expr; + assert(expression->is()); + return static_cast(expression)->value.getf64(); +} +// Unary +BinaryenOp BinaryenUnaryGetOp(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenUnaryGetOp(expressions[" << expressions[expr] << "]);\n"; } - return static_cast(ret); + auto* expression = (Expression*)expr; + assert(expression->is()); + return static_cast(expression)->op; } -BinaryenExpressionRef BinaryenUnreachable(BinaryenModuleRef module) { - auto* ret = ((Module*)module)->allocator.alloc(); +BinaryenExpressionRef BinaryenUnaryGetValue(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenUnaryGetValue(expressions[" << expressions[expr] << "]);\n"; + } + auto* expression = (Expression*)expr; + assert(expression->is()); + return static_cast(expression)->value; +} +// Binary +BinaryenOp BinaryenBinaryGetOp(BinaryenExpressionRef expr) { if (tracing) { - auto id = noteExpression(ret); - std::cout << " expressions[" << id << "] = BinaryenUnreachable(the_module);\n"; + std::cout << " BinaryenBinaryGetOp(expressions[" << expressions[expr] << "]);\n"; } - return static_cast(ret); + auto* expression = (Expression*)expr; + assert(expression->is()); + return static_cast(expression)->op; } -BinaryenExpressionRef BinaryenAtomicLoad(BinaryenModuleRef module, uint32_t bytes, uint32_t offset, BinaryenType type, BinaryenExpressionRef ptr) { - auto* ret = Builder(*((Module*)module)).makeAtomicLoad(bytes, offset, (Expression*)ptr, WasmType(type)); +BinaryenExpressionRef BinaryenBinaryGetLeft(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenBinaryGetLeft(expressions[" << expressions[expr] << "]);\n"; + } + auto* expression = (Expression*)expr; + assert(expression->is()); + return static_cast(expression)->left; +} +BinaryenExpressionRef BinaryenBinaryGetRight(BinaryenExpressionRef expr) { if (tracing) { - auto id = noteExpression(ret); - std::cout << " expressions[" << id << "] = BinaryenAtomicLoad(the_module, " << bytes << ", " << offset << ", " << type << ", expressions[" << expressions[ptr] << "]);\n"; + std::cout << " BinaryenBinaryGetRight(expressions[" << expressions[expr] << "]);\n"; } - return static_cast(ret); + auto* expression = (Expression*)expr; + assert(expression->is()); + return static_cast(expression)->right; } -BinaryenExpressionRef BinaryenAtomicStore(BinaryenModuleRef module, uint32_t bytes, uint32_t offset, BinaryenExpressionRef ptr, BinaryenExpressionRef value, BinaryenType type) { - auto* ret = Builder(*((Module*)module)).makeAtomicStore(bytes, offset, (Expression*)ptr, (Expression*)value, WasmType(type)); +// Select +BinaryenExpressionRef BinaryenSelectGetIfTrue(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenSelectGetIfTrue(expressions[" << expressions[expr] << "]);\n"; + } + auto* expression = (Expression*)expr; + assert(expression->is()); + return static_cast(expression)->ifFalse; } -BinaryenExpressionRef BinaryenAtomicRMW(BinaryenModuleRef module, BinaryenOp op, BinaryenIndex bytes, BinaryenIndex offset, BinaryenExpressionRef ptr, BinaryenExpressionRef value, BinaryenType type) { - auto* ret = Builder(*((Module*)module)).makeAtomicRMW(AtomicRMWOp(op), bytes, offset, (Expression*)ptr, (Expression*)value, WasmType(type)); +BinaryenExpressionRef BinaryenSelectGetCondition(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenSelectGetCondition(expressions[" << expressions[expr] << "]);\n"; + } + auto* expression = (Expression*)expr; + assert(expression->is