Reland: [turbofan] add MachineType to AllocatedOperand

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 {
 
 typedef std::pair<InstructionOperand, InstructionOperand> MoveKey;
-typedef ZoneMap<MoveKey, unsigned> MoveMap;
-typedef ZoneSet<InstructionOperand> OperandSet;
+
+struct MoveKeyCompare {
+  bool operator()(const MoveKey& a, const MoveKey& b) const {
+    if (a.first.EqualsModuloType(b.first)) {
+      return a.second.CompareModuloType(b.second);
+    }
+    return a.first.CompareModuloType(b.first);
+  }
+};
+
+typedef ZoneMap<MoveKey, unsigned, MoveKeyCompare> MoveMap;
+typedef ZoneSet<InstructionOperand, CompareOperandModuloType> OperandSet;
 
 
 bool GapsCanMoveOver(Instruction* instr) { return instr->IsNop(); }
 
 
 int FindFirstNonEmptySlot(Instruction* instr) {
   int i = Instruction::FIRST_GAP_POSITION;
   for (; i <= Instruction::LAST_GAP_POSITION; i++) {
     auto moves = instr->parallel_moves()[i];
     if (moves == nullptr) continue;
@@ skipping 191 matching lines @@
 
 
 namespace {
 
 bool IsSlot(const InstructionOperand& op) {
   return op.IsStackSlot() || op.IsDoubleStackSlot();
 }
 
 
 bool LoadCompare(const MoveOperands* a, const MoveOperands* b) {
-  if (a->source() != b->source()) return a->source() < b->source();
+  if (!a->source().EqualsModuloType(b->source())) {
+    return a->source().CompareModuloType(b->source());
+  }
   if (IsSlot(a->destination()) && !IsSlot(b->destination())) return false;
   if (!IsSlot(a->destination()) && IsSlot(b->destination())) return true;
-  return a->destination() < b->destination();
+  return a->destination().CompareModuloType(b->destination());
 }
 
 }  // namespace
 
 
 // Split multiple loads of the same constant or stack slot off into the second
 // slot and keep remaining moves in the first slot.
 void MoveOptimizer::FinalizeMoves(Instruction* instr) {
   auto loads = temp_vector_0();
   DCHECK(loads.empty());
   // Find all the loads.
   for (auto move : *instr->parallel_moves()[0]) {
     if (move->IsRedundant()) continue;
     if (move->source().IsConstant() || IsSlot(move->source())) {
       loads.push_back(move);
     }
   }
   if (loads.empty()) return;
   // Group the loads by source, moving the preferred destination to the
   // beginning of the group.
   std::sort(loads.begin(), loads.end(), LoadCompare);
   MoveOperands* group_begin = nullptr;
   for (auto load : loads) {
     // New group.
-    if (group_begin == nullptr || load->source() != group_begin->source()) {
+    if (group_begin == nullptr ||
+        !load->source().EqualsModuloType(group_begin->source())) {
       group_begin = load;
       continue;
     }
     // Nothing to be gained from splitting here.
     if (IsSlot(group_begin->destination())) continue;
     // Insert new move into slot 1.
     auto slot_1 = instr->GetOrCreateParallelMove(
         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