Inline ByteArray._setIndexed in the flow graph optimizer.

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 644 matching lines @@
           (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:
+      // 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.
     const Function& target =
         Function::ZoneHandle(call->ic_data()->GetTargetAt(0));
     const AbstractType& value_type =
@@ skipping 47 matching lines @@
                                   Symbols::Value());
     // Newly inserted instructions that can deoptimize or throw an exception
     // must have a deoptimization id that is valid for lookup in the unoptimized
     // code.
     assert_value->deopt_id_ = call->deopt_id();
     InsertBefore(call, assert_value, call->env(), Definition::kValue);
   }
 
   intptr_t array_cid = PrepareIndexedOp(call, class_id, &array, &index);
   // Check if store barrier is needed.
-  bool needs_store_barrier = true;
+  bool needs_store_barrier = !RawObject::IsByteArrayClassId(array_cid);
   if (!value_check.IsNull()) {
     needs_store_barrier = false;
     AddCheckClass(stored_value, value_check, call->deopt_id(), call->env(),
                   call);
   }
 
   Definition* array_op = new StoreIndexedInstr(new Value(array),
                                                new Value(index),
                                                new Value(stored_value),
                                                needs_store_barrier,
                                                array_cid,
                                                call->deopt_id());
   ReplaceCall(call, array_op);
-  return true;
 }
 
 
 
 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:
@@ skipping 596 matching lines @@
     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::kStringBaseCharCodeAt) &&
       (ic_data.NumberOfChecks() == 1) &&
       ((class_ids[0] == kOneByteStringCid) ||
        (class_ids[0] == kTwoByteStringCid))) {
     LoadIndexedInstr* instr = BuildStringCharCodeAt(call, class_ids[0]);
     ReplaceCall(call, instr);
@@ skipping 2813 matching lines @@
 
   if (FLAG_trace_constant_propagation) {
     OS::Print("\n==== After constant propagation ====\n");
     FlowGraphPrinter printer(*graph_);
     printer.PrintBlocks();
   }
 }
 
 
 }  // namespace dart