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

runtime/vm/flow_graph_optimizer.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/flow_graph_optimizer.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cha.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
@@ skipping 698 matching lines @@
         value_check = call->ic_data()->AsUnaryClassChecksForArgNr(2);
       }
       break;
     case kInt8ArrayCid:
     case kUint8ArrayCid:
     case kUint8ClampedArrayCid:
     case kExternalUint8ArrayCid:
     case kExternalUint8ClampedArrayCid:
     case kInt16ArrayCid:
     case kUint16ArrayCid:
+    case kTypedDataInt8ArrayCid:
+    case kTypedDataUint8ArrayCid:
+    case kTypedDataUint8ClampedArrayCid:
+    case kExternalTypedDataUint8ArrayCid:
+    case kExternalTypedDataUint8ClampedArrayCid:
+    case kTypedDataInt16ArrayCid:
+    case kTypedDataUint16ArrayCid:
       // Check that value is always smi.
       value_check = call->ic_data()->AsUnaryClassChecksForArgNr(2);
       if ((value_check.NumberOfChecks() != 1) ||
           (value_check.GetReceiverClassIdAt(0) != kSmiCid)) {
         return false;
       }
       break;
     case kInt32ArrayCid:
-    case kUint32ArrayCid: {
+    case kUint32ArrayCid:
+    case kTypedDataInt32ArrayCid:
+    case kTypedDataUint32ArrayCid: {
       if (!CanUnboxInt32()) return false;
       // Check that value is always smi or mint, if the platform has unboxed
       // mints (ia32 with at least SSE 4.1).
       value_check = call->ic_data()->AsUnaryClassChecksForArgNr(2);
       for (intptr_t i = 0; i < value_check.NumberOfChecks(); i++) {
         intptr_t cid = value_check.GetReceiverClassIdAt(i);
         if (FlowGraphCompiler::SupportsUnboxedMints()) {
           if ((cid != kSmiCid) && (cid != kMintCid)) {
             return false;
           }
         } else if (cid != kSmiCid) {
           return false;
         }
       }
       break;
     }
     case kFloat32ArrayCid:
-    case kFloat64ArrayCid: {
+    case kFloat64ArrayCid:
+    case kTypedDataFloat32ArrayCid:
+    case kTypedDataFloat64ArrayCid: {
       // Check that value is always double.
       value_check = call->ic_data()->AsUnaryClassChecksForArgNr(2);
       if ((value_check.NumberOfChecks() != 1) ||
           (value_check.GetReceiverClassIdAt(0) != kDoubleCid)) {
         return false;
       }
       break;
     }
     default:
       // TODO(fschneider): Add support for other array types.
@@ skipping 90 matching lines @@
       }
       case kInt8ArrayCid:
       case kUint8ArrayCid:
       case kUint8ClampedArrayCid:
       case kExternalUint8ArrayCid:
       case kExternalUint8ClampedArrayCid:
       case kInt16ArrayCid:
       case kUint16ArrayCid:
       case kInt32ArrayCid:
       case kUint32ArrayCid:
+      case kTypedDataInt8ArrayCid:
+      case kTypedDataUint8ArrayCid:
+      case kTypedDataUint8ClampedArrayCid:
+      case kExternalTypedDataUint8ArrayCid:
+      case kExternalTypedDataUint8ClampedArrayCid:
+      case kTypedDataInt16ArrayCid:
+      case kTypedDataUint16ArrayCid:
+      case kTypedDataInt32ArrayCid:
+      case kTypedDataUint32ArrayCid:
         ASSERT(value_type.IsIntType());
         // Fall through.
       case kFloat32ArrayCid:
-      case kFloat64ArrayCid: {
+      case kFloat64ArrayCid:
+      case kTypedDataFloat32ArrayCid:
+      case kTypedDataFloat64ArrayCid: {
         type_args = instantiator = flow_graph_->constant_null();
-        ASSERT((class_id != kFloat32ArrayCid && class_id != kFloat64ArrayCid) ||
+        ASSERT((class_id != kFloat32ArrayCid &&
+                class_id != kFloat64ArrayCid &&
+                class_id != kTypedDataFloat32ArrayCid &&
+                class_id != kTypedDataFloat64ArrayCid) ||
                value_type.IsDoubleType());
         ASSERT(value_type.IsInstantiated());
         break;
       }
       default:
         // TODO(fschneider): Add support for other array types.
         UNREACHABLE();
     }
     AssertAssignableInstr* assert_value =
         new AssertAssignableInstr(call->token_pos(),
@@ skipping 46 matching lines @@
     case kGrowableObjectArrayCid:
     case kFloat32ArrayCid:
     case kFloat64ArrayCid:
     case kInt8ArrayCid:
     case kUint8ArrayCid:
     case kUint8ClampedArrayCid:
     case kExternalUint8ArrayCid:
     case kExternalUint8ClampedArrayCid:
     case kInt16ArrayCid:
     case kUint16ArrayCid:
+    case kTypedDataFloat32ArrayCid:
+    case kTypedDataFloat64ArrayCid:
+    case kTypedDataInt8ArrayCid:
+    case kTypedDataUint8ArrayCid:
+    case kTypedDataUint8ClampedArrayCid:
+    case kExternalTypedDataUint8ArrayCid:
+    case kExternalTypedDataUint8ClampedArrayCid:
+    case kTypedDataInt16ArrayCid:
+    case kTypedDataUint16ArrayCid:
       break;
     case kInt32ArrayCid:
-    case kUint32ArrayCid: {
+    case kUint32ArrayCid:
+    case kTypedDataInt32ArrayCid:
+    case kTypedDataUint32ArrayCid: {
         if (!CanUnboxInt32()) return false;
 
         // Set deopt_id if we can optimistically assume that the result is Smi.
         // Assume mixed Mint/Smi if this instruction caused deoptimization once.
         ASSERT(call->HasICData());
         const ICData& ic_data = *call->ic_data();
         deopt_id = (ic_data.deopt_reason() == kDeoptUnknown) ?
             call->deopt_id() : Isolate::kNoDeoptId;
       }
       break;
@@ skipping 379 matching lines @@
 }
 
 
 static intptr_t OffsetForLengthGetter(MethodRecognizer::Kind kind) {
   switch (kind) {
     case MethodRecognizer::kObjectArrayLength:
     case MethodRecognizer::kImmutableArrayLength:
       return Array::length_offset();
     case MethodRecognizer::kByteArrayBaseLength:
       return ByteArray::length_offset();
+    case MethodRecognizer::kTypedDataLength:
+      // .length is defined in _TypedList which is the base class for internal
+      // and external typed data.
+      ASSERT(TypedData::length_offset() == ExternalTypedData::length_offset());
+      return TypedData::length_offset();
     case MethodRecognizer::kGrowableArrayLength:
       return GrowableObjectArray::length_offset();
     default:
       UNREACHABLE();
       return 0;
   }
 }
 
 
 // Only unique implicit instance getters can be currently handled.
@@ skipping 18 matching lines @@
 
   // Not an implicit getter.
   MethodRecognizer::Kind recognized_kind =
       MethodRecognizer::RecognizeKind(target);
 
   // VM objects length getter.
   switch (recognized_kind) {
     case MethodRecognizer::kObjectArrayLength:
     case MethodRecognizer::kImmutableArrayLength:
     case MethodRecognizer::kByteArrayBaseLength:
+    case MethodRecognizer::kTypedDataLength:
     case MethodRecognizer::kGrowableArrayLength: {
       if (!ic_data.HasOneTarget()) {
         // TODO(srdjan): Implement for mutiple targets.
         return false;
       }
       const bool is_immutable =
           (recognized_kind == MethodRecognizer::kObjectArrayLength) ||
           (recognized_kind == MethodRecognizer::kImmutableArrayLength) ||
-          (recognized_kind == MethodRecognizer::kByteArrayBaseLength);
+          (recognized_kind == MethodRecognizer::kByteArrayBaseLength) ||
+          (recognized_kind == MethodRecognizer::kTypedDataLength);
       InlineArrayLengthGetter(call,
                               OffsetForLengthGetter(recognized_kind),
                               is_immutable,
                               recognized_kind);
       return true;
     }
     case MethodRecognizer::kGrowableArrayCapacity:
       InlineGrowableArrayCapacityGetter(call);
       return true;
     case MethodRecognizer::kStringBaseLength:
@@ skipping 506 matching lines @@
   const ICData& unary_checks =
       ICData::ZoneHandle(instr->ic_data()->AsUnaryClassChecks());
 
   if ((unary_checks.NumberOfChecks() > FLAG_max_polymorphic_checks) &&
       InstanceCallNeedsClassCheck(instr)) {
     // Too many checks, it will be megamorphic which needs unary checks.
     instr->set_ic_data(&unary_checks);
     return;
   }
 
-  if ((op_kind == Token::kASSIGN_INDEX) &&
-      TryReplaceWithStoreIndexed(instr)) {
+  if ((op_kind == Token::kASSIGN_INDEX) && TryReplaceWithStoreIndexed(instr)) {
     return;
   }
   if ((op_kind == Token::kINDEX) && TryReplaceWithLoadIndexed(instr)) {
     return;
   }
   if (Token::IsBinaryOperator(op_kind) &&
       TryReplaceWithBinaryOp(instr, op_kind)) {
     return;
   }
   if (Token::IsPrefixOperator(op_kind) &&
@@ skipping 2751 matching lines @@
   if (changed) {
     // We may have changed the block order and the dominator tree.
     flow_graph->DiscoverBlocks();
     GrowableArray<BitVector*> dominance_frontier;
     flow_graph->ComputeDominators(&dominance_frontier);
   }
 }
 
 
 }  // namespace dart