[Turbofan] Add Simd128 registers to RegisterConfiguration.

src/compiler/register-allocator.cc

 // Copyright 2014 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/base/adapters.h"
 #include "src/compiler/linkage.h"
 #include "src/compiler/register-allocator.h"
 #include "src/string-stream.h"
 
 namespace v8 {
@@ skipping 1326 matching lines @@
       live_in_sets_(code->InstructionBlockCount(), nullptr, allocation_zone()),
       live_out_sets_(code->InstructionBlockCount(), nullptr, allocation_zone()),
       live_ranges_(code->VirtualRegisterCount() * 2, nullptr,
                    allocation_zone()),
       fixed_live_ranges_(this->config()->num_general_registers(), nullptr,
                          allocation_zone()),
       fixed_float_live_ranges_(this->config()->num_float_registers(), nullptr,
                                allocation_zone()),
       fixed_double_live_ranges_(this->config()->num_double_registers(), nullptr,
                                 allocation_zone()),
+      fixed_simd128_live_ranges_(this->config()->num_simd128_registers(),
+                                 nullptr, allocation_zone()),
       spill_ranges_(code->VirtualRegisterCount(), nullptr, allocation_zone()),
       delayed_references_(allocation_zone()),
       assigned_registers_(nullptr),
       assigned_double_registers_(nullptr),
       virtual_register_count_(code->VirtualRegisterCount()),
       preassigned_slot_ranges_(zone) {
   assigned_registers_ = new (code_zone())
       BitVector(this->config()->num_general_registers(), code_zone());
   assigned_double_registers_ = new (code_zone())
       BitVector(this->config()->num_double_registers(), code_zone());
@@ skipping 157 matching lines @@
   DCHECK(!range->IsSplinter());
   SpillRange* spill_range =
       new (allocation_zone()) SpillRange(range, allocation_zone());
   return spill_range;
 }
 
 void RegisterAllocationData::MarkAllocated(MachineRepresentation rep,
                                            int index) {
   switch (rep) {
     case MachineRepresentation::kFloat32:
+    case MachineRepresentation::kSimd128:
       if (kSimpleFPAliasing) {
         assigned_double_registers_->Add(index);
       } else {
         int alias_base_index = -1;
         int aliases = config()->GetAliases(
             rep, index, MachineRepresentation::kFloat64, &alias_base_index);
+        DCHECK(aliases > 0 || (aliases == 0 && alias_base_index == -1));
         while (aliases--) {
           int aliased_reg = alias_base_index + aliases;
           assigned_double_registers_->Add(aliased_reg);
         }
       }
       break;
     case MachineRepresentation::kFloat64:
       assigned_double_registers_->Add(index);
       break;
     default:
@@ skipping 310 matching lines @@
   BitVector::Iterator iterator(live_out);
   while (!iterator.Done()) {
     int operand_index = iterator.Current();
     TopLevelLiveRange* range = data()->GetOrCreateLiveRangeFor(operand_index);
     range->AddUseInterval(start, end, allocation_zone());
     iterator.Advance();
   }
 }
 
 int LiveRangeBuilder::FixedFPLiveRangeID(int index, MachineRepresentation rep) {
+  int result = -index - 1;
   switch (rep) {
+    case MachineRepresentation::kSimd128:
+      result -= config()->num_float_registers();
+    // Fall through.
     case MachineRepresentation::kFloat32:
-      return -index - 1 - config()->num_general_registers();
+      result -= config()->num_double_registers();
+    // Fall through.
     case MachineRepresentation::kFloat64:
-      return -index - 1 - config()->num_general_registers() -
-             config()->num_float_registers();
+      result -= config()->num_general_registers();
+      break;
     default:
+      UNREACHABLE();
       break;
   }
-  UNREACHABLE();
-  return 0;
+  return result;
 }
 
 TopLevelLiveRange* LiveRangeBuilder::FixedLiveRangeFor(int index) {
   DCHECK(index < config()->num_general_registers());
   TopLevelLiveRange* result = data()->fixed_live_ranges()[index];
   if (result == nullptr) {
     MachineRepresentation rep = InstructionSequence::DefaultRepresentation();
     result = data()->NewLiveRange(FixedLiveRangeID(index), rep);
     DCHECK(result->IsFixed());
     result->set_assigned_register(index);
     data()->MarkAllocated(rep, index);
     data()->fixed_live_ranges()[index] = result;
   }
   return result;
 }
 
 TopLevelLiveRange* LiveRangeBuilder::FixedFPLiveRangeFor(
     int index, MachineRepresentation rep) {
   TopLevelLiveRange* result = nullptr;
-  if (rep == MachineRepresentation::kFloat64) {
-    DCHECK(index < config()->num_double_registers());
-    result = data()->fixed_double_live_ranges()[index];
-    if (result == nullptr) {
-      result = data()->NewLiveRange(FixedFPLiveRangeID(index, rep), rep);
-      DCHECK(result->IsFixed());
-      result->set_assigned_register(index);
-      data()->MarkAllocated(rep, index);
-      data()->fixed_double_live_ranges()[index] = result;
-    }
-  } else {
-    DCHECK(rep == MachineRepresentation::kFloat32);
-    DCHECK(index < config()->num_float_registers());
-    result = data()->fixed_float_live_ranges()[index];
-    if (result == nullptr) {
-      result = data()->NewLiveRange(FixedFPLiveRangeID(index, rep), rep);
-      DCHECK(result->IsFixed());
-      result->set_assigned_register(index);
-      data()->MarkAllocated(rep, index);
-      data()->fixed_float_live_ranges()[index] = result;
-    }
+  switch (rep) {
+    case MachineRepresentation::kFloat32:
+      DCHECK(rep == MachineRepresentation::kFloat32);
+      DCHECK(index < config()->num_float_registers());
+      result = data()->fixed_float_live_ranges()[index];
+      if (result == nullptr) {
+        result = data()->NewLiveRange(FixedFPLiveRangeID(index, rep), rep);
+        DCHECK(result->IsFixed());
+        result->set_assigned_register(index);
+        data()->MarkAllocated(rep, index);
+        data()->fixed_float_live_ranges()[index] = result;
+      }
+      break;
+    case MachineRepresentation::kFloat64:
+      DCHECK(index < config()->num_double_registers());
+      result = data()->fixed_double_live_ranges()[index];
+      if (result == nullptr) {
+        result = data()->NewLiveRange(FixedFPLiveRangeID(index, rep), rep);
+        DCHECK(result->IsFixed());
+        result->set_assigned_register(index);
+        data()->MarkAllocated(rep, index);
+        data()->fixed_double_live_ranges()[index] = result;
+      }
+      break;
+    case MachineRepresentation::kSimd128:
+      DCHECK(index < config()->num_simd128_registers());
+      result = data()->fixed_simd128_live_ranges()[index];
+      if (result == nullptr) {
+        result = data()->NewLiveRange(FixedFPLiveRangeID(index, rep), rep);
+        DCHECK(result->IsFixed());
+        result->set_assigned_register(index);
+        data()->MarkAllocated(rep, index);
+        data()->fixed_simd128_live_ranges()[index] = result;
+      }
+      break;
+    default:
+      UNREACHABLE();
+      break;
   }
   return result;
 }
 
 TopLevelLiveRange* LiveRangeBuilder::LiveRangeFor(InstructionOperand* operand) {
   if (operand->IsUnallocated()) {
     return data()->GetOrCreateLiveRangeFor(
         UnallocatedOperand::cast(operand)->virtual_register());
   } else if (operand->IsConstant()) {
     return data()->GetOrCreateLiveRangeFor(
@@ skipping 123 matching lines @@
       if (!kSimpleFPAliasing) {
         for (int i = 0; i < config()->num_allocatable_float_registers(); ++i) {
           // Add a UseInterval for all FloatRegisters. See comment above for
           // general registers.
           int code = config()->GetAllocatableFloatCode(i);
           TopLevelLiveRange* range =
               FixedFPLiveRangeFor(code, MachineRepresentation::kFloat32);
           range->AddUseInterval(curr_position, curr_position.End(),
                                 allocation_zone());
         }
+        for (int i = 0; i < config()->num_allocatable_simd128_registers();
+             ++i) {
+          int code = config()->GetAllocatableSimd128Code(i);
+          TopLevelLiveRange* range =
+              FixedFPLiveRangeFor(code, MachineRepresentation::kSimd128);
+          range->AddUseInterval(curr_position, curr_position.End(),
+                                allocation_zone());
+        }
       }
     }
 
     for (size_t i = 0; i < instr->InputCount(); i++) {
       InstructionOperand* input = instr->InputAt(i);
       if (input->IsImmediate() || input->IsExplicit()) {
         continue;  // Ignore immediates and explicitly reserved registers.
       }
       LifetimePosition use_pos;
       if (input->IsUnallocated() &&
@@ skipping 716 matching lines @@
 
 void LinearScanAllocator::InactiveToActive(LiveRange* range) {
   RemoveElement(&inactive_live_ranges(), range);
   active_live_ranges().push_back(range);
   TRACE("Moving live range %d:%d from inactive to active\n",
         range->TopLevel()->vreg(), range->relative_id());
 }
 
 
 bool LinearScanAllocator::TryAllocateFreeReg(LiveRange* current) {
+  MachineRepresentation rep = current->representation();
   int num_regs = num_registers();
   int num_codes = num_allocatable_registers();
   const int* codes = allocatable_register_codes();
-  if (!kSimpleFPAliasing &&
-      (current->representation() == MachineRepresentation::kFloat32)) {
-    num_regs = data()->config()->num_float_registers();
-    num_codes = data()->config()->num_allocatable_float_registers();
-    codes = data()->config()->allocatable_float_codes();
+  if (!kSimpleFPAliasing) {
+    if (rep == MachineRepresentation::kFloat32) {
+      num_regs = data()->config()->num_float_registers();
+      num_codes = data()->config()->num_allocatable_float_registers();
+      codes = data()->config()->allocatable_float_codes();
+    } else if (rep == MachineRepresentation::kSimd128) {
+      num_regs = data()->config()->num_simd128_registers();
+      num_codes = data()->config()->num_allocatable_simd128_registers();
+      codes = data()->config()->allocatable_simd128_codes();
+    }
   }
+
   LifetimePosition free_until_pos[RegisterConfiguration::kMaxFPRegisters];
   for (int i = 0; i < num_regs; i++) {
     free_until_pos[i] = LifetimePosition::MaxPosition();
   }
 
   for (LiveRange* cur_active : active_live_ranges()) {
     int cur_reg = cur_active->assigned_register();
     if (kSimpleFPAliasing || mode() == GENERAL_REGISTERS) {
       free_until_pos[cur_reg] = LifetimePosition::GapFromInstructionIndex(0);
       TRACE("Register %s is free until pos %d (1)\n", RegisterName(cur_reg),
             LifetimePosition::GapFromInstructionIndex(0).value());
     } else {
       int alias_base_index = -1;
       int aliases = data()->config()->GetAliases(
-          cur_active->representation(), cur_reg, current->representation(),
-          &alias_base_index);
+          cur_active->representation(), cur_reg, rep, &alias_base_index);
+      DCHECK(aliases > 0 || (aliases == 0 && alias_base_index == -1));
       while (aliases--) {
         int aliased_reg = alias_base_index + aliases;
         free_until_pos[aliased_reg] =
             LifetimePosition::GapFromInstructionIndex(0);
       }
     }
   }
 
   for (LiveRange* cur_inactive : inactive_live_ranges()) {
     DCHECK(cur_inactive->End() > current->Start());
     LifetimePosition next_intersection =
         cur_inactive->FirstIntersection(current);
     if (!next_intersection.IsValid()) continue;
     int cur_reg = cur_inactive->assigned_register();
     if (kSimpleFPAliasing || mode() == GENERAL_REGISTERS) {
       free_until_pos[cur_reg] = Min(free_until_pos[cur_reg], next_intersection);
       TRACE("Register %s is free until pos %d (2)\n", RegisterName(cur_reg),
             Min(free_until_pos[cur_reg], next_intersection).value());
     } else {
       int alias_base_index = -1;
       int aliases = data()->config()->GetAliases(
-          cur_inactive->representation(), cur_reg, current->representation(),
-          &alias_base_index);
+          cur_inactive->representation(), cur_reg, rep, &alias_base_index);
+      DCHECK(aliases > 0 || (aliases == 0 && alias_base_index == -1));
       while (aliases--) {
         int aliased_reg = alias_base_index + aliases;
         free_until_pos[aliased_reg] =
             Min(free_until_pos[aliased_reg], next_intersection);
       }
     }
   }
 
   int hint_register;
   if (current->FirstHintPosition(&hint_register) != nullptr) {
@@ skipping 49 matching lines @@
 
 void LinearScanAllocator::AllocateBlockedReg(LiveRange* current) {
   UsePosition* register_use = current->NextRegisterPosition(current->Start());
   if (register_use == nullptr) {
     // There is no use in the current live range that requires a register.
     // We can just spill it.
     Spill(current);
     return;
   }
 
+  MachineRepresentation rep = current->representation();
   int num_regs = num_registers();
   int num_codes = num_allocatable_registers();
   const int* codes = allocatable_register_codes();
-  if (!kSimpleFPAliasing &&
-      (current->representation() == MachineRepresentation::kFloat32)) {
-    num_regs = data()->config()->num_float_registers();
-    num_codes = data()->config()->num_allocatable_float_registers();
-    codes = data()->config()->allocatable_float_codes();
+  if (!kSimpleFPAliasing) {
+    if (rep == MachineRepresentation::kFloat32) {
+      num_regs = data()->config()->num_float_registers();
+      num_codes = data()->config()->num_allocatable_float_registers();
+      codes = data()->config()->allocatable_float_codes();
+    } else if (rep == MachineRepresentation::kSimd128) {
+      num_regs = data()->config()->num_simd128_registers();
+      num_codes = data()->config()->num_allocatable_simd128_registers();
+      codes = data()->config()->allocatable_simd128_codes();
+    }
   }
 
   LifetimePosition use_pos[RegisterConfiguration::kMaxFPRegisters];
   LifetimePosition block_pos[RegisterConfiguration::kMaxFPRegisters];
   for (int i = 0; i < num_regs; i++) {
     use_pos[i] = block_pos[i] = LifetimePosition::MaxPosition();
   }
 
   for (LiveRange* range : active_live_ranges()) {
     int cur_reg = range->assigned_register();
     bool is_fixed_or_cant_spill =
         range->TopLevel()->IsFixed() || !range->CanBeSpilled(current->Start());
     if (kSimpleFPAliasing || mode() == GENERAL_REGISTERS) {
       if (is_fixed_or_cant_spill) {
         block_pos[cur_reg] = use_pos[cur_reg] =
             LifetimePosition::GapFromInstructionIndex(0);
       } else {
         UsePosition* next_use =
             range->NextUsePositionRegisterIsBeneficial(current->Start());
         if (next_use == nullptr) {
           use_pos[cur_reg] = range->End();
         } else {
           use_pos[cur_reg] = next_use->pos();
         }
       }
     } else {
       int alias_base_index = -1;
       int aliases = data()->config()->GetAliases(
-          range->representation(), cur_reg, current->representation(),
-          &alias_base_index);
+          range->representation(), cur_reg, rep, &alias_base_index);
+      DCHECK(aliases > 0 || (aliases == 0 && alias_base_index == -1));
       while (aliases--) {
         int aliased_reg = alias_base_index + aliases;
         if (is_fixed_or_cant_spill) {
           block_pos[aliased_reg] = use_pos[aliased_reg] =
               LifetimePosition::GapFromInstructionIndex(0);
         } else {
           UsePosition* next_use =
               range->NextUsePositionRegisterIsBeneficial(current->Start());
           if (next_use == nullptr) {
             use_pos[aliased_reg] = range->End();
@@ skipping 14 matching lines @@
     if (kSimpleFPAliasing || mode() == GENERAL_REGISTERS) {
       if (is_fixed) {
         block_pos[cur_reg] = Min(block_pos[cur_reg], next_intersection);
         use_pos[cur_reg] = Min(block_pos[cur_reg], use_pos[cur_reg]);
       } else {
         use_pos[cur_reg] = Min(use_pos[cur_reg], next_intersection);
       }
     } else {
       int alias_base_index = -1;
       int aliases = data()->config()->GetAliases(
-          range->representation(), cur_reg, current->representation(),
-          &alias_base_index);
+          range->representation(), cur_reg, rep, &alias_base_index);
+      DCHECK(aliases > 0 || (aliases == 0 && alias_base_index == -1));
       while (aliases--) {
         int aliased_reg = alias_base_index + aliases;
         if (is_fixed) {
           block_pos[aliased_reg] =
               Min(block_pos[aliased_reg], next_intersection);
           use_pos[aliased_reg] =
               Min(block_pos[aliased_reg], use_pos[aliased_reg]);
         } else {
           use_pos[aliased_reg] = Min(use_pos[aliased_reg], next_intersection);
         }
@@ skipping 747 matching lines @@
         }
       }
     }
   }
 }
 
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8