Support scalar lists in array bounds check elimination.

runtime/vm/intermediate_language.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/intermediate_language.h"
 
 #include "vm/bit_vector.h"
 #include "vm/dart_entry.h"
 #include "vm/flow_graph_allocator.h"
 #include "vm/flow_graph_builder.h"
@@ skipping 2417 matching lines @@
 
 void LoadFieldInstr::InferRange() {
   if ((range_ == NULL) &&
       ((recognized_kind() == MethodRecognizer::kObjectArrayLength) ||
        (recognized_kind() == MethodRecognizer::kImmutableArrayLength))) {
     range_ = new Range(RangeBoundary::FromConstant(0),
                        RangeBoundary::FromConstant(Array::kMaxElements));
     return;
   }
   if ((range_ == NULL) &&
+      (recognized_kind() == MethodRecognizer::kByteArrayBaseLength)) {
+    range_ = new Range(RangeBoundary::FromConstant(0), RangeBoundary::MaxSmi());
+    return;
+  }
+  if ((range_ == NULL) &&
       (recognized_kind() == MethodRecognizer::kStringBaseLength)) {
     range_ = new Range(RangeBoundary::FromConstant(0),
                        RangeBoundary::FromConstant(String::kMaxElements));
     return;
   }
   Definition::InferRange();
 }
 
 
 
@@ skipping 195 matching lines @@
 
 
 // Inclusive.
 bool Range::IsWithin(intptr_t min_int, intptr_t max_int) const {
   if (min().LowerBound().value() < min_int) return false;
   if (max().UpperBound().value() > max_int) return false;
   return true;
 }
 
 
+bool CheckArrayBoundInstr::IsFixedLengthArrayType(intptr_t cid) {
+  switch (cid) {
+    case kArrayCid:
+    case kImmutableArrayCid:
+    case kInt8ArrayCid:
+    case kUint8ArrayCid:
+    case kUint8ClampedArrayCid:
+    case kInt16ArrayCid:
+    case kUint16ArrayCid:
+    case kInt32ArrayCid:
+    case kUint32ArrayCid:
+    case kInt64ArrayCid:
+    case kUint64ArrayCid:
+    case kFloat32ArrayCid:
+    case kFloat64ArrayCid:
+      return true;
+    default:
+      return false;
+  }
+}
+
+
 bool CheckArrayBoundInstr::IsRedundant(RangeBoundary length) {
   // Check that array has an immutable length.
-  if ((array_type() != kArrayCid) && (array_type() != kImmutableArrayCid)) {
+  if (!IsFixedLengthArrayType(array_type())) {
     return false;
   }
 
   Range* index_range = index()->definition()->range();
 
   // Range of the index is unknown can't decide if the check is redundant.
   if (index_range == NULL) return false;
 
   // Range of the index is not positive. Check can't be redundant.
   if (Range::ConstantMin(index_range).value() < 0) return false;
@@ skipping 18 matching lines @@
 
   // Failed to prove that maximum is bounded with array length.
   return false;
 }
 
 
 intptr_t CheckArrayBoundInstr::LengthOffsetFor(intptr_t class_id) {
   switch (class_id) {
     case kGrowableObjectArrayCid:
       return GrowableObjectArray::length_offset();
-    case kFloat64ArrayCid:
-      return Float64Array::length_offset();
-    case kFloat32ArrayCid:
-      return Float32Array::length_offset();
     case kOneByteStringCid:
     case kTwoByteStringCid:
       return String::length_offset();
     case kArrayCid:
     case kImmutableArrayCid:
       return Array::length_offset();
+    case kInt8ArrayCid:
     case kUint8ArrayCid:
-      return Uint8Array::length_offset();
     case kUint8ClampedArrayCid:
-      return Uint8ClampedArray::length_offset();
+    case kInt16ArrayCid:
+    case kUint16ArrayCid:
+    case kInt32ArrayCid:
+    case kUint32ArrayCid:
+    case kInt64ArrayCid:
+    case kUint64ArrayCid:
+    case kFloat64ArrayCid:
+    case kFloat32ArrayCid:
     case kExternalUint8ArrayCid:
       return ByteArray::length_offset();
     default:
       UNREACHABLE();
       return -1;
   }
 }
 
 
 #undef __
 
 }  // namespace dart