[Turbofan] Add concept of FP register aliasing on ARM 32.

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 Blocks(const OperandSet& set, const InstructionOperand& operand) {
-  return set.find(operand) != set.end();
+#define REP_BIT(rep) (1 << static_cast<int>(rep));
+
+bool HasMixedFPReps(int reps) {
+  return reps && !base::bits::IsPowerOfTwo32(reps);
+}
+
+void InsertOp(OperandSet* set, const InstructionOperand& op, int* fp_reg_reps) {

[Mircea Trofin, 2016/10/12 21:09:26]

would it be overkill to define InsertOp as a member of OperandSet, and hide
insert from std::set? could be done in a separate CL - benefit is
maintainability.

[bbudge, 2016/10/12 23:07:17]

OperandSet is only a typedef. We could have it inherit from std::set or create a
wrapper class, but it seems to go against the V8 philosophy (e.g. ParallelMove,
which inherits from ZoneVector, and so exposes push_back, leading to some
confusion.)

[Mircea Trofin, 2016/10/14 20:58:39]

Mind adding a todo on the typedef to investigate doing this? I was thinking of
private inheritance or using set as a member.

[bbudge, 2016/10/15 01:30:25]

I replaced the typedef with a class. It's much cleaner since I can encapsulate
the FP rep tracking in the class. Good suggestion!

+  set->insert(op);
+  if (!kSimpleFPAliasing && op.IsFPRegister())
+    *fp_reg_reps |= REP_BIT(LocationOperand::cast(op).representation());
+}
+
+bool ContainsOpOrAlias(const OperandSet& set, const InstructionOperand& op,

[Mircea Trofin, 2016/10/12 21:09:26]

same for this API

[bbudge, 2016/10/12 23:07:17]

Ditto

+                       int fp_reg_reps) {
+  if (set.find(op) != set.end()) return true;
+
+  if (!kSimpleFPAliasing && op.IsFPRegister()) {
+    // Platforms where FP registers have complex aliasing need extra checks.
+    const LocationOperand& loc = LocationOperand::cast(op);
+    MachineRepresentation rep = loc.representation();
+    // If we haven't encountered mixed FP registers, skip the extra checks.
+    fp_reg_reps |= REP_BIT(rep);
+    if (!HasMixedFPReps(fp_reg_reps)) return false;
+
+    // Check register against aliasing registers of other FP representations.
+    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();
+    int base = -1;
+    int aliases =
+        config->GetAliases(rep, loc.register_code(), other_rep1, &base);
+    DCHECK(aliases > 0 || (aliases == 0 && base == -1));
+    while (aliases--) {
+      if (set.find(AllocatedOperand(LocationOperand::REGISTER, other_rep1,
+                                    base + aliases)) != set.end())
+        return true;
+    }
+    aliases = config->GetAliases(rep, loc.register_code(), other_rep2, &base);
+    DCHECK(aliases > 0 || (aliases == 0 && base == -1));
+    while (aliases--) {
+      if (set.find(AllocatedOperand(LocationOperand::REGISTER, other_rep2,
+                                    base + aliases)) != set.end())
+        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) {
       if (!move->IsRedundant()) return i;
       move->Eliminate();
@@ skipping 45 matching lines @@
 void MoveOptimizer::RemoveClobberedDestinations(Instruction* instruction) {
   if (instruction->IsCall()) return;
   ParallelMove* moves = instruction->parallel_moves()[0];
   if (moves == nullptr) return;
 
   DCHECK(instruction->parallel_moves()[1] == nullptr ||
          instruction->parallel_moves()[1]->empty());
 
   OperandSet outputs(local_zone());
   OperandSet inputs(local_zone());
+  int input_fp_reg_reps = 0;
+  int output_fp_reg_reps = 0;
 
   // Outputs and temps are treated together as potentially clobbering a
   // destination operand.
   for (size_t i = 0; i < instruction->OutputCount(); ++i) {
-    outputs.insert(*instruction->OutputAt(i));
+    InsertOp(&outputs, *instruction->OutputAt(i), &output_fp_reg_reps);
   }
   for (size_t i = 0; i < instruction->TempCount(); ++i) {
-    outputs.insert(*instruction->TempAt(i));
+    InsertOp(&outputs, *instruction->TempAt(i), &output_fp_reg_reps);
   }
 
   // Input operands block elisions.
   for (size_t i = 0; i < instruction->InputCount(); ++i) {
-    inputs.insert(*instruction->InputAt(i));
+    InsertOp(&inputs, *instruction->InputAt(i), &input_fp_reg_reps);
   }
 
   // Elide moves made redundant by the instruction.
   for (MoveOperands* move : *moves) {
-    if (outputs.find(move->destination()) != outputs.end() &&
-        inputs.find(move->destination()) == inputs.end()) {
+    if (ContainsOpOrAlias(outputs, move->destination(), output_fp_reg_reps) &&
+        !ContainsOpOrAlias(inputs, move->destination(), input_fp_reg_reps)) {
       move->Eliminate();
     }
   }
 
   // The ret instruction makes any assignment before it unnecessary, except for
   // the one for its input.
   if (instruction->IsRet() || instruction->IsTailCall()) {
     for (MoveOperands* move : *moves) {
-      if (inputs.find(move->destination()) == inputs.end()) {
+      if (!ContainsOpOrAlias(inputs, move->destination(), input_fp_reg_reps)) {
         move->Eliminate();
       }
     }
   }
 }
 
 void MoveOptimizer::MigrateMoves(Instruction* to, Instruction* from) {
   if (from->IsCall()) return;
 
   ParallelMove* from_moves = from->parallel_moves()[0];
   if (from_moves == nullptr || from_moves->empty()) return;
 
   OperandSet dst_cant_be(local_zone());
   OperandSet src_cant_be(local_zone());
+  int dst_fp_reg_reps = 0;
+  int src_fp_reg_reps = 0;
 
   // If an operand is an input to the instruction, we cannot move assignments
   // where it appears on the LHS.
   for (size_t i = 0; i < from->InputCount(); ++i) {
-    dst_cant_be.insert(*from->InputAt(i));
+    InsertOp(&dst_cant_be, *from->InputAt(i), &dst_fp_reg_reps);
   }
   // If an operand is output to the instruction, we cannot move assignments
   // where it appears on the RHS, because we would lose its value before the
   // instruction.
   // Same for temp operands.
   // The output can't appear on the LHS because we performed
   // RemoveClobberedDestinations for the "from" instruction.
   for (size_t i = 0; i < from->OutputCount(); ++i) {
-    src_cant_be.insert(*from->OutputAt(i));
+    InsertOp(&src_cant_be, *from->OutputAt(i), &src_fp_reg_reps);
   }
   for (size_t i = 0; i < from->TempCount(); ++i) {
-    src_cant_be.insert(*from->TempAt(i));
+    InsertOp(&src_cant_be, *from->TempAt(i), &src_fp_reg_reps);
   }
   for (MoveOperands* move : *from_moves) {
     if (move->IsRedundant()) continue;
     // Assume dest has a value "V". If we have a "dest = y" move, then we can't
     // move "z = dest", because z would become y rather than "V".
     // We assume CompressMoves has happened before this, which means we don't
     // have more than one assignment to dest.
-    src_cant_be.insert(move->destination());
+    InsertOp(&src_cant_be, move->destination(), &src_fp_reg_reps);
   }
 
   ZoneSet<MoveKey, MoveKeyCompare> move_candidates(local_zone());
   // We start with all the moves that don't have conflicting source or
   // destination operands are eligible for being moved down.
   for (MoveOperands* move : *from_moves) {
     if (move->IsRedundant()) continue;
-    if (!Blocks(dst_cant_be, move->destination())) {
+    if (!ContainsOpOrAlias(dst_cant_be, move->destination(), dst_fp_reg_reps)) {
       MoveKey key = {move->source(), move->destination()};
       move_candidates.insert(key);
     }
   }
   if (move_candidates.empty()) return;
 
   // Stabilize the candidate set.
   bool changed = false;
   do {
     changed = false;
     for (auto iter = move_candidates.begin(); iter != move_candidates.end();) {
       auto current = iter;
       ++iter;
       InstructionOperand src = current->source;
-      if (Blocks(src_cant_be, src)) {
-        src_cant_be.insert(current->destination);
+      if (ContainsOpOrAlias(src_cant_be, src, src_fp_reg_reps)) {
+        InsertOp(&src_cant_be, current->destination, &src_fp_reg_reps);
         move_candidates.erase(current);
         changed = true;
       }
     }
   } while (changed);
 
   ParallelMove to_move(local_zone());
   for (MoveOperands* move : *from_moves) {
     if (move->IsRedundant()) continue;
     MoveKey key = {move->source(), move->destination()};
@@ skipping 18 matching lines @@
   if (right == nullptr) return;
 
   MoveOpVector& eliminated = local_vector();
   DCHECK(eliminated.empty());
 
   if (!left->empty()) {
     // Modify the right moves in place and collect moves that will be killed by
     // merging the two gaps.
     for (MoveOperands* move : *right) {
       if (move->IsRedundant()) continue;
-      MoveOperands* to_eliminate = left->PrepareInsertAfter(move);
-      if (to_eliminate != nullptr) eliminated.push_back(to_eliminate);
+      left->PrepareInsertAfter(move, &eliminated);
     }
     // Eliminate dead moves.
     for (MoveOperands* to_eliminate : eliminated) {
       to_eliminate->Eliminate();
     }
     eliminated.clear();
   }
   // Add all possibly modified moves from right side.
   for (MoveOperands* move : *right) {
     if (move->IsRedundant()) continue;
@@ skipping 236 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