new file mode 100644
--- /dev/null
+++ b/js/src/asmjs/WasmAST.h
@@ -0,0 +1,765 @@
+/* -*- 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.
+ */
+
+#ifndef wasmast_h
+#define wasmast_h
+
+#include "asmjs/WasmTypes.h"
+
+#include "ds/LifoAlloc.h"
+#include "js/HashTable.h"
+#include "js/Vector.h"
+
+namespace js {
+namespace wasm {
+
+const uint32_t AstNoIndex = UINT32_MAX;
+const unsigned AST_LIFO_DEFAULT_CHUNK_SIZE = 4096;
+
+/*****************************************************************************/
+// wasm AST
+
+class AstExpr;
+
+template <class T>
+using AstVector = mozilla::Vector<T, 0, LifoAllocPolicy<Fallible>>;
+
+template <class K, class V, class HP>
+using AstHashMap = HashMap<K, V, HP, LifoAllocPolicy<Fallible>>;
+
+class AstName
+{
+    const char16_t* begin_;
+    const char16_t* end_;
+  public:
+    AstName(const char16_t* begin, size_t length) : begin_(begin), end_(begin + length) {}
+    AstName() : begin_(nullptr), end_(nullptr) {}
+    const char16_t* begin() const { return begin_; }
+    const char16_t* end() const { return end_; }
+    size_t length() const { return end_ - begin_; }
+    bool empty() const { return begin_ == nullptr; }
+
+    bool operator==(AstName rhs) const {
+        if (length() != rhs.length())
+            return false;
+        if (begin() == rhs.begin())
+            return true;
+        return EqualChars(begin(), rhs.begin(), length());
+    }
+    bool operator!=(AstName rhs) const {
+        return !(*this == rhs);
+    }
+};
+
+class AstRef
+{
+    AstName name_;
+    uint32_t index_;
+
+  public:
+    AstRef()
+      : index_(AstNoIndex)
+    {
+        MOZ_ASSERT(isInvalid());
+    }
+    AstRef(AstName name, uint32_t index)
+      : name_(name), index_(index)
+    {
+        MOZ_ASSERT(name.empty() ^ (index == AstNoIndex));
+        MOZ_ASSERT(!isInvalid());
+    }
+    bool isInvalid() const {
+        return name_.empty() && index_ == AstNoIndex;
+    }
+    AstName name() const {
+        return name_;
+    }
+    size_t index() const {
+        MOZ_ASSERT(index_ != AstNoIndex);
+        return index_;
+    }
+    void setIndex(uint32_t index) {
+        MOZ_ASSERT(index_ == AstNoIndex);
+        index_ = index;
+    }
+};
+
+struct AstNameHasher
+{
+    typedef const AstName Lookup;
+    static js::HashNumber hash(Lookup l) {
+        return mozilla::HashString(l.begin(), l.length());
+    }
+    static bool match(const AstName key, Lookup lookup) {
+        return key == lookup;
+    }
+};
+
+using AstNameMap = AstHashMap<AstName, uint32_t, AstNameHasher>;
+
+typedef AstVector<ValType> AstValTypeVector;
+typedef AstVector<AstExpr*> AstExprVector;
+typedef AstVector<AstName> AstNameVector;
+typedef AstVector<AstRef> AstRefVector;
+
+struct AstBase
+{
+    void* operator new(size_t numBytes, LifoAlloc& astLifo) throw() {
+        return astLifo.alloc(numBytes);
+    }
+};
+
+class AstSig : public AstBase
+{
+    AstName name_;
+    AstValTypeVector args_;
+    ExprType ret_;
+
+  public:
+    explicit AstSig(LifoAlloc& lifo)
+      : args_(lifo),
+        ret_(ExprType::Void)
+    {}
+    AstSig(AstValTypeVector&& args, ExprType ret)
+      : args_(Move(args)),
+        ret_(ret)
+    {}
+    AstSig(AstName name, AstSig&& rhs)
+      : name_(name),
+        args_(Move(rhs.args_)),
+        ret_(rhs.ret_)
+    {}
+    void operator=(AstSig&& rhs) {
+        args_ = Move(rhs.args_);
+        ret_ = rhs.ret_;
+    }
+    const AstValTypeVector& args() const {
+        return args_;
+    }
+    ExprType ret() const {
+        return ret_;
+    }
+    AstName name() const {
+        return name_;
+    }
+    bool operator==(const AstSig& rhs) const {
+        return ret() == rhs.ret() && EqualContainers(args(), rhs.args());
+    }
+
+    typedef const AstSig& Lookup;
+    static HashNumber hash(Lookup sig) {
+        return AddContainerToHash(sig.args(), HashNumber(sig.ret()));
+    }
+    static bool match(const AstSig* lhs, Lookup rhs) {
+        return *lhs == rhs;
+    }
+};
+
+class AstNode : public AstBase
+{};
+
+enum class AstExprKind
+{
+    BinaryOperator,
+    Block,
+    Branch,
+    BranchTable,
+    Call,
+    CallIndirect,
+    ComparisonOperator,
+    Const,
+    ConversionOperator,
+    GetLocal,
+    If,
+    Load,
+    Nop,
+    Return,
+    SetLocal,
+    Store,
+    TernaryOperator,
+    UnaryOperator,
+    Unreachable
+};
+
+class AstExpr : public AstNode
+{
+    const AstExprKind kind_;
+
+  protected:
+    explicit AstExpr(AstExprKind kind)
+      : kind_(kind)
+    {}
+
+  public:
+    AstExprKind kind() const { return kind_; }
+
+    template <class T>
+    T& as() {
+        MOZ_ASSERT(kind() == T::Kind);
+        return static_cast<T&>(*this);
+    }
+};
+
+struct AstNop : AstExpr
+{
+    static const AstExprKind Kind = AstExprKind::Nop;
+    AstNop()
+      : AstExpr(AstExprKind::Nop)
+    {}
+};
+
+struct AstUnreachable : AstExpr
+{
+    static const AstExprKind Kind = AstExprKind::Unreachable;
+    AstUnreachable()
+      : AstExpr(AstExprKind::Unreachable)
+    {}
+};
+
+class AstConst : public AstExpr
+{
+    const Val val_;
+
+  public:
+    static const AstExprKind Kind = AstExprKind::Const;
+    explicit AstConst(Val val)
+      : AstExpr(Kind),
+        val_(val)
+    {}
+    Val val() const { return val_; }
+};
+
+class AstGetLocal : public AstExpr
+{
+    AstRef local_;
+
+  public:
+    static const AstExprKind Kind = AstExprKind::GetLocal;
+    explicit AstGetLocal(AstRef local)
+      : AstExpr(Kind),
+        local_(local)
+    {}
+    AstRef& local() {
+        return local_;
+    }
+};
+
+class AstSetLocal : public AstExpr
+{
+    AstRef local_;
+    AstExpr& value_;
+
+  public:
+    static const AstExprKind Kind = AstExprKind::SetLocal;
+    AstSetLocal(AstRef local, AstExpr& value)
+      : AstExpr(Kind),
+        local_(local),
+        value_(value)
+    {}
+    AstRef& local() {
+        return local_;
+    }
+    AstExpr& value() const {
+        return value_;
+    }
+};
+
+class AstBlock : public AstExpr
+{
+    Expr expr_;
+    AstName breakName_;
+    AstName continueName_;
+    AstExprVector exprs_;
+
+  public:
+    static const AstExprKind Kind = AstExprKind::Block;
+    explicit AstBlock(Expr expr, AstName breakName,
+                          AstName continueName, AstExprVector&& exprs)
+      : AstExpr(Kind),
+        expr_(expr),
+        breakName_(breakName),
+        continueName_(continueName),
+        exprs_(Move(exprs))
+    {}
+
+    Expr expr() const { return expr_; }
+    AstName breakName() const { return breakName_; }
+    AstName continueName() const { return continueName_; }
+    const AstExprVector& exprs() const { return exprs_; }
+};
+
+class AstBranch : public AstExpr
+{
+    Expr expr_;
+    AstExpr* cond_;
+    AstRef target_;
+    AstExpr* value_;
+
+  public:
+    static const AstExprKind Kind = AstExprKind::Branch;
+    explicit AstBranch(Expr expr, AstExpr* cond, AstRef target, AstExpr* value)
+      : AstExpr(Kind),
+        expr_(expr),
+        cond_(cond),
+        target_(target),
+        value_(value)
+    {}
+
+    Expr expr() const { return expr_; }
+    AstRef& target() { return target_; }
+    AstExpr& cond() const { MOZ_ASSERT(cond_); return *cond_; }
+    AstExpr* maybeValue() const { return value_; }
+};
+
+class AstCall : public AstExpr
+{
+    Expr expr_;
+    AstRef func_;
+    AstExprVector args_;
+
+  public:
+    static const AstExprKind Kind = AstExprKind::Call;
+    AstCall(Expr expr, AstRef func, AstExprVector&& args)
+      : AstExpr(Kind), expr_(expr), func_(func), args_(Move(args))
+    {}
+
+    Expr expr() const { return expr_; }
+    AstRef& func() { return func_; }
+    const AstExprVector& args() const { return args_; }
+};
+
+class AstCallIndirect : public AstExpr
+{
+    AstRef sig_;
+    AstExpr* index_;
+    AstExprVector args_;
+
+  public:
+    static const AstExprKind Kind = AstExprKind::CallIndirect;
+    AstCallIndirect(AstRef sig, AstExpr* index, AstExprVector&& args)
+      : AstExpr(Kind), sig_(sig), index_(index), args_(Move(args))
+    {}
+    AstRef& sig() { return sig_; }
+    AstExpr* index() const { return index_; }
+    const AstExprVector& args() const { return args_; }
+};
+
+class AstReturn : public AstExpr
+{
+    AstExpr* maybeExpr_;
+
+  public:
+    static const AstExprKind Kind = AstExprKind::Return;
+    explicit AstReturn(AstExpr* maybeExpr)
+      : AstExpr(Kind),
+        maybeExpr_(maybeExpr)
+    {}
+    AstExpr* maybeExpr() const { return maybeExpr_; }
+};
+
+class AstIf : public AstExpr
+{
+    AstExpr* cond_;
+    AstExpr* thenBranch_;
+    AstExpr* elseBranch_;
+
+  public:
+    static const AstExprKind Kind = AstExprKind::If;
+    AstIf(AstExpr* cond, AstExpr* thenBranch, AstExpr* elseBranch)
+      : AstExpr(Kind),
+        cond_(cond),
+        thenBranch_(thenBranch),
+        elseBranch_(elseBranch)
+    {}
+
+    AstExpr& cond() const { return *cond_; }
+    AstExpr& thenBranch() const { return *thenBranch_; }
+    bool hasElse() const { return !!elseBranch_; }
+    AstExpr& elseBranch() const { MOZ_ASSERT(hasElse()); return *elseBranch_; }
+};
+
+class AstLoadStoreAddress
+{
+    AstExpr* base_;
+    int32_t flags_;
+    int32_t offset_;
+
+  public:
+    explicit AstLoadStoreAddress(AstExpr* base, int32_t flags, int32_t offset)
+      : base_(base),
+        flags_(flags),
+        offset_(offset)
+    {}
+
+    AstExpr& base() const { return *base_; }
+    int32_t flags() const { return flags_; }
+    int32_t offset() const { return offset_; }
+};
+
+class AstLoad : public AstExpr
+{
+    Expr expr_;
+    AstLoadStoreAddress address_;
+
+  public:
+    static const AstExprKind Kind = AstExprKind::Load;
+    explicit AstLoad(Expr expr, const AstLoadStoreAddress &address)
+      : AstExpr(Kind),
+        expr_(expr),
+        address_(address)
+    {}
+
+    Expr expr() const { return expr_; }
+    const AstLoadStoreAddress& address() const { return address_; }
+};
+
+class AstStore : public AstExpr
+{
+    Expr expr_;
+    AstLoadStoreAddress address_;
+    AstExpr* value_;
+
+  public:
+    static const AstExprKind Kind = AstExprKind::Store;
+    explicit AstStore(Expr expr, const AstLoadStoreAddress &address,
+                          AstExpr* value)
+      : AstExpr(Kind),
+        expr_(expr),
+        address_(address),
+        value_(value)
+    {}
+
+    Expr expr() const { return expr_; }
+    const AstLoadStoreAddress& address() const { return address_; }
+    AstExpr& value() const { return *value_; }
+};
+
+class AstBranchTable : public AstExpr
+{
+    AstExpr& index_;
+    AstRef default_;
+    AstRefVector table_;
+    AstExpr* value_;
+
+  public:
+    static const AstExprKind Kind = AstExprKind::BranchTable;
+    explicit AstBranchTable(AstExpr& index, AstRef def, AstRefVector&& table,
+                                AstExpr* maybeValue)
+      : AstExpr(Kind),
+        index_(index),
+        default_(def),
+        table_(Move(table)),
+        value_(maybeValue)
+    {}
+    AstExpr& index() const { return index_; }
+    AstRef& def() { return default_; }
+    AstRefVector& table() { return table_; }
+    AstExpr* maybeValue() { return value_; }
+};
+
+class AstFunc : public AstNode
+{
+    AstName name_;
+    AstRef sig_;
+    AstValTypeVector vars_;
+    AstNameVector localNames_;
+    AstExprVector body_;
+
+  public:
+    AstFunc(AstName name, AstRef sig, AstValTypeVector&& vars,
+                AstNameVector&& locals, AstExprVector&& body)
+      : name_(name),
+        sig_(sig),
+        vars_(Move(vars)),
+        localNames_(Move(locals)),
+        body_(Move(body))
+    {}
+    AstRef& sig() { return sig_; }
+    const AstValTypeVector& vars() const { return vars_; }
+    const AstNameVector& locals() const { return localNames_; }
+    const AstExprVector& body() const { return body_; }
+    AstName name() const { return name_; }
+};
+
+class AstImport : public AstNode
+{
+    AstName name_;
+    AstName module_;
+    AstName func_;
+    uint32_t sigIndex_;
+
+  public:
+    AstImport(AstName name, AstName module, AstName func, uint32_t sigIndex)
+      : name_(name), module_(module), func_(func), sigIndex_(sigIndex)
+    {}
+    AstName name() const { return name_; }
+    AstName module() const { return module_; }
+    AstName func() const { return func_; }
+    uint32_t sigIndex() const { return sigIndex_; }
+};
+
+enum class AstExportKind { Func, Memory };
+
+class AstExport : public AstNode
+{
+    AstName name_;
+    AstExportKind kind_;
+    AstRef func_;
+
+  public:
+    AstExport(AstName name, AstRef func)
+      : name_(name), kind_(AstExportKind::Func), func_(func)
+    {}
+    explicit AstExport(AstName name)
+      : name_(name), kind_(AstExportKind::Memory)
+    {}
+    AstName name() const { return name_; }
+    AstExportKind kind() const { return kind_; }
+    AstRef& func() { return func_; }
+};
+
+typedef AstVector<AstRef> AstTableElemVector;
+
+class AstTable : public AstNode
+{
+    AstTableElemVector elems_;
+
+  public:
+    explicit AstTable(AstTableElemVector&& elems) : elems_(Move(elems)) {}
+    AstTableElemVector& elems() { return elems_; }
+};
+
+class AstSegment : public AstNode
+{
+    uint32_t offset_;
+    AstName text_;
+
+  public:
+    AstSegment(uint32_t offset, AstName text)
+      : offset_(offset), text_(text)
+    {}
+    uint32_t offset() const { return offset_; }
+    AstName text() const { return text_; }
+};
+
+typedef AstVector<AstSegment*> AstSegmentVector;
+
+class AstMemory : public AstNode
+{
+    uint32_t initialSize_;
+    Maybe<uint32_t> maxSize_;
+    AstSegmentVector segments_;
+
+  public:
+    explicit AstMemory(uint32_t initialSize, Maybe<uint32_t> maxSize,
+                           AstSegmentVector&& segments)
+      : initialSize_(initialSize),
+        maxSize_(maxSize),
+        segments_(Move(segments))
+    {}
+    uint32_t initialSize() const { return initialSize_; }
+    const Maybe<uint32_t>& maxSize() const { return maxSize_; }
+    const AstSegmentVector& segments() const { return segments_; }
+};
+
+class AstModule : public AstNode
+{
+  public:
+    typedef AstVector<AstFunc*> FuncVector;
+    typedef AstVector<AstImport*> ImportVector;
+    typedef AstVector<AstExport*> ExportVector;
+    typedef AstVector<AstSig*> SigVector;
+
+  private:
+    typedef AstHashMap<AstSig*, uint32_t, AstSig> SigMap;
+
+    LifoAlloc& lifo_;
+    AstMemory* memory_;
+    SigVector sigs_;
+    SigMap sigMap_;
+    ImportVector imports_;
+    ExportVector exports_;
+    AstTable* table_;
+    FuncVector funcs_;
+
+  public:
+    explicit AstModule(LifoAlloc& lifo)
+      : lifo_(lifo),
+        memory_(nullptr),
+        sigs_(lifo),
+        sigMap_(lifo),
+        imports_(lifo),
+        exports_(lifo),
+        table_(nullptr),
+        funcs_(lifo)
+    {}
+    bool init() {
+        return sigMap_.init();
+    }
+    bool setMemory(AstMemory* memory) {
+        if (memory_)
+            return false;
+        memory_ = memory;
+        return true;
+    }
+    AstMemory* maybeMemory() const {
+        return memory_;
+    }
+    bool declare(AstSig&& sig, uint32_t* sigIndex) {
+        SigMap::AddPtr p = sigMap_.lookupForAdd(sig);
+        if (p) {
+            *sigIndex = p->value();
+            return true;
+        }
+        *sigIndex = sigs_.length();
+        auto* lifoSig = new (lifo_) AstSig(AstName(), Move(sig));
+        return lifoSig &&
+               sigs_.append(lifoSig) &&
+               sigMap_.add(p, sigs_.back(), *sigIndex);
+    }
+    bool append(AstSig* sig) {
+        uint32_t sigIndex = sigs_.length();
+        if (!sigs_.append(sig))
+            return false;
+        SigMap::AddPtr p = sigMap_.lookupForAdd(*sig);
+        return p || sigMap_.add(p, sig, sigIndex);
+    }
+    const SigVector& sigs() const {
+        return sigs_;
+    }
+    bool append(AstFunc* func) {
+        return funcs_.append(func);
+    }
+    const FuncVector& funcs() const {
+        return funcs_;
+    }
+    const ImportVector& imports() const {
+        return imports_;
+    }
+    bool append(AstImport* imp) {
+        return imports_.append(imp);
+    }
+    bool append(AstExport* exp) {
+        return exports_.append(exp);
+    }
+    const ExportVector& exports() const {
+        return exports_;
+    }
+    bool initTable(AstTable* table) {
+        if (table_)
+            return false;
+        table_ = table;
+        return true;
+    }
+    AstTable* maybeTable() const {
+        return table_;
+    }
+};
+
+class AstUnaryOperator final : public AstExpr
+{
+    Expr expr_;
+    AstExpr* op_;
+
+  public:
+    static const AstExprKind Kind = AstExprKind::UnaryOperator;
+    explicit AstUnaryOperator(Expr expr, AstExpr* op)
+      : AstExpr(Kind),
+        expr_(expr), op_(op)
+    {}
+
+    Expr expr() const { return expr_; }
+    AstExpr* op() const { return op_; }
+};
+
+class AstBinaryOperator final : public AstExpr
+{
+    Expr expr_;
+    AstExpr* lhs_;
+    AstExpr* rhs_;
+
+  public:
+    static const AstExprKind Kind = AstExprKind::BinaryOperator;
+    explicit AstBinaryOperator(Expr expr, AstExpr* lhs, AstExpr* rhs)
+      : AstExpr(Kind),
+        expr_(expr), lhs_(lhs), rhs_(rhs)
+    {}
+
+    Expr expr() const { return expr_; }
+    AstExpr* lhs() const { return lhs_; }
+    AstExpr* rhs() const { return rhs_; }
+};
+
+class AstTernaryOperator : public AstExpr
+{
+    Expr expr_;
+    AstExpr* op0_;
+    AstExpr* op1_;
+    AstExpr* op2_;
+
+  public:
+    static const AstExprKind Kind = AstExprKind::TernaryOperator;
+    AstTernaryOperator(Expr expr, AstExpr* op0, AstExpr* op1, AstExpr* op2)
+      : AstExpr(Kind),
+        expr_(expr), op0_(op0), op1_(op1), op2_(op2)
+    {}
+
+    Expr expr() const { return expr_; }
+    AstExpr* op0() const { return op0_; }
+    AstExpr* op1() const { return op1_; }
+    AstExpr* op2() const { return op2_; }
+};
+
+class AstComparisonOperator final : public AstExpr
+{
+    Expr expr_;
+    AstExpr* lhs_;
+    AstExpr* rhs_;
+
+  public:
+    static const AstExprKind Kind = AstExprKind::ComparisonOperator;
+    explicit AstComparisonOperator(Expr expr, AstExpr* lhs, AstExpr* rhs)
+      : AstExpr(Kind),
+        expr_(expr), lhs_(lhs), rhs_(rhs)
+    {}
+
+    Expr expr() const { return expr_; }
+    AstExpr* lhs() const { return lhs_; }
+    AstExpr* rhs() const { return rhs_; }
+};
+
+class AstConversionOperator final : public AstExpr
+{
+    Expr expr_;
+    AstExpr* op_;
+
+  public:
+    static const AstExprKind Kind = AstExprKind::ConversionOperator;
+    explicit AstConversionOperator(Expr expr, AstExpr* op)
+      : AstExpr(Kind),
+        expr_(expr), op_(op)
+    {}
+
+    Expr expr() const { return expr_; }
+    AstExpr* op() const { return op_; }
+};
+
+} // end wasm namespace
+} // end js namespace
+
+#endif // namespace wasmast_h

