[turbofan] Introduce new Select operator to improve bounds checking.

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 32 matching lines @@
   return os;
 }
 
 
 BranchHint BranchHintOf(const Operator* const op) {
   DCHECK_EQ(IrOpcode::kBranch, op->opcode());
   return OpParameter<BranchHint>(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);
+}
+
+
+size_t hash_value(SelectParameters const& p) {
+  return base::hash_combine(p.type(), p.hint());
+}
+
+
+std::ostream& operator<<(std::ostream& os, SelectParameters const& p) {
+  return os << p.type() << "|" << p.hint();
+}
+
+
+SelectParameters const& SelectParametersOf(const Operator* const op) {
+  DCHECK_EQ(IrOpcode::kSelect, op->opcode());
+  return OpParameter<SelectParameters>(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 149 matching lines @@
 }
 
 
 const Operator* CommonOperatorBuilder::HeapConstant(
     const Unique<HeapObject>& value) {
   return new (zone()) Operator1<Unique<HeapObject>>(
       IrOpcode::kHeapConstant, Operator::kPure, 0, 1, "HeapConstant", value);
 }
 
 
+const Operator* CommonOperatorBuilder::Select(MachineType type,
+                                              BranchHint hint) {
+  return new (zone())
+      Operator1<SelectParameters>(IrOpcode::kSelect, Operator::kPure, 3, 1,
+                                  "Select", SelectParameters(type, hint));
+}
+
+
 const Operator* CommonOperatorBuilder::Phi(MachineType type, int arguments) {
   DCHECK(arguments > 0);  // Disallow empty phis.
   return new (zone()) Operator1<MachineType>(IrOpcode::kPhi, Operator::kPure,
                                              arguments, 1, "Phi", type);
 }
 
 
 const Operator* CommonOperatorBuilder::EffectPhi(int arguments) {
   DCHECK(arguments > 0);  // Disallow empty phis.
   return new (zone()) Operator1<int>(IrOpcode::kEffectPhi, Operator::kPure, 0,
@@ skipping 52 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