Collect type feedback for fields.

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 1215 matching lines @@
   ASSERT(!field.IsNull());
 
   if (InstanceCallNeedsClassCheck(call)) {
     AddReceiverCheck(call);
   }
   LoadFieldInstr* load = new LoadFieldInstr(
       new Value(call->ArgumentAt(0)),
       field.Offset(),
       AbstractType::ZoneHandle(field.type()),
       field.is_final());
+  if (field.guarded_cid() != kIllegalCid) {
+    load->set_result_cid(field.GuardedCid());
+    load->set_field(&Field::ZoneHandle(field.raw()));
+  }
+  load->set_field_name(String::Handle(field.name()).ToCString());
+
   // Discard the environment from the original instruction because the load
   // can't deoptimize.
   call->RemoveEnvironment();
   ReplaceCall(call, load);
 }
 
 
 void FlowGraphOptimizer::InlineArrayLengthGetter(InstanceCallInstr* call,
                                                  intptr_t length_offset,
                                                  bool is_immutable,
@@ skipping 623 matching lines @@
       new InstanceOfInstr(call->token_pos(),
                           new Value(left),
                           new Value(instantiator),
                           new Value(type_args),
                           type,
                           negate);
   ReplaceCall(call, instance_of);
 }
 
 
+void FlowGraphOptimizer::VisitStoreInstanceField(
+    StoreInstanceFieldInstr* instr) {
+  if (!instr->should_emit_field_guard()) return;
+
+  if (instr->field().guarded_cid() != kDynamicCid) {

[Kevin Millikin (Google), 2013/03/12 12:14:56]

I think it's a bit better to always insert the guards in the builder.  Maybe
it's not easy for some reason?

[Vyacheslav Egorov (Google), 2013/03/12 16:54:40]

Done. Though it requires an expression temp to preserve value and leads to a
slightly worse code in the non-optimized case.

+    ASSERT(instr->env() != NULL);
+    // TODO(vegorov) need a deopt id here!
+    InsertBefore(instr,
+                 new GuardFieldInstr(instr->value()->Copy(),
+                                     instr->field(),
+                                     instr->deopt_id()),
+                 instr->env(),
+                 Definition::kEffect);
+  }
+
+  instr->detach_field_guard();
+}
+
+
 // Tries to optimize instance call by replacing it with a faster instruction
 // (e.g, binary op, field load, ..).
 void FlowGraphOptimizer::VisitInstanceCall(InstanceCallInstr* instr) {
   if (!instr->HasICData() || (instr->ic_data()->NumberOfChecks() == 0)) {
     return;
   }
 
   const Token::Kind op_kind = instr->token_kind();
   // Type test is special as it always gets converted into inlined code.
   if (Token::IsTypeTestOperator(op_kind)) {
@@ skipping 120 matching lines @@
   }
   StoreBarrierType needs_store_barrier = kEmitStoreBarrier;
   if (ArgIsAlwaysSmi(*instr->ic_data(), 1)) {
     InsertBefore(instr,
                  new CheckSmiInstr(new Value(instr->ArgumentAt(1)),
                                    instr->deopt_id()),
                  instr->env(),
                  Definition::kEffect);
     needs_store_barrier = kNoStoreBarrier;
   }
+
+  if (field.guarded_cid() != kDynamicCid) {
+    InsertBefore(instr,
+                 new GuardFieldInstr(new Value(instr->ArgumentAt(1)),
+                                     field,
+                                     instr->deopt_id()),
+                 instr->env(),
+                 Definition::kEffect);
+  }
+
+  // Field guard was detached.
+  const bool needs_field_guard = false;
   StoreInstanceFieldInstr* store = new StoreInstanceFieldInstr(
       field,
       new Value(instr->ArgumentAt(0)),
       new Value(instr->ArgumentAt(1)),
-      needs_store_barrier);
+      needs_store_barrier,
+      needs_field_guard);
   // Discard the environment from the original instruction because the store
   // can't deoptimize.
   instr->RemoveEnvironment();
   ReplaceCall(instr, store);
   return true;
 }
 
 
 void FlowGraphOptimizer::HandleRelationalOp(RelationalOpInstr* comp) {
   if (!comp->HasICData() || (comp->ic_data()->NumberOfChecks() == 0)) {
@@ skipping 1736 matching lines @@
 
 void ConstantPropagator::VisitCatchEntry(CatchEntryInstr* instr) { }
 
 
 void ConstantPropagator::VisitCheckStackOverflow(
     CheckStackOverflowInstr* instr) { }
 
 
 void ConstantPropagator::VisitCheckClass(CheckClassInstr* instr) { }
 
+void ConstantPropagator::VisitGuardField(GuardFieldInstr* instr) { }
 
 void ConstantPropagator::VisitCheckSmi(CheckSmiInstr* instr) { }
 
 
 void ConstantPropagator::VisitCheckEitherNonSmi(
     CheckEitherNonSmiInstr* instr) { }
 
 
 void ConstantPropagator::VisitCheckArrayBound(CheckArrayBoundInstr* instr) { }
 
@@ skipping 869 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