Using type feedback, eliminate store barriers for indexed stores.

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/hash_map.h"
@@ skipping 309 matching lines @@
 void FlowGraphOptimizer::AddCheckClass(InstanceCallInstr* call,
                                        Value* value) {
   // Type propagation has not run yet, we cannot eliminate the check.
   const ICData& unary_checks =
       ICData::ZoneHandle(call->ic_data()->AsUnaryClassChecks());
   CheckClassInstr* check = new CheckClassInstr(value, call, unary_checks);
   InsertBefore(call, check, call->env(), Definition::kEffect);
 }
 
 
+static bool ArgIsAlwaysSmi(const ICData& ic_data, intptr_t arg_n) {
+  ASSERT(ic_data.num_args_tested() > arg_n);
+  if (ic_data.NumberOfChecks() == 0) return false;
+  GrowableArray<intptr_t> class_ids;
+  Function& target = Function::Handle();
+  for (intptr_t i = 0; i < ic_data.NumberOfChecks(); i++) {
+    ic_data.GetCheckAt(i, &class_ids, &target);
+    if (class_ids[arg_n] != kSmiCid) return false;
+  }
+  return true;
+}
+
+
 bool FlowGraphOptimizer::TryReplaceWithArrayOp(InstanceCallInstr* call,
                                                Token::Kind op_kind) {
   // TODO(fschneider): Optimize []= operator in checked mode as well.
   if (op_kind == Token::kASSIGN_INDEX && FLAG_enable_type_checks) return false;
 
   const intptr_t class_id = ReceiverClassId(call);
   switch (class_id) {
     case kImmutableArrayCid:
       // Stores are only specialized for Array and GrowableObjectArray,
       // not for ImmutableArray.
@@ skipping 25 matching lines @@
                                  GrowableObjectArray::data_offset(),
                                  Type::ZoneHandle(Type::DynamicType()));
         elements->set_result_cid(kArrayCid);
         InsertBefore(call, elements, NULL, Definition::kValue);
         array = new Value(elements);
       }
       Definition* array_op = NULL;
       if (op_kind == Token::kINDEX) {
         array_op = new LoadIndexedInstr(array, index);
       } else {
+        bool needs_store_barrier = true;
+        if (ArgIsAlwaysSmi(*call->ic_data(), 2)) {
+          InsertBefore(call,
+                       new CheckSmiInstr(call->ArgumentAt(2)->value()->Copy(),
+                                         call->deopt_id()),
+                       call->env(),
+                       Definition::kEffect);
+          needs_store_barrier = false;
+        }
         Value* value = call->ArgumentAt(2)->value();
-        array_op = new StoreIndexedInstr(array, index, value);
+        array_op =
+            new StoreIndexedInstr(array, index, value, needs_store_barrier);
       }
       call->ReplaceWith(array_op, current_iterator());
       RemovePushArguments(call);
       return true;
     }
     default:
       return false;
   }
 }
 
@@ skipping 416 matching lines @@
   MethodRecognizer::Kind recognized_kind =
       MethodRecognizer::RecognizeKind(call->function());
   if (recognized_kind == MethodRecognizer::kMathSqrt) {
     MathSqrtInstr* sqrt = new MathSqrtInstr(call->ArgumentAt(0)->value(), call);
     call->ReplaceWith(sqrt, current_iterator());
     RemovePushArguments(call);
   }
 }
 
 
-static bool ArgIsAlwaysSmi(const ICData& ic_data, intptr_t arg_n) {
-  ASSERT(ic_data.num_args_tested() > arg_n);
-  if (ic_data.NumberOfChecks() == 0) return false;
-  GrowableArray<intptr_t> class_ids;
-  Function& target = Function::Handle();
-  for (intptr_t i = 0; i < ic_data.NumberOfChecks(); i++) {
-    ic_data.GetCheckAt(i, &class_ids, &target);
-    if (class_ids[arg_n] != kSmiCid) return false;
-  }
-  return true;
-}
-
-
 bool FlowGraphOptimizer::TryInlineInstanceSetter(InstanceCallInstr* instr) {
   if (FLAG_enable_type_checks) {
     // TODO(srdjan): Add assignable check node if --enable_type_checks.
     return false;
   }
 
   ASSERT(instr->HasICData());
   const ICData& unary_ic_data =
       ICData::Handle(instr->ic_data()->AsUnaryClassChecks());
   if (unary_ic_data.NumberOfChecks() == 0) {
@@ skipping 581 matching lines @@
       DirectChainedHashMap<Definition*> child_map(*map);  // Copy map.
       OptimizeRecursive(child, &child_map);
     } else {
       OptimizeRecursive(child, map);  // Reuse map for the last child.
     }
   }
 }
 
 
 }  // namespace dart