[turbofan] Eliminate typed array bounds checks if both key and length are constant.

src/compiler/node-matchers.h

 // 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.
 
 #ifndef V8_COMPILER_NODE_MATCHERS_H_
 #define V8_COMPILER_NODE_MATCHERS_H_
 
 #include "src/compiler/node.h"
 #include "src/compiler/operator.h"
 #include "src/unique.h"
@@ skipping 78 matching lines @@
   explicit FloatMatcher(Node* node) : ValueMatcher<T, kOpcode>(node) {}
 
   bool IsNaN() const { return this->HasValue() && std::isnan(this->Value()); }
 };
 
 typedef FloatMatcher<float, IrOpcode::kFloat32Constant> Float32Matcher;
 typedef FloatMatcher<double, IrOpcode::kFloat64Constant> Float64Matcher;
 typedef FloatMatcher<double, IrOpcode::kNumberConstant> NumberMatcher;
 
 
+// A pattern matcher for any numberic constant.
+struct NumericValueMatcher : public NodeMatcher {
+  explicit NumericValueMatcher(Node* const node) : NodeMatcher(node) {
+    switch (opcode()) {
+      case IrOpcode::kInt32Constant:
+        has_value_ = true;
+        value_ = OpParameter<int32_t>(node);
+        break;
+      case IrOpcode::kFloat32Constant:
+        has_value_ = true;
+        value_ = OpParameter<float>(node);
+        break;
+      case IrOpcode::kFloat64Constant:
+      case IrOpcode::kNumberConstant:
+        has_value_ = true;
+        value_ = OpParameter<double>(node);
+        break;
+      default:
+        has_value_ = false;
+        break;
+    }
+  }
+
+  bool HasValue() const { return has_value_; }
+  double Value() const {
+    DCHECK(HasValue());
+    return value_;
+  }
+
+ private:
+  double value_;
+  bool has_value_;
+};
+
+
 // A pattern matcher for heap object constants.
 template <typename T>
 struct HeapObjectMatcher FINAL
     : public ValueMatcher<Unique<T>, IrOpcode::kHeapConstant> {
   explicit HeapObjectMatcher(Node* node)
       : ValueMatcher<Unique<T>, IrOpcode::kHeapConstant>(node) {}
 };
 
 
 // For shorter pattern matching code, this struct matches both the left and
@@ skipping 111 matching lines @@
   int power_;
   int displacement_;
 };
 
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_NODE_MATCHERS_H_