diff options
Diffstat (limited to 'js/src/wasm/WasmTextToBinary.cpp')
| -rw-r--r-- | js/src/wasm/WasmTextToBinary.cpp | 4843 |
1 files changed, 4843 insertions, 0 deletions
diff --git a/js/src/wasm/WasmTextToBinary.cpp b/js/src/wasm/WasmTextToBinary.cpp new file mode 100644 index 000000000..e61a82650 --- /dev/null +++ b/js/src/wasm/WasmTextToBinary.cpp @@ -0,0 +1,4843 @@ +/* -*- 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/WasmTextToBinary.h" + +#include "mozilla/CheckedInt.h" +#include "mozilla/MathAlgorithms.h" +#include "mozilla/Maybe.h" + +#include "jsdtoa.h" +#include "jsnum.h" +#include "jsprf.h" +#include "jsstr.h" + +#include "ds/LifoAlloc.h" +#include "js/CharacterEncoding.h" +#include "js/HashTable.h" +#include "wasm/WasmAST.h" +#include "wasm/WasmBinaryFormat.h" +#include "wasm/WasmTypes.h" + +using namespace js; +using namespace js::wasm; + +using mozilla::BitwiseCast; +using mozilla::CeilingLog2; +using mozilla::CountLeadingZeroes32; +using mozilla::CheckedInt; +using mozilla::FloatingPoint; +using mozilla::IsPowerOfTwo; +using mozilla::Maybe; +using mozilla::PositiveInfinity; +using mozilla::SpecificNaN; + +/*****************************************************************************/ +// wasm text token stream + +namespace { + +class WasmToken +{ + public: + enum FloatLiteralKind + { + HexNumber, + DecNumber, + Infinity, + NaN + }; + + enum Kind + { + Align, + AnyFunc, + BinaryOpcode, + Block, + Br, + BrIf, + BrTable, + Call, + CallIndirect, + CloseParen, + ComparisonOpcode, + Const, + ConversionOpcode, + CurrentMemory, + Data, + Drop, + Elem, + Else, + End, + EndOfFile, + Equal, + Error, + Export, + Float, + Func, + GetGlobal, + GetLocal, + Global, + GrowMemory, + If, + Import, + Index, + Memory, + NegativeZero, + Load, + Local, + Loop, + Module, + Mutable, + Name, + Nop, + Offset, + OpenParen, + Param, + Result, + Return, + SetGlobal, + SetLocal, + SignedInteger, + Start, + Store, + Table, + TeeLocal, + TernaryOpcode, + Text, + Then, + Type, + UnaryOpcode, + Unreachable, + UnsignedInteger, + ValueType + }; + private: + Kind kind_; + const char16_t* begin_; + const char16_t* end_; + union { + uint32_t index_; + uint64_t uint_; + int64_t sint_; + FloatLiteralKind floatLiteralKind_; + ValType valueType_; + Op op_; + } u; + public: + WasmToken() + : kind_(Kind(-1)), + begin_(nullptr), + end_(nullptr), + u() + { } + WasmToken(Kind kind, const char16_t* begin, const char16_t* end) + : kind_(kind), + begin_(begin), + end_(end) + { + MOZ_ASSERT(kind_ != Error); + MOZ_ASSERT((kind == EndOfFile) == (begin == end)); + } + explicit WasmToken(uint32_t index, const char16_t* begin, const char16_t* end) + : kind_(Index), + begin_(begin), + end_(end) + { + MOZ_ASSERT(begin != end); + u.index_ = index; + } + explicit WasmToken(uint64_t uint, const char16_t* begin, const char16_t* end) + : kind_(UnsignedInteger), + begin_(begin), + end_(end) + { + MOZ_ASSERT(begin != end); + u.uint_ = uint; + } + explicit WasmToken(int64_t sint, const char16_t* begin, const char16_t* end) + : kind_(SignedInteger), + begin_(begin), + end_(end) + { + MOZ_ASSERT(begin != end); + u.sint_ = sint; + } + explicit WasmToken(FloatLiteralKind floatLiteralKind, + const char16_t* begin, const char16_t* end) + : kind_(Float), + begin_(begin), + end_(end) + { + MOZ_ASSERT(begin != end); + u.floatLiteralKind_ = floatLiteralKind; + } + explicit WasmToken(Kind kind, ValType valueType, const char16_t* begin, const char16_t* end) + : kind_(kind), + begin_(begin), + end_(end) + { + MOZ_ASSERT(begin != end); + MOZ_ASSERT(kind_ == ValueType || kind_ == Const); + u.valueType_ = valueType; + } + explicit WasmToken(Kind kind, Op op, const char16_t* begin, const char16_t* end) + : kind_(kind), + begin_(begin), + end_(end) + { + MOZ_ASSERT(begin != end); + MOZ_ASSERT(kind_ == UnaryOpcode || kind_ == BinaryOpcode || kind_ == TernaryOpcode || + kind_ == ComparisonOpcode || kind_ == ConversionOpcode || + kind_ == Load || kind_ == Store); + u.op_ = op; + } + explicit WasmToken(const char16_t* begin) + : kind_(Error), + begin_(begin), + end_(begin) + {} + Kind kind() const { + MOZ_ASSERT(kind_ != Kind(-1)); + return kind_; + } + const char16_t* begin() const { + return begin_; + } + const char16_t* end() const { + return end_; + } + AstName text() const { + MOZ_ASSERT(kind_ == Text); + MOZ_ASSERT(begin_[0] == '"'); + MOZ_ASSERT(end_[-1] == '"'); + MOZ_ASSERT(end_ - begin_ >= 2); + return AstName(begin_ + 1, end_ - begin_ - 2); + } + AstName name() const { + return AstName(begin_, end_ - begin_); + } + uint32_t index() const { + MOZ_ASSERT(kind_ == Index); + return u.index_; + } + uint64_t uint() const { + MOZ_ASSERT(kind_ == UnsignedInteger); + return u.uint_; + } + int64_t sint() const { + MOZ_ASSERT(kind_ == SignedInteger); + return u.sint_; + } + FloatLiteralKind floatLiteralKind() const { + MOZ_ASSERT(kind_ == Float); + return u.floatLiteralKind_; + } + ValType valueType() const { + MOZ_ASSERT(kind_ == ValueType || kind_ == Const); + return u.valueType_; + } + Op op() const { + MOZ_ASSERT(kind_ == UnaryOpcode || kind_ == BinaryOpcode || kind_ == TernaryOpcode || + kind_ == ComparisonOpcode || kind_ == ConversionOpcode || + kind_ == Load || kind_ == Store); + return u.op_; + } + bool isOpcode() const { + switch (kind_) { + case BinaryOpcode: + case Block: + case Br: + case BrIf: + case BrTable: + case Call: + case CallIndirect: + case ComparisonOpcode: + case Const: + case ConversionOpcode: + case CurrentMemory: + case Drop: + case GetGlobal: + case GetLocal: + case GrowMemory: + case If: + case Load: + case Loop: + case Nop: + case Return: + case SetGlobal: + case SetLocal: + case Store: + case TeeLocal: + case TernaryOpcode: + case UnaryOpcode: + case Unreachable: + return true; + case Align: + case AnyFunc: + case CloseParen: + case Data: + case Elem: + case Else: + case EndOfFile: + case Equal: + case End: + case Error: + case Export: + case Float: + case Func: + case Global: + case Mutable: + case Import: + case Index: + case Memory: + case NegativeZero: + case Local: + case Module: + case Name: + case Offset: + case OpenParen: + case Param: + case Result: + case SignedInteger: + case Start: + case Table: + case Text: + case Then: + case Type: + case UnsignedInteger: + case ValueType: + return false; + } + MOZ_CRASH("unexpected token kind"); + } +}; + +struct InlineImport +{ + WasmToken module; + WasmToken field; +}; + +} // end anonymous namespace + +static bool +IsWasmNewLine(char16_t c) +{ + return c == '\n'; +} + +static bool +IsWasmSpace(char16_t c) +{ + switch (c) { + case ' ': + case '\n': + case '\r': + case '\t': + case '\v': + case '\f': + return true; + default: + return false; + } +} + +static bool +IsWasmDigit(char16_t c) +{ + return c >= '0' && c <= '9'; +} + +static bool +IsWasmLetter(char16_t c) +{ + return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'); +} + +static bool +IsNameAfterDollar(char16_t c) +{ + return IsWasmLetter(c) || IsWasmDigit(c) || c == '_' || c == '$' || c == '-' || c == '.'; +} + +static bool +IsHexDigit(char c, uint8_t* value) +{ + if (c >= '0' && c <= '9') { + *value = c - '0'; + return true; + } + + if (c >= 'a' && c <= 'f') { + *value = 10 + (c - 'a'); + return true; + } + + if (c >= 'A' && c <= 'F') { + *value = 10 + (c - 'A'); + return true; + } + + return false; +} + +static WasmToken +LexHexFloatLiteral(const char16_t* begin, const char16_t* end, const char16_t** curp) +{ + const char16_t* cur = begin; + + if (cur != end && (*cur == '-' || *cur == '+')) + cur++; + + MOZ_ASSERT(cur != end && *cur == '0'); + cur++; + MOZ_ASSERT(cur != end && *cur == 'x'); + cur++; + + uint8_t digit; + while (cur != end && IsHexDigit(*cur, &digit)) + cur++; + + if (cur != end && *cur == '.') + cur++; + + while (cur != end && IsHexDigit(*cur, &digit)) + cur++; + + if (cur != end && *cur == 'p') { + cur++; + + if (cur != end && (*cur == '-' || *cur == '+')) + cur++; + + while (cur != end && IsWasmDigit(*cur)) + cur++; + } + + *curp = cur; + return WasmToken(WasmToken::HexNumber, begin, cur); +} + +static WasmToken +LexDecFloatLiteral(const char16_t* begin, const char16_t* end, const char16_t** curp) +{ + const char16_t* cur = begin; + + if (cur != end && (*cur == '-' || *cur == '+')) + cur++; + + while (cur != end && IsWasmDigit(*cur)) + cur++; + + if (cur != end && *cur == '.') + cur++; + + while (cur != end && IsWasmDigit(*cur)) + cur++; + + if (cur != end && *cur == 'e') { + cur++; + + if (cur != end && (*cur == '-' || *cur == '+')) + cur++; + + while (cur != end && IsWasmDigit(*cur)) + cur++; + } + + *curp = cur; + return WasmToken(WasmToken::DecNumber, begin, cur); +} + +static bool +ConsumeTextByte(const char16_t** curp, const char16_t* end, uint8_t* byte = nullptr) +{ + const char16_t*& cur = *curp; + MOZ_ASSERT(cur != end); + + if (*cur != '\\') { + if (byte) + *byte = *cur; + cur++; + return true; + } + + if (++cur == end) + return false; + + uint8_t u8; + switch (*cur) { + case 'n': u8 = '\n'; break; + case 't': u8 = '\t'; break; + case '\\': u8 = '\\'; break; + case '\"': u8 = '\"'; break; + case '\'': u8 = '\''; break; + default: { + uint8_t highNibble; + if (!IsHexDigit(*cur, &highNibble)) + return false; + + if (++cur == end) + return false; + + uint8_t lowNibble; + if (!IsHexDigit(*cur, &lowNibble)) + return false; + + u8 = lowNibble | (highNibble << 4); + break; + } + } + + if (byte) + *byte = u8; + cur++; + return true; +} + +namespace { + +class WasmTokenStream +{ + static const uint32_t LookaheadSize = 2; + + const char16_t* cur_; + const char16_t* const end_; + const char16_t* lineStart_; + unsigned line_; + uint32_t lookaheadIndex_; + uint32_t lookaheadDepth_; + WasmToken lookahead_[LookaheadSize]; + + bool consume(const char16_t* match) { + const char16_t* p = cur_; + for (; *match; p++, match++) { + if (p == end_ || *p != *match) + return false; + } + cur_ = p; + return true; + } + WasmToken fail(const char16_t* begin) const { + return WasmToken(begin); + } + + WasmToken nan(const char16_t* begin); + WasmToken literal(const char16_t* begin); + WasmToken next(); + void skipSpaces(); + + public: + WasmTokenStream(const char16_t* text, UniqueChars* error) + : cur_(text), + end_(text + js_strlen(text)), + lineStart_(text), + line_(1), + lookaheadIndex_(0), + lookaheadDepth_(0) + {} + void generateError(WasmToken token, UniqueChars* error) { + unsigned column = token.begin() - lineStart_ + 1; + error->reset(JS_smprintf("parsing wasm text at %u:%u", line_, column)); + } + void generateError(WasmToken token, const char* msg, UniqueChars* error) { + unsigned column = token.begin() - lineStart_ + 1; + error->reset(JS_smprintf("parsing wasm text at %u:%u: %s", line_, column, msg)); + } + WasmToken peek() { + if (!lookaheadDepth_) { + lookahead_[lookaheadIndex_] = next(); + lookaheadDepth_ = 1; + } + return lookahead_[lookaheadIndex_]; + } + WasmToken get() { + static_assert(LookaheadSize == 2, "can just flip"); + if (lookaheadDepth_) { + lookaheadDepth_--; + WasmToken ret = lookahead_[lookaheadIndex_]; + lookaheadIndex_ ^= 1; + return ret; + } + return next(); + } + void unget(WasmToken token) { + static_assert(LookaheadSize == 2, "can just flip"); + lookaheadDepth_++; + lookaheadIndex_ ^= 1; + lookahead_[lookaheadIndex_] = token; + } + + // Helpers: + bool getIf(WasmToken::Kind kind, WasmToken* token) { + if (peek().kind() == kind) { + *token = get(); + return true; + } + return false; + } + bool getIf(WasmToken::Kind kind) { + WasmToken token; + if (getIf(kind, &token)) + return true; + return false; + } + AstName getIfName() { + WasmToken token; + if (getIf(WasmToken::Name, &token)) + return token.name(); + return AstName(); + } + AstName getIfText() { + WasmToken token; + if (getIf(WasmToken::Text, &token)) + return token.text(); + return AstName(); + } + bool getIfRef(AstRef* ref) { + WasmToken token = peek(); + if (token.kind() == WasmToken::Name || token.kind() == WasmToken::Index) + return matchRef(ref, nullptr); + return false; + } + bool getIfOpcode(WasmToken* token) { + *token = peek(); + if (token->isOpcode()) { + (void)get(); + return true; + } + return false; + } + bool match(WasmToken::Kind expect, WasmToken* token, UniqueChars* error) { + *token = get(); + if (token->kind() == expect) + return true; + generateError(*token, error); + return false; + } + bool match(WasmToken::Kind expect, UniqueChars* error) { + WasmToken token; + return match(expect, &token, error); + } + bool matchRef(AstRef* ref, UniqueChars* error) { + WasmToken token = get(); + switch (token.kind()) { + case WasmToken::Name: + *ref = AstRef(token.name()); + break; + case WasmToken::Index: + *ref = AstRef(token.index()); + break; + default: + generateError(token, error); + return false; + } + return true; + } +}; + +} // end anonymous namespace + +WasmToken +WasmTokenStream::nan(const char16_t* begin) +{ + if (consume(u":")) { + if (!consume(u"0x")) + return fail(begin); + + uint8_t digit; + while (cur_ != end_ && IsHexDigit(*cur_, &digit)) + cur_++; + } + + return WasmToken(WasmToken::NaN, begin, cur_); +} + +WasmToken +WasmTokenStream::literal(const char16_t* begin) +{ + CheckedInt<uint64_t> u = 0; + if (consume(u"0x")) { + if (cur_ == end_) + return fail(begin); + + do { + if (*cur_ == '.' || *cur_ == 'p') + return LexHexFloatLiteral(begin, end_, &cur_); + + uint8_t digit; + if (!IsHexDigit(*cur_, &digit)) + break; + + u *= 16; + u += digit; + if (!u.isValid()) + return LexHexFloatLiteral(begin, end_, &cur_); + + cur_++; + } while (cur_ != end_); + + if (*begin == '-') { + uint64_t value = u.value(); + if (value == 0) + return WasmToken(WasmToken::NegativeZero, begin, cur_); + if (value > uint64_t(INT64_MIN)) + return LexHexFloatLiteral(begin, end_, &cur_); + + value = -value; + return WasmToken(int64_t(value), begin, cur_); + } + } else { + while (cur_ != end_) { + if (*cur_ == '.' || *cur_ == 'e') + return LexDecFloatLiteral(begin, end_, &cur_); + + if (!IsWasmDigit(*cur_)) + break; + + u *= 10; + u += *cur_ - '0'; + if (!u.isValid()) + return LexDecFloatLiteral(begin, end_, &cur_); + + cur_++; + } + + if (*begin == '-') { + uint64_t value = u.value(); + if (value == 0) + return WasmToken(WasmToken::NegativeZero, begin, cur_); + if (value > uint64_t(INT64_MIN)) + return LexDecFloatLiteral(begin, end_, &cur_); + + value = -value; + return WasmToken(int64_t(value), begin, cur_); + } + } + + CheckedInt<uint32_t> index = u.value(); + if (index.isValid()) + return WasmToken(index.value(), begin, cur_); + + return WasmToken(u.value(), begin, cur_); +} + +void +WasmTokenStream::skipSpaces() +{ + while (cur_ != end_) { + char16_t ch = *cur_; + if (ch == ';' && consume(u";;")) { + // Skipping single line comment. + while (cur_ != end_ && !IsWasmNewLine(*cur_)) + cur_++; + } else if (ch == '(' && consume(u"(;")) { + // Skipping multi-line and possibly nested comments. + size_t level = 1; + while (cur_ != end_) { + char16_t ch = *cur_; + if (ch == '(' && consume(u"(;")) { + level++; + } else if (ch == ';' && consume(u";)")) { + if (--level == 0) + break; + } else { + cur_++; + if (IsWasmNewLine(ch)) { + lineStart_ = cur_; + line_++; + } + } + } + } else if (IsWasmSpace(ch)) { + cur_++; + if (IsWasmNewLine(ch)) { + lineStart_ = cur_; + line_++; + } + } else + break; // non-whitespace found + } +} + +WasmToken +WasmTokenStream::next() +{ + skipSpaces(); + + if (cur_ == end_) + return WasmToken(WasmToken::EndOfFile, cur_, cur_); + + const char16_t* begin = cur_; + switch (*begin) { + case '"': + cur_++; + while (true) { + if (cur_ == end_) + return fail(begin); + if (*cur_ == '"') + break; + if (!ConsumeTextByte(&cur_, end_)) + return fail(begin); + } + cur_++; + return WasmToken(WasmToken::Text, begin, cur_); + + case '$': + cur_++; + while (cur_ != end_ && IsNameAfterDollar(*cur_)) + cur_++; + return WasmToken(WasmToken::Name, begin, cur_); + + case '(': + cur_++; + return WasmToken(WasmToken::OpenParen, begin, cur_); + + case ')': + cur_++; + return WasmToken(WasmToken::CloseParen, begin, cur_); + + case '=': + cur_++; + return WasmToken(WasmToken::Equal, begin, cur_); + + case '+': case '-': + cur_++; + if (consume(u"infinity")) + return WasmToken(WasmToken::Infinity, begin, cur_); + if (consume(u"nan")) + return nan(begin); + if (!IsWasmDigit(*cur_)) + break; + MOZ_FALLTHROUGH; + case '0': case '1': case '2': case '3': case '4': + case '5': case '6': case '7': case '8': case '9': + return literal(begin); + + case 'a': + if (consume(u"align")) + return WasmToken(WasmToken::Align, begin, cur_); + if (consume(u"anyfunc")) + return WasmToken(WasmToken::AnyFunc, begin, cur_); + break; + + case 'b': + if (consume(u"block")) + return WasmToken(WasmToken::Block, begin, cur_); + if (consume(u"br")) { + if (consume(u"_table")) + return WasmToken(WasmToken::BrTable, begin, cur_); + if (consume(u"_if")) + return WasmToken(WasmToken::BrIf, begin, cur_); + return WasmToken(WasmToken::Br, begin, cur_); + } + break; + + case 'c': + if (consume(u"call")) { + if (consume(u"_indirect")) + return WasmToken(WasmToken::CallIndirect, begin, cur_); + return WasmToken(WasmToken::Call, begin, cur_); + } + if (consume(u"current_memory")) + return WasmToken(WasmToken::CurrentMemory, begin, cur_); + break; + + case 'd': + if (consume(u"data")) + return WasmToken(WasmToken::Data, begin, cur_); + if (consume(u"drop")) + return WasmToken(WasmToken::Drop, begin, cur_); + break; + + case 'e': + if (consume(u"elem")) + return WasmToken(WasmToken::Elem, begin, cur_); + if (consume(u"else")) + return WasmToken(WasmToken::Else, begin, cur_); + if (consume(u"end")) + return WasmToken(WasmToken::End, begin, cur_); + if (consume(u"export")) + return WasmToken(WasmToken::Export, begin, cur_); + break; + + case 'f': + if (consume(u"func")) + return WasmToken(WasmToken::Func, begin, cur_); + + if (consume(u"f32")) { + if (!consume(u".")) + return WasmToken(WasmToken::ValueType, ValType::F32, begin, cur_); + + switch (*cur_) { + case 'a': + if (consume(u"abs")) + return WasmToken(WasmToken::UnaryOpcode, Op::F32Abs, begin, cur_); + if (consume(u"add")) + return WasmToken(WasmToken::BinaryOpcode, Op::F32Add, begin, cur_); + break; + case 'c': + if (consume(u"ceil")) + return WasmToken(WasmToken::UnaryOpcode, Op::F32Ceil, begin, cur_); + if (consume(u"const")) + return WasmToken(WasmToken::Const, ValType::F32, begin, cur_); + if (consume(u"convert_s/i32")) { + return WasmToken(WasmToken::ConversionOpcode, Op::F32ConvertSI32, + begin, cur_); + } + if (consume(u"convert_u/i32")) { + return WasmToken(WasmToken::ConversionOpcode, Op::F32ConvertUI32, + begin, cur_); + } + if (consume(u"convert_s/i64")) { + return WasmToken(WasmToken::ConversionOpcode, Op::F32ConvertSI64, + begin, cur_); + } + if (consume(u"convert_u/i64")) { + return WasmToken(WasmToken::ConversionOpcode, Op::F32ConvertUI64, + begin, cur_); + } + if (consume(u"copysign")) + return WasmToken(WasmToken::BinaryOpcode, Op::F32CopySign, begin, cur_); + break; + case 'd': + if (consume(u"demote/f64")) + return WasmToken(WasmToken::ConversionOpcode, Op::F32DemoteF64, + begin, cur_); + if (consume(u"div")) + return WasmToken(WasmToken::BinaryOpcode, Op::F32Div, begin, cur_); + break; + case 'e': + if (consume(u"eq")) + return WasmToken(WasmToken::ComparisonOpcode, Op::F32Eq, begin, cur_); + break; + case 'f': + if (consume(u"floor")) + return WasmToken(WasmToken::UnaryOpcode, Op::F32Floor, begin, cur_); + break; + case 'g': + if (consume(u"ge")) + return WasmToken(WasmToken::ComparisonOpcode, Op::F32Ge, begin, cur_); + if (consume(u"gt")) + return WasmToken(WasmToken::ComparisonOpcode, Op::F32Gt, begin, cur_); + break; + case 'l': + if (consume(u"le")) + return WasmToken(WasmToken::ComparisonOpcode, Op::F32Le, begin, cur_); + if (consume(u"lt")) + return WasmToken(WasmToken::ComparisonOpcode, Op::F32Lt, begin, cur_); + if (consume(u"load")) + return WasmToken(WasmToken::Load, Op::F32Load, begin, cur_); + break; + case 'm': + if (consume(u"max")) + return WasmToken(WasmToken::BinaryOpcode, Op::F32Max, begin, cur_); + if (consume(u"min")) + return WasmToken(WasmToken::BinaryOpcode, Op::F32Min, begin, cur_); + if (consume(u"mul")) + return WasmToken(WasmToken::BinaryOpcode, Op::F32Mul, begin, cur_); + break; + case 'n': + if (consume(u"nearest")) + return WasmToken(WasmToken::UnaryOpcode, Op::F32Nearest, begin, cur_); + if (consume(u"neg")) + return WasmToken(WasmToken::UnaryOpcode, Op::F32Neg, begin, cur_); + if (consume(u"ne")) + return WasmToken(WasmToken::ComparisonOpcode, Op::F32Ne, begin, cur_); + break; + case 'r': + if (consume(u"reinterpret/i32")) + return WasmToken(WasmToken::ConversionOpcode, Op::F32ReinterpretI32, + begin, cur_); + break; + case 's': + if (consume(u"sqrt")) + return WasmToken(WasmToken::UnaryOpcode, Op::F32Sqrt, begin, cur_); + if (consume(u"sub")) + return WasmToken(WasmToken::BinaryOpcode, Op::F32Sub, begin, cur_); + if (consume(u"store")) + return WasmToken(WasmToken::Store, Op::F32Store, begin, cur_); + break; + case 't': + if (consume(u"trunc")) + return WasmToken(WasmToken::UnaryOpcode, Op::F32Trunc, begin, cur_); + break; + } + break; + } + if (consume(u"f64")) { + if (!consume(u".")) + return WasmToken(WasmToken::ValueType, ValType::F64, begin, cur_); + + switch (*cur_) { + case 'a': + if (consume(u"abs")) + return WasmToken(WasmToken::UnaryOpcode, Op::F64Abs, begin, cur_); + if (consume(u"add")) + return WasmToken(WasmToken::BinaryOpcode, Op::F64Add, begin, cur_); + break; + case 'c': + if (consume(u"ceil")) + return WasmToken(WasmToken::UnaryOpcode, Op::F64Ceil, begin, cur_); + if (consume(u"const")) + return WasmToken(WasmToken::Const, ValType::F64, begin, cur_); + if (consume(u"convert_s/i32")) { + return WasmToken(WasmToken::ConversionOpcode, Op::F64ConvertSI32, + begin, cur_); + } + if (consume(u"convert_u/i32")) { + return WasmToken(WasmToken::ConversionOpcode, Op::F64ConvertUI32, + begin, cur_); + } + if (consume(u"convert_s/i64")) { + return WasmToken(WasmToken::ConversionOpcode, Op::F64ConvertSI64, + begin, cur_); + } + if (consume(u"convert_u/i64")) { + return WasmToken(WasmToken::ConversionOpcode, Op::F64ConvertUI64, + begin, cur_); + } + if (consume(u"copysign")) + return WasmToken(WasmToken::BinaryOpcode, Op::F64CopySign, begin, cur_); + break; + case 'd': + if (consume(u"div")) + return WasmToken(WasmToken::BinaryOpcode, Op::F64Div, begin, cur_); + break; + case 'e': + if (consume(u"eq")) + return WasmToken(WasmToken::ComparisonOpcode, Op::F64Eq, begin, cur_); + break; + case 'f': + if (consume(u"floor")) + return WasmToken(WasmToken::UnaryOpcode, Op::F64Floor, begin, cur_); + break; + case 'g': + if (consume(u"ge")) + return WasmToken(WasmToken::ComparisonOpcode, Op::F64Ge, begin, cur_); + if (consume(u"gt")) + return WasmToken(WasmToken::ComparisonOpcode, Op::F64Gt, begin, cur_); + break; + case 'l': + if (consume(u"le")) + return WasmToken(WasmToken::ComparisonOpcode, Op::F64Le, begin, cur_); + if (consume(u"lt")) + return WasmToken(WasmToken::ComparisonOpcode, Op::F64Lt, begin, cur_); + if (consume(u"load")) + return WasmToken(WasmToken::Load, Op::F64Load, begin, cur_); + break; + case 'm': + if (consume(u"max")) + return WasmToken(WasmToken::BinaryOpcode, Op::F64Max, begin, cur_); + if (consume(u"min")) + return WasmToken(WasmToken::BinaryOpcode, Op::F64Min, begin, cur_); + if (consume(u"mul")) + return WasmToken(WasmToken::BinaryOpcode, Op::F64Mul, begin, cur_); + break; + case 'n': + if (consume(u"nearest")) + return WasmToken(WasmToken::UnaryOpcode, Op::F64Nearest, begin, cur_); + if (consume(u"neg")) + return WasmToken(WasmToken::UnaryOpcode, Op::F64Neg, begin, cur_); + if (consume(u"ne")) + return WasmToken(WasmToken::ComparisonOpcode, Op::F64Ne, begin, cur_); + break; + case 'p': + if (consume(u"promote/f32")) + return WasmToken(WasmToken::ConversionOpcode, Op::F64PromoteF32, + begin, cur_); + break; + case 'r': + if (consume(u"reinterpret/i64")) + return WasmToken(WasmToken::UnaryOpcode, Op::F64ReinterpretI64, + begin, cur_); + break; + case 's': + if (consume(u"sqrt")) + return WasmToken(WasmToken::UnaryOpcode, Op::F64Sqrt, begin, cur_); + if (consume(u"sub")) + return WasmToken(WasmToken::BinaryOpcode, Op::F64Sub, begin, cur_); + if (consume(u"store")) + return WasmToken(WasmToken::Store, Op::F64Store, begin, cur_); + break; + case 't': + if (consume(u"trunc")) + return WasmToken(WasmToken::UnaryOpcode, Op::F64Trunc, begin, cur_); + break; + } + break; + } + break; + + case 'g': + if (consume(u"get_global")) + return WasmToken(WasmToken::GetGlobal, begin, cur_); + if (consume(u"get_local")) + return WasmToken(WasmToken::GetLocal, begin, cur_); + if (consume(u"global")) + return WasmToken(WasmToken::Global, begin, cur_); + if (consume(u"grow_memory")) + return WasmToken(WasmToken::GrowMemory, begin, cur_); + break; + + case 'i': + if (consume(u"i32")) { + if (!consume(u".")) + return WasmToken(WasmToken::ValueType, ValType::I32, begin, cur_); + + switch (*cur_) { + case 'a': + if (consume(u"add")) + return WasmToken(WasmToken::BinaryOpcode, Op::I32Add, begin, cur_); + if (consume(u"and")) + return WasmToken(WasmToken::BinaryOpcode, Op::I32And, begin, cur_); + break; + case 'c': + if (consume(u"const")) + return WasmToken(WasmToken::Const, ValType::I32, begin, cur_); + if (consume(u"clz")) + return WasmToken(WasmToken::UnaryOpcode, Op::I32Clz, begin, cur_); + if (consume(u"ctz")) + return WasmToken(WasmToken::UnaryOpcode, Op::I32Ctz, begin, cur_); + break; + case 'd': + if (consume(u"div_s")) + return WasmToken(WasmToken::BinaryOpcode, Op::I32DivS, begin, cur_); + if (consume(u"div_u")) + return WasmToken(WasmToken::BinaryOpcode, Op::I32DivU, begin, cur_); + break; + case 'e': + if (consume(u"eqz")) + return WasmToken(WasmToken::UnaryOpcode, Op::I32Eqz, begin, cur_); + if (consume(u"eq")) + return WasmToken(WasmToken::ComparisonOpcode, Op::I32Eq, begin, cur_); + break; + case 'g': + if (consume(u"ge_s")) + return WasmToken(WasmToken::ComparisonOpcode, Op::I32GeS, begin, cur_); + if (consume(u"ge_u")) + return WasmToken(WasmToken::ComparisonOpcode, Op::I32GeU, begin, cur_); + if (consume(u"gt_s")) + return WasmToken(WasmToken::ComparisonOpcode, Op::I32GtS, begin, cur_); + if (consume(u"gt_u")) + return WasmToken(WasmToken::ComparisonOpcode, Op::I32GtU, begin, cur_); + break; + case 'l': + if (consume(u"le_s")) + return WasmToken(WasmToken::ComparisonOpcode, Op::I32LeS, begin, cur_); + if (consume(u"le_u")) + return WasmToken(WasmToken::ComparisonOpcode, Op::I32LeU, begin, cur_); + if (consume(u"lt_s")) + return WasmToken(WasmToken::ComparisonOpcode, Op::I32LtS, begin, cur_); + if (consume(u"lt_u")) + return WasmToken(WasmToken::ComparisonOpcode, Op::I32LtU, begin, cur_); + if (consume(u"load")) { + if (IsWasmSpace(*cur_)) + return WasmToken(WasmToken::Load, Op::I32Load, begin, cur_); + if (consume(u"8_s")) + return WasmToken(WasmToken::Load, Op::I32Load8S, begin, cur_); + if (consume(u"8_u")) + return WasmToken(WasmToken::Load, Op::I32Load8U, begin, cur_); + if (consume(u"16_s")) + return WasmToken(WasmToken::Load, Op::I32Load16S, begin, cur_); + if (consume(u"16_u")) + return WasmToken(WasmToken::Load, Op::I32Load16U, begin, cur_); + break; + } + break; + case 'm': + if (consume(u"mul")) + return WasmToken(WasmToken::BinaryOpcode, Op::I32Mul, begin, cur_); + break; + case 'n': + if (consume(u"ne")) + return WasmToken(WasmToken::ComparisonOpcode, Op::I32Ne, begin, cur_); + break; + case 'o': + if (consume(u"or")) + return WasmToken(WasmToken::BinaryOpcode, Op::I32Or, begin, cur_); + break; + case 'p': + if (consume(u"popcnt")) + return WasmToken(WasmToken::UnaryOpcode, Op::I32Popcnt, begin, cur_); + break; + case 'r': + if (consume(u"reinterpret/f32")) + return WasmToken(WasmToken::UnaryOpcode, Op::I32ReinterpretF32, + begin, cur_); + if (consume(u"rem_s")) + return WasmToken(WasmToken::BinaryOpcode, Op::I32RemS, begin, cur_); + if (consume(u"rem_u")) + return WasmToken(WasmToken::BinaryOpcode, Op::I32RemU, begin, cur_); + if (consume(u"rotr")) + return WasmToken(WasmToken::BinaryOpcode, Op::I32Rotr, begin, cur_); + if (consume(u"rotl")) + return WasmToken(WasmToken::BinaryOpcode, Op::I32Rotl, begin, cur_); + break; + case 's': + if (consume(u"sub")) + return WasmToken(WasmToken::BinaryOpcode, Op::I32Sub, begin, cur_); + if (consume(u"shl")) + return WasmToken(WasmToken::BinaryOpcode, Op::I32Shl, begin, cur_); + if (consume(u"shr_s")) + return WasmToken(WasmToken::BinaryOpcode, Op::I32ShrS, begin, cur_); + if (consume(u"shr_u")) + return WasmToken(WasmToken::BinaryOpcode, Op::I32ShrU, begin, cur_); + if (consume(u"store")) { + if (IsWasmSpace(*cur_)) + return WasmToken(WasmToken::Store, Op::I32Store, begin, cur_); + if (consume(u"8")) + return WasmToken(WasmToken::Store, Op::I32Store8, begin, cur_); + if (consume(u"16")) + return WasmToken(WasmToken::Store, Op::I32Store16, begin, cur_); + break; + } + break; + case 't': + if (consume(u"trunc_s/f32")) + return WasmToken(WasmToken::ConversionOpcode, Op::I32TruncSF32, + begin, cur_); + if (consume(u"trunc_s/f64")) + return WasmToken(WasmToken::ConversionOpcode, Op::I32TruncSF64, + begin, cur_); + if (consume(u"trunc_u/f32")) + return WasmToken(WasmToken::ConversionOpcode, Op::I32TruncUF32, + begin, cur_); + if (consume(u"trunc_u/f64")) + return WasmToken(WasmToken::ConversionOpcode, Op::I32TruncUF64, + begin, cur_); + break; + case 'w': + if (consume(u"wrap/i64")) + return WasmToken(WasmToken::ConversionOpcode, Op::I32WrapI64, + begin, cur_); + break; + case 'x': + if (consume(u"xor")) + return WasmToken(WasmToken::BinaryOpcode, Op::I32Xor, begin, cur_); + break; + } + break; + } + if (consume(u"i64")) { + if (!consume(u".")) + return WasmToken(WasmToken::ValueType, ValType::I64, begin, cur_); + + switch (*cur_) { + case 'a': + if (consume(u"add")) + return WasmToken(WasmToken::BinaryOpcode, Op::I64Add, begin, cur_); + if (consume(u"and")) + return WasmToken(WasmToken::BinaryOpcode, Op::I64And, begin, cur_); + break; + case 'c': + if (consume(u"const")) + return WasmToken(WasmToken::Const, ValType::I64, begin, cur_); + if (consume(u"clz")) + return WasmToken(WasmToken::UnaryOpcode, Op::I64Clz, begin, cur_); + if (consume(u"ctz")) + return WasmToken(WasmToken::UnaryOpcode, Op::I64Ctz, begin, cur_); + break; + case 'd': + if (consume(u"div_s")) + return WasmToken(WasmToken::BinaryOpcode, Op::I64DivS, begin, cur_); + if (consume(u"div_u")) + return WasmToken(WasmToken::BinaryOpcode, Op::I64DivU, begin, cur_); + break; + case 'e': + if (consume(u"eqz")) + return WasmToken(WasmToken::UnaryOpcode, Op::I64Eqz, begin, cur_); + if (consume(u"eq")) + return WasmToken(WasmToken::ComparisonOpcode, Op::I64Eq, begin, cur_); + if (consume(u"extend_s/i32")) + return WasmToken(WasmToken::ConversionOpcode, Op::I64ExtendSI32, + begin, cur_); + if (consume(u"extend_u/i32")) + return WasmToken(WasmToken::ConversionOpcode, Op::I64ExtendUI32, + begin, cur_); + break; + case 'g': + if (consume(u"ge_s")) + return WasmToken(WasmToken::ComparisonOpcode, Op::I64GeS, begin, cur_); + if (consume(u"ge_u")) + return WasmToken(WasmToken::ComparisonOpcode, Op::I64GeU, begin, cur_); + if (consume(u"gt_s")) + return WasmToken(WasmToken::ComparisonOpcode, Op::I64GtS, begin, cur_); + if (consume(u"gt_u")) + return WasmToken(WasmToken::ComparisonOpcode, Op::I64GtU, begin, cur_); + break; + case 'l': + if (consume(u"le_s")) + return WasmToken(WasmToken::ComparisonOpcode, Op::I64LeS, begin, cur_); + if (consume(u"le_u")) + return WasmToken(WasmToken::ComparisonOpcode, Op::I64LeU, begin, cur_); + if (consume(u"lt_s")) + return WasmToken(WasmToken::ComparisonOpcode, Op::I64LtS, begin, cur_); + if (consume(u"lt_u")) + return WasmToken(WasmToken::ComparisonOpcode, Op::I64LtU, begin, cur_); + if (consume(u"load")) { + if (IsWasmSpace(*cur_)) + return WasmToken(WasmToken::Load, Op::I64Load, begin, cur_); + if (consume(u"8_s")) + return WasmToken(WasmToken::Load, Op::I64Load8S, begin, cur_); + if (consume(u"8_u")) + return WasmToken(WasmToken::Load, Op::I64Load8U, begin, cur_); + if (consume(u"16_s")) + return WasmToken(WasmToken::Load, Op::I64Load16S, begin, cur_); + if (consume(u"16_u")) + return WasmToken(WasmToken::Load, Op::I64Load16U, begin, cur_); + if (consume(u"32_s")) + return WasmToken(WasmToken::Load, Op::I64Load32S, begin, cur_); + if (consume(u"32_u")) + return WasmToken(WasmToken::Load, Op::I64Load32U, begin, cur_); + break; + } + break; + case 'm': + if (consume(u"mul")) + return WasmToken(WasmToken::BinaryOpcode, Op::I64Mul, begin, cur_); + break; + case 'n': + if (consume(u"ne")) + return WasmToken(WasmToken::ComparisonOpcode, Op::I64Ne, begin, cur_); + break; + case 'o': + if (consume(u"or")) + return WasmToken(WasmToken::BinaryOpcode, Op::I64Or, begin, cur_); + break; + case 'p': + if (consume(u"popcnt")) + return WasmToken(WasmToken::UnaryOpcode, Op::I64Popcnt, begin, cur_); + break; + case 'r': + if (consume(u"reinterpret/f64")) + return WasmToken(WasmToken::UnaryOpcode, Op::I64ReinterpretF64, + begin, cur_); + if (consume(u"rem_s")) + return WasmToken(WasmToken::BinaryOpcode, Op::I64RemS, begin, cur_); + if (consume(u"rem_u")) + return WasmToken(WasmToken::BinaryOpcode, Op::I64RemU, begin, cur_); + if (consume(u"rotr")) + return WasmToken(WasmToken::BinaryOpcode, Op::I64Rotr, begin, cur_); + if (consume(u"rotl")) + return WasmToken(WasmToken::BinaryOpcode, Op::I64Rotl, begin, cur_); + break; + case 's': + if (consume(u"sub")) + return WasmToken(WasmToken::BinaryOpcode, Op::I64Sub, begin, cur_); + if (consume(u"shl")) + return WasmToken(WasmToken::BinaryOpcode, Op::I64Shl, begin, cur_); + if (consume(u"shr_s")) + return WasmToken(WasmToken::BinaryOpcode, Op::I64ShrS, begin, cur_); + if (consume(u"shr_u")) + return WasmToken(WasmToken::BinaryOpcode, Op::I64ShrU, begin, cur_); + if (consume(u"store")) { + if (IsWasmSpace(*cur_)) + return WasmToken(WasmToken::Store, Op::I64Store, begin, cur_); + if (consume(u"8")) + return WasmToken(WasmToken::Store, Op::I64Store8, begin, cur_); + if (consume(u"16")) + return WasmToken(WasmToken::Store, Op::I64Store16, begin, cur_); + if (consume(u"32")) + return WasmToken(WasmToken::Store, Op::I64Store32, begin, cur_); + break; + } + break; + case 't': + if (consume(u"trunc_s/f32")) + return WasmToken(WasmToken::ConversionOpcode, Op::I64TruncSF32, + begin, cur_); + if (consume(u"trunc_s/f64")) + return WasmToken(WasmToken::ConversionOpcode, Op::I64TruncSF64, + begin, cur_); + if (consume(u"trunc_u/f32")) + return WasmToken(WasmToken::ConversionOpcode, Op::I64TruncUF32, + begin, cur_); + if (consume(u"trunc_u/f64")) + return WasmToken(WasmToken::ConversionOpcode, Op::I64TruncUF64, + begin, cur_); + break; + case 'x': + if (consume(u"xor")) + return WasmToken(WasmToken::BinaryOpcode, Op::I64Xor, begin, cur_); + break; + } + break; + } + if (consume(u"import")) + return WasmToken(WasmToken::Import, begin, cur_); + if (consume(u"infinity")) + return WasmToken(WasmToken::Infinity, begin, cur_); + if (consume(u"if")) + return WasmToken(WasmToken::If, begin, cur_); + break; + + case 'l': + if (consume(u"local")) + return WasmToken(WasmToken::Local, begin, cur_); + if (consume(u"loop")) + return WasmToken(WasmToken::Loop, begin, cur_); + break; + + case 'm': + if (consume(u"module")) + return WasmToken(WasmToken::Module, begin, cur_); + if (consume(u"memory")) + return WasmToken(WasmToken::Memory, begin, cur_); + if (consume(u"mut")) + return WasmToken(WasmToken::Mutable, begin, cur_); + break; + + case 'n': + if (consume(u"nan")) + return nan(begin); + if (consume(u"nop")) + return WasmToken(WasmToken::Nop, begin, cur_); + break; + + case 'o': + if (consume(u"offset")) + return WasmToken(WasmToken::Offset, begin, cur_); + break; + + case 'p': + if (consume(u"param")) + return WasmToken(WasmToken::Param, begin, cur_); + break; + + case 'r': + if (consume(u"result")) + return WasmToken(WasmToken::Result, begin, cur_); + if (consume(u"return")) + return WasmToken(WasmToken::Return, begin, cur_); + break; + + case 's': + if (consume(u"select")) + return WasmToken(WasmToken::TernaryOpcode, Op::Select, begin, cur_); + if (consume(u"set_global")) + return WasmToken(WasmToken::SetGlobal, begin, cur_); + if (consume(u"set_local")) + return WasmToken(WasmToken::SetLocal, begin, cur_); + if (consume(u"start")) + return WasmToken(WasmToken::Start, begin, cur_); + break; + + case 't': + if (consume(u"table")) + return WasmToken(WasmToken::Table, begin, cur_); + if (consume(u"tee_local")) + return WasmToken(WasmToken::TeeLocal, begin, cur_); + if (consume(u"then")) + return WasmToken(WasmToken::Then, begin, cur_); + if (consume(u"type")) + return WasmToken(WasmToken::Type, begin, cur_); + break; + + case 'u': + if (consume(u"unreachable")) + return WasmToken(WasmToken::Unreachable, begin, cur_); + break; + + default: + break; + } + + return fail(begin); +} + +/*****************************************************************************/ +// wasm text format parser + +namespace { + +struct WasmParseContext +{ + WasmTokenStream ts; + LifoAlloc& lifo; + UniqueChars* error; + DtoaState* dtoaState; + + WasmParseContext(const char16_t* text, LifoAlloc& lifo, UniqueChars* error) + : ts(text, error), + lifo(lifo), + error(error), + dtoaState(NewDtoaState()) + {} + + bool fail(const char* message) { + error->reset(js_strdup(message)); + return false; + } + ~WasmParseContext() { + DestroyDtoaState(dtoaState); + } +}; + +} // end anonymous namespace + +static AstExpr* +ParseExprInsideParens(WasmParseContext& c); + +static AstExpr* +ParseExprBody(WasmParseContext& c, WasmToken token, bool inParens); + +static AstExpr* +ParseExpr(WasmParseContext& c, bool inParens) +{ + WasmToken openParen; + if (!inParens || !c.ts.getIf(WasmToken::OpenParen, &openParen)) + return new(c.lifo) AstPop(); + + // Special case: If we have an open paren, but it's a "(then ...", then + // we don't have an expresion following us, so we pop here too. This + // handles "(if (then ...))" which pops the condition. + if (c.ts.peek().kind() == WasmToken::Then) { + c.ts.unget(openParen); + return new(c.lifo) AstPop(); + } + + AstExpr* expr = ParseExprInsideParens(c); + if (!expr) + return nullptr; + + if (!c.ts.match(WasmToken::CloseParen, c.error)) + return nullptr; + + return expr; +} + +static bool +ParseExprList(WasmParseContext& c, AstExprVector* exprs, bool inParens) +{ + for (;;) { + if (c.ts.getIf(WasmToken::OpenParen)) { + AstExpr* expr = ParseExprInsideParens(c); + if (!expr || !exprs->append(expr)) + return false; + if (!c.ts.match(WasmToken::CloseParen, c.error)) + return false; + continue; + } + + WasmToken token; + if (c.ts.getIfOpcode(&token)) { + AstExpr* expr = ParseExprBody(c, token, false); + if (!expr || !exprs->append(expr)) + return false; + continue; + } + + break; + } + + return true; +} + +static bool +ParseBlockSignature(WasmParseContext& c, ExprType* type) +{ + WasmToken token; + if (c.ts.getIf(WasmToken::ValueType, &token)) + *type = ToExprType(token.valueType()); + else + *type = ExprType::Void; + + return true; +} + +static AstBlock* +ParseBlock(WasmParseContext& c, Op op, bool inParens) +{ + AstExprVector exprs(c.lifo); + + AstName name = c.ts.getIfName(); + + // Compatibility syntax sugar: If a second label is present, we'll wrap + // this loop in a block. + AstName otherName; + if (op == Op::Loop) { + AstName maybeName = c.ts.getIfName(); + if (!maybeName.empty()) { + otherName = name; + name = maybeName; + } + } + + ExprType type; + if (!ParseBlockSignature(c, &type)) + return nullptr; + + if (!ParseExprList(c, &exprs, inParens)) + return nullptr; + + if (!inParens) { + if (!c.ts.match(WasmToken::End, c.error)) + return nullptr; + } + + AstBlock* result = new(c.lifo) AstBlock(op, type, name, Move(exprs)); + + if (op == Op::Loop && !otherName.empty()) { + if (!exprs.append(result)) + return nullptr; + result = new(c.lifo) AstBlock(Op::Block, type, otherName, Move(exprs)); + } + + return result; +} + +static AstBranch* +ParseBranch(WasmParseContext& c, Op op, bool inParens) +{ + MOZ_ASSERT(op == Op::Br || op == Op::BrIf); + + AstRef target; + if (!c.ts.matchRef(&target, c.error)) + return nullptr; + + AstExpr* value = nullptr; + if (inParens) { + if (c.ts.getIf(WasmToken::OpenParen)) { + value = ParseExprInsideParens(c); + if (!value) + return nullptr; + if (!c.ts.match(WasmToken::CloseParen, c.error)) + return nullptr; + } + } + + AstExpr* cond = nullptr; + if (op == Op::BrIf) { + if (inParens && c.ts.getIf(WasmToken::OpenParen)) { + cond = ParseExprInsideParens(c); + if (!cond) + return nullptr; + if (!c.ts.match(WasmToken::CloseParen, c.error)) + return nullptr; + } else { + cond = new(c.lifo) AstPop(); + if (!cond) + return nullptr; + } + } + + return new(c.lifo) AstBranch(op, ExprType::Void, cond, target, value); +} + +static bool +ParseArgs(WasmParseContext& c, AstExprVector* args) +{ + while (c.ts.getIf(WasmToken::OpenParen)) { + AstExpr* arg = ParseExprInsideParens(c); + if (!arg || !args->append(arg)) + return false; + if (!c.ts.match(WasmToken::CloseParen, c.error)) + return false; + } + + return true; +} + +static AstCall* +ParseCall(WasmParseContext& c, bool inParens) +{ + AstRef func; + if (!c.ts.matchRef(&func, c.error)) + return nullptr; + + AstExprVector args(c.lifo); + if (inParens) { + if (!ParseArgs(c, &args)) + return nullptr; + } + + return new(c.lifo) AstCall(Op::Call, ExprType::Void, func, Move(args)); +} + +static AstCallIndirect* +ParseCallIndirect(WasmParseContext& c, bool inParens) +{ + AstRef sig; + if (!c.ts.matchRef(&sig, c.error)) + return nullptr; + + AstExprVector args(c.lifo); + AstExpr* index; + if (inParens) { + if (!ParseArgs(c, &args)) + return nullptr; + + if (args.empty()) + index = new(c.lifo) AstPop(); + else + index = args.popCopy(); + } else { + index = new(c.lifo) AstPop(); + } + + return new(c.lifo) AstCallIndirect(sig, ExprType::Void, Move(args), index); +} + +static uint_fast8_t +CountLeadingZeroes4(uint8_t x) +{ + MOZ_ASSERT((x & -0x10) == 0); + return CountLeadingZeroes32(x) - 28; +} + +template <typename T> +static T +ushl(T lhs, unsigned rhs) +{ + return rhs < sizeof(T) * CHAR_BIT ? (lhs << rhs) : 0; +} + +template <typename T> +static T +ushr(T lhs, unsigned rhs) +{ + return rhs < sizeof(T) * CHAR_BIT ? (lhs >> rhs) : 0; +} + +template<typename Float> +static AstConst* +ParseNaNLiteral(WasmParseContext& c, WasmToken token, const char16_t* cur, bool isNegated) +{ + const char16_t* end = token.end(); + + MOZ_ALWAYS_TRUE(*cur++ == 'n' && *cur++ == 'a' && *cur++ == 'n'); + + typedef FloatingPoint<Float> Traits; + typedef typename Traits::Bits Bits; + + Bits value; + if (cur != end) { + MOZ_ALWAYS_TRUE(*cur++ == ':' && *cur++ == '0' && *cur++ == 'x'); + if (cur == end) + goto error; + CheckedInt<Bits> u = 0; + do { + uint8_t digit = 0; + MOZ_ALWAYS_TRUE(IsHexDigit(*cur, &digit)); + u *= 16; + u += digit; + cur++; + } while (cur != end); + if (!u.isValid()) + goto error; + value = u.value(); + if ((value & ~Traits::kSignificandBits) != 0) + goto error; + // NaN payloads must contain at least one set bit. + if (value == 0) + goto error; + } else { + // Produce the spec's default NaN. + value = (Traits::kSignificandBits + 1) >> 1; + } + + value = (isNegated ? Traits::kSignBit : 0) | Traits::kExponentBits | value; + return new (c.lifo) AstConst(Val(Raw<Float>::fromBits(value))); + + error: + c.ts.generateError(token, c.error); + return nullptr; +} + +template <typename Float> +static bool +ParseHexFloatLiteral(const char16_t* cur, const char16_t* end, Float* result) +{ + MOZ_ALWAYS_TRUE(*cur++ == '0' && *cur++ == 'x'); + typedef FloatingPoint<Float> Traits; + typedef typename Traits::Bits Bits; + static const unsigned numBits = sizeof(Float) * CHAR_BIT; + static const Bits allOnes = ~Bits(0); + static const Bits mostSignificantBit = ~(allOnes >> 1); + + // Significand part. + Bits significand = 0; + CheckedInt<int32_t> exponent = 0; + bool sawFirstNonZero = false; + bool discardedExtraNonZero = false; + const char16_t* dot = nullptr; + int significandPos; + for (; cur != end; cur++) { + if (*cur == '.') { + MOZ_ASSERT(!dot); + dot = cur; + continue; + } + + uint8_t digit; + if (!IsHexDigit(*cur, &digit)) + break; + if (!sawFirstNonZero) { + if (digit == 0) + continue; + // We've located the first non-zero digit; we can now determine the + // initial exponent. If we're after the dot, count the number of + // zeros from the dot to here, and adjust for the number of leading + // zero bits in the digit. Set up significandPos to put the first + // nonzero at the most significant bit. + int_fast8_t lz = CountLeadingZeroes4(digit); + ptrdiff_t zeroAdjustValue = !dot ? 1 : dot + 1 - cur; + CheckedInt<ptrdiff_t> zeroAdjust = zeroAdjustValue; + zeroAdjust *= 4; + zeroAdjust -= lz + 1; + if (!zeroAdjust.isValid()) + return false; + exponent = zeroAdjust.value(); + significandPos = numBits - (4 - lz); + sawFirstNonZero = true; + } else { + // We've already seen a non-zero; just take 4 more bits. + if (!dot) + exponent += 4; + if (significandPos > -4) + significandPos -= 4; + } + + // Or the newly parsed digit into significand at signicandPos. + if (significandPos >= 0) { + significand |= ushl(Bits(digit), significandPos); + } else if (significandPos > -4) { + significand |= ushr(digit, 4 - significandPos); + discardedExtraNonZero = (digit & ~ushl(allOnes, 4 - significandPos)) != 0; + } else if (digit != 0) { + discardedExtraNonZero = true; + } + } + + // Exponent part. + if (cur != end) { + MOZ_ALWAYS_TRUE(*cur++ == 'p'); + bool isNegated = false; + if (cur != end && (*cur == '-' || *cur == '+')) + isNegated = *cur++ == '-'; + CheckedInt<int32_t> parsedExponent = 0; + while (cur != end && IsWasmDigit(*cur)) + parsedExponent = parsedExponent * 10 + (*cur++ - '0'); + if (isNegated) + parsedExponent = -parsedExponent; + exponent += parsedExponent; + } + + MOZ_ASSERT(cur == end); + if (!exponent.isValid()) + return false; + + // Create preliminary exponent and significand encodings of the results. + Bits encodedExponent, encodedSignificand, discardedSignificandBits; + if (significand == 0) { + // Zero. The exponent is encoded non-biased. + encodedExponent = 0; + encodedSignificand = 0; + discardedSignificandBits = 0; + } else if (MOZ_UNLIKELY(exponent.value() <= int32_t(-Traits::kExponentBias))) { + // Underflow to subnormal or zero. + encodedExponent = 0; + encodedSignificand = ushr(significand, + numBits - Traits::kExponentShift - + exponent.value() - Traits::kExponentBias); + discardedSignificandBits = + ushl(significand, + Traits::kExponentShift + exponent.value() + Traits::kExponentBias); + } else if (MOZ_LIKELY(exponent.value() <= int32_t(Traits::kExponentBias))) { + // Normal (non-zero). The significand's leading 1 is encoded implicitly. + encodedExponent = (Bits(exponent.value()) + Traits::kExponentBias) << + Traits::kExponentShift; + MOZ_ASSERT(significand & mostSignificantBit); + encodedSignificand = ushr(significand, numBits - Traits::kExponentShift - 1) & + Traits::kSignificandBits; + discardedSignificandBits = ushl(significand, Traits::kExponentShift + 1); + } else { + // Overflow to infinity. + encodedExponent = Traits::kExponentBits; + encodedSignificand = 0; + discardedSignificandBits = 0; + } + MOZ_ASSERT((encodedExponent & ~Traits::kExponentBits) == 0); + MOZ_ASSERT((encodedSignificand & ~Traits::kSignificandBits) == 0); + MOZ_ASSERT(encodedExponent != Traits::kExponentBits || encodedSignificand == 0); + Bits bits = encodedExponent | encodedSignificand; + + // Apply rounding. If this overflows the significand, it carries into the + // exponent bit according to the magic of the IEEE 754 encoding. + bits += (discardedSignificandBits & mostSignificantBit) && + ((discardedSignificandBits & ~mostSignificantBit) || + discardedExtraNonZero || + // ties to even + (encodedSignificand & 1)); + + *result = BitwiseCast<Float>(bits); + return true; +} + +template <typename Float> +static AstConst* +ParseFloatLiteral(WasmParseContext& c, WasmToken token) +{ + Float result; + switch (token.kind()) { + case WasmToken::Index: result = token.index(); break; + case WasmToken::UnsignedInteger: result = token.uint(); break; + case WasmToken::SignedInteger: result = token.sint(); break; + case WasmToken::NegativeZero: result = -0.; break; + case WasmToken::Float: break; + default: c.ts.generateError(token, c.error); return nullptr; + } + + if (token.kind() != WasmToken::Float) + return new (c.lifo) AstConst(Val(Raw<Float>(result))); + + const char16_t* begin = token.begin(); + const char16_t* end = token.end(); + const char16_t* cur = begin; + + bool isNegated = false; + if (*cur == '-' || *cur == '+') + isNegated = *cur++ == '-'; + + switch (token.floatLiteralKind()) { + case WasmToken::Infinity: { + result = PositiveInfinity<Float>(); + break; + } + case WasmToken::NaN: { + return ParseNaNLiteral<Float>(c, token, cur, isNegated); + } + case WasmToken::HexNumber: { + if (!ParseHexFloatLiteral(cur, end, &result)) { + c.ts.generateError(token, c.error); + return nullptr; + } + break; + } + case WasmToken::DecNumber: { + // Call into JS' strtod. Tokenization has already required that the + // string is well-behaved. + LifoAlloc::Mark mark = c.lifo.mark(); + char* buffer = c.lifo.newArray<char>(end - cur + 1); + if (!buffer) + return nullptr; + for (ptrdiff_t i = 0; i < end - cur; ++i) + buffer[i] = char(cur[i]); + buffer[end - cur] = '\0'; + char* strtod_end; + int err; + result = (Float)js_strtod_harder(c.dtoaState, buffer, &strtod_end, &err); + if (err != 0 || strtod_end == buffer) { + c.lifo.release(mark); + c.ts.generateError(token, c.error); + return nullptr; + } + c.lifo.release(mark); + break; + } + } + + if (isNegated) + result = -result; + + return new (c.lifo) AstConst(Val(Raw<Float>(result))); +} + +static AstConst* +ParseConst(WasmParseContext& c, WasmToken constToken) +{ + WasmToken val = c.ts.get(); + switch (constToken.valueType()) { + case ValType::I32: { + switch (val.kind()) { + case WasmToken::Index: + return new(c.lifo) AstConst(Val(val.index())); + case WasmToken::SignedInteger: { + CheckedInt<int32_t> sint = val.sint(); + if (!sint.isValid()) + break; + return new(c.lifo) AstConst(Val(uint32_t(sint.value()))); + } + case WasmToken::NegativeZero: + return new(c.lifo) AstConst(Val(uint32_t(0))); + default: + break; + } + break; + } + case ValType::I64: { + switch (val.kind()) { + case WasmToken::Index: + return new(c.lifo) AstConst(Val(uint64_t(val.index()))); + case WasmToken::UnsignedInteger: + return new(c.lifo) AstConst(Val(val.uint())); + case WasmToken::SignedInteger: + return new(c.lifo) AstConst(Val(uint64_t(val.sint()))); + case WasmToken::NegativeZero: + return new(c.lifo) AstConst(Val(uint64_t(0))); + default: + break; + } + break; + } + case ValType::F32: { + return ParseFloatLiteral<float>(c, val); + } + case ValType::F64: { + return ParseFloatLiteral<double>(c, val); + } + default: + break; + } + c.ts.generateError(constToken, c.error); + return nullptr; +} + +static AstGetLocal* +ParseGetLocal(WasmParseContext& c) +{ + AstRef local; + if (!c.ts.matchRef(&local, c.error)) + return nullptr; + + return new(c.lifo) AstGetLocal(local); +} + +static AstGetGlobal* +ParseGetGlobal(WasmParseContext& c) +{ + AstRef local; + if (!c.ts.matchRef(&local, c.error)) + return nullptr; + return new(c.lifo) AstGetGlobal(local); +} + +static AstSetGlobal* +ParseSetGlobal(WasmParseContext& c, bool inParens) +{ + AstRef global; + if (!c.ts.matchRef(&global, c.error)) + return nullptr; + + AstExpr* value = ParseExpr(c, inParens); + if (!value) + return nullptr; + + return new(c.lifo) AstSetGlobal(global, *value); +} + +static AstSetLocal* +ParseSetLocal(WasmParseContext& c, bool inParens) +{ + AstRef local; + if (!c.ts.matchRef(&local, c.error)) + return nullptr; + + AstExpr* value = ParseExpr(c, inParens); + if (!value) + return nullptr; + + return new(c.lifo) AstSetLocal(local, *value); +} + +static AstTeeLocal* +ParseTeeLocal(WasmParseContext& c, bool inParens) +{ + AstRef local; + if (!c.ts.matchRef(&local, c.error)) + return nullptr; + + AstExpr* value = ParseExpr(c, inParens); + if (!value) + return nullptr; + + return new(c.lifo) AstTeeLocal(local, *value); +} + +static AstReturn* +ParseReturn(WasmParseContext& c, bool inParens) +{ + AstExpr* maybeExpr = nullptr; + + if (c.ts.peek().kind() != WasmToken::CloseParen) { + maybeExpr = ParseExpr(c, inParens); + if (!maybeExpr) + return nullptr; + } + + return new(c.lifo) AstReturn(maybeExpr); +} + +static AstUnaryOperator* +ParseUnaryOperator(WasmParseContext& c, Op op, bool inParens) +{ + AstExpr* operand = ParseExpr(c, inParens); + if (!operand) + return nullptr; + + return new(c.lifo) AstUnaryOperator(op, operand); +} + +static AstBinaryOperator* +ParseBinaryOperator(WasmParseContext& c, Op op, bool inParens) +{ + AstExpr* lhs = ParseExpr(c, inParens); + if (!lhs) + return nullptr; + + AstExpr* rhs = ParseExpr(c, inParens); + if (!rhs) + return nullptr; + + return new(c.lifo) AstBinaryOperator(op, lhs, rhs); +} + +static AstComparisonOperator* +ParseComparisonOperator(WasmParseContext& c, Op op, bool inParens) +{ + AstExpr* lhs = ParseExpr(c, inParens); + if (!lhs) + return nullptr; + + AstExpr* rhs = ParseExpr(c, inParens); + if (!rhs) + return nullptr; + + return new(c.lifo) AstComparisonOperator(op, lhs, rhs); +} + +static AstTernaryOperator* +ParseTernaryOperator(WasmParseContext& c, Op op, bool inParens) +{ + AstExpr* op0 = ParseExpr(c, inParens); + if (!op0) + return nullptr; + + AstExpr* op1 = ParseExpr(c, inParens); + if (!op1) + return nullptr; + + AstExpr* op2 = ParseExpr(c, inParens); + if (!op2) + return nullptr; + + return new(c.lifo) AstTernaryOperator(op, op0, op1, op2); +} + +static AstConversionOperator* +ParseConversionOperator(WasmParseContext& c, Op op, bool inParens) +{ + AstExpr* operand = ParseExpr(c, inParens); + if (!operand) + return nullptr; + + return new(c.lifo) AstConversionOperator(op, operand); +} + +static AstDrop* +ParseDrop(WasmParseContext& c, bool inParens) +{ + AstExpr* value = ParseExpr(c, inParens); + if (!value) + return nullptr; + + return new(c.lifo) AstDrop(*value); +} + +static AstIf* +ParseIf(WasmParseContext& c, bool inParens) +{ + AstName name = c.ts.getIfName(); + + ExprType type; + if (!ParseBlockSignature(c, &type)) + return nullptr; + + AstExpr* cond = ParseExpr(c, inParens); + if (!cond) + return nullptr; + + if (inParens) { + if (!c.ts.match(WasmToken::OpenParen, c.error)) + return nullptr; + } + + AstExprVector thenExprs(c.lifo); + if (!inParens || c.ts.getIf(WasmToken::Then)) { + if (!ParseExprList(c, &thenExprs, inParens)) + return nullptr; + } else { + AstExpr* thenBranch = ParseExprInsideParens(c); + if (!thenBranch || !thenExprs.append(thenBranch)) + return nullptr; + } + if (inParens) { + if (!c.ts.match(WasmToken::CloseParen, c.error)) + return nullptr; + } + + AstExprVector elseExprs(c.lifo); + if (!inParens || c.ts.getIf(WasmToken::OpenParen)) { + if (c.ts.getIf(WasmToken::Else)) { + if (!ParseExprList(c, &elseExprs, inParens)) + return nullptr; + } else if (inParens) { + AstExpr* elseBranch = ParseExprInsideParens(c); + if (!elseBranch || !elseExprs.append(elseBranch)) + return nullptr; + } + if (inParens) { + if (!c.ts.match(WasmToken::CloseParen, c.error)) + return nullptr; + } else { + if (!c.ts.match(WasmToken::End, c.error)) + return nullptr; + } + } + + return new(c.lifo) AstIf(type, cond, name, Move(thenExprs), Move(elseExprs)); +} + +static bool +ParseLoadStoreAddress(WasmParseContext& c, int32_t* offset, uint32_t* alignLog2, AstExpr** base, + bool inParens) +{ + *offset = 0; + if (c.ts.getIf(WasmToken::Offset)) { + if (!c.ts.match(WasmToken::Equal, c.error)) + return false; + WasmToken val = c.ts.get(); + switch (val.kind()) { + case WasmToken::Index: + *offset = val.index(); + break; + default: + c.ts.generateError(val, c.error); + return false; + } + } + + *alignLog2 = UINT32_MAX; + if (c.ts.getIf(WasmToken::Align)) { + if (!c.ts.match(WasmToken::Equal, c.error)) + return false; + WasmToken val = c.ts.get(); + switch (val.kind()) { + case WasmToken::Index: + if (!IsPowerOfTwo(val.index())) { + c.ts.generateError(val, "non-power-of-two alignment", c.error); + return false; + } + *alignLog2 = CeilingLog2(val.index()); + break; + default: + c.ts.generateError(val, c.error); + return false; + } + } + + *base = ParseExpr(c, inParens); + if (!*base) + return false; + + return true; +} + +static AstLoad* +ParseLoad(WasmParseContext& c, Op op, bool inParens) +{ + int32_t offset; + uint32_t alignLog2; + AstExpr* base; + if (!ParseLoadStoreAddress(c, &offset, &alignLog2, &base, inParens)) + return nullptr; + + if (alignLog2 == UINT32_MAX) { + switch (op) { + case Op::I32Load8S: + case Op::I32Load8U: + case Op::I64Load8S: + case Op::I64Load8U: + alignLog2 = 0; + break; + case Op::I32Load16S: + case Op::I32Load16U: + case Op::I64Load16S: + case Op::I64Load16U: + alignLog2 = 1; + break; + case Op::I32Load: + case Op::F32Load: + case Op::I64Load32S: + case Op::I64Load32U: + alignLog2 = 2; + break; + case Op::I64Load: + case Op::F64Load: + alignLog2 = 3; + break; + default: + MOZ_CRASH("Bad load op"); + } + } + + uint32_t flags = alignLog2; + + return new(c.lifo) AstLoad(op, AstLoadStoreAddress(base, flags, offset)); +} + +static AstStore* +ParseStore(WasmParseContext& c, Op op, bool inParens) +{ + int32_t offset; + uint32_t alignLog2; + AstExpr* base; + if (!ParseLoadStoreAddress(c, &offset, &alignLog2, &base, inParens)) + return nullptr; + + if (alignLog2 == UINT32_MAX) { + switch (op) { + case Op::I32Store8: + case Op::I64Store8: + alignLog2 = 0; + break; + case Op::I32Store16: + case Op::I64Store16: + alignLog2 = 1; + break; + case Op::I32Store: + case Op::F32Store: + case Op::I64Store32: + alignLog2 = 2; + break; + case Op::I64Store: + case Op::F64Store: + alignLog2 = 3; + break; + default: + MOZ_CRASH("Bad load op"); + } + } + + AstExpr* value = ParseExpr(c, inParens); + if (!value) + return nullptr; + + uint32_t flags = alignLog2; + + return new(c.lifo) AstStore(op, AstLoadStoreAddress(base, flags, offset), value); +} + +static AstBranchTable* +ParseBranchTable(WasmParseContext& c, WasmToken brTable, bool inParens) +{ + AstRefVector table(c.lifo); + + AstRef target; + while (c.ts.getIfRef(&target)) { + if (!table.append(target)) + return nullptr; + } + + if (table.empty()) { + c.ts.generateError(c.ts.get(), c.error); + return nullptr; + } + + AstRef def = table.popCopy(); + + AstExpr* index = ParseExpr(c, inParens); + if (!index) + return nullptr; + + AstExpr* value = nullptr; + if (inParens) { + if (c.ts.getIf(WasmToken::OpenParen)) { + value = index; + index = ParseExprInsideParens(c); + if (!index) + return nullptr; + if (!c.ts.match(WasmToken::CloseParen, c.error)) + return nullptr; + } + } + + return new(c.lifo) AstBranchTable(*index, def, Move(table), value); +} + +static AstGrowMemory* +ParseGrowMemory(WasmParseContext& c, bool inParens) +{ + AstExpr* operand = ParseExpr(c, inParens); + if (!operand) + return nullptr; + + return new(c.lifo) AstGrowMemory(operand); +} + +static AstExpr* +ParseExprBody(WasmParseContext& c, WasmToken token, bool inParens) +{ + switch (token.kind()) { + case WasmToken::Unreachable: + return new(c.lifo) AstUnreachable; + case WasmToken::BinaryOpcode: + return ParseBinaryOperator(c, token.op(), inParens); + case WasmToken::Block: + return ParseBlock(c, Op::Block, inParens); + case WasmToken::Br: + return ParseBranch(c, Op::Br, inParens); + case WasmToken::BrIf: + return ParseBranch(c, Op::BrIf, inParens); + case WasmToken::BrTable: + return ParseBranchTable(c, token, inParens); + case WasmToken::Call: + return ParseCall(c, inParens); + case WasmToken::CallIndirect: + return ParseCallIndirect(c, inParens); + case WasmToken::ComparisonOpcode: + return ParseComparisonOperator(c, token.op(), inParens); + case WasmToken::Const: + return ParseConst(c, token); + case WasmToken::ConversionOpcode: + return ParseConversionOperator(c, token.op(), inParens); + case WasmToken::Drop: + return ParseDrop(c, inParens); + case WasmToken::If: + return ParseIf(c, inParens); + case WasmToken::GetGlobal: + return ParseGetGlobal(c); + case WasmToken::GetLocal: + return ParseGetLocal(c); + case WasmToken::Load: + return ParseLoad(c, token.op(), inParens); + case WasmToken::Loop: + return ParseBlock(c, Op::Loop, inParens); + case WasmToken::Return: + return ParseReturn(c, inParens); + case WasmToken::SetGlobal: + return ParseSetGlobal(c, inParens); + case WasmToken::SetLocal: + return ParseSetLocal(c, inParens); + case WasmToken::Store: + return ParseStore(c, token.op(), inParens); + case WasmToken::TeeLocal: + return ParseTeeLocal(c, inParens); + case WasmToken::TernaryOpcode: + return ParseTernaryOperator(c, token.op(), inParens); + case WasmToken::UnaryOpcode: + return ParseUnaryOperator(c, token.op(), inParens); + case WasmToken::Nop: + return new(c.lifo) AstNop(); + case WasmToken::CurrentMemory: + return new(c.lifo) AstCurrentMemory(); + case WasmToken::GrowMemory: + return ParseGrowMemory(c, inParens); + default: + c.ts.generateError(token, c.error); + return nullptr; + } +} + +static AstExpr* +ParseExprInsideParens(WasmParseContext& c) +{ + WasmToken token = c.ts.get(); + + return ParseExprBody(c, token, true); +} + +static bool +ParseValueTypeList(WasmParseContext& c, AstValTypeVector* vec) +{ + WasmToken token; + while (c.ts.getIf(WasmToken::ValueType, &token)) { + if (!vec->append(token.valueType())) + return false; + } + + return true; +} + +static bool +ParseResult(WasmParseContext& c, ExprType* result) +{ + if (*result != ExprType::Void) { + c.ts.generateError(c.ts.peek(), c.error); + return false; + } + + WasmToken token; + if (!c.ts.match(WasmToken::ValueType, &token, c.error)) + return false; + + *result = ToExprType(token.valueType()); + return true; +} + +static bool +ParseLocalOrParam(WasmParseContext& c, AstNameVector* locals, AstValTypeVector* localTypes) +{ + if (c.ts.peek().kind() != WasmToken::Name) + return locals->append(AstName()) && ParseValueTypeList(c, localTypes); + + WasmToken token; + return locals->append(c.ts.get().name()) && + c.ts.match(WasmToken::ValueType, &token, c.error) && + localTypes->append(token.valueType()); +} + +static bool +ParseInlineImport(WasmParseContext& c, InlineImport* import) +{ + return c.ts.match(WasmToken::Text, &import->module, c.error) && + c.ts.match(WasmToken::Text, &import->field, c.error); +} + +static bool +ParseInlineExport(WasmParseContext& c, DefinitionKind kind, AstModule* module, AstRef ref) +{ + WasmToken name; + if (!c.ts.match(WasmToken::Text, &name, c.error)) + return false; + + AstExport* exp = new(c.lifo) AstExport(name.text(), kind, ref); + return exp && module->append(exp); +} + +static bool +MaybeParseTypeUse(WasmParseContext& c, AstRef* sig) +{ + WasmToken openParen; + if (c.ts.getIf(WasmToken::OpenParen, &openParen)) { + if (c.ts.getIf(WasmToken::Type)) { + if (!c.ts.matchRef(sig, c.error)) + return false; + if (!c.ts.match(WasmToken::CloseParen, c.error)) + return false; + } else { + c.ts.unget(openParen); + } + } + return true; +} + +static bool +ParseFuncSig(WasmParseContext& c, AstSig* sig) +{ + AstValTypeVector args(c.lifo); + ExprType result = ExprType::Void; + + while (c.ts.getIf(WasmToken::OpenParen)) { + WasmToken token = c.ts.get(); + switch (token.kind()) { + case WasmToken::Param: + if (!ParseValueTypeList(c, &args)) + return false; + break; + case WasmToken::Result: + if (!ParseResult(c, &result)) + return false; + break; + default: + c.ts.generateError(token, c.error); + return false; + } + if (!c.ts.match(WasmToken::CloseParen, c.error)) + return false; + } + + *sig = AstSig(Move(args), result); + return true; +} + +static bool +ParseFuncType(WasmParseContext& c, AstRef* ref, AstModule* module) +{ + if (!MaybeParseTypeUse(c, ref)) + return false; + + if (ref->isInvalid()) { + AstSig sig(c.lifo); + if (!ParseFuncSig(c, &sig)) + return false; + uint32_t sigIndex; + if (!module->declare(Move(sig), &sigIndex)) + return false; + ref->setIndex(sigIndex); + } + + return true; +} + +static bool +ParseFunc(WasmParseContext& c, AstModule* module) +{ + AstValTypeVector vars(c.lifo); + AstValTypeVector args(c.lifo); + AstNameVector locals(c.lifo); + + AstName funcName = c.ts.getIfName(); + + // Inline imports and exports. + WasmToken openParen; + if (c.ts.getIf(WasmToken::OpenParen, &openParen)) { + if (c.ts.getIf(WasmToken::Import)) { + if (module->funcs().length()) { + c.ts.generateError(openParen, "import after function definition", c.error); + return false; + } + + InlineImport names; + if (!ParseInlineImport(c, &names)) + return false; + if (!c.ts.match(WasmToken::CloseParen, c.error)) + return false; + + AstRef sig; + if (!ParseFuncType(c, &sig, module)) + return false; + + auto* imp = new(c.lifo) AstImport(funcName, names.module.text(), names.field.text(), sig); + return imp && module->append(imp); + } + + if (c.ts.getIf(WasmToken::Export)) { + AstRef ref = funcName.empty() + ? AstRef(module->funcImportNames().length() + module->funcs().length()) + : AstRef(funcName); + if (!ParseInlineExport(c, DefinitionKind::Function, module, ref)) + return false; + if (!c.ts.match(WasmToken::CloseParen, c.error)) + return false; + } else { + c.ts.unget(openParen); + } + } + + AstRef sigRef; + if (!MaybeParseTypeUse(c, &sigRef)) + return false; + + AstExprVector body(c.lifo); + + ExprType result = ExprType::Void; + while (c.ts.getIf(WasmToken::OpenParen)) { + WasmToken token = c.ts.get(); + switch (token.kind()) { + case WasmToken::Local: + if (!ParseLocalOrParam(c, &locals, &vars)) + return false; + break; + case WasmToken::Param: + if (!vars.empty()) { + c.ts.generateError(token, c.error); + return false; + } + if (!ParseLocalOrParam(c, &locals, &args)) + return false; + break; + case WasmToken::Result: + if (!ParseResult(c, &result)) + return false; + break; + default: + c.ts.unget(token); + AstExpr* expr = ParseExprInsideParens(c); + if (!expr || !body.append(expr)) + return false; + break; + } + if (!c.ts.match(WasmToken::CloseParen, c.error)) + return false; + } + + if (!ParseExprList(c, &body, true)) + return false; + + if (sigRef.isInvalid()) { + uint32_t sigIndex; + if (!module->declare(AstSig(Move(args), result), &sigIndex)) + return false; + sigRef.setIndex(sigIndex); + } + + auto* func = new(c.lifo) AstFunc(funcName, sigRef, Move(vars), Move(locals), Move(body)); + return func && module->append(func); +} + +static AstSig* +ParseTypeDef(WasmParseContext& c) +{ + AstName name = c.ts.getIfName(); + + if (!c.ts.match(WasmToken::OpenParen, c.error)) + return nullptr; + if (!c.ts.match(WasmToken::Func, c.error)) + return nullptr; + + AstSig sig(c.lifo); + if (!ParseFuncSig(c, &sig)) + return nullptr; + + if (!c.ts.match(WasmToken::CloseParen, c.error)) + return nullptr; + + return new(c.lifo) AstSig(name, Move(sig)); +} + +static bool +MaybeParseOwnerIndex(WasmParseContext& c) +{ + if (c.ts.peek().kind() == WasmToken::Index) { + WasmToken elemIndex = c.ts.get(); + if (elemIndex.index()) { + c.ts.generateError(elemIndex, "can't handle non-default memory/table yet", c.error); + return false; + } + } + return true; +} + +static AstExpr* +ParseInitializerExpression(WasmParseContext& c) +{ + if (!c.ts.match(WasmToken::OpenParen, c.error)) + return nullptr; + + AstExpr* initExpr = ParseExprInsideParens(c); + if (!initExpr) + return nullptr; + + if (!c.ts.match(WasmToken::CloseParen, c.error)) + return nullptr; + + return initExpr; +} + +static AstDataSegment* +ParseDataSegment(WasmParseContext& c) +{ + if (!MaybeParseOwnerIndex(c)) + return nullptr; + + AstExpr* offset = ParseInitializerExpression(c); + if (!offset) + return nullptr; + + AstNameVector fragments(c.lifo); + + WasmToken text; + while (c.ts.getIf(WasmToken::Text, &text)) { + if (!fragments.append(text.text())) + return nullptr; + } + + return new(c.lifo) AstDataSegment(offset, Move(fragments)); +} + +static bool +ParseLimits(WasmParseContext& c, Limits* limits) +{ + WasmToken initial; + if (!c.ts.match(WasmToken::Index, &initial, c.error)) + return false; + + Maybe<uint32_t> maximum; + WasmToken token; + if (c.ts.getIf(WasmToken::Index, &token)) + maximum.emplace(token.index()); + + Limits r = { initial.index(), maximum }; + *limits = r; + return true; +} + +static bool +ParseMemory(WasmParseContext& c, WasmToken token, AstModule* module) +{ + AstName name = c.ts.getIfName(); + + WasmToken openParen; + if (c.ts.getIf(WasmToken::OpenParen, &openParen)) { + if (c.ts.getIf(WasmToken::Import)) { + InlineImport names; + if (!ParseInlineImport(c, &names)) + return false; + if (!c.ts.match(WasmToken::CloseParen, c.error)) + return false; + + Limits memory; + if (!ParseLimits(c, &memory)) + return false; + + auto* imp = new(c.lifo) AstImport(name, names.module.text(), names.field.text(), + DefinitionKind::Memory, memory); + return imp && module->append(imp); + } + + if (c.ts.getIf(WasmToken::Export)) { + AstRef ref = name.empty() ? AstRef(module->memories().length()) : AstRef(name); + if (!ParseInlineExport(c, DefinitionKind::Memory, module, ref)) + return false; + if (!c.ts.match(WasmToken::CloseParen, c.error)) + return false; + } else { + c.ts.unget(openParen); + } + } + + if (c.ts.getIf(WasmToken::OpenParen)) { + if (!c.ts.match(WasmToken::Data, c.error)) + return false; + + AstNameVector fragments(c.lifo); + + WasmToken data; + size_t pages = 0; + size_t totalLength = 0; + while (c.ts.getIf(WasmToken::Text, &data)) { + if (!fragments.append(data.text())) + return false; + totalLength += data.text().length(); + } + + if (fragments.length()) { + AstExpr* offset = new(c.lifo) AstConst(Val(uint32_t(0))); + if (!offset) + return false; + + AstDataSegment* segment = new(c.lifo) AstDataSegment(offset, Move(fragments)); + if (!segment || !module->append(segment)) + return false; + + pages = AlignBytes<size_t>(totalLength, PageSize) / PageSize; + if (pages != uint32_t(pages)) + return false; + } + + Limits memory = { uint32_t(pages), Some(uint32_t(pages)) }; + if (!module->addMemory(name, memory)) + return false; + + if (!c.ts.match(WasmToken::CloseParen, c.error)) + return false; + + return true; + } + + Limits memory; + if (!ParseLimits(c, &memory)) + return false; + + return module->addMemory(name, memory); +} + +static bool +ParseStartFunc(WasmParseContext& c, WasmToken token, AstModule* module) +{ + AstRef func; + if (!c.ts.matchRef(&func, c.error)) + return false; + + if (!module->setStartFunc(AstStartFunc(func))) { + c.ts.generateError(token, c.error); + return false; + } + + return true; +} + +static bool +ParseGlobalType(WasmParseContext& c, WasmToken* typeToken, bool* isMutable) +{ + *isMutable = false; + + // Either (mut i32) or i32. + if (c.ts.getIf(WasmToken::OpenParen)) { + // Immutable by default. + *isMutable = c.ts.getIf(WasmToken::Mutable); + if (!c.ts.match(WasmToken::ValueType, typeToken, c.error)) + return false; + if (!c.ts.match(WasmToken::CloseParen, c.error)) + return false; + return true; + } + + return c.ts.match(WasmToken::ValueType, typeToken, c.error); +} + +static bool +ParseElemType(WasmParseContext& c) +{ + // Only AnyFunc is allowed at the moment. + return c.ts.match(WasmToken::AnyFunc, c.error); +} + +static bool +ParseTableSig(WasmParseContext& c, Limits* table) +{ + return ParseLimits(c, table) && + ParseElemType(c); +} + +static AstImport* +ParseImport(WasmParseContext& c, AstModule* module) +{ + AstName name = c.ts.getIfName(); + + WasmToken moduleName; + if (!c.ts.match(WasmToken::Text, &moduleName, c.error)) + return nullptr; + + WasmToken fieldName; + if (!c.ts.match(WasmToken::Text, &fieldName, c.error)) + return nullptr; + + AstRef sigRef; + WasmToken openParen; + if (c.ts.getIf(WasmToken::OpenParen, &openParen)) { + if (c.ts.getIf(WasmToken::Memory)) { + if (name.empty()) + name = c.ts.getIfName(); + + Limits memory; + if (!ParseLimits(c, &memory)) + return nullptr; + if (!c.ts.match(WasmToken::CloseParen, c.error)) + return nullptr; + return new(c.lifo) AstImport(name, moduleName.text(), fieldName.text(), + DefinitionKind::Memory, memory); + } + if (c.ts.getIf(WasmToken::Table)) { + if (name.empty()) + name = c.ts.getIfName(); + + Limits table; + if (!ParseTableSig(c, &table)) + return nullptr; + if (!c.ts.match(WasmToken::CloseParen, c.error)) + return nullptr; + return new(c.lifo) AstImport(name, moduleName.text(), fieldName.text(), + DefinitionKind::Table, table); + } + if (c.ts.getIf(WasmToken::Global)) { + if (name.empty()) + name = c.ts.getIfName(); + + WasmToken typeToken; + bool isMutable; + if (!ParseGlobalType(c, &typeToken, &isMutable)) + return nullptr; + if (!c.ts.match(WasmToken::CloseParen, c.error)) + return nullptr; + + return new(c.lifo) AstImport(name, moduleName.text(), fieldName.text(), + AstGlobal(AstName(), typeToken.valueType(), isMutable)); + } + if (c.ts.getIf(WasmToken::Func)) { + if (name.empty()) + name = c.ts.getIfName(); + + AstRef sigRef; + if (!ParseFuncType(c, &sigRef, module)) + return nullptr; + if (!c.ts.match(WasmToken::CloseParen, c.error)) + return nullptr; + + return new(c.lifo) AstImport(name, moduleName.text(), fieldName.text(), sigRef); + } + + if (c.ts.getIf(WasmToken::Type)) { + if (!c.ts.matchRef(&sigRef, c.error)) + return nullptr; + if (!c.ts.match(WasmToken::CloseParen, c.error)) + return nullptr; + } else { + c.ts.unget(openParen); + } + } + + if (sigRef.isInvalid()) { + AstSig sig(c.lifo); + if (!ParseFuncSig(c, &sig)) + return nullptr; + + uint32_t sigIndex; + if (!module->declare(Move(sig), &sigIndex)) + return nullptr; + sigRef.setIndex(sigIndex); + } + + return new(c.lifo) AstImport(name, moduleName.text(), fieldName.text(), sigRef); +} + +static AstExport* +ParseExport(WasmParseContext& c) +{ + WasmToken name; + if (!c.ts.match(WasmToken::Text, &name, c.error)) + return nullptr; + + WasmToken exportee = c.ts.get(); + switch (exportee.kind()) { + case WasmToken::Index: + return new(c.lifo) AstExport(name.text(), DefinitionKind::Function, AstRef(exportee.index())); + case WasmToken::Name: + return new(c.lifo) AstExport(name.text(), DefinitionKind::Function, AstRef(exportee.name())); + case WasmToken::Table: { + AstRef ref; + if (!c.ts.getIfRef(&ref)) + ref = AstRef(0); + return new(c.lifo) AstExport(name.text(), DefinitionKind::Table, ref); + } + case WasmToken::Memory: { + AstRef ref; + if (!c.ts.getIfRef(&ref)) + ref = AstRef(0); + return new(c.lifo) AstExport(name.text(), DefinitionKind::Memory, ref); + } + case WasmToken::Global: { + AstRef ref; + if (!c.ts.matchRef(&ref, c.error)) + return nullptr; + return new(c.lifo) AstExport(name.text(), DefinitionKind::Global, ref); + } + case WasmToken::OpenParen: { + exportee = c.ts.get(); + + DefinitionKind kind; + switch (exportee.kind()) { + case WasmToken::Func: + kind = DefinitionKind::Function; + break; + case WasmToken::Table: + kind = DefinitionKind::Table; + break; + case WasmToken::Memory: + kind = DefinitionKind::Memory; + break; + case WasmToken::Global: + kind = DefinitionKind::Global; + break; + default: + c.ts.generateError(exportee, c.error); + return nullptr; + } + + AstRef ref; + if (!c.ts.matchRef(&ref, c.error)) + return nullptr; + if (!c.ts.match(WasmToken::CloseParen, c.error)) + return nullptr; + + return new(c.lifo) AstExport(name.text(), kind, ref); + } + default: + break; + } + + c.ts.generateError(exportee, c.error); + return nullptr; +} + +static bool +ParseTable(WasmParseContext& c, WasmToken token, AstModule* module) +{ + AstName name = c.ts.getIfName(); + + if (c.ts.getIf(WasmToken::OpenParen)) { + // Either an import and we're done, or an export and continue. + if (c.ts.getIf(WasmToken::Import)) { + InlineImport names; + if (!ParseInlineImport(c, &names)) + return false; + if (!c.ts.match(WasmToken::CloseParen, c.error)) + return false; + + Limits table; + if (!ParseTableSig(c, &table)) + return false; + + auto* import = new(c.lifo) AstImport(name, names.module.text(), names.field.text(), + DefinitionKind::Table, table); + + return import && module->append(import); + } + + if (!c.ts.match(WasmToken::Export, c.error)) { + c.ts.generateError(token, c.error); + return false; + } + + AstRef ref = name.empty() ? AstRef(module->tables().length()) : AstRef(name); + if (!ParseInlineExport(c, DefinitionKind::Table, module, ref)) + return false; + if (!c.ts.match(WasmToken::CloseParen, c.error)) + return false; + } + + // Either: min max? anyfunc + if (c.ts.peek().kind() == WasmToken::Index) { + Limits table; + if (!ParseTableSig(c, &table)) + return false; + return module->addTable(name, table); + } + + // Or: anyfunc (elem 1 2 ...) + if (!ParseElemType(c)) + return false; + + if (!c.ts.match(WasmToken::OpenParen, c.error)) + return false; + if (!c.ts.match(WasmToken::Elem, c.error)) + return false; + + AstRefVector elems(c.lifo); + + AstRef elem; + while (c.ts.getIfRef(&elem)) { + if (!elems.append(elem)) + return false; + } + + if (!c.ts.match(WasmToken::CloseParen, c.error)) + return false; + + uint32_t numElements = uint32_t(elems.length()); + if (numElements != elems.length()) + return false; + + Limits r = { numElements, Some(numElements) }; + if (!module->addTable(name, r)) + return false; + + auto* zero = new(c.lifo) AstConst(Val(uint32_t(0))); + if (!zero) + return false; + + AstElemSegment* segment = new(c.lifo) AstElemSegment(zero, Move(elems)); + return segment && module->append(segment); +} + +static AstElemSegment* +ParseElemSegment(WasmParseContext& c) +{ + if (!MaybeParseOwnerIndex(c)) + return nullptr; + + AstExpr* offset = ParseInitializerExpression(c); + if (!offset) + return nullptr; + + AstRefVector elems(c.lifo); + + AstRef elem; + while (c.ts.getIfRef(&elem)) { + if (!elems.append(elem)) + return nullptr; + } + + return new(c.lifo) AstElemSegment(offset, Move(elems)); +} + +static bool +ParseGlobal(WasmParseContext& c, AstModule* module) +{ + AstName name = c.ts.getIfName(); + + WasmToken typeToken; + bool isMutable; + + WasmToken openParen; + if (c.ts.getIf(WasmToken::OpenParen, &openParen)) { + if (c.ts.getIf(WasmToken::Import)) { + if (module->globals().length()) { + c.ts.generateError(openParen, "import after global definition", c.error); + return false; + } + + InlineImport names; + if (!ParseInlineImport(c, &names)) + return false; + if (!c.ts.match(WasmToken::CloseParen, c.error)) + return false; + + if (!ParseGlobalType(c, &typeToken, &isMutable)) + return false; + + auto* imp = new(c.lifo) AstImport(name, names.module.text(), names.field.text(), + AstGlobal(AstName(), typeToken.valueType(), + isMutable)); + return imp && module->append(imp); + } + + if (c.ts.getIf(WasmToken::Export)) { + AstRef ref = name.empty() ? AstRef(module->globals().length()) : AstRef(name); + if (!ParseInlineExport(c, DefinitionKind::Global, module, ref)) + return false; + if (!c.ts.match(WasmToken::CloseParen, c.error)) + return false; + } else { + c.ts.unget(openParen); + } + } + + if (!ParseGlobalType(c, &typeToken, &isMutable)) + return false; + + AstExpr* init = ParseInitializerExpression(c); + if (!init) + return false; + + auto* glob = new(c.lifo) AstGlobal(name, typeToken.valueType(), isMutable, Some(init)); + return glob && module->append(glob); +} + +static AstModule* +ParseBinaryModule(WasmParseContext& c, AstModule* module) +{ + // By convention with EncodeBinaryModule, a binary module only contains a + // data section containing the raw bytes contained in the module. + AstNameVector fragments(c.lifo); + + WasmToken text; + while (c.ts.getIf(WasmToken::Text, &text)) { + if (!fragments.append(text.text())) + return nullptr; + } + + auto* data = new(c.lifo) AstDataSegment(nullptr, Move(fragments)); + if (!data || !module->append(data)) + return nullptr; + + return module; +} + +static AstModule* +ParseModule(const char16_t* text, LifoAlloc& lifo, UniqueChars* error, bool* binary) +{ + WasmParseContext c(text, lifo, error); + + *binary = false; + + if (!c.ts.match(WasmToken::OpenParen, c.error)) + return nullptr; + if (!c.ts.match(WasmToken::Module, c.error)) + return nullptr; + + auto* module = new(c.lifo) AstModule(c.lifo); + if (!module || !module->init()) + return nullptr; + + if (c.ts.peek().kind() == WasmToken::Text) { + *binary = true; + return ParseBinaryModule(c, module); + } + + while (c.ts.getIf(WasmToken::OpenParen)) { + WasmToken section = c.ts.get(); + + switch (section.kind()) { + case WasmToken::Type: { + AstSig* sig = ParseTypeDef(c); + if (!sig || !module->append(sig)) + return nullptr; + break; + } + case WasmToken::Start: { + if (!ParseStartFunc(c, section, module)) + return nullptr; + break; + } + case WasmToken::Memory: { + if (!ParseMemory(c, section, module)) + return nullptr; + break; + } + case WasmToken::Global: { + if (!ParseGlobal(c, module)) + return nullptr; + break; + } + case WasmToken::Data: { + AstDataSegment* segment = ParseDataSegment(c); + if (!segment || !module->append(segment)) + return nullptr; + break; + } + case WasmToken::Import: { + AstImport* imp = ParseImport(c, module); + if (!imp || !module->append(imp)) + return nullptr; + break; + } + case WasmToken::Export: { + AstExport* exp = ParseExport(c); + if (!exp || !module->append(exp)) + return nullptr; + break; + } + case WasmToken::Table: { + if (!ParseTable(c, section, module)) + return nullptr; + break; + } + case WasmToken::Elem: { + AstElemSegment* segment = ParseElemSegment(c); + if (!segment || !module->append(segment)) + return nullptr; + break; + } + case WasmToken::Func: { + if (!ParseFunc(c, module)) + return nullptr; + break; + } + default: + c.ts.generateError(section, c.error); + return nullptr; + } + + if (!c.ts.match(WasmToken::CloseParen, c.error)) + return nullptr; + } + + if (!c.ts.match(WasmToken::CloseParen, c.error)) + return nullptr; + if (!c.ts.match(WasmToken::EndOfFile, c.error)) + return nullptr; + + return module; +} + +/*****************************************************************************/ +// wasm name resolution + +namespace { + +class Resolver +{ + UniqueChars* error_; + AstNameMap varMap_; + AstNameMap globalMap_; + AstNameMap sigMap_; + AstNameMap funcMap_; + AstNameMap importMap_; + AstNameMap tableMap_; + AstNameMap memoryMap_; + AstNameVector targetStack_; + + bool registerName(AstNameMap& map, AstName name, size_t index) { + AstNameMap::AddPtr p = map.lookupForAdd(name); + if (!p) { + if (!map.add(p, name, index)) + return false; + } else { + return false; + } + return true; + } + bool resolveName(AstNameMap& map, AstName name, size_t* index) { + AstNameMap::Ptr p = map.lookup(name); + if (p) { + *index = p->value(); + return true; + } + return false; + } + bool resolveRef(AstNameMap& map, AstRef& ref) { + AstNameMap::Ptr p = map.lookup(ref.name()); + if (p) { + ref.setIndex(p->value()); + return true; + } + return false; + } + bool failResolveLabel(const char* kind, AstName name) { + TwoByteChars chars(name.begin(), name.length()); + UniqueChars utf8Chars(CharsToNewUTF8CharsZ(nullptr, chars).c_str()); + error_->reset(JS_smprintf("%s label '%s' not found", kind, utf8Chars.get())); + return false; + } + + public: + explicit Resolver(LifoAlloc& lifo, UniqueChars* error) + : error_(error), + varMap_(lifo), + globalMap_(lifo), + sigMap_(lifo), + funcMap_(lifo), + importMap_(lifo), + tableMap_(lifo), + memoryMap_(lifo), + targetStack_(lifo) + {} + bool init() { + return sigMap_.init() && + funcMap_.init() && + importMap_.init() && + tableMap_.init() && + memoryMap_.init() && + varMap_.init() && + globalMap_.init(); + } + void beginFunc() { + varMap_.clear(); + MOZ_ASSERT(targetStack_.empty()); + } + +#define REGISTER(what, map) \ + bool register##what##Name(AstName name, size_t index) { \ + return name.empty() || registerName(map, name, index); \ + } + + REGISTER(Sig, sigMap_) + REGISTER(Func, funcMap_) + REGISTER(Import, importMap_) + REGISTER(Var, varMap_) + REGISTER(Global, globalMap_) + REGISTER(Table, tableMap_) + REGISTER(Memory, memoryMap_) + +#undef REGISTER + + bool pushTarget(AstName name) { + return targetStack_.append(name); + } + void popTarget(AstName name) { + MOZ_ASSERT(targetStack_.back() == name); + targetStack_.popBack(); + } + +#define RESOLVE(map, label) \ + bool resolve##label(AstRef& ref) { \ + MOZ_ASSERT(!ref.isInvalid()); \ + if (!ref.name().empty() && !resolveRef(map, ref)) \ + return failResolveLabel(#label, ref.name()); \ + return true; \ + } + + RESOLVE(sigMap_, Signature) + RESOLVE(funcMap_, Function) + RESOLVE(importMap_, Import) + RESOLVE(varMap_, Local) + RESOLVE(globalMap_, Global) + RESOLVE(tableMap_, Table) + RESOLVE(memoryMap_, Memory) + +#undef RESOLVE + + bool resolveBranchTarget(AstRef& ref) { + if (ref.name().empty()) + return true; + for (size_t i = 0, e = targetStack_.length(); i < e; i++) { + if (targetStack_[e - i - 1] == ref.name()) { + ref.setIndex(i); + return true; + } + } + return failResolveLabel("branch target", ref.name()); + } + + bool fail(const char* message) { + error_->reset(JS_smprintf("%s", message)); + return false; + } +}; + +} // end anonymous namespace + +static bool +ResolveExpr(Resolver& r, AstExpr& expr); + +static bool +ResolveExprList(Resolver& r, const AstExprVector& v) +{ + for (size_t i = 0; i < v.length(); i++) { + if (!ResolveExpr(r, *v[i])) + return false; + } + return true; +} + +static bool +ResolveBlock(Resolver& r, AstBlock& b) +{ + if (!r.pushTarget(b.name())) + return false; + + if (!ResolveExprList(r, b.exprs())) + return false; + + r.popTarget(b.name()); + return true; +} + +static bool +ResolveDropOperator(Resolver& r, AstDrop& drop) +{ + return ResolveExpr(r, drop.value()); +} + +static bool +ResolveBranch(Resolver& r, AstBranch& br) +{ + if (!r.resolveBranchTarget(br.target())) + return false; + + if (br.maybeValue() && !ResolveExpr(r, *br.maybeValue())) + return false; + + if (br.op() == Op::BrIf) { + if (!ResolveExpr(r, br.cond())) + return false; + } + + return true; +} + +static bool +ResolveArgs(Resolver& r, const AstExprVector& args) +{ + for (AstExpr* arg : args) { + if (!ResolveExpr(r, *arg)) + return false; + } + + return true; +} + +static bool +ResolveCall(Resolver& r, AstCall& c) +{ + MOZ_ASSERT(c.op() == Op::Call); + + if (!ResolveArgs(r, c.args())) + return false; + + if (!r.resolveFunction(c.func())) + return false; + + return true; +} + +static bool +ResolveCallIndirect(Resolver& r, AstCallIndirect& c) +{ + if (!ResolveArgs(r, c.args())) + return false; + + if (!ResolveExpr(r, *c.index())) + return false; + + if (!r.resolveSignature(c.sig())) + return false; + + return true; +} + +static bool +ResolveFirst(Resolver& r, AstFirst& f) +{ + return ResolveExprList(r, f.exprs()); +} + +static bool +ResolveGetLocal(Resolver& r, AstGetLocal& gl) +{ + return r.resolveLocal(gl.local()); +} + +static bool +ResolveSetLocal(Resolver& r, AstSetLocal& sl) +{ + if (!ResolveExpr(r, sl.value())) + return false; + + if (!r.resolveLocal(sl.local())) + return false; + + return true; +} + +static bool +ResolveGetGlobal(Resolver& r, AstGetGlobal& gl) +{ + return r.resolveGlobal(gl.global()); +} + +static bool +ResolveSetGlobal(Resolver& r, AstSetGlobal& sl) +{ + if (!ResolveExpr(r, sl.value())) + return false; + + if (!r.resolveGlobal(sl.global())) + return false; + + return true; +} + +static bool +ResolveTeeLocal(Resolver& r, AstTeeLocal& sl) +{ + if (!ResolveExpr(r, sl.value())) + return false; + + if (!r.resolveLocal(sl.local())) + return false; + + return true; +} + +static bool +ResolveUnaryOperator(Resolver& r, AstUnaryOperator& b) +{ + return ResolveExpr(r, *b.operand()); +} + +static bool +ResolveGrowMemory(Resolver& r, AstGrowMemory& gm) +{ + return ResolveExpr(r, *gm.operand()); +} + +static bool +ResolveBinaryOperator(Resolver& r, AstBinaryOperator& b) +{ + return ResolveExpr(r, *b.lhs()) && + ResolveExpr(r, *b.rhs()); +} + +static bool +ResolveTernaryOperator(Resolver& r, AstTernaryOperator& b) +{ + return ResolveExpr(r, *b.op0()) && + ResolveExpr(r, *b.op1()) && + ResolveExpr(r, *b.op2()); +} + +static bool +ResolveComparisonOperator(Resolver& r, AstComparisonOperator& b) +{ + return ResolveExpr(r, *b.lhs()) && + ResolveExpr(r, *b.rhs()); +} + +static bool +ResolveConversionOperator(Resolver& r, AstConversionOperator& b) +{ + return ResolveExpr(r, *b.operand()); +} + +static bool +ResolveIfElse(Resolver& r, AstIf& i) +{ + if (!ResolveExpr(r, i.cond())) + return false; + if (!r.pushTarget(i.name())) + return false; + if (!ResolveExprList(r, i.thenExprs())) + return false; + if (i.hasElse()) { + if (!ResolveExprList(r, i.elseExprs())) + return false; + } + r.popTarget(i.name()); + return true; +} + +static bool +ResolveLoadStoreAddress(Resolver& r, const AstLoadStoreAddress &address) +{ + return ResolveExpr(r, address.base()); +} + +static bool +ResolveLoad(Resolver& r, AstLoad& l) +{ + return ResolveLoadStoreAddress(r, l.address()); +} + +static bool +ResolveStore(Resolver& r, AstStore& s) +{ + return ResolveLoadStoreAddress(r, s.address()) && + ResolveExpr(r, s.value()); +} + +static bool +ResolveReturn(Resolver& r, AstReturn& ret) +{ + return !ret.maybeExpr() || ResolveExpr(r, *ret.maybeExpr()); +} + +static bool +ResolveBranchTable(Resolver& r, AstBranchTable& bt) +{ + if (!r.resolveBranchTarget(bt.def())) + return false; + + for (AstRef& elem : bt.table()) { + if (!r.resolveBranchTarget(elem)) + return false; + } + + if (bt.maybeValue() && !ResolveExpr(r, *bt.maybeValue())) + return false; + + return ResolveExpr(r, bt.index()); +} + +static bool +ResolveExpr(Resolver& r, AstExpr& expr) +{ + switch (expr.kind()) { + case AstExprKind::Nop: + case AstExprKind::Pop: + case AstExprKind::Unreachable: + case AstExprKind::CurrentMemory: + return true; + case AstExprKind::Drop: + return ResolveDropOperator(r, expr.as<AstDrop>()); + case AstExprKind::BinaryOperator: + return ResolveBinaryOperator(r, expr.as<AstBinaryOperator>()); + case AstExprKind::Block: + return ResolveBlock(r, expr.as<AstBlock>()); + case AstExprKind::Branch: + return ResolveBranch(r, expr.as<AstBranch>()); + case AstExprKind::Call: + return ResolveCall(r, expr.as<AstCall>()); + case AstExprKind::CallIndirect: + return ResolveCallIndirect(r, expr.as<AstCallIndirect>()); + case AstExprKind::ComparisonOperator: + return ResolveComparisonOperator(r, expr.as<AstComparisonOperator>()); + case AstExprKind::Const: + return true; + case AstExprKind::ConversionOperator: + return ResolveConversionOperator(r, expr.as<AstConversionOperator>()); + case AstExprKind::First: + return ResolveFirst(r, expr.as<AstFirst>()); + case AstExprKind::GetGlobal: + return ResolveGetGlobal(r, expr.as<AstGetGlobal>()); + case AstExprKind::GetLocal: + return ResolveGetLocal(r, expr.as<AstGetLocal>()); + case AstExprKind::If: + return ResolveIfElse(r, expr.as<AstIf>()); + case AstExprKind::Load: + return ResolveLoad(r, expr.as<AstLoad>()); + case AstExprKind::Return: + return ResolveReturn(r, expr.as<AstReturn>()); + case AstExprKind::SetGlobal: + return ResolveSetGlobal(r, expr.as<AstSetGlobal>()); + case AstExprKind::SetLocal: + return ResolveSetLocal(r, expr.as<AstSetLocal>()); + case AstExprKind::Store: + return ResolveStore(r, expr.as<AstStore>()); + case AstExprKind::BranchTable: + return ResolveBranchTable(r, expr.as<AstBranchTable>()); + case AstExprKind::TeeLocal: + return ResolveTeeLocal(r, expr.as<AstTeeLocal>()); + case AstExprKind::TernaryOperator: + return ResolveTernaryOperator(r, expr.as<AstTernaryOperator>()); + case AstExprKind::UnaryOperator: + return ResolveUnaryOperator(r, expr.as<AstUnaryOperator>()); + case AstExprKind::GrowMemory: + return ResolveGrowMemory(r, expr.as<AstGrowMemory>()); + } + MOZ_CRASH("Bad expr kind"); +} + +static bool +ResolveFunc(Resolver& r, AstFunc& func) +{ + r.beginFunc(); + + for (size_t i = 0; i < func.locals().length(); i++) { + if (!r.registerVarName(func.locals()[i], i)) + return r.fail("duplicate var"); + } + + for (AstExpr* expr : func.body()) { + if (!ResolveExpr(r, *expr)) + return false; + } + return true; +} + +static bool +ResolveModule(LifoAlloc& lifo, AstModule* module, UniqueChars* error) +{ + Resolver r(lifo, error); + + if (!r.init()) + return false; + + size_t numSigs = module->sigs().length(); + for (size_t i = 0; i < numSigs; i++) { + AstSig* sig = module->sigs()[i]; + if (!r.registerSigName(sig->name(), i)) + return r.fail("duplicate signature"); + } + + size_t lastFuncIndex = 0; + size_t lastGlobalIndex = 0; + size_t lastMemoryIndex = 0; + size_t lastTableIndex = 0; + for (AstImport* imp : module->imports()) { + switch (imp->kind()) { + case DefinitionKind::Function: + if (!r.registerFuncName(imp->name(), lastFuncIndex++)) + return r.fail("duplicate import"); + if (!r.resolveSignature(imp->funcSig())) + return false; + break; + case DefinitionKind::Global: + if (!r.registerGlobalName(imp->name(), lastGlobalIndex++)) + return r.fail("duplicate import"); + break; + case DefinitionKind::Memory: + if (!r.registerMemoryName(imp->name(), lastMemoryIndex++)) + return r.fail("duplicate import"); + break; + case DefinitionKind::Table: + if (!r.registerTableName(imp->name(), lastTableIndex++)) + return r.fail("duplicate import"); + break; + } + } + + for (AstFunc* func : module->funcs()) { + if (!r.resolveSignature(func->sig())) + return false; + if (!r.registerFuncName(func->name(), lastFuncIndex++)) + return r.fail("duplicate function"); + } + + for (const AstGlobal* global : module->globals()) { + if (!r.registerGlobalName(global->name(), lastGlobalIndex++)) + return r.fail("duplicate import"); + if (global->hasInit() && !ResolveExpr(r, global->init())) + return false; + } + + for (const AstResizable& table : module->tables()) { + if (table.imported) + continue; + if (!r.registerTableName(table.name, lastTableIndex++)) + return r.fail("duplicate import"); + } + + for (const AstResizable& memory : module->memories()) { + if (memory.imported) + continue; + if (!r.registerMemoryName(memory.name, lastMemoryIndex++)) + return r.fail("duplicate import"); + } + + for (AstExport* export_ : module->exports()) { + switch (export_->kind()) { + case DefinitionKind::Function: + if (!r.resolveFunction(export_->ref())) + return false; + break; + case DefinitionKind::Global: + if (!r.resolveGlobal(export_->ref())) + return false; + break; + case DefinitionKind::Table: + if (!r.resolveTable(export_->ref())) + return false; + break; + case DefinitionKind::Memory: + if (!r.resolveMemory(export_->ref())) + return false; + break; + } + } + + for (AstFunc* func : module->funcs()) { + if (!ResolveFunc(r, *func)) + return false; + } + + if (module->hasStartFunc()) { + if (!r.resolveFunction(module->startFunc().func())) + return false; + } + + for (AstDataSegment* segment : module->dataSegments()) { + if (!ResolveExpr(r, *segment->offset())) + return false; + } + + for (AstElemSegment* segment : module->elemSegments()) { + if (!ResolveExpr(r, *segment->offset())) + return false; + for (AstRef& ref : segment->elems()) { + if (!r.resolveFunction(ref)) + return false; + } + } + + return true; +} + +/*****************************************************************************/ +// wasm function body serialization + +static bool +EncodeExpr(Encoder& e, AstExpr& expr); + +static bool +EncodeExprList(Encoder& e, const AstExprVector& v) +{ + for (size_t i = 0; i < v.length(); i++) { + if (!EncodeExpr(e, *v[i])) + return false; + } + return true; +} + +static bool +EncodeBlock(Encoder& e, AstBlock& b) +{ + if (!e.writeOp(b.op())) + return false; + + if (!e.writeBlockType(b.type())) + return false; + + if (!EncodeExprList(e, b.exprs())) + return false; + + if (!e.writeOp(Op::End)) + return false; + + return true; +} + +static bool +EncodeBranch(Encoder& e, AstBranch& br) +{ + MOZ_ASSERT(br.op() == Op::Br || br.op() == Op::BrIf); + + if (br.maybeValue()) { + if (!EncodeExpr(e, *br.maybeValue())) + return false; + } + + if (br.op() == Op::BrIf) { + if (!EncodeExpr(e, br.cond())) + return false; + } + + if (!e.writeOp(br.op())) + return false; + + if (!e.writeVarU32(br.target().index())) + return false; + + return true; +} + +static bool +EncodeFirst(Encoder& e, AstFirst& f) +{ + return EncodeExprList(e, f.exprs()); +} + +static bool +EncodeArgs(Encoder& e, const AstExprVector& args) +{ + for (AstExpr* arg : args) { + if (!EncodeExpr(e, *arg)) + return false; + } + + return true; +} + +static bool +EncodeCall(Encoder& e, AstCall& c) +{ + if (!EncodeArgs(e, c.args())) + return false; + + if (!e.writeOp(c.op())) + return false; + + if (!e.writeVarU32(c.func().index())) + return false; + + return true; +} + +static bool +EncodeCallIndirect(Encoder& e, AstCallIndirect& c) +{ + if (!EncodeArgs(e, c.args())) + return false; + + if (!EncodeExpr(e, *c.index())) + return false; + + if (!e.writeOp(Op::CallIndirect)) + return false; + + if (!e.writeVarU32(c.sig().index())) + return false; + + if (!e.writeVarU32(uint32_t(MemoryTableFlags::Default))) + return false; + + return true; +} + +static bool +EncodeConst(Encoder& e, AstConst& c) +{ + switch (c.val().type()) { + case ValType::I32: + return e.writeOp(Op::I32Const) && + e.writeVarS32(c.val().i32()); + case ValType::I64: + return e.writeOp(Op::I64Const) && + e.writeVarS64(c.val().i64()); + case ValType::F32: + return e.writeOp(Op::F32Const) && + e.writeFixedF32(c.val().f32()); + case ValType::F64: + return e.writeOp(Op::F64Const) && + e.writeFixedF64(c.val().f64()); + default: + break; + } + MOZ_CRASH("Bad value type"); +} + +static bool +EncodeDrop(Encoder& e, AstDrop &drop) +{ + return EncodeExpr(e, drop.value()) && + e.writeOp(Op::Drop); +} + +static bool +EncodeGetLocal(Encoder& e, AstGetLocal& gl) +{ + return e.writeOp(Op::GetLocal) && + e.writeVarU32(gl.local().index()); +} + +static bool +EncodeSetLocal(Encoder& e, AstSetLocal& sl) +{ + return EncodeExpr(e, sl.value()) && + e.writeOp(Op::SetLocal) && + e.writeVarU32(sl.local().index()); +} + +static bool +EncodeTeeLocal(Encoder& e, AstTeeLocal& sl) +{ + return EncodeExpr(e, sl.value()) && + e.writeOp(Op::TeeLocal) && + e.writeVarU32(sl.local().index()); +} + +static bool +EncodeGetGlobal(Encoder& e, AstGetGlobal& gg) +{ + return e.writeOp(Op::GetGlobal) && + e.writeVarU32(gg.global().index()); +} + +static bool +EncodeSetGlobal(Encoder& e, AstSetGlobal& sg) +{ + return EncodeExpr(e, sg.value()) && + e.writeOp(Op::SetGlobal) && + e.writeVarU32(sg.global().index()); +} + +static bool +EncodeUnaryOperator(Encoder& e, AstUnaryOperator& b) +{ + return EncodeExpr(e, *b.operand()) && + e.writeOp(b.op()); +} + +static bool +EncodeBinaryOperator(Encoder& e, AstBinaryOperator& b) +{ + return EncodeExpr(e, *b.lhs()) && + EncodeExpr(e, *b.rhs()) && + e.writeOp(b.op()); +} + +static bool +EncodeTernaryOperator(Encoder& e, AstTernaryOperator& b) +{ + return EncodeExpr(e, *b.op0()) && + EncodeExpr(e, *b.op1()) && + EncodeExpr(e, *b.op2()) && + e.writeOp(b.op()); +} + +static bool +EncodeComparisonOperator(Encoder& e, AstComparisonOperator& b) +{ + return EncodeExpr(e, *b.lhs()) && + EncodeExpr(e, *b.rhs()) && + e.writeOp(b.op()); +} + +static bool +EncodeConversionOperator(Encoder& e, AstConversionOperator& b) +{ + return EncodeExpr(e, *b.operand()) && + e.writeOp(b.op()); +} + +static bool +EncodeIf(Encoder& e, AstIf& i) +{ + if (!EncodeExpr(e, i.cond()) || !e.writeOp(Op::If)) + return false; + + if (!e.writeBlockType(i.type())) + return false; + + if (!EncodeExprList(e, i.thenExprs())) + return false; + + if (i.hasElse()) { + if (!e.writeOp(Op::Else)) + return false; + if (!EncodeExprList(e, i.elseExprs())) + return false; + } + + return e.writeOp(Op::End); +} + +static bool +EncodeLoadStoreAddress(Encoder &e, const AstLoadStoreAddress &address) +{ + return EncodeExpr(e, address.base()); +} + +static bool +EncodeLoadStoreFlags(Encoder &e, const AstLoadStoreAddress &address) +{ + return e.writeVarU32(address.flags()) && + e.writeVarU32(address.offset()); +} + +static bool +EncodeLoad(Encoder& e, AstLoad& l) +{ + return EncodeLoadStoreAddress(e, l.address()) && + e.writeOp(l.op()) && + EncodeLoadStoreFlags(e, l.address()); +} + +static bool +EncodeStore(Encoder& e, AstStore& s) +{ + return EncodeLoadStoreAddress(e, s.address()) && + EncodeExpr(e, s.value()) && + e.writeOp(s.op()) && + EncodeLoadStoreFlags(e, s.address()); +} + +static bool +EncodeReturn(Encoder& e, AstReturn& r) +{ + if (r.maybeExpr()) { + if (!EncodeExpr(e, *r.maybeExpr())) + return false; + } + + if (!e.writeOp(Op::Return)) + return false; + + return true; +} + +static bool +EncodeBranchTable(Encoder& e, AstBranchTable& bt) +{ + if (bt.maybeValue()) { + if (!EncodeExpr(e, *bt.maybeValue())) + return false; + } + + if (!EncodeExpr(e, bt.index())) + return false; + + if (!e.writeOp(Op::BrTable)) + return false; + + if (!e.writeVarU32(bt.table().length())) + return false; + + for (const AstRef& elem : bt.table()) { + if (!e.writeVarU32(elem.index())) + return false; + } + + if (!e.writeVarU32(bt.def().index())) + return false; + + return true; +} + +static bool +EncodeCurrentMemory(Encoder& e, AstCurrentMemory& cm) +{ + if (!e.writeOp(Op::CurrentMemory)) + return false; + + if (!e.writeVarU32(uint32_t(MemoryTableFlags::Default))) + return false; + + return true; +} + +static bool +EncodeGrowMemory(Encoder& e, AstGrowMemory& gm) +{ + if (!EncodeExpr(e, *gm.operand())) + return false; + + if (!e.writeOp(Op::GrowMemory)) + return false; + + if (!e.writeVarU32(uint32_t(MemoryTableFlags::Default))) + return false; + + return true; +} + +static bool +EncodeExpr(Encoder& e, AstExpr& expr) +{ + switch (expr.kind()) { + case AstExprKind::Pop: + return true; + case AstExprKind::Nop: + return e.writeOp(Op::Nop); + case AstExprKind::Unreachable: + return e.writeOp(Op::Unreachable); + case AstExprKind::BinaryOperator: + return EncodeBinaryOperator(e, expr.as<AstBinaryOperator>()); + case AstExprKind::Block: + return EncodeBlock(e, expr.as<AstBlock>()); + case AstExprKind::Branch: + return EncodeBranch(e, expr.as<AstBranch>()); + case AstExprKind::Call: + return EncodeCall(e, expr.as<AstCall>()); + case AstExprKind::CallIndirect: + return EncodeCallIndirect(e, expr.as<AstCallIndirect>()); + case AstExprKind::ComparisonOperator: + return EncodeComparisonOperator(e, expr.as<AstComparisonOperator>()); + case AstExprKind::Const: + return EncodeConst(e, expr.as<AstConst>()); + case AstExprKind::ConversionOperator: + return EncodeConversionOperator(e, expr.as<AstConversionOperator>()); + case AstExprKind::Drop: + return EncodeDrop(e, expr.as<AstDrop>()); + case AstExprKind::First: + return EncodeFirst(e, expr.as<AstFirst>()); + case AstExprKind::GetLocal: + return EncodeGetLocal(e, expr.as<AstGetLocal>()); + case AstExprKind::GetGlobal: + return EncodeGetGlobal(e, expr.as<AstGetGlobal>()); + case AstExprKind::If: + return EncodeIf(e, expr.as<AstIf>()); + case AstExprKind::Load: + return EncodeLoad(e, expr.as<AstLoad>()); + case AstExprKind::Return: + return EncodeReturn(e, expr.as<AstReturn>()); + case AstExprKind::SetLocal: + return EncodeSetLocal(e, expr.as<AstSetLocal>()); + case AstExprKind::TeeLocal: + return EncodeTeeLocal(e, expr.as<AstTeeLocal>()); + case AstExprKind::SetGlobal: + return EncodeSetGlobal(e, expr.as<AstSetGlobal>()); + case AstExprKind::Store: + return EncodeStore(e, expr.as<AstStore>()); + case AstExprKind::BranchTable: + return EncodeBranchTable(e, expr.as<AstBranchTable>()); + case AstExprKind::TernaryOperator: + return EncodeTernaryOperator(e, expr.as<AstTernaryOperator>()); + case AstExprKind::UnaryOperator: + return EncodeUnaryOperator(e, expr.as<AstUnaryOperator>()); + case AstExprKind::CurrentMemory: + return EncodeCurrentMemory(e, expr.as<AstCurrentMemory>()); + case AstExprKind::GrowMemory: + return EncodeGrowMemory(e, expr.as<AstGrowMemory>()); + } + MOZ_CRASH("Bad expr kind"); +} + +/*****************************************************************************/ +// wasm AST binary serialization + +static bool +EncodeTypeSection(Encoder& e, AstModule& module) +{ + if (module.sigs().empty()) + return true; + + size_t offset; + if (!e.startSection(SectionId::Type, &offset)) + return false; + + if (!e.writeVarU32(module.sigs().length())) + return false; + + for (AstSig* sig : module.sigs()) { + if (!e.writeVarU32(uint32_t(TypeCode::Func))) + return false; + + if (!e.writeVarU32(sig->args().length())) + return false; + + for (ValType t : sig->args()) { + if (!e.writeValType(t)) + return false; + } + + if (!e.writeVarU32(!IsVoid(sig->ret()))) + return false; + + if (!IsVoid(sig->ret())) { + if (!e.writeValType(NonVoidToValType(sig->ret()))) + return false; + } + } + + e.finishSection(offset); + return true; +} + +static bool +EncodeFunctionSection(Encoder& e, AstModule& module) +{ + if (module.funcs().empty()) + return true; + + size_t offset; + if (!e.startSection(SectionId::Function, &offset)) + return false; + + if (!e.writeVarU32(module.funcs().length())) + return false; + + for (AstFunc* func : module.funcs()) { + if (!e.writeVarU32(func->sig().index())) + return false; + } + + e.finishSection(offset); + return true; +} + +static bool +EncodeBytes(Encoder& e, AstName wasmName) +{ + TwoByteChars range(wasmName.begin(), wasmName.length()); + UniqueChars utf8(JS::CharsToNewUTF8CharsZ(nullptr, range).c_str()); + return utf8 && e.writeBytes(utf8.get(), strlen(utf8.get())); +} + +static bool +EncodeLimits(Encoder& e, const Limits& limits) +{ + uint32_t flags = limits.maximum ? 1 : 0; + if (!e.writeVarU32(flags)) + return false; + + if (!e.writeVarU32(limits.initial)) + return false; + + if (limits.maximum) { + if (!e.writeVarU32(*limits.maximum)) + return false; + } + + return true; +} + +static bool +EncodeTableLimits(Encoder& e, const Limits& limits) +{ + if (!e.writeVarU32(uint32_t(TypeCode::AnyFunc))) + return false; + + return EncodeLimits(e, limits); +} + +static bool +EncodeGlobalType(Encoder& e, const AstGlobal* global) +{ + return e.writeValType(global->type()) && + e.writeVarU32(global->isMutable() ? uint32_t(GlobalTypeImmediate::IsMutable) : 0); +} + +static bool +EncodeImport(Encoder& e, AstImport& imp) +{ + if (!EncodeBytes(e, imp.module())) + return false; + + if (!EncodeBytes(e, imp.field())) + return false; + + if (!e.writeVarU32(uint32_t(imp.kind()))) + return false; + + switch (imp.kind()) { + case DefinitionKind::Function: + if (!e.writeVarU32(imp.funcSig().index())) + return false; + break; + case DefinitionKind::Global: + MOZ_ASSERT(!imp.global().hasInit()); + if (!EncodeGlobalType(e, &imp.global())) + return false; + break; + case DefinitionKind::Table: + if (!EncodeTableLimits(e, imp.limits())) + return false; + break; + case DefinitionKind::Memory: + if (!EncodeLimits(e, imp.limits())) + return false; + break; + } + + return true; +} + +static bool +EncodeImportSection(Encoder& e, AstModule& module) +{ + if (module.imports().empty()) + return true; + + size_t offset; + if (!e.startSection(SectionId::Import, &offset)) + return false; + + if (!e.writeVarU32(module.imports().length())) + return false; + + for (AstImport* imp : module.imports()) { + if (!EncodeImport(e, *imp)) + return false; + } + + e.finishSection(offset); + return true; +} + +static bool +EncodeMemorySection(Encoder& e, AstModule& module) +{ + size_t numOwnMemories = 0; + for (const AstResizable& memory : module.memories()) { + if (!memory.imported) + numOwnMemories++; + } + + if (!numOwnMemories) + return true; + + size_t offset; + if (!e.startSection(SectionId::Memory, &offset)) + return false; + + if (!e.writeVarU32(numOwnMemories)) + return false; + + for (const AstResizable& memory : module.memories()) { + if (memory.imported) + continue; + if (!EncodeLimits(e, memory.limits)) + return false; + } + + e.finishSection(offset); + return true; +} + +static bool +EncodeGlobalSection(Encoder& e, AstModule& module) +{ + size_t offset; + if (!e.startSection(SectionId::Global, &offset)) + return false; + + const AstGlobalVector& globals = module.globals(); + + if (!e.writeVarU32(globals.length())) + return false; + + for (const AstGlobal* global : globals) { + MOZ_ASSERT(global->hasInit()); + if (!EncodeGlobalType(e, global)) + return false; + if (!EncodeExpr(e, global->init())) + return false; + if (!e.writeOp(Op::End)) + return false; + } + + e.finishSection(offset); + return true; +} + +static bool +EncodeExport(Encoder& e, AstExport& exp) +{ + if (!EncodeBytes(e, exp.name())) + return false; + + if (!e.writeVarU32(uint32_t(exp.kind()))) + return false; + + if (!e.writeVarU32(exp.ref().index())) + return false; + + return true; +} + +static bool +EncodeExportSection(Encoder& e, AstModule& module) +{ + uint32_t numExports = module.exports().length(); + if (!numExports) + return true; + + size_t offset; + if (!e.startSection(SectionId::Export, &offset)) + return false; + + if (!e.writeVarU32(numExports)) + return false; + + for (AstExport* exp : module.exports()) { + if (!EncodeExport(e, *exp)) + return false; + } + + e.finishSection(offset); + return true; +} + +static bool +EncodeTableSection(Encoder& e, AstModule& module) +{ + size_t numOwnTables = 0; + for (const AstResizable& table : module.tables()) { + if (!table.imported) + numOwnTables++; + } + + if (!numOwnTables) + return true; + + size_t offset; + if (!e.startSection(SectionId::Table, &offset)) + return false; + + if (!e.writeVarU32(numOwnTables)) + return false; + + for (const AstResizable& table : module.tables()) { + if (table.imported) + continue; + if (!EncodeTableLimits(e, table.limits)) + return false; + } + + e.finishSection(offset); + return true; +} + +static bool +EncodeFunctionBody(Encoder& e, AstFunc& func) +{ + size_t bodySizeAt; + if (!e.writePatchableVarU32(&bodySizeAt)) + return false; + + size_t beforeBody = e.currentOffset(); + + ValTypeVector varTypes; + if (!varTypes.appendAll(func.vars())) + return false; + if (!EncodeLocalEntries(e, varTypes)) + return false; + + for (AstExpr* expr : func.body()) { + if (!EncodeExpr(e, *expr)) + return false; + } + + if (!e.writeOp(Op::End)) + return false; + + e.patchVarU32(bodySizeAt, e.currentOffset() - beforeBody); + return true; +} + +static bool +EncodeStartSection(Encoder& e, AstModule& module) +{ + if (!module.hasStartFunc()) + return true; + + size_t offset; + if (!e.startSection(SectionId::Start, &offset)) + return false; + + if (!e.writeVarU32(module.startFunc().func().index())) + return false; + + e.finishSection(offset); + return true; +} + +static bool +EncodeCodeSection(Encoder& e, AstModule& module) +{ + if (module.funcs().empty()) + return true; + + size_t offset; + if (!e.startSection(SectionId::Code, &offset)) + return false; + + if (!e.writeVarU32(module.funcs().length())) + return false; + + for (AstFunc* func : module.funcs()) { + if (!EncodeFunctionBody(e, *func)) + return false; + } + + e.finishSection(offset); + return true; +} + +static bool +EncodeDataSegment(Encoder& e, const AstDataSegment& segment) +{ + if (!e.writeVarU32(0)) // linear memory index + return false; + + if (!EncodeExpr(e, *segment.offset())) + return false; + if (!e.writeOp(Op::End)) + return false; + + size_t totalLength = 0; + for (const AstName& fragment : segment.fragments()) + totalLength += fragment.length(); + + Vector<uint8_t, 0, SystemAllocPolicy> bytes; + if (!bytes.reserve(totalLength)) + return false; + + for (const AstName& fragment : segment.fragments()) { + const char16_t* cur = fragment.begin(); + const char16_t* end = fragment.end(); + while (cur != end) { + uint8_t byte; + MOZ_ALWAYS_TRUE(ConsumeTextByte(&cur, end, &byte)); + bytes.infallibleAppend(byte); + } + } + + return e.writeBytes(bytes.begin(), bytes.length()); +} + +static bool +EncodeDataSection(Encoder& e, AstModule& module) +{ + if (module.dataSegments().empty()) + return true; + + size_t offset; + if (!e.startSection(SectionId::Data, &offset)) + return false; + + if (!e.writeVarU32(module.dataSegments().length())) + return false; + + for (AstDataSegment* segment : module.dataSegments()) { + if (!EncodeDataSegment(e, *segment)) + return false; + } + + e.finishSection(offset); + return true; +} + +static bool +EncodeElemSegment(Encoder& e, AstElemSegment& segment) +{ + if (!e.writeVarU32(0)) // table index + return false; + + if (!EncodeExpr(e, *segment.offset())) + return false; + if (!e.writeOp(Op::End)) + return false; + + if (!e.writeVarU32(segment.elems().length())) + return false; + + for (const AstRef& elem : segment.elems()) { + if (!e.writeVarU32(elem.index())) + return false; + } + + return true; +} + +static bool +EncodeElemSection(Encoder& e, AstModule& module) +{ + if (module.elemSegments().empty()) + return true; + + size_t offset; + if (!e.startSection(SectionId::Elem, &offset)) + return false; + + if (!e.writeVarU32(module.elemSegments().length())) + return false; + + for (AstElemSegment* segment : module.elemSegments()) { + if (!EncodeElemSegment(e, *segment)) + return false; + } + + e.finishSection(offset); + return true; +} + +static bool +EncodeModule(AstModule& module, Bytes* bytes) +{ + Encoder e(*bytes); + + if (!e.writeFixedU32(MagicNumber)) + return false; + + if (!e.writeFixedU32(EncodingVersion)) + return false; + + if (!EncodeTypeSection(e, module)) + return false; + + if (!EncodeImportSection(e, module)) + return false; + + if (!EncodeFunctionSection(e, module)) + return false; + + if (!EncodeTableSection(e, module)) + return false; + + if (!EncodeMemorySection(e, module)) + return false; + + if (!EncodeGlobalSection(e, module)) + return false; + + if (!EncodeExportSection(e, module)) + return false; + + if (!EncodeStartSection(e, module)) + return false; + + if (!EncodeElemSection(e, module)) + return false; + + if (!EncodeCodeSection(e, module)) + return false; + + if (!EncodeDataSection(e, module)) + return false; + + return true; +} + +static bool +EncodeBinaryModule(const AstModule& module, Bytes* bytes) +{ + Encoder e(*bytes); + + const AstDataSegmentVector& dataSegments = module.dataSegments(); + MOZ_ASSERT(dataSegments.length() == 1); + + for (const AstName& fragment : dataSegments[0]->fragments()) { + const char16_t* cur = fragment.begin(); + const char16_t* end = fragment.end(); + while (cur != end) { + uint8_t byte; + MOZ_ALWAYS_TRUE(ConsumeTextByte(&cur, end, &byte)); + if (!e.writeFixedU8(byte)) + return false; + } + } + + return true; +} + +/*****************************************************************************/ + +bool +wasm::TextToBinary(const char16_t* text, Bytes* bytes, UniqueChars* error) +{ + LifoAlloc lifo(AST_LIFO_DEFAULT_CHUNK_SIZE); + + bool binary = false; + AstModule* module = ParseModule(text, lifo, error, &binary); + if (!module) + return false; + + if (binary) + return EncodeBinaryModule(*module, bytes); + + if (!ResolveModule(lifo, module, error)) + return false; + + return EncodeModule(*module, bytes); +} |