ARM: Improve register allocation and constraints....

src/arm/assembler-arm.h

Index: src/arm/assembler-arm.h
===================================================================
--- src/arm/assembler-arm.h	(revision 8283)
+++ src/arm/assembler-arm.h	(working copy)
@@ -167,13 +167,16 @@
 
 // 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);
@@ -188,6 +191,7 @@
   static const char* AllocationIndexToString(int index) {
     ASSERT(index >= 0 && index < kNumAllocatableRegisters);
     const char* const names[] = {
+      "d0",
       "d1",
       "d2",
       "d3",
@@ -198,11 +202,7 @@
       "d8",
       "d9",
       "d10",
-      "d11",
-      "d12",
-      "d13",
-      "d14",
-      "d15"
+      "d11"
     };
     return names[index];
   }
@@ -303,7 +303,14 @@
 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; }