[turbofan] Add support for eager/soft deoptimization reasons.

src/compiler/common-operator.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/common-operator.h"
 
 #include "src/assembler.h"
 #include "src/base/lazy-instance.h"
 #include "src/compiler/linkage.h"
 #include "src/compiler/opcodes.h"
@@ skipping 17 matching lines @@
   UNREACHABLE();
   return os;
 }
 
 
 BranchHint BranchHintOf(const Operator* const op) {
   DCHECK_EQ(IrOpcode::kBranch, op->opcode());
   return OpParameter<BranchHint>(op);
 }
 
+DeoptimizeReason DeoptimizeReasonOf(Operator const* const op) {
+  DCHECK(op->opcode() == IrOpcode::kDeoptimizeIf ||
+         op->opcode() == IrOpcode::kDeoptimizeUnless);
+  return OpParameter<DeoptimizeReason>(op);
+}
 
 size_t hash_value(DeoptimizeKind kind) { return static_cast<size_t>(kind); }
 
-
 std::ostream& operator<<(std::ostream& os, DeoptimizeKind kind) {
   switch (kind) {
     case DeoptimizeKind::kEager:
       return os << "Eager";
     case DeoptimizeKind::kSoft:
       return os << "Soft";
   }
   UNREACHABLE();
   return os;
 }
 
-
-DeoptimizeKind DeoptimizeKindOf(const Operator* const op) {
-  DCHECK_EQ(IrOpcode::kDeoptimize, op->opcode());
-  return OpParameter<DeoptimizeKind>(op);
+bool operator==(DeoptimizeParameters lhs, DeoptimizeParameters rhs) {
+  return lhs.kind() == rhs.kind() && lhs.reason() == rhs.reason();
 }
 
+bool operator!=(DeoptimizeParameters lhs, DeoptimizeParameters rhs) {
+  return !(lhs == rhs);
+}
+
+size_t hash_value(DeoptimizeParameters p) {
+  return base::hash_combine(p.kind(), p.reason());
+}
+
+std::ostream& operator<<(std::ostream& os, DeoptimizeParameters p) {
+  return os << p.kind() << ":" << p.reason();
+}
+
+DeoptimizeParameters const& DeoptimizeParametersOf(Operator const* const op) {
+  DCHECK_EQ(IrOpcode::kDeoptimize, op->opcode());
+  return OpParameter<DeoptimizeParameters>(op);
+}
 
 size_t hash_value(IfExceptionHint hint) { return static_cast<size_t>(hint); }
 
 
 std::ostream& operator<<(std::ostream& os, IfExceptionHint hint) {
   switch (hint) {
     case IfExceptionHint::kLocallyCaught:
       return os << "Caught";
     case IfExceptionHint::kLocallyUncaught:
       return os << "Uncaught";
@@ skipping 127 matching lines @@
       os << ", ";
     }
     first = false;
     os << elem;
   }
   return os;
 }
 
 #define CACHED_OP_LIST(V)                                    \
   V(Dead, Operator::kFoldable, 0, 0, 0, 1, 1, 1)             \
-  V(DeoptimizeIf, Operator::kFoldable, 2, 1, 1, 0, 1, 1)     \
-  V(DeoptimizeUnless, Operator::kFoldable, 2, 1, 1, 0, 1, 1) \
   V(IfTrue, Operator::kKontrol, 0, 0, 1, 0, 0, 1)            \
   V(IfFalse, Operator::kKontrol, 0, 0, 1, 0, 0, 1)           \
   V(IfSuccess, Operator::kKontrol, 0, 0, 1, 0, 0, 1)         \
   V(IfDefault, Operator::kKontrol, 0, 0, 1, 0, 0, 1)         \
   V(Throw, Operator::kKontrol, 1, 1, 1, 0, 0, 1)             \
   V(Terminate, Operator::kKontrol, 0, 1, 1, 0, 0, 1)         \
   V(OsrNormalEntry, Operator::kFoldable, 0, 1, 1, 0, 1, 1)   \
   V(OsrLoopEntry, Operator::kFoldable, 0, 1, 1, 0, 1, 1)     \
   V(LoopExit, Operator::kKontrol, 0, 0, 2, 0, 0, 1)          \
   V(LoopExitValue, Operator::kPure, 1, 0, 1, 1, 0, 0)        \
@@ skipping 95 matching lines @@
     Name##Operator()                                                         \
         : Operator(IrOpcode::k##Name, properties, #Name, value_input_count,  \
                    effect_input_count, control_input_count,                  \
                    value_output_count, effect_output_count,                  \
                    control_output_count) {}                                  \
   };                                                                         \
   Name##Operator k##Name##Operator;
   CACHED_OP_LIST(CACHED)
 #undef CACHED
 
