Fix guarded_cid handling: add field to list of guarded_field at LoadField creation time.

runtime/vm/flow_graph_inliner.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_inliner.h"
 
 #include "vm/compiler.h"
 #include "vm/flags.h"
 #include "vm/flow_graph.h"
 #include "vm/flow_graph_builder.h"
@@ skipping 274 matching lines @@
   GrowableArray<ClosureCallInstr*> closure_calls_;
   GrowableArray<InstanceCallInfo> instance_calls_;
   GrowableArray<intptr_t> skip_static_call_deopt_ids_;
 
   DISALLOW_COPY_AND_ASSIGN(CallSites);
 };
 
 
 class CallSiteInliner : public ValueObject {
  public:
-  explicit CallSiteInliner(FlowGraph* flow_graph)
+  CallSiteInliner(FlowGraph* flow_graph, GrowableArray<Field*>* guarded_fields)
       : caller_graph_(flow_graph),
         inlined_(false),
         initial_size_(flow_graph->InstructionCount()),
         inlined_size_(0),
         inlining_depth_(1),
         collected_call_sites_(NULL),
         inlining_call_sites_(NULL),
-        function_cache_() { }
+        function_cache_(),
+        guarded_fields_(guarded_fields) { }
 
   // Inlining heuristics based on Cooper et al. 2008.
   bool ShouldWeInline(intptr_t instr_count,
                       intptr_t call_site_count,
                       intptr_t const_arg_count) {
     if (instr_count <= FLAG_inlining_size_threshold) {
       return true;
     }
     if (call_site_count <= FLAG_inlining_callee_call_sites_threshold) {
       return true;
@@ skipping 180 matching lines @@
         callee_graph->ComputeSSA(caller_graph_->max_virtual_register_number(),
                                  &param_stubs);
         DEBUG_ASSERT(callee_graph->VerifyUseLists());
       }
 
       {
         TimerScope timer(FLAG_compiler_stats,
                          &CompilerStats::graphinliner_opt_timer,
                          isolate);
         // TODO(zerny): Do more optimization passes on the callee graph.
-        FlowGraphOptimizer optimizer(callee_graph);
+        FlowGraphOptimizer optimizer(callee_graph, guarded_fields_);
         optimizer.ApplyICData();
         DEBUG_ASSERT(callee_graph->VerifyUseLists());
       }
 
       if (FLAG_trace_inlining &&
           (FLAG_print_flow_graph || FLAG_print_flow_graph_optimized)) {
         OS::Print("Callee graph for inlining %s\n",
                   function.ToFullyQualifiedCString());
         FlowGraphPrinter printer(*callee_graph);
         printer.PrintBlocks();
@@ skipping 312 matching lines @@
 
 
   FlowGraph* caller_graph_;
   bool inlined_;
   intptr_t initial_size_;
   intptr_t inlined_size_;
   intptr_t inlining_depth_;
   CallSites* collected_call_sites_;
   CallSites* inlining_call_sites_;
   GrowableArray<ParsedFunction*> function_cache_;
+  GrowableArray<Field*>* guarded_fields_;
 
   DISALLOW_COPY_AND_ASSIGN(CallSiteInliner);
 };
 
 
 void FlowGraphInliner::CollectGraphInfo(FlowGraph* flow_graph) {
   GraphInfoCollector info;
   info.Collect(*flow_graph);
   const Function& function = flow_graph->parsed_function().function();
   function.set_optimized_instruction_count(
@@ skipping 20 matching lines @@
       flow_graph_->parsed_function().function().ToCString()));
 
   if (FLAG_trace_inlining &&
       (FLAG_print_flow_graph || FLAG_print_flow_graph_optimized)) {
     OS::Print("Before Inlining of %s\n", flow_graph_->
               parsed_function().function().ToFullyQualifiedCString());
     FlowGraphPrinter printer(*flow_graph_);
     printer.PrintBlocks();
   }
 
-  CallSiteInliner inliner(flow_graph_);
+  CallSiteInliner inliner(flow_graph_, guarded_fields_);
   inliner.InlineCalls();
 
   if (inliner.inlined()) {
     flow_graph_->RepairGraphAfterInlining();
     if (FLAG_trace_inlining) {
       OS::Print("Inlining growth factor: %f\n", inliner.GrowthFactor());
       if (FLAG_print_flow_graph || FLAG_print_flow_graph_optimized) {
         OS::Print("After Inlining of %s\n", flow_graph_->
                   parsed_function().function().ToFullyQualifiedCString());
         FlowGraphPrinter printer(*flow_graph_);
         printer.PrintBlocks();
       }
     }
   }
 }
 
 }  // namespace dart