diff options
Diffstat (limited to 'js/src/wasm/WasmBinaryToExperimentalText.cpp')
| -rw-r--r-- | js/src/wasm/WasmBinaryToExperimentalText.cpp | 1922 |
1 files changed, 1922 insertions, 0 deletions
diff --git a/js/src/wasm/WasmBinaryToExperimentalText.cpp b/js/src/wasm/WasmBinaryToExperimentalText.cpp new file mode 100644 index 000000000..29f79981b --- /dev/null +++ b/js/src/wasm/WasmBinaryToExperimentalText.cpp @@ -0,0 +1,1922 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * vim: set ts=8 sts=4 et sw=4 tw=99: + * + * Copyright 2015 Mozilla Foundation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "wasm/WasmBinaryToExperimentalText.h" + +#include "mozilla/CheckedInt.h" + +#include "jsnum.h" +#include "jsprf.h" + +#include "vm/ArrayBufferObject.h" +#include "vm/StringBuffer.h" +#include "wasm/WasmAST.h" +#include "wasm/WasmBinaryToAST.h" +#include "wasm/WasmTextUtils.h" +#include "wasm/WasmTypes.h" + +using namespace js; +using namespace js::wasm; + +using mozilla::CheckedInt; +using mozilla::IsInfinite; +using mozilla::IsNaN; +using mozilla::IsNegativeZero; + +enum PrintOperatorPrecedence +{ + ExpressionPrecedence = 0, + AssignmentPrecedence = 1, + StoreOperatorPrecedence = 1, + BitwiseOrPrecedence = 4, + BitwiseXorPrecedence = 5, + BitwiseAndPrecedence = 6, + EqualityPrecedence = 7, + ComparisonPrecedence = 8, + BitwiseShiftPrecedence = 9, + AdditionPrecedence = 10, + MultiplicationPrecedence = 11, + NegatePrecedence = 12, + EqzPrecedence = 12, + OperatorPrecedence = 15, + LoadOperatorPrecedence = 15, + CallPrecedence = 15, + GroupPrecedence = 16, +}; + +struct WasmPrintContext +{ + JSContext* cx; + AstModule* module; + WasmPrintBuffer& buffer; + const ExperimentalTextFormatting& f; + GeneratedSourceMap* maybeSourceMap; + uint32_t indent; + + uint32_t currentFuncIndex; + PrintOperatorPrecedence currentPrecedence; + + WasmPrintContext(JSContext* cx, AstModule* module, WasmPrintBuffer& buffer, + const ExperimentalTextFormatting& f, GeneratedSourceMap* wasmSourceMap_) + : cx(cx), + module(module), + buffer(buffer), + f(f), + maybeSourceMap(wasmSourceMap_), + indent(0), + currentFuncIndex(0), + currentPrecedence(PrintOperatorPrecedence::ExpressionPrecedence) + {} + + StringBuffer& sb() { return buffer.stringBuffer(); } +}; + +/*****************************************************************************/ +// utilities + +static bool +IsDropValueExpr(AstExpr& expr) +{ + // Based on AST information, determines if the expression does not return a value. + // TODO infer presence of a return value for rest kinds of expressions from + // the function return type. + switch (expr.kind()) { + case AstExprKind::Branch: + return !expr.as<AstBranch>().maybeValue(); + case AstExprKind::BranchTable: + return !expr.as<AstBranchTable>().maybeValue(); + case AstExprKind::If: + return !expr.as<AstIf>().hasElse(); + case AstExprKind::Nop: + case AstExprKind::Drop: + case AstExprKind::Unreachable: + case AstExprKind::Return: + case AstExprKind::SetLocal: + case AstExprKind::Store: + return true; + default: + return false; + } +} + +static bool +PrintIndent(WasmPrintContext& c) +{ + for (uint32_t i = 0; i < c.indent; i++) { + if (!c.buffer.append(" ")) + return false; + } + return true; +} + +static bool +PrintInt32(WasmPrintContext& c, int32_t num, bool printSign = false) +{ + // Negative sign will be printed, printing '+' for non-negative values. + if (printSign && num >= 0) { + if (!c.buffer.append("+")) + return false; + } + return NumberValueToStringBuffer(c.cx, Int32Value(num), c.buffer.stringBuffer()); +} + +static bool +PrintInt64(WasmPrintContext& c, int64_t num) +{ + if (num < 0 && !c.buffer.append("-")) + return false; + if (!num) + return c.buffer.append("0"); + + uint64_t abs = mozilla::Abs(num); + uint64_t n = abs; + uint64_t pow = 1; + while (n) { + pow *= 10; + n /= 10; + } + pow /= 10; + + n = abs; + while (pow) { + if (!c.buffer.append((char16_t)(u'0' + n / pow))) + return false; + n -= (n / pow) * pow; + pow /= 10; + } + + return true; +} + +static bool +PrintDouble(WasmPrintContext& c, RawF64 num) +{ + double d = num.fp(); + if (IsNegativeZero(d)) + return c.buffer.append("-0.0"); + if (IsNaN(d)) + return RenderNaN(c.sb(), num); + if (IsInfinite(d)) { + if (d > 0) + return c.buffer.append("infinity"); + return c.buffer.append("-infinity"); + } + + uint32_t startLength = c.buffer.length(); + if (!NumberValueToStringBuffer(c.cx, DoubleValue(d), c.buffer.stringBuffer())) + return false; + MOZ_ASSERT(startLength < c.buffer.length()); + + // Checking if we need to end number with '.0'. + for (uint32_t i = c.buffer.length() - 1; i >= startLength; i--) { + char16_t ch = c.buffer.getChar(i); + if (ch == '.' || ch == 'e') + return true; + } + return c.buffer.append(".0"); +} + +static bool +PrintFloat32(WasmPrintContext& c, RawF32 num) +{ + float f = num.fp(); + if (IsNaN(f)) + return RenderNaN(c.sb(), num) && c.buffer.append(".f"); + return PrintDouble(c, RawF64(double(f))) && + c.buffer.append("f"); +} + +static bool +PrintEscapedString(WasmPrintContext& c, const AstName& s) +{ + size_t length = s.length(); + const char16_t* p = s.begin(); + for (size_t i = 0; i < length; i++) { + char16_t byte = p[i]; + switch (byte) { + case '\n': + if (!c.buffer.append("\\n")) + return false; + break; + case '\r': + if (!c.buffer.append("\\0d")) + return false; + break; + case '\t': + if (!c.buffer.append("\\t")) + return false; + break; + case '\f': + if (!c.buffer.append("\\0c")) + return false; + break; + case '\b': + if (!c.buffer.append("\\08")) + return false; + break; + case '\\': + if (!c.buffer.append("\\\\")) + return false; + break; + case '"' : + if (!c.buffer.append("\\\"")) + return false; + break; + case '\'': + if (!c.buffer.append("\\'")) + return false; + break; + default: + if (byte >= 32 && byte < 127) { + if (!c.buffer.append((char)byte)) + return false; + } else { + char digit1 = byte / 16, digit2 = byte % 16; + if (!c.buffer.append("\\")) + return false; + if (!c.buffer.append((char)(digit1 < 10 ? digit1 + '0' : digit1 - 10 + 'a'))) + return false; + if (!c.buffer.append((char)(digit2 < 10 ? digit2 + '0' : digit2 - 10 + 'a'))) + return false; + } + break; + } + } + return true; +} + +static bool +PrintExprType(WasmPrintContext& c, ExprType type) +{ + switch (type) { + case ExprType::Void: return true; // ignoring void + case ExprType::I32: return c.buffer.append("i32"); + case ExprType::I64: return c.buffer.append("i64"); + case ExprType::F32: return c.buffer.append("f32"); + case ExprType::F64: return c.buffer.append("f64"); + default:; + } + + MOZ_CRASH("bad type"); +} + +static bool +PrintValType(WasmPrintContext& c, ValType type) +{ + return PrintExprType(c, ToExprType(type)); +} + +static bool +PrintName(WasmPrintContext& c, const AstName& name) +{ + return c.buffer.append(name.begin(), name.end()); +} + +static bool +PrintRef(WasmPrintContext& c, const AstRef& ref) +{ + if (ref.name().empty()) + return PrintInt32(c, ref.index()); + + return PrintName(c, ref.name()); +} + +static bool +PrintExpr(WasmPrintContext& c, AstExpr& expr); + +static bool +PrintBlockLevelExpr(WasmPrintContext& c, AstExpr& expr, bool isLast) +{ + if (!PrintIndent(c)) + return false; + if (!PrintExpr(c, expr)) + return false; + if (!isLast || IsDropValueExpr(expr)) { + if (!c.buffer.append(';')) + return false; + } + return c.buffer.append('\n'); +} + +/*****************************************************************************/ +// binary format parsing and rendering + +static bool +PrintNop(WasmPrintContext& c) +{ + return c.buffer.append("nop"); +} + +static bool +PrintDrop(WasmPrintContext& c, AstDrop& drop) +{ + if (!PrintExpr(c, drop.value())) + return false; + + return true; +} + +static bool +PrintUnreachable(WasmPrintContext& c, AstUnreachable& unreachable) +{ + return c.buffer.append("unreachable"); +} + +static bool +PrintCallArgs(WasmPrintContext& c, const AstExprVector& args) +{ + PrintOperatorPrecedence lastPrecedence = c.currentPrecedence; + c.currentPrecedence = ExpressionPrecedence; + + if (!c.buffer.append("(")) + return false; + for (uint32_t i = 0; i < args.length(); i++) { + if (!PrintExpr(c, *args[i])) + return false; + if (i + 1 == args.length()) + break; + if (!c.buffer.append(", ")) + return false; + } + if (!c.buffer.append(")")) + return false; + + c.currentPrecedence = lastPrecedence; + return true; +} + +static bool +PrintCall(WasmPrintContext& c, AstCall& call) +{ + if (call.op() == Op::Call) { + if (!c.buffer.append("call ")) + return false; + } else { + return false; + } + + if (!PrintRef(c, call.func())) + return false; + + if (!c.buffer.append(" ")) + return false; + + if (!PrintCallArgs(c, call.args())) + return false; + + return true; +} + +static bool +PrintCallIndirect(WasmPrintContext& c, AstCallIndirect& call) +{ + if (!c.buffer.append("call_indirect ")) + return false; + if (!PrintRef(c, call.sig())) + return false; + + if (!c.buffer.append(' ')) + return false; + + if (!PrintCallArgs(c, call.args())) + return false; + + if (!c.buffer.append(" [")) + return false; + + PrintOperatorPrecedence lastPrecedence = c.currentPrecedence; + c.currentPrecedence = ExpressionPrecedence; + + if (!PrintExpr(c, *call.index())) + return false; + + c.currentPrecedence = lastPrecedence; + + if (!c.buffer.append(']')) + return false; + return true; +} + +static bool +PrintConst(WasmPrintContext& c, AstConst& cst) +{ + switch (ToExprType(cst.val().type())) { + case ExprType::I32: + if (!PrintInt32(c, (uint32_t)cst.val().i32())) + return false; + break; + case ExprType::I64: + if (!PrintInt64(c, (uint32_t)cst.val().i64())) + return false; + if (!c.buffer.append("i64")) + return false; + break; + case ExprType::F32: + if (!PrintFloat32(c, cst.val().f32())) + return false; + break; + case ExprType::F64: + if (!PrintDouble(c, cst.val().f64())) + return false; + break; + default: + return false; + } + return true; +} + +static bool +PrintGetLocal(WasmPrintContext& c, AstGetLocal& gl) +{ + if (!PrintRef(c, gl.local())) + return false; + return true; +} + +static bool +PrintSetLocal(WasmPrintContext& c, AstSetLocal& sl) +{ + PrintOperatorPrecedence lastPrecedence = c.currentPrecedence; + + if (!c.f.reduceParens || lastPrecedence > AssignmentPrecedence) { + if (!c.buffer.append("(")) + return false; + } + + if (!PrintRef(c, sl.local())) + return false; + if (!c.buffer.append(" = ")) + return false; + + c.currentPrecedence = AssignmentPrecedence; + + if (!PrintExpr(c, sl.value())) + return false; + + if (!c.f.reduceParens || lastPrecedence > AssignmentPrecedence) { + if (!c.buffer.append(")")) + return false; + } + + c.currentPrecedence = lastPrecedence; + return true; +} + +static bool +PrintTeeLocal(WasmPrintContext& c, AstTeeLocal& sl) +{ + PrintOperatorPrecedence lastPrecedence = c.currentPrecedence; + + if (!c.f.reduceParens || lastPrecedence > AssignmentPrecedence) { + if (!c.buffer.append("(")) + return false; + } + + if (!PrintRef(c, sl.local())) + return false; + if (!c.buffer.append(" = ")) + return false; + + c.currentPrecedence = AssignmentPrecedence; + + if (!PrintExpr(c, sl.value())) + return false; + + if (!c.f.reduceParens || lastPrecedence > AssignmentPrecedence) { + if (!c.buffer.append(")")) + return false; + } + + c.currentPrecedence = lastPrecedence; + return true; +} + +static bool +PrintGetGlobal(WasmPrintContext& c, AstGetGlobal& gg) +{ + return PrintRef(c, gg.global()); +} + +static bool +PrintSetGlobal(WasmPrintContext& c, AstSetGlobal& sg) +{ + PrintOperatorPrecedence lastPrecedence = c.currentPrecedence; + + if (!c.f.reduceParens || lastPrecedence > AssignmentPrecedence) { + if (!c.buffer.append("(")) + return false; + } + + if (!PrintRef(c, sg.global())) + return false; + if (!c.buffer.append(" = ")) + return false; + + c.currentPrecedence = AssignmentPrecedence; + + if (!PrintExpr(c, sg.value())) + return false; + + if (!c.f.reduceParens || lastPrecedence > AssignmentPrecedence) { + if (!c.buffer.append(")")) + return false; + } + + c.currentPrecedence = lastPrecedence; + return true; +} + +static bool +PrintExprList(WasmPrintContext& c, const AstExprVector& exprs, uint32_t startFrom = 0) +{ + for (uint32_t i = startFrom; i < exprs.length(); i++) { + if (!PrintBlockLevelExpr(c, *exprs[i], i + 1 == exprs.length())) + return false; + } + return true; +} + +static bool +PrintGroupedBlock(WasmPrintContext& c, AstBlock& block) +{ + uint32_t skip = 0; + if (block.exprs().length() > 0 && + block.exprs()[0]->kind() == AstExprKind::Block) { + if (!PrintGroupedBlock(c, *static_cast<AstBlock*>(block.exprs()[0]))) + return false; + skip = 1; + } + c.indent++; + if (!PrintExprList(c, block.exprs(), skip)) + return false; + c.indent--; + if (!PrintIndent(c)) + return false; + + // If no br/br_if/br_table refer this block, use some non-existent label. + if (block.name().empty()) + return c.buffer.append("$label:\n"); + + if (!PrintName(c, block.name())) + return false; + if (!c.buffer.append(":\n")) + return false; + return true; +} + +static bool +PrintBlockName(WasmPrintContext& c, const AstName& name) { + if (name.empty()) + return true; + + if (!PrintIndent(c)) + return false; + if (!PrintName(c, name)) + return false; + return c.buffer.append(":\n"); +} + +static bool +PrintBlock(WasmPrintContext& c, AstBlock& block) +{ + PrintOperatorPrecedence lastPrecedence = c.currentPrecedence; + if (block.op() == Op::Block) { + if (!c.buffer.append("{\n")) + return false; + } else if (block.op() == Op::Loop) { + if (!c.buffer.append("loop")) + return false; + if (!block.name().empty()) { + if (!c.buffer.append(" ")) + return false; + if (!PrintName(c, block.name())) + return false; + } + if (!c.buffer.append(" {\n")) + return false; + } else + return false; + + c.currentPrecedence = ExpressionPrecedence; + + bool skip = 0; + if (c.f.groupBlocks && block.op() == Op::Block && + block.exprs().length() > 0 && block.exprs()[0]->kind() == AstExprKind::Block) + { + AstBlock* innerBlock = static_cast<AstBlock*>(block.exprs()[0]); + if (innerBlock->op() == Op::Block) { + if (!PrintGroupedBlock(c, *innerBlock)) + return false; + skip = 1; + if (block.exprs().length() == 1 && block.name().empty()) { + // Special case to resolve ambiguity in parsing of optional end block label. + if (!PrintIndent(c)) + return false; + if (!c.buffer.append("$exit$:\n")) + return false; + } + } + } + + c.indent++; + if (!PrintExprList(c, block.exprs(), skip)) + return false; + c.indent--; + c.currentPrecedence = lastPrecedence; + + if (block.op() != Op::Loop) { + if (!PrintBlockName(c, block.name())) + return false; + } + + if (!PrintIndent(c)) + return false; + + return c.buffer.append("}"); +} + +static bool +PrintUnaryOperator(WasmPrintContext& c, AstUnaryOperator& unary) +{ + PrintOperatorPrecedence lastPrecedence = c.currentPrecedence; + + const char* opStr; + const char* prefixStr = nullptr; + PrintOperatorPrecedence precedence = OperatorPrecedence; + switch (unary.op()) { + case Op::I32Clz: opStr = "i32.clz"; break; + case Op::I32Ctz: opStr = "i32.ctz"; break; + case Op::I32Popcnt: opStr = "i32.popcnt"; break; + case Op::I64Clz: opStr = "i64.clz"; break; + case Op::I64Ctz: opStr = "i64.ctz"; break; + case Op::I64Popcnt: opStr = "i64.popcnt"; break; + case Op::F32Abs: opStr = "f32.abs"; break; + case Op::F32Neg: opStr = "f32.neg"; prefixStr = "-"; precedence = NegatePrecedence; break; + case Op::F32Ceil: opStr = "f32.ceil"; break; + case Op::F32Floor: opStr = "f32.floor"; break; + case Op::F32Sqrt: opStr = "f32.sqrt"; break; + case Op::F32Trunc: opStr = "f32.trunc"; break; + case Op::F32Nearest: opStr = "f32.nearest"; break; + case Op::F64Abs: opStr = "f64.abs"; break; + case Op::F64Neg: opStr = "f64.neg"; prefixStr = "-"; precedence = NegatePrecedence; break; + case Op::F64Ceil: opStr = "f64.ceil"; break; + case Op::F64Floor: opStr = "f64.floor"; break; + case Op::F64Sqrt: opStr = "f64.sqrt"; break; + default: return false; + } + + if (c.f.allowAsciiOperators && prefixStr) { + if (!c.f.reduceParens || lastPrecedence > precedence) { + if (!c.buffer.append("(")) + return false; + } + + c.currentPrecedence = precedence; + if (!c.buffer.append(prefixStr, strlen(prefixStr))) + return false; + if (!PrintExpr(c, *unary.operand())) + return false; + + if (!c.f.reduceParens || lastPrecedence > precedence) { + if (!c.buffer.append(")")) + return false; + } + } else { + if (!c.buffer.append(opStr, strlen(opStr))) + return false; + if (!c.buffer.append("(")) + return false; + + c.currentPrecedence = ExpressionPrecedence; + if (!PrintExpr(c, *unary.operand())) + return false; + + if (!c.buffer.append(")")) + return false; + } + c.currentPrecedence = lastPrecedence; + + return true; +} + +static bool +PrintBinaryOperator(WasmPrintContext& c, AstBinaryOperator& binary) +{ + PrintOperatorPrecedence lastPrecedence = c.currentPrecedence; + + const char* opStr; + const char* infixStr = nullptr; + PrintOperatorPrecedence precedence; + switch (binary.op()) { + case Op::I32Add: opStr = "i32.add"; infixStr = "+"; precedence = AdditionPrecedence; break; + case Op::I32Sub: opStr = "i32.sub"; infixStr = "-"; precedence = AdditionPrecedence; break; + case Op::I32Mul: opStr = "i32.mul"; infixStr = "*"; precedence = MultiplicationPrecedence; break; + case Op::I32DivS: opStr = "i32.div_s"; infixStr = "/s"; precedence = MultiplicationPrecedence; break; + case Op::I32DivU: opStr = "i32.div_u"; infixStr = "/u"; precedence = MultiplicationPrecedence; break; + case Op::I32RemS: opStr = "i32.rem_s"; infixStr = "%s"; precedence = MultiplicationPrecedence; break; + case Op::I32RemU: opStr = "i32.rem_u"; infixStr = "%u"; precedence = MultiplicationPrecedence; break; + case Op::I32And: opStr = "i32.and"; infixStr = "&"; precedence = BitwiseAndPrecedence; break; + case Op::I32Or: opStr = "i32.or"; infixStr = "|"; precedence = BitwiseOrPrecedence; break; + case Op::I32Xor: opStr = "i32.xor"; infixStr = "^"; precedence = BitwiseXorPrecedence; break; + case Op::I32Shl: opStr = "i32.shl"; infixStr = "<<"; precedence = BitwiseShiftPrecedence; break; + case Op::I32ShrS: opStr = "i32.shr_s"; infixStr = ">>s"; precedence = BitwiseShiftPrecedence; break; + case Op::I32ShrU: opStr = "i32.shr_u"; infixStr = ">>u"; precedence = BitwiseShiftPrecedence; break; + case Op::I64Add: opStr = "i64.add"; infixStr = "+"; precedence = AdditionPrecedence; break; + case Op::I64Sub: opStr = "i64.sub"; infixStr = "-"; precedence = AdditionPrecedence; break; + case Op::I64Mul: opStr = "i64.mul"; infixStr = "*"; precedence = MultiplicationPrecedence; break; + case Op::I64DivS: opStr = "i64.div_s"; infixStr = "/s"; precedence = MultiplicationPrecedence; break; + case Op::I64DivU: opStr = "i64.div_u"; infixStr = "/u"; precedence = MultiplicationPrecedence; break; + case Op::I64RemS: opStr = "i64.rem_s"; infixStr = "%s"; precedence = MultiplicationPrecedence; break; + case Op::I64RemU: opStr = "i64.rem_u"; infixStr = "%u"; precedence = MultiplicationPrecedence; break; + case Op::I64And: opStr = "i64.and"; infixStr = "&"; precedence = BitwiseAndPrecedence; break; + case Op::I64Or: opStr = "i64.or"; infixStr = "|"; precedence = BitwiseOrPrecedence; break; + case Op::I64Xor: opStr = "i64.xor"; infixStr = "^"; precedence = BitwiseXorPrecedence; break; + case Op::I64Shl: opStr = "i64.shl"; infixStr = "<<"; precedence = BitwiseShiftPrecedence; break; + case Op::I64ShrS: opStr = "i64.shr_s"; infixStr = ">>s"; precedence = BitwiseShiftPrecedence; break; + case Op::I64ShrU: opStr = "i64.shr_u"; infixStr = ">>u"; precedence = BitwiseShiftPrecedence; break; + case Op::F32Add: opStr = "f32.add"; infixStr = "+"; precedence = AdditionPrecedence; break; + case Op::F32Sub: opStr = "f32.sub"; infixStr = "-"; precedence = AdditionPrecedence; break; + case Op::F32Mul: opStr = "f32.mul"; infixStr = "*"; precedence = MultiplicationPrecedence; break; + case Op::F32Div: opStr = "f32.div"; infixStr = "/"; precedence = MultiplicationPrecedence; break; + case Op::F32Min: opStr = "f32.min"; precedence = OperatorPrecedence; break; + case Op::F32Max: opStr = "f32.max"; precedence = OperatorPrecedence; break; + case Op::F32CopySign: opStr = "f32.copysign"; precedence = OperatorPrecedence; break; + case Op::F64Add: opStr = "f64.add"; infixStr = "+"; precedence = AdditionPrecedence; break; + case Op::F64Sub: opStr = "f64.sub"; infixStr = "-"; precedence = AdditionPrecedence; break; + case Op::F64Mul: opStr = "f64.mul"; infixStr = "*"; precedence = MultiplicationPrecedence; break; + case Op::F64Div: opStr = "f64.div"; infixStr = "/"; precedence = MultiplicationPrecedence; break; + case Op::F64Min: opStr = "f64.min"; precedence = OperatorPrecedence; break; + case Op::F64Max: opStr = "f64.max"; precedence = OperatorPrecedence; break; + case Op::F64CopySign: opStr = "f64.copysign"; precedence = OperatorPrecedence; break; + default: return false; + } + + if (c.f.allowAsciiOperators && infixStr) { + if (!c.f.reduceParens || lastPrecedence > precedence) { + if (!c.buffer.append("(")) + return false; + } + + c.currentPrecedence = precedence; + if (!PrintExpr(c, *binary.lhs())) + return false; + if (!c.buffer.append(" ")) + return false; + if (!c.buffer.append(infixStr, strlen(infixStr))) + return false; + if (!c.buffer.append(" ")) + return false; + // case of A / (B / C) + c.currentPrecedence = (PrintOperatorPrecedence)(precedence + 1); + + if (!PrintExpr(c, *binary.rhs())) + return false; + if (!c.f.reduceParens || lastPrecedence > precedence) { + if (!c.buffer.append(")")) + return false; + } + } else { + if (!c.buffer.append(opStr, strlen(opStr))) + return false; + if (!c.buffer.append("(")) + return false; + + c.currentPrecedence = ExpressionPrecedence; + if (!PrintExpr(c, *binary.lhs())) + return false; + if (!c.buffer.append(", ")) + return false; + if (!PrintExpr(c, *binary.rhs())) + return false; + + if (!c.buffer.append(")")) + return false; + } + c.currentPrecedence = lastPrecedence; + + return true; +} + +static bool +PrintTernaryOperator(WasmPrintContext& c, AstTernaryOperator& ternary) +{ + PrintOperatorPrecedence lastPrecedence = c.currentPrecedence; + + const char* opStr; + switch (ternary.op()) { + case Op::Select: opStr = "select"; break; + default: return false; + } + + if (!c.buffer.append(opStr, strlen(opStr))) + return false; + if (!c.buffer.append("(")) + return false; + + c.currentPrecedence = ExpressionPrecedence; + if (!PrintExpr(c, *ternary.op0())) + return false; + if (!c.buffer.append(", ")) + return false; + if (!PrintExpr(c, *ternary.op1())) + return false; + if (!c.buffer.append(", ")) + return false; + if (!PrintExpr(c, *ternary.op2())) + return false; + + if (!c.buffer.append(")")) + return false; + c.currentPrecedence = lastPrecedence; + + return true; +} + +static bool +PrintComparisonOperator(WasmPrintContext& c, AstComparisonOperator& comp) +{ + PrintOperatorPrecedence lastPrecedence = c.currentPrecedence; + + const char* opStr; + const char* infixStr = nullptr; + PrintOperatorPrecedence precedence; + switch (comp.op()) { + case Op::I32Eq: opStr = "i32.eq"; infixStr = "=="; precedence = EqualityPrecedence; break; + case Op::I32Ne: opStr = "i32.ne"; infixStr = "!="; precedence = EqualityPrecedence; break; + case Op::I32LtS: opStr = "i32.lt_s"; infixStr = "<s"; precedence = ComparisonPrecedence; break; + case Op::I32LtU: opStr = "i32.lt_u"; infixStr = "<u"; precedence = ComparisonPrecedence; break; + case Op::I32LeS: opStr = "i32.le_s"; infixStr = "<=s"; precedence = ComparisonPrecedence; break; + case Op::I32LeU: opStr = "i32.le_u"; infixStr = "<=u"; precedence = ComparisonPrecedence; break; + case Op::I32GtS: opStr = "i32.gt_s"; infixStr = ">s"; precedence = ComparisonPrecedence; break; + case Op::I32GtU: opStr = "i32.gt_u"; infixStr = ">u"; precedence = ComparisonPrecedence; break; + case Op::I32GeS: opStr = "i32.ge_s"; infixStr = ">=s"; precedence = ComparisonPrecedence; break; + case Op::I32GeU: opStr = "i32.ge_u"; infixStr = ">=u"; precedence = ComparisonPrecedence; break; + case Op::I64Eq: opStr = "i64.eq"; infixStr = "=="; precedence = EqualityPrecedence; break; + case Op::I64Ne: opStr = "i64.ne"; infixStr = "!="; precedence = EqualityPrecedence; break; + case Op::I64LtS: opStr = "i64.lt_s"; infixStr = "<s"; precedence = ComparisonPrecedence; break; + case Op::I64LtU: opStr = "i64.lt_u"; infixStr = "<u"; precedence = ComparisonPrecedence; break; + case Op::I64LeS: opStr = "i64.le_s"; infixStr = "<=s"; precedence = ComparisonPrecedence; break; + case Op::I64LeU: opStr = "i64.le_u"; infixStr = "<=u"; precedence = ComparisonPrecedence; break; + case Op::I64GtS: opStr = "i64.gt_s"; infixStr = ">s"; precedence = ComparisonPrecedence; break; + case Op::I64GtU: opStr = "i64.gt_u"; infixStr = ">u"; precedence = ComparisonPrecedence; break; + case Op::I64GeS: opStr = "i64.ge_s"; infixStr = ">=s"; precedence = ComparisonPrecedence; break; + case Op::I64GeU: opStr = "i64.ge_u"; infixStr = ">=u"; precedence = ComparisonPrecedence; break; + case Op::F32Eq: opStr = "f32.eq"; infixStr = "=="; precedence = EqualityPrecedence; break; + case Op::F32Ne: opStr = "f32.ne"; infixStr = "!="; precedence = EqualityPrecedence; break; + case Op::F32Lt: opStr = "f32.lt"; infixStr = "<"; precedence = ComparisonPrecedence; break; + case Op::F32Le: opStr = "f32.le"; infixStr = "<="; precedence = ComparisonPrecedence; break; + case Op::F32Gt: opStr = "f32.gt"; infixStr = ">"; precedence = ComparisonPrecedence; break; + case Op::F32Ge: opStr = "f32.ge"; infixStr = ">="; precedence = ComparisonPrecedence; break; + case Op::F64Eq: opStr = "f64.eq"; infixStr = "=="; precedence = ComparisonPrecedence; break; + case Op::F64Ne: opStr = "f64.ne"; infixStr = "!="; precedence = EqualityPrecedence; break; + case Op::F64Lt: opStr = "f64.lt"; infixStr = "<"; precedence = EqualityPrecedence; break; + case Op::F64Le: opStr = "f64.le"; infixStr = "<="; precedence = ComparisonPrecedence; break; + case Op::F64Gt: opStr = "f64.gt"; infixStr = ">"; precedence = ComparisonPrecedence; break; + case Op::F64Ge: opStr = "f64.ge"; infixStr = ">="; precedence = ComparisonPrecedence; break; + default: return false; + } + + if (c.f.allowAsciiOperators && infixStr) { + if (!c.f.reduceParens || lastPrecedence > precedence) { + if (!c.buffer.append("(")) + return false; + } + c.currentPrecedence = precedence; + if (!PrintExpr(c, *comp.lhs())) + return false; + if (!c.buffer.append(" ")) + return false; + if (!c.buffer.append(infixStr, strlen(infixStr))) + return false; + if (!c.buffer.append(" ")) + return false; + // case of A == (B == C) + c.currentPrecedence = (PrintOperatorPrecedence)(precedence + 1); + if (!PrintExpr(c, *comp.rhs())) + return false; + if (!c.f.reduceParens || lastPrecedence > precedence) { + if (!c.buffer.append(")")) + return false; + } + } else { + if (!c.buffer.append(opStr, strlen(opStr))) + return false; + c.currentPrecedence = ExpressionPrecedence; + if (!c.buffer.append("(")) + return false; + if (!PrintExpr(c, *comp.lhs())) + return false; + if (!c.buffer.append(", ")) + return false; + if (!PrintExpr(c, *comp.rhs())) + return false; + if (!c.buffer.append(")")) + return false; + } + c.currentPrecedence = lastPrecedence; + + return true; +} + +static bool +PrintConversionOperator(WasmPrintContext& c, AstConversionOperator& conv) +{ + PrintOperatorPrecedence lastPrecedence = c.currentPrecedence; + + const char* opStr; + const char* prefixStr = nullptr; + PrintOperatorPrecedence precedence = ExpressionPrecedence; + switch (conv.op()) { + case Op::I32Eqz: opStr = "i32.eqz"; prefixStr = "!"; precedence = EqzPrecedence; break; + case Op::I32WrapI64: opStr = "i32.wrap/i64"; break; + case Op::I32TruncSF32: opStr = "i32.trunc_s/f32"; break; + case Op::I32TruncUF32: opStr = "i32.trunc_u/f32"; break; + case Op::I32ReinterpretF32: opStr = "i32.reinterpret/f32"; break; + case Op::I32TruncSF64: opStr = "i32.trunc_s/f64"; break; + case Op::I32TruncUF64: opStr = "i32.trunc_u/f64"; break; + case Op::I64Eqz: opStr = "i64.eqz"; prefixStr = "!"; precedence = EqzPrecedence; break; + case Op::I64ExtendSI32: opStr = "i64.extend_s/i32"; break; + case Op::I64ExtendUI32: opStr = "i64.extend_u/i32"; break; + case Op::I64TruncSF32: opStr = "i64.trunc_s/f32"; break; + case Op::I64TruncUF32: opStr = "i64.trunc_u/f32"; break; + case Op::I64TruncSF64: opStr = "i64.trunc_s/f64"; break; + case Op::I64TruncUF64: opStr = "i64.trunc_u/f64"; break; + case Op::I64ReinterpretF64: opStr = "i64.reinterpret/f64"; break; + case Op::F32ConvertSI32: opStr = "f32.convert_s/i32"; break; + case Op::F32ConvertUI32: opStr = "f32.convert_u/i32"; break; + case Op::F32ReinterpretI32: opStr = "f32.reinterpret/i32"; break; + case Op::F32ConvertSI64: opStr = "f32.convert_s/i64"; break; + case Op::F32ConvertUI64: opStr = "f32.convert_u/i64"; break; + case Op::F32DemoteF64: opStr = "f32.demote/f64"; break; + case Op::F64ConvertSI32: opStr = "f64.convert_s/i32"; break; + case Op::F64ConvertUI32: opStr = "f64.convert_u/i32"; break; + case Op::F64ConvertSI64: opStr = "f64.convert_s/i64"; break; + case Op::F64ConvertUI64: opStr = "f64.convert_u/i64"; break; + case Op::F64ReinterpretI64: opStr = "f64.reinterpret/i64"; break; + case Op::F64PromoteF32: opStr = "f64.promote/f32"; break; + default: return false; + } + + if (c.f.allowAsciiOperators && prefixStr) { + if (!c.f.reduceParens || lastPrecedence > precedence) { + if (!c.buffer.append("(")) + return false; + } + + c.currentPrecedence = precedence; + if (!c.buffer.append(prefixStr, strlen(prefixStr))) + return false; + if (!PrintExpr(c, *conv.operand())) + return false; + + if (!c.f.reduceParens || lastPrecedence > precedence) { + if (!c.buffer.append(")")) + return false; + } + } else { + if (!c.buffer.append(opStr, strlen(opStr))) + return false; + if (!c.buffer.append("(")) + return false; + + c.currentPrecedence = ExpressionPrecedence; + if (!PrintExpr(c, *conv.operand())) + return false; + + if (!c.buffer.append(")")) + return false; + } + c.currentPrecedence = lastPrecedence; + + return true; +} + +static bool +PrintIf(WasmPrintContext& c, AstIf& if_) +{ + PrintOperatorPrecedence lastPrecedence = c.currentPrecedence; + + c.currentPrecedence = ExpressionPrecedence; + if (!c.buffer.append("if (")) + return false; + if (!PrintExpr(c, if_.cond())) + return false; + + if (!c.buffer.append(") {\n")) + return false; + + c.indent++; + if (!PrintExprList(c, if_.thenExprs())) + return false; + c.indent--; + + if (!PrintBlockName(c, if_.name())) + return false; + + if (if_.hasElse()) { + if (!PrintIndent(c)) + return false; + if (!c.buffer.append("} else {\n")) + return false; + + c.indent++; + if (!PrintExprList(c, if_.elseExprs())) + return false; + c.indent--; + if (!PrintBlockName(c, if_.name())) + return false; + } + + if (!PrintIndent(c)) + return false; + + c.currentPrecedence = lastPrecedence; + + return c.buffer.append("}"); +} + +static bool +PrintLoadStoreAddress(WasmPrintContext& c, const AstLoadStoreAddress& lsa, uint32_t defaultAlignLog2) +{ + PrintOperatorPrecedence lastPrecedence = c.currentPrecedence; + + c.currentPrecedence = ExpressionPrecedence; + + if (!c.buffer.append("[")) + return false; + if (!PrintExpr(c, lsa.base())) + return false; + + if (lsa.offset() != 0) { + if (!c.buffer.append(", ")) + return false; + if (!PrintInt32(c, lsa.offset(), true)) + return false; + } + if (!c.buffer.append("]")) + return false; + + uint32_t alignLog2 = lsa.flags(); + if (defaultAlignLog2 != alignLog2) { + if (!c.buffer.append(", align=")) + return false; + if (!PrintInt32(c, 1 << alignLog2)) + return false; + } + + c.currentPrecedence = lastPrecedence; + return true; +} + +static bool +PrintLoad(WasmPrintContext& c, AstLoad& load) +{ + PrintOperatorPrecedence lastPrecedence = c.currentPrecedence; + + c.currentPrecedence = LoadOperatorPrecedence; + if (!c.f.reduceParens || lastPrecedence > LoadOperatorPrecedence) { + if (!c.buffer.append("(")) + return false; + } + + uint32_t defaultAlignLog2; + switch (load.op()) { + case Op::I32Load8S: + if (!c.buffer.append("i32:8s")) + return false; + defaultAlignLog2 = 0; + break; + case Op::I64Load8S: + if (!c.buffer.append("i64:8s")) + return false; + defaultAlignLog2 = 0; + break; + case Op::I32Load8U: + if (!c.buffer.append("i32:8u")) + return false; + defaultAlignLog2 = 0; + break; + case Op::I64Load8U: + if (!c.buffer.append("i64:8u")) + return false; + defaultAlignLog2 = 0; + break; + case Op::I32Load16S: + if (!c.buffer.append("i32:16s")) + return false; + defaultAlignLog2 = 1; + break; + case Op::I64Load16S: + if (!c.buffer.append("i64:16s")) + return false; + defaultAlignLog2 = 1; + break; + case Op::I32Load16U: + if (!c.buffer.append("i32:16u")) + return false; + defaultAlignLog2 = 1; + break; + case Op::I64Load16U: + if (!c.buffer.append("i64:16u")) + return false; + defaultAlignLog2 = 1; + break; + case Op::I64Load32S: + if (!c.buffer.append("i64:32s")) + return false; + defaultAlignLog2 = 2; + break; + case Op::I64Load32U: + if (!c.buffer.append("i64:32u")) + return false; + defaultAlignLog2 = 2; + break; + case Op::I32Load: + if (!c.buffer.append("i32")) + return false; + defaultAlignLog2 = 2; + break; + case Op::I64Load: + if (!c.buffer.append("i64")) + return false; + defaultAlignLog2 = 3; + break; + case Op::F32Load: + if (!c.buffer.append("f32")) + return false; + defaultAlignLog2 = 2; + break; + case Op::F64Load: + if (!c.buffer.append("f64")) + return false; + defaultAlignLog2 = 3; + break; + default: + return false; + } + + if (!PrintLoadStoreAddress(c, load.address(), defaultAlignLog2)) + return false; + + if (!c.f.reduceParens || lastPrecedence > LoadOperatorPrecedence) { + if (!c.buffer.append(")")) + return false; + } + c.currentPrecedence = lastPrecedence; + + return true; +} + +static bool +PrintStore(WasmPrintContext& c, AstStore& store) +{ + PrintOperatorPrecedence lastPrecedence = c.currentPrecedence; + + c.currentPrecedence = StoreOperatorPrecedence; + if (!c.f.reduceParens || lastPrecedence > StoreOperatorPrecedence) { + if (!c.buffer.append("(")) + return false; + } + + uint32_t defaultAlignLog2; + switch (store.op()) { + case Op::I32Store8: + if (!c.buffer.append("i32:8")) + return false; + defaultAlignLog2 = 0; + break; + case Op::I64Store8: + if (!c.buffer.append("i64:8")) + return false; + defaultAlignLog2 = 0; + break; + case Op::I32Store16: + if (!c.buffer.append("i32:16")) + return false; + defaultAlignLog2 = 1; + break; + case Op::I64Store16: + if (!c.buffer.append("i64:16")) + return false; + defaultAlignLog2 = 1; + break; + case Op::I64Store32: + if (!c.buffer.append("i64:32")) + return false; + defaultAlignLog2 = 2; + break; + case Op::I32Store: + if (!c.buffer.append("i32")) + return false; + defaultAlignLog2 = 2; + break; + case Op::I64Store: + if (!c.buffer.append("i64")) + return false; + defaultAlignLog2 = 3; + break; + case Op::F32Store: + if (!c.buffer.append("f32")) + return false; + defaultAlignLog2 = 2; + break; + case Op::F64Store: + if (!c.buffer.append("f64")) + return false; + defaultAlignLog2 = 3; + break; + default: + return false; + } + + if (!PrintLoadStoreAddress(c, store.address(), defaultAlignLog2)) + return false; + + if (!c.buffer.append(" = ")) + return false; + + if (!PrintExpr(c, store.value())) + return false; + + if (!c.f.reduceParens || lastPrecedence > StoreOperatorPrecedence) { + if (!c.buffer.append(")")) + return false; + } + + c.currentPrecedence = lastPrecedence; + return true; +} + +static bool +PrintBranch(WasmPrintContext& c, AstBranch& branch) +{ + Op op = branch.op(); + MOZ_ASSERT(op == Op::BrIf || op == Op::Br); + + if (op == Op::BrIf ? !c.buffer.append("br_if ") : !c.buffer.append("br ")) + return false; + + if (op == Op::BrIf || branch.maybeValue()) { + if (!c.buffer.append('(')) + return false; + } + + if (op == Op::BrIf) { + if (!PrintExpr(c, branch.cond())) + return false; + } + + if (branch.maybeValue()) { + if (!c.buffer.append(", ")) + return false; + + if (!PrintExpr(c, *(branch.maybeValue()))) + return false; + } + + if (op == Op::BrIf || branch.maybeValue()) { + if (!c.buffer.append(") ")) + return false; + } + + if (!PrintRef(c, branch.target())) + return false; + + return true; +} + +static bool +PrintBrTable(WasmPrintContext& c, AstBranchTable& table) +{ + if (!c.buffer.append("br_table ")) + return false; + + if (!c.buffer.append('(')) + return false; + + // Index + if (!PrintExpr(c, table.index())) + return false; + + if (table.maybeValue()) { + if (!c.buffer.append(", ")) + return false; + + if (!PrintExpr(c, *(table.maybeValue()))) + return false; + } + + if (!c.buffer.append(") ")) + return false; + + uint32_t tableLength = table.table().length(); + if (tableLength > 0) { + if (!c.buffer.append("[")) + return false; + for (uint32_t i = 0; i < tableLength; i++) { + if (!PrintRef(c, table.table()[i])) + return false; + if (i + 1 == tableLength) + break; + if (!c.buffer.append(", ")) + return false; + } + if (!c.buffer.append("], ")) + return false; + } + + if (!PrintRef(c, table.def())) + return false; + + return true; +} + +static bool +PrintReturn(WasmPrintContext& c, AstReturn& ret) +{ + if (!c.buffer.append("return")) + return false; + + if (ret.maybeExpr()) { + if (!c.buffer.append(" ")) + return false; + if (!PrintExpr(c, *(ret.maybeExpr()))) + return false; + } + + return true; +} + +static bool +PrintFirst(WasmPrintContext& c, AstFirst& first) +{ + if (!c.buffer.append("first(")) + return false; + + for (uint32_t i = 0; i < first.exprs().length(); i++) { + if (!PrintExpr(c, *first.exprs()[i])) + return false; + if (i + 1 == first.exprs().length()) + break; + if (!c.buffer.append(", ")) + return false; + } + + if (!c.buffer.append(")")) + return false; + + return true; +} + +static bool +PrintCurrentMemory(WasmPrintContext& c, AstCurrentMemory& cm) +{ + return c.buffer.append("current_memory"); +} + +static bool +PrintGrowMemory(WasmPrintContext& c, AstGrowMemory& gm) +{ + if (!c.buffer.append("grow_memory(")) + return false; + + PrintOperatorPrecedence lastPrecedence = c.currentPrecedence; + c.currentPrecedence = ExpressionPrecedence; + + if (!PrintExpr(c, *gm.operand())) + return false; + + if (!c.buffer.append(")")) + return false; + + c.currentPrecedence = lastPrecedence; + return true; +} + +static bool +PrintExpr(WasmPrintContext& c, AstExpr& expr) +{ + if (c.maybeSourceMap) { + uint32_t lineno = c.buffer.lineno(); + uint32_t column = c.buffer.column(); + if (!c.maybeSourceMap->exprlocs().emplaceBack(lineno, column, expr.offset())) + return false; + } + + switch (expr.kind()) { + case AstExprKind::Nop: + return PrintNop(c); + case AstExprKind::Drop: + return PrintDrop(c, expr.as<AstDrop>()); + case AstExprKind::Unreachable: + return PrintUnreachable(c, expr.as<AstUnreachable>()); + case AstExprKind::Call: + return PrintCall(c, expr.as<AstCall>()); + case AstExprKind::CallIndirect: + return PrintCallIndirect(c, expr.as<AstCallIndirect>()); + case AstExprKind::Const: + return PrintConst(c, expr.as<AstConst>()); + case AstExprKind::GetLocal: + return PrintGetLocal(c, expr.as<AstGetLocal>()); + case AstExprKind::SetLocal: + return PrintSetLocal(c, expr.as<AstSetLocal>()); + case AstExprKind::TeeLocal: + return PrintTeeLocal(c, expr.as<AstTeeLocal>()); + case AstExprKind::GetGlobal: + return PrintGetGlobal(c, expr.as<AstGetGlobal>()); + case AstExprKind::SetGlobal: + return PrintSetGlobal(c, expr.as<AstSetGlobal>()); + case AstExprKind::Block: + return PrintBlock(c, expr.as<AstBlock>()); + case AstExprKind::If: + return PrintIf(c, expr.as<AstIf>()); + case AstExprKind::UnaryOperator: + return PrintUnaryOperator(c, expr.as<AstUnaryOperator>()); + case AstExprKind::BinaryOperator: + return PrintBinaryOperator(c, expr.as<AstBinaryOperator>()); + case AstExprKind::TernaryOperator: + return PrintTernaryOperator(c, expr.as<AstTernaryOperator>()); + case AstExprKind::ComparisonOperator: + return PrintComparisonOperator(c, expr.as<AstComparisonOperator>()); + case AstExprKind::ConversionOperator: + return PrintConversionOperator(c, expr.as<AstConversionOperator>()); + case AstExprKind::Load: + return PrintLoad(c, expr.as<AstLoad>()); + case AstExprKind::Store: + return PrintStore(c, expr.as<AstStore>()); + case AstExprKind::Branch: + return PrintBranch(c, expr.as<AstBranch>()); + case AstExprKind::BranchTable: + return PrintBrTable(c, expr.as<AstBranchTable>()); + case AstExprKind::Return: + return PrintReturn(c, expr.as<AstReturn>()); + case AstExprKind::First: + return PrintFirst(c, expr.as<AstFirst>()); + case AstExprKind::CurrentMemory: + return PrintCurrentMemory(c, expr.as<AstCurrentMemory>()); + case AstExprKind::GrowMemory: + return PrintGrowMemory(c, expr.as<AstGrowMemory>()); + case AstExprKind::Pop: + return true; + } + + MOZ_CRASH("Bad AstExprKind"); +} + +static bool +PrintSignature(WasmPrintContext& c, const AstSig& sig, const AstNameVector* maybeLocals = nullptr) +{ + uint32_t paramsNum = sig.args().length(); + + if (!c.buffer.append("(")) + return false; + if (maybeLocals) { + for (uint32_t i = 0; i < paramsNum; i++) { + const AstName& name = (*maybeLocals)[i]; + if (!name.empty()) { + if (!PrintName(c, name)) + return false; + if (!c.buffer.append(": ")) + return false; + } + ValType arg = sig.args()[i]; + if (!PrintValType(c, arg)) + return false; + if (i + 1 == paramsNum) + break; + if (!c.buffer.append(", ")) + return false; + } + } else if (paramsNum > 0) { + for (uint32_t i = 0; i < paramsNum; i++) { + ValType arg = sig.args()[i]; + if (!PrintValType(c, arg)) + return false; + if (i + 1 == paramsNum) + break; + if (!c.buffer.append(", ")) + return false; + } + } + if (!c.buffer.append(") : (")) + return false; + if (sig.ret() != ExprType::Void) { + if (!PrintExprType(c, sig.ret())) + return false; + } + if (!c.buffer.append(")")) + return false; + return true; +} + +static bool +PrintTypeSection(WasmPrintContext& c, const AstModule::SigVector& sigs) +{ + uint32_t numSigs = sigs.length(); + if (!numSigs) + return true; + + for (uint32_t sigIndex = 0; sigIndex < numSigs; sigIndex++) { + const AstSig* sig = sigs[sigIndex]; + if (!PrintIndent(c)) + return false; + if (!c.buffer.append("type ")) + return false; + if (!sig->name().empty()) { + if (!PrintName(c, sig->name())) + return false; + if (!c.buffer.append(" of ")) + return false; + } + if (!c.buffer.append("function ")) + return false; + if (!PrintSignature(c, *sig)) + return false; + if (!c.buffer.append(";\n")) + return false; + } + + if (!c.buffer.append("\n")) + return false; + + return true; +} + +static bool +PrintTableSection(WasmPrintContext& c, const AstModule& module) +{ + if (module.elemSegments().empty()) + return true; + + const AstElemSegment& segment = *module.elemSegments()[0]; + + if (!c.buffer.append("table [")) + return false; + + for (uint32_t i = 0; i < segment.elems().length(); i++) { + const AstRef& elem = segment.elems()[i]; + uint32_t index = elem.index(); + AstName name = index < module.funcImportNames().length() + ? module.funcImportNames()[index] + : module.funcs()[index - module.funcImportNames().length()]->name(); + if (name.empty()) { + if (!PrintInt32(c, index)) + return false; + } else { + if (!PrintName(c, name)) + return false; + } + if (i + 1 == segment.elems().length()) + break; + if (!c.buffer.append(", ")) + return false; + } + + if (!c.buffer.append("];\n\n")) + return false; + + return true; +} + +static bool +PrintImport(WasmPrintContext& c, AstImport& import, const AstModule::SigVector& sigs) +{ + const AstSig* sig = sigs[import.funcSig().index()]; + if (!PrintIndent(c)) + return false; + if (!c.buffer.append("import ")) + return false; + if (!c.buffer.append("\"")) + return false; + + const AstName& fieldName = import.field(); + if (!PrintEscapedString(c, fieldName)) + return false; + + if (!c.buffer.append("\" as ")) + return false; + + if (!PrintName(c, import.name())) + return false; + + if (!c.buffer.append(" from \"")) + return false; + + const AstName& moduleName = import.module(); + if (!PrintEscapedString(c, moduleName)) + return false; + + if (!c.buffer.append("\" typeof function ")) + return false; + + if (!PrintSignature(c, *sig)) + return false; + if (!c.buffer.append(";\n")) + return false; + + return true; +} + + +static bool +PrintImportSection(WasmPrintContext& c, const AstModule::ImportVector& imports, const AstModule::SigVector& sigs) +{ + uint32_t numImports = imports.length(); + + for (uint32_t i = 0; i < numImports; i++) { + if (!PrintImport(c, *imports[i], sigs)) + return false; + } + + if (numImports) { + if (!c.buffer.append("\n")) + return false; + } + + return true; +} + +static bool +PrintExport(WasmPrintContext& c, AstExport& export_, + const AstModule::NameVector& funcImportNames, + const AstModule::FuncVector& funcs) +{ + if (!PrintIndent(c)) + return false; + if (!c.buffer.append("export ")) + return false; + if (export_.kind() == DefinitionKind::Memory) { + if (!c.buffer.append("memory")) + return false; + } else { + uint32_t index = export_.ref().index(); + AstName name = index < funcImportNames.length() + ? funcImportNames[index] + : funcs[index - funcImportNames.length()]->name(); + if (name.empty()) { + if (!PrintInt32(c, index)) + return false; + } else { + if (!PrintName(c, name)) + return false; + } + } + if (!c.buffer.append(" as \"")) + return false; + if (!PrintEscapedString(c, export_.name())) + return false; + if (!c.buffer.append("\";\n")) + return false; + + return true; +} + +static bool +PrintExportSection(WasmPrintContext& c, const AstModule::ExportVector& exports, + const AstModule::NameVector& funcImportNames, + const AstModule::FuncVector& funcs) +{ + uint32_t numExports = exports.length(); + for (uint32_t i = 0; i < numExports; i++) { + if (!PrintExport(c, *exports[i], funcImportNames, funcs)) + return false; + } + if (numExports) { + if (!c.buffer.append("\n")) + return false; + } + return true; +} + +static bool +PrintFunctionBody(WasmPrintContext& c, AstFunc& func, const AstModule::SigVector& sigs) +{ + const AstSig* sig = sigs[func.sig().index()]; + c.indent++; + + size_t startExprIndex = c.maybeSourceMap ? c.maybeSourceMap->exprlocs().length() : 0; + uint32_t startLineno = c.buffer.lineno(); + + uint32_t argsNum = sig->args().length(); + uint32_t localsNum = func.vars().length(); + if (localsNum > 0) { + if (!PrintIndent(c)) + return false; + if (!c.buffer.append("var ")) + return false; + for (uint32_t i = 0; i < localsNum; i++) { + const AstName& name = func.locals()[argsNum + i]; + if (!name.empty()) { + if (!PrintName(c, name)) + return false; + if (!c.buffer.append(": ")) + return false; + } + ValType local = func.vars()[i]; + if (!PrintValType(c, local)) + return false; + if (i + 1 == localsNum) + break; + if (!c.buffer.append(", ")) + return false; + } + if (!c.buffer.append(";\n")) + return false; + } + + + uint32_t exprsNum = func.body().length(); + for (uint32_t i = 0; i < exprsNum; i++) { + if (!PrintBlockLevelExpr(c, *func.body()[i], i + 1 == exprsNum)) + return false; + } + + c.indent--; + + size_t endExprIndex = c.maybeSourceMap ? c.maybeSourceMap->exprlocs().length() : 0; + uint32_t endLineno = c.buffer.lineno(); + + if (c.maybeSourceMap) { + if (!c.maybeSourceMap->functionlocs().emplaceBack(startExprIndex, endExprIndex, startLineno, endLineno)) + return false; + } + return true; +} + +static bool +PrintCodeSection(WasmPrintContext& c, const AstModule::FuncVector& funcs, const AstModule::SigVector& sigs) +{ + uint32_t numFuncBodies = funcs.length(); + for (uint32_t funcIndex = 0; funcIndex < numFuncBodies; funcIndex++) { + AstFunc* func = funcs[funcIndex]; + uint32_t sigIndex = func->sig().index(); + AstSig* sig = sigs[sigIndex]; + + if (!PrintIndent(c)) + return false; + if (!c.buffer.append("function ")) + return false; + if (!func->name().empty()) { + if (!PrintName(c, func->name())) + return false; + } + + if (!PrintSignature(c, *sig, &(func->locals()))) + return false; + if (!c.buffer.append(" {\n")) + return false; + + c.currentFuncIndex = funcIndex; + + if (!PrintFunctionBody(c, *func, sigs)) + return false; + + if (!PrintIndent(c)) + return false; + if (!c.buffer.append("}\n\n")) + return false; + } + + return true; +} + +static bool +PrintDataSection(WasmPrintContext& c, const AstModule& module) +{ + if (!module.hasMemory()) + return true; + + MOZ_ASSERT(module.memories().length() == 1, "NYI: several memories"); + + if (!PrintIndent(c)) + return false; + if (!c.buffer.append("memory ")) + return false; + + const Limits& memory = module.memories()[0].limits; + MOZ_ASSERT(memory.initial % PageSize == 0); + if (!PrintInt32(c, memory.initial / PageSize)) + return false; + + if (memory.maximum) { + MOZ_ASSERT(*memory.maximum % PageSize == 0); + if (!c.buffer.append(", ")) + return false; + if (!PrintInt32(c, *memory.maximum / PageSize)) + return false; + } + + c.indent++; + + uint32_t numSegments = module.dataSegments().length(); + if (!numSegments) { + if (!c.buffer.append(" {}\n\n")) + return false; + return true; + } + if (!c.buffer.append(" {\n")) + return false; + + for (uint32_t i = 0; i < numSegments; i++) { + const AstDataSegment* segment = module.dataSegments()[i]; + if (!PrintIndent(c)) + return false; + if (!c.buffer.append("segment ")) + return false; + if (!PrintInt32(c, segment->offset()->as<AstConst>().val().i32())) + return false; + if (!c.buffer.append("\n")) + return false; + + c.indent++; + for (const AstName& fragment : segment->fragments()) { + if (!PrintIndent(c)) + return false; + if (!c.buffer.append("\"")) + return false; + if (!PrintEscapedString(c, fragment)) + return false; + if (!c.buffer.append("\"\n")) + return false; + } + c.indent--; + + if (!PrintIndent(c)) + return false; + if (!c.buffer.append(";\n")) + return false; + } + + c.indent--; + if (!c.buffer.append("}\n\n")) + return false; + + return true; +} + +static bool +PrintModule(WasmPrintContext& c, AstModule& module) +{ + if (!PrintTypeSection(c, module.sigs())) + return false; + + if (!PrintImportSection(c, module.imports(), module.sigs())) + return false; + + if (!PrintTableSection(c, module)) + return false; + + if (!PrintExportSection(c, module.exports(), module.funcImportNames(), module.funcs())) + return false; + + if (!PrintCodeSection(c, module.funcs(), module.sigs())) + return false; + + if (!PrintDataSection(c, module)) + return false; + + return true; +} + +/*****************************************************************************/ +// Top-level functions + +bool +wasm::BinaryToExperimentalText(JSContext* cx, const uint8_t* bytes, size_t length, + StringBuffer& buffer, const ExperimentalTextFormatting& formatting, + GeneratedSourceMap* sourceMap) +{ + + LifoAlloc lifo(AST_LIFO_DEFAULT_CHUNK_SIZE); + + AstModule* module; + if (!BinaryToAst(cx, bytes, length, lifo, &module)) + return false; + + WasmPrintBuffer buf(buffer); + WasmPrintContext c(cx, module, buf, formatting, sourceMap); + + if (!PrintModule(c, *module)) { + if (!cx->isExceptionPending()) + ReportOutOfMemory(cx); + return false; + } + + return true; +} + |