Add m-esr52 at 52.6.0

1 files changed, 278 insertions, 0 deletions

diff --git a/js/src/jit/Disassembler.h b/js/src/jit/Disassembler.h
new file mode 100644
index 000000000..101b78968
--- /dev/null
+++ b/js/src/jit/Disassembler.h
@@ -0,0 +1,278 @@
+/* -*- 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_Disassembler_h
+#define jit_Disassembler_h
+
+#include "jit/MacroAssembler.h"
+#include "jit/Registers.h"
+
+namespace js {
+namespace jit {
+
+namespace Disassembler {
+
+class ComplexAddress {
+    int32_t disp_;
+    Register::Encoding base_ : 8;
+    Register::Encoding index_ : 8;
+    int8_t scale_; // log2 encoding
+    bool isPCRelative_;
+
+  public:
+    ComplexAddress()
+      : disp_(0),
+        base_(Registers::Invalid),
+        index_(Registers::Invalid),
+        scale_(0),
+        isPCRelative_(false)
+    {
+        MOZ_ASSERT(*this == *this);
+    }
+
+    ComplexAddress(int32_t disp, Register::Encoding base)
+      : disp_(disp),
+        base_(base),
+        index_(Registers::Invalid),
+        scale_(0),
+        isPCRelative_(false)
+    {
+        MOZ_ASSERT(*this == *this);
+        MOZ_ASSERT(base != Registers::Invalid);
+        MOZ_ASSERT(base_ == base);
+    }
+
+    ComplexAddress(int32_t disp, Register::Encoding base, Register::Encoding index, int scale)
+      : disp_(disp),
+        base_(base),
+        index_(index),
+        scale_(scale),
+        isPCRelative_(false)
+    {
+        MOZ_ASSERT(scale >= 0 && scale < 4);
+        MOZ_ASSERT_IF(index == Registers::Invalid, scale == 0);
+        MOZ_ASSERT(*this == *this);
+        MOZ_ASSERT(base_ == base);
+        MOZ_ASSERT(index_ == index);
+    }
+
+    explicit ComplexAddress(const void* addr)
+      : disp_(static_cast<uint32_t>(reinterpret_cast<uintptr_t>(addr))),
+        base_(Registers::Invalid),
+        index_(Registers::Invalid),
+        scale_(0),
+        isPCRelative_(false)
+    {
+        MOZ_ASSERT(*this == *this);
+        MOZ_ASSERT(reinterpret_cast<const void*>(uintptr_t(disp_)) == addr);
+    }
+
+    explicit ComplexAddress(const Operand& op) {
+#if defined(JS_CODEGEN_X64) || defined(JS_CODEGEN_X86)
+        switch (op.kind()) {
+          case Operand::MEM_REG_DISP:
+            *this = ComplexAddress(op.disp(), op.base());
+            return;
+          case Operand::MEM_SCALE:
+            *this = ComplexAddress(op.disp(), op.base(), op.index(), op.scale());
+            return;
+          case Operand::MEM_ADDRESS32:
+            *this = ComplexAddress(op.address());
+            return;
+          default:
+            break;
+        }
+#endif
+        MOZ_CRASH("Unexpected Operand kind");
+    }
+
+    bool isPCRelative() const {
+        return isPCRelative_;
+    }
+
+    int32_t disp() const {
+        return disp_;
+    }
+
+    bool hasBase() const {
+        return base_ != Registers::Invalid;
+    }
+
+    Register::Encoding base() const {
+        MOZ_ASSERT(hasBase());
+        return base_;
+    }
+
+    bool hasIndex() const {
+        return index_ != Registers::Invalid;
+    }
+
+    Register::Encoding index() const {
+        MOZ_ASSERT(hasIndex());
+        return index_;
+    }
+
+    uint32_t scale() const {
+        return scale_;
+    }
+
+#ifdef DEBUG
+    bool operator==(const ComplexAddress& other) const;
+    bool operator!=(const ComplexAddress& other) const;
+#endif
+};
+
+// An operand other than a memory operand -- a register or an immediate.
+class OtherOperand {
+  public:
+    enum Kind {
+        Imm,
+        GPR,
+        FPR,
+    };
+
+  private:
+    Kind kind_;
+    union {
+        int32_t imm;
+        Register::Encoding gpr;
+        FloatRegister::Encoding fpr;
+    } u_;
+
+  public:
+    OtherOperand()
+      : kind_(Imm)
+    {
+        u_.imm = 0;
+        MOZ_ASSERT(*this == *this);
+    }
+
+    explicit OtherOperand(int32_t imm)
+      : kind_(Imm)
+    {
+        u_.imm = imm;
+        MOZ_ASSERT(*this == *this);
+    }
+
+    explicit OtherOperand(Register::Encoding gpr)
+      : kind_(GPR)
+    {
+        u_.gpr = gpr;
+        MOZ_ASSERT(*this == *this);
+    }
+
+    explicit OtherOperand(FloatRegister::Encoding fpr)
+      : kind_(FPR)
+    {
+        u_.fpr = fpr;
+        MOZ_ASSERT(*this == *this);
+    }
+
+    Kind kind() const {
+        return kind_;
+    }
+
+    int32_t imm() const {
+        MOZ_ASSERT(kind_ == Imm);
+        return u_.imm;
+    }
+
+    Register::Encoding gpr() const {
+        MOZ_ASSERT(kind_ == GPR);
+        return u_.gpr;
+    }
+
+    FloatRegister::Encoding fpr() const {
+        MOZ_ASSERT(kind_ == FPR);
+        return u_.fpr;
+    }
+
+#ifdef DEBUG
+    bool operator==(const OtherOperand& other) const;
+    bool operator!=(const OtherOperand& other) const;
+#endif
+};
+
+class HeapAccess {
+  public:
+    enum Kind {
+        Unknown,
+        Load,       // any bits not covered by the load are zeroed
+        LoadSext32, // like Load, but sign-extend to 32 bits
+        LoadSext64, // like Load, but sign-extend to 64 bits
+        Store
+    };
+
+  private:
+    Kind kind_;
+    size_t size_; // The number of bytes of memory accessed
+    ComplexAddress address_;
+    OtherOperand otherOperand_;
+
+  public:
+    HeapAccess()
+      : kind_(Unknown),
+        size_(0)
+    {
+        MOZ_ASSERT(*this == *this);
+    }
+
+    HeapAccess(Kind kind, size_t size, const ComplexAddress& address, const OtherOperand& otherOperand)
+      : kind_(kind),
+        size_(size),
+        address_(address),
+        otherOperand_(otherOperand)
+    {
+        MOZ_ASSERT(kind != Unknown);
+        MOZ_ASSERT_IF(kind == LoadSext32, otherOperand.kind() != OtherOperand::FPR);
+        MOZ_ASSERT_IF(kind == Load || kind == LoadSext32, otherOperand.kind() != OtherOperand::Imm);
+        MOZ_ASSERT(*this == *this);
+    }
+
+    Kind kind() const {
+        return kind_;
+    }
+
+    size_t size() const {
+        MOZ_ASSERT(kind_ != Unknown);
+        return size_;
+    }
+
+    const ComplexAddress& address() const {
+        return address_;
+    }
+
+    const OtherOperand& otherOperand() const {
+        return otherOperand_;
+    }
+
+#ifdef DEBUG
+    bool operator==(const HeapAccess& other) const;
+    bool operator!=(const HeapAccess& other) const;
+#endif
+};
+
+MOZ_COLD uint8_t* DisassembleHeapAccess(uint8_t* ptr, HeapAccess* access);
+
+#ifdef DEBUG
+void DumpHeapAccess(const HeapAccess& access);
+
+inline void
+VerifyHeapAccess(uint8_t* begin, uint8_t* end, const HeapAccess& expected)
+{
+    HeapAccess disassembled;
+    uint8_t* e = DisassembleHeapAccess(begin, &disassembled);
+    MOZ_ASSERT(e == end);
+    MOZ_ASSERT(disassembled == expected);
+}
+#endif
+
+} // namespace Disassembler
+
+} // namespace jit
+} // namespace js
+
+#endif /* jit_Disassembler_h */