[turbofan] Add support for (deferred) instance migration.

src/compiler/simplified-operator.cc

 // Copyright 2012 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/simplified-operator.h"
 
 #include "src/base/lazy-instance.h"
 #include "src/compiler/opcodes.h"
 #include "src/compiler/operator.h"
 #include "src/compiler/types.h"
@@ skipping 216 matching lines @@
   switch (mode) {
     case CheckForMinusZeroMode::kCheckForMinusZero:
       return os << "check-for-minus-zero";
     case CheckForMinusZeroMode::kDontCheckForMinusZero:
       return os << "dont-check-for-minus-zero";
   }
   UNREACHABLE();
   return os;
 }
 
+std::ostream& operator<<(std::ostream& os, CheckMapsFlags flags) {
+  bool empty = true;
+  if (flags & CheckMapsFlag::kTryMigrateInstance) {
+    os << "TryMigrateInstance";
+    empty = false;
+  }
+  if (empty) os << "None";
+  return os;
+}
+
 bool operator==(CheckMapsParameters const& lhs,
                 CheckMapsParameters const& rhs) {
-  return lhs.maps() == rhs.maps();
+  return lhs.flags() == rhs.flags() && lhs.maps() == rhs.maps();
 }
 
 bool operator!=(CheckMapsParameters const& lhs,
                 CheckMapsParameters const& rhs) {
   return !(lhs == rhs);
 }
 
-size_t hash_value(CheckMapsParameters const& p) { return hash_value(p.maps()); }
+size_t hash_value(CheckMapsParameters const& p) {
+  return base::hash_combine(p.flags(), p.maps());
+}
 
 std::ostream& operator<<(std::ostream& os, CheckMapsParameters const& p) {
   ZoneHandleSet<Map> const& maps = p.maps();
+  os << p.flags();
   for (size_t i = 0; i < maps.size(); ++i) {
-    if (i != 0) os << ", ";
-    os << Brief(*maps[i]);
+    os << ", " << Brief(*maps[i]);
   }
   return os;
 }
 
 CheckMapsParameters const& CheckMapsParametersOf(Operator const* op) {
   DCHECK_EQ(IrOpcode::kCheckMaps, op->opcode());
   return OpParameter<CheckMapsParameters>(op);
 }
 
 size_t hash_value(CheckTaggedInputMode mode) {
@@ skipping 471 matching lines @@
   switch (mode) {
     case CheckTaggedInputMode::kNumber:
       return &cache_.kCheckedTaggedToFloat64NumberOperator;
     case CheckTaggedInputMode::kNumberOrOddball:
       return &cache_.kCheckedTaggedToFloat64NumberOrOddballOperator;
   }
   UNREACHABLE();
   return nullptr;
 }
 
-const Operator* SimplifiedOperatorBuilder::CheckMaps(ZoneHandleSet<Map> maps) {
-  CheckMapsParameters const parameters(maps);
+const Operator* SimplifiedOperatorBuilder::CheckMaps(CheckMapsFlags flags,
+                                                     ZoneHandleSet<Map> maps) {
+  CheckMapsParameters const parameters(flags, maps);
   return new (zone()) Operator1<CheckMapsParameters>(  // --
       IrOpcode::kCheckMaps,                            // opcode
       Operator::kNoThrow | Operator::kNoWrite,         // flags
       "CheckMaps",                                     // name
       1, 1, 1, 0, 1, 0,                                // counts
       parameters);                                     // parameter
 }
 
 const Operator* SimplifiedOperatorBuilder::CheckFloat64Hole(
     CheckFloat64HoleMode mode) {
@@ skipping 134 matching lines @@
                         Operator::kNoDeopt | Operator::kNoThrow | properties,  \
                         #Name, value_input_count, 1, control_input_count,      \
                         output_count, 1, 0, access);                           \
   }
 ACCESS_OP_LIST(ACCESS)
 #undef ACCESS
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8