[turbofan] Initial support for Switch.

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 CaseIndexOf(const Operator* const op) {
+  DCHECK_EQ(IrOpcode::kCase, op->opcode());
+  return OpParameter<size_t>(op);
+}
+
+
 bool operator==(SelectParameters const& lhs, SelectParameters const& rhs) {
   return lhs.type() == rhs.type() && lhs.hint() == rhs.hint();
 }
 
 
 bool operator!=(SelectParameters const& lhs, SelectParameters const& rhs) {
   return !(lhs == rhs);
 }
 
 
@@ skipping 194 matching lines @@
     case BranchHint::kTrue:
       return &cache_.kBranchTrueOperator;
     case BranchHint::kFalse:
       return &cache_.kBranchFalseOperator;
   }
   UNREACHABLE();
   return nullptr;
 }
 
 
+const Operator* CommonOperatorBuilder::Switch(size_t control_output_count) {
+  DCHECK_GE(control_output_count, 2u);         // Disallow trivial switches.
+  return new (zone()) Operator(                // --
+      IrOpcode::kSwitch, Operator::kFoldable,  // opcode
+      "Switch",                                // name
+      1, 0, 1, 0, 0, control_output_count);    // counts
+}
+
+
+const Operator* CommonOperatorBuilder::Case(size_t index) {
+  return new (zone()) Operator1<size_t>(     // --
+      IrOpcode::kCase, Operator::kFoldable,  // opcode
+      "Case",                                // name
+      0, 0, 1, 0, 0, 1,                      // counts
+      index);                                // parameter
+}
+
+
 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 248 matching lines @@
   } else {
     UNREACHABLE();
     return nullptr;
   }
 }
 
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8