Add m-esr52 at 52.6.0

1 files changed, 2246 insertions, 0 deletions

diff --git a/js/src/wasm/WasmBinaryIterator.h b/js/src/wasm/WasmBinaryIterator.h
new file mode 100644
index 000000000..76e0c2875
--- /dev/null
+++ b/js/src/wasm/WasmBinaryIterator.h
@@ -0,0 +1,2246 @@
+/* -*- 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.
+ */
+
+#ifndef wasm_binary_iterator_h
+#define wasm_binary_iterator_h
+
+#include "mozilla/Poison.h"
+
+#include "jsprf.h"
+
+#include "jit/AtomicOp.h"
+#include "wasm/WasmBinaryFormat.h"
+
+namespace js {
+namespace wasm {
+
+// The kind of a control-flow stack item.
+enum class LabelKind : uint8_t {
+    Block,
+    Loop,
+    Then,
+    UnreachableThen, // like Then, but not reachable
+    Else
+};
+
+#ifdef DEBUG
+// Families of opcodes that share a signature and validation logic.
+enum class OpKind {
+    Block,
+    Loop,
+    Unreachable,
+    Drop,
+    I32,
+    I64,
+    F32,
+    F64,
+    I8x16,
+    I16x8,
+    I32x4,
+    F32x4,
+    B8x16,
+    B16x8,
+    B32x4,
+    Br,
+    BrIf,
+    BrTable,
+    Nop,
+    Nullary,
+    Unary,
+    Binary,
+    Comparison,
+    Conversion,
+    Load,
+    Store,
+    TeeStore,
+    CurrentMemory,
+    GrowMemory,
+    Select,
+    GetLocal,
+    SetLocal,
+    TeeLocal,
+    GetGlobal,
+    SetGlobal,
+    TeeGlobal,
+    Call,
+    CallIndirect,
+    OldCallIndirect,
+    Return,
+    If,
+    Else,
+    End,
+    AtomicLoad,
+    AtomicStore,
+    AtomicBinOp,
+    AtomicCompareExchange,
+    AtomicExchange,
+    ExtractLane,
+    ReplaceLane,
+    Swizzle,
+    Shuffle,
+    Splat,
+    SimdSelect,
+    SimdCtor,
+    SimdBooleanReduction,
+    SimdShiftByScalar,
+    SimdComparison,
+};
+
+// Return the OpKind for a given Op. This is used for sanity-checking that
+// API users use the correct read function for a given Op.
+OpKind
+Classify(Op op);
+#endif
+
+// Common fields for linear memory access.
+template <typename Value>
+struct LinearMemoryAddress
+{
+    Value base;
+    uint32_t offset;
+    uint32_t align;
+
+    LinearMemoryAddress()
+    {}
+    LinearMemoryAddress(Value base, uint32_t offset, uint32_t align)
+      : base(base), offset(offset), align(align)
+    {}
+};
+
+template <typename ControlItem>
+class ControlStackEntry
+{
+    LabelKind kind_;
+    bool reachable_;
+    ExprType type_;
+    size_t valueStackStart_;
+    ControlItem controlItem_;
+
+  public:
+    ControlStackEntry(LabelKind kind, ExprType type, bool reachable, size_t valueStackStart)
+      : kind_(kind), reachable_(reachable), type_(type), valueStackStart_(valueStackStart),
+        controlItem_()
+    {
+        MOZ_ASSERT(type != ExprType::Limit);
+    }
+
+    LabelKind kind() const { return kind_; }
+    ExprType type() const { return type_; }
+    bool reachable() const { return reachable_; }
+    size_t valueStackStart() const { return valueStackStart_; }
+    ControlItem& controlItem() { return controlItem_; }
+
+    void setReachable() { reachable_ = true; }
+
+    void switchToElse(bool reachable) {
+        MOZ_ASSERT(kind_ == LabelKind::Then || kind_ == LabelKind::UnreachableThen);
+        reachable_ = reachable;
+        kind_ = LabelKind::Else;
+        controlItem_ = ControlItem();
+    }
+};
+
+// Specialization for when there is no additional data needed.
+template <>
+class ControlStackEntry<Nothing>
+{
+    LabelKind kind_;
+    bool reachable_;
+    ExprType type_;
+    size_t valueStackStart_;
+
+  public:
+    ControlStackEntry(LabelKind kind, ExprType type, bool reachable, size_t valueStackStart)
+      : kind_(kind), reachable_(reachable), type_(type), valueStackStart_(valueStackStart)
+    {
+        MOZ_ASSERT(type != ExprType::Limit);
+    }
+
+    LabelKind kind() const { return kind_; }
+    ExprType type() const { return type_; }
+    bool reachable() const { return reachable_; }
+    size_t valueStackStart() const { return valueStackStart_; }
+    Nothing controlItem() { return Nothing(); }
+
+    void setReachable() { reachable_ = true; }
+
+    void switchToElse(bool reachable) {
+        MOZ_ASSERT(kind_ == LabelKind::Then || kind_ == LabelKind::UnreachableThen);
+        reachable_ = reachable;
+        kind_ = LabelKind::Else;
+    }
+};
+
+template <typename Value>
+class TypeAndValue
+{
+    ValType type_;
+    Value value_;
+
+  public:
+    TypeAndValue() : type_(ValType(TypeCode::Limit)), value_() {}
+    explicit TypeAndValue(ValType type)
+      : type_(type), value_()
+    {}
+    TypeAndValue(ValType type, Value value)
+      : type_(type), value_(value)
+    {}
+    ValType type() const {
+        return type_;
+    }
+    Value value() const {
+        return value_;
+    }
+    void setValue(Value value) {
+        value_ = value;
+    }
+};
+
+// Specialization for when there is no additional data needed.
+template <>
+class TypeAndValue<Nothing>
+{
+    ValType type_;
+
+  public:
+    TypeAndValue() : type_(ValType(TypeCode::Limit)) {}
+    explicit TypeAndValue(ValType type) : type_(type) {}
+
+    TypeAndValue(ValType type, Nothing value)
+      : type_(type)
+    {}
+
+    ValType type() const { return type_; }
+    Nothing value() const { return Nothing(); }
+    void setValue(Nothing value) {}
+};
+
+// A policy class for configuring OpIter. Clients can use this as a
+// base class, and override the behavior as needed.
+struct OpIterPolicy
+{
+    // Should the iterator perform validation, such as type checking and
+    // validity checking?
+    static const bool Validate = false;
+
+    // Should the iterator produce output values?
+    static const bool Output = false;
+
+    // These members allow clients to add additional information to the value
+    // and control stacks, respectively. Using Nothing means that no additional
+    // field is added.
+    typedef Nothing Value;
+    typedef Nothing ControlItem;
+};
+
+// An iterator over the bytes of a function body. It performs validation
+// (if Policy::Validate is true) and unpacks the data into a usable form.
+//
+// The MOZ_STACK_CLASS attribute here is because of the use of DebugOnly.
+// There's otherwise nothing inherent in this class which would require
+// it to be used on the stack.
+template <typename Policy>
+class MOZ_STACK_CLASS OpIter : private Policy
+{
+    static const bool Validate = Policy::Validate;
+    static const bool Output = Policy::Output;
+    typedef typename Policy::Value Value;
+    typedef typename Policy::ControlItem ControlItem;
+
+    Decoder& d_;
+    const size_t offsetInModule_;
+
+    Vector<TypeAndValue<Value>, 8, SystemAllocPolicy> valueStack_;
+    Vector<ControlStackEntry<ControlItem>, 8, SystemAllocPolicy> controlStack_;
+    bool reachable_;
+
+    DebugOnly<Op> op_;
+    size_t offsetOfExpr_;
+
+    MOZ_MUST_USE bool readFixedU8(uint8_t* out) {
+        if (Validate)
+            return d_.readFixedU8(out);
+        *out = d_.uncheckedReadFixedU8();
+        return true;
+    }
+    MOZ_MUST_USE bool readFixedU32(uint32_t* out) {
+        if (Validate)
+            return d_.readFixedU32(out);
+        *out = d_.uncheckedReadFixedU32();
+        return true;
+    }
+    MOZ_MUST_USE bool readVarS32(int32_t* out) {
+        if (Validate)
+            return d_.readVarS32(out);
+        *out = d_.uncheckedReadVarS32();
+        return true;
+    }
+    MOZ_MUST_USE bool readVarU32(uint32_t* out) {
+        if (Validate)
+            return d_.readVarU32(out);
+        *out = d_.uncheckedReadVarU32();
+        return true;
+    }
+    MOZ_MUST_USE bool readVarS64(int64_t* out) {
+        if (Validate)
+            return d_.readVarS64(out);
+        *out = d_.uncheckedReadVarS64();
+        return true;
+    }
+    MOZ_MUST_USE bool readVarU64(uint64_t* out) {
+        if (Validate)
+            return d_.readVarU64(out);
+        *out = d_.uncheckedReadVarU64();
+        return true;
+    }
+    MOZ_MUST_USE bool readFixedF32(RawF32* out) {
+        if (Validate)
+            return d_.readFixedF32(out);
+        *out = d_.uncheckedReadFixedF32();
+        return true;
+    }
+    MOZ_MUST_USE bool readFixedF64(RawF64* out) {
+        if (Validate)
+            return d_.readFixedF64(out);
+        *out = d_.uncheckedReadFixedF64();
+        return true;
+    }
+    MOZ_MUST_USE bool readFixedI8x16(I8x16* out) {
+        if (Validate)
+            return d_.readFixedI8x16(out);
+        d_.uncheckedReadFixedI8x16(out);
+        return true;
+    }
+    MOZ_MUST_USE bool readFixedI16x8(I16x8* out) {
+        if (Validate)
+            return d_.readFixedI16x8(out);
+        d_.uncheckedReadFixedI16x8(out);
+        return true;
+    }
+    MOZ_MUST_USE bool readFixedI32x4(I32x4* out) {
+        if (Validate)
+            return d_.readFixedI32x4(out);
+        d_.uncheckedReadFixedI32x4(out);
+        return true;
+    }
+    MOZ_MUST_USE bool readFixedF32x4(F32x4* out) {
+        if (Validate)
+            return d_.readFixedF32x4(out);
+        d_.uncheckedReadFixedF32x4(out);
+        return true;
+    }
+
+    MOZ_MUST_USE bool readAtomicViewType(Scalar::Type* viewType) {
+        uint8_t x;
+        if (!readFixedU8(&x))
+            return fail("unable to read atomic view");
+        if (Validate && x >= Scalar::MaxTypedArrayViewType)
+            return fail("invalid atomic view type");
+        *viewType = Scalar::Type(x);
+        return true;
+    }
+
+    MOZ_MUST_USE bool readAtomicBinOpOp(jit::AtomicOp* op) {
+        uint8_t x;
+        if (!readFixedU8(&x))
+            return fail("unable to read atomic opcode");
+        if (Validate) {
+            switch (x) {
+              case jit::AtomicFetchAddOp:
+              case jit::AtomicFetchSubOp:
+              case jit::AtomicFetchAndOp:
+              case jit::AtomicFetchOrOp:
+              case jit::AtomicFetchXorOp:
+                break;
+              default:
+                return fail("unrecognized atomic binop");
+            }
+        }
+        *op = jit::AtomicOp(x);
+        return true;
+    }
+
+    MOZ_MUST_USE bool readLinearMemoryAddress(uint32_t byteSize, LinearMemoryAddress<Value>* addr);
+    MOZ_MUST_USE bool readBlockType(ExprType* expr);
+
+    MOZ_MUST_USE bool typeMismatch(ExprType actual, ExprType expected) MOZ_COLD;
+    MOZ_MUST_USE bool checkType(ValType actual, ValType expected);
+    MOZ_MUST_USE bool checkType(ExprType actual, ExprType expected);
+
+    MOZ_MUST_USE bool pushControl(LabelKind kind, ExprType type, bool reachable);
+    MOZ_MUST_USE bool mergeControl(LabelKind* kind, ExprType* type, Value* value);
+    MOZ_MUST_USE bool popControl(LabelKind* kind, ExprType* type, Value* value);
+
+    MOZ_MUST_USE bool push(ValType t) {
+        if (MOZ_UNLIKELY(!reachable_))
+            return true;
+        return valueStack_.emplaceBack(t);
+    }
+    MOZ_MUST_USE bool push(TypeAndValue<Value> tv) {
+        if (MOZ_UNLIKELY(!reachable_))
+            return true;
+        return valueStack_.append(tv);
+    }
+    void infalliblePush(ValType t) {
+        if (MOZ_UNLIKELY(!reachable_))
+            return;
+        valueStack_.infallibleEmplaceBack(t);
+    }
+    void infalliblePush(TypeAndValue<Value> tv) {
+        if (MOZ_UNLIKELY(!reachable_))
+            return;
+        valueStack_.infallibleAppend(tv);
+    }
+
+    // Test whether reading the top of the value stack is currently valid.
+    MOZ_MUST_USE bool checkTop() {
+        MOZ_ASSERT(reachable_);
+        if (Validate && valueStack_.length() <= controlStack_.back().valueStackStart()) {
+            if (valueStack_.empty())
+                return fail("popping value from empty stack");
+            return fail("popping value from outside block");
+        }
+        return true;
+    }
+
+    // Pop the top of the value stack.
+    MOZ_MUST_USE bool pop(TypeAndValue<Value>* tv) {
+        if (MOZ_UNLIKELY(!reachable_))
+            return true;
+        if (!checkTop())
+            return false;
+        *tv = valueStack_.popCopy();
+        return true;
+    }
+
+    // Pop the top of the value stack and check that it has the given type.
+    MOZ_MUST_USE bool popWithType(ValType expectedType, Value* value) {
+        if (MOZ_UNLIKELY(!reachable_))
+            return true;
+        if (!checkTop())
+            return false;
+        TypeAndValue<Value> tv = valueStack_.popCopy();
+        if (!checkType(tv.type(), expectedType))
+            return false;
+        if (Output)
+            *value = tv.value();
+        return true;
+    }
+
+    // Pop the top of the value stack and discard the result.
+    MOZ_MUST_USE bool pop() {
+        if (MOZ_UNLIKELY(!reachable_))
+            return true;
+        if (!checkTop())
+            return false;
+        valueStack_.popBack();
+        return true;
+    }
+
+    // Read the top of the value stack (without popping it).
+    MOZ_MUST_USE bool top(TypeAndValue<Value>* tv) {
+        if (MOZ_UNLIKELY(!reachable_))
+            return true;
+        if (!checkTop())
+            return false;
+        *tv = valueStack_.back();
+        return true;
+    }
+
+    // Read the top of the value stack (without popping it) and check that it
+    // has the given type.
+    MOZ_MUST_USE bool topWithType(ValType expectedType, Value* value) {
+        if (MOZ_UNLIKELY(!reachable_))
+            return true;
+        if (!checkTop())
+            return false;
+        TypeAndValue<Value>& tv = valueStack_.back();
+        if (!checkType(tv.type(), expectedType))
+            return false;
+        if (Output)
+            *value = tv.value();
+        return true;
+    }
+
+    // Read the value stack entry at depth |index|.
+    MOZ_MUST_USE bool peek(uint32_t index, TypeAndValue<Value>* tv) {
+        MOZ_ASSERT(reachable_);
+        if (Validate && valueStack_.length() - controlStack_.back().valueStackStart() < index)
+            return fail("peeking at value from outside block");
+        *tv = valueStack_[valueStack_.length() - index];
+        return true;
+    }
+
+    bool getControl(uint32_t relativeDepth, ControlStackEntry<ControlItem>** controlEntry) {
+        if (Validate && relativeDepth >= controlStack_.length())
+            return fail("branch depth exceeds current nesting level");
+
+        *controlEntry = &controlStack_[controlStack_.length() - 1 - relativeDepth];
+        return true;
+    }
+
+    void enterUnreachableCode() {
+        valueStack_.shrinkTo(controlStack_.back().valueStackStart());
+        reachable_ = false;
+    }
+
+    bool checkBrValue(uint32_t relativeDepth, ExprType* type, Value* value);
+    bool checkBrIfValues(uint32_t relativeDepth, Value* condition, ExprType* type, Value* value);
+
+  public:
+    explicit OpIter(Decoder& decoder, uint32_t offsetInModule = 0)
+      : d_(decoder), offsetInModule_(offsetInModule), reachable_(true),
+        op_(Op::Limit), offsetOfExpr_(0)
+    {}
+
+    // Return the decoding byte offset.
+    uint32_t currentOffset() const { return d_.currentOffset(); }
+
+    // Returning the offset within the entire module of the last-read Op.
+    TrapOffset trapOffset() const {
+        return TrapOffset(offsetInModule_ + offsetOfExpr_);
+    }
+
+    // Test whether the iterator has reached the end of the buffer.
+    bool done() const { return d_.done(); }
+
+    // Report a general failure.
+    MOZ_MUST_USE bool fail(const char* msg) MOZ_COLD;
+
+    // Report an unimplemented feature.
+    MOZ_MUST_USE bool notYetImplemented(const char* what) MOZ_COLD;
+
+    // Report an unrecognized opcode.
+    MOZ_MUST_USE bool unrecognizedOpcode(uint32_t expr) MOZ_COLD;
+
+    // Test whether the iterator is currently in "reachable" code.
+    bool inReachableCode() const { return reachable_; }
+
+    // ------------------------------------------------------------------------
+    // Decoding and validation interface.
+
+    MOZ_MUST_USE bool readOp(uint16_t* op);
+    MOZ_MUST_USE bool readFunctionStart(ExprType ret);
+    MOZ_MUST_USE bool readFunctionEnd();
+    MOZ_MUST_USE bool readReturn(Value* value);
+    MOZ_MUST_USE bool readBlock();
+    MOZ_MUST_USE bool readLoop();
+    MOZ_MUST_USE bool readIf(Value* condition);
+    MOZ_MUST_USE bool readElse(ExprType* thenType, Value* thenValue);
+    MOZ_MUST_USE bool readEnd(LabelKind* kind, ExprType* type, Value* value);
+    MOZ_MUST_USE bool readBr(uint32_t* relativeDepth, ExprType* type, Value* value);
+    MOZ_MUST_USE bool readBrIf(uint32_t* relativeDepth, ExprType* type,
+                               Value* value, Value* condition);
+    MOZ_MUST_USE bool readBrTable(uint32_t* tableLength, ExprType* type,
+                                  Value* value, Value* index);
+    MOZ_MUST_USE bool readBrTableEntry(ExprType* type, Value* value, uint32_t* depth);
+    MOZ_MUST_USE bool readBrTableDefault(ExprType* type, Value* value, uint32_t* depth);
+    MOZ_MUST_USE bool readUnreachable();
+    MOZ_MUST_USE bool readDrop();
+    MOZ_MUST_USE bool readUnary(ValType operandType, Value* input);
+    MOZ_MUST_USE bool readConversion(ValType operandType, ValType resultType, Value* input);
+    MOZ_MUST_USE bool readBinary(ValType operandType, Value* lhs, Value* rhs);
+    MOZ_MUST_USE bool readComparison(ValType operandType, Value* lhs, Value* rhs);
+    MOZ_MUST_USE bool readLoad(ValType resultType, uint32_t byteSize,
+                               LinearMemoryAddress<Value>* addr);
+    MOZ_MUST_USE bool readStore(ValType resultType, uint32_t byteSize,
+                                LinearMemoryAddress<Value>* addr, Value* value);
+    MOZ_MUST_USE bool readTeeStore(ValType resultType, uint32_t byteSize,
+                                   LinearMemoryAddress<Value>* addr, Value* value);
+    MOZ_MUST_USE bool readNop();
+    MOZ_MUST_USE bool readCurrentMemory();
+    MOZ_MUST_USE bool readGrowMemory(Value* input);
+    MOZ_MUST_USE bool readSelect(ValType* type,
+                                 Value* trueValue, Value* falseValue, Value* condition);
+    MOZ_MUST_USE bool readGetLocal(const ValTypeVector& locals, uint32_t* id);
+    MOZ_MUST_USE bool readSetLocal(const ValTypeVector& locals, uint32_t* id, Value* value);
+    MOZ_MUST_USE bool readTeeLocal(const ValTypeVector& locals, uint32_t* id, Value* value);
+    MOZ_MUST_USE bool readGetGlobal(const GlobalDescVector& globals, uint32_t* id);
+    MOZ_MUST_USE bool readSetGlobal(const GlobalDescVector& globals, uint32_t* id, Value* value);
+    MOZ_MUST_USE bool readTeeGlobal(const GlobalDescVector& globals, uint32_t* id, Value* value);
+    MOZ_MUST_USE bool readI32Const(int32_t* i32);
+    MOZ_MUST_USE bool readI64Const(int64_t* i64);
+    MOZ_MUST_USE bool readF32Const(RawF32* f32);
+    MOZ_MUST_USE bool readF64Const(RawF64* f64);
+    MOZ_MUST_USE bool readI8x16Const(I8x16* i8x16);
+    MOZ_MUST_USE bool readI16x8Const(I16x8* i16x8);
+    MOZ_MUST_USE bool readI32x4Const(I32x4* i32x4);
+    MOZ_MUST_USE bool readF32x4Const(F32x4* f32x4);
+    MOZ_MUST_USE bool readB8x16Const(I8x16* i8x16);
+    MOZ_MUST_USE bool readB16x8Const(I16x8* i16x8);
+    MOZ_MUST_USE bool readB32x4Const(I32x4* i32x4);
+    MOZ_MUST_USE bool readCall(uint32_t* calleeIndex);
+    MOZ_MUST_USE bool readCallIndirect(uint32_t* sigIndex, Value* callee);
+    MOZ_MUST_USE bool readOldCallIndirect(uint32_t* sigIndex);
+    MOZ_MUST_USE bool readCallArg(ValType type, uint32_t numArgs, uint32_t argIndex, Value* arg);
+    MOZ_MUST_USE bool readCallArgsEnd(uint32_t numArgs);
+    MOZ_MUST_USE bool readOldCallIndirectCallee(Value* callee);
+    MOZ_MUST_USE bool readCallReturn(ExprType ret);
+    MOZ_MUST_USE bool readAtomicLoad(LinearMemoryAddress<Value>* addr,
+                                     Scalar::Type* viewType);
+    MOZ_MUST_USE bool readAtomicStore(LinearMemoryAddress<Value>* addr,
+                                      Scalar::Type* viewType,
+                                      Value* value);
+    MOZ_MUST_USE bool readAtomicBinOp(LinearMemoryAddress<Value>* addr,
+                                      Scalar::Type* viewType,
+                                      jit::AtomicOp* op,
+                                      Value* value);
+    MOZ_MUST_USE bool readAtomicCompareExchange(LinearMemoryAddress<Value>* addr,
+                                                Scalar::Type* viewType,
+                                                Value* oldValue,
+                                                Value* newValue);
+    MOZ_MUST_USE bool readAtomicExchange(LinearMemoryAddress<Value>* addr,
+                                         Scalar::Type* viewType,
+                                         Value* newValue);
+    MOZ_MUST_USE bool readSimdComparison(ValType simdType, Value* lhs,
+                                         Value* rhs);
+    MOZ_MUST_USE bool readSimdShiftByScalar(ValType simdType, Value* lhs,
+                                            Value* rhs);
+    MOZ_MUST_USE bool readSimdBooleanReduction(ValType simdType, Value* input);
+    MOZ_MUST_USE bool readExtractLane(ValType simdType, uint8_t* lane,
+                                      Value* vector);
+    MOZ_MUST_USE bool readReplaceLane(ValType simdType, uint8_t* lane,
+                                      Value* vector, Value* scalar);
+    MOZ_MUST_USE bool readSplat(ValType simdType, Value* scalar);
+    MOZ_MUST_USE bool readSwizzle(ValType simdType, uint8_t (* lanes)[16], Value* vector);
+    MOZ_MUST_USE bool readShuffle(ValType simdType, uint8_t (* lanes)[16],
+                                  Value* lhs, Value* rhs);
+    MOZ_MUST_USE bool readSimdSelect(ValType simdType, Value* trueValue,
+                                     Value* falseValue,
+                                     Value* condition);
+    MOZ_MUST_USE bool readSimdCtor();
+    MOZ_MUST_USE bool readSimdCtorArg(ValType elementType, uint32_t numElements, uint32_t argIndex,
+                                      Value* arg);
+    MOZ_MUST_USE bool readSimdCtorArgsEnd(uint32_t numElements);
+    MOZ_MUST_USE bool readSimdCtorReturn(ValType simdType);
+
+    // At a location where readOp is allowed, peek at the next opcode
+    // without consuming it or updating any internal state.
+    // Never fails: returns uint16_t(Op::Limit) if it can't read.
+    uint16_t peekOp();
+
+    // ------------------------------------------------------------------------
+    // Stack management.
+
+    // Set the result value of the current top-of-value-stack expression.
+    void setResult(Value value) {
+        if (MOZ_LIKELY(reachable_))
+            valueStack_.back().setValue(value);
+    }
+
+    // Return the result value of the current top-of-value-stack expression.
+    Value getResult() {
+        MOZ_ASSERT(reachable_);
+        return valueStack_.back().value();
+    }
+
+    // Return a reference to the top of the control stack.
+    ControlItem& controlItem() {
+        return controlStack_.back().controlItem();
+    }
+
+    // Return the signature of the top of the control stack.
+    ExprType controlType() {
+        return controlStack_.back().type();
+    }
+
+    // Test whether the control-stack is empty, meaning we've consumed the final
+    // end of the function body.
+    bool controlStackEmpty() const {
+        return controlStack_.empty();
+    }
+};
+
+template <typename Policy>
+bool
+OpIter<Policy>::typeMismatch(ExprType actual, ExprType expected)
+{
+    MOZ_ASSERT(Validate);
+    MOZ_ASSERT(reachable_);
+
+    UniqueChars error(JS_smprintf("type mismatch: expression has type %s but expected %s",
+                                  ToCString(actual), ToCString(expected)));
+    if (!error)
+        return false;
+
+    return fail(error.get());
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::checkType(ValType actual, ValType expected)
+{
+    return checkType(ToExprType(actual), ToExprType(expected));
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::checkType(ExprType actual, ExprType expected)
+{
+    MOZ_ASSERT(reachable_);
+
+    if (!Validate) {
+        MOZ_ASSERT(actual == expected, "type mismatch");
+        return true;
+    }
+
+    if (MOZ_LIKELY(actual == expected))
+        return true;
+
+    return typeMismatch(actual, expected);
+}
+
+template <typename Policy>
+bool
+OpIter<Policy>::notYetImplemented(const char* what)
+{
+    UniqueChars error(JS_smprintf("not yet implemented: %s", what));
+    if (!error)
+        return false;
+
+    return fail(error.get());
+}
+
+template <typename Policy>
+bool
+OpIter<Policy>::unrecognizedOpcode(uint32_t expr)
+{
+    UniqueChars error(JS_smprintf("unrecognized opcode: %x", expr));
+    if (!error)
+        return false;
+
+    return fail(error.get());
+}
+
+template <typename Policy>
+bool
+OpIter<Policy>::fail(const char* msg)
+{
+    return d_.fail("%s", msg);
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::pushControl(LabelKind kind, ExprType type, bool reachable)
+{
+    return controlStack_.emplaceBack(kind, type, reachable, valueStack_.length());
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::mergeControl(LabelKind* kind, ExprType* type, Value* value)
+{
+    MOZ_ASSERT(!controlStack_.empty());
+
+    ControlStackEntry<ControlItem>& controlItem = controlStack_.back();
+    *kind = controlItem.kind();
+
+    if (reachable_) {
+        // Unlike branching, exiting a scope via fallthrough does not implicitly
+        // pop excess items on the stack.
+        size_t valueStackStart = controlItem.valueStackStart();
+        size_t valueStackLength = valueStack_.length();
+        MOZ_ASSERT(valueStackLength >= valueStackStart);
+        if (valueStackLength == valueStackStart) {
+            *type = ExprType::Void;
+            if (!checkType(ExprType::Void, controlItem.type()))
+                return false;
+        } else {
+            *type = controlItem.type();
+            if (Validate && valueStackLength - valueStackStart > (IsVoid(*type) ? 0u : 1u))
+                return fail("unused values not explicitly dropped by end of block");
+            if (!topWithType(NonVoidToValType(*type), value))
+                return false;
+        }
+    } else {
+        if (*kind != LabelKind::Loop && controlItem.reachable()) {
+            // There was no fallthrough path, but there was some other reachable
+            // branch to the end.
+            reachable_ = true;
+            *type = controlItem.type();
+            if (!IsVoid(*type)) {
+                if (!push(NonVoidToValType(*type)))
+                    return false;
+            }
+        } else {
+            // No fallthrough and no branch to the end either; we remain
+            // unreachable.
+            *type = ExprType::Void;
+        }
+        if (Output)
+            *value = Value();
+    }
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::popControl(LabelKind* kind, ExprType* type, Value* value)
+{
+    if (!mergeControl(kind, type, value))
+        return false;
+
+    if (*kind == LabelKind::Then) {
+        // A reachable If without an Else. Forbid a result value.
+        if (reachable_) {
+            if (Validate && !IsVoid(*type))
+                return fail("if without else with a result value");
+        }
+        reachable_ = true;
+    }
+
+    controlStack_.popBack();
+
+    if (!reachable_ && !controlStack_.empty())
+        valueStack_.shrinkTo(controlStack_.back().valueStackStart());
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readBlockType(ExprType* type)
+{
+    uint8_t unchecked;
+    if (!d_.readBlockType(&unchecked))
+        return fail("unable to read block signature");
+
+    if (Validate) {
+        switch (unchecked) {
+          case uint8_t(ExprType::Void):
+          case uint8_t(ExprType::I32):
+          case uint8_t(ExprType::I64):
+          case uint8_t(ExprType::F32):
+          case uint8_t(ExprType::F64):
+          case uint8_t(ExprType::I8x16):
+          case uint8_t(ExprType::I16x8):
+          case uint8_t(ExprType::I32x4):
+          case uint8_t(ExprType::F32x4):
+          case uint8_t(ExprType::B8x16):
+          case uint8_t(ExprType::B16x8):
+          case uint8_t(ExprType::B32x4):
+            break;
+          default:
+            return fail("invalid inline block type");
+        }
+    }
+
+    *type = ExprType(unchecked);
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readOp(uint16_t* op)
+{
+    offsetOfExpr_ = d_.currentOffset();
+
+    if (Validate) {
+        if (MOZ_UNLIKELY(!d_.readOp(op)))
+            return fail("unable to read opcode");
+    } else {
+        *op = uint16_t(d_.uncheckedReadOp());
+    }
+
+    op_ = Op(*op);  // debug-only
+
+    return true;
+}
+
+template <typename Policy>
+inline uint16_t
+OpIter<Policy>::peekOp()
+{
+    const uint8_t* pos = d_.currentPosition();
+    uint16_t op;
+
+    if (Validate) {
+        if (MOZ_UNLIKELY(!d_.readOp(&op)))
+            op = uint16_t(Op::Limit);
+    } else {
+        op = uint16_t(d_.uncheckedReadOp());
+    }
+
+    d_.rollbackPosition(pos);
+
+    return op;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readFunctionStart(ExprType ret)
+{
+    MOZ_ASSERT(valueStack_.empty());
+    MOZ_ASSERT(controlStack_.empty());
+    MOZ_ASSERT(Op(op_) == Op::Limit);
+    MOZ_ASSERT(reachable_);
+
+    return pushControl(LabelKind::Block, ret, false);
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readFunctionEnd()
+{
+    if (Validate) {
+        if (!controlStack_.empty())
+            return fail("unbalanced function body control flow");
+    } else {
+        MOZ_ASSERT(controlStack_.empty());
+    }
+
+    op_ = Op::Limit;
+    valueStack_.clear();
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readReturn(Value* value)
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::Return);
+
+    if (MOZ_LIKELY(reachable_)) {
+        ControlStackEntry<ControlItem>& controlItem = controlStack_[0];
+        MOZ_ASSERT(controlItem.kind() == LabelKind::Block);
+
+        controlItem.setReachable();
+
+        if (!IsVoid(controlItem.type())) {
+            if (!popWithType(NonVoidToValType(controlItem.type()), value))
+                return false;
+        }
+    }
+
+    enterUnreachableCode();
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readBlock()
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::Block);
+
+    ExprType type = ExprType::Limit;
+    if (!readBlockType(&type))
+        return false;
+
+    return pushControl(LabelKind::Block, type, false);
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readLoop()
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::Loop);
+
+    ExprType type = ExprType::Limit;
+    if (!readBlockType(&type))
+        return false;
+
+    return pushControl(LabelKind::Loop, type, reachable_);
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readIf(Value* condition)
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::If);
+
+    ExprType type = ExprType::Limit;
+    if (!readBlockType(&type))
+        return false;
+
+    if (MOZ_LIKELY(reachable_)) {
+        if (!popWithType(ValType::I32, condition))
+            return false;
+
+        return pushControl(LabelKind::Then, type, false);
+    }
+
+    return pushControl(LabelKind::UnreachableThen, type, false);
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readElse(ExprType* thenType, Value* thenValue)
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::Else);
+
+    // Finish up the then arm.
+    ExprType type = ExprType::Limit;
+    LabelKind kind;
+    if (!mergeControl(&kind, &type, thenValue))
+        return false;
+
+    if (Output)
+        *thenType = type;
+
+    // Pop the old then value from the stack.
+    if (!IsVoid(type))
+        valueStack_.popBack();
+
+    if (Validate && kind != LabelKind::Then && kind != LabelKind::UnreachableThen)
+        return fail("else can only be used within an if");
+
+    // Switch to the else arm.
+    controlStack_.back().switchToElse(reachable_);
+
+    reachable_ = kind != LabelKind::UnreachableThen;
+
+    MOZ_ASSERT(valueStack_.length() == controlStack_.back().valueStackStart());
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readEnd(LabelKind* kind, ExprType* type, Value* value)
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::End);
+
+    LabelKind validateKind = static_cast<LabelKind>(-1);
+    ExprType validateType = ExprType::Limit;
+    if (!popControl(&validateKind, &validateType, value))
+        return false;
+
+    if (Output) {
+        *kind = validateKind;
+        *type = validateType;
+    }
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::checkBrValue(uint32_t relativeDepth, ExprType* type, Value* value)
+{
+    if (MOZ_LIKELY(reachable_)) {
+        ControlStackEntry<ControlItem>* controlItem = nullptr;
+        if (!getControl(relativeDepth, &controlItem))
+            return false;
+
+        if (controlItem->kind() != LabelKind::Loop) {
+            controlItem->setReachable();
+
+            ExprType expectedType = controlItem->type();
+            if (Output)
+                *type = expectedType;
+
+            if (!IsVoid(expectedType))
+                return topWithType(NonVoidToValType(expectedType), value);
+        }
+    }
+
+    if (Output) {
+        *type = ExprType::Void;
+        *value = Value();
+    }
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readBr(uint32_t* relativeDepth, ExprType* type, Value* value)
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::Br);
+
+    uint32_t validateRelativeDepth;
+    if (!readVarU32(&validateRelativeDepth))
+        return fail("unable to read br depth");
+
+    if (!checkBrValue(validateRelativeDepth, type, value))
+        return false;
+
+    if (Output)
+        *relativeDepth = validateRelativeDepth;
+
+    enterUnreachableCode();
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::checkBrIfValues(uint32_t relativeDepth, Value* condition,
+                                  ExprType* type, Value* value)
+{
+    if (MOZ_LIKELY(reachable_)) {
+        if (!popWithType(ValType::I32, condition))
+            return false;
+
+        ControlStackEntry<ControlItem>* controlItem = nullptr;
+        if (!getControl(relativeDepth, &controlItem))
+            return false;
+
+        if (controlItem->kind() != LabelKind::Loop) {
+            controlItem->setReachable();
+
+            ExprType expectedType = controlItem->type();
+            if (Output)
+                *type = expectedType;
+
+            if (!IsVoid(expectedType))
+                return topWithType(NonVoidToValType(expectedType), value);
+        }
+    }
+
+    if (Output) {
+        *type = ExprType::Void;
+        *value = Value();
+    }
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readBrIf(uint32_t* relativeDepth, ExprType* type, Value* value, Value* condition)
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::BrIf);
+
+    uint32_t validateRelativeDepth;
+    if (!readVarU32(&validateRelativeDepth))
+        return fail("unable to read br_if depth");
+
+    if (!checkBrIfValues(validateRelativeDepth, condition, type, value))
+        return false;
+
+    if (Output)
+        *relativeDepth = validateRelativeDepth;
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readBrTable(uint32_t* tableLength, ExprType* type,
+                              Value* value, Value* index)
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::BrTable);
+
+    if (!readVarU32(tableLength))
+        return fail("unable to read br_table table length");
+
+    if (MOZ_LIKELY(reachable_)) {
+        if (!popWithType(ValType::I32, index))
+            return false;
+    }
+
+    // Set *type to indicate that we don't know the type yet.
+    *type = ExprType::Limit;
+    if (Output)
+        *value = Value();
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readBrTableEntry(ExprType* type, Value* value, uint32_t* depth)
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::BrTable);
+
+    if (!readVarU32(depth))
+        return false;
+
+    ExprType knownType = *type;
+
+    if (MOZ_LIKELY(reachable_)) {
+        ControlStackEntry<ControlItem>* controlItem = nullptr;
+        if (!getControl(*depth, &controlItem))
+            return false;
+
+        if (controlItem->kind() != LabelKind::Loop) {
+            controlItem->setReachable();
+
+            // If we've already seen one label, we know the type and can check
+            // that the type for the current label matches it.
+            if (knownType != ExprType::Limit)
+                return checkType(knownType, controlItem->type());
+
+            // This is the first label; record the type and the value now.
+            ExprType expectedType = controlItem->type();
+            if (!IsVoid(expectedType)) {
+                *type = expectedType;
+                return popWithType(NonVoidToValType(expectedType), value);
+            }
+        }
+
+        if (knownType != ExprType::Limit && knownType != ExprType::Void)
+            return typeMismatch(knownType, ExprType::Void);
+    }
+
+    *type = ExprType::Void;
+    if (Output)
+        *value = Value();
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readBrTableDefault(ExprType* type, Value* value, uint32_t* depth)
+{
+    if (!readBrTableEntry(type, value, depth))
+        return false;
+
+    MOZ_ASSERT(!reachable_ || *type != ExprType::Limit);
+
+    enterUnreachableCode();
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readUnreachable()
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::Unreachable);
+
+    enterUnreachableCode();
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readDrop()
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::Drop);
+
+    if (!pop())
+        return false;
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readUnary(ValType operandType, Value* input)
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::Unary);
+
+    if (!popWithType(operandType, input))
+        return false;
+
+    infalliblePush(operandType);
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readConversion(ValType operandType, ValType resultType, Value* input)
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::Conversion);
+
+    if (!popWithType(operandType, input))
+        return false;
+
+    infalliblePush(resultType);
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readBinary(ValType operandType, Value* lhs, Value* rhs)
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::Binary);
+
+    if (!popWithType(operandType, rhs))
+        return false;
+
+    if (!popWithType(operandType, lhs))
+        return false;
+
+    infalliblePush(operandType);
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readComparison(ValType operandType, Value* lhs, Value* rhs)
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::Comparison);
+
+    if (!popWithType(operandType, rhs))
+        return false;
+
+    if (!popWithType(operandType, lhs))
+        return false;
+
+    infalliblePush(ValType::I32);
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readLinearMemoryAddress(uint32_t byteSize, LinearMemoryAddress<Value>* addr)
+{
+    uint8_t alignLog2;
+    if (!readFixedU8(&alignLog2))
+        return fail("unable to read load alignment");
+
+    uint32_t unusedOffset;
+    if (!readVarU32(Output ? &addr->offset : &unusedOffset))
+        return fail("unable to read load offset");
+
+    if (Validate && (alignLog2 >= 32 || (uint32_t(1) << alignLog2) > byteSize))
+        return fail("greater than natural alignment");
+
+    Value unused;
+    if (!popWithType(ValType::I32, Output ? &addr->base : &unused))
+        return false;
+
+    if (Output)
+        addr->align = uint32_t(1) << alignLog2;
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readLoad(ValType resultType, uint32_t byteSize, LinearMemoryAddress<Value>* addr)
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::Load);
+
+    if (!readLinearMemoryAddress(byteSize, addr))
+        return false;
+
+    infalliblePush(resultType);
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readStore(ValType resultType, uint32_t byteSize, LinearMemoryAddress<Value>* addr,
+                          Value* value)
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::Store);
+
+    if (!popWithType(resultType, value))
+        return false;
+
+    if (!readLinearMemoryAddress(byteSize, addr))
+        return false;
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readTeeStore(ValType resultType, uint32_t byteSize, LinearMemoryAddress<Value>* addr,
+                             Value* value)
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::TeeStore);
+
+    if (!popWithType(resultType, value))
+        return false;
+
+    if (!readLinearMemoryAddress(byteSize, addr))
+        return false;
+
+    infalliblePush(TypeAndValue<Value>(resultType, Output ? *value : Value()));
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readNop()
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::Nop);
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readCurrentMemory()
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::CurrentMemory);
+
+    uint32_t flags;
+    if (!readVarU32(&flags))
+        return false;
+
+    if (Validate && flags != uint32_t(MemoryTableFlags::Default))
+        return fail("unexpected flags");
+
+    if (!push(ValType::I32))
+        return false;
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readGrowMemory(Value* input)
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::GrowMemory);
+
+    uint32_t flags;
+    if (!readVarU32(&flags))
+        return false;
+
+    if (Validate && flags != uint32_t(MemoryTableFlags::Default))
+        return fail("unexpected flags");
+
+    if (!popWithType(ValType::I32, input))
+        return false;
+
+    infalliblePush(ValType::I32);
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readSelect(ValType* type, Value* trueValue, Value* falseValue, Value* condition)
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::Select);
+
+    if (!popWithType(ValType::I32, condition))
+        return false;
+
+    TypeAndValue<Value> false_;
+    if (!pop(&false_))
+        return false;
+
+    TypeAndValue<Value> true_;
+    if (!pop(&true_))
+        return false;
+
+    ValType resultType = true_.type();
+    if (Validate && resultType != false_.type())
+        return fail("select operand types must match");
+
+    infalliblePush(resultType);
+
+    if (Output) {
+        *type = resultType;
+        *trueValue = true_.value();
+        *falseValue = false_.value();
+    }
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readGetLocal(const ValTypeVector& locals, uint32_t* id)
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::GetLocal);
+
+    uint32_t validateId;
+    if (!readVarU32(&validateId))
+        return false;
+
+    if (Validate && validateId >= locals.length())
+        return fail("get_local index out of range");
+
+    if (!push(locals[validateId]))
+        return false;
+
+    if (Output)
+        *id = validateId;
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readSetLocal(const ValTypeVector& locals, uint32_t* id, Value* value)
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::SetLocal);
+
+    uint32_t validateId;
+    if (!readVarU32(&validateId))
+        return false;
+
+    if (Validate && validateId >= locals.length())
+        return fail("set_local index out of range");
+
+    if (!popWithType(locals[validateId], value))
+        return false;
+
+    if (Output)
+        *id = validateId;
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readTeeLocal(const ValTypeVector& locals, uint32_t* id, Value* value)
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::TeeLocal);
+
+    uint32_t validateId;
+    if (!readVarU32(&validateId))
+        return false;
+
+    if (Validate && validateId >= locals.length())
+        return fail("set_local index out of range");
+
+    if (!topWithType(locals[validateId], value))
+        return false;
+
+    if (Output)
+        *id = validateId;
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readGetGlobal(const GlobalDescVector& globals, uint32_t* id)
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::GetGlobal);
+
+    uint32_t validateId;
+    if (!readVarU32(&validateId))
+        return false;
+
+    if (Validate && validateId >= globals.length())
+        return fail("get_global index out of range");
+
+    if (!push(globals[validateId].type()))
+        return false;
+
+    if (Output)
+        *id = validateId;
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readSetGlobal(const GlobalDescVector& globals, uint32_t* id, Value* value)
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::SetGlobal);
+
+    uint32_t validateId;
+    if (!readVarU32(&validateId))
+        return false;
+
+    if (Validate && validateId >= globals.length())
+        return fail("set_global index out of range");
+
+    if (Validate && !globals[validateId].isMutable())
+        return fail("can't write an immutable global");
+
+    if (!popWithType(globals[validateId].type(), value))
+        return false;
+
+    if (Output)
+        *id = validateId;
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readTeeGlobal(const GlobalDescVector& globals, uint32_t* id, Value* value)
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::TeeGlobal);
+
+    uint32_t validateId;
+    if (!readVarU32(&validateId))
+        return false;
+
+    if (Validate && validateId >= globals.length())
+        return fail("set_global index out of range");
+
+    if (Validate && !globals[validateId].isMutable())
+        return fail("can't write an immutable global");
+
+    if (!topWithType(globals[validateId].type(), value))
+        return false;
+
+    if (Output)
+        *id = validateId;
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readI32Const(int32_t* i32)
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::I32);
+
+    int32_t unused;
+    if (!readVarS32(Output ? i32 : &unused))
+        return false;
+
+    if (!push(ValType::I32))
+       return false;
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readI64Const(int64_t* i64)
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::I64);
+
+    int64_t unused;
+    if (!readVarS64(Output ? i64 : &unused))
+        return false;
+
+    if (!push(ValType::I64))
+        return false;
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readF32Const(RawF32* f32)
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::F32);
+
+    RawF32 unused;
+    if (!readFixedF32(Output ? f32 : &unused))
+        return false;
+
+    if (!push(ValType::F32))
+        return false;
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readF64Const(RawF64* f64)
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::F64);
+
+    RawF64 unused;
+    if (!readFixedF64(Output ? f64 : &unused))
+       return false;
+
+    if (!push(ValType::F64))
+        return false;
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readI8x16Const(I8x16* i8x16)
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::I8x16);
+
+    I8x16 unused;
+    if (!readFixedI8x16(Output ? i8x16 : &unused))
+        return false;
+
+    if (!push(ValType::I8x16))
+        return false;
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readI16x8Const(I16x8* i16x8)
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::I16x8);
+
+    I16x8 unused;
+    if (!readFixedI16x8(Output ? i16x8 : &unused))
+        return false;
+
+    if (!push(ValType::I16x8))
+        return false;
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readI32x4Const(I32x4* i32x4)
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::I32x4);
+
+    I32x4 unused;
+    if (!readFixedI32x4(Output ? i32x4 : &unused))
+        return false;
+
+    if (!push(ValType::I32x4))
+        return false;
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readF32x4Const(F32x4* f32x4)
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::F32x4);
+
+    F32x4 unused;
+    if (!readFixedF32x4(Output ? f32x4 : &unused))
+        return false;
+
+    if (!push(ValType::F32x4))
+        return false;
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readB8x16Const(I8x16* i8x16)
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::B8x16);
+
+    I8x16 unused;
+    if (!readFixedI8x16(Output ? i8x16 : &unused))
+        return false;
+
+    if (!push(ValType::B8x16))
+        return false;
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readB16x8Const(I16x8* i16x8)
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::B16x8);
+
+    I16x8 unused;
+    if (!readFixedI16x8(Output ? i16x8 : &unused))
+        return false;
+
+    if (!push(ValType::B16x8))
+        return false;
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readB32x4Const(I32x4* i32x4)
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::B32x4);
+
+    I32x4 unused;
+    if (!readFixedI32x4(Output ? i32x4 : &unused))
+        return false;
+
+    if (!push(ValType::B32x4))
+        return false;
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readCall(uint32_t* calleeIndex)
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::Call);
+
+    if (!readVarU32(calleeIndex))
+        return fail("unable to read call function index");
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readCallIndirect(uint32_t* sigIndex, Value* callee)
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::CallIndirect);
+
+    if (!readVarU32(sigIndex))
+        return fail("unable to read call_indirect signature index");
+
+    uint32_t flags;
+    if (!readVarU32(&flags))
+        return false;
+
+    if (Validate && flags != uint32_t(MemoryTableFlags::Default))
+        return fail("unexpected flags");
+
+    if (reachable_) {
+        if (!popWithType(ValType::I32, callee))
+            return false;
+    }
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readOldCallIndirect(uint32_t* sigIndex)
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::OldCallIndirect);
+
+    if (!readVarU32(sigIndex))
+        return fail("unable to read call_indirect signature index");
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readCallArg(ValType type, uint32_t numArgs, uint32_t argIndex, Value* arg)
+{
+    MOZ_ASSERT(reachable_);
+
+    TypeAndValue<Value> tv;
+
+    if (!peek(numArgs - argIndex, &tv))
+        return false;
+    if (!checkType(tv.type(), type))
+        return false;
+
+    if (Output)
+        *arg = tv.value();
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readCallArgsEnd(uint32_t numArgs)
+{
+    MOZ_ASSERT(reachable_);
+    MOZ_ASSERT(numArgs <= valueStack_.length());
+
+    valueStack_.shrinkBy(numArgs);
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readOldCallIndirectCallee(Value* callee)
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::OldCallIndirect);
+    MOZ_ASSERT(reachable_);
+
+    if (!popWithType(ValType::I32, callee))
+        return false;
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readCallReturn(ExprType ret)
+{
+    MOZ_ASSERT(reachable_);
+
+    if (!IsVoid(ret)) {
+        if (!push(NonVoidToValType(ret)))
+            return false;
+    }
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readAtomicLoad(LinearMemoryAddress<Value>* addr, Scalar::Type* viewType)
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::AtomicLoad);
+
+    Scalar::Type validateViewType;
+    if (!readAtomicViewType(&validateViewType))
+        return false;
+
+    uint32_t byteSize = Scalar::byteSize(validateViewType);
+    if (!readLinearMemoryAddress(byteSize, addr))
+        return false;
+
+    infalliblePush(ValType::I32);
+
+    if (Output)
+        *viewType = validateViewType;
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readAtomicStore(LinearMemoryAddress<Value>* addr, Scalar::Type* viewType,
+                                Value* value)
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::AtomicStore);
+
+    Scalar::Type validateViewType;
+    if (!readAtomicViewType(&validateViewType))
+        return false;
+
+    uint32_t byteSize = Scalar::byteSize(validateViewType);
+    if (!readLinearMemoryAddress(byteSize, addr))
+        return false;
+
+    if (!popWithType(ValType::I32, value))
+        return false;
+
+    infalliblePush(ValType::I32);
+
+    if (Output)
+        *viewType = validateViewType;
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readAtomicBinOp(LinearMemoryAddress<Value>* addr, Scalar::Type* viewType,
+                                jit::AtomicOp* op, Value* value)
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::AtomicBinOp);
+
+    Scalar::Type validateViewType;
+    if (!readAtomicViewType(&validateViewType))
+        return false;
+
+    if (!readAtomicBinOpOp(op))
+        return false;
+
+    uint32_t byteSize = Scalar::byteSize(validateViewType);
+    if (!readLinearMemoryAddress(byteSize, addr))
+        return false;
+
+    if (!popWithType(ValType::I32, value))
+        return false;
+
+    infalliblePush(ValType::I32);
+
+    if (Output)
+        *viewType = validateViewType;
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readAtomicCompareExchange(LinearMemoryAddress<Value>* addr, Scalar::Type* viewType,
+                                          Value* oldValue, Value* newValue)
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::AtomicCompareExchange);
+
+    Scalar::Type validateViewType;
+    if (!readAtomicViewType(&validateViewType))
+        return false;
+
+    uint32_t byteSize = Scalar::byteSize(validateViewType);
+    if (!readLinearMemoryAddress(byteSize, addr))
+        return false;
+
+    if (!popWithType(ValType::I32, newValue))
+        return false;
+
+    if (!popWithType(ValType::I32, oldValue))
+        return false;
+
+    infalliblePush(ValType::I32);
+
+    if (Output)
+        *viewType = validateViewType;
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readAtomicExchange(LinearMemoryAddress<Value>* addr, Scalar::Type* viewType,
+                                   Value* value)
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::AtomicExchange);
+
+    Scalar::Type validateViewType;
+    if (!readAtomicViewType(&validateViewType))
+        return false;
+
+    uint32_t byteSize = Scalar::byteSize(validateViewType);
+    if (!readLinearMemoryAddress(byteSize, addr))
+        return false;
+
+    if (!popWithType(ValType::I32, value))
+        return false;
+
+    infalliblePush(ValType::I32);
+
+    if (Output)
+        *viewType = validateViewType;
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readSimdComparison(ValType simdType, Value* lhs, Value* rhs)
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::SimdComparison);
+
+    if (!popWithType(simdType, rhs))
+        return false;
+
+    if (!popWithType(simdType, lhs))
+        return false;
+
+    infalliblePush(SimdBoolType(simdType));
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readSimdShiftByScalar(ValType simdType, Value* lhs, Value* rhs)
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::SimdShiftByScalar);
+
+    if (!popWithType(ValType::I32, rhs))
+        return false;
+
+    if (!popWithType(simdType, lhs))
+        return false;
+
+    infalliblePush(simdType);
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readSimdBooleanReduction(ValType simdType, Value* input)
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::SimdBooleanReduction);
+
+    if (!popWithType(simdType, input))
+        return false;
+
+    infalliblePush(ValType::I32);
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readExtractLane(ValType simdType, uint8_t* lane, Value* vector)
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::ExtractLane);
+
+    uint32_t laneBits;
+    if (!readVarU32(&laneBits))
+        return false;
+
+    if (Validate && laneBits >= NumSimdElements(simdType))
+        return fail("simd lane out of bounds for simd type");
+
+    if (!popWithType(simdType, vector))
+        return false;
+
+    infalliblePush(SimdElementType(simdType));
+
+    if (Output)
+        *lane = uint8_t(laneBits);
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readReplaceLane(ValType simdType, uint8_t* lane, Value* vector, Value* scalar)
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::ReplaceLane);
+
+    uint32_t laneBits;
+    if (!readVarU32(&laneBits))
+        return false;
+
+    if (Validate && laneBits >= NumSimdElements(simdType))
+        return fail("simd lane out of bounds for simd type");
+
+    if (!popWithType(SimdElementType(simdType), scalar))
+        return false;
+
+    if (!popWithType(simdType, vector))
+        return false;
+
+    infalliblePush(simdType);
+
+    if (Output)
+        *lane = uint8_t(laneBits);
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readSplat(ValType simdType, Value* scalar)
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::Splat);
+
+    if (!popWithType(SimdElementType(simdType), scalar))
+        return false;
+
+    infalliblePush(simdType);
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readSwizzle(ValType simdType, uint8_t (* lanes)[16], Value* vector)
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::Swizzle);
+
+    uint32_t numSimdLanes = NumSimdElements(simdType);
+    MOZ_ASSERT(numSimdLanes <= mozilla::ArrayLength(*lanes));
+    for (uint32_t i = 0; i < numSimdLanes; ++i) {
+        uint8_t validateLane;
+        if (!readFixedU8(Output ? &(*lanes)[i] : &validateLane))
+            return fail("unable to read swizzle lane");
+        if (Validate && (Output ? (*lanes)[i] : validateLane) >= numSimdLanes)
+            return fail("swizzle index out of bounds");
+    }
+
+    if (!popWithType(simdType, vector))
+        return false;
+
+    infalliblePush(simdType);
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readShuffle(ValType simdType, uint8_t (* lanes)[16], Value* lhs, Value* rhs)
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::Shuffle);
+
+    uint32_t numSimdLanes = NumSimdElements(simdType);
+    MOZ_ASSERT(numSimdLanes <= mozilla::ArrayLength(*lanes));
+    for (uint32_t i = 0; i < numSimdLanes; ++i) {
+        uint8_t validateLane;
+        if (!readFixedU8(Output ? &(*lanes)[i] : &validateLane))
+            return fail("unable to read shuffle lane");
+        if (Validate && (Output ? (*lanes)[i] : validateLane) >= numSimdLanes * 2)
+            return fail("shuffle index out of bounds");
+    }
+
+    if (!popWithType(simdType, rhs))
+        return false;
+
+    if (!popWithType(simdType, lhs))
+        return false;
+
+    infalliblePush(simdType);
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readSimdSelect(ValType simdType, Value* trueValue, Value* falseValue,
+                               Value* condition)
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::SimdSelect);
+
+    if (!popWithType(simdType, falseValue))
+        return false;
+    if (!popWithType(simdType, trueValue))
+        return false;
+    if (!popWithType(SimdBoolType(simdType), condition))
+        return false;
+
+    infalliblePush(simdType);
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readSimdCtor()
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::SimdCtor);
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readSimdCtorArg(ValType elementType, uint32_t numElements, uint32_t index,
+                                Value* arg)
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::SimdCtor);
+    MOZ_ASSERT(numElements > 0);
+
+    TypeAndValue<Value> tv;
+
+    if (!peek(numElements - index, &tv))
+        return false;
+    if (!checkType(tv.type(), elementType))
+        return false;
+
+    *arg = tv.value();
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readSimdCtorArgsEnd(uint32_t numElements)
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::SimdCtor);
+    MOZ_ASSERT(numElements <= valueStack_.length());
+
+    valueStack_.shrinkBy(numElements);
+
+    return true;
+}
+
+template <typename Policy>
+inline bool
+OpIter<Policy>::readSimdCtorReturn(ValType simdType)
+{
+    MOZ_ASSERT(Classify(op_) == OpKind::SimdCtor);
+
+    infalliblePush(simdType);
+
+    return true;
+}
+
+} // namespace wasm
+} // namespace js
+
+namespace mozilla {
+
+// Specialize IsPod for the Nothing specializations.
+template<> struct IsPod<js::wasm::TypeAndValue<Nothing>> : TrueType {};
+template<> struct IsPod<js::wasm::ControlStackEntry<Nothing>> : TrueType {};
+
+} // namespace mozilla
+
+#endif // wasm_iterator_h