[turbofan] Add support for deferred code.

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/unique.h"
@@ skipping 12 matching lines @@
                   int outputs, int controls, const char* mnemonic)
       : Operator1<int>(opcode, properties, inputs, outputs, mnemonic,
                        controls) {}
 
   virtual void PrintParameter(std::ostream& os) const FINAL {}
 };
 
 }  // namespace
 
 
+std::ostream& operator<<(std::ostream& os, BranchHint hint) {
+  switch (hint) {
+    case BranchHint::kNone:
+      return os << "None";
+    case BranchHint::kTrue:
+      return os << "True";
+    case BranchHint::kFalse:
+      return os << "False";
+  }
+  UNREACHABLE();
+  return os;
+}
+
+
+BranchHint BranchHintOf(const Operator* const op) {
+  DCHECK_EQ(IrOpcode::kBranch, op->opcode());
+  return OpParameter<BranchHint>(op);
+}
+
+
 size_t hash_value(OutputFrameStateCombine const& sc) {
   return base::hash_combine(sc.kind_, sc.parameter_);
 }
 
 
 std::ostream& operator<<(std::ostream& os, OutputFrameStateCombine const& sc) {
   switch (sc.kind_) {
     case OutputFrameStateCombine::kPushOutput:
       if (sc.parameter_ == 0) return os << "Ignore";
       return os << "Push(" << sc.parameter_ << ")";
@@ skipping 24 matching lines @@
 
 std::ostream& operator<<(std::ostream& os, FrameStateCallInfo const& info) {
   return os << info.type() << ", " << info.bailout_id() << ", "
             << info.state_combine();
 }
 
 
 #define SHARED_OP_LIST(V)               \
   V(Dead, Operator::kFoldable, 0, 0)    \
   V(End, Operator::kFoldable, 0, 1)     \
-  V(Branch, Operator::kFoldable, 1, 1)  \
   V(IfTrue, Operator::kFoldable, 0, 1)  \
   V(IfFalse, Operator::kFoldable, 0, 1) \
   V(Throw, Operator::kFoldable, 1, 1)   \
   V(Return, Operator::kNoProperties, 1, 1)
 
 
 struct CommonOperatorBuilderImpl FINAL {
 #define SHARED(Name, properties, value_input_count, control_input_count)       \
   struct Name##Operator FINAL : public ControlOperator {                       \
     Name##Operator()                                                           \
@@ skipping 15 matching lines @@
 
 
 #define SHARED(Name, properties, value_input_count, control_input_count) \
   const Operator* CommonOperatorBuilder::Name() {                        \
     return &impl_.k##Name##Operator;                                     \
   }
 SHARED_OP_LIST(SHARED)
 #undef SHARED
 
 
+const Operator* CommonOperatorBuilder::Branch(BranchHint hint) {
+  return new (zone()) Operator1<BranchHint>(
+      IrOpcode::kBranch, Operator::kFoldable, 1, 0, "Branch", hint);
+}
+
+
 const Operator* CommonOperatorBuilder::Start(int num_formal_parameters) {
   // Outputs are formal parameters, plus context, receiver, and JSFunction.
   const int value_output_count = num_formal_parameters + 3;
   return new (zone()) ControlOperator(IrOpcode::kStart, Operator::kFoldable, 0,
                                       value_output_count, 0, "Start");
 }
 
 
 const Operator* CommonOperatorBuilder::Merge(int controls) {
   return new (zone()) ControlOperator(IrOpcode::kMerge, Operator::kFoldable, 0,
@@ skipping 129 matching lines @@
 
 
 const Operator* CommonOperatorBuilder::Projection(size_t index) {
   return new (zone()) Operator1<size_t>(IrOpcode::kProjection, Operator::kPure,
                                         1, 1, "Projection", index);
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8