new file mode 100644
--- /dev/null
+++ b/js/src/asmjs/WasmBinaryToAST.cpp
@@ -0,0 +1,1387 @@
+/* -*- 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 2016 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 "asmjs/WasmBinaryToAST.h"
+
+#include "mozilla/MathAlgorithms.h"
+
+#include "asmjs/Wasm.h"
+#include "asmjs/WasmBinaryIterator.h"
+
+using namespace js;
+using namespace js::wasm;
+
+using mozilla::FloorLog2;
+
+enum AstDecodeTerminationKind
+{
+    Unknown,
+    End,
+    Else
+};
+
+struct AstDecodeStackItem
+{
+    AstExpr* expr;
+    union {
+      uint32_t stackDelta;
+      AstDecodeTerminationKind terminationKind;
+    };
+
+    explicit AstDecodeStackItem(): expr(nullptr), terminationKind(AstDecodeTerminationKind::Unknown) {}
+    explicit AstDecodeStackItem(AstDecodeTerminationKind terminationKind): expr(nullptr), terminationKind(terminationKind) {}
+    explicit AstDecodeStackItem(AstExpr* expr): expr(expr), stackDelta(0) {}
+    explicit AstDecodeStackItem(AstExpr* expr, uint32_t stackDelta): expr(expr), stackDelta(stackDelta) {}
+};
+
+struct AstDecodePolicy : ExprIterPolicy
+{
+    static const bool Output = true;
+    typedef AstDecodeStackItem Value;
+};
+
+typedef ExprIter<AstDecodePolicy> AstDecodeExprIter;
+
+class AstDecodeContext
+{
+  public:
+    typedef AstVector<uint32_t> AstIndexVector;
+
+    JSContext* cx;
+    LifoAlloc& lifo;
+    Decoder& d;
+    bool generateNames;
+
+    uint32_t numTableElems;
+    Maybe<uint32_t> initialSizePages;
+    Maybe<uint32_t> maxSizePages;
+
+  private:
+    AstModule& module_;
+    AstIndexVector funcSigs_;
+    AstDecodeExprIter *iter_;
+    const ValTypeVector* locals_;
+
+  public:
+    AstDecodeContext(JSContext* cx, LifoAlloc& lifo, Decoder& d, AstModule& module, bool generateNames)
+     : cx(cx),
+       lifo(lifo),
+       d(d),
+       generateNames(generateNames),
+       numTableElems(0),
+       initialSizePages(),
+       maxSizePages(),
+       module_(module),
+       funcSigs_(lifo),
+       iter_(nullptr),
+       locals_(nullptr)
+    {}
+
+    AstModule& module() { return module_; }
+    AstIndexVector& funcSigs() { return funcSigs_; }
+    AstDecodeExprIter& iter() { return *iter_; }
+    const ValTypeVector& locals() { return *locals_; }
+
+    void startFunction(AstDecodeExprIter *iter, const ValTypeVector* locals)
+    {
+        this->iter_ = iter;
+        this->locals_ = locals;
+    }
+    void endFunction()
+    {
+        this->iter_ = nullptr;
+        this->locals_ = nullptr;
+    }
+};
+
+static bool
+AstDecodeFail(AstDecodeContext& c, const char* str)
+{
+    uint32_t offset = c.d.currentOffset();
+    char offsetStr[sizeof "4294967295"];
+    JS_snprintf(offsetStr, sizeof offsetStr, "%" PRIu32, offset);
+    JS_ReportErrorNumber(c.cx, GetErrorMessage, nullptr, JSMSG_WASM_DECODE_FAIL, offsetStr, str);
+    return false;
+}
+
+static bool
+AstDecodeGenerateName(AstDecodeContext& c, const AstName& prefix, uint32_t index, AstName& name)
+{
+    if (!c.generateNames) {
+        name = AstName();
+        return true;
+    }
+
+    AstVector<char16_t> result(c.lifo);
+    if (!result.append(prefix.begin(), prefix.length()))
+        return false;
+    uint32_t tmp = index;
+    do {
+        if (!result.append(MOZ_UTF16('0')))
+            return false;
+        tmp /= 10;
+    } while (tmp);
+
+    if (index) {
+        char16_t* p = result.end();
+        for (tmp = index; tmp; tmp /= 10)
+            *(--p) = MOZ_UTF16('0' + (tmp % 10));
+    }
+
+    size_t length = result.length();
+    char16_t* begin = result.extractOrCopyRawBuffer();
+    if (!begin)
+        return false;
+
+    name = AstName(begin, length);
+    return true;
+}
+
+static bool
+AstDecodeGenerateRef(AstDecodeContext& c, const AstName& prefix, uint32_t index, AstRef& ref)
+{
+    MOZ_ASSERT(index != AstNoIndex);
+
+    if (!c.generateNames) {
+        ref = AstRef(AstName(), index);
+        return true;
+    }
+
+    AstName name;
+    if (!AstDecodeGenerateName(c, prefix, index, name))
+        return false;
+    MOZ_ASSERT(!name.empty());
+
+    ref = AstRef(name, AstNoIndex);
+    ref.setIndex(index);
+    return true;
+}
+
+static bool
+AstDecodeCallArgs(AstDecodeContext& c, uint32_t arity, const AstSig& sig, AstExprVector& funcArgs)
+{
+    if (arity != sig.args().length())
+        return c.iter().fail("call arity out of range");
+
+    const AstValTypeVector& args = sig.args();
+    uint32_t numArgs = args.length();
+
+    if (!funcArgs.resize(numArgs))
+        return false;
+
+    for (size_t i = 0; i < numArgs; ++i) {
+        ValType argType = args[i];
+        AstDecodeStackItem item;
+        if (!c.iter().readCallArg(argType, numArgs, i, &item))
+            return false;
+        funcArgs[i] = item.expr;
+    }
+
+    return c.iter().readCallArgsEnd(numArgs);
+}
+
+static bool
+AstDecodeCallReturn(AstDecodeContext& c, const AstSig& sig)
+{
+    return c.iter().readCallReturn(sig.ret());
+}
+
+static bool
+AstDecodeExpr(AstDecodeContext& c);
+
+static bool
+AstDecodeCall(AstDecodeContext& c)
+{
+    uint32_t calleeIndex;
+    uint32_t arity;
+    if (!c.iter().readCall(&calleeIndex, &arity))
+        return false;
+
+    if (calleeIndex >= c.funcSigs().length())
+        return c.iter().fail("callee index out of range");
+
+    uint32_t sigIndex = c.funcSigs()[calleeIndex];
+    const AstSig* sig = c.module().sigs()[sigIndex];
+    AstRef funcRef;
+    if (!AstDecodeGenerateRef(c, AstName(MOZ_UTF16("$func$"), 6), calleeIndex, funcRef))
+        return false;
+    AstExprVector args(c.lifo);
+    if (!AstDecodeCallArgs(c, arity, *sig, args) ||
+        !AstDecodeCallReturn(c, *sig))
+        return false;
+    AstCall* call = new(c.lifo) AstCall(Expr::Call, funcRef, Move(args));
+    c.iter().setResult(AstDecodeStackItem(call, args.length()));
+    return call;
+}
+
+static bool
+AstDecodeCallIndirect(AstDecodeContext& c)
+{
+    uint32_t sigIndex;
+    uint32_t arity;
+    if (!c.iter().readCallIndirect(&sigIndex, &arity))
+        return false;
+
+    if (sigIndex >= c.module().sigs().length())
+        return c.iter().fail("signature index out of range");
+
+    const AstSig* sig = c.module().sigs()[sigIndex];
+    AstExprVector args(c.lifo);
+    if (!AstDecodeCallArgs(c, arity, *sig, args))
+        return false;
+
+    AstDecodeStackItem index;
+    if (!c.iter().readCallIndirectCallee(&index))
+        return false;
+
+
+    if (!AstDecodeCallReturn(c, *sig))
+        return false;
+    AstRef sigRef;
+    if (!AstDecodeGenerateRef(c, AstName(MOZ_UTF16("$type$"), 6), sigIndex, sigRef))
+        return false;
+    AstCallIndirect* call = new(c.lifo) AstCallIndirect(sigRef, index.expr, Move(args));
+    c.iter().setResult(AstDecodeStackItem(call, 1 + args.length()));
+    return call;
+}
+
+static bool
+AstDecodeCallImport(AstDecodeContext& c)
+{
+    uint32_t importIndex;
+    uint32_t arity;
+    if (!c.iter().readCallImport(&importIndex, &arity))
+        return false;
+
+    if (importIndex >= c.module().imports().length())
+        return c.iter().fail("import index out of range");
+
+    const AstImport* import = c.module().imports()[importIndex];
+    const AstSig* sig = c.module().sigs()[import->sigIndex()];
+    AstRef funcRef;
+    if (!AstDecodeGenerateRef(c, AstName(MOZ_UTF16("$import$"), 8), importIndex, funcRef))
+        return false;
+    AstExprVector args(c.lifo);
+    if (!AstDecodeCallArgs(c, arity, *sig, args) ||
+        !AstDecodeCallReturn(c, *sig))
+        return false;
+    AstCall* call = new(c.lifo) AstCall(Expr::CallImport, funcRef, Move(args));
+    c.iter().setResult(AstDecodeStackItem(call, args.length()));
+    return call;
+}
+
+static bool
+AstDecodeBrTable(AstDecodeContext& c)
+{
+    uint32_t tableLength;
+    ExprType type;
+    AstDecodeStackItem index;
+    AstDecodeStackItem value;
+    if (!c.iter().readBrTable(&tableLength, &type, &value, &index))
+        return false;
+
+    AstRefVector table(c.lifo);
+    if (!table.resize(tableLength))
+        return false;
+
+    uint32_t depth;
+    for (size_t i = 0, e = tableLength; i < e; ++i) {
+        if (!c.iter().readBrTableEntry(type, &depth))
+            return false;
+        table[i] = AstRef(AstName(), depth);
+    }
+
+    // Read the default label.
+    if (!c.iter().readBrTableEntry(type, &depth))
+        return false;
+    AstRef def(AstName(), depth);
+
+
+    AstBranchTable* branchTable = new(c.lifo) AstBranchTable(*index.expr, def, Move(table), value.expr);
+    c.iter().setResult(AstDecodeStackItem(branchTable, value.expr ? 2 : 1));
+    return branchTable;
+}
+
+static bool
+AstDecodeBlock(AstDecodeContext& c, Expr expr)
+{
+    MOZ_ASSERT(expr == Expr::Block || expr == Expr::Loop);
+
+    if (expr == Expr::Loop) {
+      if (!c.iter().readLoop())
+          return false;
+    } else {
+      if (!c.iter().readBlock())
+          return false;
+    }
+    AstExprVector exprs(c.lifo);
+    while (true) {
+        if (!AstDecodeExpr(c))
+            return false;
+        AstDecodeStackItem item = c.iter().getResult();
+        if (!item.expr) // Expr::End was found
+            break;
+        exprs.shrinkBy(item.stackDelta);
+        if (!exprs.append(item.expr))
+            return false;
+    }
+    AstBlock* block = new(c.lifo) AstBlock(expr, AstName(), AstName(), Move(exprs));
+    c.iter().setResult(AstDecodeStackItem(block));
+    return block;
+}
+
+static bool
+AstDecodeIf(AstDecodeContext& c)
+{
+    AstDecodeStackItem cond;
+    if (!c.iter().readIf(&cond))
+        return false;
+
+    if (!AstDecodeExpr(c))
+        return false;
+
+    AstDecodeStackItem nextItem;
+    AstDecodeStackItem thenItem = c.iter().getResult();
+    while (true) {
+        if (!AstDecodeExpr(c))
+            return false;
+        nextItem = c.iter().getResult();
+        if (!nextItem.expr)
+            break;
+        thenItem = nextItem;
+    }
+
+    AstDecodeStackItem elseItem;
+    if (nextItem.terminationKind == AstDecodeTerminationKind::Else) {
+        if (!AstDecodeExpr(c))
+            return false;
+        elseItem = c.iter().getResult();
+
+        while (true) {
+            if (!AstDecodeExpr(c))
+                return false;
+            nextItem = c.iter().getResult();
+            if (!nextItem.expr)
+                break;
+            elseItem = nextItem;
+        }
+    }
+
+    AstIf* if_ = new(c.lifo) AstIf(cond.expr, thenItem.expr, elseItem.expr);
+    c.iter().setResult(AstDecodeStackItem(if_, 1));
+    return if_;
+}
+
+static bool
+AstDecodeEnd(AstDecodeContext& c)
+{
+    LabelKind kind;
+    ExprType type;
+    AstDecodeStackItem tmp;
+    if (!c.iter().readEnd(&kind, &type, &tmp))
+        return false;
+
+    c.iter().setResult(AstDecodeStackItem(AstDecodeTerminationKind::End));
+    return true;
+}
+
+static bool
+AstDecodeElse(AstDecodeContext& c)
+{
+    ExprType type;
+    AstDecodeStackItem tmp;
+
+    if (!c.iter().readElse(&type, &tmp))
+        return false;
+
+    c.iter().setResult(AstDecodeStackItem(AstDecodeTerminationKind::Else));
+    return true;
+}
+
+static bool
+AstDecodeUnary(AstDecodeContext& c, ValType type, Expr expr)
+{
+    AstDecodeStackItem op;
+    if (!c.iter().readUnary(type, &op))
+        return false;
+    AstUnaryOperator* unary = new(c.lifo) AstUnaryOperator(expr, op.expr);
+    c.iter().setResult(AstDecodeStackItem(unary, 1));
+    return unary;
+}
+
+static bool
+AstDecodeBinary(AstDecodeContext& c, ValType type, Expr expr)
+{
+    AstDecodeStackItem lhs;
+    AstDecodeStackItem rhs;
+    if (!c.iter().readBinary(type, &lhs, &rhs))
+        return false;
+    AstBinaryOperator* binary = new(c.lifo) AstBinaryOperator(expr, lhs.expr, rhs.expr);
+    c.iter().setResult(AstDecodeStackItem(binary, 2));
+    return binary;
+}
+
+static bool
+AstDecodeSelect(AstDecodeContext& c)
+{
+    ExprType type;
+    AstDecodeStackItem cond;
+    AstDecodeStackItem selectTrue;
+    AstDecodeStackItem selectFalse;
+    if (!c.iter().readSelect(&type, &cond, &selectTrue, &selectFalse))
+        return false;
+    AstTernaryOperator* ternary = new(c.lifo) AstTernaryOperator(Expr::Select, cond.expr, selectTrue.expr, selectFalse.expr);
+    c.iter().setResult(AstDecodeStackItem(ternary, 3));
+    return ternary;
+}
+
+static bool
+AstDecodeComparison(AstDecodeContext& c, ValType type, Expr expr)
+{
+    AstDecodeStackItem lhs;
+    AstDecodeStackItem rhs;
+    if (!c.iter().readComparison(type, &lhs, &rhs))
+        return false;
+    AstComparisonOperator* comparison = new(c.lifo) AstComparisonOperator(expr, lhs.expr, rhs.expr);
+    c.iter().setResult(AstDecodeStackItem(comparison, 2));
+    return comparison;
+}
+
+static bool
+AstDecodeConversion(AstDecodeContext& c, ValType fromType, ValType toType, Expr expr)
+{
+    AstDecodeStackItem op;
+    if (!c.iter().readConversion(fromType, toType, &op))
+        return false;
+    AstConversionOperator* conversion = new(c.lifo) AstConversionOperator(expr, op.expr);
+    c.iter().setResult(AstDecodeStackItem(conversion, 1));
+    return conversion;
+}
+
+static AstLoadStoreAddress
+AstDecodeLoadStoreAddress(const LinearMemoryAddress<AstDecodeStackItem>& addr)
+{
+    uint32_t flags = FloorLog2(addr.align);
+    return AstLoadStoreAddress(addr.base.expr, flags, addr.offset);
+}
+
+static bool
+AstDecodeLoad(AstDecodeContext& c, ValType type, uint32_t byteSize, Expr expr)
+{
+    LinearMemoryAddress<AstDecodeStackItem> addr;
+    if (!c.iter().readLoad(type, byteSize, &addr))
+        return false;
+    AstLoad* load = new(c.lifo) AstLoad(expr, AstDecodeLoadStoreAddress(addr));
+    c.iter().setResult(AstDecodeStackItem(load, 1));
+    return load;
+}
+
+static bool
+AstDecodeStore(AstDecodeContext& c, ValType type, uint32_t byteSize, Expr expr)
+{
+    LinearMemoryAddress<AstDecodeStackItem> addr;
+    AstDecodeStackItem value;
+    if (!c.iter().readStore(type, byteSize, &addr, &value))
+        return false;
+    AstStore* store = new(c.lifo) AstStore(expr, AstDecodeLoadStoreAddress(addr), value.expr);
+    c.iter().setResult(AstDecodeStackItem(store, 2));
+    return store;
+}
+
+static bool
+AstDecodeBranch(AstDecodeContext& c, Expr expr)
+{
+    MOZ_ASSERT(expr == Expr::Br || expr == Expr::BrIf);
+
+    uint32_t depth;
+    ExprType type;
+    AstDecodeStackItem value;
+    AstDecodeStackItem cond;
+    uint32_t stackDelta;
+    if (expr == Expr::Br) {
+        if (!c.iter().readBr(&depth, &type, &value))
+            return false;
+        stackDelta = value.expr ? 1 : 0;
+    } else {
+        if (!c.iter().readBrIf(&depth, &type, &value, &cond))
+            return false;
+        stackDelta = value.expr ? 2 : 1;
+    }
+
+    AstRef depthRef(AstName(), depth);
+    AstBranch* branch = new(c.lifo) AstBranch(expr, cond.expr, depthRef, value.expr);
+    c.iter().setResult(AstDecodeStackItem(branch, stackDelta));
+    return branch;
+}
+
+static bool
+AstDecodeGetLocal(AstDecodeContext& c)
+{
+    uint32_t getLocalId;
+    if (!c.iter().readGetLocal(c.locals(), &getLocalId))
+        return false;
+    AstRef localRef;
+    if (!AstDecodeGenerateRef(c, AstName(MOZ_UTF16("$var$"), 5), getLocalId, localRef))
+        return false;
+    AstGetLocal* getLocal = new(c.lifo) AstGetLocal(localRef);
+    c.iter().setResult(AstDecodeStackItem(getLocal));
+    return getLocal;
+}
+
+static bool
+AstDecodeSetLocal(AstDecodeContext& c)
+{
+    uint32_t setLocalId;
+    AstDecodeStackItem setLocalValue;
+    if (!c.iter().readSetLocal(c.locals(), &setLocalId, &setLocalValue))
+        return false;
+    AstRef localRef;
+    if (!AstDecodeGenerateRef(c, AstName(MOZ_UTF16("$var$"), 5), setLocalId, localRef))
+        return false;
+    AstSetLocal* setLocal = new(c.lifo) AstSetLocal(localRef, *setLocalValue.expr);
+    c.iter().setResult(AstDecodeStackItem(setLocal, 1));
+    return setLocal;
+}
+
+static bool
+AstDecodeReturn(AstDecodeContext& c)
+{
+    AstDecodeStackItem result;
+    if (!c.iter().readReturn(&result))
+        return false;
+    AstReturn* ret = new(c.lifo) AstReturn(result.expr);
+    c.iter().setResult(AstDecodeStackItem(ret, result.expr ? 1 : 0));
+    return ret;
+}
+
+static bool
+AstDecodeExpr(AstDecodeContext& c)
+{
+    Expr expr;
+    if (!c.iter().readExpr(&expr))
+        return false;
+
+    AstExpr* tmp;
+    switch (expr) {
+      case Expr::Nop:
+        if (!c.iter().readNullary())
+            return false;
+        tmp = new(c.lifo) AstNop();
+        c.iter().setResult(AstDecodeStackItem(tmp));
+        return tmp;
+      case Expr::Call:
+        return AstDecodeCall(c);
+      case Expr::CallIndirect:
+        return AstDecodeCallIndirect(c);
+      case Expr::CallImport:
+        return AstDecodeCallImport(c);
+      case Expr::I32Const:
+        int32_t i32;
+        if (!c.iter().readI32Const(&i32))
+            return false;
+        tmp = new(c.lifo) AstConst(Val((uint32_t)i32));
+        c.iter().setResult(AstDecodeStackItem(tmp));
+        return tmp;
+      case Expr::I64Const:
+        int64_t i64;
+        if (!c.iter().readI64Const(&i64))
+            return false;
+        tmp = new(c.lifo) AstConst(Val((uint64_t)i64));
+        c.iter().setResult(AstDecodeStackItem(tmp));
+        return tmp;
+      case Expr::F32Const:
+        float f32;
+        if (!c.iter().readF32Const(&f32))
+            return false;
+        tmp = new(c.lifo) AstConst(Val(f32));
+        c.iter().setResult(AstDecodeStackItem(tmp));
+        return tmp;
+      case Expr::F64Const:
+        double f64;
+        if (!c.iter().readF64Const(&f64))
+            return false;
+        tmp = new(c.lifo) AstConst(Val(f64));
+        c.iter().setResult(AstDecodeStackItem(tmp));
+        return tmp;
+      case Expr::GetLocal:
+        return AstDecodeGetLocal(c);
+      case Expr::SetLocal:
+        return AstDecodeSetLocal(c);
+      case Expr::Select:
+        return AstDecodeSelect(c);
+      case Expr::Block:
+      case Expr::Loop:
+        return AstDecodeBlock(c, expr);
+      case Expr::If:
+        return AstDecodeIf(c);
+      case Expr::Else:
+        return AstDecodeElse(c);
+      case Expr::End:
+        return AstDecodeEnd(c);
+      case Expr::I32Clz:
+      case Expr::I32Ctz:
+      case Expr::I32Popcnt:
+        return AstDecodeUnary(c, ValType::I32, expr);
+      case Expr::I64Clz:
+      case Expr::I64Ctz:
+      case Expr::I64Popcnt:
+        return AstDecodeUnary(c, ValType::I64, expr);
+      case Expr::F32Abs:
+      case Expr::F32Neg:
+      case Expr::F32Ceil:
+      case Expr::F32Floor:
+      case Expr::F32Sqrt:
+      case Expr::F32Trunc:
+      case Expr::F32Nearest:
+        return AstDecodeUnary(c, ValType::F32, expr);
+      case Expr::F64Abs:
+      case Expr::F64Neg:
+      case Expr::F64Ceil:
+      case Expr::F64Floor:
+      case Expr::F64Sqrt:
+      case Expr::F64Trunc:
+      case Expr::F64Nearest:
+        return AstDecodeUnary(c, ValType::F64, expr);
+      case Expr::I32Add:
+      case Expr::I32Sub:
+      case Expr::I32Mul:
+      case Expr::I32DivS:
+      case Expr::I32DivU:
+      case Expr::I32RemS:
+      case Expr::I32RemU:
+      case Expr::I32And:
+      case Expr::I32Or:
+      case Expr::I32Xor:
+      case Expr::I32Shl:
+      case Expr::I32ShrS:
+      case Expr::I32ShrU:
+      case Expr::I32Rotl:
+      case Expr::I32Rotr:
+        return AstDecodeBinary(c, ValType::I32, expr);
+      case Expr::I64Add:
+      case Expr::I64Sub:
+      case Expr::I64Mul:
+      case Expr::I64DivS:
+      case Expr::I64DivU:
+      case Expr::I64RemS:
+      case Expr::I64RemU:
+      case Expr::I64And:
+      case Expr::I64Or:
+      case Expr::I64Xor:
+      case Expr::I64Shl:
+      case Expr::I64ShrS:
+      case Expr::I64ShrU:
+      case Expr::I64Rotl:
+      case Expr::I64Rotr:
+        return AstDecodeBinary(c, ValType::I64, expr);
+      case Expr::F32Add:
+      case Expr::F32Sub:
+      case Expr::F32Mul:
+      case Expr::F32Div:
+      case Expr::F32Min:
+      case Expr::F32Max:
+      case Expr::F32CopySign:
+        return AstDecodeBinary(c, ValType::F32, expr);
+      case Expr::F64Add:
+      case Expr::F64Sub:
+      case Expr::F64Mul:
+      case Expr::F64Div:
+      case Expr::F64Min:
+      case Expr::F64Max:
+      case Expr::F64CopySign:
+        return AstDecodeBinary(c, ValType::F64, expr);
+      case Expr::I32Eq:
+      case Expr::I32Ne:
+      case Expr::I32LtS:
+      case Expr::I32LtU:
+      case Expr::I32LeS:
+      case Expr::I32LeU:
+      case Expr::I32GtS:
+      case Expr::I32GtU:
+      case Expr::I32GeS:
+      case Expr::I32GeU:
+        return AstDecodeComparison(c, ValType::I32, expr);
+      case Expr::I64Eq:
+      case Expr::I64Ne:
+      case Expr::I64LtS:
+      case Expr::I64LtU:
+      case Expr::I64LeS:
+      case Expr::I64LeU:
+      case Expr::I64GtS:
+      case Expr::I64GtU:
+      case Expr::I64GeS:
+      case Expr::I64GeU:
+        return AstDecodeComparison(c, ValType::I64, expr);
+      case Expr::F32Eq:
+      case Expr::F32Ne:
+      case Expr::F32Lt:
+      case Expr::F32Le:
+      case Expr::F32Gt:
+      case Expr::F32Ge:
+        return AstDecodeComparison(c, ValType::F32, expr);
+      case Expr::F64Eq:
+      case Expr::F64Ne:
+      case Expr::F64Lt:
+      case Expr::F64Le:
+      case Expr::F64Gt:
+      case Expr::F64Ge:
+        return AstDecodeComparison(c, ValType::F64, expr);
+      case Expr::I32Eqz:
+        return AstDecodeConversion(c, ValType::I32, ValType::I32, expr);
+      case Expr::I64Eqz:
+        return AstDecodeConversion(c, ValType::I64, ValType::I32, expr);
+      case Expr::I32TruncSF32:
+      case Expr::I32TruncUF32:
+      case Expr::I32ReinterpretF32:
+        return AstDecodeConversion(c, ValType::F32, ValType::I32, expr);
+      case Expr::I32TruncSF64:
+      case Expr::I32TruncUF64:
+        return AstDecodeConversion(c, ValType::F64, ValType::I32, expr);
+      case Expr::I64ExtendSI32:
+      case Expr::I64ExtendUI32:
+        return AstDecodeConversion(c, ValType::I32, ValType::I64, expr);
+      case Expr::I64TruncSF32:
+      case Expr::I64TruncUF32:
+        return AstDecodeConversion(c, ValType::F32, ValType::I64, expr);
+      case Expr::I64TruncSF64:
+      case Expr::I64TruncUF64:
+      case Expr::I64ReinterpretF64:
+        return AstDecodeConversion(c, ValType::F64, ValType::I64, expr);
+      case Expr::F32ConvertSI32:
+      case Expr::F32ConvertUI32:
+      case Expr::F32ReinterpretI32:
+        return AstDecodeConversion(c, ValType::I32, ValType::F32, expr);
+      case Expr::F32ConvertSI64:
+      case Expr::F32ConvertUI64:
+        return AstDecodeConversion(c, ValType::I64, ValType::F32, expr);
+      case Expr::F32DemoteF64:
+        return AstDecodeConversion(c, ValType::F64, ValType::F32, expr);
+      case Expr::F64ConvertSI32:
+      case Expr::F64ConvertUI32:
+        return AstDecodeConversion(c, ValType::I32, ValType::F64, expr);
+      case Expr::F64ConvertSI64:
+      case Expr::F64ConvertUI64:
+      case Expr::F64ReinterpretI64:
+        return AstDecodeConversion(c, ValType::I64, ValType::F64, expr);
+      case Expr::F64PromoteF32:
+        return AstDecodeConversion(c, ValType::F32, ValType::F64, expr);
+      case Expr::I32Load8S:
+      case Expr::I32Load8U:
+        return AstDecodeLoad(c, ValType::I32, 1, expr);
+      case Expr::I32Load16S:
+      case Expr::I32Load16U:
+        return AstDecodeLoad(c, ValType::I32, 2, expr);
+      case Expr::I32Load:
+        return AstDecodeLoad(c, ValType::I32, 4, expr);
+      case Expr::I64Load8S:
+      case Expr::I64Load8U:
+        return AstDecodeLoad(c, ValType::I64, 1, expr);
+      case Expr::I64Load16S:
+      case Expr::I64Load16U:
+        return AstDecodeLoad(c, ValType::I64, 2, expr);
+      case Expr::I64Load32S:
+      case Expr::I64Load32U:
+        return AstDecodeLoad(c, ValType::I64, 4, expr);
+      case Expr::I64Load:
+        return AstDecodeLoad(c, ValType::I64, 8, expr);
+      case Expr::F32Load:
+        return AstDecodeLoad(c, ValType::F32, 4, expr);
+      case Expr::F64Load:
+        return AstDecodeLoad(c, ValType::F64, 8, expr);
+      case Expr::I32Store8:
+        return AstDecodeStore(c, ValType::I32, 1, expr);
+      case Expr::I32Store16:
+        return AstDecodeStore(c, ValType::I32, 2, expr);
+      case Expr::I32Store:
+        return AstDecodeStore(c, ValType::I32, 4, expr);
+      case Expr::I64Store8:
+        return AstDecodeStore(c, ValType::I64, 1, expr);
+      case Expr::I64Store16:
+        return AstDecodeStore(c, ValType::I64, 2, expr);
+      case Expr::I64Store32:
+        return AstDecodeStore(c, ValType::I64, 4, expr);
+      case Expr::I64Store:
+        return AstDecodeStore(c, ValType::I64, 8, expr);
+      case Expr::F32Store:
+        return AstDecodeStore(c, ValType::F32, 4, expr);
+      case Expr::F64Store:
+        return AstDecodeStore(c, ValType::F64, 8, expr);
+      case Expr::Br:
+      case Expr::BrIf:
+        return AstDecodeBranch(c, expr);
+      case Expr::BrTable:
+        return AstDecodeBrTable(c);
+      case Expr::Return:
+        return AstDecodeReturn(c);
+      case Expr::Unreachable:
+        if (!c.iter().readUnreachable())
+            return false;
+        tmp = new(c.lifo) AstUnreachable();
+        c.iter().setResult(AstDecodeStackItem(tmp));
+        return tmp;
+      default:
+        // Note: it's important not to remove this default since readExpr()
+        // can return Expr values for which there is no enumerator.
+        break;
+    }
+
+    return c.iter().unrecognizedOpcode(expr);
+}
+
+/*****************************************************************************/
+// wasm decoding and generation
+
+static bool
+AstDecodeTypeSection(AstDecodeContext& c)
+{
+    uint32_t sectionStart, sectionSize;
+    if (!c.d.startSection(TypeSectionId, &sectionStart, &sectionSize))
+        return AstDecodeFail(c, "failed to start section");
+    if (sectionStart == Decoder::NotStarted)
+        return true;
+
+    uint32_t numSigs;
+    if (!c.d.readVarU32(&numSigs))
+        return AstDecodeFail(c, "expected number of signatures");
+
+    if (numSigs > MaxSigs)
+        return AstDecodeFail(c, "too many signatures");
+
+    for (uint32_t sigIndex = 0; sigIndex < numSigs; sigIndex++) {
+        uint32_t form;
+        if (!c.d.readVarU32(&form) || form != uint32_t(TypeConstructor::Function))
+            return AstDecodeFail(c, "expected function form");
+
+        uint32_t numArgs;
+        if (!c.d.readVarU32(&numArgs))
+            return AstDecodeFail(c, "bad number of function args");
+
+        if (numArgs > MaxArgsPerFunc)
+            return AstDecodeFail(c, "too many arguments in signature");
+
+        AstValTypeVector args(c.lifo);
+        if (!args.resize(numArgs))
+            return false;
+
+        for (uint32_t i = 0; i < numArgs; i++) {
+            if (!c.d.readValType(&args[i]))
+                return AstDecodeFail(c, "bad value type");
+        }
+
+        uint32_t numRets;
+        if (!c.d.readVarU32(&numRets))
+            return AstDecodeFail(c, "bad number of function returns");
+
+        if (numRets > 1)
+            return AstDecodeFail(c, "too many returns in signature");
+
+        ExprType result = ExprType::Void;
+
+        if (numRets == 1) {
+            ValType type;
+            if (!c.d.readValType(&type))
+                return AstDecodeFail(c, "bad expression type");
+
+            result = ToExprType(type);
+        }
+
+        AstSig sigNoName(Move(args), result);
+        AstName sigName;
+        if (!AstDecodeGenerateName(c, AstName(MOZ_UTF16("$type$"), 6), sigIndex, sigName))
+            return false;
+
+        AstSig* sig = new(c.lifo) AstSig(sigName, Move(sigNoName));
+        if (!c.module().append(sig))
+            return false;
+    }
+
+    if (!c.d.finishSection(sectionStart, sectionSize))
+        return AstDecodeFail(c, "decls section byte size mismatch");
+
+    return true;
+}
+
+static bool
+AstDecodeSignatureIndex(AstDecodeContext& c, uint32_t* sigIndex)
+{
+    if (!c.d.readVarU32(sigIndex))
+        return AstDecodeFail(c, "expected signature index");
+
+    if (*sigIndex >= c.module().sigs().length())
+        return AstDecodeFail(c, "signature index out of range");
+
+    return true;
+}
+
+static bool
+AstDecodeFunctionSection(AstDecodeContext& c)
+{
+    uint32_t sectionStart, sectionSize;
+    if (!c.d.startSection(FunctionSectionId, &sectionStart, &sectionSize))
+        return AstDecodeFail(c, "failed to start section");
+    if (sectionStart == Decoder::NotStarted)
+        return true;
+
+    uint32_t numDecls;
+    if (!c.d.readVarU32(&numDecls))
+        return AstDecodeFail(c, "expected number of declarations");
+
+    if (numDecls > MaxFuncs)
+        return AstDecodeFail(c, "too many functions");
+
+
+    if (!c.funcSigs().resize(numDecls))
+        return false;
+
+    for (uint32_t i = 0; i < numDecls; i++) {
+        if (!AstDecodeSignatureIndex(c, &c.funcSigs()[i]))
+            return false;
+    }
+
+    if (!c.d.finishSection(sectionStart, sectionSize))
+        return AstDecodeFail(c, "decls section byte size mismatch");
+
+    return true;
+}
+
+static bool
+AstDecodeTableSection(AstDecodeContext& c)
+{
+    uint32_t sectionStart, sectionSize;
+    if (!c.d.startSection(TableSectionId, &sectionStart, &sectionSize))
+        return AstDecodeFail(c, "failed to start section");
+    if (sectionStart == Decoder::NotStarted)
+        return true;
+
+    if (!c.d.readVarU32(&c.numTableElems))
+        return AstDecodeFail(c, "expected number of table elems");
+
+    if (c.numTableElems > MaxTableElems)
+        return AstDecodeFail(c, "too many table elements");
+
+    AstTableElemVector elems(c.lifo);
+    if (!elems.resize(c.numTableElems))
+        return false;
+
+    for (uint32_t i = 0; i < c.numTableElems; i++) {
+        uint32_t funcIndex;
+        if (!c.d.readVarU32(&funcIndex))
+            return AstDecodeFail(c, "expected table element");
+
+        if (funcIndex >= c.funcSigs().length())
+            return AstDecodeFail(c, "table element out of range");
+
+        elems[i] = AstRef(AstName(), funcIndex);
+    }
+
+    c.module().initTable(new(c.lifo) AstTable(Move(elems)));
+
+    if (!c.d.finishSection(sectionStart, sectionSize))
+        return AstDecodeFail(c, "table section byte size mismatch");
+
+    return true;
+}
+
+static bool
+AstDecodeName(AstDecodeContext& c, AstName* name)
+{
+    Bytes bytes;
+    if (!c.d.readBytes(&bytes))
+        return false;
+    size_t length = bytes.length();
+    char16_t *buffer = static_cast<char16_t *>(c.lifo.alloc(length * sizeof(char16_t)));
+    for (size_t i = 0; i < length; i++)
+        buffer[i] = bytes[i];
+    *name = AstName(buffer, length);
+    return true;
+}
+
+static bool
+AstDecodeImport(AstDecodeContext& c, uint32_t importIndex, AstImport** import)
+{
+    uint32_t sigIndex = AstNoIndex;
+    if (!AstDecodeSignatureIndex(c, &sigIndex))
+        return false;
+
+    AstName moduleName;
+    if (!AstDecodeName(c, &moduleName))
+        return AstDecodeFail(c, "expected import module name");
+
+    if (moduleName.empty())
+        return AstDecodeFail(c, "module name cannot be empty");
+
+    AstName funcName;
+    if (!AstDecodeName(c, &funcName))
+        return AstDecodeFail(c, "expected import func name");
+
+    AstName importName;
+    if (!AstDecodeGenerateName(c, AstName(MOZ_UTF16("$import$"), 8), importIndex, importName))
+        return false;
+
+    *import = new(c.lifo) AstImport(importName, moduleName, funcName, sigIndex);
+    return *import;
+}
+
+static bool
+AstDecodeImportSection(AstDecodeContext& c)
+{
+    uint32_t sectionStart, sectionSize;
+    if (!c.d.startSection(ImportSectionId, &sectionStart, &sectionSize))
+        return AstDecodeFail(c, "failed to start section");
+    if (sectionStart == Decoder::NotStarted)
+        return true;
+
+    uint32_t numImports;
+    if (!c.d.readVarU32(&numImports))
+        return AstDecodeFail(c, "failed to read number of imports");
+
+    if (numImports > MaxImports)
+        return AstDecodeFail(c,  "too many imports");
+
+    for (uint32_t i = 0; i < numImports; i++) {
+        AstImport* import;
+        if (!AstDecodeImport(c, i, &import))
+            return false;
+        if (!c.module().append(import))
+            return false;
+    }
+
+    if (!c.d.finishSection(sectionStart, sectionSize))
+        return AstDecodeFail(c, "import section byte size mismatch");
+
+    return true;
+}
+
+static bool
+AstDecodeMemorySection(AstDecodeContext& c)
+{
+    uint32_t sectionStart, sectionSize;
+    if (!c.d.startSection(MemorySectionId, &sectionStart, &sectionSize))
+        return AstDecodeFail(c, "failed to start section");
+    if (sectionStart == Decoder::NotStarted)
+        return true;
+
+    uint32_t initialSizePages;
+    if (!c.d.readVarU32(&initialSizePages))
+        return AstDecodeFail(c, "expected initial memory size");
+
+    CheckedInt<int32_t> initialSize = initialSizePages;
+    initialSize *= PageSize;
+    if (!initialSize.isValid())
+        return AstDecodeFail(c, "initial memory size too big");
+
+    uint32_t maxSizePages;
+    if (!c.d.readVarU32(&maxSizePages))
+        return AstDecodeFail(c, "expected initial memory size");
+
+    CheckedInt<int32_t> maxSize = maxSizePages;
+    maxSize *= PageSize;
+    if (!maxSize.isValid())
+        return AstDecodeFail(c, "initial memory size too big");
+
+    uint8_t exported;
+    if (!c.d.readFixedU8(&exported))
+        return AstDecodeFail(c, "expected exported byte");
+
+    c.initialSizePages.emplace(initialSizePages);
+    if (initialSizePages != maxSizePages) {
+      c.maxSizePages.emplace(maxSizePages);
+    }
+
+    if (exported) {
+        if (!c.module().append(new(c.lifo) AstExport(AstName(MOZ_UTF16("memory"), 6))))
+            return false;
+    }
+
+    if (!c.d.finishSection(sectionStart, sectionSize))
+        return AstDecodeFail(c, "memory section byte size mismatch");
+
+    return true;
+}
+
+static bool
+AstDecodeFunctionExport(AstDecodeContext& c, AstExport** export_)
+{
+    uint32_t funcIndex;
+    if (!c.d.readVarU32(&funcIndex))
+        return AstDecodeFail(c, "expected export internal index");
+
+    if (funcIndex >= c.funcSigs().length())
+        return AstDecodeFail(c, "export function index out of range");
+
+    AstName fieldName;
+    if (!AstDecodeName(c, &fieldName))
+        return AstDecodeFail(c, "expected export name");
+
+    *export_ = new(c.lifo) AstExport(fieldName, AstRef(AstName(), funcIndex));
+    return *export_;
+}
+
+static bool
+AstDecodeExportSection(AstDecodeContext& c)
+{
+    uint32_t sectionStart, sectionSize;
+    if (!c.d.startSection(ExportSectionId, &sectionStart, &sectionSize))
+        return AstDecodeFail(c, "failed to start section");
+    if (sectionStart == Decoder::NotStarted)
+        return true;
+
+    uint32_t numExports;
+    if (!c.d.readVarU32(&numExports))
+        return AstDecodeFail(c, "failed to read number of exports");
+
+    if (numExports > MaxExports)
+        return AstDecodeFail(c, "too many exports");
+
+    for (uint32_t i = 0; i < numExports; i++) {
+        AstExport* export_;
+        if (!AstDecodeFunctionExport(c, &export_))
+            return false;
+        if (!c.module().append(export_))
+            return false;
+    }
+
+    if (!c.d.finishSection(sectionStart, sectionSize))
+        return AstDecodeFail(c, "export section byte size mismatch");
+
+    return true;
+}
+
+static bool
+AstDecodeFunctionBody(AstDecodeContext &c, uint32_t funcIndex, AstFunc** func)
+{
+    uint32_t bodySize;
+    if (!c.d.readVarU32(&bodySize))
+        return AstDecodeFail(c, "expected number of function body bytes");
+
+    if (c.d.bytesRemain() < bodySize)
+        return AstDecodeFail(c, "function body length too big");
+
+    const uint8_t* bodyBegin = c.d.currentPosition();
+    const uint8_t* bodyEnd = bodyBegin + bodySize;
+
+    AstDecodeExprIter iter(AstDecodePolicy(), c.d);
+
+    uint32_t sigIndex = c.funcSigs()[funcIndex];
+    const AstSig* sig = c.module().sigs()[sigIndex];
+
+    AstValTypeVector vars(c.lifo);
+    AstNameVector localsNames(c.lifo);
+    AstExprVector body(c.lifo);
+
+    ValTypeVector locals;
+    if (!locals.appendAll(sig->args()))
+        return false;
+
+    if (!DecodeLocalEntries(c.d, &locals))
+        return AstDecodeFail(c, "failed decoding local entries");
+
+    c.startFunction(&iter, &locals);
+
+    uint32_t numParams = sig->args().length();
+    uint32_t numLocals = locals.length();
+    for (uint32_t i = numParams; i < numLocals; i++) {
+        if (!vars.append(locals[i]))
+            return false;
+    }
+    for (uint32_t i = 0; i < numLocals; i++) {
+        AstName varName;
+        if (!AstDecodeGenerateName(c, AstName(MOZ_UTF16("$var$"), 5), i, varName))
+            return false;
+        if (!localsNames.append(varName))
+            return false;
+    }
+
+    if (!c.iter().readFunctionStart())
+        return false;
+
+    while (c.d.currentPosition() < bodyEnd) {
+        if (!AstDecodeExpr(c))
+            return false;
+        AstDecodeStackItem item = c.iter().getResult();
+        body.shrinkBy(item.stackDelta);
+        if (!body.append(item.expr))
+            return false;
+    }
+
+    AstDecodeStackItem tmp;
+    if (!c.iter().readFunctionEnd(sig->ret(), &tmp))
+        return false;
+
+    c.endFunction();
+
+    if (c.d.currentPosition() != bodyEnd)
+        return AstDecodeFail(c, "function body length mismatch");
+
+    AstName funcName;
+    if (!AstDecodeGenerateName(c, AstName(MOZ_UTF16("$func$"), 6), funcIndex, funcName))
+        return false;
+    AstRef sigRef;
+    if (!AstDecodeGenerateRef(c, AstName(MOZ_UTF16("$type$"), 6), sigIndex, sigRef))
+        return false;
+    *func = new(c.lifo) AstFunc(funcName, sigRef,
+                                    Move(vars), Move(localsNames), Move(body));
+    return *func;
+}
+
+static bool
+AstDecodeCodeSection(AstDecodeContext &c)
+{
+    uint32_t sectionStart, sectionSize;
+    if (!c.d.startSection(CodeSectionId, &sectionStart, &sectionSize))
+        return AstDecodeFail(c, "failed to start section");
+
+    if (sectionStart == Decoder::NotStarted) {
+        if (c.funcSigs().length() != 0)
+            return AstDecodeFail(c, "expected function bodies");
+
+        return false;
+    }
+
+    uint32_t numFuncBodies;
+    if (!c.d.readVarU32(&numFuncBodies))
+        return AstDecodeFail(c, "expected function body count");
+
+    if (numFuncBodies != c.funcSigs().length())
+        return AstDecodeFail(c, "function body count does not match function signature count");
+
+    for (uint32_t funcIndex = 0; funcIndex < numFuncBodies; funcIndex++) {
+        AstFunc* func;
+        if (!AstDecodeFunctionBody(c, funcIndex, &func))
+            return false;
+        if (!c.module().append(func))
+            return false;
+    }
+
+    if (!c.d.finishSection(sectionStart, sectionSize))
+        return AstDecodeFail(c, "function section byte size mismatch");
+
+    return true;
+}
+
+static bool
+AstDecodeDataSection(AstDecodeContext &c)
+{
+    uint32_t sectionStart, sectionSize;
+    if (!c.d.startSection(DataSectionId, &sectionStart, &sectionSize))
+        return AstDecodeFail(c, "failed to start section");
+    AstSegmentVector segments(c.lifo);
+    if (sectionStart == Decoder::NotStarted) {
+        if (!c.initialSizePages)
+            return true;
+        c.module().setMemory(new(c.lifo) AstMemory(*c.initialSizePages, c.maxSizePages, Move(segments)));
+
+        return true;
+    }
+
+    uint32_t numSegments;
+    if (!c.d.readVarU32(&numSegments))
+        return AstDecodeFail(c, "failed to read number of data segments");
+
+    uint32_t initialSizePages = c.initialSizePages ? *c.initialSizePages : 0;
+    uint32_t heapLength = initialSizePages * PageSize;
+    uint32_t prevEnd = 0;
+
+    for (uint32_t i = 0; i < numSegments; i++) {
+        uint32_t dstOffset;
+        if (!c.d.readVarU32(&dstOffset))
+            return AstDecodeFail(c, "expected segment destination offset");
+
+        if (dstOffset < prevEnd)
+            return AstDecodeFail(c, "data segments must be disjoint and ordered");
+
+        uint32_t numBytes;
+        if (!c.d.readVarU32(&numBytes))
+            return AstDecodeFail(c, "expected segment size");
+
+        if (dstOffset > heapLength || heapLength - dstOffset < numBytes)
+            return AstDecodeFail(c, "data segment does not fit in memory");
+
+        const uint8_t* src;
+        if (!c.d.readBytesRaw(numBytes, &src))
+            return AstDecodeFail(c, "data segment shorter than declared");
+
+        char16_t *buffer = static_cast<char16_t *>(c.lifo.alloc(numBytes * sizeof(char16_t)));
+        for (size_t i = 0; i < numBytes; i++)
+            buffer[i] = src[i];
+        AstName name(buffer, numBytes);
+        if (!segments.append(new(c.lifo) AstSegment(dstOffset, name)))
+            return false;
+        prevEnd = dstOffset + numBytes;
+    }
+
+    c.module().setMemory(new(c.lifo) AstMemory(initialSizePages, c.maxSizePages, Move(segments)));
+
+    if (!c.d.finishSection(sectionStart, sectionSize))
+        return AstDecodeFail(c, "data section byte size mismatch");
+
+    return true;
+}
+
+
+bool
+wasm::BinaryToAst(JSContext* cx, const uint8_t* bytes, uint32_t length,
+                  LifoAlloc& lifo, AstModule** module)
+{
+    AstModule* result = new(lifo) AstModule(lifo);
+    if (!result->init())
+        return false;
+
+    Decoder d(bytes, bytes + length);
+    AstDecodeContext c(cx, lifo, d, *result, true);
+
+    uint32_t u32;
+    if (!d.readFixedU32(&u32) || u32 != MagicNumber)
+        return AstDecodeFail(c, "failed to match magic number");
+
+    if (!d.readFixedU32(&u32) || u32 != EncodingVersion)
+        return AstDecodeFail(c, "failed to match binary version");
+
+    if (!AstDecodeTypeSection(c))
+        return false;
+
+    if (!AstDecodeImportSection(c))
+        return false;
+
+    if (!AstDecodeFunctionSection(c))
+        return false;
+
+    if (!AstDecodeTableSection(c))
+        return false;
+
+    if (!AstDecodeMemorySection(c))
+        return false;
+
+    if (!AstDecodeExportSection(c))
+        return false;
+
+    if (!AstDecodeCodeSection(c))
+        return false;
+
+    if (!AstDecodeDataSection(c))
+        return false;
+
+    while (!d.done()) {
+        if (!d.skipSection())
+            return AstDecodeFail(c, "failed to skip unknown section at end");
+    }
+
+    *module = result;
+    return true;
+}
+

