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

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 357 matching lines @@
 
 void FlowGraphOptimizer::InsertConversionsFor(Definition* def) {
   const Representation from_rep = def->representation();
 
   for (Value::Iterator it(def->input_use_list());
        !it.Done();
        it.Advance()) {
     Value* use = it.Current();
     const Representation to_rep =
         use->instruction()->RequiredInputRepresentation(use->use_index());
-    if (from_rep == to_rep) {
+    if (from_rep == to_rep || to_rep == kNoRepresentation) {
       continue;
     }
 
     Instruction* insert_before;
     Instruction* deopt_target;
     PhiInstr* phi = use->instruction()->AsPhi();
     if (phi != NULL) {
       ASSERT(phi->is_alive());
       // For phis conversions have to be inserted in the predecessor.
       insert_before =
@@ skipping 292 matching lines @@
     // Insert data elements load.
     LoadFieldInstr* elements =
         new LoadFieldInstr(new Value(*array),
                            GrowableObjectArray::data_offset(),
                            Type::ZoneHandle(Type::DynamicType()));
     elements->set_result_cid(kArrayCid);
     InsertBefore(call, elements, NULL, Definition::kValue);
     *array = elements;
     return kArrayCid;
   }
+  if (RawObject::IsExternalTypedDataClassId(class_id)) {
+    LoadUntaggedInstr* elements =
+        new LoadUntaggedInstr(new Value(*array),
+                              ExternalTypedData::data_offset());
+    InsertBefore(call, elements, NULL, Definition::kValue);
+    *array = elements;
+  }
   return class_id;
 }
 
 
 static bool CanUnboxInt32() {
   // Int32/Uint32 can be unboxed if it fits into a smi or the platform
   // supports unboxed mints.
   return (kSmiBits >= 32) || FlowGraphCompiler::SupportsUnboxedMints();
 }
 
 
 bool FlowGraphOptimizer::TryReplaceWithStoreIndexed(InstanceCallInstr* call) {
   const intptr_t class_id = ReceiverClassId(call);
   ICData& value_check = ICData::ZoneHandle();
   switch (class_id) {
     case kArrayCid:
     case kGrowableObjectArrayCid:
       if (ArgIsAlwaysSmi(*call->ic_data(), 2)) {
         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 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 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.
       return false;
   }
 
   BuildStoreIndexed(call, value_check, class_id);
   return true;
 }
 
 
-bool FlowGraphOptimizer::TryInlineByteArraySetIndexed(InstanceCallInstr* call) {
-  const intptr_t class_id = ReceiverClassId(call);
-  ICData& value_check = ICData::ZoneHandle();
-  switch (class_id) {
-    case kInt8ArrayCid:
-    case kUint8ArrayCid:
-    case kUint8ClampedArrayCid:
-    case kExternalUint8ArrayCid:
-    case kExternalUint8ClampedArrayCid:
-    case kInt16ArrayCid:
-    case kUint16ArrayCid: {
-      // Check that value is always smi.
-      value_check = ICData::New(Function::Handle(),
-                                String::Handle(),
-                                Isolate::kNoDeoptId,
-                                1);
-      value_check.AddReceiverCheck(kSmiCid, Function::Handle());
-      break;
-    }
-    case kInt32ArrayCid:
-    case kUint32ArrayCid:
-      if (!CanUnboxInt32()) return false;
-
-      // We don't have ICData for the value stored, so we optimistically assume
-      // smis first. If we ever deoptimized here, we require to unbox the value
-      // before storing to handle the mint case, too.
-      if (call->ic_data()->deopt_reason() == kDeoptUnknown) {
-        value_check = ICData::New(Function::Handle(),
-                                  String::Handle(),
-                                  Isolate::kNoDeoptId,
-                                  1);
-        value_check.AddReceiverCheck(kSmiCid, Function::Handle());
-      }
-      break;
-    case kFloat32ArrayCid:
-    case kFloat64ArrayCid: {
-      // Check that value is always double.
-      value_check = ICData::New(Function::Handle(),
-                                String::Handle(),
-                                Isolate::kNoDeoptId,
-                                1);
-      value_check.AddReceiverCheck(kDoubleCid, Function::Handle());
-      break;
-    }
-    default:
-      return false;
-  }
-  BuildStoreIndexed(call, value_check, class_id);
-  return true;
-}
-
-
 void FlowGraphOptimizer::BuildStoreIndexed(InstanceCallInstr* call,
                                            const ICData& value_check,
                                            intptr_t class_id) {
   Definition* array = call->ArgumentAt(0);
   Definition* index = call->ArgumentAt(1);
   Definition* stored_value = call->ArgumentAt(2);
   if (FLAG_enable_type_checks) {
     // Only type check for the value. A type check for the index is not
     // needed here because we insert a deoptimizing smi-check for the case
     // the index is not a smi.
@@ skipping 11 matching lines @@
             instantiator_class.type_arguments_field_offset();
         LoadFieldInstr* load_type_args =
             new LoadFieldInstr(new Value(array),
                                type_arguments_field_offset,
                                Type::ZoneHandle());  // No type.
         InsertBefore(call, load_type_args, NULL, Definition::kValue);
         instantiator = array;
         type_args = load_type_args;
         break;
       }
-      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 kTypedDataFloat32ArrayCid:
       case kTypedDataFloat64ArrayCid: {
         type_args = instantiator = flow_graph_->constant_null();
         ASSERT((class_id != kFloat32ArrayCid &&
                 class_id != kFloat64ArrayCid &&
                 class_id != kTypedDataFloat32ArrayCid &&
                 class_id != kTypedDataFloat64ArrayCid) ||
                value_type.IsDoubleType());
         ASSERT(value_type.IsInstantiated());
         break;
@@ skipping 44 matching lines @@
 
 
 bool FlowGraphOptimizer::TryReplaceWithLoadIndexed(InstanceCallInstr* call) {
   const intptr_t class_id = ReceiverClassId(call);
   // Set deopt_id to a valid id if the LoadIndexedInstr can cause deopt.
   intptr_t deopt_id = Isolate::kNoDeoptId;
   switch (class_id) {
     case kArrayCid:
     case kImmutableArrayCid:
     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 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;
@@ skipping 379 matching lines @@
                              new Value(zero));
   ReplaceCall(call, compare);
 }
 
 
 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;
@@ skipping 22 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::kTypedDataLength);
       InlineArrayLengthGetter(call,
                               OffsetForLengthGetter(recognized_kind),
                               is_immutable,
                               recognized_kind);
       return true;
     }
     case MethodRecognizer::kGrowableArrayCapacity:
       InlineGrowableArrayCapacityGetter(call);
       return true;
@@ skipping 68 matching lines @@
     args->Add(new Value(call->ArgumentAt(i)));
   }
   InvokeMathCFunctionInstr* invoke =
       new InvokeMathCFunctionInstr(args, call, recognized_kind);
   ReplaceCall(call, invoke);
 }
 
 
 static bool IsSupportedByteArrayViewCid(intptr_t cid) {
   switch (cid) {
-    case kInt8ArrayCid:
-    case kUint8ArrayCid:
-    case kUint8ClampedArrayCid:
-    case kInt16ArrayCid:
-    case kUint16ArrayCid:
-    case kInt32ArrayCid:
-    case kUint32ArrayCid:
-    case kFloat32ArrayCid:
-    case kFloat64ArrayCid:
+    case kTypedDataInt8ArrayCid:
+    case kTypedDataUint8ArrayCid:
+    case kExternalTypedDataUint8ArrayCid:
+    case kTypedDataUint8ClampedArrayCid:
+    case kExternalTypedDataUint8ClampedArrayCid:
+    case kTypedDataInt16ArrayCid:
+    case kTypedDataUint16ArrayCid:
+    case kTypedDataInt32ArrayCid:
+    case kTypedDataUint32ArrayCid:
+    case kTypedDataFloat32ArrayCid:
+    case kTypedDataFloat64ArrayCid:
       return true;
     default:
       return false;
   }
 }
 
 
 // Inline only simple, frequently called core library methods.
 bool FlowGraphOptimizer::TryInlineInstanceMethod(InstanceCallInstr* call) {
   ASSERT(call->HasICData());
   const ICData& ic_data = *call->ic_data();
   if ((ic_data.NumberOfChecks() == 0) || !ic_data.HasOneTarget()) {
     // No type feedback collected or multiple targets found.
     return false;
   }
 
   Function& target = Function::Handle();
   GrowableArray<intptr_t> class_ids;
   ic_data.GetCheckAt(0, &class_ids, &target);
   MethodRecognizer::Kind recognized_kind =
       MethodRecognizer::RecognizeKind(target);
 
-  // Byte array access.
-  switch (recognized_kind) {
-    case MethodRecognizer::kFloat32ArrayGetIndexed:
-    case MethodRecognizer::kFloat64ArrayGetIndexed:
-    case MethodRecognizer::kInt8ArrayGetIndexed:
-    case MethodRecognizer::kUint8ArrayGetIndexed:
-    case MethodRecognizer::kUint8ClampedArrayGetIndexed:
-    case MethodRecognizer::kExternalUint8ArrayGetIndexed:
-    case MethodRecognizer::kExternalUint8ClampedArrayGetIndexed:
-    case MethodRecognizer::kInt16ArrayGetIndexed:
-    case MethodRecognizer::kUint16ArrayGetIndexed:
-    case MethodRecognizer::kInt32ArrayGetIndexed:
-    case MethodRecognizer::kUint32ArrayGetIndexed:
-      return TryReplaceWithLoadIndexed(call);
-
-    case MethodRecognizer::kFloat32ArraySetIndexed:
-    case MethodRecognizer::kFloat64ArraySetIndexed:
-    case MethodRecognizer::kInt8ArraySetIndexed:
-    case MethodRecognizer::kUint8ArraySetIndexed:
-    case MethodRecognizer::kUint8ClampedArraySetIndexed:
-    case MethodRecognizer::kExternalUint8ArraySetIndexed:
-    case MethodRecognizer::kExternalUint8ClampedArraySetIndexed:
-    case MethodRecognizer::kInt16ArraySetIndexed:
-    case MethodRecognizer::kUint16ArraySetIndexed:
-    case MethodRecognizer::kInt32ArraySetIndexed:
-    case MethodRecognizer::kUint32ArraySetIndexed:
-      return TryInlineByteArraySetIndexed(call);
-
-    default:
-      break;
-  }
-
   if ((recognized_kind == MethodRecognizer::kStringBaseCodeUnitAt) &&
       (ic_data.NumberOfChecks() == 1) &&
       ((class_ids[0] == kOneByteStringCid) ||
        (class_ids[0] == kTwoByteStringCid))) {
     LoadIndexedInstr* instr = BuildStringCodeUnitAt(call, class_ids[0]);
     ReplaceCall(call, instr);
     return true;
   }
   if ((recognized_kind == MethodRecognizer::kStringBaseCharAt) &&
       (ic_data.NumberOfChecks() == 1) &&
@@ skipping 68 matching lines @@
     if ((recognized_kind == MethodRecognizer::kByteArrayBaseGetInt32) ||
         (recognized_kind == MethodRecognizer::kByteArrayBaseGetUint32) ||
         (recognized_kind == MethodRecognizer::kByteArrayBaseSetInt32) ||
         (recognized_kind == MethodRecognizer::kByteArrayBaseSetUint32)) {
       if (!CanUnboxInt32()) return false;
     }
 
     switch (recognized_kind) {
       // ByteArray getters.
       case MethodRecognizer::kByteArrayBaseGetInt8:
-        return BuildByteArrayViewLoad(call, class_ids[0], kInt8ArrayCid);
+        return BuildByteArrayViewLoad(
+            call, class_ids[0], kTypedDataInt8ArrayCid);
       case MethodRecognizer::kByteArrayBaseGetUint8:
-        return BuildByteArrayViewLoad(call, class_ids[0], kUint8ArrayCid);
+        return BuildByteArrayViewLoad(
+            call, class_ids[0], kTypedDataUint8ArrayCid);
       case MethodRecognizer::kByteArrayBaseGetInt16:
-        return BuildByteArrayViewLoad(call, class_ids[0], kInt16ArrayCid);
+        return BuildByteArrayViewLoad(
+            call, class_ids[0], kTypedDataInt16ArrayCid);
       case MethodRecognizer::kByteArrayBaseGetUint16:
-        return BuildByteArrayViewLoad(call, class_ids[0], kUint16ArrayCid);
+        return BuildByteArrayViewLoad(
+            call, class_ids[0], kTypedDataUint16ArrayCid);
       case MethodRecognizer::kByteArrayBaseGetInt32:
-        return BuildByteArrayViewLoad(call, class_ids[0], kInt32ArrayCid);
+        return BuildByteArrayViewLoad(
+            call, class_ids[0], kTypedDataInt32ArrayCid);
       case MethodRecognizer::kByteArrayBaseGetUint32:
-        return BuildByteArrayViewLoad(call, class_ids[0], kUint32ArrayCid);
+        return BuildByteArrayViewLoad(
+            call, class_ids[0], kTypedDataUint32ArrayCid);
       case MethodRecognizer::kByteArrayBaseGetFloat32:
-        return BuildByteArrayViewLoad(call, class_ids[0], kFloat32ArrayCid);
+        return BuildByteArrayViewLoad(
+            call, class_ids[0], kTypedDataFloat32ArrayCid);
       case MethodRecognizer::kByteArrayBaseGetFloat64:
-        return BuildByteArrayViewLoad(call, class_ids[0], kFloat64ArrayCid);
+        return BuildByteArrayViewLoad(
+            call, class_ids[0], kTypedDataFloat64ArrayCid);
 
       // ByteArray setters.
       case MethodRecognizer::kByteArrayBaseSetInt8:
-        return BuildByteArrayViewStore(call, class_ids[0], kInt8ArrayCid);
+        return BuildByteArrayViewStore(
+            call, class_ids[0], kTypedDataInt8ArrayCid);
       case MethodRecognizer::kByteArrayBaseSetUint8:
-        return BuildByteArrayViewStore(call, class_ids[0], kUint8ArrayCid);
+        return BuildByteArrayViewStore(
+            call, class_ids[0], kTypedDataUint8ArrayCid);
       case MethodRecognizer::kByteArrayBaseSetInt16:
-        return BuildByteArrayViewStore(call, class_ids[0], kInt16ArrayCid);
+        return BuildByteArrayViewStore(
+            call, class_ids[0], kTypedDataInt16ArrayCid);
       case MethodRecognizer::kByteArrayBaseSetUint16:
-        return BuildByteArrayViewStore(call, class_ids[0], kUint16ArrayCid);
+        return BuildByteArrayViewStore(
+            call, class_ids[0], kTypedDataUint16ArrayCid);
       case MethodRecognizer::kByteArrayBaseSetInt32:
-        return BuildByteArrayViewStore(call, class_ids[0], kInt32ArrayCid);
+        return BuildByteArrayViewStore(
+            call, class_ids[0], kTypedDataInt32ArrayCid);
       case MethodRecognizer::kByteArrayBaseSetUint32:
-        return BuildByteArrayViewStore(call, class_ids[0], kUint32ArrayCid);
+        return BuildByteArrayViewStore(
+            call, class_ids[0], kTypedDataUint32ArrayCid);
       case MethodRecognizer::kByteArrayBaseSetFloat32:
-        return BuildByteArrayViewStore(call, class_ids[0], kFloat32ArrayCid);
+        return BuildByteArrayViewStore(
+            call, class_ids[0], kTypedDataFloat32ArrayCid);
       case MethodRecognizer::kByteArrayBaseSetFloat64:
-        return BuildByteArrayViewStore(call, class_ids[0], kFloat64ArrayCid);
+        return BuildByteArrayViewStore(
+            call, class_ids[0], kTypedDataFloat64ArrayCid);
       default:
         // Unsupported method.
         return false;
     }
   }
   return false;
 }
 
 
 bool FlowGraphOptimizer::BuildByteArrayViewLoad(
     InstanceCallInstr* call,
     intptr_t receiver_cid,
     intptr_t view_cid) {
-  PrepareByteArrayViewOp(call, receiver_cid, view_cid);
-
   Definition* array = call->ArgumentAt(0);
-  Definition* byte_index = call->ArgumentAt(1);
+  PrepareByteArrayViewOp(call, receiver_cid, view_cid, &array);
 
   // Optimistically build a smi-checked load for Int32 and Uint32
   // loads on ia32 like we do for normal array loads, and only revert to
   // mint case after deoptimizing here.
   intptr_t deopt_id = Isolate::kNoDeoptId;
   if ((view_cid == kInt32ArrayCid || view_cid == kUint32ArrayCid) &&
       call->ic_data()->deopt_reason() == kDeoptUnknown) {
     deopt_id = call->deopt_id();
   }
+  Definition* byte_index = call->ArgumentAt(1);
   LoadIndexedInstr* array_op = new LoadIndexedInstr(new Value(array),
                                                     new Value(byte_index),
                                                     1,  // Index scale.
                                                     view_cid,
                                                     deopt_id);
   ReplaceCall(call, array_op);
   return true;
 }
 
 
 bool FlowGraphOptimizer::BuildByteArrayViewStore(
     InstanceCallInstr* call,
     intptr_t receiver_cid,
     intptr_t view_cid) {
-  PrepareByteArrayViewOp(call, receiver_cid, view_cid);
+  Definition* array = call->ArgumentAt(0);
+  PrepareByteArrayViewOp(call, receiver_cid, view_cid, &array);
   ICData& value_check = ICData::ZoneHandle();
   switch (view_cid) {
-    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 = ICData::New(Function::Handle(),
                                 String::Handle(),
                                 Isolate::kNoDeoptId,
                                 1);
       value_check.AddReceiverCheck(kSmiCid, Function::Handle());
       break;
     }
-    case kInt32ArrayCid:
-    case kUint32ArrayCid:
+    case kTypedDataInt32ArrayCid:
+    case kTypedDataUint32ArrayCid:
       // We don't have ICData for the value stored, so we optimistically assume
       // smis first. If we ever deoptimized here, we require to unbox the value
       // before storing to handle the mint case, too.
       if (call->ic_data()->deopt_reason() == kDeoptUnknown) {
         value_check = ICData::New(Function::Handle(),
                                   String::Handle(),
                                   Isolate::kNoDeoptId,
                                   1);
         value_check.AddReceiverCheck(kSmiCid, Function::Handle());
       }
       break;
-    case kFloat32ArrayCid:
-    case kFloat64ArrayCid: {
+    case kTypedDataFloat32ArrayCid:
+    case kTypedDataFloat64ArrayCid: {
       // Check that value is always double.
       value_check = ICData::New(Function::Handle(),
                                 String::Handle(),
                                 Isolate::kNoDeoptId,
                                 1);
       value_check.AddReceiverCheck(kDoubleCid, Function::Handle());
       break;
     }
     default:
       // Array cids are already checked in the caller.
       UNREACHABLE();
       return NULL;
   }
 
-  Definition* array = call->ArgumentAt(0);
   Definition* index = call->ArgumentAt(1);
   Definition* stored_value = call->ArgumentAt(2);
   if (!value_check.IsNull()) {
     AddCheckClass(stored_value, value_check, call->deopt_id(), call->env(),
                   call);
   }
   StoreBarrierType needs_store_barrier = kNoStoreBarrier;
-
-
-  // result = index + bytesPerElement.
-  intptr_t element_size = FlowGraphCompiler::ElementSizeFor(receiver_cid);
-  ConstantInstr* bytes_per_element =
-      new ConstantInstr(Smi::Handle(Smi::New(element_size)));
-  InsertBefore(call, bytes_per_element, NULL, Definition::kValue);
-  BinarySmiOpInstr* result =
-      new BinarySmiOpInstr(Token::kADD,
-                           call,
-                           new Value(index),
-                           new Value(bytes_per_element));
-  InsertBefore(call, result, call->env(), Definition::kValue);
-
   StoreIndexedInstr* array_op = new StoreIndexedInstr(new Value(array),
                                                       new Value(index),
                                                       new Value(stored_value),
                                                       needs_store_barrier,
                                                       1,  // Index scale
                                                       view_cid,
                                                       call->deopt_id());
-  call->ReplaceUsesWith(result);  // Fix uses of the call's return value.
   ReplaceCall(call, array_op);
-  array_op->ClearSSATempIndex();  // Store has no uses.
   return true;
 }
 
 
 void FlowGraphOptimizer::PrepareByteArrayViewOp(
     InstanceCallInstr* call,
     intptr_t receiver_cid,
-    intptr_t view_cid) {
-  Definition* array = call->ArgumentAt(0);
+    intptr_t view_cid,
+    Definition** array) {
   Definition* byte_index = call->ArgumentAt(1);
 
   AddReceiverCheck(call);
   const bool is_immutable = true;
   LoadFieldInstr* length = new LoadFieldInstr(
-      new Value(array),
+      new Value(*array),
       CheckArrayBoundInstr::LengthOffsetFor(receiver_cid),
       Type::ZoneHandle(Type::SmiType()),
       is_immutable);
   length->set_result_cid(kSmiCid);
   length->set_recognized_kind(
       LoadFieldInstr::RecognizedKindFromArrayCid(receiver_cid));
   InsertBefore(call, length, NULL, Definition::kValue);
 
   // len_in_bytes = length * kBytesPerElement(receiver)
   intptr_t element_size = FlowGraphCompiler::ElementSizeFor(receiver_cid);
   ConstantInstr* bytes_per_element =
       new ConstantInstr(Smi::Handle(Smi::New(element_size)));
   InsertBefore(call, bytes_per_element, NULL, Definition::kValue);
   BinarySmiOpInstr* len_in_bytes =
       new BinarySmiOpInstr(Token::kMUL,
                            call,
                            new Value(length),
                            new Value(bytes_per_element));
   InsertBefore(call, len_in_bytes, call->env(), Definition::kValue);
 
     // Check byte_index < len_in_bytes.
   InsertBefore(call,
                new CheckArrayBoundInstr(new Value(len_in_bytes),
                                         new Value(byte_index),
                                         receiver_cid,
                                         call),
                call->env(),
                Definition::kEffect);
+
+  // Insert load of elements for external typed arrays.
+  if (RawObject::IsExternalTypedDataClassId(receiver_cid)) {
+    LoadUntaggedInstr* elements =
+        new LoadUntaggedInstr(new Value(*array),
+                              ExternalTypedData::data_offset());
+    InsertBefore(call, elements, NULL, Definition::kValue);
+    *array = elements;
+  }
 }
 
 
 // Returns a Boolean constant if all classes in ic_data yield the same type-test
 // result and the type tests do not depend on type arguments. Otherwise return
 // Bool::null().
 RawBool* FlowGraphOptimizer::InstanceOfAsBool(const ICData& ic_data,
                                               const AbstractType& type) const {
   ASSERT(ic_data.num_args_tested() == 1);  // Unary checks only.
   if (!type.IsInstantiated() || type.IsMalformed()) return Bool::null();
@@ skipping 2220 matching lines @@
   SetValue(instr, non_constant_);
 }
 
 
 void ConstantPropagator::VisitAllocateObjectWithBoundsCheck(
     AllocateObjectWithBoundsCheckInstr* instr) {
   SetValue(instr, non_constant_);
 }
 
 
+void ConstantPropagator::VisitLoadUntagged(LoadUntaggedInstr* instr) {
+  SetValue(instr, non_constant_);
+}
+
+
 void ConstantPropagator::VisitLoadField(LoadFieldInstr* instr) {
   if ((instr->recognized_kind() == MethodRecognizer::kObjectArrayLength) &&
       (instr->value()->definition()->IsCreateArray())) {
     const intptr_t length =
         instr->value()->definition()->AsCreateArray()->num_elements();
     const Object& result = Smi::ZoneHandle(Smi::New(length));
     SetValue(instr, result);
     return;
   }
 
@@ skipping 603 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