Add m-esr52 at 52.6.0

1 files changed, 579 insertions, 0 deletions

diff --git a/js/src/jit/Snapshots.h b/js/src/jit/Snapshots.h
new file mode 100644
index 000000000..7aac3ccf6
--- /dev/null
+++ b/js/src/jit/Snapshots.h
@@ -0,0 +1,579 @@
+/* -*- 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_Snapshot_h
+#define jit_Snapshot_h
+
+#include "mozilla/Alignment.h"
+
+#include "jsalloc.h"
+#include "jsbytecode.h"
+
+#include "jit/CompactBuffer.h"
+#include "jit/IonTypes.h"
+#include "jit/Registers.h"
+
+#include "js/HashTable.h"
+
+namespace js {
+class GenericPrinter;
+
+namespace jit {
+
+class RValueAllocation;
+
+// A Recover Value Allocation mirror what is known at compiled time as being the
+// MIRType and the LAllocation.  This is read out of the snapshot to recover the
+// value which would be there if this frame was an interpreter frame instead of
+// an Ion frame.
+//
+// It is used with the SnapshotIterator to recover a Value from the stack,
+// spilled registers or the list of constant of the compiled script.
+//
+// Unit tests are located in jsapi-tests/testJitRValueAlloc.cpp.
+class RValueAllocation
+{
+  public:
+
+    // See RValueAllocation encoding in Snapshots.cpp
+    enum Mode
+    {
+        CONSTANT            = 0x00,
+        CST_UNDEFINED       = 0x01,
+        CST_NULL            = 0x02,
+        DOUBLE_REG          = 0x03,
+        ANY_FLOAT_REG       = 0x04,
+        ANY_FLOAT_STACK     = 0x05,
+#if defined(JS_NUNBOX32)
+        UNTYPED_REG_REG     = 0x06,
+        UNTYPED_REG_STACK   = 0x07,
+        UNTYPED_STACK_REG   = 0x08,
+        UNTYPED_STACK_STACK = 0x09,
+#elif defined(JS_PUNBOX64)
+        UNTYPED_REG         = 0x06,
+        UNTYPED_STACK       = 0x07,
+#endif
+
+        // Recover instructions.
+        RECOVER_INSTRUCTION = 0x0a,
+        RI_WITH_DEFAULT_CST = 0x0b,
+
+        // The JSValueType is packed in the Mode.
+        TYPED_REG_MIN       = 0x10,
+        TYPED_REG_MAX       = 0x1f,
+        TYPED_REG = TYPED_REG_MIN,
+
+        // The JSValueType is packed in the Mode.
+        TYPED_STACK_MIN     = 0x20,
+        TYPED_STACK_MAX     = 0x2f,
+        TYPED_STACK = TYPED_STACK_MIN,
+
+        // This mask can be used with any other valid mode. When this flag is
+        // set on the mode, this inform the snapshot iterator that even if the
+        // allocation is readable, the content of if might be incomplete unless
+        // all side-effects are executed.
+        RECOVER_SIDE_EFFECT_MASK = 0x80,
+
+        // This mask represents the set of bits which can be used to encode a
+        // value in a snapshot. The mode is used to determine how to interpret
+        // the union of values and how to pack the value in memory.
+        MODE_BITS_MASK           = 0x17f,
+
+        INVALID = 0x100,
+    };
+
+    enum { PACKED_TAG_MASK = 0x0f };
+
+    // See Payload encoding in Snapshots.cpp
+    enum PayloadType {
+        PAYLOAD_NONE,
+        PAYLOAD_INDEX,
+        PAYLOAD_STACK_OFFSET,
+        PAYLOAD_GPR,
+        PAYLOAD_FPU,
+        PAYLOAD_PACKED_TAG
+    };
+
+    struct Layout {
+        PayloadType type1;
+        PayloadType type2;
+        const char* name;
+    };
+
+  private:
+    Mode mode_;
+
+    // Additional information to recover the content of the allocation.
+    struct FloatRegisterBits {
+        uint32_t data;
+        bool operator == (const FloatRegisterBits& other) const {
+            return data == other.data;
+        }
+        uint32_t code() const {
+            return data;
+        }
+        const char* name() const {
+            FloatRegister tmp = FloatRegister::FromCode(data);
+            return tmp.name();
+        }
+    };
+
+    union Payload {
+        uint32_t index;
+        int32_t stackOffset;
+        Register gpr;
+        FloatRegisterBits fpu;
+        JSValueType type;
+    };
+
+    Payload arg1_;
+    Payload arg2_;
+
+    static Payload payloadOfIndex(uint32_t index) {
+        Payload p;
+        p.index = index;
+        return p;
+    }
+    static Payload payloadOfStackOffset(int32_t offset) {
+        Payload p;
+        p.stackOffset = offset;
+        return p;
+    }
+    static Payload payloadOfRegister(Register reg) {
+        Payload p;
+        p.gpr = reg;
+        return p;
+    }
+    static Payload payloadOfFloatRegister(FloatRegister reg) {
+        Payload p;
+        FloatRegisterBits b;
+        b.data = reg.code();
+        p.fpu = b;
+        return p;
+    }
+    static Payload payloadOfValueType(JSValueType type) {
+        Payload p;
+        p.type = type;
+        return p;
+    }
+
+    static const Layout& layoutFromMode(Mode mode);
+
+    static void readPayload(CompactBufferReader& reader, PayloadType t,
+                            uint8_t* mode, Payload* p);
+    static void writePayload(CompactBufferWriter& writer, PayloadType t,
+                             Payload p);
+    static void writePadding(CompactBufferWriter& writer);
+    static void dumpPayload(GenericPrinter& out, PayloadType t, Payload p);
+    static bool equalPayloads(PayloadType t, Payload lhs, Payload rhs);
+
+    RValueAllocation(Mode mode, Payload a1, Payload a2)
+      : mode_(mode),
+        arg1_(a1),
+        arg2_(a2)
+    {
+    }
+
+    RValueAllocation(Mode mode, Payload a1)
+      : mode_(mode),
+        arg1_(a1)
+    {
+    }
+
+    explicit RValueAllocation(Mode mode)
+      : mode_(mode)
+    {
+    }
+
+  public:
+    RValueAllocation()
+      : mode_(INVALID)
+    { }
+
+    // DOUBLE_REG
+    static RValueAllocation Double(FloatRegister reg) {
+        return RValueAllocation(DOUBLE_REG, payloadOfFloatRegister(reg));
+    }
+
+    // ANY_FLOAT_REG or ANY_FLOAT_STACK
+    static RValueAllocation AnyFloat(FloatRegister reg) {
+        return RValueAllocation(ANY_FLOAT_REG, payloadOfFloatRegister(reg));
+    }
+    static RValueAllocation AnyFloat(int32_t offset) {
+        return RValueAllocation(ANY_FLOAT_STACK, payloadOfStackOffset(offset));
+    }
+
+    // TYPED_REG or TYPED_STACK
+    static RValueAllocation Typed(JSValueType type, Register reg) {
+        MOZ_ASSERT(type != JSVAL_TYPE_DOUBLE &&
+                   type != JSVAL_TYPE_MAGIC &&
+                   type != JSVAL_TYPE_NULL &&
+                   type != JSVAL_TYPE_UNDEFINED);
+        return RValueAllocation(TYPED_REG, payloadOfValueType(type),
+                                payloadOfRegister(reg));
+    }
+    static RValueAllocation Typed(JSValueType type, int32_t offset) {
+        MOZ_ASSERT(type != JSVAL_TYPE_MAGIC &&
+                   type != JSVAL_TYPE_NULL &&
+                   type != JSVAL_TYPE_UNDEFINED);
+        return RValueAllocation(TYPED_STACK, payloadOfValueType(type),
+                                payloadOfStackOffset(offset));
+    }
+
+    // UNTYPED
+#if defined(JS_NUNBOX32)
+    static RValueAllocation Untyped(Register type, Register payload) {
+        return RValueAllocation(UNTYPED_REG_REG,
+                                payloadOfRegister(type),
+                                payloadOfRegister(payload));
+    }
+
+    static RValueAllocation Untyped(Register type, int32_t payloadStackOffset) {
+        return RValueAllocation(UNTYPED_REG_STACK,
+                                payloadOfRegister(type),
+                                payloadOfStackOffset(payloadStackOffset));
+    }
+
+    static RValueAllocation Untyped(int32_t typeStackOffset, Register payload) {
+        return RValueAllocation(UNTYPED_STACK_REG,
+                                payloadOfStackOffset(typeStackOffset),
+                                payloadOfRegister(payload));
+    }
+
+    static RValueAllocation Untyped(int32_t typeStackOffset, int32_t payloadStackOffset) {
+        return RValueAllocation(UNTYPED_STACK_STACK,
+                                payloadOfStackOffset(typeStackOffset),
+                                payloadOfStackOffset(payloadStackOffset));
+    }
+
+#elif defined(JS_PUNBOX64)
+    static RValueAllocation Untyped(Register reg) {
+        return RValueAllocation(UNTYPED_REG, payloadOfRegister(reg));
+    }
+
+    static RValueAllocation Untyped(int32_t stackOffset) {
+        return RValueAllocation(UNTYPED_STACK, payloadOfStackOffset(stackOffset));
+    }
+#endif
+
+    // common constants.
+    static RValueAllocation Undefined() {
+        return RValueAllocation(CST_UNDEFINED);
+    }
+    static RValueAllocation Null() {
+        return RValueAllocation(CST_NULL);
+    }
+
+    // CONSTANT's index
+    static RValueAllocation ConstantPool(uint32_t index) {
+        return RValueAllocation(CONSTANT, payloadOfIndex(index));
+    }
+
+    // Recover instruction's index
+    static RValueAllocation RecoverInstruction(uint32_t index) {
+        return RValueAllocation(RECOVER_INSTRUCTION, payloadOfIndex(index));
+    }
+    static RValueAllocation RecoverInstruction(uint32_t riIndex, uint32_t cstIndex) {
+        return RValueAllocation(RI_WITH_DEFAULT_CST,
+                                payloadOfIndex(riIndex),
+                                payloadOfIndex(cstIndex));
+    }
+
+    void setNeedSideEffect() {
+        MOZ_ASSERT(!needSideEffect() && mode_ != INVALID);
+        mode_ = Mode(mode_ | RECOVER_SIDE_EFFECT_MASK);
+    }
+
+    void writeHeader(CompactBufferWriter& writer, JSValueType type, uint32_t regCode) const;
+  public:
+    static RValueAllocation read(CompactBufferReader& reader);
+    void write(CompactBufferWriter& writer) const;
+
+  public:
+    Mode mode() const {
+        return Mode(mode_ & MODE_BITS_MASK);
+    }
+    bool needSideEffect() const {
+        return mode_ & RECOVER_SIDE_EFFECT_MASK;
+    }
+
+    uint32_t index() const {
+        MOZ_ASSERT(layoutFromMode(mode()).type1 == PAYLOAD_INDEX);
+        return arg1_.index;
+    }
+    int32_t stackOffset() const {
+        MOZ_ASSERT(layoutFromMode(mode()).type1 == PAYLOAD_STACK_OFFSET);
+        return arg1_.stackOffset;
+    }
+    Register reg() const {
+        MOZ_ASSERT(layoutFromMode(mode()).type1 == PAYLOAD_GPR);
+        return arg1_.gpr;
+    }
+    FloatRegister fpuReg() const {
+        MOZ_ASSERT(layoutFromMode(mode()).type1 == PAYLOAD_FPU);
+        FloatRegisterBits b = arg1_.fpu;
+        return FloatRegister::FromCode(b.data);
+    }
+    JSValueType knownType() const {
+        MOZ_ASSERT(layoutFromMode(mode()).type1 == PAYLOAD_PACKED_TAG);
+        return arg1_.type;
+    }
+
+    uint32_t index2() const {
+        MOZ_ASSERT(layoutFromMode(mode()).type2 == PAYLOAD_INDEX);
+        return arg2_.index;
+    }
+    int32_t stackOffset2() const {
+        MOZ_ASSERT(layoutFromMode(mode()).type2 == PAYLOAD_STACK_OFFSET);
+        return arg2_.stackOffset;
+    }
+    Register reg2() const {
+        MOZ_ASSERT(layoutFromMode(mode()).type2 == PAYLOAD_GPR);
+        return arg2_.gpr;
+    }
+
+  public:
+    void dump(GenericPrinter& out) const;
+
+  public:
+    bool operator==(const RValueAllocation& rhs) const {
+        if (mode_ != rhs.mode_)
+            return false;
+
+        const Layout& layout = layoutFromMode(mode());
+        return equalPayloads(layout.type1, arg1_, rhs.arg1_) &&
+            equalPayloads(layout.type2, arg2_, rhs.arg2_);
+    }
+
+    HashNumber hash() const;
+
+    struct Hasher
+    {
+        typedef RValueAllocation Key;
+        typedef Key Lookup;
+        static HashNumber hash(const Lookup& v) {
+            return v.hash();
+        }
+        static bool match(const Key& k, const Lookup& l) {
+            return k == l;
+        }
+    };
+};
+
+class RecoverWriter;
+
+// Collects snapshots in a contiguous buffer, which is copied into IonScript
+// memory after code generation.
+class SnapshotWriter
+{
+    CompactBufferWriter writer_;
+    CompactBufferWriter allocWriter_;
+
+    // Map RValueAllocations to an offset in the allocWriter_ buffer.  This is
+    // useful as value allocations are repeated frequently.
+    typedef RValueAllocation RVA;
+    typedef HashMap<RVA, uint32_t, RVA::Hasher, SystemAllocPolicy> RValueAllocMap;
+    RValueAllocMap allocMap_;
+
+    // This is only used to assert sanity.
+    uint32_t allocWritten_;
+
+    // Used to report size of the snapshot in the spew messages.
+    SnapshotOffset lastStart_;
+
+  public:
+    MOZ_MUST_USE bool init();
+
+    SnapshotOffset startSnapshot(RecoverOffset recoverOffset, BailoutKind kind);
+#ifdef TRACK_SNAPSHOTS
+    void trackSnapshot(uint32_t pcOpcode, uint32_t mirOpcode, uint32_t mirId,
+                       uint32_t lirOpcode, uint32_t lirId);
+#endif
+    MOZ_MUST_USE bool add(const RValueAllocation& slot);
+
+    uint32_t allocWritten() const {
+        return allocWritten_;
+    }
+    void endSnapshot();
+
+    bool oom() const {
+        return writer_.oom() || writer_.length() >= MAX_BUFFER_SIZE ||
+            allocWriter_.oom() || allocWriter_.length() >= MAX_BUFFER_SIZE;
+    }
+
+    size_t listSize() const {
+        return writer_.length();
+    }
+    const uint8_t* listBuffer() const {
+        return writer_.buffer();
+    }
+
+    size_t RVATableSize() const {
+        return allocWriter_.length();
+    }
+    const uint8_t* RVATableBuffer() const {
+        return allocWriter_.buffer();
+    }
+};
+
+class MNode;
+
+class RecoverWriter
+{
+    CompactBufferWriter writer_;
+
+    uint32_t instructionCount_;
+    uint32_t instructionsWritten_;
+
+  public:
+    SnapshotOffset startRecover(uint32_t instructionCount, bool resumeAfter);
+
+    void writeInstruction(const MNode* rp);
+
+    void endRecover();
+
+    size_t size() const {
+        return writer_.length();
+    }
+    const uint8_t* buffer() const {
+        return writer_.buffer();
+    }
+
+    bool oom() const {
+        return writer_.oom() || writer_.length() >= MAX_BUFFER_SIZE;
+    }
+};
+
+class RecoverReader;
+
+// A snapshot reader reads the entries out of the compressed snapshot buffer in
+// a script. These entries describe the equivalent interpreter frames at a given
+// position in JIT code. Each entry is an Ion's value allocations, used to
+// recover the corresponding Value from an Ion frame.
+class SnapshotReader
+{
+    CompactBufferReader reader_;
+    CompactBufferReader allocReader_;
+    const uint8_t* allocTable_;
+
+    BailoutKind bailoutKind_;
+    uint32_t allocRead_;          // Number of slots that have been read.
+    RecoverOffset recoverOffset_; // Offset of the recover instructions.
+
+#ifdef TRACK_SNAPSHOTS
+  private:
+    uint32_t pcOpcode_;
+    uint32_t mirOpcode_;
+    uint32_t mirId_;
+    uint32_t lirOpcode_;
+    uint32_t lirId_;
+
+  public:
+    void readTrackSnapshot();
+    void spewBailingFrom() const;
+#endif
+
+  private:
+    void readSnapshotHeader();
+    uint32_t readAllocationIndex();
+
+  public:
+    SnapshotReader(const uint8_t* snapshots, uint32_t offset,
+                   uint32_t RVATableSize, uint32_t listSize);
+
+    RValueAllocation readAllocation();
+    void skipAllocation() {
+        readAllocationIndex();
+    }
+
+    BailoutKind bailoutKind() const {
+        return bailoutKind_;
+    }
+    RecoverOffset recoverOffset() const {
+        return recoverOffset_;
+    }
+
+    uint32_t numAllocationsRead() const {
+        return allocRead_;
+    }
+    void resetNumAllocationsRead() {
+        allocRead_ = 0;
+    }
+};
+
+class RInstructionStorage
+{
+    static const size_t Size = 4 * sizeof(uint32_t);
+    mozilla::AlignedStorage<Size> mem;
+
+  public:
+    const void* addr() const { return mem.addr(); }
+    void* addr() { return mem.addr(); }
+
+    RInstructionStorage() = default;
+
+    RInstructionStorage(const RInstructionStorage& other) {
+        memcpy(addr(), other.addr(), Size);
+    }
+    void operator=(const RInstructionStorage& other) {
+        memcpy(addr(), other.addr(), Size);
+    }
+};
+
+class RInstruction;
+
+class RecoverReader
+{
+    CompactBufferReader reader_;
+
+    // Number of encoded instructions.
+    uint32_t numInstructions_;
+
+    // Number of instruction read.
+    uint32_t numInstructionsRead_;
+
+    // True if we need to resume after the Resume Point instruction of the
+    // innermost frame.
+    bool resumeAfter_;
+
+    // Space is reserved as part of the RecoverReader to avoid allocations of
+    // data which is needed to decode the current instruction.
+    RInstructionStorage rawData_;
+
+  private:
+    void readRecoverHeader();
+    void readInstruction();
+
+  public:
+    RecoverReader(SnapshotReader& snapshot, const uint8_t* recovers, uint32_t size);
+
+    uint32_t numInstructions() const {
+        return numInstructions_;
+    }
+    uint32_t numInstructionsRead() const {
+        return numInstructionsRead_;
+    }
+
+    bool moreInstructions() const {
+        return numInstructionsRead_ < numInstructions_;
+    }
+    void nextInstruction() {
+        readInstruction();
+    }
+
+    const RInstruction* instruction() const {
+        return reinterpret_cast<const RInstruction*>(rawData_.addr());
+    }
+
+    bool resumeAfter() const {
+        return resumeAfter_;
+    }
+};
+
+} // namespace jit
+} // namespace js
+
+#endif /* jit_Snapshot_h */