ARM64: Give LR to the allocator.

src/arm64/assembler-arm64.h

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_ARM64_ASSEMBLER_ARM64_H_
 #define V8_ARM64_ASSEMBLER_ARM64_H_
 
 #include <list>
 #include <map>
 
@@ skipping 117 matching lines @@
   // These memebers are necessary for compilation.
   // A few of them may be unused for now.
 
   static const int kNumRegisters = kNumberOfRegisters;
   static int NumRegisters() { return kNumRegisters; }
 
   // We allow crankshaft to use the following registers:
   //   - x0 to x15
   //   - x18 to x24
   //   - x27 (also context)
+  //   - x30 (also lr)
   //
   // TODO(all): Register x25 is currently free and could be available for
   // crankshaft, but we don't use it as we might use it as a per function
   // literal pool pointer in the future.
   //
   // TODO(all): Consider storing cp in x25 to have only two ranges.
   // We split allocatable registers in three ranges called
   //   - "low range"
   //   - "high range"
   //   - "context"
   static const unsigned kAllocatableLowRangeBegin = 0;
   static const unsigned kAllocatableLowRangeEnd = 15;
   static const unsigned kAllocatableHighRangeBegin = 18;
   static const unsigned kAllocatableHighRangeEnd = 24;
   static const unsigned kAllocatableContext = 27;
+  static const unsigned kAllocatableLR = 30;
+
+  static const RegList kAllocatableRegisters =
+      ((1 << (kAllocatableLowRangeEnd + 1)) -
+       (1 << kAllocatableLowRangeBegin)) |
+      ((1 << (kAllocatableHighRangeEnd + 1)) -
+       (1 << kAllocatableHighRangeBegin)) |
+      (1 << kAllocatableLR) | (1 << kAllocatableContext);
 
   // Gap between low and high ranges.
   static const int kAllocatableRangeGapSize =
       (kAllocatableHighRangeBegin - kAllocatableLowRangeEnd) - 1;
 
   static const int kMaxNumAllocatableRegisters =
       (kAllocatableLowRangeEnd - kAllocatableLowRangeBegin + 1) +
-      (kAllocatableHighRangeEnd - kAllocatableHighRangeBegin + 1) + 1;  // cp
+      (kAllocatableHighRangeEnd - kAllocatableHighRangeBegin + 1) + 2;  // cp/lr
   static int NumAllocatableRegisters() { return kMaxNumAllocatableRegisters; }
 
   // Return true if the register is one that crankshaft can allocate.
   bool IsAllocatable() const {
     return ((reg_code == kAllocatableContext) ||
+            (reg_code == kAllocatableLR) ||
             (reg_code <= kAllocatableLowRangeEnd) ||
             ((reg_code >= kAllocatableHighRangeBegin) &&
              (reg_code <= kAllocatableHighRangeEnd)));
   }
 
   static Register FromAllocationIndex(unsigned index) {
     ASSERT(index < static_cast<unsigned>(NumAllocatableRegisters()));
-    // cp is the last allocatable register.
+    // lr is the last allocatable register.
     if (index == (static_cast<unsigned>(NumAllocatableRegisters() - 1))) {
+      return from_code(kAllocatableLR);
+    }
+    // cp is the second-last allocatable register.
+    if (index == (static_cast<unsigned>(NumAllocatableRegisters() - 2))) {
       return from_code(kAllocatableContext);
     }
 
     // Handle low and high ranges.
     return (index <= kAllocatableLowRangeEnd)
         ? from_code(index)
         : from_code(index + kAllocatableRangeGapSize);
   }
 
   static const char* AllocationIndexToString(int index) {
     ASSERT((index >= 0) && (index < NumAllocatableRegisters()));
-    ASSERT((kAllocatableLowRangeBegin == 0) &&
-           (kAllocatableLowRangeEnd == 15) &&
-           (kAllocatableHighRangeBegin == 18) &&
-           (kAllocatableHighRangeEnd == 24) &&
-           (kAllocatableContext == 27));
+    STATIC_ASSERT((kAllocatableLowRangeBegin == 0) &&
+                  (kAllocatableLowRangeEnd == 15) &&
+                  (kAllocatableHighRangeBegin == 18) &&
+                  (kAllocatableHighRangeEnd == 24) &&
+                  (kAllocatableContext == 27) &&
+                  (kAllocatableLR == 30));
     const char* const names[] = {
       "x0", "x1", "x2", "x3", "x4",
       "x5", "x6", "x7", "x8", "x9",
       "x10", "x11", "x12", "x13", "x14",
       "x15", "x18", "x19", "x20", "x21",
-      "x22", "x23", "x24", "x27",
+      "x22", "x23", "x24", "x27", "lr"
     };
     return names[index];
   }
 
   static int ToAllocationIndex(Register reg) {
     ASSERT(reg.IsAllocatable());
     unsigned code = reg.code();
+    if (code == kAllocatableLR) {
+      return NumAllocatableRegisters() - 1;
+    }
     if (code == kAllocatableContext) {
-      return NumAllocatableRegisters() - 1;
+      return NumAllocatableRegisters() - 2;
     }
 
     return (code <= kAllocatableLowRangeEnd)
         ? code
         : code - kAllocatableRangeGapSize;
   }
 
   static Register from_code(int code) {
     // Always return an X register.
     return Register::Create(code, kXRegSizeInBits);
@@ skipping 42 matching lines @@
 
   // Crankshaft can use all the FP registers except:
   //   - d15 which is used to keep the 0 double value
   //   - d30 which is used in crankshaft as a double scratch register
   //   - d31 which is used in the MacroAssembler as a double scratch register
   static const unsigned kAllocatableLowRangeBegin = 0;
   static const unsigned kAllocatableLowRangeEnd = 14;
   static const unsigned kAllocatableHighRangeBegin = 16;
   static const unsigned kAllocatableHighRangeEnd = 28;
 
-  static const RegList kAllocatableFPRegisters = 0x1fff7fff;
+  static const RegList kAllocatableFPRegisters =
+      ((1 << (kAllocatableLowRangeEnd + 1)) -
+       (1 << kAllocatableLowRangeBegin)) |
+      ((1 << (kAllocatableHighRangeEnd + 1)) -
+       (1 << kAllocatableHighRangeBegin));
 
   // Gap between low and high ranges.
   static const int kAllocatableRangeGapSize =
       (kAllocatableHighRangeBegin - kAllocatableLowRangeEnd) - 1;
 
   static const int kMaxNumAllocatableRegisters =
       (kAllocatableLowRangeEnd - kAllocatableLowRangeBegin + 1) +
       (kAllocatableHighRangeEnd - kAllocatableHighRangeBegin + 1);
   static int NumAllocatableRegisters() { return kMaxNumAllocatableRegisters; }
 
@@ skipping 1968 matching lines @@
 class EnsureSpace BASE_EMBEDDED {
  public:
   explicit EnsureSpace(Assembler* assembler) {
     assembler->CheckBufferSpace();
   }
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_ARM64_ASSEMBLER_ARM64_H_