Replace scalarlist optimizations and split external array loads into two IL instructions.

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());
+      || (library.raw() == Library::TypedDataLibrary());
 }
 
 
 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 819 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:
-    case kExternalUint8ArrayCid:
-    case kExternalUint8ClampedArrayCid:
-    case kInt16ArrayCid:
-    case kUint16ArrayCid:
-    case kInt32ArrayCid:
-    case kUint32ArrayCid:
-    case kInt64ArrayCid:
-    case kUint64ArrayCid:
-    case kFloat32ArrayCid:
-    case kFloat64ArrayCid:
-      return MethodRecognizer::kByteArrayBaseLength;
     default:
       UNREACHABLE();
       return MethodRecognizer::kUnknown;
   }
 }
 
 
 bool LoadFieldInstr::IsFixedLengthArrayCid(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:
+    case kTypedDataInt8ArrayCid:
+    case kTypedDataUint8ArrayCid:
+    case kTypedDataUint8ClampedArrayCid:
+    case kTypedDataInt16ArrayCid:
+    case kTypedDataUint16ArrayCid:
+    case kTypedDataInt32ArrayCid:
+    case kTypedDataUint32ArrayCid:
+    case kTypedDataInt64ArrayCid:
+    case kTypedDataUint64ArrayCid:
+    case kTypedDataFloat32ArrayCid:
+    case kTypedDataFloat64ArrayCid:
       return true;
     default:
       return false;
   }
 }
 
 
 Definition* ConstantInstr::Canonicalize(FlowGraphOptimizer* optimizer) {
   return HasUses() ? this : NULL;
 }
@@ skipping 739 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::kTypedDataLength)) {
+      (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();
@@ skipping 378 matching lines @@
     default:
       UNREACHABLE();
   }
   return kPowRuntimeEntry;
 }
 
 
 #undef __
 
 }  // namespace dart