Revert of Reland: Remove register index/code indirection

src/compiler/greedy-allocator.cc

 // Copyright 2015 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.
 
 #include "src/compiler/greedy-allocator.h"
 #include "src/compiler/register-allocator.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
@@ skipping 231 matching lines @@
 void GreedyAllocator::TryAllocateGroup(LiveRangeGroup* group) {
   float group_weight = 0.0;
   for (LiveRange* member : group->ranges()) {
     EnsureValidRangeWeight(member);
     group_weight = Max(group_weight, member->weight());
   }
 
   float eviction_weight = group_weight;
   int eviction_reg = -1;
   int free_reg = -1;
-  for (int i = 0; i < num_allocatable_registers(); ++i) {
-    int reg = allocatable_register_code(i);
+  for (int reg = 0; reg < num_registers(); ++reg) {
     float weight = GetMaximumConflictingWeight(reg, group, group_weight);
     if (weight == LiveRange::kInvalidWeight) {
       free_reg = reg;
       break;
     }
     if (weight < eviction_weight) {
       eviction_weight = weight;
       eviction_reg = reg;
     }
   }
@@ skipping 43 matching lines @@
     }
   }
 
   if (free_reg < 0 && evictable_reg < 0) {
     // There was no hinted reg, or we cannot allocate there.
     float smallest_weight = LiveRange::kMaxWeight;
 
     // Seek either the first free register, or, from the set of registers
     // where the maximum conflict is lower than the candidate's weight, the one
     // with the smallest such weight.
-    for (int i = 0; i < num_allocatable_registers(); i++) {
-      int reg = allocatable_register_code(i);
+    for (int i = 0; i < num_registers(); i++) {
       // Skip unnecessarily re-visiting the hinted register, if any.
-      if (reg == hinted_reg) continue;
+      if (i == hinted_reg) continue;
       float max_conflict_weight =
-          GetMaximumConflictingWeight(reg, range, competing_weight);
+          GetMaximumConflictingWeight(i, range, competing_weight);
       if (max_conflict_weight == LiveRange::kInvalidWeight) {
-        free_reg = reg;
+        free_reg = i;
         break;
       }
       if (max_conflict_weight < range->weight() &&
           max_conflict_weight < smallest_weight) {
         smallest_weight = max_conflict_weight;
-        evictable_reg = reg;
+        evictable_reg = i;
       }
     }
   }
 
   // We have a free register, so we use it.
   if (free_reg >= 0) {
     TRACE("Found free register %s for live range %d:%d.\n",
           RegisterName(free_reg), range->TopLevel()->vreg(),
           range->relative_id());
     AssignRangeToRegister(free_reg, range);
@@ skipping 329 matching lines @@
 
 
 bool GreedyAllocator::IsProgressPossible(const LiveRange* range) {
   return range->CanBeSpilled(range->Start()) ||
          GetLastResortSplitPosition(range).IsValid();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8