The Tor Browser / file revision

 /* -*- 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_RegisterSets_h

 #define jit_RegisterSets_h

 #include "mozilla/Alignment.h"

 #include "mozilla/MathAlgorithms.h"

 #include "jit/IonAllocPolicy.h"

 #include "jit/Registers.h"

 namespace js {

 namespace jit {

 struct AnyRegister {

     typedef uint32_t Code;

     static const uint32_t Total = Registers::Total + FloatRegisters::Total;

     static const uint32_t Invalid = UINT_MAX;

     union {

         Registers::Code gpr_;

         FloatRegisters::Code fpu_;

     };

     bool isFloat_;

     AnyRegister()

     { }

     explicit AnyRegister(Register gpr) {

         gpr_ = gpr.code();

         isFloat_ = false;

     }

     explicit AnyRegister(FloatRegister fpu) {

         fpu_ = fpu.code();

         isFloat_ = true;

     }

     static AnyRegister FromCode(uint32_t i) {

         JS_ASSERT(i < Total);

         AnyRegister r;

         if (i < Registers::Total) {

             r.gpr_ = Register::Code(i);

             r.isFloat_ = false;

         } else {

             r.fpu_ = FloatRegister::Code(i - Registers::Total);

             r.isFloat_ = true;

         }

         return r;

     }

     bool isFloat() const {

         return isFloat_;

     }

     Register gpr() const {

         JS_ASSERT(!isFloat());

         return Register::FromCode(gpr_);

     }

     FloatRegister fpu() const {

         JS_ASSERT(isFloat());

         return FloatRegister::FromCode(fpu_);

     }

     bool operator ==(const AnyRegister &other) const {

         return isFloat()

                ? (other.isFloat() && fpu_ == other.fpu_)

                : (!other.isFloat() && gpr_ == other.gpr_);

     }

     bool operator !=(const AnyRegister &other) const {

         return isFloat()

                ? (!other.isFloat() || fpu_ != other.fpu_)

                : (other.isFloat() || gpr_ != other.gpr_);

     }

     const char *name() const {

         return isFloat()

                ? FloatRegister::FromCode(fpu_).name()

                : Register::FromCode(gpr_).name();

     }

     const Code code() const {

         return isFloat()

                ? fpu_ + Registers::Total

                : gpr_;

     }

     bool volatile_() const {

         return isFloat() ? fpu().volatile_() : gpr().volatile_();

     }

 };

 // Registers to hold a boxed value. Uses one register on 64 bit

 // platforms, two registers on 32 bit platforms.

 class ValueOperand

 {

 #if defined(JS_NUNBOX32)

     Register type_;

     Register payload_;

   public:

     MOZ_CONSTEXPR ValueOperand(Register type, Register payload)

       : type_(type), payload_(payload)

     { }

     Register typeReg() const {

         return type_;

     }

     Register payloadReg() const {

         return payload_;

     }

     Register scratchReg() const {

         return payloadReg();

     }

     bool operator==(const ValueOperand &o) const {

         return type_ == o.type_ && payload_ == o.payload_;

     }

     bool operator!=(const ValueOperand &o) const {

         return !(*this == o);

     }

 #elif defined(JS_PUNBOX64)

     Register value_;

   public:

     explicit MOZ_CONSTEXPR ValueOperand(Register value)

       : value_(value)

     { }

     Register valueReg() const {

         return value_;

     }

     Register scratchReg() const {

         return valueReg();

     }

     bool operator==(const ValueOperand &o) const {

         return value_ == o.value_;

     }

     bool operator!=(const ValueOperand &o) const {

         return !(*this == o);

     }

 #endif

     ValueOperand() {}

 };

 // Registers to hold either either a typed or untyped value.

 class TypedOrValueRegister

 {

     // Type of value being stored.

     MIRType type_;

     // Space to hold either an AnyRegister or a ValueOperand.

     union U {

         mozilla::AlignedStorage2<AnyRegister> typed;

         mozilla::AlignedStorage2<ValueOperand> value;

     } data;

     AnyRegister &dataTyped() {

         JS_ASSERT(hasTyped());

         return *data.typed.addr();

     }

     ValueOperand &dataValue() {

         JS_ASSERT(hasValue());

         return *data.value.addr();

     }

     const AnyRegister &dataTyped() const {

         JS_ASSERT(hasTyped());

         return *data.typed.addr();

     }

     const ValueOperand &dataValue() const {

         JS_ASSERT(hasValue());

         return *data.value.addr();

     }

   public:

     TypedOrValueRegister()

       : type_(MIRType_None)

     {}

     TypedOrValueRegister(MIRType type, AnyRegister reg)

       : type_(type)

     {

         dataTyped() = reg;

     }

     TypedOrValueRegister(ValueOperand value)

       : type_(MIRType_Value)

     {

         dataValue() = value;

     }

     MIRType type() const {

         return type_;

     }

     bool hasTyped() const {

         return type() != MIRType_None && type() != MIRType_Value;

     }

     bool hasValue() const {

         return type() == MIRType_Value;

     }

     AnyRegister typedReg() const {

         return dataTyped();

     }

     ValueOperand valueReg() const {

         return dataValue();

     }

     AnyRegister scratchReg() {

         if (hasValue())

             return AnyRegister(valueReg().scratchReg());

         return typedReg();

     }

 };

 // A constant value, or registers to hold a typed/untyped value.

 class ConstantOrRegister

 {

     // Whether a constant value is being stored.

     bool constant_;

     // Space to hold either a Value or a TypedOrValueRegister.

     union U {

         mozilla::AlignedStorage2<Value> constant;

         mozilla::AlignedStorage2<TypedOrValueRegister> reg;

     } data;

     Value &dataValue() {

         JS_ASSERT(constant());

         return *data.constant.addr();

     }

     TypedOrValueRegister &dataReg() {

         JS_ASSERT(!constant());

         return *data.reg.addr();

     }

   public:

     ConstantOrRegister()

     {}

     ConstantOrRegister(Value value)

       : constant_(true)

     {

         dataValue() = value;

     }

     ConstantOrRegister(TypedOrValueRegister reg)

       : constant_(false)

     {

         dataReg() = reg;

     }

     bool constant() {

         return constant_;

     }

     Value value() {

         return dataValue();

     }

     TypedOrValueRegister reg() {

         return dataReg();

     }

 };

 struct Int32Key {

     bool isRegister_;

     union {

         Register reg_;

         int32_t constant_;

     };

     explicit Int32Key(Register reg)

       : isRegister_(true), reg_(reg)

     { }

     explicit Int32Key(int32_t index)

       : isRegister_(false), constant_(index)

     { }

     inline void bumpConstant(int diff) {

         JS_ASSERT(!isRegister_);

         constant_ += diff;

     }

     inline Register reg() const {

         JS_ASSERT(isRegister_);

         return reg_;

     }

     inline int32_t constant() const {

         JS_ASSERT(!isRegister_);

         return constant_;

     }

     inline bool isRegister() const {

         return isRegister_;

     }

     inline bool isConstant() const {

         return !isRegister_;

     }

 };

 template <typename T>

 class TypedRegisterSet

 {

     uint32_t bits_;

   public:

     explicit MOZ_CONSTEXPR TypedRegisterSet(uint32_t bits)

       : bits_(bits)

     { }

     MOZ_CONSTEXPR TypedRegisterSet() : bits_(0)

     { }

     MOZ_CONSTEXPR TypedRegisterSet(const TypedRegisterSet<T> &set) : bits_(set.bits_)

     { }

     static inline TypedRegisterSet All() {

         return TypedRegisterSet(T::Codes::AllocatableMask);

     }

     static inline TypedRegisterSet Intersect(const TypedRegisterSet &lhs,

                                              const TypedRegisterSet &rhs) {

         return TypedRegisterSet(lhs.bits_ & rhs.bits_);

     }

     static inline TypedRegisterSet Union(const TypedRegisterSet &lhs,

                                          const TypedRegisterSet &rhs) {

         return TypedRegisterSet(lhs.bits_ | rhs.bits_);

     }

     static inline TypedRegisterSet Not(const TypedRegisterSet &in) {

         return TypedRegisterSet(~in.bits_ & T::Codes::AllocatableMask);

     }

     static inline TypedRegisterSet VolatileNot(const TypedRegisterSet &in) {

         const uint32_t allocatableVolatile =

             T::Codes::AllocatableMask & T::Codes::VolatileMask;

         return TypedRegisterSet(~in.bits_ & allocatableVolatile);

     }

     static inline TypedRegisterSet Volatile() {

         return TypedRegisterSet(T::Codes::AllocatableMask & T::Codes::VolatileMask);

     }

     static inline TypedRegisterSet NonVolatile() {

         return TypedRegisterSet(T::Codes::AllocatableMask & T::Codes::NonVolatileMask);

     }

     bool has(T reg) const {

         return !!(bits_ & (1 << reg.code()));

     }

     void addUnchecked(T reg) {

         bits_ |= (1 << reg.code());

     }

     void add(T reg) {

         JS_ASSERT(!has(reg));

         addUnchecked(reg);

     }

     void add(ValueOperand value) {

 #if defined(JS_NUNBOX32)

         add(value.payloadReg());

         add(value.typeReg());

 #elif defined(JS_PUNBOX64)

         add(value.valueReg());

 #else

 #error "Bad architecture"

 #endif

     }

     // Determemine if some register are still allocated.  This function should

     // be used with the set of allocatable registers used for the initialization

     // of the current set.

     bool someAllocated(const TypedRegisterSet &allocatable) const {

         return allocatable.bits_ & ~bits_;

     }

     bool empty() const {

         return !bits_;

     }

     void take(T reg) {

         JS_ASSERT(has(reg));

         takeUnchecked(reg);

     }

     void takeUnchecked(T reg) {

         bits_ &= ~(1 << reg.code());

     }

     void take(ValueOperand value) {

 #if defined(JS_NUNBOX32)

         take(value.payloadReg());

         take(value.typeReg());

 #elif defined(JS_PUNBOX64)

         take(value.valueReg());

 #else

 #error "Bad architecture"

 #endif

     }

     void takeUnchecked(ValueOperand value) {

 #if defined(JS_NUNBOX32)

         takeUnchecked(value.payloadReg());

         takeUnchecked(value.typeReg());

 #elif defined(JS_PUNBOX64)

         takeUnchecked(value.valueReg());

 #else

 #error "Bad architecture"

 #endif

     }

     ValueOperand takeValueOperand() {

 #if defined(JS_NUNBOX32)

         return ValueOperand(takeAny(), takeAny());

 #elif defined(JS_PUNBOX64)

         return ValueOperand(takeAny());

 #else

 #error "Bad architecture"

 #endif

     }

     T getAny() const {

         // The choice of first or last here is mostly arbitrary, as they are

         // about the same speed on popular architectures. We choose first, as

         // it has the advantage of using the "lower" registers more often. These

         // registers are sometimes more efficient (e.g. optimized encodings for

         // EAX on x86).

         return getFirst();

     }

     T getAnyExcluding(T preclude) {

         JS_ASSERT(!empty());

         if (!has(preclude))

             return getAny();

         take(preclude);

         JS_ASSERT(!empty());

         T result = getAny();

         add(preclude);

         return result;

     }

     T getFirst() const {

         JS_ASSERT(!empty());

         return T::FromCode(mozilla::CountTrailingZeroes32(bits_));

     }

     T getLast() const {

         JS_ASSERT(!empty());

         int ireg = 31 - mozilla::CountLeadingZeroes32(bits_);

         return T::FromCode(ireg);

     }

     T takeAny() {

         JS_ASSERT(!empty());

         T reg = getAny();

         take(reg);

         return reg;

     }

     T takeAnyExcluding(T preclude) {

         T reg = getAnyExcluding(preclude);

         take(reg);

         return reg;

     }

     ValueOperand takeAnyValue() {

 #if defined(JS_NUNBOX32)

         T type = takeAny();

         T payload = takeAny();

         return ValueOperand(type, payload);

 #elif defined(JS_PUNBOX64)

         T reg = takeAny();

         return ValueOperand(reg);

 #else

 #error "Bad architecture"

 #endif

     }

     T takeFirst() {

         JS_ASSERT(!empty());

         T reg = getFirst();

         take(reg);

         return reg;

     }

     T takeLast() {

         JS_ASSERT(!empty());

         T reg = getLast();

         take(reg);

         return reg;

     }

     void clear() {

         bits_ = 0;

     }

     uint32_t bits() const {

         return bits_;

     }

     uint32_t size() const {

         return mozilla::CountPopulation32(bits_);

     }

     bool operator ==(const TypedRegisterSet<T> &other) const {

         return other.bits_ == bits_;

     }

 };

 typedef TypedRegisterSet<Register> GeneralRegisterSet;

 typedef TypedRegisterSet<FloatRegister> FloatRegisterSet;

 class AnyRegisterIterator;

 class RegisterSet {

     GeneralRegisterSet gpr_;

     FloatRegisterSet fpu_;

     friend class AnyRegisterIterator;

   public:

     RegisterSet()

     { }

     MOZ_CONSTEXPR RegisterSet(const GeneralRegisterSet &gpr, const FloatRegisterSet &fpu)

       : gpr_(gpr),

         fpu_(fpu)

     { }

     static inline RegisterSet All() {

         return RegisterSet(GeneralRegisterSet::All(), FloatRegisterSet::All());

     }

     static inline RegisterSet Intersect(const RegisterSet &lhs, const RegisterSet &rhs) {

         return RegisterSet(GeneralRegisterSet::Intersect(lhs.gpr_, rhs.gpr_),

                            FloatRegisterSet::Intersect(lhs.fpu_, rhs.fpu_));

     }

     static inline RegisterSet Union(const RegisterSet &lhs, const RegisterSet &rhs) {

         return RegisterSet(GeneralRegisterSet::Union(lhs.gpr_, rhs.gpr_),

                            FloatRegisterSet::Union(lhs.fpu_, rhs.fpu_));

     }

     static inline RegisterSet Not(const RegisterSet &in) {

         return RegisterSet(GeneralRegisterSet::Not(in.gpr_),

                            FloatRegisterSet::Not(in.fpu_));

     }

     static inline RegisterSet VolatileNot(const RegisterSet &in) {

         return RegisterSet(GeneralRegisterSet::VolatileNot(in.gpr_),

                            FloatRegisterSet::VolatileNot(in.fpu_));

     }

     static inline RegisterSet Volatile() {

         return RegisterSet(GeneralRegisterSet::Volatile(), FloatRegisterSet::Volatile());

     }

     bool has(Register reg) const {

         return gpr_.has(reg);

     }

     bool has(FloatRegister reg) const {

         return fpu_.has(reg);

     }

     bool has(AnyRegister reg) const {

         return reg.isFloat() ? has(reg.fpu()) : has(reg.gpr());

     }

     void add(Register reg) {

         gpr_.add(reg);

     }

     void add(FloatRegister reg) {

         fpu_.add(reg);

     }

     void add(const AnyRegister &any) {

         if (any.isFloat())

             add(any.fpu());

         else

             add(any.gpr());

     }

     void add(ValueOperand value) {

 #if defined(JS_NUNBOX32)

         add(value.payloadReg());

         add(value.typeReg());

 #elif defined(JS_PUNBOX64)

         add(value.valueReg());

 #else

 #error "Bad architecture"

 #endif

     }

     void add(TypedOrValueRegister reg) {

         if (reg.hasValue())

             add(reg.valueReg());

         else if (reg.hasTyped())

             add(reg.typedReg());

     }

     void addUnchecked(Register reg) {

         gpr_.addUnchecked(reg);

     }

     void addUnchecked(FloatRegister reg) {

         fpu_.addUnchecked(reg);

     }

     void addUnchecked(const AnyRegister &any) {

         if (any.isFloat())

             addUnchecked(any.fpu());

         else

             addUnchecked(any.gpr());

     }

     bool empty(bool floats) const {

         return floats ? fpu_.empty() : gpr_.empty();

     }

     FloatRegister takeFloat() {

         return fpu_.takeAny();

     }

     Register takeGeneral() {

         return gpr_.takeAny();

     }

     ValueOperand takeValueOperand() {

 #if defined(JS_NUNBOX32)

         return ValueOperand(takeGeneral(), takeGeneral());

 #elif defined(JS_PUNBOX64)

         return ValueOperand(takeGeneral());

 #else

 #error "Bad architecture"

 #endif

     }

     void take(const AnyRegister &reg) {

         if (reg.isFloat())

             fpu_.take(reg.fpu());

         else

             gpr_.take(reg.gpr());

     }

     AnyRegister takeAny(bool isFloat) {

         if (isFloat)

             return AnyRegister(takeFloat());

         return AnyRegister(takeGeneral());

     }

     void clear() {

         gpr_.clear();

         fpu_.clear();

     }

     MOZ_CONSTEXPR GeneralRegisterSet gprs() const {

         return gpr_;

     }

     MOZ_CONSTEXPR FloatRegisterSet fpus() const {

         return fpu_;

     }

     bool operator ==(const RegisterSet &other) const {

         return other.gpr_ == gpr_ && other.fpu_ == fpu_;

     }

     void takeUnchecked(Register reg) {

         gpr_.takeUnchecked(reg);

     }

     void takeUnchecked(FloatRegister reg) {

         fpu_.takeUnchecked(reg);

     }

     void takeUnchecked(AnyRegister reg) {

         if (reg.isFloat())

             fpu_.takeUnchecked(reg.fpu());

         else

             gpr_.takeUnchecked(reg.gpr());

     }

     void takeUnchecked(ValueOperand value) {

         gpr_.takeUnchecked(value);

     }

     void takeUnchecked(TypedOrValueRegister reg) {

         if (reg.hasValue())

             takeUnchecked(reg.valueReg());

         else if (reg.hasTyped())

             takeUnchecked(reg.typedReg());

     }

 };

 // iterates in whatever order happens to be convenient.

 // Use TypedRegisterBackwardIterator or TypedRegisterForwardIterator if a

 // specific order is required.

 template <typename T>

 class TypedRegisterIterator

 {

     TypedRegisterSet<T> regset_;

   public:

     TypedRegisterIterator(TypedRegisterSet<T> regset) : regset_(regset)

     { }

     TypedRegisterIterator(const TypedRegisterIterator &other) : regset_(other.regset_)

     { }

     bool more() const {

         return !regset_.empty();

     }

     TypedRegisterIterator<T> operator ++(int) {

         TypedRegisterIterator<T> old(*this);

         regset_.takeAny();

         return old;

     }

     TypedRegisterIterator<T>& operator ++() {

         regset_.takeAny();

         return *this;

     }

     T operator *() const {

         return regset_.getAny();

     }

 };

 // iterates backwards, that is, rn to r0

 template <typename T>

 class TypedRegisterBackwardIterator

 {

     TypedRegisterSet<T> regset_;

   public:

     TypedRegisterBackwardIterator(TypedRegisterSet<T> regset) : regset_(regset)

     { }

     TypedRegisterBackwardIterator(const TypedRegisterBackwardIterator &other)

       : regset_(other.regset_)

     { }

     bool more() const {

         return !regset_.empty();

     }

     TypedRegisterBackwardIterator<T> operator ++(int) {

         TypedRegisterBackwardIterator<T> old(*this);

         regset_.takeLast();

         return old;

     }

     TypedRegisterBackwardIterator<T>& operator ++() {

         regset_.takeLast();

         return *this;

     }

     T operator *() const {

         return regset_.getLast();

     }

 };

 // iterates forwards, that is r0 to rn

 template <typename T>

 class TypedRegisterForwardIterator

 {

     TypedRegisterSet<T> regset_;

   public:

     TypedRegisterForwardIterator(TypedRegisterSet<T> regset) : regset_(regset)

     { }

     TypedRegisterForwardIterator(const TypedRegisterForwardIterator &other) : regset_(other.regset_)

     { }

     bool more() const {

         return !regset_.empty();

     }

     TypedRegisterForwardIterator<T> operator ++(int) {

         TypedRegisterForwardIterator<T> old(*this);

         regset_.takeFirst();

         return old;

     }

     TypedRegisterForwardIterator<T>& operator ++() {

         regset_.takeFirst();

         return *this;

     }

     T operator *() const {

         return regset_.getFirst();

     }

 };

 typedef TypedRegisterIterator<Register> GeneralRegisterIterator;

 typedef TypedRegisterIterator<FloatRegister> FloatRegisterIterator;

 typedef TypedRegisterBackwardIterator<Register> GeneralRegisterBackwardIterator;

 typedef TypedRegisterBackwardIterator<FloatRegister> FloatRegisterBackwardIterator;

 typedef TypedRegisterForwardIterator<Register> GeneralRegisterForwardIterator;

 typedef TypedRegisterForwardIterator<FloatRegister> FloatRegisterForwardIterator;

 class AnyRegisterIterator

 {

     GeneralRegisterIterator geniter_;

     FloatRegisterIterator floatiter_;

   public:

     AnyRegisterIterator()

       : geniter_(GeneralRegisterSet::All()), floatiter_(FloatRegisterSet::All())

     { }

     AnyRegisterIterator(GeneralRegisterSet genset, FloatRegisterSet floatset)

       : geniter_(genset), floatiter_(floatset)

     { }

     AnyRegisterIterator(const RegisterSet &set)

       : geniter_(set.gpr_), floatiter_(set.fpu_)

     { }

     AnyRegisterIterator(const AnyRegisterIterator &other)

       : geniter_(other.geniter_), floatiter_(other.floatiter_)

     { }

     bool more() const {

         return geniter_.more() || floatiter_.more();

     }

     AnyRegisterIterator operator ++(int) {

         AnyRegisterIterator old(*this);

         if (geniter_.more())

             geniter_++;

         else

             floatiter_++;

         return old;

     }

     AnyRegister operator *() const {

         if (geniter_.more())

             return AnyRegister(*geniter_);

         return AnyRegister(*floatiter_);

     }

 };

 class ABIArg

 {

   public:

     enum Kind { GPR, FPU, Stack };

   private:

     Kind kind_;

     union {

         Registers::Code gpr_;

         FloatRegisters::Code fpu_;

         uint32_t offset_;

     } u;

   public:

     ABIArg() : kind_(Kind(-1)) { u.offset_ = -1; }

     ABIArg(Register gpr) : kind_(GPR) { u.gpr_ = gpr.code(); }

     ABIArg(FloatRegister fpu) : kind_(FPU) { u.fpu_ = fpu.code(); }

     ABIArg(uint32_t offset) : kind_(Stack) { u.offset_ = offset; }

     Kind kind() const { return kind_; }

     Register gpr() const { JS_ASSERT(kind() == GPR); return Register::FromCode(u.gpr_); }

     FloatRegister fpu() const { JS_ASSERT(kind() == FPU); return FloatRegister::FromCode(u.fpu_); }

     uint32_t offsetFromArgBase() const { JS_ASSERT(kind() == Stack); return u.offset_; }

     bool argInRegister() const { return kind() != Stack; }

     AnyRegister reg() const { return kind_ == GPR ? AnyRegister(gpr()) : AnyRegister(fpu()); }

 };

 } // namespace jit

 } // namespace js

 #endif /* jit_RegisterSets_h */