Optimize TypedData operators [] and []= in the same way as ScalarList.

runtime/vm/intermediate_language.cc

 // Copyright (c) 2013, 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 253 matching lines @@
   // Both names are private. Mangle test_name before comparison.
   const String& test_name_symbol = String::Handle(Symbols::New(test_name));
   return String::Handle(lib.PrivateName(test_name_symbol)).Equals(name);
 }
 
 
 static bool IsRecognizedLibrary(const Library& library) {
   // List of libraries where methods can be recognized.
   return (library.raw() == Library::CoreLibrary())
       || (library.raw() == Library::MathLibrary())
+      || (library.raw() == Library::TypedDataLibrary())
       || (library.raw() == Library::ScalarlistLibrary());
 }
 
 
 MethodRecognizer::Kind MethodRecognizer::RecognizeKind(
     const Function& function) {
   const Class& function_class = Class::Handle(function.Owner());
   const Library& lib = Library::Handle(function_class.library());
   if (!IsRecognizedLibrary(lib)) {
     return kUnknown;
@@ skipping 821 matching lines @@
 Definition* Definition::Canonicalize(FlowGraphOptimizer* optimizer) {
   return this;
 }
 
 
 bool LoadFieldInstr::IsImmutableLengthLoad() const {
   switch (recognized_kind()) {
     case MethodRecognizer::kObjectArrayLength:
     case MethodRecognizer::kImmutableArrayLength:
     case MethodRecognizer::kByteArrayBaseLength:
+    case MethodRecognizer::kTypedDataLength:
     case MethodRecognizer::kStringBaseLength:
       return true;
     default:
       return false;
   }
 }
 
 
 MethodRecognizer::Kind LoadFieldInstr::RecognizedKindFromArrayCid(
     intptr_t cid) {
+  if (RawObject::IsTypedDataClassId(cid) ||
+      RawObject::IsExternalTypedDataClassId(cid)) {
+    return MethodRecognizer::kTypedDataLength;
+  }
   switch (cid) {
     case kArrayCid:
       return MethodRecognizer::kObjectArrayLength;
     case kImmutableArrayCid:
       return MethodRecognizer::kImmutableArrayLength;
     case kGrowableObjectArrayCid:
       return MethodRecognizer::kGrowableArrayLength;
     case kInt8ArrayCid:
     case kUint8ArrayCid:
     case kUint8ClampedArrayCid:
@@ skipping 782 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)) {
+      (recognized_kind() == MethodRecognizer::kByteArrayBaseLength ||
+       recognized_kind() == MethodRecognizer::kTypedDataLength)) {
     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();
 }
 
 
 
 void LoadIndexedInstr::InferRange() {
   switch (class_id()) {
     case kInt8ArrayCid:
+    case kTypedDataInt8ArrayCid:
       range_ = new Range(RangeBoundary::FromConstant(-128),
                          RangeBoundary::FromConstant(127));
       break;
     case kUint8ArrayCid:
     case kUint8ClampedArrayCid:
     case kExternalUint8ArrayCid:
     case kExternalUint8ClampedArrayCid:
+    case kTypedDataUint8ArrayCid:
+    case kTypedDataUint8ClampedArrayCid:
+    case kExternalTypedDataUint8ArrayCid:
+    case kExternalTypedDataUint8ClampedArrayCid:
       range_ = new Range(RangeBoundary::FromConstant(0),
                          RangeBoundary::FromConstant(255));
       break;
     case kInt16ArrayCid:
+    case kTypedDataInt16ArrayCid:
       range_ = new Range(RangeBoundary::FromConstant(-32768),
                          RangeBoundary::FromConstant(32767));
       break;
     case kUint16ArrayCid:
+    case kTypedDataUint16ArrayCid:
       range_ = new Range(RangeBoundary::FromConstant(0),
                          RangeBoundary::FromConstant(65535));
       break;
     case kOneByteStringCid:
       range_ = new Range(RangeBoundary::FromConstant(0),
                          RangeBoundary::FromConstant(0xFF));
       break;
     case kTwoByteStringCid:
       range_ = new Range(RangeBoundary::FromConstant(0),
                          RangeBoundary::FromConstant(0xFFFF));
@@ skipping 213 matching lines @@
   do {
     if (DependOnSameSymbol(max, length)) return max.offset() < length.offset();
   } while (CanonicalizeMaxBoundary(&max) || CanonicalizeMinBoundary(&length));
 
   // Failed to prove that maximum is bounded with array length.
   return false;
 }
 
 
 intptr_t CheckArrayBoundInstr::LengthOffsetFor(intptr_t class_id) {
+  if (RawObject::IsExternalTypedDataClassId(class_id)) {
+    return ExternalTypedData::length_offset();
+  }
+  if (RawObject::IsTypedDataClassId(class_id)) {
+    return TypedData::length_offset();
+  }
   switch (class_id) {
     case kGrowableObjectArrayCid:
       return GrowableObjectArray::length_offset();
     case kOneByteStringCid:
     case kTwoByteStringCid:
       return String::length_offset();
     case kArrayCid:
     case kImmutableArrayCid:
       return Array::length_offset();
     case kInt8ArrayCid:
@@ skipping 100 matching lines @@
     default:
       UNREACHABLE();
   }
   return kPowRuntimeEntry;
 }
 
 
 #undef __
 
 }  // namespace dart