[Turbofan] Allow compiler to elide complex aliasing code.

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 63 matching lines @@
   }
   return false;
 }
 
 bool IsOutputFPRegisterOf(Instruction* instr, MachineRepresentation rep,
                           int code) {
   for (size_t i = 0; i < instr->OutputCount(); i++) {
     InstructionOperand* output = instr->OutputAt(i);
     if (output->IsFPRegister()) {
       const LocationOperand* op = LocationOperand::cast(output);
-      const RegisterConfiguration* config =
-          RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN);
-      if (config->fp_aliasing_kind() != RegisterConfiguration::COMBINE) {
+      if (kSimpleFPAliasing) {
         if (op->register_code() == code) return true;
       } else {
-        if (config->AreAliases(op->representation(), op->register_code(), rep,
-                               code)) {
+        if (RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
+                ->AreAliases(op->representation(), op->register_code(), rep,
+                             code)) {
           return true;
         }
       }
     }
   }
   return false;
 }
 
 
 // TODO(dcarney): fix frame to allow frame accesses to half size location.
@@ skipping 1448 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:
-      if (config()->fp_aliasing_kind() == RegisterConfiguration::COMBINE) {
+      if (kSimpleFPAliasing) {
+        assigned_double_registers_->Add(index);
+      } else {
         int alias_base_index = -1;
         int aliases = config()->GetAliases(
             rep, index, MachineRepresentation::kFloat64, &alias_base_index);
         while (aliases--) {
           int aliased_reg = alias_base_index + aliases;
           assigned_double_registers_->Add(aliased_reg);
         }
       }
       break;
     case MachineRepresentation::kFloat64:
@@ skipping 847 matching lines @@
 }
 
 RegisterAllocator::RegisterAllocator(RegisterAllocationData* data,
                                      RegisterKind kind)
     : data_(data),
       mode_(kind),
       num_registers_(GetRegisterCount(data->config(), kind)),
       num_allocatable_registers_(
           GetAllocatableRegisterCount(data->config(), kind)),
       allocatable_register_codes_(
-          GetAllocatableRegisterCodes(data->config(), kind)),
-      no_combining_(kind != FP_REGISTERS ||
-                    data->config()->fp_aliasing_kind() !=
-                        RegisterConfiguration::COMBINE) {}
+          GetAllocatableRegisterCodes(data->config(), kind)) {}
 
 LifetimePosition RegisterAllocator::GetSplitPositionForInstruction(
     const LiveRange* range, int instruction_index) {
   LifetimePosition ret = LifetimePosition::Invalid();
 
   ret = LifetimePosition::GapFromInstructionIndex(instruction_index);
   if (range->Start() >= ret || ret >= range->End()) {
     return LifetimePosition::Invalid();
   }
   return ret;
@@ skipping 375 matching lines @@
   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) {
   int num_regs = num_registers();
   int num_codes = num_allocatable_registers();
   const int* codes = allocatable_register_codes();
-  if (!no_combining() &&
+  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();
   }
   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 (no_combining()) {
+    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);
       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 (no_combining()) {
+    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);
       while (aliases--) {
         int aliased_reg = alias_base_index + aliases;
@@ skipping 60 matching lines @@
   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;
   }
 
   int num_regs = num_registers();
   int num_codes = num_allocatable_registers();
   const int* codes = allocatable_register_codes();
-  if (!no_combining() &&
+  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();
   }
 
   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 (no_combining()) {
+    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();
@@ skipping 21 matching lines @@
       }
     }
   }
 
   for (LiveRange* range : inactive_live_ranges()) {
     DCHECK(range->End() > current->Start());
     LifetimePosition next_intersection = range->FirstIntersection(current);
     if (!next_intersection.IsValid()) continue;
     int cur_reg = range->assigned_register();
     bool is_fixed = range->TopLevel()->IsFixed();
-    if (no_combining()) {
+    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(),
@@ skipping 53 matching lines @@
   SplitAndSpillIntersecting(current);
 }
 
 
 void LinearScanAllocator::SplitAndSpillIntersecting(LiveRange* current) {
   DCHECK(current->HasRegisterAssigned());
   int reg = current->assigned_register();
   LifetimePosition split_pos = current->Start();
   for (size_t i = 0; i < active_live_ranges().size(); ++i) {
     LiveRange* range = active_live_ranges()[i];
-    if (no_combining()) {
+    if (kSimpleFPAliasing || mode() == GENERAL_REGISTERS) {
       if (range->assigned_register() != reg) continue;
     } else {
       if (!data()->config()->AreAliases(current->representation(), reg,
                                         range->representation(),
                                         range->assigned_register())) {
         continue;
       }
     }
 
     UsePosition* next_pos = range->NextRegisterPosition(current->Start());
@@ skipping 14 matching lines @@
       SpillBetweenUntil(range, spill_pos, current->Start(), next_pos->pos());
     }
     ActiveToHandled(range);
     --i;
   }
 
   for (size_t i = 0; i < inactive_live_ranges().size(); ++i) {
     LiveRange* range = inactive_live_ranges()[i];
     DCHECK(range->End() > current->Start());
     if (range->TopLevel()->IsFixed()) continue;
-    if (no_combining()) {
+    if (kSimpleFPAliasing || mode() == GENERAL_REGISTERS) {
       if (range->assigned_register() != reg) continue;
     } else {
       if (!data()->config()->AreAliases(current->representation(), reg,
                                         range->representation(),
                                         range->assigned_register()))
         continue;
     }
 
     LifetimePosition next_intersection = range->FirstIntersection(current);
     if (next_intersection.IsValid()) {
@@ skipping 649 matching lines @@
         }
       }
     }
   }
 }
 
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8