Reland: Fix bug in field type tracking and polymorphic inlining.

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/block_scheduler.h"
@@ skipping 252 matching lines @@
   bool done = false;
   // volatile because the variable may be clobbered by a longjmp.
   volatile bool use_far_branches = false;
   while (!done) {
     const intptr_t prev_deopt_id = isolate->deopt_id();
     isolate->set_deopt_id(0);
     LongJump* old_base = isolate->long_jump_base();
     LongJump bailout_jump;
     isolate->set_long_jump_base(&bailout_jump);
     if (setjmp(*bailout_jump.Set()) == 0) {
+      FlowGraphBuilder* builder = NULL;
       FlowGraph* flow_graph = NULL;
+      GrowableArray<const Field*> guarded_fields;
       // TimerScope needs an isolate to be properly terminated in case of a
       // LongJump.
       {
         TimerScope timer(FLAG_compiler_stats,
                          &CompilerStats::graphbuilder_timer,
                          isolate);
         Array& ic_data_array = Array::Handle();
         if (optimized) {
           ASSERT(function.HasCode());
           // Extract type feedback before the graph is built, as the graph
           // builder uses it to attach it to nodes.
           ASSERT(function.deoptimization_counter() <
                  FLAG_deoptimization_counter_threshold);
           const Code& unoptimized_code =
               Code::Handle(function.unoptimized_code());
           ic_data_array = unoptimized_code.ExtractTypeFeedbackArray();
         }
 
         // Build the flow graph.
-        FlowGraphBuilder builder(parsed_function,
-                                 ic_data_array,
-                                 NULL,  // NULL = not inlining.
-                                 osr_id);
-        flow_graph = builder.BuildGraph();
+        builder = new FlowGraphBuilder(parsed_function,
+                                       ic_data_array,
+                                       NULL,  // NULL = not inlining.
+                                       &guarded_fields,
+                                       osr_id);
+        flow_graph = builder->BuildGraph();
       }
 
       if (FLAG_print_flow_graph ||
           (optimized && FLAG_print_flow_graph_optimized)) {
         if (osr_id == Isolate::kNoDeoptId) {
           FlowGraphPrinter::PrintGraph("Before Optimizations", flow_graph);
         } else {
           FlowGraphPrinter::PrintGraph("For OSR", flow_graph);
         }
       }
@@ skipping 11 matching lines @@
         flow_graph->ComputeSSA(0, NULL);
         DEBUG_ASSERT(flow_graph->VerifyUseLists());
         if (FLAG_print_flow_graph || FLAG_print_flow_graph_optimized) {
           FlowGraphPrinter::PrintGraph("After SSA", flow_graph);
         }
       }
 
       // Collect all instance fields that are loaded in the graph and
       // have non-generic type feedback attached to them that can
       // potentially affect optimizations.
-      GrowableArray<const Field*> guarded_fields(10);
       if (optimized) {
         TimerScope timer(FLAG_compiler_stats,
                          &CompilerStats::graphoptimizer_timer,
                          isolate);
 
-        FlowGraphOptimizer optimizer(flow_graph, &guarded_fields);
+        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);
           // Propagate types to create more inlining opportunities.
           if (FLAG_propagate_types) {
             FlowGraphTypePropagator propagator(flow_graph);
             propagator.Propagate();
             DEBUG_ASSERT(flow_graph->VerifyUseLists());
           }
 
           // Use propagated class-ids to create more inlining opportunities.
           optimizer.ApplyClassIds();
           DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
-          FlowGraphInliner inliner(flow_graph, &guarded_fields);
+          FlowGraphInliner inliner(flow_graph);
           inliner.Inline();
           // Use lists are maintained and validated by the inliner.
           DEBUG_ASSERT(flow_graph->VerifyUseLists());
         }
 
         // Propagate types and eliminate more type tests.
         if (FLAG_propagate_types) {
           FlowGraphTypePropagator propagator(flow_graph);
           propagator.Propagate();
           DEBUG_ASSERT(flow_graph->VerifyUseLists());
@@ skipping 551 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