Collect type feedback for fields.

runtime/vm/compiler.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/compiler.h"
 
 #include "vm/assembler.h"
 
 #include "vm/ast_printer.h"
 #include "vm/code_generator.h"
@@ skipping 92 matching lines @@
   if (FLAG_trace_compiler) {
     OS::Print("--> patching entry %#"Px"\n",
               Code::Handle(function.CurrentCode()).EntryPoint());
   }
   function.SwitchToUnoptimizedCode();
   if (FLAG_trace_compiler) {
     OS::Print("--> restoring entry at %#"Px"\n",
               Code::Handle(function.unoptimized_code()).EntryPoint());
   }
 }
 

[srdjan, 2013/03/18 18:54:35]

why the deleted line?

[Vyacheslav Egorov (Google), 2013/03/18 19:41:18]

Done.

-
 // Return false if bailed out.
 static bool CompileParsedFunctionHelper(const ParsedFunction& parsed_function,
                                         bool optimized) {
   TimerScope timer(FLAG_compiler_stats, &CompilerStats::codegen_timer);
   bool is_compiled = false;
   Isolate* isolate = Isolate::Current();
   HANDLESCOPE(isolate);
   ASSERT(isolate->ic_data_array() == Array::null());  // Must be reset to null.
   const intptr_t prev_deopt_id = isolate->deopt_id();
   isolate->set_deopt_id(0);
@@ skipping 35 matching lines @@
       // Transform to SSA (virtual register 0 and no inlining arguments).
       flow_graph->ComputeSSA(0, NULL);
       DEBUG_ASSERT(flow_graph->VerifyUseLists());
     }
 
     if (FLAG_print_flow_graph ||
         (optimized && FLAG_print_flow_graph_optimized)) {
       FlowGraphPrinter::PrintGraph("Before Optimizations", flow_graph);
     }
 
+    ZoneGrowableArray<Field*>* guarded_fields = NULL;
+
     if (optimized) {
       TimerScope timer(FLAG_compiler_stats,
                        &CompilerStats::graphoptimizer_timer,
                        isolate);
 
       FlowGraphOptimizer optimizer(flow_graph);
       optimizer.ApplyICData();
       DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
       // Optimize (a << b) & c patterns. Must occur before
       // 'SelectRepresentations' which inserts conversion nodes.
       // TODO(srdjan): Moved before inlining until environment use list can
       // be used to detect when shift-left is outside the scope of bit-and.
       optimizer.TryOptimizeLeftShiftWithBitAndPattern();
       DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
       // Inlining (mutates the flow graph)
       if (FLAG_use_inlining) {
         TimerScope timer(FLAG_compiler_stats,
                          &CompilerStats::graphinliner_timer);
         FlowGraphInliner inliner(flow_graph);
         inliner.Inline();
         // Use lists are maintained and validated by the inliner.
         DEBUG_ASSERT(flow_graph->VerifyUseLists());
       }
 
+      guarded_fields = flow_graph->FieldDependencies();
+
       // Propagate types and eliminate more type tests.
       if (FLAG_propagate_types) {
         FlowGraphTypePropagator propagator(flow_graph);
         propagator.Propagate();
         DEBUG_ASSERT(flow_graph->VerifyUseLists());
       }
 
       // Use propagated class-ids to optimize further.
       optimizer.ApplyClassIds();
       DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
       // Do optimizations that depend on the propagated type information.
       optimizer.Canonicalize();
       DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
       BranchSimplifier::Simplify(flow_graph);
       DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
       if (FLAG_constant_propagation) {
         ConstantPropagator::Optimize(flow_graph);
         DEBUG_ASSERT(flow_graph->VerifyUseLists());
         // A canonicalization pass to remove e.g. smi checks on smi constants.
         optimizer.Canonicalize();
         DEBUG_ASSERT(flow_graph->VerifyUseLists());
       }
 
       // Propagate types and eliminate even more type tests.
       if (FLAG_propagate_types) {
+        // Recompute types after constant propagation to infer more precise
+        // types for uses that were previously reached by now eliminated phis.
         FlowGraphTypePropagator propagator(flow_graph);
         propagator.Propagate();
         DEBUG_ASSERT(flow_graph->VerifyUseLists());
       }
 
       // Unbox doubles. Performed after constant propagation to minimize
       // interference from phis merging double values and tagged
       // values comming from dead paths.
       optimizer.SelectRepresentations();
       DEBUG_ASSERT(flow_graph->VerifyUseLists());
@@ skipping 18 matching lines @@
 
       if (FLAG_range_analysis) {
         // We have to perform range analysis after LICM because it
         // optimistically moves CheckSmi through phis into loop preheaders
         // making some phis smi.
         optimizer.InferSmiRanges();
         DEBUG_ASSERT(flow_graph->VerifyUseLists());
       }
 
       // The final canonicalization pass before the code generation.
+      if (FLAG_propagate_types) {
+        // Propagate types one more time after code movement phases.
+        // This recomputes types of values that became dominated by
+        // hoisted checks.
+        FlowGraphTypePropagator propagator(flow_graph);
+        propagator.Propagate();
+        DEBUG_ASSERT(flow_graph->VerifyUseLists());
+      }
       optimizer.Canonicalize();
       DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
       // Perform register allocation on the SSA graph.
       FlowGraphAllocator allocator(*flow_graph);
       allocator.AllocateRegisters();
 
       if (FLAG_print_flow_graph || FLAG_print_flow_graph_optimized) {
         FlowGraphPrinter::PrintGraph("After Optimizations", flow_graph);
       }
@@ skipping 17 matching lines @@
       const Code& code = Code::Handle(
           Code::FinalizeCode(function, &assembler, optimized));
       code.set_is_optimized(optimized);
       graph_compiler.FinalizePcDescriptors(code);
       graph_compiler.FinalizeDeoptInfo(code);
       graph_compiler.FinalizeStackmaps(code);
       graph_compiler.FinalizeVarDescriptors(code);
       graph_compiler.FinalizeExceptionHandlers(code);
       graph_compiler.FinalizeComments(code);
       graph_compiler.FinalizeStaticCallTargetsTable(code);
+
       if (optimized) {
         CodePatcher::PatchEntry(Code::Handle(function.CurrentCode()));
         function.SetCode(code);
         if (FLAG_trace_compiler) {
           OS::Print("--> patching entry %#"Px"\n",
                     Code::Handle(function.unoptimized_code()).EntryPoint());
         }
+
+        for (intptr_t i = 0; i < guarded_fields->length(); i++) {
+          const Field& field = *(*guarded_fields)[i];
+          field.RegisterDependentCode(code);
+        }
       } else {
         function.set_unoptimized_code(code);
         function.SetCode(code);
         ASSERT(CodePatcher::CodeIsPatchable(code));
       }
     }
     is_compiled = true;
   } else {
     // We bailed out.
     Error& bailout_error = Error::Handle(
@@ skipping 345 matching lines @@
       Object::Handle(isolate->object_store()->sticky_error());
     isolate->object_store()->clear_sticky_error();
     isolate->set_long_jump_base(base);
     return result.raw();
   }
   UNREACHABLE();
   return Object::null();
 }
 
 }  // namespace dart