[turbofan] Cache the Branch operator(s).

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 106 matching lines @@
                control_input_count, control_output_count)                   \
   struct Name##Operator FINAL : public Operator {                           \
     Name##Operator()                                                        \
         : Operator(IrOpcode::k##Name, properties, #Name, value_input_count, \
                    effect_input_count, control_input_count, 0, 0,           \
                    control_output_count) {}                                 \
   };                                                                        \
   Name##Operator k##Name##Operator;
   CACHED_OP_LIST(CACHED)
 #undef CACHED
+
+  template <BranchHint kBranchHint>
+  struct BranchOperator FINAL : public Operator1<BranchHint> {
+    BranchOperator()
+        : Operator1<BranchHint>(                       // --
+              IrOpcode::kBranch, Operator::kFoldable,  // opcode
+              "Branch",                                // name
+              1, 0, 1, 0, 0, 2,                        // counts
+              kBranchHint) {}                          // parameter
+  };
+  BranchOperator<BranchHint::kNone> kBranchNoneOperator;
+  BranchOperator<BranchHint::kTrue> kBranchTrueOperator;
+  BranchOperator<BranchHint::kFalse> kBranchFalseOperator;
 };
 
 
 static base::LazyInstance<CommonOperatorGlobalCache>::type kCache =
     LAZY_INSTANCE_INITIALIZER;
 
 
 CommonOperatorBuilder::CommonOperatorBuilder(Zone* zone)
     : cache_(kCache.Get()), zone_(zone) {}
 
 
 #define CACHED(Name, properties, value_input_count, effect_input_count, \
                control_input_count, control_output_count)               \
   const Operator* CommonOperatorBuilder::Name() {                       \
     return &cache_.k##Name##Operator;                                   \
   }
 CACHED_OP_LIST(CACHED)
 #undef CACHED
 
 
 const Operator* CommonOperatorBuilder::Branch(BranchHint hint) {
-  return new (zone()) Operator1<BranchHint>(
-      IrOpcode::kBranch, Operator::kFoldable, "Branch", 1, 0, 1, 0, 0, 2, hint);
+  switch (hint) {
+    case BranchHint::kNone:
+      return &cache_.kBranchNoneOperator;
+    case BranchHint::kTrue:
+      return &cache_.kBranchTrueOperator;
+    case BranchHint::kFalse:
+      return &cache_.kBranchFalseOperator;
+  }
+  UNREACHABLE();
+  return nullptr;
 }
 
 
 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()) Operator(               // --
       IrOpcode::kStart, Operator::kFoldable,  // opcode
       "Start",                                // name
       0, 0, 0, value_output_count, 1, 1);     // counts
@@ skipping 191 matching lines @@
   return new (zone()) Operator1<size_t>(       // --
       IrOpcode::kProjection, Operator::kPure,  // opcode
       "Projection",                            // name
       1, 0, 0, 1, 0, 0,                        // counts
       index);                                  // parameter
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8