new file mode 100644
--- /dev/null
+++ b/js/src/asmjs/WasmBinaryToAST.h
@@ -0,0 +1,36 @@
+/* -*- 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.
+ */
+
+#ifndef wasmbinarytoast_h
+#define wasmbinarytoast_h
+
+#include "asmjs/WasmAST.h"
+#include "asmjs/WasmTypes.h"
+
+#include "ds/LifoAlloc.h"
+
+namespace js {
+namespace wasm {
+
+bool
+BinaryToAst(JSContext* cx, const uint8_t* bytes, uint32_t length, LifoAlloc& lifo, AstModule** module);
+
+} // end wasm namespace
+} // end js namespace
+
+#endif // namespace wasmbinarytoast_h

--- a/js/src/asmjs/WasmBinaryToText.cpp
+++ b/js/src/asmjs/WasmBinaryToText.cpp
@@ -19,61 +19,53 @@
 #include "asmjs/WasmBinaryToText.h"
 
 #include "mozilla/CheckedInt.h"
 
 #include "jsnum.h"
 #include "jsprf.h"
 
 #include "asmjs/Wasm.h"
+#include "asmjs/WasmAST.h"
+#include "asmjs/WasmBinaryToAST.h"
 #include "asmjs/WasmTypes.h"
 #include "vm/ArrayBufferObject.h"
 #include "vm/StringBuffer.h"
 
 using namespace js;
 using namespace js::wasm;
 
 using mozilla::CheckedInt;
 using mozilla::IsInfinite;
 using mozilla::IsNaN;
 using mozilla::IsNegativeZero;
 
 struct WasmRenderContext
 {
     JSContext* cx;
-    Decoder& d;
+    AstModule* module;
     StringBuffer& buffer;
     uint32_t indent;
 
     DeclaredSigVector signatures;
     Uint32Vector funcSigs;
     Uint32Vector funcLocals;
     Uint32Vector importSigs;
 
     uint32_t currentFuncIndex;
 
-    WasmRenderContext(JSContext* cx, Decoder& d, StringBuffer& buffer)
-      : cx(cx), d(d), buffer(buffer), indent(0), currentFuncIndex(0)
+    WasmRenderContext(JSContext* cx, AstModule* module, StringBuffer& buffer)
+      : cx(cx), module(module), buffer(buffer), indent(0), currentFuncIndex(0)
     {}
 };
 
 /*****************************************************************************/
 // utilities
 
 static bool
