From 5f8de423f190bbb79a62f804151bc24824fa32d8 Mon Sep 17 00:00:00 2001 From: "Matt A. Tobin" Date: Fri, 2 Feb 2018 04:16:08 -0500 Subject: Add m-esr52 at 52.6.0 --- js/src/jit/Registers.h | 250 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 250 insertions(+) create mode 100644 js/src/jit/Registers.h (limited to 'js/src/jit/Registers.h') diff --git a/js/src/jit/Registers.h b/js/src/jit/Registers.h new file mode 100644 index 000000000..4ecf3ae9c --- /dev/null +++ b/js/src/jit/Registers.h @@ -0,0 +1,250 @@ +/* -*- 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_Registers_h +#define jit_Registers_h + +#include "mozilla/Array.h" + +#include "jit/IonTypes.h" +#if defined(JS_CODEGEN_X86) || defined(JS_CODEGEN_X64) +# include "jit/x86-shared/Architecture-x86-shared.h" +#elif defined(JS_CODEGEN_ARM) +# include "jit/arm/Architecture-arm.h" +#elif defined(JS_CODEGEN_ARM64) +# include "jit/arm64/Architecture-arm64.h" +#elif defined(JS_CODEGEN_MIPS32) +# include "jit/mips32/Architecture-mips32.h" +#elif defined(JS_CODEGEN_MIPS64) +# include "jit/mips64/Architecture-mips64.h" +#elif defined(JS_CODEGEN_NONE) +# include "jit/none/Architecture-none.h" +#else +# error "Unknown architecture!" +#endif + +namespace js { +namespace jit { + +struct Register { + typedef Registers Codes; + typedef Codes::Encoding Encoding; + typedef Codes::Code Code; + typedef Codes::SetType SetType; + + Codes::Encoding reg_; + static Register FromCode(Code i) { + MOZ_ASSERT(i < Registers::Total); + Register r = { Encoding(i) }; + return r; + } + static Register FromName(const char* name) { + Code code = Registers::FromName(name); + Register r = { Encoding(code) }; + return r; + } + static Register Invalid() { + Register r = { Encoding(Codes::Invalid) }; + return r; + } + constexpr Code code() const { + return Code(reg_); + } + Encoding encoding() const { + MOZ_ASSERT(Code(reg_) < Registers::Total); + return reg_; + } + const char* name() const { + return Registers::GetName(code()); + } + bool operator ==(Register other) const { + return reg_ == other.reg_; + } + bool operator !=(Register other) const { + return reg_ != other.reg_; + } + bool volatile_() const { + return !!((SetType(1) << code()) & Registers::VolatileMask); + } + bool aliases(const Register& other) const { + return reg_ == other.reg_; + } + uint32_t numAliased() const { + return 1; + } + + // N.B. FloatRegister is an explicit outparam here because msvc-2010 + // miscompiled it on win64 when the value was simply returned. This + // now has an explicit outparam for compatability. + void aliased(uint32_t aliasIdx, Register* ret) const { + MOZ_ASSERT(aliasIdx == 0); + *ret = *this; + } + + SetType alignedOrDominatedAliasedSet() const { + return SetType(1) << code(); + } + + static uint32_t SetSize(SetType x) { + return Codes::SetSize(x); + } + static uint32_t FirstBit(SetType x) { + return Codes::FirstBit(x); + } + static uint32_t LastBit(SetType x) { + return Codes::LastBit(x); + } +}; + +#if defined(JS_NUNBOX32) +static const uint32_t INT64LOW_OFFSET = 0 * sizeof(int32_t); +static const uint32_t INT64HIGH_OFFSET = 1 * sizeof(int32_t); +#endif + +struct Register64 +{ +#ifdef JS_PUNBOX64 + Register reg; +#else + Register high; + Register low; +#endif + +#ifdef JS_PUNBOX64 + explicit constexpr Register64(Register r) + : reg(r) + {} + bool operator ==(Register64 other) const { + return reg == other.reg; + } + bool operator !=(Register64 other) const { + return reg != other.reg; + } + static Register64 Invalid() { + return Register64(Register::Invalid()); + } +#else + constexpr Register64(Register h, Register l) + : high(h), low(l) + {} + bool operator ==(Register64 other) const { + return high == other.high && low == other.low; + } + bool operator !=(Register64 other) const { + return high != other.high || low != other.low; + } + static Register64 Invalid() { + return Register64(Register::Invalid(), Register::Invalid()); + } +#endif +}; + +class RegisterDump +{ + public: + typedef mozilla::Array GPRArray; + typedef mozilla::Array FPUArray; + + protected: // Silence Clang warning. + GPRArray regs_; + FPUArray fpregs_; + + public: + static size_t offsetOfRegister(Register reg) { + return offsetof(RegisterDump, regs_) + reg.code() * sizeof(uintptr_t); + } + static size_t offsetOfRegister(FloatRegister reg) { + return offsetof(RegisterDump, fpregs_) + reg.getRegisterDumpOffsetInBytes(); + } +}; + +// Information needed to recover machine register state. This records the +// location of spilled register and not the content of the spilled +// registers. Thus we can safely assume that this structure is unchanged, even +// if the GC pointers mapped by this structure are relocated. +class MachineState +{ + mozilla::Array regs_; + mozilla::Array fpregs_; + + public: + MachineState() { +#ifndef JS_CODEGEN_NONE + for (uintptr_t i = 0; i < Registers::Total; i++) + regs_[i] = reinterpret_cast(i + 0x100); + for (uintptr_t i = 0; i < FloatRegisters::Total; i++) + fpregs_[i] = reinterpret_cast(i + 0x200); +#endif + } + + static MachineState FromBailout(RegisterDump::GPRArray& regs, RegisterDump::FPUArray& fpregs); + + void setRegisterLocation(Register reg, uintptr_t* up) { + regs_[reg.code()] = (Registers::RegisterContent*) up; + } + void setRegisterLocation(FloatRegister reg, float* fp) { + MOZ_ASSERT(reg.isSingle()); + fpregs_[reg.code()] = (FloatRegisters::RegisterContent*) fp; + } + void setRegisterLocation(FloatRegister reg, double* dp) { + fpregs_[reg.code()] = (FloatRegisters::RegisterContent*) dp; + } + void setRegisterLocation(FloatRegister reg, FloatRegisters::RegisterContent* rp) { + fpregs_[reg.code()] = rp; + } + + bool has(Register reg) const { + return regs_[reg.code()] != nullptr; + } + bool has(FloatRegister reg) const { + return fpregs_[reg.code()] != nullptr; + } + uintptr_t read(Register reg) const { + return regs_[reg.code()]->r; + } + double read(FloatRegister reg) const { + return fpregs_[reg.code()]->d; + } + void write(Register reg, uintptr_t value) const { + regs_[reg.code()]->r = value; + } + const FloatRegisters::RegisterContent* address(FloatRegister reg) const { + return fpregs_[reg.code()]; + } +}; + +class MacroAssembler; + +// Declares a register as owned within the scope of the object. +// In debug mode, owned register state is tracked within the MacroAssembler, +// and an assert will fire if ownership is conflicting. +// In contrast to ARM64's UseScratchRegisterScope, this class has no overhead +// in non-debug builds. +template +struct AutoGenericRegisterScope : public RegisterType +{ + // Prevent MacroAssembler templates from creating copies, + // which causes the destructor to fire more than once. + AutoGenericRegisterScope(const AutoGenericRegisterScope& other) = delete; + +#ifdef DEBUG + MacroAssembler& masm_; + explicit AutoGenericRegisterScope(MacroAssembler& masm, RegisterType reg); + ~AutoGenericRegisterScope(); +#else + constexpr explicit AutoGenericRegisterScope(MacroAssembler& masm, RegisterType reg) + : RegisterType(reg) + { } +#endif +}; + +typedef AutoGenericRegisterScope AutoRegisterScope; +typedef AutoGenericRegisterScope AutoFloatRegisterScope; + +} // namespace jit +} // namespace js + +#endif /* jit_Registers_h */ -- cgit v1.2.3