Revision: 19156
Author: [email protected]
Date: Thu Feb 6 13:19:27 2014 UTC
Log: A64: Eliminate static initializers
[email protected], [email protected]
BUG=none
LOG=y
Review URL: https://codereview.chromium.org/143493006
http://code.google.com/p/v8/source/detail?r=19156
Modified:
/branches/experimental/a64/src/a64/assembler-a64-inl.h
/branches/experimental/a64/src/a64/assembler-a64.cc
/branches/experimental/a64/src/a64/assembler-a64.h
/branches/experimental/a64/src/a64/code-stubs-a64.cc
/branches/experimental/a64/src/a64/constants-a64.h
/branches/experimental/a64/src/a64/debug-a64.cc
/branches/experimental/a64/src/a64/frames-a64.h
/branches/experimental/a64/src/a64/instructions-a64.cc
/branches/experimental/a64/src/a64/instructions-a64.h
/branches/experimental/a64/src/a64/lithium-gap-resolver-a64.cc
/branches/experimental/a64/src/a64/lithium-gap-resolver-a64.h
/branches/experimental/a64/src/a64/macro-assembler-a64.h
/branches/experimental/a64/src/a64/regexp-macro-assembler-a64.cc
/branches/experimental/a64/test/cctest/test-utils-a64.cc
=======================================
--- /branches/experimental/a64/src/a64/assembler-a64-inl.h Wed Feb 5
17:41:02 2014 UTC
+++ /branches/experimental/a64/src/a64/assembler-a64-inl.h Thu Feb 6
13:19:27 2014 UTC
@@ -55,44 +55,44 @@
inline unsigned CPURegister::code() const {
ASSERT(IsValid());
- return code_;
+ return reg_code;
}
inline CPURegister::RegisterType CPURegister::type() const {
ASSERT(IsValidOrNone());
- return type_;
+ return reg_type;
}
inline RegList CPURegister::Bit() const {
- ASSERT(code_ < (sizeof(RegList) * kBitsPerByte));
- return IsValid() ? 1UL << code_ : 0;
+ ASSERT(reg_code < (sizeof(RegList) * kBitsPerByte));
+ return IsValid() ? 1UL << reg_code : 0;
}
inline unsigned CPURegister::SizeInBits() const {
ASSERT(IsValid());
- return size_;
+ return reg_size;
}
inline int CPURegister::SizeInBytes() const {
ASSERT(IsValid());
ASSERT(SizeInBits() % 8 == 0);
- return size_ / 8;
+ return reg_size / 8;
}
inline bool CPURegister::Is32Bits() const {
ASSERT(IsValid());
- return size_ == 32;
+ return reg_size == 32;
}
inline bool CPURegister::Is64Bits() const {
ASSERT(IsValid());
- return size_ == 64;
+ return reg_size == 64;
}
@@ -109,46 +109,46 @@
inline bool CPURegister::IsValidRegister() const {
return IsRegister() &&
- ((size_ == kWRegSize) || (size_ == kXRegSize)) &&
- ((code_ < kNumberOfRegisters) || (code_ == kSPRegInternalCode));
+ ((reg_size == kWRegSize) || (reg_size == kXRegSize)) &&
+ ((reg_code < kNumberOfRegisters) || (reg_code ==
kSPRegInternalCode));
}
inline bool CPURegister::IsValidFPRegister() const {
return IsFPRegister() &&
- ((size_ == kSRegSize) || (size_ == kDRegSize)) &&
- (code_ < kNumberOfFPRegisters);
+ ((reg_size == kSRegSize) || (reg_size == kDRegSize)) &&
+ (reg_code < kNumberOfFPRegisters);
}
inline bool CPURegister::IsNone() const {
// kNoRegister types should always have size 0 and code 0.
- ASSERT((type_ != kNoRegister) || (code_ == 0));
- ASSERT((type_ != kNoRegister) || (size_ == 0));
+ ASSERT((reg_type != kNoRegister) || (reg_code == 0));
+ ASSERT((reg_type != kNoRegister) || (reg_size == 0));
- return type_ == kNoRegister;
+ return reg_type == kNoRegister;
}
inline bool CPURegister::Is(const CPURegister& other) const {
ASSERT(IsValidOrNone() && other.IsValidOrNone());
- return (code_ == other.code_) && (size_ == other.size_) &&
- (type_ == other.type_);
+ return (reg_code == other.reg_code) && (reg_size == other.reg_size) &&
+ (reg_type == other.reg_type);
}
inline bool CPURegister::IsRegister() const {
- return type_ == kRegister;
+ return reg_type == kRegister;
}
inline bool CPURegister::IsFPRegister() const {
- return type_ == kFPRegister;
+ return reg_type == kFPRegister;
}
inline bool CPURegister::IsSameSizeAndType(const CPURegister& other) const
{
- return (size_ == other.size_) && (type_ == other.type_);
+ return (reg_size == other.reg_size) && (reg_type == other.reg_type);
}
@@ -159,13 +159,13 @@
inline bool CPURegister::IsZero() const {
ASSERT(IsValid());
- return IsRegister() && (code_ == kZeroRegCode);
+ return IsRegister() && (reg_code == kZeroRegCode);
}
inline bool CPURegister::IsSP() const {
ASSERT(IsValid());
- return IsRegister() && (code_ == kSPRegInternalCode);
+ return IsRegister() && (reg_code == kSPRegInternalCode);
}
@@ -201,65 +201,65 @@
inline void CPURegList::Combine(int code) {
ASSERT(IsValid());
- ASSERT(CPURegister(code, size_, type_).IsValid());
+ ASSERT(CPURegister::Create(code, size_, type_).IsValid());
list_ |= (1UL << code);
}
inline void CPURegList::Remove(int code) {
ASSERT(IsValid());
- ASSERT(CPURegister(code, size_, type_).IsValid());
+ ASSERT(CPURegister::Create(code, size_, type_).IsValid());
list_ &= ~(1UL << code);
}
-inline const Register& Register::XRegFromCode(unsigned code) {
+inline Register Register::XRegFromCode(unsigned code) {
// This function returns the zero register when code = 31. The stack
pointer
// can not be returned.
ASSERT(code < kNumberOfRegisters);
- return xregisters[code];
+ return Register::Create(code, kXRegSize);
}
-inline const Register& Register::WRegFromCode(unsigned code) {
+inline Register Register::WRegFromCode(unsigned code) {
ASSERT(code < kNumberOfRegisters);
- return wregisters[code];
+ return Register::Create(code, kWRegSize);
}
-inline const FPRegister& FPRegister::SRegFromCode(unsigned code) {
+inline FPRegister FPRegister::SRegFromCode(unsigned code) {
ASSERT(code < kNumberOfFPRegisters);
- return sregisters[code];
+ return FPRegister::Create(code, kSRegSize);
}
-inline const FPRegister& FPRegister::DRegFromCode(unsigned code) {
+inline FPRegister FPRegister::DRegFromCode(unsigned code) {
ASSERT(code < kNumberOfFPRegisters);
- return dregisters[code];
+ return FPRegister::Create(code, kDRegSize);
}
-inline const Register& CPURegister::W() const {
+inline Register CPURegister::W() const {
ASSERT(IsValidRegister());
- return Register::WRegFromCode(code_);
+ return Register::WRegFromCode(reg_code);
}
-inline const Register& CPURegister::X() const {
+inline Register CPURegister::X() const {
ASSERT(IsValidRegister());
- return Register::XRegFromCode(code_);
+ return Register::XRegFromCode(reg_code);
}
-inline const FPRegister& CPURegister::S() const {
+inline FPRegister CPURegister::S() const {
ASSERT(IsValidFPRegister());
- return FPRegister::SRegFromCode(code_);
+ return FPRegister::SRegFromCode(reg_code);
}
-inline const FPRegister& CPURegister::D() const {
+inline FPRegister CPURegister::D() const {
ASSERT(IsValidFPRegister());
- return FPRegister::DRegFromCode(code_);
+ return FPRegister::DRegFromCode(reg_code);
}
=======================================
--- /branches/experimental/a64/src/a64/assembler-a64.cc Thu Feb 6 11:53:35
2014 UTC
+++ /branches/experimental/a64/src/a64/assembler-a64.cc Thu Feb 6 13:19:27
2014 UTC
@@ -30,6 +30,8 @@
#if V8_TARGET_ARCH_A64
+#define A64_DEFINE_REG_STATICS
+
#include "a64/assembler-a64-inl.h"
namespace v8 {
@@ -55,7 +57,7 @@
int index = CountTrailingZeros(list_, kRegListSizeInBits);
ASSERT((1 << index) & list_);
Remove(index);
- return CPURegister(index, size_, type_);
+ return CPURegister::Create(index, size_, type_);
}
@@ -68,7 +70,7 @@
index = kRegListSizeInBits - 1 - index;
ASSERT((1 << index) & list_);
Remove(index);
- return CPURegister(index, size_, type_);
+ return CPURegister::Create(index, size_, type_);
}
@@ -109,12 +111,6 @@
list.Combine(CPURegList(CPURegister::kFPRegister, size, 16, 31));
return list;
}
-
-
-const CPURegList kCalleeSaved = CPURegList::GetCalleeSaved();
-const CPURegList kCalleeSavedFP = CPURegList::GetCalleeSavedFP();
-const CPURegList kCallerSaved = CPURegList::GetCallerSaved();
-const CPURegList kCallerSavedFP = CPURegList::GetCallerSavedFP();
// This function defines the list of registers which are associated with a
@@ -183,31 +179,6 @@
UNIMPLEMENTED();
}
-
-// Registers.
-#define XREG(n) x##n,
-const Register Register::xregisters[] = {
-REGISTER_CODE_LIST(XREG)
-};
-#undef XREG
-
-#define WREG(n) w##n,
-const Register Register::wregisters[] = {
-REGISTER_CODE_LIST(WREG)
-};
-#undef WREG
-
-#define SREG(n) s##n,
-const FPRegister FPRegister::sregisters[] = {
-REGISTER_CODE_LIST(SREG)
-};
-#undef SREG
-
-#define DREG(n) d##n,
-const FPRegister FPRegister::dregisters[] = {
-REGISTER_CODE_LIST(DREG)
-};
-#undef DREG
bool AreAliased(const CPURegister& reg1, const CPURegister& reg2,
const CPURegister& reg3, const CPURegister& reg4,
@@ -1955,7 +1926,7 @@
ASSERT(rd.SizeInBits() >= rn.SizeInBits());
unsigned reg_size = rd.SizeInBits();
// Use the correct size of register.
- Register rn_ = Register(rn.code(), rd.SizeInBits());
+ Register rn_ = Register::Create(rn.code(), rd.SizeInBits());
// Bits extracted are high_bit:0.
unsigned high_bit = (8 << (extend & 0x3)) - 1;
// Number of bits left in the result that are not introduced by the
shift.
=======================================
--- /branches/experimental/a64/src/a64/assembler-a64.h Wed Feb 5 17:41:02
2014 UTC
+++ /branches/experimental/a64/src/a64/assembler-a64.h Thu Feb 6 13:19:27
2014 UTC
@@ -60,8 +60,7 @@
class FPRegister;
-class CPURegister {
- public:
+struct CPURegister {
enum RegisterType {
// The kInvalid value is used to detect uninitialized static instances,
// which are always zero-initialized before any constructors are
called.
@@ -71,25 +70,9 @@
kNoRegister
};
- CPURegister() : code_(0), size_(0), type_(kNoRegister) {
- ASSERT(!IsValid());
- ASSERT(IsNone());
- }
-
- CPURegister(unsigned code, unsigned size, RegisterType type)
- : code_(code), size_(size), type_(type) {
- ASSERT(IsValidOrNone());
- }
-
- // This copy constructor is used by the Register and FPRegister classes
for
- // converting a CPURegister into a more specialized type. It is necessary
- // because (FP)Register cannot directly access other.size_ and suchlike
and
- // the accessor methods don't allow NoCPUReg. Unfortunately, it cannot be
- // explicit because otherwise the simple (FP)Register->CPURegister casts
do
- // not work.
- CPURegister(const CPURegister& other)
- : code_(other.code_), size_(other.size_), type_(other.type_) {
- ASSERT(IsValidOrNone());
+ static CPURegister Create(unsigned code, unsigned size, RegisterType
type) {
+ CPURegister r = {code, size, type};
+ return r;
}
unsigned code() const;
@@ -111,10 +94,10 @@
bool IsRegister() const;
bool IsFPRegister() const;
- const Register& X() const;
- const Register& W() const;
- const FPRegister& D() const;
- const FPRegister& S() const;
+ Register X() const;
+ Register W() const;
+ FPRegister D() const;
+ FPRegister S() const;
bool IsSameSizeAndType(const CPURegister& other) const;
@@ -122,32 +105,40 @@
bool is(const CPURegister& other) const { return Is(other); }
bool is_valid() const { return IsValid(); }
- protected:
- unsigned code_;
- unsigned size_;
- RegisterType type_;
+ unsigned reg_code;
+ unsigned reg_size;
+ RegisterType reg_type;
private:
bool IsValidOrNone() const;
};
-class Register : public CPURegister {
- public:
- Register() : CPURegister() {}
- explicit Register(const CPURegister& other) : CPURegister(other) {
- ASSERT(IsValidRegister() || IsNone());
+struct Register : public CPURegister {
+ static Register Create(unsigned code, unsigned size) {
+ return CPURegister::Create(code, size, CPURegister::kRegister);
}
- Register(unsigned code, unsigned size)
- : CPURegister(code, size, kRegister) {}
+
+ Register() {
+ reg_code = 0;
+ reg_size = 0;
+ reg_type = CPURegister::kNoRegister;
+ }
+
+ Register(const CPURegister& r) { // NOLINT(runtime/explicit)
+ reg_code = r.reg_code;
+ reg_size = r.reg_size;
+ reg_type = r.reg_type;
+ ASSERT(IsValid());
+ }
bool IsValid() const {
ASSERT(IsRegister() || IsNone());
return IsValidRegister();
}
- static const Register& XRegFromCode(unsigned code);
- static const Register& WRegFromCode(unsigned code);
+ static Register XRegFromCode(unsigned code);
+ static Register WRegFromCode(unsigned code);
// Start of V8 compatibility section ---------------------
// These memebers are necessary for compilation.
@@ -181,9 +172,9 @@
// Return true if the register is one that crankshaft can allocate.
bool IsAllocatable() const {
- return (code_ <= kAllocatableLowRangeEnd) ||
- ((code_ >= kAllocatableHighRangeBegin) &&
- (code_ <= kAllocatableHighRangeEnd));
+ return (reg_code <= kAllocatableLowRangeEnd) ||
+ ((reg_code >= kAllocatableHighRangeBegin) &&
+ (reg_code <= kAllocatableHighRangeEnd));
}
static Register FromAllocationIndex(unsigned index) {
@@ -219,34 +210,38 @@
static Register from_code(int code) {
// Always return an X register.
- Register r(code, kXRegSize);
- return r;
+ return Register::Create(code, kXRegSize);
}
// End of V8 compatibility section -----------------------
-
- private:
- static const Register xregisters[];
- static const Register wregisters[];
};
-class FPRegister : public CPURegister {
- public:
- FPRegister() : CPURegister() {}
- explicit FPRegister(const CPURegister& other) : CPURegister(other) {
- ASSERT(IsValidFPRegister() || IsNone());
+struct FPRegister : public CPURegister {
+ static FPRegister Create(unsigned code, unsigned size) {
+ return CPURegister::Create(code, size, CPURegister::kFPRegister);
}
- FPRegister(unsigned code, unsigned size)
- : CPURegister(code, size, kFPRegister) {}
+
+ FPRegister() {
+ reg_code = 0;
+ reg_size = 0;
+ reg_type = CPURegister::kNoRegister;
+ }
+
+ FPRegister(const CPURegister& r) { // NOLINT(runtime/explicit)
+ reg_code = r.reg_code;
+ reg_size = r.reg_size;
+ reg_type = r.reg_type;
+ ASSERT(IsValid());
+ }
bool IsValid() const {
ASSERT(IsFPRegister() || IsNone());
return IsValidFPRegister();
}
- static const FPRegister& SRegFromCode(unsigned code);
- static const FPRegister& DRegFromCode(unsigned code);
+ static FPRegister SRegFromCode(unsigned code);
+ static FPRegister DRegFromCode(unsigned code);
// Start of V8 compatibility section ---------------------
static const int kMaxNumRegisters = kNumberOfFPRegisters;
@@ -286,71 +281,91 @@
static FPRegister from_code(int code) {
// Always return a D register.
- FPRegister r(code, kDRegSize);
- return r;
+ return FPRegister::Create(code, kDRegSize);
}
// End of V8 compatibility section -----------------------
+};
+
+
+STATIC_ASSERT(sizeof(CPURegister) == sizeof(Register));
+STATIC_ASSERT(sizeof(CPURegister) == sizeof(FPRegister));
- private:
- static const FPRegister sregisters[];
- static const FPRegister dregisters[];
-};
+#if defined(A64_DEFINE_REG_STATICS)
+#define INITIALIZE_REGISTER(register_class, name, code, size, type) \
+ const CPURegister init_##register_class##_##name = {code, size, type}; \
+ const register_class& name = *reinterpret_cast<const register_class*>( \
+ &init_##register_class##_##name)
+#define ALIAS_REGISTER(register_class, alias, name) \
+ const register_class& alias = *reinterpret_cast<const register_class*>( \
+ &init_##register_class##_##name)
+#else
+#define INITIALIZE_REGISTER(register_class, name, code, size, type) \
+ extern const register_class& name
+#define ALIAS_REGISTER(register_class, alias, name) \
+ extern const register_class& alias
+#endif // defined(A64_DEFINE_REG_STATICS)
// No*Reg is used to indicate an unused argument, or an error case. Note
that
// these all compare equal (using the Is() method). The Register and
FPRegister
// variants are provided for convenience.
-const Register NoReg;
-const FPRegister NoFPReg;
-const CPURegister NoCPUReg;
-
-const Register no_reg; // v8 compatibility.
+INITIALIZE_REGISTER(Register, NoReg, 0, 0, CPURegister::kNoRegister);
+INITIALIZE_REGISTER(FPRegister, NoFPReg, 0, 0, CPURegister::kNoRegister);
+INITIALIZE_REGISTER(CPURegister, NoCPUReg, 0, 0, CPURegister::kNoRegister);
+// v8 compatibility.
+INITIALIZE_REGISTER(Register, no_reg, 0, 0, CPURegister::kNoRegister);
-#define DEFINE_REGISTERS(N) \
-const Register w##N(N, kWRegSize); \
-const Register x##N(N, kXRegSize);
+#define
DEFINE_REGISTERS(N) \
+ INITIALIZE_REGISTER(Register, w##N, N, kWRegSize,
CPURegister::kRegister); \
+ INITIALIZE_REGISTER(Register, x##N, N, kXRegSize,
CPURegister::kRegister);
REGISTER_CODE_LIST(DEFINE_REGISTERS)
#undef DEFINE_REGISTERS
-const Register wcsp(kSPRegInternalCode, kWRegSize);
-const Register csp(kSPRegInternalCode, kXRegSize);
+INITIALIZE_REGISTER(Register, wcsp, kSPRegInternalCode, kWRegSize,
+ CPURegister::kRegister);
+INITIALIZE_REGISTER(Register, csp, kSPRegInternalCode, kXRegSize,
+ CPURegister::kRegister);
-#define DEFINE_FPREGISTERS(N) \
-const FPRegister s##N(N, kSRegSize); \
-const FPRegister d##N(N, kDRegSize);
+#define DEFINE_FPREGISTERS(N) \
+ INITIALIZE_REGISTER(FPRegister, s##N, N, kSRegSize, \
+ CPURegister::kFPRegister); \
+ INITIALIZE_REGISTER(FPRegister, d##N, N, kDRegSize,
CPURegister::kFPRegister);
REGISTER_CODE_LIST(DEFINE_FPREGISTERS)
#undef DEFINE_FPREGISTERS
+#undef INITIALIZE_REGISTER
// Registers aliases.
-const Register ip0 = x16;
-const Register ip1 = x17;
-const Register wip0 = w16;
-const Register wip1 = w17;
+ALIAS_REGISTER(Register, ip0, x16);
+ALIAS_REGISTER(Register, ip1, x17);
+ALIAS_REGISTER(Register, wip0, w16);
+ALIAS_REGISTER(Register, wip1, w17);
// Root register.
-const Register root = x26;
-const Register rr = root;
+ALIAS_REGISTER(Register, root, x26);
+ALIAS_REGISTER(Register, rr, x26);
// Context pointer register.
-const Register cp = x27;
+ALIAS_REGISTER(Register, cp, x27);
// We use a register as a JS stack pointer to overcome the restriction on
the
// architectural SP alignment.
// We chose x28 because it is contiguous with the other specific purpose
// registers.
STATIC_ASSERT(kJSSPCode == 28);
-const Register jssp = x28;
-const Register wjssp = w28;
-const Register fp = x29;
-const Register lr = x30;
-const Register xzr = x31;
-const Register wzr = w31;
+ALIAS_REGISTER(Register, jssp, x28);
+ALIAS_REGISTER(Register, wjssp, w28);
+ALIAS_REGISTER(Register, fp, x29);
+ALIAS_REGISTER(Register, lr, x30);
+ALIAS_REGISTER(Register, xzr, x31);
+ALIAS_REGISTER(Register, wzr, w31);
// Crankshaft double scratch register.
-const FPRegister crankshaft_fp_scratch = d29;
+ALIAS_REGISTER(FPRegister, crankshaft_fp_scratch, d29);
// Keeps the 0 double value.
-const FPRegister fp_zero = d30;
+ALIAS_REGISTER(FPRegister, fp_zero, d30);
// MacroAssembler double scratch register.
-const FPRegister fp_scratch = d31;
+ALIAS_REGISTER(FPRegister, fp_scratch, d31);
+
+#undef ALIAS_REGISTER
// AreAliased returns true if any of the named registers overlap.
Arguments set
// to NoReg are ignored. The system stack pointer may be specified.
@@ -497,7 +512,7 @@
// Try to create a CPURegister for each element in the list.
for (int i = 0; i < kRegListSizeInBits; i++) {
if (((list_ >> i) & 1) != 0) {
- is_valid &= CPURegister(i, size_, type_).IsValid();
+ is_valid &= CPURegister::Create(i, size_, type_).IsValid();
}
}
return is_valid;
@@ -513,13 +528,13 @@
// AAPCS64 callee-saved registers.
-extern const CPURegList kCalleeSaved;
-extern const CPURegList kCalleeSavedFP;
+#define kCalleeSaved CPURegList::GetCalleeSaved()
+#define kCalleeSavedFP CPURegList::GetCalleeSavedFP()
// AAPCS64 caller-saved registers. Note that this includes lr.
-extern const CPURegList kCallerSaved;
-extern const CPURegList kCallerSavedFP;
+#define kCallerSaved CPURegList::GetCallerSaved()
+#define kCallerSavedFP CPURegList::GetCallerSavedFP()
//
-----------------------------------------------------------------------------
=======================================
--- /branches/experimental/a64/src/a64/code-stubs-a64.cc Wed Feb 5
19:41:46 2014 UTC
+++ /branches/experimental/a64/src/a64/code-stubs-a64.cc Thu Feb 6
13:19:27 2014 UTC
@@ -5180,40 +5180,43 @@
__ Pop(x1, x0);
}
+#define MINOR_KEY_FOR(obj, value, addr, action, fp_mode) \
+ ((obj) | ((value) << 5) | ((addr) << 10) | ((action) << 15) | \
+ ((fp_mode) << 16))
const int RecordWriteStub::kAheadOfTime[] = {
// Arguments to MinorKeyFor() are object, value and address registers.
// Used in StoreArrayLiteralElementStub::Generate.
- MinorKeyFor(x10, x0, x11, EMIT_REMEMBERED_SET, kDontSaveFPRegs),
+ MINOR_KEY_FOR(10, 0, 11, EMIT_REMEMBERED_SET, kDontSaveFPRegs),
// Used in FastNewClosure::Generate.
- MinorKeyFor(x5, x4, x1, EMIT_REMEMBERED_SET, kDontSaveFPRegs),
+ MINOR_KEY_FOR(5, 4, 1, EMIT_REMEMBERED_SET, kDontSaveFPRegs),
// Used in KeyedStoreStubCompiler::GenerateStoreFastElement.
- MinorKeyFor(x3, x2, x10, EMIT_REMEMBERED_SET, kDontSaveFPRegs),
+ MINOR_KEY_FOR(3, 2, 10, EMIT_REMEMBERED_SET, kDontSaveFPRegs),
// Used in KeyedStoreStubCompiler::GenerateStoreFastDoubleElement.
- MinorKeyFor(x2, x3, x10, EMIT_REMEMBERED_SET, kDontSaveFPRegs),
+ MINOR_KEY_FOR(2, 3, 10, EMIT_REMEMBERED_SET, kDontSaveFPRegs),
// Used in ElementsTransitionGenerator::GenerateSmiToDouble.
- MinorKeyFor(x2, x3, x6, OMIT_REMEMBERED_SET, kDontSaveFPRegs),
- MinorKeyFor(x2, x10, x6, EMIT_REMEMBERED_SET, kDontSaveFPRegs),
+ MINOR_KEY_FOR(2, 3, 6, OMIT_REMEMBERED_SET, kDontSaveFPRegs),
+ MINOR_KEY_FOR(2, 10, 6, EMIT_REMEMBERED_SET, kDontSaveFPRegs),
// Used in ElementsTransitionGenerator::GenerateDoubleToObject.
- MinorKeyFor(x7, x5, x13, EMIT_REMEMBERED_SET, kDontSaveFPRegs),
- MinorKeyFor(x2, x7, x13, EMIT_REMEMBERED_SET, kDontSaveFPRegs),
- MinorKeyFor(x2, x3, x13, OMIT_REMEMBERED_SET, kDontSaveFPRegs),
+ MINOR_KEY_FOR(7, 5, 13, EMIT_REMEMBERED_SET, kDontSaveFPRegs),
+ MINOR_KEY_FOR(2, 7, 13, EMIT_REMEMBERED_SET, kDontSaveFPRegs),
+ MINOR_KEY_FOR(2, 3, 13, OMIT_REMEMBERED_SET, kDontSaveFPRegs),
// Used in KeyedStoreIC::GenerateGeneric helper function.
- MinorKeyFor(x4, x10, x11, EMIT_REMEMBERED_SET, kDontSaveFPRegs),
+ MINOR_KEY_FOR(4, 10, 11, EMIT_REMEMBERED_SET, kDontSaveFPRegs),
// Used in RegExpExecStub::Generate.
- MinorKeyFor(x21, x10, x11, EMIT_REMEMBERED_SET, kDontSaveFPRegs),
+ MINOR_KEY_FOR(21, 10, 11, EMIT_REMEMBERED_SET, kDontSaveFPRegs),
// Used in StringAddStub::Generate.
- MinorKeyFor(x0, x10, x3, EMIT_REMEMBERED_SET, kDontSaveFPRegs),
- MinorKeyFor(x0, x11, x3, EMIT_REMEMBERED_SET, kDontSaveFPRegs),
+ MINOR_KEY_FOR(0, 10, 3, EMIT_REMEMBERED_SET, kDontSaveFPRegs),
+ MINOR_KEY_FOR(0, 11, 3, EMIT_REMEMBERED_SET, kDontSaveFPRegs),
// TODO(jbramley): There are many more sites that want a pregenerated
// instance of this stub, but they are currently unimplemented. Once
they are
@@ -5226,6 +5229,9 @@
};
+#undef MINOR_KEY_FOR
+
+
void RecordWriteStub::GenerateFixedRegStubsAheadOfTime(Isolate* isolate) {
// Pregenerate all of the stub variants in the kAheadOfTime list.
for (const int* entry = kAheadOfTime; *entry != 0; entry++) {
=======================================
--- /branches/experimental/a64/src/a64/constants-a64.h Wed Jan 22 12:46:44
2014 UTC
+++ /branches/experimental/a64/src/a64/constants-a64.h Thu Feb 6 13:19:27
2014 UTC
@@ -65,19 +65,19 @@
// TODO(all): k<Y>RegSize should probably be k<Y>RegSizeInBits.
const unsigned kWRegSize = 32;
const unsigned kWRegSizeLog2 = 5;
-const unsigned kWRegSizeInBytes = kWRegSize / 8;
+const unsigned kWRegSizeInBytes = kWRegSize >> 3;
const unsigned kWRegSizeInBytesLog2 = kWRegSizeLog2 - 3;
const unsigned kXRegSize = 64;
const unsigned kXRegSizeLog2 = 6;
-const unsigned kXRegSizeInBytes = kXRegSize / 8;
+const unsigned kXRegSizeInBytes = kXRegSize >> 3;
const unsigned kXRegSizeInBytesLog2 = kXRegSizeLog2 - 3;
const unsigned kSRegSize = 32;
const unsigned kSRegSizeLog2 = 5;
-const unsigned kSRegSizeInBytes = kSRegSize / 8;
+const unsigned kSRegSizeInBytes = kSRegSize >> 3;
const unsigned kSRegSizeInBytesLog2 = kSRegSizeLog2 - 3;
const unsigned kDRegSize = 64;
const unsigned kDRegSizeLog2 = 6;
-const unsigned kDRegSizeInBytes = kDRegSize / 8;
+const unsigned kDRegSizeInBytes = kDRegSize >> 3;
const unsigned kDRegSizeInBytesLog2 = kDRegSizeLog2 - 3;
const int64_t kWRegMask = 0x00000000ffffffffL;
const int64_t kXRegMask = 0xffffffffffffffffL;
@@ -108,19 +108,19 @@
const unsigned kRegCodeMask = 0x1f;
// Standard machine types defined by AAPCS64.
const unsigned kByteSize = 8;
-const unsigned kByteSizeInBytes = kByteSize / 8;
+const unsigned kByteSizeInBytes = kByteSize >> 3;
const unsigned kHalfWordSize = 16;
const unsigned kHalfWordSizeLog2 = 4;
-const unsigned kHalfWordSizeInBytes = kHalfWordSizeInBytes / 8;
+const unsigned kHalfWordSizeInBytes = kHalfWordSize >> 3;
const unsigned kHalfWordSizeInBytesLog2 = kHalfWordSizeLog2 - 3;
const unsigned kWordSize = 32;
const unsigned kWordSizeLog2 = 5;
-const unsigned kWordSizeInBytes = kWordSizeInBytes / 8;
+const unsigned kWordSizeInBytes = kWordSize >> 3;
const unsigned kWordSizeInBytesLog2 = kWordSizeLog2 - 3;
const unsigned kDoubleWordSize = 64;
-const unsigned kDoubleWordSizeInBytes = kDoubleWordSizeInBytes / 8;
+const unsigned kDoubleWordSizeInBytes = kDoubleWordSize >> 3;
const unsigned kQuadWordSize = 128;
-const unsigned kQuadWordSizeInBytes = kQuadWordSizeInBytes / 8;
+const unsigned kQuadWordSizeInBytes = kQuadWordSize >> 3;
// AArch64 floating-point specifics. These match IEEE-754.
const unsigned kDoubleMantissaBits = 52;
const unsigned kDoubleExponentBits = 11;
=======================================
--- /branches/experimental/a64/src/a64/debug-a64.cc Tue Feb 4 12:58:02
2014 UTC
+++ /branches/experimental/a64/src/a64/debug-a64.cc Thu Feb 6 13:19:27
2014 UTC
@@ -183,7 +183,7 @@
CPURegList(CPURegister::kRegister, kXRegSize, non_object_regs);
while (!non_object_list.IsEmpty()) {
// Store each non-object register as two SMIs.
- Register reg(non_object_list.PopLowestIndex());
+ Register reg = Register(non_object_list.PopLowestIndex());
__ Push(reg);
__ Poke(wzr, 0);
__ Push(reg.W(), wzr);
@@ -222,7 +222,7 @@
// jssp[8]: 0x00000000 (SMI tag & padding)
// jssp[4]: reg[31:0]
// jssp[0]: 0x00000000 (SMI tag & padding)
- Register reg(non_object_list.PopHighestIndex());
+ Register reg = Register(non_object_list.PopHighestIndex());
__ Pop(scratch, reg);
__ Bfxil(reg, scratch, 32, 32);
}
=======================================
--- /branches/experimental/a64/src/a64/frames-a64.h Thu Feb 6 11:53:35
2014 UTC
+++ /branches/experimental/a64/src/a64/frames-a64.h Thu Feb 6 13:19:27
2014 UTC
@@ -48,10 +48,9 @@
// Define the list of registers actually saved at safepoints.
// Note that the number of saved registers may be smaller than the reserved
// space, i.e. kNumSafepointSavedRegisters <= kNumSafepointRegisters.
-const RegList kSafepointSavedRegisters =
- CPURegList::GetSafepointSavedRegisters().list();
-const int kNumSafepointSavedRegisters =
- CPURegList::GetSafepointSavedRegisters().Count();
+#define kSafepointSavedRegisters
CPURegList::GetSafepointSavedRegisters().list()
+#define kNumSafepointSavedRegisters \
+ CPURegList::GetSafepointSavedRegisters().Count();
class EntryFrameConstants : public AllStatic {
public:
=======================================
--- /branches/experimental/a64/src/a64/instructions-a64.cc Fri Jan 31
17:26:22 2014 UTC
+++ /branches/experimental/a64/src/a64/instructions-a64.cc Thu Feb 6
13:19:27 2014 UTC
@@ -29,6 +29,8 @@
#if V8_TARGET_ARCH_A64
+#define A64_DEFINE_FP_STATICS
+
#include "a64/instructions-a64.h"
#include "a64/assembler-a64-inl.h"
=======================================
--- /branches/experimental/a64/src/a64/instructions-a64.h Fri Jan 31
17:26:22 2014 UTC
+++ /branches/experimental/a64/src/a64/instructions-a64.h Thu Feb 6
13:19:27 2014 UTC
@@ -40,19 +40,35 @@
// ISA constants.
--------------------------------------------------------------
typedef uint32_t Instr;
-const float kFP32PositiveInfinity = rawbits_to_float(0x7f800000);
-const float kFP32NegativeInfinity = rawbits_to_float(0xff800000);
-const double kFP64PositiveInfinity =
rawbits_to_double(0x7ff0000000000000UL);
-const double kFP64NegativeInfinity =
rawbits_to_double(0xfff0000000000000UL);
+
+// The following macros initialize a float/double variable with a bit
pattern
+// without using static initializers: If A64_DEFINE_FP_STATICS is defined,
the
+// symbol is defined as uint32_t/uint64_t initialized with the desired bit
+// pattern. Otherwise, the same symbol is declared as an external
float/double.
+#if defined(A64_DEFINE_FP_STATICS)
+#define DEFINE_FLOAT(name, value) extern const uint32_t name = value
+#define DEFINE_DOUBLE(name, value) extern const uint64_t name = value
+#else
+#define DEFINE_FLOAT(name, value) extern const float name
+#define DEFINE_DOUBLE(name, value) extern const double name
+#endif // defined(A64_DEFINE_FP_STATICS)
+
+DEFINE_FLOAT(kFP32PositiveInfinity, 0x7f800000);
+DEFINE_FLOAT(kFP32NegativeInfinity, 0xff800000);
+DEFINE_DOUBLE(kFP64PositiveInfinity, 0x7ff0000000000000UL);
+DEFINE_DOUBLE(kFP64NegativeInfinity, 0xfff0000000000000UL);
// This value is a signalling NaN as both a double and as a float (taking
the
// least-significant word).
-static const double kFP64SignallingNaN =
rawbits_to_double(0x7ff000007f800001);
-static const float kFP32SignallingNaN = rawbits_to_float(0x7f800001);
+DEFINE_DOUBLE(kFP64SignallingNaN, 0x7ff000007f800001);
+DEFINE_FLOAT(kFP32SignallingNaN, 0x7f800001);
// A similar value, but as a quiet NaN.
-static const double kFP64QuietNaN = rawbits_to_double(0x7ff800007fc00001);
-static const float kFP32QuietNaN = rawbits_to_float(0x7fc00001);
+DEFINE_DOUBLE(kFP64QuietNaN, 0x7ff800007fc00001);
+DEFINE_FLOAT(kFP32QuietNaN, 0x7fc00001);
+
+#undef DEFINE_FLOAT
+#undef DEFINE_DOUBLE
enum LSDataSize {
=======================================
--- /branches/experimental/a64/src/a64/lithium-gap-resolver-a64.cc Wed Feb
5 08:06:23 2014 UTC
+++ /branches/experimental/a64/src/a64/lithium-gap-resolver-a64.cc Thu Feb
6 13:19:27 2014 UTC
@@ -40,8 +40,7 @@
// with any of the moves we are resolving.
// - We don't need to push it on the stack, as we can reload it with its
value
// once we have resolved a cycle.
-const Register LGapResolver::kSavedValue = root;
-
+#define kSavedValue root
LGapResolver::LGapResolver(LCodeGen* owner)
: cgen_(owner), moves_(32, owner->zone()), root_index_(0),
in_cycle_(false),
=======================================
--- /branches/experimental/a64/src/a64/lithium-gap-resolver-a64.h Wed Jan
22 12:46:44 2014 UTC
+++ /branches/experimental/a64/src/a64/lithium-gap-resolver-a64.h Thu Feb
6 13:19:27 2014 UTC
@@ -71,9 +71,6 @@
// Verify the move list before performing moves.
void Verify();
- // Register used to break cycle in moves list.
- static const Register kSavedValue;
-
LCodeGen* cgen_;
// List of moves not yet resolved.
=======================================
--- /branches/experimental/a64/src/a64/macro-assembler-a64.h Thu Feb 6
11:53:35 2014 UTC
+++ /branches/experimental/a64/src/a64/macro-assembler-a64.h Thu Feb 6
13:19:27 2014 UTC
@@ -1862,11 +1862,11 @@
}
const Register WTmp0() const {
- return Register(tmp0_.code(), kWRegSize);
+ return Register::Create(tmp0_.code(), kWRegSize);
}
const Register WTmp1() const {
- return Register(tmp1_.code(), kWRegSize);
+ return Register::Create(tmp1_.code(), kWRegSize);
}
void SetFPScratchRegister(const FPRegister& fptmp0) {
@@ -1882,7 +1882,7 @@
const CPURegister& forbidden = NoCPUReg) const {
Register candidate = forbidden.Is(Tmp0()) ? Tmp1() : Tmp0();
ASSERT(!candidate.Is(target));
- return Register(candidate.code(), target.SizeInBits());
+ return Register::Create(candidate.code(), target.SizeInBits());
}
const FPRegister AppropriateTempFor(
@@ -1892,7 +1892,7 @@
FPRegister candidate = FPTmp0();
ASSERT(!candidate.Is(forbidden));
ASSERT(!candidate.Is(target));
- return FPRegister(candidate.code(), target.SizeInBits());
+ return FPRegister::Create(candidate.code(), target.SizeInBits());
}
// Like printf, but print at run-time from generated code.
=======================================
--- /branches/experimental/a64/src/a64/regexp-macro-assembler-a64.cc Tue
Feb 4 12:58:02 2014 UTC
+++ /branches/experimental/a64/src/a64/regexp-macro-assembler-a64.cc Thu
Feb 6 13:19:27 2014 UTC
@@ -1558,7 +1558,7 @@
Register RegExpMacroAssemblerA64::GetCachedRegister(int register_index) {
ASSERT(register_index < kNumCachedRegisters);
- return Register(register_index / 2, kXRegSize);
+ return Register::Create(register_index / 2, kXRegSize);
}
=======================================
--- /branches/experimental/a64/test/cctest/test-utils-a64.cc Wed Jan 22
12:46:44 2014 UTC
+++ /branches/experimental/a64/test/cctest/test-utils-a64.cc Thu Feb 6
13:19:27 2014 UTC
@@ -218,13 +218,13 @@
if (((1UL << n) & allowed) != 0) {
// Only assign allowed registers.
if (r) {
- r[i] = Register(n, reg_size);
+ r[i] = Register::Create(n, reg_size);
}
if (x) {
- x[i] = Register(n, kXRegSize);
+ x[i] = Register::Create(n, kXRegSize);
}
if (w) {
- w[i] = Register(n, kWRegSize);
+ w[i] = Register::Create(n, kWRegSize);
}
list |= (1UL << n);
i++;
@@ -245,13 +245,13 @@
if (((1UL << n) & allowed) != 0) {
// Only assigned allowed registers.
if (v) {
- v[i] = FPRegister(n, reg_size);
+ v[i] = FPRegister::Create(n, reg_size);
}
if (d) {
- d[i] = FPRegister(n, kDRegSize);
+ d[i] = FPRegister::Create(n, kDRegSize);
}
if (s) {
- s[i] = FPRegister(n, kSRegSize);
+ s[i] = FPRegister::Create(n, kSRegSize);
}
list |= (1UL << n);
i++;
@@ -268,7 +268,7 @@
Register first = NoReg;
for (unsigned i = 0; i < kNumberOfRegisters; i++) {
if (reg_list & (1UL << i)) {
- Register xn(i, kXRegSize);
+ Register xn = Register::Create(i, kXRegSize);
// We should never write into csp here.
ASSERT(!xn.Is(csp));
if (!xn.IsZero()) {
@@ -291,7 +291,7 @@
FPRegister first = NoFPReg;
for (unsigned i = 0; i < kNumberOfFPRegisters; i++) {
if (reg_list & (1UL << i)) {
- FPRegister dn(i, kDRegSize);
+ FPRegister dn = FPRegister::Create(i, kDRegSize);
if (!first.IsValid()) {
// This is the first register we've hit, so construct the literal.
__ Fmov(dn, value);
--
--
v8-dev mailing list
[email protected]
http://groups.google.com/group/v8-dev
---
You received this message because you are subscribed to the Google Groups "v8-dev" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to [email protected].
For more options, visit https://groups.google.com/groups/opt_out.
