[Turbofan] Add Simd128 registers to RegisterConfiguration.

src/compiler/move-optimizer.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/compiler/move-optimizer.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 namespace {
 
 struct MoveKey {
   InstructionOperand source;
   InstructionOperand destination;
 };
 
 struct MoveKeyCompare {
   bool operator()(const MoveKey& a, const MoveKey& b) const {
     if (a.source.EqualsCanonicalized(b.source)) {
       return a.destination.CompareCanonicalized(b.destination);
     }
     return a.source.CompareCanonicalized(b.source);
   }
 };
 
 typedef ZoneMap<MoveKey, unsigned, MoveKeyCompare> MoveMap;
 typedef ZoneSet<InstructionOperand, CompareOperandModuloType> OperandSet;
 
+bool Contains(const OperandSet& set, const LocationOperand& loc,
+              MachineRepresentation rep, int reg_code) {
+  return set.find(LocationOperand(loc.kind(), loc.location_kind(), rep,
+                                  reg_code)) != set.end();
+}
+
 bool Blocks(const OperandSet& set, const InstructionOperand& operand) {
   if (set.find(operand) != set.end()) return true;
-  // Only FP registers alias.
+  // General registers don't alias.
   if (!operand.IsFPRegister()) return false;
 
+  // Check operand against operands of other FP types for interference.
   const LocationOperand& loc = LocationOperand::cast(operand);
   MachineRepresentation rep = loc.representation();
-  MachineRepresentation other_fp_rep = rep == MachineRepresentation::kFloat64
-                                           ? MachineRepresentation::kFloat32
-                                           : MachineRepresentation::kFloat64;
+  MachineRepresentation other_rep1, other_rep2;
+  switch (rep) {
+    case MachineRepresentation::kFloat32:
+      other_rep1 = MachineRepresentation::kFloat64;
+      other_rep2 = MachineRepresentation::kSimd128;
+      break;
+    case MachineRepresentation::kFloat64:
+      other_rep1 = MachineRepresentation::kFloat32;
+      other_rep2 = MachineRepresentation::kSimd128;
+      break;
+    case MachineRepresentation::kSimd128:
+      other_rep1 = MachineRepresentation::kFloat32;
+      other_rep2 = MachineRepresentation::kFloat64;
+      break;
+    default:
+      UNREACHABLE();
+      break;
+  }
   const RegisterConfiguration* config = RegisterConfiguration::Turbofan();
   if (config->fp_aliasing_kind() != RegisterConfiguration::COMBINE) {
     // Overlap aliasing case.
-    return set.find(LocationOperand(loc.kind(), loc.location_kind(),
-                                    other_fp_rep, loc.register_code())) !=
-           set.end();
+    return Contains(set, loc, other_rep1, loc.register_code()) ||
+           Contains(set, loc, other_rep2, loc.register_code());
   }
   // Combine aliasing case.
-  int alias_base_index = -1;
-  int aliases = config->GetAliases(rep, loc.register_code(), other_fp_rep,
-                                   &alias_base_index);
+  int base = -1;
+  int aliases = config->GetAliases(rep, loc.register_code(), other_rep1, &base);

[Mircea Trofin, 2016/06/27 20:32:26]

Is base expected to be positive after this?

[bbudge, 2016/06/27 20:43:21]

It is left unchanged if the return value is 0 (no aliases.) I initialize it to
-1 to fail quicker if someone tries to use it when the return value is 0.

[Mircea Trofin, 2016/06/27 20:49:20]

Should we have the DCHECK right after the call to GetAliases?

[bbudge, 2016/06/27 21:08:01]

Good idea, I've added a DCHECK at all GetAliases call sites.

   while (aliases--) {
-    int aliased_reg = alias_base_index + aliases;
-    if (set.find(LocationOperand(loc.kind(), loc.location_kind(), other_fp_rep,
-                                 aliased_reg)) != set.end())
-      return true;
+    if (Contains(set, loc, other_rep1, base + aliases)) return true;
+  }
+  aliases = config->GetAliases(rep, loc.register_code(), other_rep2, &base);
+  while (aliases--) {
+    if (Contains(set, loc, other_rep2, base + aliases)) return true;
   }
   return false;
 }
 
 int FindFirstNonEmptySlot(const Instruction* instr) {
   int i = Instruction::FIRST_GAP_POSITION;
   for (; i <= Instruction::LAST_GAP_POSITION; i++) {
     ParallelMove* moves = instr->parallel_moves()[i];
     if (moves == nullptr) continue;
     for (MoveOperands* move : *moves) {
@@ skipping 434 matching lines @@
         static_cast<Instruction::GapPosition>(1), code_zone());
     slot_1->AddMove(group_begin->destination(), load->destination());
     load->Eliminate();
   }
   loads.clear();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8