Optimize stores to Uint8List.

runtime/vm/flow_graph_optimizer.cc

 // Copyright (c) 2012, 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 530 matching lines @@
   return class_id;
 }
 
 
 bool FlowGraphOptimizer::TryReplaceWithStoreIndexed(InstanceCallInstr* call) {
   const intptr_t class_id = ReceiverClassId(call);
   ICData& value_check = ICData::ZoneHandle();
   switch (class_id) {
     case kArrayCid:
     case kGrowableObjectArrayCid:
-      // Acceptable store index classes.
+      if (ArgIsAlwaysSmi(*call->ic_data(), 2)) {
+        value_check = call->ic_data()->AsUnaryClassChecksForArgNr(2);
+      }
       break;
+    case kUint8ArrayCid:
+      // 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 kFloat32ArrayCid:
     case kFloat64ArrayCid: {
       // 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;
     }
@@ skipping 22 matching lines @@
             instantiator_class.type_arguments_field_offset();
         LoadFieldInstr* load_type_args =
             new LoadFieldInstr(array->Copy(),
                                type_arguments_field_offset,
                                Type::ZoneHandle());  // No type.
         InsertBefore(call, load_type_args, NULL, Definition::kValue);
         instantiator = array->Copy();
         type_args = new Value(load_type_args);
         break;
       }
+      case kUint8ArrayCid:
       case kFloat32ArrayCid:
       case kFloat64ArrayCid: {
         ConstantInstr* null_constant = new ConstantInstr(Object::ZoneHandle());
         InsertBefore(call, null_constant, NULL, Definition::kValue);
         instantiator = new Value(null_constant);
         type_args = new Value(null_constant);
-        ASSERT(value_type.IsDoubleType());
+        ASSERT(value_type.IsDoubleType() || value_type.IsIntType());

[srdjan, 2013/01/11 17:02:38]

Maybe you want to split the ASSERT: double type is not allowed for Uint8  array
and int is not allowed for Float32.

[Florian Schneider, 2013/01/14 10:03:10]

Done.

         ASSERT(value_type.IsInstantiated());
         break;
       }
       default:
         // TODO(fschneider): Add support for other array types.
         UNREACHABLE();
     }
     AssertAssignableInstr* assert_value =
         new AssertAssignableInstr(call->token_pos(),
                                   value->Copy(),
                                   instantiator,
                                   type_args,
                                   value_type,
                                   Symbols::Value());
     InsertBefore(call, assert_value, NULL, Definition::kValue);
   }
 
   Value* array = NULL;
   Value* index = NULL;
   intptr_t array_cid = PrepareIndexedOp(call, class_id, &array, &index);
   Value* value = call->ArgumentAt(2)->value();
   // Check if store barrier is needed.
   bool needs_store_barrier = true;
-  if ((class_id == kFloat32ArrayCid) || (class_id == kFloat64ArrayCid)) {
-    ASSERT(!value_check.IsNull());
-    InsertBefore(call,
-                 new CheckClassInstr(value->Copy(),
-                                     call->deopt_id(),
-                                     value_check),
-                 call->env(),
-                 Definition::kEffect);
-    needs_store_barrier = false;
-  } else if (ArgIsAlwaysSmi(*call->ic_data(), 2)) {
-    InsertBefore(call,
-                 new CheckSmiInstr(value->Copy(), call->deopt_id()),
-                 call->env(),
-                 Definition::kEffect);
-    needs_store_barrier = false;
+  if (!value_check.IsNull()) {
+    ASSERT(value_check.NumberOfChecks() == 1);
+    if (value_check.GetReceiverClassIdAt(0) == kSmiCid) {
+      InsertBefore(call,
+                   new CheckSmiInstr(value->Copy(), call->deopt_id()),
+                   call->env(),
+                   Definition::kEffect);
+      needs_store_barrier = false;
+    } else {
+      ASSERT(value_check.GetReceiverClassIdAt(0) == kDoubleCid);
+      InsertBefore(call,
+                   new CheckClassInstr(value->Copy(),
+                                       call->deopt_id(),
+                                       value_check),
+                   call->env(),
+                   Definition::kEffect);
+      needs_store_barrier = false;
+    }
   }
 
   Definition* array_op =
       new StoreIndexedInstr(array, index, value,
                             needs_store_barrier, array_cid, call->deopt_id());
   call->ReplaceWith(array_op, current_iterator());
   RemovePushArguments(call);
   return true;
 }
 
@@ skipping 3764 matching lines @@
 
   if (FLAG_trace_constant_propagation) {
     OS::Print("\n==== After constant propagation ====\n");
     FlowGraphPrinter printer(*graph_);
     printer.PrintBlocks();
   }
 }
 
 
 }  // namespace dart