Add m-esr52 at 52.6.0

1 files changed, 731 insertions, 0 deletions

diff --git a/js/src/jit/Snapshots.cpp b/js/src/jit/Snapshots.cpp
new file mode 100644
index 000000000..9923e41fc
--- /dev/null
+++ b/js/src/jit/Snapshots.cpp
@@ -0,0 +1,731 @@
+/* -*- 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/. */
+
+#include "jit/Snapshots.h"
+
+#include "jsscript.h"
+
+#include "jit/CompileInfo.h"
+#include "jit/JitSpewer.h"
+#ifdef TRACK_SNAPSHOTS
+# include "jit/LIR.h"
+#endif
+#include "jit/MIR.h"
+#include "jit/Recover.h"
+
+#include "vm/Printer.h"
+
+using namespace js;
+using namespace js::jit;
+
+// Encodings:
+//   [ptr] A fixed-size pointer.
+//   [vwu] A variable-width unsigned integer.
+//   [vws] A variable-width signed integer.
+//    [u8] An 8-bit unsigned integer.
+//   [u8'] An 8-bit unsigned integer which is potentially extended with packed
+//         data.
+//   [u8"] Packed data which is stored and packed in the previous [u8'].
+//  [vwu*] A list of variable-width unsigned integers.
+//   [pld] Payload of Recover Value Allocation:
+//         PAYLOAD_NONE:
+//           There is no payload.
+//
+//         PAYLOAD_INDEX:
+//           [vwu] Index, such as the constant pool index.
+//
+//         PAYLOAD_STACK_OFFSET:
+//           [vws] Stack offset based on the base of the Ion frame.
+//
+//         PAYLOAD_GPR:
+//            [u8] Code of the general register.
+//
+//         PAYLOAD_FPU:
+//            [u8] Code of the FPU register.
+//
+//         PAYLOAD_PACKED_TAG:
+//           [u8"] Bits 5-7: JSValueType is encoded on the low bits of the Mode
+//                           of the RValueAllocation.
+//
+// Snapshot header:
+//
+//   [vwu] bits ((n+1)-31]: recover instruction offset
+//         bits [0,n): bailout kind (n = SNAPSHOT_BAILOUTKIND_BITS)
+//
+// Snapshot body, repeated "frame count" times, from oldest frame to newest frame.
+// Note that the first frame doesn't have the "parent PC" field.
+//
+//   [ptr] Debug only: JSScript*
+//   [vwu] pc offset
+//   [vwu] # of RVA's indexes, including nargs
+//  [vwu*] List of indexes to R(ecover)ValueAllocation table. Contains
+//         nargs + nfixed + stackDepth items.
+//
+// Recover value allocations are encoded at the end of the Snapshot buffer, and
+// they are padded on ALLOCATION_TABLE_ALIGNMENT.  The encoding of each
+// allocation is determined by the RValueAllocation::Layout, which can be
+// obtained from the RValueAllocation::Mode with layoutFromMode function.  The
+// layout structure list the type of payload which are used to serialized /
+// deserialized / dumped the content of the allocations.
+//
+// R(ecover)ValueAllocation items:
+//   [u8'] Mode, which defines the type of the payload as well as the
+//         interpretation.
+//   [pld] first payload (packed tag, index, stack offset, register, ...)
+//   [pld] second payload (register, stack offset, none)
+//
+//       Modes:
+//         CONSTANT [INDEX]
+//           Index into the constant pool.
+//
+//         CST_UNDEFINED []
+//           Constant value which correspond to the "undefined" JS value.
+//
+//         CST_NULL []
+//           Constant value which correspond to the "null" JS value.
+//
+//         DOUBLE_REG [FPU_REG]
+//           Double value stored in a FPU register.
+//
+//         ANY_FLOAT_REG [FPU_REG]
+//           Any Float value (float32, simd) stored in a FPU register.
+//
+//         ANY_FLOAT_STACK [STACK_OFFSET]
+//           Any Float value (float32, simd) stored on the stack.
+//
+//         UNTYPED_REG   [GPR_REG]
+//         UNTYPED_STACK [STACK_OFFSET]
+//         UNTYPED_REG_REG     [GPR_REG,      GPR_REG]
+//         UNTYPED_REG_STACK   [GPR_REG,      STACK_OFFSET]
+//         UNTYPED_STACK_REG   [STACK_OFFSET, GPR_REG]
+//         UNTYPED_STACK_STACK [STACK_OFFSET, STACK_OFFSET]
+//           Value with dynamically known type. On 32 bits architecture, the
+//           first register/stack-offset correspond to the holder of the type,
+//           and the second correspond to the payload of the JS Value.
+//
+//         RECOVER_INSTRUCTION [INDEX]
+//           Index into the list of recovered instruction results.
+//
+//         RI_WITH_DEFAULT_CST [INDEX] [INDEX]
+//           The first payload is the index into the list of recovered
+//           instruction results.  The second payload is the index in the
+//           constant pool.
+//
+//         TYPED_REG [PACKED_TAG, GPR_REG]:
+//           Value with statically known type, which payload is stored in a
+//           register.
+//
+//         TYPED_STACK [PACKED_TAG, STACK_OFFSET]:
+//           Value with statically known type, which payload is stored at an
+//           offset on the stack.
+//
+
+const RValueAllocation::Layout&
+RValueAllocation::layoutFromMode(Mode mode)
+{
+    switch (mode) {
+      case CONSTANT: {
+        static const RValueAllocation::Layout layout = {
+            PAYLOAD_INDEX,
+            PAYLOAD_NONE,
+            "constant"
+        };
+        return layout;
+      }
+
+      case CST_UNDEFINED: {
+        static const RValueAllocation::Layout layout = {
+            PAYLOAD_NONE,
+            PAYLOAD_NONE,
+            "undefined"
+        };
+        return layout;
+      }
+
+      case CST_NULL: {
+        static const RValueAllocation::Layout layout = {
+            PAYLOAD_NONE,
+            PAYLOAD_NONE,
+            "null"
+        };
+        return layout;
+      }
+
+      case DOUBLE_REG: {
+        static const RValueAllocation::Layout layout = {
+            PAYLOAD_FPU,
+            PAYLOAD_NONE,
+            "double"
+        };
+        return layout;
+      }
+      case ANY_FLOAT_REG: {
+        static const RValueAllocation::Layout layout = {
+            PAYLOAD_FPU,
+            PAYLOAD_NONE,
+            "float register content"
+        };
+        return layout;
+      }
+      case ANY_FLOAT_STACK: {
+        static const RValueAllocation::Layout layout = {
+            PAYLOAD_STACK_OFFSET,
+            PAYLOAD_NONE,
+            "float register content"
+        };
+        return layout;
+      }
+#if defined(JS_NUNBOX32)
+      case UNTYPED_REG_REG: {
+        static const RValueAllocation::Layout layout = {
+            PAYLOAD_GPR,
+            PAYLOAD_GPR,
+            "value"
+        };
+        return layout;
+      }
+      case UNTYPED_REG_STACK: {
+        static const RValueAllocation::Layout layout = {
+            PAYLOAD_GPR,
+            PAYLOAD_STACK_OFFSET,
+            "value"
+        };
+        return layout;
+      }
+      case UNTYPED_STACK_REG: {
+        static const RValueAllocation::Layout layout = {
+            PAYLOAD_STACK_OFFSET,
+            PAYLOAD_GPR,
+            "value"
+        };
+        return layout;
+      }
+      case UNTYPED_STACK_STACK: {
+        static const RValueAllocation::Layout layout = {
+            PAYLOAD_STACK_OFFSET,
+            PAYLOAD_STACK_OFFSET,
+            "value"
+        };
+        return layout;
+      }
+#elif defined(JS_PUNBOX64)
+      case UNTYPED_REG: {
+        static const RValueAllocation::Layout layout = {
+            PAYLOAD_GPR,
+            PAYLOAD_NONE,
+            "value"
+        };
+        return layout;
+      }
+      case UNTYPED_STACK: {
+        static const RValueAllocation::Layout layout = {
+            PAYLOAD_STACK_OFFSET,
+            PAYLOAD_NONE,
+            "value"
+        };
+        return layout;
+      }
+#endif
+      case RECOVER_INSTRUCTION: {
+        static const RValueAllocation::Layout layout = {
+            PAYLOAD_INDEX,
+            PAYLOAD_NONE,
+            "instruction"
+        };
+        return layout;
+      }
+      case RI_WITH_DEFAULT_CST: {
+        static const RValueAllocation::Layout layout = {
+            PAYLOAD_INDEX,
+            PAYLOAD_INDEX,
+            "instruction with default"
+        };
+        return layout;
+      }
+
+      default: {
+        static const RValueAllocation::Layout regLayout = {
+            PAYLOAD_PACKED_TAG,
+            PAYLOAD_GPR,
+            "typed value"
+        };
+
+        static const RValueAllocation::Layout stackLayout = {
+            PAYLOAD_PACKED_TAG,
+            PAYLOAD_STACK_OFFSET,
+            "typed value"
+        };
+
+        if (mode >= TYPED_REG_MIN && mode <= TYPED_REG_MAX)
+            return regLayout;
+        if (mode >= TYPED_STACK_MIN && mode <= TYPED_STACK_MAX)
+            return stackLayout;
+      }
+    }
+
+    MOZ_CRASH("Wrong mode type?");
+}
+
+// Pad serialized RValueAllocations by a multiple of X bytes in the allocation
+// buffer.  By padding serialized value allocations, we are building an
+// indexable table of elements of X bytes, and thus we can safely divide any
+// offset within the buffer by X to obtain an index.
+//
+// By padding, we are loosing space within the allocation buffer, but we
+// multiple by X the number of indexes that we can store on one byte in each
+// snapshots.
+//
+// Some value allocations are taking more than X bytes to be encoded, in which
+// case we will pad to a multiple of X, and we are wasting indexes. The choice
+// of X should be balanced between the wasted padding of serialized value
+// allocation, and the saving made in snapshot indexes.
+static const size_t ALLOCATION_TABLE_ALIGNMENT = 2; /* bytes */
+
+void
+RValueAllocation::readPayload(CompactBufferReader& reader, PayloadType type,
+                              uint8_t* mode, Payload* p)
+{
+    switch (type) {
+      case PAYLOAD_NONE:
+        break;
+      case PAYLOAD_INDEX:
+        p->index = reader.readUnsigned();
+        break;
+      case PAYLOAD_STACK_OFFSET:
+        p->stackOffset = reader.readSigned();
+        break;
+      case PAYLOAD_GPR:
+        p->gpr = Register::FromCode(reader.readByte());
+        break;
+      case PAYLOAD_FPU:
+        p->fpu.data = reader.readByte();
+        break;
+      case PAYLOAD_PACKED_TAG:
+        p->type = JSValueType(*mode & PACKED_TAG_MASK);
+        *mode = *mode & ~PACKED_TAG_MASK;
+        break;
+    }
+}
+
+RValueAllocation
+RValueAllocation::read(CompactBufferReader& reader)
+{
+    uint8_t mode = reader.readByte();
+    const Layout& layout = layoutFromMode(Mode(mode & MODE_BITS_MASK));
+    Payload arg1, arg2;
+
+    readPayload(reader, layout.type1, &mode, &arg1);
+    readPayload(reader, layout.type2, &mode, &arg2);
+    return RValueAllocation(Mode(mode), arg1, arg2);
+}
+
+void
+RValueAllocation::writePayload(CompactBufferWriter& writer, PayloadType type, Payload p)
+{
+    switch (type) {
+      case PAYLOAD_NONE:
+        break;
+      case PAYLOAD_INDEX:
+        writer.writeUnsigned(p.index);
+        break;
+      case PAYLOAD_STACK_OFFSET:
+        writer.writeSigned(p.stackOffset);
+        break;
+      case PAYLOAD_GPR:
+        static_assert(Registers::Total <= 0x100,
+                      "Not enough bytes to encode all registers.");
+        writer.writeByte(p.gpr.code());
+        break;
+      case PAYLOAD_FPU:
+        static_assert(FloatRegisters::Total <= 0x100,
+                      "Not enough bytes to encode all float registers.");
+        writer.writeByte(p.fpu.code());
+        break;
+      case PAYLOAD_PACKED_TAG: {
+        // This code assumes that the PACKED_TAG payload is following the
+        // writeByte of the mode.
+        if (!writer.oom()) {
+            MOZ_ASSERT(writer.length());
+            uint8_t* mode = writer.buffer() + (writer.length() - 1);
+            MOZ_ASSERT((*mode & PACKED_TAG_MASK) == 0 && (p.type & ~PACKED_TAG_MASK) == 0);
+            *mode = *mode | p.type;
+        }
+        break;
+      }
+    }
+}
+
+void
+RValueAllocation::writePadding(CompactBufferWriter& writer)
+{
+    // Write 0x7f in all padding bytes.
+    while (writer.length() % ALLOCATION_TABLE_ALIGNMENT)
+        writer.writeByte(0x7f);
+}
+
+void
+RValueAllocation::write(CompactBufferWriter& writer) const
+{
+    const Layout& layout = layoutFromMode(mode());
+    MOZ_ASSERT(layout.type2 != PAYLOAD_PACKED_TAG);
+    MOZ_ASSERT(writer.length() % ALLOCATION_TABLE_ALIGNMENT == 0);
+
+    writer.writeByte(mode_);
+    writePayload(writer, layout.type1, arg1_);
+    writePayload(writer, layout.type2, arg2_);
+    writePadding(writer);
+}
+
+HashNumber
+RValueAllocation::hash() const {
+    CompactBufferWriter writer;
+    write(writer);
+
+    // We should never oom because the compact buffer writer has 32 inlined
+    // bytes, and in the worse case scenario, only encode 12 bytes
+    // (12 == mode + signed + signed + pad).
+    MOZ_ASSERT(!writer.oom());
+    MOZ_ASSERT(writer.length() <= 12);
+
+    HashNumber res = 0;
+    for (size_t i = 0; i < writer.length(); i++) {
+        res = ((res << 8) | (res >> (sizeof(res) - 1)));
+        res ^= writer.buffer()[i];
+    }
+    return res;
+}
+
+static const char*
+ValTypeToString(JSValueType type)
+{
+    switch (type) {
+      case JSVAL_TYPE_INT32:
+        return "int32_t";
+      case JSVAL_TYPE_DOUBLE:
+        return "double";
+      case JSVAL_TYPE_STRING:
+        return "string";
+      case JSVAL_TYPE_SYMBOL:
+        return "symbol";
+      case JSVAL_TYPE_BOOLEAN:
+        return "boolean";
+      case JSVAL_TYPE_OBJECT:
+        return "object";
+      case JSVAL_TYPE_MAGIC:
+        return "magic";
+      default:
+        MOZ_CRASH("no payload");
+    }
+}
+
+void
+RValueAllocation::dumpPayload(GenericPrinter& out, PayloadType type, Payload p)
+{
+    switch (type) {
+      case PAYLOAD_NONE:
+        break;
+      case PAYLOAD_INDEX:
+        out.printf("index %u", p.index);
+        break;
+      case PAYLOAD_STACK_OFFSET:
+        out.printf("stack %d", p.stackOffset);
+        break;
+      case PAYLOAD_GPR:
+        out.printf("reg %s", p.gpr.name());
+        break;
+      case PAYLOAD_FPU:
+        out.printf("reg %s", p.fpu.name());
+        break;
+      case PAYLOAD_PACKED_TAG:
+        out.printf("%s", ValTypeToString(p.type));
+        break;
+    }
+}
+
+void
+RValueAllocation::dump(GenericPrinter& out) const
+{
+    const Layout& layout = layoutFromMode(mode());
+    out.printf("%s", layout.name);
+
+    if (layout.type1 != PAYLOAD_NONE)
+        out.printf(" (");
+    dumpPayload(out, layout.type1, arg1_);
+    if (layout.type2 != PAYLOAD_NONE)
+        out.printf(", ");
+    dumpPayload(out, layout.type2, arg2_);
+    if (layout.type1 != PAYLOAD_NONE)
+        out.printf(")");
+}
+
+bool
+RValueAllocation::equalPayloads(PayloadType type, Payload lhs, Payload rhs)
+{
+    switch (type) {
+      case PAYLOAD_NONE:
+        return true;
+      case PAYLOAD_INDEX:
+        return lhs.index == rhs.index;
+      case PAYLOAD_STACK_OFFSET:
+        return lhs.stackOffset == rhs.stackOffset;
+      case PAYLOAD_GPR:
+        return lhs.gpr == rhs.gpr;
+      case PAYLOAD_FPU:
+        return lhs.fpu == rhs.fpu;
+      case PAYLOAD_PACKED_TAG:
+        return lhs.type == rhs.type;
+    }
+
+    return false;
+}
+
+SnapshotReader::SnapshotReader(const uint8_t* snapshots, uint32_t offset,
+                               uint32_t RVATableSize, uint32_t listSize)
+  : reader_(snapshots + offset, snapshots + listSize),
+    allocReader_(snapshots + listSize, snapshots + listSize + RVATableSize),
+    allocTable_(snapshots + listSize),
+    allocRead_(0)
+{
+    if (!snapshots)
+        return;
+    JitSpew(JitSpew_IonSnapshots, "Creating snapshot reader");
+    readSnapshotHeader();
+}
+
+#define COMPUTE_SHIFT_AFTER_(name) (name ## _BITS + name ##_SHIFT)
+#define COMPUTE_MASK_(name) ((uint32_t(1 << name ## _BITS) - 1) << name ##_SHIFT)
+
+// Details of snapshot header packing.
+static const uint32_t SNAPSHOT_BAILOUTKIND_SHIFT = 0;
+static const uint32_t SNAPSHOT_BAILOUTKIND_BITS = 6;
+static const uint32_t SNAPSHOT_BAILOUTKIND_MASK = COMPUTE_MASK_(SNAPSHOT_BAILOUTKIND);
+
+static const uint32_t SNAPSHOT_ROFFSET_SHIFT = COMPUTE_SHIFT_AFTER_(SNAPSHOT_BAILOUTKIND);
+static const uint32_t SNAPSHOT_ROFFSET_BITS = 32 - SNAPSHOT_ROFFSET_SHIFT;
+static const uint32_t SNAPSHOT_ROFFSET_MASK = COMPUTE_MASK_(SNAPSHOT_ROFFSET);
+
+// Details of recover header packing.
+static const uint32_t RECOVER_RESUMEAFTER_SHIFT = 0;
+static const uint32_t RECOVER_RESUMEAFTER_BITS = 1;
+static const uint32_t RECOVER_RESUMEAFTER_MASK = COMPUTE_MASK_(RECOVER_RESUMEAFTER);
+
+static const uint32_t RECOVER_RINSCOUNT_SHIFT = COMPUTE_SHIFT_AFTER_(RECOVER_RESUMEAFTER);
+static const uint32_t RECOVER_RINSCOUNT_BITS = 32 - RECOVER_RINSCOUNT_SHIFT;
+static const uint32_t RECOVER_RINSCOUNT_MASK = COMPUTE_MASK_(RECOVER_RINSCOUNT);
+
+#undef COMPUTE_MASK_
+#undef COMPUTE_SHIFT_AFTER_
+
+void
+SnapshotReader::readSnapshotHeader()
+{
+    uint32_t bits = reader_.readUnsigned();
+
+    bailoutKind_ = BailoutKind((bits & SNAPSHOT_BAILOUTKIND_MASK) >> SNAPSHOT_BAILOUTKIND_SHIFT);
+    recoverOffset_ = (bits & SNAPSHOT_ROFFSET_MASK) >> SNAPSHOT_ROFFSET_SHIFT;
+
+    JitSpew(JitSpew_IonSnapshots, "Read snapshot header with bailout kind %u",
+            bailoutKind_);
+
+#ifdef TRACK_SNAPSHOTS
+    readTrackSnapshot();
+#endif
+}
+
+#ifdef TRACK_SNAPSHOTS
+void
+SnapshotReader::readTrackSnapshot()
+{
+    pcOpcode_  = reader_.readUnsigned();
+    mirOpcode_ = reader_.readUnsigned();
+    mirId_     = reader_.readUnsigned();
+    lirOpcode_ = reader_.readUnsigned();
+    lirId_     = reader_.readUnsigned();
+}
+
+void
+SnapshotReader::spewBailingFrom() const
+{
+    if (JitSpewEnabled(JitSpew_IonBailouts)) {
+        JitSpewHeader(JitSpew_IonBailouts);
+        Fprinter& out = JitSpewPrinter();
+        out.printf(" bailing from bytecode: %s, MIR: ", CodeName[pcOpcode_]);
+        MDefinition::PrintOpcodeName(out, MDefinition::Opcode(mirOpcode_));
+        out.printf(" [%u], LIR: ", mirId_);
+        LInstruction::printName(out, LInstruction::Opcode(lirOpcode_));
+        out.printf(" [%u]", lirId_);
+        out.printf("\n");
+    }
+}
+#endif
+
+uint32_t
+SnapshotReader::readAllocationIndex()
+{
+    allocRead_++;
+    return reader_.readUnsigned();
+}
+
+RValueAllocation
+SnapshotReader::readAllocation()
+{
+    JitSpew(JitSpew_IonSnapshots, "Reading slot %u", allocRead_);
+    uint32_t offset = readAllocationIndex() * ALLOCATION_TABLE_ALIGNMENT;
+    allocReader_.seek(allocTable_, offset);
+    return RValueAllocation::read(allocReader_);
+}
+
+bool
+SnapshotWriter::init()
+{
+    // Based on the measurements made in Bug 962555 comment 20, this should be
+    // enough to prevent the reallocation of the hash table for at least half of
+    // the compilations.
+    return allocMap_.init(32);
+}
+
+RecoverReader::RecoverReader(SnapshotReader& snapshot, const uint8_t* recovers, uint32_t size)
+  : reader_(nullptr, nullptr),
+    numInstructions_(0),
+    numInstructionsRead_(0)
+{
+    if (!recovers)
+        return;
+    reader_ = CompactBufferReader(recovers + snapshot.recoverOffset(), recovers + size);
+    readRecoverHeader();
+    readInstruction();
+}
+
+void
+RecoverReader::readRecoverHeader()
+{
+    uint32_t bits = reader_.readUnsigned();
+
+    numInstructions_ = (bits & RECOVER_RINSCOUNT_MASK) >> RECOVER_RINSCOUNT_SHIFT;
+    resumeAfter_ = (bits & RECOVER_RESUMEAFTER_MASK) >> RECOVER_RESUMEAFTER_SHIFT;
+    MOZ_ASSERT(numInstructions_);
+
+    JitSpew(JitSpew_IonSnapshots, "Read recover header with instructionCount %u (ra: %d)",
+            numInstructions_, resumeAfter_);
+}
+
+void
+RecoverReader::readInstruction()
+{
+    MOZ_ASSERT(moreInstructions());
+    RInstruction::readRecoverData(reader_, &rawData_);
+    numInstructionsRead_++;
+}
+
+SnapshotOffset
+SnapshotWriter::startSnapshot(RecoverOffset recoverOffset, BailoutKind kind)
+{
+    lastStart_ = writer_.length();
+    allocWritten_ = 0;
+
+    JitSpew(JitSpew_IonSnapshots, "starting snapshot with recover offset %u, bailout kind %u",
+            recoverOffset, kind);
+
+    MOZ_ASSERT(uint32_t(kind) < (1 << SNAPSHOT_BAILOUTKIND_BITS));
+    MOZ_ASSERT(recoverOffset < (1 << SNAPSHOT_ROFFSET_BITS));
+    uint32_t bits =
+        (uint32_t(kind) << SNAPSHOT_BAILOUTKIND_SHIFT) |
+        (recoverOffset << SNAPSHOT_ROFFSET_SHIFT);
+
+    writer_.writeUnsigned(bits);
+    return lastStart_;
+}
+
+#ifdef TRACK_SNAPSHOTS
+void
+SnapshotWriter::trackSnapshot(uint32_t pcOpcode, uint32_t mirOpcode, uint32_t mirId,
+                              uint32_t lirOpcode, uint32_t lirId)
+{
+    writer_.writeUnsigned(pcOpcode);
+    writer_.writeUnsigned(mirOpcode);
+    writer_.writeUnsigned(mirId);
+    writer_.writeUnsigned(lirOpcode);
+    writer_.writeUnsigned(lirId);
+}
+#endif
+
+bool
+SnapshotWriter::add(const RValueAllocation& alloc)
+{
+    MOZ_ASSERT(allocMap_.initialized());
+
+    uint32_t offset;
+    RValueAllocMap::AddPtr p = allocMap_.lookupForAdd(alloc);
+    if (!p) {
+        offset = allocWriter_.length();
+        alloc.write(allocWriter_);
+        if (!allocMap_.add(p, alloc, offset)) {
+            allocWriter_.setOOM();
+            return false;
+        }
+    } else {
+        offset = p->value();
+    }
+
+    if (JitSpewEnabled(JitSpew_IonSnapshots)) {
+        JitSpewHeader(JitSpew_IonSnapshots);
+        Fprinter& out = JitSpewPrinter();
+        out.printf("    slot %u (%d): ", allocWritten_, offset);
+        alloc.dump(out);
+        out.printf("\n");
+    }
+
+    allocWritten_++;
+    writer_.writeUnsigned(offset / ALLOCATION_TABLE_ALIGNMENT);
+    return true;
+}
+
+void
+SnapshotWriter::endSnapshot()
+{
+    // Place a sentinel for asserting on the other end.
+#ifdef DEBUG
+    writer_.writeSigned(-1);
+#endif
+
+    JitSpew(JitSpew_IonSnapshots, "ending snapshot total size: %u bytes (start %u)",
+            uint32_t(writer_.length() - lastStart_), lastStart_);
+}
+
+RecoverOffset
+RecoverWriter::startRecover(uint32_t instructionCount, bool resumeAfter)
+{
+    MOZ_ASSERT(instructionCount);
+    instructionCount_ = instructionCount;
+    instructionsWritten_ = 0;
+
+    JitSpew(JitSpew_IonSnapshots, "starting recover with %u instruction(s)",
+            instructionCount);
+
+    MOZ_ASSERT(!(uint32_t(resumeAfter) &~ RECOVER_RESUMEAFTER_MASK));
+    MOZ_ASSERT(instructionCount < uint32_t(1 << RECOVER_RINSCOUNT_BITS));
+    uint32_t bits =
+        (uint32_t(resumeAfter) << RECOVER_RESUMEAFTER_SHIFT) |
+        (instructionCount << RECOVER_RINSCOUNT_SHIFT);
+
+    RecoverOffset recoverOffset = writer_.length();
+    writer_.writeUnsigned(bits);
+    return recoverOffset;
+}
+
+void
+RecoverWriter::writeInstruction(const MNode* rp)
+{
+    if (!rp->writeRecoverData(writer_))
+        writer_.setOOM();
+    instructionsWritten_++;
+}
+
+void
+RecoverWriter::endRecover()
+{
+    MOZ_ASSERT(instructionCount_ == instructionsWritten_);
+}