-RenderFail(WasmRenderContext& c, const char* str)
-{
-    uint32_t offset = c.d.currentOffset();
-    char offsetStr[sizeof "4294967295"];
-    JS_snprintf(offsetStr, sizeof offsetStr, "%" PRIu32, offset);
-    JS_ReportErrorNumber(c.cx, GetErrorMessage, nullptr, JSMSG_WASM_DECODE_FAIL, offsetStr, str);
-    return false;
-}
-
-static bool
 RenderIndent(WasmRenderContext& c)
 {
     for (uint32_t i = 0; i < c.indent; i++) {
         if (!c.buffer.append("  "))
             return false;
     }
     return true;
 }
@@ -123,20 +115,22 @@ RenderDouble(WasmRenderContext& c, doubl
         if (num > 0)
             return c.buffer.append("infinity");
         return c.buffer.append("-infinity");
     }
     return NumberValueToStringBuffer(c.cx, DoubleValue(num), c.buffer);
 }
 
 static bool
-RenderString(WasmRenderContext& c, const uint8_t* s, size_t length)
+RenderEscapedString(WasmRenderContext& c, const AstName& s)
 {
+    size_t length = s.length();
+    const char16_t* p = s.begin();
     for (size_t i = 0; i < length; i++) {
-        uint8_t byte = s[i];
+        char16_t byte = p[i];
         bool success;
         switch (byte) {
             case '\n': success = c.buffer.append("\\n"); break;
             case '\r': success = c.buffer.append("\\0d"); break;
             case '\t': success = c.buffer.append("\\t"); break;
             case '\f': success = c.buffer.append("\\0c"); break;
             case '\b': success = c.buffer.append("\\08"); break;
             case '\\': success = c.buffer.append("\\\\"); break;
@@ -174,321 +168,211 @@ RenderExprType(WasmRenderContext& c, Exp
 
 static bool
 RenderValType(WasmRenderContext& c, ValType type)
 {
     return RenderExprType(c, ToExprType(type));
 }
 
 static bool
-RenderExpr(WasmRenderContext& c);
+RenderName(WasmRenderContext& c, const AstName& name)
+{
+    return c.buffer.append(name.begin(), name.end());
+}
 
 static bool
-RenderFullLine(WasmRenderContext& c)
+RenderRef(WasmRenderContext& c, const AstRef& ref) {
+    return ref.name().empty() ? RenderInt32(c, ref.index()) : RenderName(c, ref.name());
+}
+
+static bool
+RenderExpr(WasmRenderContext& c, AstExpr& expr);
+
+static bool
+RenderFullLine(WasmRenderContext& c, AstExpr& expr)
 {
     if (!RenderIndent(c))
         return false;
-    if (!RenderExpr(c))
+    if (!RenderExpr(c, expr))
         return false;
     return c.buffer.append('\n');
 }
 
 /*****************************************************************************/
 // binary format parsing and rendering
 
 static bool
-RenderNop(WasmRenderContext& c)
+RenderNop(WasmRenderContext& c, AstNop& nop)
 {
     return c.buffer.append("(nop)");
 }
 
 static bool
-RenderUnreachable(WasmRenderContext& c)
+RenderUnreachable(WasmRenderContext& c, AstUnreachable& unreachable)
 {
     return c.buffer.append("(trap)");
 }
 
 static bool
-RenderCallWithSig(WasmRenderContext& c, uint32_t sigIndex)
+RenderCallArgs(WasmRenderContext& c, const AstExprVector& args)
 {
-    const DeclaredSig& sig = c.signatures[sigIndex];
-    for (uint32_t i = 0; i < sig.args().length(); i++) {
+    for (uint32_t i = 0; i < args.length(); i++) {
         if (!c.buffer.append(" "))
             return false;
-        if (!RenderExpr(c))
+        if (!RenderExpr(c, *args[i]))
             return false;
     }
 
     return true;
 }
 
 static bool
-RenderCall(WasmRenderContext& c)
+RenderCall(WasmRenderContext& c, AstCall& call)
 {
-    uint32_t funcIndex;
-    if (!c.d.readVarU32(&funcIndex))
-        return RenderFail(c, "unable to read import index");
-
-    if (!c.buffer.append("(call $func$"))
+    if (call.expr() == Expr::Call) {
+        if (!c.buffer.append("(call "))
+            return false;
+    } else if (call.expr() == Expr::CallImport) {
+        if (!c.buffer.append("(call_import "))
+            return false;
+    } else
         return false;
-    if (!RenderInt32(c, funcIndex))
+    if (!RenderRef(c, call.func()))
         return false;
-
-    if (funcIndex >= c.funcSigs.length())
-        return RenderFail(c, "callee index out of range");
-
-    uint32_t sigIndex = c.funcSigs[funcIndex];
-    if (!RenderCallWithSig(c, sigIndex))
+    if (!RenderCallArgs(c, call.args()))
         return false;
     if (!c.buffer.append(")"))
         return false;
     return true;
 }
 
 static bool
-RenderCallImport(WasmRenderContext& c)
+RenderCallIndirect(WasmRenderContext& c, AstCallIndirect& call)
 {
-    uint32_t importIndex;
-    if (!c.d.readVarU32(&importIndex))
-        return RenderFail(c, "unable to read import index");
-
-    if (!c.buffer.append("(call_import $import$"))
-        return false;
-    if (!RenderInt32(c, importIndex))
-        return false;
-
-    if (importIndex >= c.importSigs.length())
-        return RenderFail(c, "import index out of range");
-
-    uint32_t sigIndex = c.importSigs[importIndex];
-    if (!RenderCallWithSig(c, sigIndex))
+    if (!c.buffer.append("(call_indirect "))
         return false;
-    if (!c.buffer.append(")"))
-        return false;
-
-    return true;
-}
-
-static bool
-RenderCallIndirect(WasmRenderContext& c)
-{
-    uint32_t sigIndex;
-    if (!c.d.readVarU32(&sigIndex))
-        return RenderFail(c, "unable to read indirect call signature index");
-
-    if (!c.buffer.append("(call_indirect $type$"))
-        return false;
-    if (!RenderInt32(c, sigIndex))
+    if (!RenderRef(c, call.sig()))
         return false;
 
     if (!c.buffer.append(" "))
         return false;
 
-    if (!RenderExpr(c))
+    if (!RenderExpr(c, *call.index()))
         return false;
 
     if (!c.buffer.append(" "))
         return false;
-
-    if (!RenderCallWithSig(c, sigIndex))
+    if (!RenderCallArgs(c, call.args()))
         return false;
-    if (!c.buffer.append(")"))
-        return false;
-
     return true;
 }
 
 static bool
-RenderConstI32(WasmRenderContext& c)
+RenderConst(WasmRenderContext& c, AstConst& cst)
 {
-    if (!c.buffer.append("(i32.const "))
+    if (!c.buffer.append('('))
+        return false;
+    if (!RenderValType(c, cst.val().type()))
+        return false;
+    if (!c.buffer.append(".const "))
         return false;
 
-    int32_t i32;
-    if (!c.d.readVarS32(&i32))
-        return RenderFail(c, "unable to read i32.const immediate");
+    switch (ToExprType(cst.val().type()))
+    {
+      case ExprType::I32:
+        if (!RenderInt32(c, (uint32_t)cst.val().i32()))
+            return false;
+        break;
+      case ExprType::I64:
+        if (!RenderInt64(c, (uint32_t)cst.val().i64()))
+            return false;
+        break;
+      case ExprType::F32:
+        if (!RenderDouble(c, (double)cst.val().f32()))
+            return false;
+        break;
+      case ExprType::F64:
+        if (!RenderDouble(c, cst.val().f64()))
+            return false;
+        break;
+      default:
+        return false;
+    }
+    if (!c.buffer.append(")"))
+        return false;
+    return true;
+}
 
-    if (!RenderInt32(c, (uint32_t)i32))
+static bool
+RenderGetLocal(WasmRenderContext& c, AstGetLocal& gl)
+{
+    if (!c.buffer.append("(get_local "))
+        return false;
+    if (!RenderRef(c, gl.local()))
+        return false;
+    if (!c.buffer.append(")"))
+        return false;
+    return true;
+}
+
+static bool
+RenderSetLocal(WasmRenderContext& c, AstSetLocal& sl)
+{
+    if (!c.buffer.append("(set_local "))
+        return false;
+    if (!RenderRef(c, sl.local()))
+        return false;
+    if (!c.buffer.append(" "))
+        return false;
+
+    if (!RenderExpr(c, sl.value()))
         return false;
 
     if (!c.buffer.append(")"))
         return false;
     return true;
 }
 
 static bool
-RenderConstI64(WasmRenderContext& c)
-{
-    if (!c.buffer.append("(i64.const "))
-        return false;
-
-    int64_t i64;
-    if (!c.d.readVarS64(&i64))
-        return RenderFail(c, "unable to read i64.const immediate");
-
-    if (!RenderInt64(c, i64))
-        return false;
-
-    if (!c.buffer.append(")"))
-        return false;
-    return true;
-}
-
-static bool
-RenderConstF32(WasmRenderContext& c)
-{
-    if (!c.buffer.append("(f32.const "))
-        return false;
-
-    float value;
-    if (!c.d.readFixedF32(&value))
-        return RenderFail(c, "unable to read f32.const immediate");
-
-    if (IsNaN(value)) {
-        const float jsNaN = (float)JS::GenericNaN();
-        if (memcmp(&value, &jsNaN, sizeof(value)) != 0)
-            return RenderFail(c, "NYI: NaN literals with custom payloads");
-    }
-
-    if (!RenderDouble(c, (double)value))
-        return false;
-
-    if (!c.buffer.append(")"))
-        return false;
-    return true;
-}
-
-static bool
-RenderConstF64(WasmRenderContext& c)
+RenderBlock(WasmRenderContext& c, AstBlock& block)
 {
-    if (!c.buffer.append("(f64.const "))
-        return false;
-
-    double value;
-    if (!c.d.readFixedF64(&value))
-        return RenderFail(c, "unable to read f64.const immediate");
-
-    if (IsNaN(value)) {
-        const double jsNaN = JS::GenericNaN();
-        if (memcmp(&value, &jsNaN, sizeof(value)) != 0)
-            return RenderFail(c, "NYI: NaN literals with custom payloads");
-    }
-
-    if (!RenderDouble(c, value))
-        return false;
-
-    if (!c.buffer.append(")"))
-        return false;
-    return true;
-}
-
-static bool
-RenderGetLocal(WasmRenderContext& c)
-{
-    uint32_t localIndex;
-    if (!c.d.readVarU32(&localIndex))
-        return RenderFail(c, "unable to read get_local index");
-
-    if (localIndex >= c.funcLocals[c.currentFuncIndex])
-        return RenderFail(c, "get_local index out of range");
-
-    if (!c.buffer.append("(get_local $var$"))
-        return false;
-    if (!RenderInt32(c, localIndex))
-        return false;
-    if (!c.buffer.append(")"))
-        return false;
-    return true;
-}
-
-static bool
-RenderSetLocal(WasmRenderContext& c)
-{
-    uint32_t localIndex;
-    if (!c.d.readVarU32(&localIndex))
-        return RenderFail(c, "unable to read set_local index");
-
-    if (localIndex >= c.funcLocals[c.currentFuncIndex])
-        return RenderFail(c, "set_local index out of range");
-
-    if (!c.buffer.append("(set_local $var$"))
-        return false;
-    if (!RenderInt32(c, localIndex))
-        return false;
-    if (!c.buffer.append(" "))
-        return false;
-
-    if (!RenderExpr(c))
-        return false;
-
-    if (!c.buffer.append(")"))
-        return false;
-    return true;
-}
-
-static bool
-RenderBlock(WasmRenderContext& c)
-{
-    if (!c.buffer.append("(block"))
+    if (block.expr() == Expr::Block) {
+        if (!c.buffer.append("(block "))
+            return false;
+    } else if (block.expr() == Expr::Loop) {
+        if (!c.buffer.append("(loop "))
+            return false;
+    } else
         return false;
 
     c.indent++;
 
-    uint32_t numExprs;
-    if (!c.d.readVarU32(&numExprs))
-        return RenderFail(c, "unable to read block's number of expressions");
-
+    uint32_t numExprs = block.exprs().length();
     for (uint32_t i = 0; i < numExprs; i++) {
         if (!c.buffer.append(" "))
             return false;
-        if (!RenderExpr(c))
+        if (!RenderExpr(c, *(block.exprs()[i])))
             return false;
     }
 
     c.indent--;
     if (!c.buffer.append(")"))
         return false;
 
     return true;
 }
 
 static bool
-RenderLoop(WasmRenderContext& c)
-{
-    if (!c.buffer.append("(loop"))
-        return false;
-
-    c.indent++;
-
-    uint32_t numExprs;
-    if (!c.d.readVarU32(&numExprs))
-        return RenderFail(c, "unable to read block's number of expressions");
-
-    for (uint32_t i = 0; i < numExprs; i++) {
-        if (!c.buffer.append(" "))
-            return false;
-        if (!RenderExpr(c))
-            return false;
-    }
-
-    c.indent--;
-    if (!c.buffer.append(")"))
-        return false;
-
-    return true;
-}
-
-static bool
-RenderUnaryOperator(WasmRenderContext& c, Expr expr, ValType argType)
+RenderUnaryOperator(WasmRenderContext& c, AstUnaryOperator& op)
 {
     if (!c.buffer.append("("))
       return false;
 
     bool success = false;
-    switch (expr) {
+    switch (op.expr()) {
       case Expr::I32Eqz:     success = c.buffer.append("i32.eqz"); break;
       case Expr::I32Clz:     success = c.buffer.append("i32.clz"); break;
       case Expr::I32Ctz:     success = c.buffer.append("i32.ctz"); break;
       case Expr::I32Popcnt:  success = c.buffer.append("i32.popcnt"); break;
       case Expr::I64Clz:     success = c.buffer.append("i64.clz"); break;
       case Expr::I64Ctz:     success = c.buffer.append("i64.ctz"); break;
       case Expr::I64Popcnt:  success = c.buffer.append("i64.popcnt"); break;
       case Expr::F32Abs:     success = c.buffer.append("f32.abs"); break;
@@ -506,32 +390,32 @@ RenderUnaryOperator(WasmRenderContext& c
       default: return false;
     }
     if (!success)
         return false;
 
     if (!c.buffer.append(" "))
         return false;
 
-    if (!RenderExpr(c))
+    if (!RenderExpr(c, *op.op()))
         return false;
 
     if (!c.buffer.append(")"))
         return false;
     return true;
 }
 
 static bool
-RenderBinaryOperator(WasmRenderContext& c, Expr expr, ValType argType)
+RenderBinaryOperator(WasmRenderContext& c, AstBinaryOperator& op)
 {
     if (!c.buffer.append("("))
       return false;
 
     bool success = false;
-    switch (expr) {
+    switch (op.expr()) {
       case Expr::I32Add:      success = c.buffer.append("i32.add"); break;
       case Expr::I32Sub:      success = c.buffer.append("i32.sub"); break;
       case Expr::I32Mul:      success = c.buffer.append("i32.mul"); break;
       case Expr::I32DivS:     success = c.buffer.append("i32.div_s"); break;
       case Expr::I32DivU:     success = c.buffer.append("i32.div_u"); break;
       case Expr::I32RemS:     success = c.buffer.append("i32.rem_s"); break;
       case Expr::I32RemU:     success = c.buffer.append("i32.rem_u"); break;
       case Expr::I32And:      success = c.buffer.append("i32.and"); break;
@@ -567,35 +451,65 @@ RenderBinaryOperator(WasmRenderContext& 
       case Expr::F64Min:      success = c.buffer.append("f64.min"); break;
       case Expr::F64Max:      success = c.buffer.append("f64.max"); break;
       default: return false;
     }
     if (!success)
         return false;
     if (!c.buffer.append(" "))
         return false;
-    if (!RenderExpr(c))
+    if (!RenderExpr(c, *op.lhs()))
         return false;
     if (!c.buffer.append(" "))
         return false;
-    if (!RenderExpr(c))
+    if (!RenderExpr(c, *op.rhs()))
         return false;
     if (!c.buffer.append(")"))
         return false;
     return true;
 }
 
 static bool
-RenderComparisonOperator(WasmRenderContext& c, Expr expr, ValType argType)
+RenderTernaryOperator(WasmRenderContext& c, AstTernaryOperator& op)
+{
+    if (!c.buffer.append("("))
+        return false;
+
+    bool success = false;
+    switch (op.expr()) {
+      case Expr::Select: success = c.buffer.append("select"); break;
+      default: return false;
+    }
+    if (!success)
+        return false;
+    if (!c.buffer.append(" "))
+        return false;
+    if (!RenderExpr(c, *op.op0()))
+        return false;
+    if (!c.buffer.append(" "))
+        return false;
+    if (!RenderExpr(c, *op.op1()))
+        return false;
+    if (!c.buffer.append(" "))
+        return false;
+    if (!RenderExpr(c, *op.op2()))
+        return false;
+    if (!c.buffer.append(")"))
+        return false;
+    return true;
+}
+
+static bool
+RenderComparisonOperator(WasmRenderContext& c, AstComparisonOperator& op)
 {
     if (!c.buffer.append("("))
       return false;
 
     bool success = false;
-    switch (expr) {
+    switch (op.expr()) {
       case Expr::I32Eq:  success = c.buffer.append("i32.eq"); break;
       case Expr::I32Ne:  success = c.buffer.append("i32.ne"); break;
       case Expr::I32LtS: success = c.buffer.append("i32.lt_s"); break;
       case Expr::I32LtU: success = c.buffer.append("i32.lt_u"); break;
       case Expr::I32LeS: success = c.buffer.append("i32.le_s"); break;
       case Expr::I32LeU: success = c.buffer.append("i32.le_u"); break;
       case Expr::I32GtS: success = c.buffer.append("i32.gt_s"); break;
       case Expr::I32GtU: success = c.buffer.append("i32.gt_u"); break;
@@ -625,35 +539,35 @@ RenderComparisonOperator(WasmRenderConte
       case Expr::F64Ge:  success = c.buffer.append("f64.ge"); break;
       default: return false;
     }
     if (!success)
         return false;
 
     if (!c.buffer.append(" "))
         return false;
-    if (!RenderExpr(c))
+    if (!RenderExpr(c, *op.lhs()))
         return false;
     if (!c.buffer.append(" "))
         return false;
-    if (!RenderExpr(c))
+    if (!RenderExpr(c, *op.rhs()))
         return false;
     if (!c.buffer.append(")"))
         return false;
     return true;
 }
 
 static bool
-RenderConversionOperator(WasmRenderContext& c, Expr expr, ValType to, ValType argType)
+RenderConversionOperator(WasmRenderContext& c, AstConversionOperator& op)
 {
     if (!c.buffer.append("("))
       return false;
 
     bool success = false;
-    switch (expr) {
+    switch (op.expr()) {
       case Expr::I32WrapI64:        success = c.buffer.append("i32.wrap/i64"); break;
       case Expr::I32TruncSF32:      success = c.buffer.append("i32.trunc_s/f32"); break;
       case Expr::I32TruncUF32:      success = c.buffer.append("i32.trunc_u/f32"); break;
       case Expr::I32ReinterpretF32: success = c.buffer.append("i32.reinterpret/f32"); break;
       case Expr::I32TruncSF64:      success = c.buffer.append("i32.trunc_s/f64"); break;
       case Expr::I32TruncUF64:      success = c.buffer.append("i32.trunc_u/f64"); break;
       case Expr::I64ExtendSI32:     success = c.buffer.append("i64.extend_s/i32"); break;
       case Expr::I64ExtendUI32:     success = c.buffer.append("i64.extend_u/i32"); break;
@@ -677,575 +591,409 @@ RenderConversionOperator(WasmRenderConte
       default: return false;
     }
     if (!success)
         return false;
 
     if (!c.buffer.append(" "))
         return false;
 
-    if (!RenderExpr(c))
+    if (!RenderExpr(c, *op.op()))
         return false;
 
     if (!c.buffer.append(")"))
         return false;
     return true;
 }
 
 static bool
-RenderIfElse(WasmRenderContext& c, bool hasElse)
+RenderIfElse(WasmRenderContext& c, AstIf& if_)
 {
     if (!c.buffer.append("(if "))
         return false;
-    if (!RenderExpr(c))
+    if (!RenderExpr(c, if_.cond()))
         return false;
 
     if (!c.buffer.append(" "))
         return false;
 
     c.indent++;
-    if (!RenderExpr(c))
+    if (!RenderExpr(c, if_.thenBranch()))
         return false;
     c.indent--;
 
-    if (hasElse) {
+    if (if_.hasElse()) {
         if (!c.buffer.append(" "))
             return false;
 
         c.indent++;
-        if (!RenderExpr(c))
+        if (!RenderExpr(c, if_.elseBranch()))
             return false;
         c.indent--;
     }
 
     if (!c.buffer.append(")"))
         return false;
 
     return true;
 }
 
 static bool
-RenderLoadStoreAddress(WasmRenderContext& c)
+RenderLoadStoreAddress(WasmRenderContext& c, const AstLoadStoreAddress& lsa, uint32_t defaultAlignLog2)
 {
-    uint32_t flags;
-    if (!c.d.readVarU32(&flags))
-        return RenderFail(c, "expected memory access flags");
-
-    uint32_t offset;
-    if (!c.d.readVarU32(&offset))
-        return RenderFail(c, "expected memory access offset");
-
-    if (offset != 0) {
+    if (lsa.offset() != 0) {
       if (!c.buffer.append(" offset="))
           return false;
-      if (!RenderInt32(c, offset))
+      if (!RenderInt32(c, lsa.offset()))
           return false;
     }
 
-    uint32_t alignLog2 = flags;
-    if (!c.buffer.append(" align="))
-        return false;
-    if (!RenderInt32(c, 1 << alignLog2))
-        return false;
+    uint32_t alignLog2 = lsa.flags();
+    if (defaultAlignLog2 != alignLog2) {
+      if (!c.buffer.append(" align="))
+          return false;
+      if (!RenderInt32(c, 1 << alignLog2))
+          return false;
+    }
 
     if (!c.buffer.append(" "))
         return false;
 
-    if (!RenderExpr(c))
+    if (!RenderExpr(c, lsa.base()))
         return false;
 
     return true;
 }
 
 static bool
-RenderLoad(WasmRenderContext& c, Expr expr, ValType loadType)
+RenderLoad(WasmRenderContext& c, AstLoad& load)
 {
-    if (!c.buffer.append("("))
-        return false;
-    if (!RenderValType(c, loadType))
-        return false;
-    if (!c.buffer.append(".load"))
-        return false;
-    switch (expr) {
+    uint32_t defaultAlignLog2;
+    switch (load.expr()) {
       case Expr::I32Load8S:
+        if (!c.buffer.append("(i32.load8_s"))
+            return false;
+        defaultAlignLog2 = 0;
+        break;
       case Expr::I64Load8S:
-        if (!c.buffer.append("8_s"))
+        if (!c.buffer.append("(i64.load8_s"))
             return false;
+        defaultAlignLog2 = 0;
         break;
       case Expr::I32Load8U:
+        if (!c.buffer.append("(i32.load8_u"))
+            return false;
+        defaultAlignLog2 = 0;
+        break;
       case Expr::I64Load8U:
-        if (!c.buffer.append("8_u"))
+        if (!c.buffer.append("(i64.load8_u"))
             return false;
+        defaultAlignLog2 = 0;
         break;
       case Expr::I32Load16S:
+        if (!c.buffer.append("(i32.load16_s"))
+            return false;
+        defaultAlignLog2 = 1;
+        break;
       case Expr::I64Load16S:
-        if (!c.buffer.append("16_s"))
+        if (!c.buffer.append("(i64.load16_s"))
             return false;
+        defaultAlignLog2 = 1;
         break;
       case Expr::I32Load16U:
+        if (!c.buffer.append("(i32.load16_u"))
+            return false;
+        defaultAlignLog2 = 1;
+        break;
       case Expr::I64Load16U:
-        if (!c.buffer.append("16_u"))
+        if (!c.buffer.append("(i64.load16_u"))
             return false;
+        defaultAlignLog2 = 1;
         break;
       case Expr::I64Load32S:
-        if (!c.buffer.append("32_s"))
+        if (!c.buffer.append("(i64.load32_s"))
             return false;
+        defaultAlignLog2 = 2;
         break;
       case Expr::I64Load32U:
-        if (!c.buffer.append("32_u"))
+        if (!c.buffer.append("(i64.load32_u"))
             return false;
+        defaultAlignLog2 = 2;
+        break;
+      case Expr::I32Load:
+        if (!c.buffer.append("(i32.load"))
+            return false;
+        defaultAlignLog2 = 2;
         break;
-      default: /* rest of them have not prefix */
+      case Expr::I64Load:
+        if (!c.buffer.append("(i64.load"))
+            return false;
+        defaultAlignLog2 = 3;
         break;
+      case Expr::F32Load:
+        if (!c.buffer.append("(f32.load"))
+            return false;
+        defaultAlignLog2 = 2;
+        break;
+      case Expr::F64Load:
+        if (!c.buffer.append("(f64.load"))
+            return false;
+        defaultAlignLog2 = 3;
+        break;
+      default:
+        return false;
     }
 
-    if (!RenderLoadStoreAddress(c))
+
+    if (!RenderLoadStoreAddress(c, load.address(), defaultAlignLog2))
         return false;
 
     if (!c.buffer.append(")"))
         return false;
     return true;
 }
 
 static bool
-RenderStore(WasmRenderContext& c, Expr expr, ValType storeType)
+RenderStore(WasmRenderContext& c, AstStore& store)
 {
-    if (!c.buffer.append("("))
-        return false;
-    if (!RenderValType(c, storeType))
-        return false;
-    if (!c.buffer.append(".store"))
-        return false;
-    switch (expr) {
+    uint32_t defaultAlignLog2;
+    switch (store.expr()) {
       case Expr::I32Store8:
+        if (!c.buffer.append("(i32.store8"))
+            return false;
+        defaultAlignLog2 = 0;
+        break;
       case Expr::I64Store8:
-        if (!c.buffer.append("8"))
+        if (!c.buffer.append("(i64.store8"))
             return false;
+        defaultAlignLog2 = 0;
         break;
       case Expr::I32Store16:
+        if (!c.buffer.append("(i32.store16"))
+            return false;
+        defaultAlignLog2 = 1;
+        break;
       case Expr::I64Store16:
-        if (!c.buffer.append("16"))
+        if (!c.buffer.append("(i64.store16"))
             return false;
+        defaultAlignLog2 = 1;
         break;
       case Expr::I64Store32:
-        if (!c.buffer.append("32"))
+        if (!c.buffer.append("(i64.store32"))
             return false;
+        defaultAlignLog2 = 2;
+        break;
+      case Expr::I32Store:
+        if (!c.buffer.append("(i32.store"))
+            return false;
+        defaultAlignLog2 = 2;
         break;
-      default: /* rest of them have not prefix */
+      case Expr::I64Store:
+        if (!c.buffer.append("(i64.store"))
+            return false;
+        defaultAlignLog2 = 3;
         break;
+      case Expr::F32Store:
+        if (!c.buffer.append("(f32.store"))
+            return false;
+        defaultAlignLog2 = 2;
+        break;
+      case Expr::F64Store:
+        if (!c.buffer.append("(f64.store"))
+            return false;
+        defaultAlignLog2 = 3;
+        break;
+      default:
+        return false;
     }
 
-    if (!RenderLoadStoreAddress(c))
+    if (!RenderLoadStoreAddress(c, store.address(), defaultAlignLog2))
         return false;
 
     if (!c.buffer.append(" "))
         return false;
 
-    if (!RenderExpr(c))
+    if (!RenderExpr(c, store.value()))
         return false;
 
     if (!c.buffer.append(")"))
         return false;
 
     return true;
 }
 
 static bool
-RenderBranch(WasmRenderContext& c, Expr expr)
+RenderBranch(WasmRenderContext& c, AstBranch& branch)
 {
+    Expr expr = branch.expr();
     MOZ_ASSERT(expr == Expr::BrIf || expr == Expr::Br);
 
-    uint32_t relativeDepth;
-    if (!c.d.readVarU32(&relativeDepth))
-        return RenderFail(c, "expected relative depth");
-
     if (expr == Expr::BrIf ? !c.buffer.append("(br_if ") : !c.buffer.append("(br "))
         return false;
 
-    if (!RenderInt32(c, relativeDepth))
-        return false;
-
-    if (!c.buffer.append(" "))
-        return false;
-
-    if (!RenderExpr(c))
+    if (!RenderRef(c, branch.target()))
         return false;
 
     if (expr == Expr::BrIf) {
         if (!c.buffer.append(" "))
             return false;
-        if (!RenderExpr(c))
-            return false;
-    }
 
-    if (!c.buffer.append(")"))
-        return false;
-    return true;
-}
-
-static bool
-RenderBrTable(WasmRenderContext& c)
-{
-    uint32_t tableLength;
-    if (!c.d.readVarU32(&tableLength))
-        return false;
-
-    if (!c.buffer.append("(br_table "))
-        return false;
-
-    for (uint32_t i = 0; i < tableLength; i++) {
-        uint32_t depth;
-        if (!c.d.readFixedU32(&depth))
-            return RenderFail(c, "missing br_table entry");
-
-        if (!RenderInt32(c, depth))
-            return false;
-
-        if (!c.buffer.append(" "))
+        if (!RenderExpr(c, branch.cond()))
             return false;
     }
 
-    uint32_t defaultDepth;
-    if (!c.d.readFixedU32(&defaultDepth))
-        return RenderFail(c, "expected default relative depth");
-
-    if (!RenderInt32(c, defaultDepth))
-        return false;
-
-    if (!c.buffer.append(" "))
-        return false;
-
-    // Value
-    if (!RenderExpr(c))
-        return false;
-
-    if (!c.buffer.append(" "))
-        return false;
-
-    // Index
-    if (!RenderExpr(c))
-        return false;
-
-    if (!c.buffer.append(")"))
-        return false;
-
-    return true;
-}
-
-static bool
-RenderReturn(WasmRenderContext& c)
-{
-    if (!c.buffer.append("(return"))
-        return false;
-
-    if (c.signatures[c.funcSigs[c.currentFuncIndex]].ret() != ExprType::Void) {
+    if (branch.maybeValue()) {
         if (!c.buffer.append(" "))
             return false;
-        if (!RenderExpr(c))
+        if (!RenderExpr(c, *(branch.maybeValue())))
             return false;
     }
 
     if (!c.buffer.append(")"))
         return false;
     return true;
 }
 
 static bool
-RenderSelect(WasmRenderContext& c)
+RenderBrTable(WasmRenderContext& c, AstBranchTable& table)
 {
-    if (!c.buffer.append("(select "))
+    if (!c.buffer.append("(br_table "))
         return false;
 
-    if (!RenderExpr(c))
-        return false;
+    uint32_t tableLength = table.table().length();
+    for (uint32_t i = 0; i < tableLength; i++) {
+        if (!RenderRef(c, table.table()[i]))
+            return false;
 
-    if (!c.buffer.append(" "))
-        return false;
+        if (!c.buffer.append(" "))
+            return false;
+    }
 
-    if (!RenderExpr(c))
+    if (!RenderRef(c, table.def()))
         return false;
 
     if (!c.buffer.append(" "))
         return false;
 
-    if (!RenderExpr(c))
+    if (table.maybeValue()) {
+      if (!RenderExpr(c, *(table.maybeValue())))
+          return false;
+
+      if (!c.buffer.append(" "))
+          return false;
+    }
+
+    // Index
+    if (!RenderExpr(c, table.index()))
+        return false;
+
+    if (!c.buffer.append(")"))
         return false;
 
-    return c.buffer.append(")");
+    return true;
+}
+
+static bool
+RenderReturn(WasmRenderContext& c, AstReturn& ret)
+{
+    if (!c.buffer.append("(return"))
+        return false;
+
+    if (ret.maybeExpr()) {
+        if (!c.buffer.append(" "))
+            return false;
+        if (!RenderExpr(c, *(ret.maybeExpr())))
+            return false;
+    }
+
+    if (!c.buffer.append(")"))
+        return false;
+    return true;
 }
 
 static bool
-RenderExpr(WasmRenderContext& c)
+RenderExpr(WasmRenderContext& c, AstExpr& expr)
 {
-    Expr expr;
-    if (!c.d.readExpr(&expr))
-        return RenderFail(c, "unable to read expression");
-
-    switch (expr) {
-      case Expr::Nop:
-        return RenderNop(c);
-      case Expr::Unreachable:
-        return RenderUnreachable(c);
-      case Expr::Call:
-        return RenderCall(c);
-      case Expr::CallImport:
-        return RenderCallImport(c);
-      case Expr::CallIndirect:
-        return RenderCallIndirect(c);
-      case Expr::I32Const:
-        return RenderConstI32(c);
-      case Expr::I64Const:
-        return RenderConstI64(c);
-      case Expr::F32Const:
-        return RenderConstF32(c);
-      case Expr::F64Const:
-        return RenderConstF64(c);
-      case Expr::GetLocal:
-        return RenderGetLocal(c);
-      case Expr::SetLocal:
-        return RenderSetLocal(c);
-      case Expr::Block:
-        return RenderBlock(c);
-      case Expr::Loop:
-        return RenderLoop(c);
-      case Expr::If:
-        return RenderIfElse(c, false);
-      case Expr::Else:
-        return RenderIfElse(c, true);
-      case Expr::I32Clz:
-      case Expr::I32Ctz:
-      case Expr::I32Popcnt:
-      case Expr::I32Eqz:
-        return RenderUnaryOperator(c, expr, ValType::I32);
-      case Expr::I64Clz:
-      case Expr::I64Ctz:
-      case Expr::I64Popcnt:
-        return RenderFail(c, "NYI: i64") &&
-               RenderUnaryOperator(c, expr, ValType::I64);
-      case Expr::F32Abs:
-      case Expr::F32Neg:
-      case Expr::F32Ceil:
-      case Expr::F32Floor:
-      case Expr::F32Sqrt:
-        return RenderUnaryOperator(c, expr, ValType::F32);
-      case Expr::F32Trunc:
-        return RenderFail(c, "NYI: trunc");
-      case Expr::F32Nearest:
-        return RenderFail(c, "NYI: nearest");
-      case Expr::F64Abs:
-      case Expr::F64Neg:
-      case Expr::F64Ceil:
-      case Expr::F64Floor:
-      case Expr::F64Sqrt:
-        return RenderUnaryOperator(c, expr, ValType::F64);
-      case Expr::F64Trunc:
-        return RenderFail(c, "NYI: trunc");
-      case Expr::F64Nearest:
-        return RenderFail(c, "NYI: nearest");
-      case Expr::I32Add:
-      case Expr::I32Sub:
-      case Expr::I32Mul:
-      case Expr::I32DivS:
-      case Expr::I32DivU:
-      case Expr::I32RemS:
-      case Expr::I32RemU:
-      case Expr::I32And:
-      case Expr::I32Or:
-      case Expr::I32Xor:
-      case Expr::I32Shl:
-      case Expr::I32ShrS:
-      case Expr::I32ShrU:
-        return RenderBinaryOperator(c, expr, ValType::I32);
-      case Expr::I64Add:
-      case Expr::I64Sub:
-      case Expr::I64Mul:
-      case Expr::I64DivS:
-      case Expr::I64DivU:
-      case Expr::I64RemS:
-      case Expr::I64RemU:
-      case Expr::I64And:
-      case Expr::I64Or:
-      case Expr::I64Xor:
-      case Expr::I64Shl:
-      case Expr::I64ShrS:
-      case Expr::I64ShrU:
-        return RenderBinaryOperator(c, expr, ValType::I64);
-      case Expr::F32Add:
-      case Expr::F32Sub:
-      case Expr::F32Mul:
-      case Expr::F32Div:
-      case Expr::F32Min:
-      case Expr::F32Max:
-        return RenderBinaryOperator(c, expr, ValType::F32);
-      case Expr::F32CopySign:
-        return RenderFail(c, "NYI: copysign");
-      case Expr::F64Add:
-      case Expr::F64Sub:
-      case Expr::F64Mul:
-      case Expr::F64Div:
-      case Expr::F64Min:
-      case Expr::F64Max:
-        return RenderBinaryOperator(c, expr, ValType::F64);
-      case Expr::F64CopySign:
-        return RenderFail(c, "NYI: copysign");
-      case Expr::I32Eq:
-      case Expr::I32Ne:
-      case Expr::I32LtS:
-      case Expr::I32LtU:
-      case Expr::I32LeS:
-      case Expr::I32LeU:
-      case Expr::I32GtS:
-      case Expr::I32GtU:
-      case Expr::I32GeS:
-      case Expr::I32GeU:
-        return RenderComparisonOperator(c, expr, ValType::I32);
-      case Expr::I64Eq:
-      case Expr::I64Ne:
-      case Expr::I64LtS:
-      case Expr::I64LtU:
-      case Expr::I64LeS:
-      case Expr::I64LeU:
-      case Expr::I64GtS:
-      case Expr::I64GtU:
-      case Expr::I64GeS:
-      case Expr::I64GeU:
-        return RenderComparisonOperator(c, expr, ValType::I64);
-      case Expr::F32Eq:
-      case Expr::F32Ne:
-      case Expr::F32Lt:
-      case Expr::F32Le:
-      case Expr::F32Gt:
-      case Expr::F32Ge:
-        return RenderComparisonOperator(c, expr, ValType::F32);
-      case Expr::F64Eq:
-      case Expr::F64Ne:
-      case Expr::F64Lt:
-      case Expr::F64Le:
-      case Expr::F64Gt:
-      case Expr::F64Ge:
-        return RenderComparisonOperator(c, expr, ValType::F64);
-      case Expr::I32WrapI64:
-        return RenderConversionOperator(c, expr, ValType::I32, ValType::I64);
-      case Expr::I32TruncSF32:
-      case Expr::I32TruncUF32:
-      case Expr::I32ReinterpretF32:
-        return RenderConversionOperator(c, expr, ValType::I32, ValType::F32);
-      case Expr::I32TruncSF64:
-      case Expr::I32TruncUF64:
-        return RenderConversionOperator(c, expr, ValType::I32, ValType::F64);
-      case Expr::I64ExtendSI32:
-      case Expr::I64ExtendUI32:
-        return RenderConversionOperator(c, expr, ValType::I64, ValType::I32);
-      case Expr::I64TruncSF32:
-      case Expr::I64TruncUF32:
-        return RenderConversionOperator(c, expr, ValType::I64, ValType::F32);
-      case Expr::I64TruncSF64:
-      case Expr::I64TruncUF64:
-      case Expr::I64ReinterpretF64:
-        return RenderConversionOperator(c, expr, ValType::I64, ValType::F64);
-      case Expr::F32ConvertSI32:
-      case Expr::F32ConvertUI32:
-      case Expr::F32ReinterpretI32:
-        return RenderConversionOperator(c, expr, ValType::F32, ValType::I32);
-      case Expr::F32ConvertSI64:
-      case Expr::F32ConvertUI64:
-        return RenderConversionOperator(c, expr, ValType::F32, ValType::I64);
-      case Expr::F32DemoteF64:
-        return RenderConversionOperator(c, expr, ValType::F32, ValType::I64);
-      case Expr::F64ConvertSI32:
-      case Expr::F64ConvertUI32:
-        return RenderConversionOperator(c, expr, ValType::F64, ValType::I32);
-      case Expr::F64ConvertSI64:
-      case Expr::F64ConvertUI64:
-      case Expr::F64ReinterpretI64:
-        return RenderConversionOperator(c, expr, ValType::F64, ValType::I64);
-      case Expr::F64PromoteF32:
-        return RenderConversionOperator(c, expr, ValType::F64, ValType::F32);
-      case Expr::I32Load8S:
-      case Expr::I32Load8U:
-      case Expr::I32Load16S:
-      case Expr::I32Load16U:
-      case Expr::I32Load:
-        return RenderLoad(c, expr, ValType::I32);
-      case Expr::I64Load:
-      case Expr::I64Load8S:
-      case Expr::I64Load8U:
-      case Expr::I64Load16S:
-      case Expr::I64Load16U:
-      case Expr::I64Load32S:
-      case Expr::I64Load32U:
-        return RenderFail(c, "NYI: i64") &&
-               RenderLoad(c, expr, ValType::I64);
-      case Expr::F32Load:
-        return RenderLoad(c, expr, ValType::F32);
-      case Expr::F64Load:
-        return RenderLoad(c, expr, ValType::F64);
-      case Expr::I32Store8:
-        return RenderStore(c, expr, ValType::I32);
-      case Expr::I32Store16:
-        return RenderStore(c, expr, ValType::I32);
-      case Expr::I32Store:
-        return RenderStore(c, expr, ValType::I32);
-      case Expr::I64Store:
-      case Expr::I64Store8:
-      case Expr::I64Store16:
-      case Expr::I64Store32:
-        return RenderFail(c, "NYI: i64") &&
-               RenderStore(c, expr, ValType::I64);
-      case Expr::F32Store:
-        return RenderStore(c, expr, ValType::F32);
-      case Expr::F64Store:
-        return RenderStore(c, expr, ValType::F64);
-      case Expr::Br:
-        return RenderBranch(c, expr);
-      case Expr::BrIf:
-        return RenderBranch(c, expr);
-      case Expr::BrTable:
-        return RenderBrTable(c);
-      case Expr::Return:
-        return RenderReturn(c);
-      case Expr::Select:
-        return RenderSelect(c);
+    switch (expr.kind()) {
+      case AstExprKind::Nop:
+        return RenderNop(c, expr.as<AstNop>());
+      case AstExprKind::Unreachable:
+        return RenderUnreachable(c, expr.as<AstUnreachable>());
+      case AstExprKind::Call:
+        return RenderCall(c, expr.as<AstCall>());
+      case AstExprKind::CallIndirect:
+        return RenderCallIndirect(c, expr.as<AstCallIndirect>());
+      case AstExprKind::Const:
+        return RenderConst(c, expr.as<AstConst>());
+      case AstExprKind::GetLocal:
+        return RenderGetLocal(c, expr.as<AstGetLocal>());
+      case AstExprKind::SetLocal:
+        return RenderSetLocal(c, expr.as<AstSetLocal>());
+      case AstExprKind::Block:
+        return RenderBlock(c, expr.as<AstBlock>());
+      case AstExprKind::If:
+        return RenderIfElse(c, expr.as<AstIf>());
+      case AstExprKind::UnaryOperator:
+        return RenderUnaryOperator(c, expr.as<AstUnaryOperator>());
+      case AstExprKind::BinaryOperator:
+        return RenderBinaryOperator(c, expr.as<AstBinaryOperator>());
+      case AstExprKind::TernaryOperator:
+        return RenderTernaryOperator(c, expr.as<AstTernaryOperator>());
+      case AstExprKind::ComparisonOperator:
+        return RenderComparisonOperator(c, expr.as<AstComparisonOperator>());
+      case AstExprKind::ConversionOperator:
+        return RenderConversionOperator(c, expr.as<AstConversionOperator>());
+      case AstExprKind::Load:
+        return RenderLoad(c, expr.as<AstLoad>());
+      case AstExprKind::Store:
+        return RenderStore(c, expr.as<AstStore>());
+      case AstExprKind::Branch:
+        return RenderBranch(c, expr.as<AstBranch>());
+      case AstExprKind::BranchTable:
+        return RenderBrTable(c, expr.as<AstBranchTable>());
+      case AstExprKind::Return:
+        return RenderReturn(c, expr.as<AstReturn>());
       default:
         // Note: it's important not to remove this default since readExpr()
         // can return Expr values for which there is no enumerator.
         break;
     }
 
-    return RenderFail(c, "bad expression code");
+    return false;
 }
 
 static bool
-RenderSignature(WasmRenderContext& c, const DeclaredSig& sig, bool varAssignment)
+RenderSignature(WasmRenderContext& c, const AstSig& sig, const AstNameVector* maybeLocals = nullptr)
 {
     uint32_t paramsNum = sig.args().length();
 
-    if (varAssignment) {
+    if (maybeLocals) {
       for (uint32_t i = 0; i < paramsNum; i++) {
           if (!c.buffer.append(" (param "))
               return false;
-          if (!c.buffer.append("$var$"))
-              return false;
-          if (!RenderInt32(c, i))
-              return false;
-          if (!c.buffer.append(" "))
-              return false;
-          ValType arg = sig.arg(i);
+          const AstName& name = (*maybeLocals)[i];
+          if (!name.empty()) {
+              if (!RenderName(c, name))
+                  return false;
+              if (!c.buffer.append(" "))
+                  return false;
+          }
+          ValType arg = sig.args()[i];
           if (!RenderValType(c, arg))
               return false;
           if (!c.buffer.append(")"))
               return false;
       }
     } else if (paramsNum > 0) {
       if (!c.buffer.append(" (param"))
           return false;
       for (uint32_t i = 0; i < paramsNum; i++) {
           if (!c.buffer.append(" "))
               return false;
-          ValType arg = sig.arg(i);
+          ValType arg = sig.args()[i];
           if (!RenderValType(c, arg))
               return false;
       }
       if (!c.buffer.append(")"))
           return false;
     }
     if (sig.ret() != ExprType::Void) {
         if (!c.buffer.append(" (result "))
@@ -1254,579 +1002,351 @@ RenderSignature(WasmRenderContext& c, co
             return false;
         if (!c.buffer.append(")"))
             return false;
     }
     return true;
 }
 
 static bool
-RenderTypeSection(WasmRenderContext& c)
+RenderTypeSection(WasmRenderContext& c, const AstModule::SigVector& sigs)
 {
-    uint32_t sectionStart, sectionSize;
-    if (!c.d.startSection(TypeSectionId, &sectionStart, &sectionSize))
-        return RenderFail(c, "failed to start section");
-    if (sectionStart == Decoder::NotStarted)
+    uint32_t numSigs = sigs.length();
+    if (!numSigs)
         return true;
 
-    uint32_t numSigs;
-    if (!c.d.readVarU32(&numSigs))
-        return RenderFail(c, "expected number of signatures");
-
-    if (!c.signatures.resize(numSigs))
-        return false;
-
     for (uint32_t sigIndex = 0; sigIndex < numSigs; sigIndex++) {
-        uint32_t form;
-        if (!c.d.readVarU32(&form) || form != uint32_t(TypeConstructor::Function))
-            return RenderFail(c, "expected function form");
-
-        uint32_t numArgs;
-        if (!c.d.readVarU32(&numArgs))
-            return RenderFail(c, "bad number of signature args");
-
-        ValTypeVector args;
-        if (!args.resize(numArgs))
-            return false;
-
-        for (uint32_t i = 0; i < numArgs; i++) {
-            ValType arg;
-            if (!c.d.readValType(&arg))
-                return RenderFail(c, "bad value type");
-            args[i] = arg;
-        }
-
-        uint32_t numRets;
-        if (!c.d.readVarU32(&numRets))
-            return RenderFail(c, "bad number of function returns");
-
-        if (numRets > 1)
-            return RenderFail(c, "too many returns in signature");
-
-        ExprType result = ExprType::Void;
-
-        if (numRets == 1) {
-            ValType type;
-            if (!c.d.readValType(&type))
-                return RenderFail(c, "bad expression type");
-
-            result = ToExprType(type);
-        }
-
-        c.signatures[sigIndex] = Sig(Move(args), result);
-
+        const AstSig* sig = sigs[sigIndex];
         if (!RenderIndent(c))
             return false;
-        if (!c.buffer.append("(type $type$"))
+        if (!c.buffer.append("(type"))
             return false;
-        if (!RenderInt32(c, sigIndex))
-            return false;
+        if (!sig->name().empty()) {
+          if (!c.buffer.append(" "))
+              return false;
+          if (!RenderName(c, sig->name()))
+              return false;
+        }
         if (!c.buffer.append(" (func"))
             return false;
-        if (!RenderSignature(c, c.signatures[sigIndex], false))
+        if (!RenderSignature(c, *sig))
             return false;
         if (!c.buffer.append("))\n"))
             return false;
     }
+    return true;
+}
 
-    if (!c.d.finishSection(sectionStart, sectionSize))
-        return RenderFail(c, "decls section byte size mismatch");
+static bool
+RenderTableSection(WasmRenderContext& c, AstTable* maybeTable, const AstModule::FuncVector& funcs)
+{
+    if (!maybeTable)
+        return true;
+
+    uint32_t numTableElems = maybeTable->elems().length();
+
+    if (!c.buffer.append("(table "))
+        return false;
+
+    for (uint32_t i = 0; i < numTableElems; i++) {
+        AstRef& elem = maybeTable->elems()[i];
+        AstFunc* func = funcs[elem.index()];
+        if (func->name().empty()) {
+            if (!RenderInt32(c, elem.index()))
+                return false;
+        } else {
+          if (!RenderName(c, func->name()))
+              return false;
+        }
+    }
+
+    if (!c.buffer.append(")"))
+        return false;
 
     return true;
 }
 
 static bool
-RenderFunctionSection(WasmRenderContext& c)
-{
-    uint32_t sectionStart, sectionSize;
-    if (!c.d.startSection(FunctionSectionId, &sectionStart, &sectionSize))
-        return RenderFail(c, "failed to start section");
-    if (sectionStart == Decoder::NotStarted)
-        return true;
-
-    uint32_t numDecls;
-    if (!c.d.readVarU32(&numDecls))
-        return RenderFail(c, "expected number of declarations");
-
-    if (!c.funcSigs.resize(numDecls))
-        return false;
-
-    for (uint32_t i = 0; i < numDecls; i++) {
-        uint32_t sigIndex;
-        if (!c.d.readVarU32(&sigIndex))
-            return RenderFail(c, "expected signature index");
-        c.funcSigs[i] = sigIndex;
-    }
-
-    if (!c.d.finishSection(sectionStart, sectionSize))
-        return RenderFail(c, "decls section byte size mismatch");
-
-    return true;
-}
-
-static bool
-RenderTableSection(WasmRenderContext& c)
+RenderImport(WasmRenderContext& c, AstImport& import, const AstModule::SigVector& sigs)
 {
-    uint32_t sectionStart, sectionSize;
-    if (!c.d.startSection(TableSectionId, &sectionStart, &sectionSize))
-        return RenderFail(c, "failed to start section");
-    if (sectionStart == Decoder::NotStarted)
-        return true;
-
-    uint32_t numTableElems;
-    if (!c.d.readVarU32(&numTableElems))
-        return RenderFail(c, "expected number of table elems");
-
-    if (!c.buffer.append("(table "))
-        return false;
-
-    for (uint32_t i = 0; i < numTableElems; i++) {
-        uint32_t funcIndex;
-        if (!c.d.readVarU32(&funcIndex))
-            return RenderFail(c, "expected table element");
-        if (!RenderInt32(c, funcIndex))
-            return false;
-        if (!c.buffer.append(" "))
-            return false;
-    }
-
-    if (!c.buffer.append(")"))
-        return false;
-
-    if (!c.d.finishSection(sectionStart, sectionSize))
-        return RenderFail(c, "table section byte size mismatch");
-
-    return true;
-}
-
-static bool
-RenderImport(WasmRenderContext& c, uint32_t importIndex)
-{
-    uint32_t sigIndex;
-    if (!c.d.readVarU32(&sigIndex))
-        return RenderFail(c, "expected signature index");
-
-    c.importSigs[importIndex] = sigIndex;
-
+    const AstSig* sig = sigs[import.sigIndex()];
     if (!RenderIndent(c))
         return false;
-    if (!c.buffer.append("(import $import$"))
+    if (!c.buffer.append("(import "))
         return false;
-    if (!RenderInt32(c, importIndex))
+    if (!RenderName(c, import.name()))
         return false;
     if (!c.buffer.append(" \""))
         return false;
 
-    Bytes moduleName;
-    if (!c.d.readBytes(&moduleName))
-        return RenderFail(c, "expected import module name");
-
-    if (moduleName.empty())
-        return RenderFail(c, "module name cannot be empty");
-
-    if (!RenderString(c, moduleName.begin(), moduleName.length()))
+    const AstName& moduleName = import.module();
+    if (!RenderEscapedString(c, moduleName))
         return false;
 
     if (!c.buffer.append("\" \""))
         return false;
 
-    Bytes funcName;
-    if (!c.d.readBytes(&funcName))
-        return RenderFail(c, "expected import func name");
-
-    if (!RenderString(c, funcName.begin(), funcName.length()))
+    const AstName& funcName = import.func();
+    if (!RenderEscapedString(c, funcName))
         return false;
 
     if (!c.buffer.append("\""))
         return false;
 
-    if (!RenderSignature(c, c.signatures[sigIndex], false))
+    if (!RenderSignature(c, *sig))
         return false;
     if (!c.buffer.append(")\n"))
         return false;
 
     return true;
 }
 
 
 static bool
-RenderImportSection(WasmRenderContext& c)
+RenderImportSection(WasmRenderContext& c, const AstModule::ImportVector& imports, const AstModule::SigVector& sigs)
 {
-    uint32_t sectionStart, sectionSize;
-    if (!c.d.startSection(ImportSectionId, &sectionStart, &sectionSize))
-        return RenderFail(c, "failed to start section");
-    if (sectionStart == Decoder::NotStarted)
-        return true;
-
-    uint32_t numImports;
-    if (!c.d.readVarU32(&numImports))
-        return RenderFail(c, "failed to read number of imports");
-
-    if (!c.importSigs.resize(numImports))
-        return false;
+    uint32_t numImports = imports.length();
 
     for (uint32_t i = 0; i < numImports; i++) {
-        if (!RenderImport(c, i))
+        if (!RenderImport(c, *imports[i], sigs))
             return false;
     }
 
-    if (!c.d.finishSection(sectionStart, sectionSize))
-        return RenderFail(c, "import section byte size mismatch");
-
     return true;
 }
 
 static bool
-RenderMemorySection(WasmRenderContext& c, uint32_t* memInitial, uint32_t* memMax)
+RenderExport(WasmRenderContext& c, AstExport& export_, const AstModule::FuncVector& funcs)
 {
-    *memInitial = 0;
-    *memMax = 0;
-
-    uint32_t sectionStart, sectionSize;
-    if (!c.d.startSection(MemorySectionId, &sectionStart, &sectionSize))
-        return RenderFail(c, "failed to start section");
-    if (sectionStart == Decoder::NotStarted)
-        return true;
-
-    uint32_t initialSizePages;
-    if (!c.d.readVarU32(&initialSizePages))
-        return RenderFail(c, "expected initial memory size");
-    *memInitial = initialSizePages;
-
-    uint32_t maxSizePages;
-    if (!c.d.readVarU32(&maxSizePages))
-        return RenderFail(c, "expected initial memory size");
-    *memMax = maxSizePages;
-
-    uint8_t exported;
-    if (!c.d.readFixedU8(&exported))
-        return RenderFail(c, "expected exported byte");
-
-    if (!c.d.finishSection(sectionStart, sectionSize))
-        return RenderFail(c, "memory section byte size mismatch");
-
-    if (exported && !c.buffer.append("(export \"memory\" memory)"))
-        return false;
-
-    return true;
-}
-
-static bool
-RenderExportName(WasmRenderContext& c)
-{
-    Bytes fieldBytes;
-    if (!c.d.readBytes(&fieldBytes)) {
-        RenderFail(c, "expected export name");
-        return false;
-    }
-
-    if (!RenderString(c, fieldBytes.begin(), fieldBytes.length()))
-        return false;
-
-    return true;
-}
-
-static bool
-RenderFunctionExport(WasmRenderContext& c)
-{
-    uint32_t funcIndex;
-    if (!c.d.readVarU32(&funcIndex))
-        return RenderFail(c, "expected export internal index");
-
-    if (funcIndex >= c.funcSigs.length())
-        return RenderFail(c, "export function index out of range");
-
     if (!RenderIndent(c))
         return false;
     if (!c.buffer.append("(export \""))
         return false;
-    if (!RenderExportName(c))
+    if (!RenderEscapedString(c, export_.name()))
         return false;
     if (!c.buffer.append("\" "))
         return false;
-    if (!c.buffer.append("$func$"))
-        return false;
-    if (!RenderInt32(c, funcIndex))
-        return false;
+    if (export_.kind() == AstExportKind::Memory) {
+        if (!c.buffer.append("memory"))
+          return false;
+    } else {
+        const AstFunc* func = funcs[export_.func().index()];
+        if (func->name().empty()) {
+            if (!RenderInt32(c, export_.func().index()))
+                return false;
+        } else {
+            if (!RenderName(c, func->name()))
+                return false;
+        }
+    }
     if (!c.buffer.append(")\n"))
         return false;
 
     return true;
 }
 
 static bool
-RenderExportSection(WasmRenderContext& c)
+RenderExportSection(WasmRenderContext& c, const AstModule::ExportVector& exports, const AstModule::FuncVector& funcs)
 {
-    uint32_t sectionStart, sectionSize;
-    if (!c.d.startSection(ExportSectionId, &sectionStart, &sectionSize))
-        return RenderFail(c, "failed to start section");
-    if (sectionStart == Decoder::NotStarted)
-        return true;
-
-    uint32_t numExports;
-    if (!c.d.readVarU32(&numExports))
-        return RenderFail(c, "failed to read number of exports");
-
+    uint32_t numExports = exports.length();
     for (uint32_t i = 0; i < numExports; i++) {
-        if (!RenderFunctionExport(c))
+        if (!RenderExport(c, *exports[i], funcs))
             return false;
     }
-
-    if (!c.d.finishSection(sectionStart, sectionSize))
-        return RenderFail(c, "export section byte size mismatch");
-
     return true;
 }
 
 static bool
-RenderFunctionBody(WasmRenderContext& c, uint32_t funcIndex, uint32_t paramsNum)
+RenderFunctionBody(WasmRenderContext& c, AstFunc& func, const AstModule::SigVector& sigs)
 {
-    uint32_t bodySize;
-    if (!c.d.readVarU32(&bodySize))
-        return RenderFail(c, "expected number of function body bytes");
-
-    if (c.d.bytesRemain() < bodySize)
-        return RenderFail(c, "function body length too big");
-
-    const uint8_t* bodyBegin = c.d.currentPosition();
-    const uint8_t* bodyEnd = bodyBegin + bodySize;
-
+    const AstSig* sig = sigs[func.sig().index()];
     c.indent++;
 
-    ValTypeVector locals;
-    if (!DecodeLocalEntries(c.d, &locals))
-        return RenderFail(c, "failed decoding local entries");
-
-    uint32_t localsNum = locals.length();
+    uint32_t argsNum = sig->args().length();
+    uint32_t localsNum = func.vars().length();
     if (localsNum > 0) {
         if (!RenderIndent(c))
             return false;
         for (uint32_t i = 0; i < localsNum; i++) {
             if (!c.buffer.append("(local "))
                 return false;
-            if (!c.buffer.append("$var$"))
-                return false;
-            if (!RenderInt32(c, i + paramsNum))
-                return false;
-            ValType local = locals[i];
-            if (!c.buffer.append(" "))
-                return false;
+            const AstName& name = func.locals()[argsNum + i];
+            if (!name.empty()) {
+              if (!RenderName(c, name))
+                  return false;
+              if (!c.buffer.append(" "))
+                  return false;
+            }
+            ValType local = func.vars()[i];
             if (!RenderValType(c, local))
                 return false;
             if (!c.buffer.append(") "))
                 return false;
         }
         if (!c.buffer.append("\n"))
             return false;
     }
 
-    if (funcIndex >= c.funcLocals.length() && !c.funcLocals.resize(funcIndex + 1))
-        return false;
 
-    c.funcLocals[funcIndex] = localsNum + paramsNum;
-
-    while (c.d.currentPosition() < bodyEnd) {
-      if (!RenderFullLine(c))
+    uint32_t exprsNum = func.body().length();
+    for (uint32_t i = 0; i < exprsNum; i++) {
+      if (!RenderFullLine(c, *func.body()[i]))
           return false;
     }
 
-    if (c.d.currentPosition() != bodyEnd)
-        return RenderFail(c, "function body length mismatch");
-
     c.indent--;
 
     return true;
 }
 
 static bool
-RenderCodeSection(WasmRenderContext& c)
+RenderCodeSection(WasmRenderContext& c, const AstModule::FuncVector& funcs, const AstModule::SigVector& sigs)
 {
-    uint32_t sectionStart, sectionSize;
-    if (!c.d.startSection(CodeSectionId, &sectionStart, &sectionSize))
-        return RenderFail(c, "failed to start section");
-
-    if (sectionStart == Decoder::NotStarted)
-        return true;
-
-    uint32_t numFuncSigs = c.funcSigs.length();
-
-    uint32_t numFuncBodies;
-    if (!c.d.readVarU32(&numFuncBodies))
-        return RenderFail(c, "expected function body count");
-    if (numFuncBodies != numFuncSigs)
-        return RenderFail(c, "function body count does not match function signature count");
+    uint32_t numFuncBodies = funcs.length();
     for (uint32_t funcIndex = 0; funcIndex < numFuncBodies; funcIndex++) {
-        uint32_t sigIndex = c.funcSigs[funcIndex];
-        const DeclaredSig& sig = c.signatures[sigIndex];
+        AstFunc* func = funcs[funcIndex];
+        uint32_t sigIndex = func->sig().index();
+        AstSig* sig = sigs[sigIndex];
 
         if (!RenderIndent(c))
             return false;
-        if (!c.buffer.append("(func $func$"))
+        if (!c.buffer.append("(func "))
             return false;
-        if (!RenderInt32(c, funcIndex))
-            return false;
+        if (!func->name().empty()) {
+          if (!RenderName(c, func->name()))
+              return false;
+        }
 
-        if (!RenderSignature(c, sig, true))
+        if (!RenderSignature(c, *sig, &(func->locals())))
             return false;
         if (!c.buffer.append("\n"))
             return false;
 
         c.currentFuncIndex = funcIndex;
 
         c.indent++;
-        if (!RenderFunctionBody(c, funcIndex, sig.args().length()))
+        if (!RenderFunctionBody(c, *func, sigs))
             return false;
         c.indent--;
         if (!RenderIndent(c))
             return false;
         if (!c.buffer.append(")\n"))
             return false;
     }
 
-    if (!c.d.finishSection(sectionStart, sectionSize))
-        return RenderFail(c, "function section byte size mismatch");
-
    return true;
 }
 
 
 static bool
-RenderDataSection(WasmRenderContext& c, uint32_t memInitial, uint32_t memMax)
+RenderDataSection(WasmRenderContext& c, AstMemory* maybeMemory)
 {
+    if (!maybeMemory)
+        return true;
+
     if (!RenderIndent(c))
         return false;
     if (!c.buffer.append("(memory "))
         return false;
-    if (!RenderInt32(c, memInitial))
+    if (!RenderInt32(c, maybeMemory->initialSize()))
        return false;
-    if (memMax != 0 && ~memMax != 0) {
+    Maybe<uint32_t> memMax = maybeMemory->maxSize();
+    if (memMax) {
         if (!c.buffer.append(" "))
             return false;
-        if (!RenderInt32(c, memMax))
+        if (!RenderInt32(c, *memMax))
             return false;
     }
 
     c.indent++;
-    uint32_t sectionStart;
-    uint32_t sectionSize;
-    if (!c.d.startSection(DataSectionId, &sectionStart, &sectionSize))
-        return RenderFail(c, "failed to start section");
-    if (sectionStart == Decoder::NotStarted) {
+
+    uint32_t numSegments = maybeMemory->segments().length();
+    if (!numSegments) {
       if (!c.buffer.append(")\n"))
           return false;
       return true;
     }
     if (!c.buffer.append("\n"))
         return false;
 
-    uint32_t numSegments;
-    if (!c.d.readVarU32(&numSegments))
-        return RenderFail(c, "failed to read number of data segments");
-
     for (uint32_t i = 0; i < numSegments; i++) {
-        uint32_t dstOffset;
-        if (!c.d.readVarU32(&dstOffset))
-            return RenderFail(c, "expected segment destination offset");
+        const AstSegment* segment = maybeMemory->segments()[i];
 
         if (!RenderIndent(c))
             return false;
         if (!c.buffer.append("(segment "))
            return false;
-        if (!RenderInt32(c, dstOffset))
+        if (!RenderInt32(c, segment->offset()))
            return false;
         if (!c.buffer.append(" \""))
            return false;
 
-        uint32_t numBytes;
-        if (!c.d.readVarU32(&numBytes))
-            return RenderFail(c, "expected segment size");
-
-        const uint8_t* src;
-        if (!c.d.readBytesRaw(numBytes, &src))
-            return RenderFail(c, "data segment shorter than declared");
-
-        RenderString(c, src, numBytes);
+        RenderEscapedString(c, segment->text());
 
         if (!c.buffer.append("\")\n"))
            return false;
     }
 
-    if (!c.d.finishSection(sectionStart, sectionSize))
-        return RenderFail(c, "data section byte size mismatch");
-
     c.indent--;
     if (!c.buffer.append(")\n"))
         return false;
 
     return true;
 }
 
 static bool
-RenderModule(WasmRenderContext& c)
+RenderModule(WasmRenderContext& c, AstModule& module)
 {
-    uint32_t u32;
-    if (!c.d.readFixedU32(&u32) || u32 != MagicNumber)
-        return RenderFail(c, "failed to match magic number");
-
-    if (!c.d.readFixedU32(&u32) || u32 != EncodingVersion)
-        return RenderFail(c, "failed to match binary version");
-
     if (!c.buffer.append("(module\n"))
         return false;
 
     c.indent++;
 
-    if (!RenderTypeSection(c))
+    if (!RenderTypeSection(c, module.sigs()))
         return false;
 
-    if (!RenderImportSection(c))
-        return false;
-
-    if (!RenderFunctionSection(c))
-        return false;
-
-    if (!RenderTableSection(c))
+    if (!RenderImportSection(c, module.imports(), module.sigs()))
         return false;
 
-    uint32_t memInitial, memMax;
-    if (!RenderMemorySection(c, &memInitial, &memMax))
+    if (!RenderTableSection(c, module.maybeTable(), module.funcs()))
         return false;
 
-    if (!RenderExportSection(c))
+    if (!RenderExportSection(c, module.exports(), module.funcs()))
         return false;
 
-    if (!RenderCodeSection(c))
+    if (!RenderCodeSection(c, module.funcs(), module.sigs()))
         return false;
 
-    if (!RenderDataSection(c, memInitial, memMax))
+    if (!RenderDataSection(c, module.maybeMemory()))
         return false;
 
     c.indent--;
 
     if (!c.buffer.append(")"))
         return false;
 
     return true;
 }
 
 /*****************************************************************************/
 // Top-level functions
 
 bool
 wasm::BinaryToText(JSContext* cx, const uint8_t* bytes, size_t length, StringBuffer& buffer)
 {
-    Decoder d(bytes, bytes + length);
+
+    LifoAlloc lifo(AST_LIFO_DEFAULT_CHUNK_SIZE);
 
-    WasmRenderContext c(cx, d, buffer);
-
-    if (!c.buffer.append("Binary-to-text is temporarily unavailable\n"))
+    AstModule* module;
+    if (!BinaryToAst(cx, bytes, length, lifo, &module))
         return false;
 
-    // FIXME: Implement binary-to-text and re-enable this.
-    if (0 && !RenderModule(c)) {
+    WasmRenderContext c(cx, module, buffer);
+
+    if (!RenderModule(c, *module)) {
         if (!cx->isExceptionPending())
             ReportOutOfMemory(cx);
         return false;
     }
 
     return true;
 }