Use ICData to collect type feedback on instance setter value. If value is always Smi, insert a smi …

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 285 matching lines @@
       return false;
     }
   }
   return true;
 }
 
 
 static intptr_t ReceiverClassId(InstanceCallInstr* call) {
   if (!call->HasICData()) return kIllegalCid;
 
-  const ICData& ic_data = *call->ic_data();
+  const ICData& ic_data = ICData::Handle(call->ic_data()->AsUnaryClassChecks());
 
   if (ic_data.NumberOfChecks() == 0) return kIllegalCid;
   // TODO(vegorov): Add multiple receiver type support.
   if (ic_data.NumberOfChecks() != 1) return kIllegalCid;
   ASSERT(HasOneTarget(ic_data));
 
   Function& target = Function::Handle();
   intptr_t class_id;
   ic_data.GetOneClassCheckAt(0, &class_id, &target);
   return class_id;
@@ skipping 471 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& ic_data = *instr->ic_data();
-  if (ic_data.NumberOfChecks() == 0) {
+  const ICData& unary_ic_data =
+      ICData::Handle(instr->ic_data()->AsUnaryClassChecks());
+  if (unary_ic_data.NumberOfChecks() == 0) {
     // No type feedback collected.
     return false;
   }
-  if (!HasOneTarget(ic_data)) {
+  if (!HasOneTarget(unary_ic_data)) {
     // TODO(srdjan): Implement when not all targets are the same.
     return false;
   }
   Function& target = Function::Handle();
   intptr_t class_id;
-  ic_data.GetOneClassCheckAt(0, &class_id, &target);
+  unary_ic_data.GetOneClassCheckAt(0, &class_id, &target);
   if (target.kind() != RawFunction::kImplicitSetter) {
     // Not an implicit setter.
     // TODO(srdjan): Inline special setters.
     return false;
   }
   // Inline implicit instance setter.
   const String& field_name =
       String::Handle(Field::NameFromSetter(instr->function_name()));
   const Field& field = Field::Handle(GetField(class_id, field_name));
   ASSERT(!field.IsNull());
 
   if (InstanceCallNeedsClassCheck(instr)) {
     AddCheckClass(instr, instr->ArgumentAt(0)->value()->Copy());
   }
+  bool needs_store_barrier = true;
+  if (ArgIsAlwaysSmi(*instr->ic_data(), 1)) {
+    InsertBefore(instr,
+                 new CheckSmiInstr(instr->ArgumentAt(1)->value()->Copy(),
+                                   instr->deopt_id()),
+                 instr->env(),
+                 Definition::kEffect);
+    needs_store_barrier = false;
+  }
   // Detach environment from the original instruction because it can't
   // deoptimize.
   instr->set_env(NULL);
   StoreInstanceFieldInstr* store = new StoreInstanceFieldInstr(
       field,
       instr->ArgumentAt(0)->value(),
       instr->ArgumentAt(1)->value());
+  store->set_may_need_store_barrier(needs_store_barrier);
   instr->ReplaceWith(store, current_iterator());
   RemovePushArguments(instr);
   return true;
 }
 
 
 // TODO(fschneider): Once we get rid of the distinction between Instruction
 // and computation, this helper can go away.
 static void HandleRelationalOp(FlowGraphOptimizer* optimizer,
                                RelationalOpInstr* comp,
@@ skipping 530 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