[turbofan] add MachineType to AllocatedOperand

src/compiler/register-allocator-verifier.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/bit-vector.h"
 #include "src/compiler/instruction.h"
 #include "src/compiler/register-allocator-verifier.h"
 
 namespace v8 {
 namespace internal {
@@ skipping 145 matching lines @@
     constraint->virtual_register_ = vreg;
     if (unallocated->basic_policy() == UnallocatedOperand::FIXED_SLOT) {
       constraint->type_ = kFixedSlot;
       constraint->value_ = unallocated->fixed_slot_index();
     } else {
       switch (unallocated->extended_policy()) {
         case UnallocatedOperand::ANY:
           CHECK(false);
           break;
         case UnallocatedOperand::NONE:
-          if (sequence()->IsDouble(vreg)) {
+          if (sequence()->IsFloat(vreg)) {
             constraint->type_ = kNoneDouble;
           } else {
             constraint->type_ = kNone;
           }
           break;
         case UnallocatedOperand::FIXED_REGISTER:
           constraint->type_ = kFixedRegister;
           constraint->value_ = unallocated->fixed_register_index();
           break;
         case UnallocatedOperand::FIXED_DOUBLE_REGISTER:
           constraint->type_ = kFixedDoubleRegister;
           constraint->value_ = unallocated->fixed_register_index();
           break;
         case UnallocatedOperand::MUST_HAVE_REGISTER:
-          if (sequence()->IsDouble(vreg)) {
+          if (sequence()->IsFloat(vreg)) {
             constraint->type_ = kDoubleRegister;
           } else {
             constraint->type_ = kRegister;
           }
           break;
         case UnallocatedOperand::MUST_HAVE_SLOT:
-          if (sequence()->IsDouble(vreg)) {
+          if (sequence()->IsFloat(vreg)) {
             constraint->type_ = kDoubleSlot;
           } else {
             constraint->type_ = kSlot;
           }
           break;
         case UnallocatedOperand::SAME_AS_FIRST_INPUT:
           constraint->type_ = kSameAsFirst;
           break;
       }
     }
@@ skipping 80 matching lines @@
 };
 
 class PhiMap : public ZoneMap<int, PhiData*>, public ZoneObject {
  public:
   explicit PhiMap(Zone* zone) : ZoneMap<int, PhiData*>(zone) {}
 };
 
 struct OperandLess {
   bool operator()(const InstructionOperand* a,
                   const InstructionOperand* b) const {
-    return *a < *b;
+    return a->CompareModuloType(*b);
   }
 };
 
 class OperandMap : public ZoneObject {
  public:
   struct MapValue : public ZoneObject {
     MapValue()
         : incoming(nullptr),
           define_vreg(kInvalidVreg),
           use_vreg(kInvalidVreg),
@@ skipping 13 matching lines @@
     // Remove all entries with keys not in other.
     void Intersect(const Map& other) {
       if (this->empty()) return;
       auto it = this->begin();
       OperandLess less;
       for (const auto& o : other) {
         while (less(it->first, o.first)) {
           this->erase(it++);
           if (it == this->end()) return;
         }
-        if (*it->first == *o.first) {
+        if (it->first->EqualsModuloType(*o.first)) {
           ++it;
           if (it == this->end()) return;
         } else {
           CHECK(less(o.first, it->first));
         }
       }
     }
   };
 
   explicit OperandMap(Zone* zone) : map_(zone) {}
@@ skipping 31 matching lines @@
       RunParallelMoves(zone, move);
     }
   }
 
   void Drop(const InstructionOperand* op) {
     auto it = map().find(op);
     if (it != map().end()) map().erase(it);
   }
 
   void DropRegisters(const RegisterConfiguration* config) {
-    for (int i = 0; i < config->num_general_registers(); ++i) {
-      RegisterOperand op(i);
-      Drop(&op);
-    }
-    for (int i = 0; i < config->num_double_registers(); ++i) {
-      DoubleRegisterOperand op(i);
-      Drop(&op);
+    // TODO(dcarney): sort map by kind and drop range.
+    for (auto it = map().begin(); it != map().end();) {
+      auto op = it->first;
+      if (op->IsRegister() || op->IsDoubleRegister()) {
+        map().erase(it++);
+      } else {
+        ++it;
+      }
     }
   }
 
   void Define(Zone* zone, const InstructionOperand* op, int virtual_register) {
     auto value = new (zone) MapValue();
     value->define_vreg = virtual_register;
     auto res = map().insert(std::make_pair(op, value));
     if (!res.second) res.first->second = value;
   }
 
@@ skipping 307 matching lines @@
         int virtual_register = op_constraints[count].virtual_register_;
         current->Define(zone(), instr->OutputAt(i), virtual_register);
       }
     }
   }
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8