-  template <DeoptimizeKind kKind>
-  struct DeoptimizeOperator final : public Operator1<DeoptimizeKind> {
-    DeoptimizeOperator()
-        : Operator1<DeoptimizeKind>(                      // --
-              IrOpcode::kDeoptimize, Operator::kNoThrow,  // opcode
-              "Deoptimize",                               // name
-              1, 1, 1, 0, 0, 1,                           // counts
-              kKind) {}                                   // parameter
-  };
-  DeoptimizeOperator<DeoptimizeKind::kEager> kDeoptimizeEagerOperator;
-  DeoptimizeOperator<DeoptimizeKind::kSoft> kDeoptimizeSoftOperator;
-
   template <IfExceptionHint kCaughtLocally>
   struct IfExceptionOperator final : public Operator1<IfExceptionHint> {
     IfExceptionOperator()
         : Operator1<IfExceptionHint>(                      // --
               IrOpcode::kIfException, Operator::kKontrol,  // opcode
               "IfException",                               // name
               0, 1, 1, 1, 1, 1,                            // counts
               kCaughtLocally) {}                           // parameter
   };
   IfExceptionOperator<IfExceptionHint::kLocallyCaught> kIfExceptionCOperator;
@@ skipping 211 matching lines @@
       return &cache_.kBranchNoneOperator;
     case BranchHint::kTrue:
       return &cache_.kBranchTrueOperator;
     case BranchHint::kFalse:
       return &cache_.kBranchFalseOperator;
   }
   UNREACHABLE();
   return nullptr;
 }
 
-
-const Operator* CommonOperatorBuilder::Deoptimize(DeoptimizeKind kind) {
-  switch (kind) {
-    case DeoptimizeKind::kEager:
-      return &cache_.kDeoptimizeEagerOperator;
-    case DeoptimizeKind::kSoft:
-      return &cache_.kDeoptimizeSoftOperator;
-  }
-  UNREACHABLE();
-  return nullptr;
+const Operator* CommonOperatorBuilder::Deoptimize(DeoptimizeKind kind,
+                                                  DeoptimizeReason reason) {
+  // TODO(turbofan): Cache the most common versions of this.
+  DeoptimizeParameters parameter(kind, reason);
+  return new (zone()) Operator1<DeoptimizeParameters>(  // --
+      IrOpcode::kDeoptimize,                            // opcodes
+      Operator::kFoldable | Operator::kNoThrow,         // properties
+      "Deoptimize",                                     // name
+      1, 1, 1, 0, 0, 1,                                 // counts
+      parameter);                                       // parameter
 }
 
+const Operator* CommonOperatorBuilder::DeoptimizeIf(DeoptimizeReason reason) {
+  // TODO(turbofan): Cache the most common versions of this.
+  return new (zone()) Operator1<DeoptimizeReason>(  // --
+      IrOpcode::kDeoptimizeIf,                      // opcode
+      Operator::kFoldable | Operator::kNoThrow,     // properties
+      "DeoptimizeIf",                               // name
+      2, 1, 1, 0, 1, 1,                             // counts
+      reason);                                      // parameter
+}
+
+const Operator* CommonOperatorBuilder::DeoptimizeUnless(
+    DeoptimizeReason reason) {
+  // TODO(turbofan): Cache the most common versions of this.
+  return new (zone()) Operator1<DeoptimizeReason>(  // --
+      IrOpcode::kDeoptimizeUnless,                  // opcode
+      Operator::kFoldable | Operator::kNoThrow,     // properties
+      "DeoptimizeUnless",                           // name
+      2, 1, 1, 0, 1, 1,                             // counts
+      reason);                                      // parameter
+}
 
 const Operator* CommonOperatorBuilder::IfException(IfExceptionHint hint) {
   switch (hint) {
     case IfExceptionHint::kLocallyCaught:
       return &cache_.kIfExceptionCOperator;
     case IfExceptionHint::kLocallyUncaught:
       return &cache_.kIfExceptionUOperator;
   }
   UNREACHABLE();
   return nullptr;
@@ skipping 360 matching lines @@
 CommonOperatorBuilder::CreateFrameStateFunctionInfo(
     FrameStateType type, int parameter_count, int local_count,
     Handle<SharedFunctionInfo> shared_info) {
   return new (zone()->New(sizeof(FrameStateFunctionInfo)))
       FrameStateFunctionInfo(type, parameter_count, local_count, shared_info);
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8