Add m-esr52 at 52.6.0

1 files changed, 991 insertions, 0 deletions

diff --git a/js/src/jit/shared/Assembler-shared.h b/js/src/jit/shared/Assembler-shared.h
new file mode 100644
index 000000000..aac9687b8
--- /dev/null
+++ b/js/src/jit/shared/Assembler-shared.h
@@ -0,0 +1,991 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ * vim: set ts=8 sts=4 et sw=4 tw=99:
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef jit_shared_Assembler_shared_h
+#define jit_shared_Assembler_shared_h
+
+#include "mozilla/PodOperations.h"
+
+#include <limits.h>
+
+#include "jit/AtomicOp.h"
+#include "jit/JitAllocPolicy.h"
+#include "jit/Label.h"
+#include "jit/Registers.h"
+#include "jit/RegisterSets.h"
+#include "vm/HelperThreads.h"
+#include "wasm/WasmTypes.h"
+
+#if defined(JS_CODEGEN_ARM) || defined(JS_CODEGEN_ARM64) || \
+    defined(JS_CODEGEN_MIPS32) || defined(JS_CODEGEN_MIPS64)
+// Push return addresses callee-side.
+# define JS_USE_LINK_REGISTER
+#endif
+
+#if defined(JS_CODEGEN_X64) || defined(JS_CODEGEN_ARM) || defined(JS_CODEGEN_ARM64)
+// JS_SMALL_BRANCH means the range on a branch instruction
+// is smaller than the whole address space
+# define JS_SMALL_BRANCH
+#endif
+
+namespace js {
+namespace jit {
+
+namespace Disassembler {
+class HeapAccess;
+} // namespace Disassembler
+
+static const uint32_t Simd128DataSize = 4 * sizeof(int32_t);
+static_assert(Simd128DataSize == 4 * sizeof(int32_t), "SIMD data should be able to contain int32x4");
+static_assert(Simd128DataSize == 4 * sizeof(float), "SIMD data should be able to contain float32x4");
+static_assert(Simd128DataSize == 2 * sizeof(double), "SIMD data should be able to contain float64x2");
+
+enum Scale {
+    TimesOne = 0,
+    TimesTwo = 1,
+    TimesFour = 2,
+    TimesEight = 3
+};
+
+static_assert(sizeof(JS::Value) == 8,
+              "required for TimesEight and 3 below to be correct");
+static const Scale ValueScale = TimesEight;
+static const size_t ValueShift = 3;
+
+static inline unsigned
+ScaleToShift(Scale scale)
+{
+    return unsigned(scale);
+}
+
+static inline bool
+IsShiftInScaleRange(int i)
+{
+    return i >= TimesOne && i <= TimesEight;
+}
+
+static inline Scale
+ShiftToScale(int i)
+{
+    MOZ_ASSERT(IsShiftInScaleRange(i));
+    return Scale(i);
+}
+
+static inline Scale
+ScaleFromElemWidth(int shift)
+{
+    switch (shift) {
+      case 1:
+        return TimesOne;
+      case 2:
+        return TimesTwo;
+      case 4:
+        return TimesFour;
+      case 8:
+        return TimesEight;
+    }
+
+    MOZ_CRASH("Invalid scale");
+}
+
+// Used for 32-bit immediates which do not require relocation.
+struct Imm32
+{
+    int32_t value;
+
+    explicit Imm32(int32_t value) : value(value)
+    { }
+
+    static inline Imm32 ShiftOf(enum Scale s) {
+        switch (s) {
+          case TimesOne:
+            return Imm32(0);
+          case TimesTwo:
+            return Imm32(1);
+          case TimesFour:
+            return Imm32(2);
+          case TimesEight:
+            return Imm32(3);
+        };
+        MOZ_CRASH("Invalid scale");
+    }
+
+    static inline Imm32 FactorOf(enum Scale s) {
+        return Imm32(1 << ShiftOf(s).value);
+    }
+};
+
+// Pointer-sized integer to be embedded as an immediate in an instruction.
+struct ImmWord
+{
+    uintptr_t value;
+
+    explicit ImmWord(uintptr_t value) : value(value)
+    { }
+};
+
+// Used for 64-bit immediates which do not require relocation.
+struct Imm64
+{
+    uint64_t value;
+
+    explicit Imm64(int64_t value) : value(value)
+    { }
+
+    Imm32 low() const {
+        return Imm32(int32_t(value));
+    }
+
+    Imm32 hi() const {
+        return Imm32(int32_t(value >> 32));
+    }
+
+    inline Imm32 firstHalf() const;
+    inline Imm32 secondHalf() const;
+};
+
+#ifdef DEBUG
+static inline bool
+IsCompilingWasm()
+{
+    // wasm compilation pushes a JitContext with a null JSCompartment.
+    return GetJitContext()->compartment == nullptr;
+}
+#endif
+
+// Pointer to be embedded as an immediate in an instruction.
+struct ImmPtr
+{
+    void* value;
+
+    explicit ImmPtr(const void* value) : value(const_cast<void*>(value))
+    {
+        // To make code serialization-safe, wasm compilation should only
+        // compile pointer immediates using a SymbolicAddress.
+        MOZ_ASSERT(!IsCompilingWasm());
+    }
+
+    template <class R>
+    explicit ImmPtr(R (*pf)())
+      : value(JS_FUNC_TO_DATA_PTR(void*, pf))
+    {
+        MOZ_ASSERT(!IsCompilingWasm());
+    }
+
+    template <class R, class A1>
+    explicit ImmPtr(R (*pf)(A1))
+      : value(JS_FUNC_TO_DATA_PTR(void*, pf))
+    {
+        MOZ_ASSERT(!IsCompilingWasm());
+    }
+
+    template <class R, class A1, class A2>
+    explicit ImmPtr(R (*pf)(A1, A2))
+      : value(JS_FUNC_TO_DATA_PTR(void*, pf))
+    {
+        MOZ_ASSERT(!IsCompilingWasm());
+    }
+
+    template <class R, class A1, class A2, class A3>
+    explicit ImmPtr(R (*pf)(A1, A2, A3))
+      : value(JS_FUNC_TO_DATA_PTR(void*, pf))
+    {
+        MOZ_ASSERT(!IsCompilingWasm());
+    }
+
+    template <class R, class A1, class A2, class A3, class A4>
+    explicit ImmPtr(R (*pf)(A1, A2, A3, A4))
+      : value(JS_FUNC_TO_DATA_PTR(void*, pf))
+    {
+        MOZ_ASSERT(!IsCompilingWasm());
+    }
+
+};
+
+// The same as ImmPtr except that the intention is to patch this
+// instruction. The initial value of the immediate is 'addr' and this value is
+// either clobbered or used in the patching process.
+struct PatchedImmPtr {
+    void* value;
+
+    explicit PatchedImmPtr()
+      : value(nullptr)
+    { }
+    explicit PatchedImmPtr(const void* value)
+      : value(const_cast<void*>(value))
+    { }
+};
+
+class AssemblerShared;
+class ImmGCPtr;
+
+// Used for immediates which require relocation.
+class ImmGCPtr
+{
+  public:
+    const gc::Cell* value;
+
+    explicit ImmGCPtr(const gc::Cell* ptr) : value(ptr)
+    {
+        // Nursery pointers can't be used if the main thread might be currently
+        // performing a minor GC.
+        MOZ_ASSERT_IF(ptr && !ptr->isTenured(),
+                      !CurrentThreadIsIonCompilingSafeForMinorGC());
+
+        // wasm shouldn't be creating GC things
+        MOZ_ASSERT(!IsCompilingWasm());
+    }
+
+  private:
+    ImmGCPtr() : value(0) {}
+};
+
+// Pointer to be embedded as an immediate that is loaded/stored from by an
+// instruction.
+struct AbsoluteAddress
+{
+    void* addr;
+
+    explicit AbsoluteAddress(const void* addr)
+      : addr(const_cast<void*>(addr))
+    {
+        MOZ_ASSERT(!IsCompilingWasm());
+    }
+
+    AbsoluteAddress offset(ptrdiff_t delta) {
+        return AbsoluteAddress(((uint8_t*) addr) + delta);
+    }
+};
+
+// The same as AbsoluteAddress except that the intention is to patch this
+// instruction. The initial value of the immediate is 'addr' and this value is
+// either clobbered or used in the patching process.
+struct PatchedAbsoluteAddress
+{
+    void* addr;
+
+    explicit PatchedAbsoluteAddress()
+      : addr(nullptr)
+    { }
+    explicit PatchedAbsoluteAddress(const void* addr)
+      : addr(const_cast<void*>(addr))
+    { }
+    explicit PatchedAbsoluteAddress(uintptr_t addr)
+      : addr(reinterpret_cast<void*>(addr))
+    { }
+};
+
+// Specifies an address computed in the form of a register base and a constant,
+// 32-bit offset.
+struct Address
+{
+    Register base;
+    int32_t offset;
+
+    Address(Register base, int32_t offset) : base(base), offset(offset)
+    { }
+
+    Address() { mozilla::PodZero(this); }
+};
+
+// Specifies an address computed in the form of a register base, a register
+// index with a scale, and a constant, 32-bit offset.
+struct BaseIndex
+{
+    Register base;
+    Register index;
+    Scale scale;
+    int32_t offset;
+
+    BaseIndex(Register base, Register index, Scale scale, int32_t offset = 0)
+      : base(base), index(index), scale(scale), offset(offset)
+    { }
+
+    BaseIndex() { mozilla::PodZero(this); }
+};
+
+// A BaseIndex used to access Values.  Note that |offset| is *not* scaled by
+// sizeof(Value).  Use this *only* if you're indexing into a series of Values
+// that aren't object elements or object slots (for example, values on the
+// stack, values in an arguments object, &c.).  If you're indexing into an
+// object's elements or slots, don't use this directly!  Use
+// BaseObject{Element,Slot}Index instead.
+struct BaseValueIndex : BaseIndex
+{
+    BaseValueIndex(Register base, Register index, int32_t offset = 0)
+      : BaseIndex(base, index, ValueScale, offset)
+    { }
+};
+
+// Specifies the address of an indexed Value within object elements from a
+// base.  The index must not already be scaled by sizeof(Value)!
+struct BaseObjectElementIndex : BaseValueIndex
+{
+    BaseObjectElementIndex(Register base, Register index, int32_t offset = 0)
+      : BaseValueIndex(base, index, offset)
+    {
+        NativeObject::elementsSizeMustNotOverflow();
+    }
+};
+
+// Like BaseObjectElementIndex, except for object slots.
+struct BaseObjectSlotIndex : BaseValueIndex
+{
+    BaseObjectSlotIndex(Register base, Register index)
+      : BaseValueIndex(base, index)
+    {
+        NativeObject::slotsSizeMustNotOverflow();
+    }
+};
+
+class Relocation {
+  public:
+    enum Kind {
+        // The target is immovable, so patching is only needed if the source
+        // buffer is relocated and the reference is relative.
+        HARDCODED,
+
+        // The target is the start of a JitCode buffer, which must be traced
+        // during garbage collection. Relocations and patching may be needed.
+        JITCODE
+    };
+};
+
+class RepatchLabel
+{
+    static const int32_t INVALID_OFFSET = 0xC0000000;
+    int32_t offset_ : 31;
+    uint32_t bound_ : 1;
+  public:
+
+    RepatchLabel() : offset_(INVALID_OFFSET), bound_(0) {}
+
+    void use(uint32_t newOffset) {
+        MOZ_ASSERT(offset_ == INVALID_OFFSET);
+        MOZ_ASSERT(newOffset != (uint32_t)INVALID_OFFSET);
+        offset_ = newOffset;
+    }
+    bool bound() const {
+        return bound_;
+    }
+    void bind(int32_t dest) {
+        MOZ_ASSERT(!bound_);
+        MOZ_ASSERT(dest != INVALID_OFFSET);
+        offset_ = dest;
+        bound_ = true;
+    }
+    int32_t target() {
+        MOZ_ASSERT(bound());
+        int32_t ret = offset_;
+        offset_ = INVALID_OFFSET;
+        return ret;
+    }
+    int32_t offset() {
+        MOZ_ASSERT(!bound());
+        return offset_;
+    }
+    bool used() const {
+        return !bound() && offset_ != (INVALID_OFFSET);
+    }
+
+};
+// An absolute label is like a Label, except it represents an absolute
+// reference rather than a relative one. Thus, it cannot be patched until after
+// linking.
+struct AbsoluteLabel : public LabelBase
+{
+  public:
+    AbsoluteLabel()
+    { }
+    AbsoluteLabel(const AbsoluteLabel& label) : LabelBase(label)
+    { }
+    int32_t prev() const {
+        MOZ_ASSERT(!bound());
+        if (!used())
+            return INVALID_OFFSET;
+        return offset();
+    }
+    void setPrev(int32_t offset) {
+        use(offset);
+    }
+    void bind() {
+        bound_ = true;
+
+        // These labels cannot be used after being bound.
+        offset_ = -1;
+    }
+};
+
+class CodeOffset
+{
+    size_t offset_;
+
+    static const size_t NOT_BOUND = size_t(-1);
+
+  public:
+    explicit CodeOffset(size_t offset) : offset_(offset) {}
+    CodeOffset() : offset_(NOT_BOUND) {}
+
+    size_t offset() const {
+        MOZ_ASSERT(bound());
+        return offset_;
+    }
+
+    void bind(size_t offset) {
+        MOZ_ASSERT(!bound());
+        offset_ = offset;
+        MOZ_ASSERT(bound());
+    }
+    bool bound() const {
+        return offset_ != NOT_BOUND;
+    }
+
+    void offsetBy(size_t delta) {
+        MOZ_ASSERT(bound());
+        MOZ_ASSERT(offset_ + delta >= offset_, "no overflow");
+        offset_ += delta;
+    }
+};
+
+// A code label contains an absolute reference to a point in the code. Thus, it
+// cannot be patched until after linking.
+// When the source label is resolved into a memory address, this address is
+// patched into the destination address.
+class CodeLabel
+{
+    // The destination position, where the absolute reference should get
+    // patched into.
+    CodeOffset patchAt_;
+
+    // The source label (relative) in the code to where the destination should
+    // get patched to.
+    CodeOffset target_;
+
+  public:
+    CodeLabel()
+    { }
+    explicit CodeLabel(const CodeOffset& patchAt)
+      : patchAt_(patchAt)
+    { }
+    CodeLabel(const CodeOffset& patchAt, const CodeOffset& target)
+      : patchAt_(patchAt),
+        target_(target)
+    { }
+    CodeOffset* patchAt() {
+        return &patchAt_;
+    }
+    CodeOffset* target() {
+        return &target_;
+    }
+    void offsetBy(size_t delta) {
+        patchAt_.offsetBy(delta);
+        target_.offsetBy(delta);
+    }
+};
+
+// Location of a jump or label in a generated JitCode block, relative to the
+// start of the block.
+
+class CodeOffsetJump
+{
+    size_t offset_;
+
+#ifdef JS_SMALL_BRANCH
+    size_t jumpTableIndex_;
+#endif
+
+  public:
+
+#ifdef JS_SMALL_BRANCH
+    CodeOffsetJump(size_t offset, size_t jumpTableIndex)
+        : offset_(offset), jumpTableIndex_(jumpTableIndex)
+    {}
+    size_t jumpTableIndex() const {
+        return jumpTableIndex_;
+    }
+#else
+    explicit CodeOffsetJump(size_t offset) : offset_(offset) {}
+#endif
+
+    CodeOffsetJump() {
+        mozilla::PodZero(this);
+    }
+
+    size_t offset() const {
+        return offset_;
+    }
+    void fixup(MacroAssembler* masm);
+};
+
+// Absolute location of a jump or a label in some generated JitCode block.
+// Can also encode a CodeOffset{Jump,Label}, such that the offset is initially
+// set and the absolute location later filled in after the final JitCode is
+// allocated.
+
+class CodeLocationJump
+{
+    uint8_t* raw_;
+#ifdef DEBUG
+    enum State { Uninitialized, Absolute, Relative };
+    State state_;
+    void setUninitialized() {
+        state_ = Uninitialized;
+    }
+    void setAbsolute() {
+        state_ = Absolute;
+    }
+    void setRelative() {
+        state_ = Relative;
+    }
+#else
+    void setUninitialized() const {
+    }
+    void setAbsolute() const {
+    }
+    void setRelative() const {
+    }
+#endif
+
+#ifdef JS_SMALL_BRANCH
+    uint8_t* jumpTableEntry_;
+#endif
+
+  public:
+    CodeLocationJump() {
+        raw_ = nullptr;
+        setUninitialized();
+#ifdef JS_SMALL_BRANCH
+        jumpTableEntry_ = (uint8_t*) uintptr_t(0xdeadab1e);
+#endif
+    }
+    CodeLocationJump(JitCode* code, CodeOffsetJump base) {
+        *this = base;
+        repoint(code);
+    }
+
+    void operator = (CodeOffsetJump base) {
+        raw_ = (uint8_t*) base.offset();
+        setRelative();
+#ifdef JS_SMALL_BRANCH
+        jumpTableEntry_ = (uint8_t*) base.jumpTableIndex();
+#endif
+    }
+
+    void repoint(JitCode* code, MacroAssembler* masm = nullptr);
+
+    uint8_t* raw() const {
+        MOZ_ASSERT(state_ == Absolute);
+        return raw_;
+    }
+    uint8_t* offset() const {
+        MOZ_ASSERT(state_ == Relative);
+        return raw_;
+    }
+
+#ifdef JS_SMALL_BRANCH
+    uint8_t* jumpTableEntry() const {
+        MOZ_ASSERT(state_ == Absolute);
+        return jumpTableEntry_;
+    }
+#endif
+};
+
+class CodeLocationLabel
+{
+    uint8_t* raw_;
+#ifdef DEBUG
+    enum State { Uninitialized, Absolute, Relative };
+    State state_;
+    void setUninitialized() {
+        state_ = Uninitialized;
+    }
+    void setAbsolute() {
+        state_ = Absolute;
+    }
+    void setRelative() {
+        state_ = Relative;
+    }
+#else
+    void setUninitialized() const {
+    }
+    void setAbsolute() const {
+    }
+    void setRelative() const {
+    }
+#endif
+
+  public:
+    CodeLocationLabel() {
+        raw_ = nullptr;
+        setUninitialized();
+    }
+    CodeLocationLabel(JitCode* code, CodeOffset base) {
+        *this = base;
+        repoint(code);
+    }
+    explicit CodeLocationLabel(JitCode* code) {
+        raw_ = code->raw();
+        setAbsolute();
+    }
+    explicit CodeLocationLabel(uint8_t* raw) {
+        raw_ = raw;
+        setAbsolute();
+    }
+
+    void operator = (CodeOffset base) {
+        raw_ = (uint8_t*)base.offset();
+        setRelative();
+    }
+    ptrdiff_t operator - (const CodeLocationLabel& other) {
+        return raw_ - other.raw_;
+    }
+
+    void repoint(JitCode* code, MacroAssembler* masm = nullptr);
+
+#ifdef DEBUG
+    bool isSet() const {
+        return state_ != Uninitialized;
+    }
+#endif
+
+    uint8_t* raw() const {
+        MOZ_ASSERT(state_ == Absolute);
+        return raw_;
+    }
+    uint8_t* offset() const {
+        MOZ_ASSERT(state_ == Relative);
+        return raw_;
+    }
+};
+
+} // namespace jit
+
+namespace wasm {
+
+// As an invariant across architectures, within wasm code:
+//   $sp % WasmStackAlignment = (sizeof(wasm::Frame) + masm.framePushed) % WasmStackAlignment
+// Thus, wasm::Frame represents the bytes pushed after the call (which occurred
+// with a WasmStackAlignment-aligned StackPointer) that are not included in
+// masm.framePushed.
+
+struct Frame
+{
+    // The caller's saved frame pointer. In non-profiling mode, internal
+    // wasm-to-wasm calls don't update fp and thus don't save the caller's
+    // frame pointer; the space is reserved, however, so that profiling mode can
+    // reuse the same function body without recompiling.
+    uint8_t* callerFP;
+
+    // The return address pushed by the call (in the case of ARM/MIPS the return
+    // address is pushed by the first instruction of the prologue).
+    void* returnAddress;
+};
+
+static_assert(sizeof(Frame) == 2 * sizeof(void*), "?!");
+static const uint32_t FrameBytesAfterReturnAddress = sizeof(void*);
+
+// Represents an instruction to be patched and the intended pointee. These
+// links are accumulated in the MacroAssembler, but patching is done outside
+// the MacroAssembler (in Module::staticallyLink).
+
+struct SymbolicAccess
+{
+    SymbolicAccess(jit::CodeOffset patchAt, SymbolicAddress target)
+      : patchAt(patchAt), target(target) {}
+
+    jit::CodeOffset patchAt;
+    SymbolicAddress target;
+};
+
+typedef Vector<SymbolicAccess, 0, SystemAllocPolicy> SymbolicAccessVector;
+
+// Describes a single wasm or asm.js memory access for the purpose of generating
+// code and metadata.
+
+class MemoryAccessDesc
+{
+    uint32_t offset_;
+    uint32_t align_;
+    Scalar::Type type_;
+    unsigned numSimdElems_;
+    jit::MemoryBarrierBits barrierBefore_;
+    jit::MemoryBarrierBits barrierAfter_;
+    mozilla::Maybe<wasm::TrapOffset> trapOffset_;
+
+  public:
+    explicit MemoryAccessDesc(Scalar::Type type, uint32_t align, uint32_t offset,
+                              mozilla::Maybe<TrapOffset> trapOffset,
+                              unsigned numSimdElems = 0,
+                              jit::MemoryBarrierBits barrierBefore = jit::MembarNobits,
+                              jit::MemoryBarrierBits barrierAfter = jit::MembarNobits)
+      : offset_(offset),
+        align_(align),
+        type_(type),
+        numSimdElems_(numSimdElems),
+        barrierBefore_(barrierBefore),
+        barrierAfter_(barrierAfter),
+        trapOffset_(trapOffset)
+    {
+        MOZ_ASSERT(Scalar::isSimdType(type) == (numSimdElems > 0));
+        MOZ_ASSERT(numSimdElems <= jit::ScalarTypeToLength(type));
+        MOZ_ASSERT(mozilla::IsPowerOfTwo(align));
+        MOZ_ASSERT_IF(isSimd(), hasTrap());
+        MOZ_ASSERT_IF(isAtomic(), hasTrap());
+    }
+
+    uint32_t offset() const { return offset_; }
+    uint32_t align() const { return align_; }
+    Scalar::Type type() const { return type_; }
+    unsigned byteSize() const {
+        return Scalar::isSimdType(type())
+               ? Scalar::scalarByteSize(type()) * numSimdElems()
+               : Scalar::byteSize(type());
+    }
+    unsigned numSimdElems() const { MOZ_ASSERT(isSimd()); return numSimdElems_; }
+    jit::MemoryBarrierBits barrierBefore() const { return barrierBefore_; }
+    jit::MemoryBarrierBits barrierAfter() const { return barrierAfter_; }
+    bool hasTrap() const { return !!trapOffset_; }
+    TrapOffset trapOffset() const { return *trapOffset_; }
+    bool isAtomic() const { return (barrierBefore_ | barrierAfter_) != jit::MembarNobits; }
+    bool isSimd() const { return Scalar::isSimdType(type_); }
+    bool isUnaligned() const { return align() && align() < byteSize(); }
+    bool isPlainAsmJS() const { return !hasTrap(); }
+
+    void clearOffset() { offset_ = 0; }
+};
+
+// Summarizes a global access for a mutable (in asm.js) or immutable value (in
+// asm.js or the wasm MVP) that needs to get patched later.
+
+struct GlobalAccess
+{
+    GlobalAccess(jit::CodeOffset patchAt, unsigned globalDataOffset)
+      : patchAt(patchAt), globalDataOffset(globalDataOffset)
+    {}
+
+    jit::CodeOffset patchAt;
+    unsigned globalDataOffset;
+};
+
+typedef Vector<GlobalAccess, 0, SystemAllocPolicy> GlobalAccessVector;
+
+// The TrapDesc struct describes a wasm trap that is about to be emitted. This
+// includes the logical wasm bytecode offset to report, the kind of instruction
+// causing the trap, and the stack depth right before control is transferred to
+// the trap out-of-line path.
+
+struct TrapDesc : TrapOffset
+{
+    enum Kind { Jump, MemoryAccess };
+    Kind kind;
+    Trap trap;
+    uint32_t framePushed;
+
+    TrapDesc(TrapOffset offset, Trap trap, uint32_t framePushed, Kind kind = Jump)
+      : TrapOffset(offset), kind(kind), trap(trap), framePushed(framePushed)
+    {}
+};
+
+// A TrapSite captures all relevant information at the point of emitting the
+// in-line trapping instruction for the purpose of generating the out-of-line
+// trap code (at the end of the function).
+
+struct TrapSite : TrapDesc
+{
+    uint32_t codeOffset;
+
+    TrapSite(TrapDesc trap, uint32_t codeOffset)
+      : TrapDesc(trap), codeOffset(codeOffset)
+    {}
+};
+
+typedef Vector<TrapSite, 0, SystemAllocPolicy> TrapSiteVector;
+
+// A TrapFarJump records the offset of a jump that needs to be patched to a trap
+// exit at the end of the module when trap exits are emitted.
+
+struct TrapFarJump
+{
+    Trap trap;
+    jit::CodeOffset jump;
+
+    TrapFarJump(Trap trap, jit::CodeOffset jump)
+      : trap(trap), jump(jump)
+    {}
+
+    void offsetBy(size_t delta) {
+        jump.offsetBy(delta);
+    }
+};
+
+typedef Vector<TrapFarJump, 0, SystemAllocPolicy> TrapFarJumpVector;
+
+} // namespace wasm
+
+namespace jit {
+
+// The base class of all Assemblers for all archs.
+class AssemblerShared
+{
+    wasm::CallSiteAndTargetVector callSites_;
+    wasm::TrapSiteVector trapSites_;
+    wasm::TrapFarJumpVector trapFarJumps_;
+    wasm::MemoryAccessVector memoryAccesses_;
+    wasm::MemoryPatchVector memoryPatches_;
+    wasm::BoundsCheckVector boundsChecks_;
+    wasm::GlobalAccessVector globalAccesses_;
+    wasm::SymbolicAccessVector symbolicAccesses_;
+
+  protected:
+    Vector<CodeLabel, 0, SystemAllocPolicy> codeLabels_;
+
+    bool enoughMemory_;
+    bool embedsNurseryPointers_;
+
+  public:
+    AssemblerShared()
+     : enoughMemory_(true),
+       embedsNurseryPointers_(false)
+    {}
+
+    void propagateOOM(bool success) {
+        enoughMemory_ &= success;
+    }
+
+    void setOOM() {
+        enoughMemory_ = false;
+    }
+
+    bool oom() const {
+        return !enoughMemory_;
+    }
+
+    bool embedsNurseryPointers() const {
+        return embedsNurseryPointers_;
+    }
+
+    template <typename... Args>
+    void append(const wasm::CallSiteDesc& desc, CodeOffset retAddr, size_t framePushed,
+                Args&&... args)
+    {
+        // framePushed does not include sizeof(wasm:Frame), so add it in explicitly when
+        // setting the CallSite::stackDepth.
+        wasm::CallSite cs(desc, retAddr.offset(), framePushed + sizeof(wasm::Frame));
+        enoughMemory_ &= callSites_.emplaceBack(cs, mozilla::Forward<Args>(args)...);
+    }
+    wasm::CallSiteAndTargetVector& callSites() { return callSites_; }
+
+    void append(wasm::TrapSite trapSite) {
+        enoughMemory_ &= trapSites_.append(trapSite);
+    }
+    const wasm::TrapSiteVector& trapSites() const { return trapSites_; }
+    void clearTrapSites() { trapSites_.clear(); }
+
+    void append(wasm::TrapFarJump jmp) {
+        enoughMemory_ &= trapFarJumps_.append(jmp);
+    }
+    const wasm::TrapFarJumpVector& trapFarJumps() const { return trapFarJumps_; }
+
+    void append(wasm::MemoryAccess access) { enoughMemory_ &= memoryAccesses_.append(access); }
+    wasm::MemoryAccessVector&& extractMemoryAccesses() { return Move(memoryAccesses_); }
+
+    void append(const wasm::MemoryAccessDesc& access, size_t codeOffset, size_t framePushed) {
+        if (access.hasTrap()) {
+            // If a memory access is trapping (wasm, SIMD.js, Atomics), create a
+            // TrapSite now which will generate a trap out-of-line path at the end
+            // of the function which will *then* append a MemoryAccess.
+            wasm::TrapDesc trap(access.trapOffset(), wasm::Trap::OutOfBounds, framePushed,
+                                wasm::TrapSite::MemoryAccess);
+            append(wasm::TrapSite(trap, codeOffset));
+        } else {
+            // Otherwise, this is a plain asm.js access. On WASM_HUGE_MEMORY
+            // platforms, asm.js uses signal handlers to remove bounds checks
+            // and thus requires a MemoryAccess.
+            MOZ_ASSERT(access.isPlainAsmJS());
+#ifdef WASM_HUGE_MEMORY
+            append(wasm::MemoryAccess(codeOffset));
+#endif
+        }
+    }
+
+    void append(wasm::MemoryPatch patch) { enoughMemory_ &= memoryPatches_.append(patch); }
+    wasm::MemoryPatchVector&& extractMemoryPatches() { return Move(memoryPatches_); }
+
+    void append(wasm::BoundsCheck check) { enoughMemory_ &= boundsChecks_.append(check); }
+    wasm::BoundsCheckVector&& extractBoundsChecks() { return Move(boundsChecks_); }
+
+    void append(wasm::GlobalAccess access) { enoughMemory_ &= globalAccesses_.append(access); }
+    const wasm::GlobalAccessVector& globalAccesses() const { return globalAccesses_; }
+
+    void append(wasm::SymbolicAccess access) { enoughMemory_ &= symbolicAccesses_.append(access); }
+    size_t numSymbolicAccesses() const { return symbolicAccesses_.length(); }
+    wasm::SymbolicAccess symbolicAccess(size_t i) const { return symbolicAccesses_[i]; }
+
+    static bool canUseInSingleByteInstruction(Register reg) { return true; }
+
+    void addCodeLabel(CodeLabel label) {
+        propagateOOM(codeLabels_.append(label));
+    }
+    size_t numCodeLabels() const {
+        return codeLabels_.length();
+    }
+    CodeLabel codeLabel(size_t i) {
+        return codeLabels_[i];
+    }
+
+    // Merge this assembler with the other one, invalidating it, by shifting all
+    // offsets by a delta.
+    bool asmMergeWith(size_t delta, const AssemblerShared& other) {
+        size_t i = callSites_.length();
+        enoughMemory_ &= callSites_.appendAll(other.callSites_);
+        for (; i < callSites_.length(); i++)
+            callSites_[i].offsetReturnAddressBy(delta);
+
+        MOZ_ASSERT(other.trapSites_.empty(), "should have been cleared by wasmEmitTrapOutOfLineCode");
+
+        i = trapFarJumps_.length();
+        enoughMemory_ &= trapFarJumps_.appendAll(other.trapFarJumps_);
+        for (; i < trapFarJumps_.length(); i++)
+            trapFarJumps_[i].offsetBy(delta);
+
+        i = memoryAccesses_.length();
+        enoughMemory_ &= memoryAccesses_.appendAll(other.memoryAccesses_);
+        for (; i < memoryAccesses_.length(); i++)
+            memoryAccesses_[i].offsetBy(delta);
+
+        i = memoryPatches_.length();
+        enoughMemory_ &= memoryPatches_.appendAll(other.memoryPatches_);
+        for (; i < memoryPatches_.length(); i++)
+            memoryPatches_[i].offsetBy(delta);
+
+        i = boundsChecks_.length();
+        enoughMemory_ &= boundsChecks_.appendAll(other.boundsChecks_);
+        for (; i < boundsChecks_.length(); i++)
+            boundsChecks_[i].offsetBy(delta);
+
+        i = globalAccesses_.length();
+        enoughMemory_ &= globalAccesses_.appendAll(other.globalAccesses_);
+        for (; i < globalAccesses_.length(); i++)
+            globalAccesses_[i].patchAt.offsetBy(delta);
+
+        i = symbolicAccesses_.length();
+        enoughMemory_ &= symbolicAccesses_.appendAll(other.symbolicAccesses_);
+        for (; i < symbolicAccesses_.length(); i++)
+            symbolicAccesses_[i].patchAt.offsetBy(delta);
+
+        i = codeLabels_.length();
+        enoughMemory_ &= codeLabels_.appendAll(other.codeLabels_);
+        for (; i < codeLabels_.length(); i++)
+            codeLabels_[i].offsetBy(delta);
+
+        return !oom();
+    }
+};
+
+} // namespace jit
+} // namespace js
+
+#endif /* jit_shared_Assembler_shared_h */