ARM: Improve register allocation and constraints....

src/arm/assembler-arm.h

 // Copyright (c) 1994-2006 Sun Microsystems Inc.
 // All Rights Reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions
 // are met:
 //
 // - Redistributions of source code must retain the above copyright notice,
 // this list of conditions and the following disclaimer.
 //
@@ skipping 149 matching lines @@
     *m = code_ & 0x1;
     *vm = code_ >> 1;
   }
 
   int code_;
 };
 
 
 // Double word VFP register.
 struct DwVfpRegister {
-  // d0 has been excluded from allocation. This is following ia32
-  // where xmm0 is excluded. This should be revisited.
-  // Currently d0 is used as a scratch register.
-  // d1 has also been excluded from allocation to be used as a scratch
-  // register as well.
   static const int kNumRegisters = 16;
-  static const int kNumAllocatableRegisters = 15;
+  // A few double registers are reserved: one as a scratch register and three
+  // for common values not fitting the immediate field of vmov instructions.

[Søren Thygesen Gjesse, 2011/06/16 09:38:07]

It seems to be some of a waste to use 3 double registers for these constants -
they are not used that many times in the code. How about regressions on floating
point intensive benchmarks where having fewer registers could lead to more
spilling to the stack?

Also as far as I can see this change only uses 0.0 (to comvert -0.0 to 0.0 in
sqrt).

[Alexandre, 2011/06/16 12:58:48]

I thought we never put enough pressure on double registers to actually need 16
of them, and I have never seen such code. However I believe you are right that
using 3 registers for this purpose is useless.
I changed the code to use only one register for 0.0. -0.0 can be derived from it
with a vneg. And allocating one for 255.0 is not really useful.

This mechanism is actually used in more places via the Vmov macro, especially-
in LCodeGen::DoConstantD.
This is interesting because 0.0 is very often used as a constant.

On 2011/06/16 09:38:07, Søren Gjesse wrote:

+  //  d12: 255.0
+  //  d13: -0.0
+  //  d14: 0.0
+  //  d15: scratch register.
+  static const int kNumReservedRegisters = 4;
+  static const int kNumAllocatableRegisters = kNumRegisters -
+      kNumReservedRegisters;
 
   static int ToAllocationIndex(DwVfpRegister reg) {
     ASSERT(reg.code() != 0);
     return reg.code() - 1;
   }
 
   static DwVfpRegister FromAllocationIndex(int index) {
     ASSERT(index >= 0 && index < kNumAllocatableRegisters);
     return from_code(index + 1);
   }
 
   static const char* AllocationIndexToString(int index) {
     ASSERT(index >= 0 && index < kNumAllocatableRegisters);
     const char* const names[] = {
+      "d0",
       "d1",
       "d2",
       "d3",
       "d4",
       "d5",
       "d6",
       "d7",
       "d8",
       "d9",
       "d10",
-      "d11",
-      "d12",
-      "d13",
-      "d14",
-      "d15"
+      "d11"
     };
     return names[index];
   }
 
   static DwVfpRegister from_code(int code) {
     DwVfpRegister r = { code };
     return r;
   }
 
   // Supporting d0 to d15, can be later extended to d31.
@@ skipping 80 matching lines @@
 const DwVfpRegister d7  = {  7 };
 const DwVfpRegister d8  = {  8 };
 const DwVfpRegister d9  = {  9 };
 const DwVfpRegister d10 = { 10 };
 const DwVfpRegister d11 = { 11 };
 const DwVfpRegister d12 = { 12 };
 const DwVfpRegister d13 = { 13 };
 const DwVfpRegister d14 = { 14 };
 const DwVfpRegister d15 = { 15 };
 
+//  Aliases for double registers.
+const DwVfpRegister kFirstCalleeSavedDoubleReg = d8;
+const DwVfpRegister kLastCalleeSavedDoubleReg = d15;
+const DwVfpRegister kDoubleReg255 = d12;
+const DwVfpRegister kDoubleRegMinusZero = d13;
+const DwVfpRegister kDoubleRegZero = d14;
+
 
 // Coprocessor register
 struct CRegister {
   bool is_valid() const { return 0 <= code_ && code_ < 16; }
   bool is(CRegister creg) const { return code_ == creg.code_; }
   int code() const {
     ASSERT(is_valid());
     return code_;
   }
   int bit() const {
@@ skipping 1053 matching lines @@
  public:
   explicit EnsureSpace(Assembler* assembler) {
     assembler->CheckBuffer();
   }
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_ARM_ASSEMBLER_ARM_H_