[turbofan] add non fixed slot constraint to register allocator

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 144 matching lines @@
           constraint->type_ = kFixedDoubleRegister;
           constraint->value_ = unallocated->fixed_register_index();
           break;
         case UnallocatedOperand::MUST_HAVE_REGISTER:
           if (sequence()->IsDouble(vreg)) {
             constraint->type_ = kDoubleRegister;
           } else {
             constraint->type_ = kRegister;
           }
           break;
+        case UnallocatedOperand::MUST_HAVE_SLOT:
+          if (sequence()->IsDouble(vreg)) {
+            constraint->type_ = kDoubleSlot;
+          } else {
+            constraint->type_ = kSlot;
+          }
+          break;
         case UnallocatedOperand::SAME_AS_FIRST_INPUT:
           constraint->type_ = kSameAsFirst;
           break;
       }
     }
   }
 }
 
 
 void RegisterAllocatorVerifier::CheckConstraint(
@@ skipping 18 matching lines @@
       CHECK(op->IsDoubleRegister());
       return;
     case kFixedDoubleRegister:
       CHECK(op->IsDoubleRegister());
       CHECK_EQ(op->index(), constraint->value_);
       return;
     case kFixedSlot:
       CHECK(op->IsStackSlot());
       CHECK_EQ(op->index(), constraint->value_);
       return;
+    case kSlot:
+      CHECK(op->IsStackSlot());
+      return;
+    case kDoubleSlot:
+      CHECK(op->IsDoubleStackSlot());
+      return;
     case kNone:
       CHECK(op->IsRegister() || op->IsStackSlot());
       return;
     case kNoneDouble:
       CHECK(op->IsDoubleRegister() || op->IsDoubleStackSlot());
       return;
     case kSameAsFirst:
       CHECK(false);
       return;
   }
@@ skipping 81 matching lines @@
   Map& map() { return map_; }
 
   void RunParallelMoves(Zone* zone, const ParallelMove* move) {
     // Compute outgoing mappings.
     Map to_insert(zone);
     auto moves = move->move_operands();
     for (auto i = moves->begin(); i != moves->end(); ++i) {
       if (i->IsEliminated()) continue;
       auto cur = map().find(i->source());
       CHECK(cur != map().end());
-      to_insert.insert(std::make_pair(i->destination(), cur->second));
+      auto res =
+          to_insert.insert(std::make_pair(i->destination(), cur->second));
+      // Ensure injectivity of moves.
+      CHECK(res.second);
     }
     // Drop current mappings.
     for (auto i = moves->begin(); i != moves->end(); ++i) {
       if (i->IsEliminated()) continue;
       auto cur = map().find(i->destination());
       if (cur != map().end()) map().erase(cur);
     }
     // Insert new values.
     map().insert(to_insert.begin(), to_insert.end());
   }
@@ skipping 345 matching lines @@
         int virtual_register = op_constraints[count].virtual_register_;
         current->Define(zone(), instr->OutputAt(i), virtual_register);
       }
     }
   }
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8