[turbofan] Add initial support for SOFT deopts.

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 18 matching lines @@
   return os;
 }
 
 
 BranchHint BranchHintOf(const Operator* const op) {
   DCHECK_EQ(IrOpcode::kBranch, op->opcode());
   return OpParameter<BranchHint>(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);
+}
+
+
 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 66 matching lines @@
 }
 
 
 #define CACHED_OP_LIST(V)                                  \
   V(Dead, Operator::kFoldable, 0, 0, 0, 1, 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(Deoptimize, Operator::kNoThrow, 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(BeginRegion, Operator::kNoThrow, 0, 1, 0, 0, 1, 0)     \
   V(FinishRegion, Operator::kNoThrow, 1, 1, 0, 1, 1, 0)
 
 
 #define CACHED_RETURN_LIST(V) \
   V(1)                        \
   V(2)                        \
@@ skipping 88 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 197 matching lines @@
     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::IfException(IfExceptionHint hint) {
   switch (hint) {
     case IfExceptionHint::kLocallyCaught:
       return &cache_.kIfExceptionCOperator;
     case IfExceptionHint::kLocallyUncaught:
       return &cache_.kIfExceptionUOperator;
   }
   UNREACHABLE();
   return nullptr;
 }
@@ skipping 347 matching lines @@
     Handle<SharedFunctionInfo> shared_info,
     ContextCallingMode context_calling_mode) {
   return new (zone()->New(sizeof(FrameStateFunctionInfo)))
       FrameStateFunctionInfo(type, parameter_count, local_count, shared_info,
                              context_calling_mode);
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8