[Turbofan] Make operand canonicalization distinguish between FP types.

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) {
+  if (!operand.IsFPRegister()) return set.find(operand) != set.end();
+
+  const LocationOperand& loc = LocationOperand::cast(operand);
+  if (loc.representation() == MachineRepresentation::kFloat64) {
+    return set.find(operand) != set.end() ||
+           set.find(LocationOperand(loc.kind(), loc.location_kind(),
+                                    MachineRepresentation::kFloat32,
+                                    loc.register_code())) != set.end();
+  }
+  DCHECK_EQ(MachineRepresentation::kFloat32, loc.representation());
+  return set.find(operand) != set.end() ||
+         set.find(LocationOperand(loc.kind(), loc.location_kind(),
+                                  MachineRepresentation::kFloat64,
+                                  loc.register_code())) != set.end();
+}
 
 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 118 matching lines @@
     // 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());
   }
 
   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 (dst_cant_be.find(move->destination()) == dst_cant_be.end()) {
+    if (!Blocks(dst_cant_be, move->destination())) {
       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 (src_cant_be.find(src) != src_cant_be.end()) {
+      if (Blocks(src_cant_be, src)) {
         src_cant_be.insert(current->destination);
         move_candidates.erase(current);
         changed = true;
       }
     }
   } while (changed);
 
   ParallelMove to_move(local_zone());
   for (MoveOperands* move : *from_moves) {
     if (move->IsRedundant()) continue;
@@ skipping 277 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