Cleanups in the inliner.

runtime/vm/flow_graph_inliner.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_inliner.h"
 
 #include "vm/compiler.h"
 #include "vm/flags.h"
 #include "vm/flow_graph.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/flow_graph_optimizer.h"
 #include "vm/il_printer.h"
 #include "vm/intrinsifier.h"
 #include "vm/longjump.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, trace_inlining, false, "Trace inlining");
 DEFINE_FLAG(charp, inlining_filter, NULL, "Inline only in named function");
 DEFINE_FLAG(int, inlining_size_threshold, 50,
     "Inline only functions with up to threshold instructions (default 50)");
 // TODO(srdjan): set to 3 once crash in apidoc.dart is resolved.
 DEFINE_FLAG(int, inlining_depth_threshold, 3,
     "Inline recursively up to threshold depth (default 3)");
-DEFINE_FLAG(bool, inline_control_flow, true,
-    "Inline functions with control flow.");
 DECLARE_FLAG(bool, print_flow_graph);
 DECLARE_FLAG(int, deoptimization_counter_threshold);
 DECLARE_FLAG(bool, verify_compiler);
 
 #define TRACE_INLINING(statement)                                              \
   do {                                                                         \
     if (FLAG_trace_inlining) statement;                                        \
   } while (false)
 
 
@@ skipping 126 matching lines @@
  public:
   explicit CallSiteInliner(FlowGraph* flow_graph)
       : caller_graph_(flow_graph),
         next_ssa_temp_index_(flow_graph->max_virtual_register_number()),
         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_() { }
 
   void InlineCalls() {
     // If inlining depth is less then one abort.
     if (FLAG_inlining_depth_threshold < 1) return;
     // Create two call site collections to swap between.
     CallSites sites1(caller_graph_);
     CallSites sites2(caller_graph_);
     CallSites* call_sites_temp = NULL;
     collected_call_sites_ = &sites1;
     inlining_call_sites_ = &sites2;
@@ skipping 76 matching lines @@
     // Save and clear deopt id.
     const intptr_t prev_deopt_id = isolate->deopt_id();
     isolate->set_deopt_id(0);
     // Install bailout jump.
     LongJump* base = isolate->long_jump_base();
     LongJump jump;
     isolate->set_long_jump_base(&jump);
     if (setjmp(*jump.Set()) == 0) {
       // Parse the callee function.
       bool in_cache;
-      ParsedFunction* parsed_function = ParseFunction(function, &in_cache);
+      ParsedFunction* parsed_function = GetParsedFunction(function, &in_cache);
 
       // Load IC data for the callee.
       if (function.HasCode()) {
         const Code& unoptimized_code =
             Code::Handle(function.unoptimized_code());
         isolate->set_ic_data_array(unoptimized_code.ExtractTypeFeedbackArray());
       }
 
       // Build the callee graph.
       FlowGraphBuilder builder(*parsed_function);
       builder.SetInitialBlockId(caller_graph_->max_block_id());
       FlowGraph* callee_graph =
           builder.BuildGraph(FlowGraphBuilder::kValueContext);
 
-      // Abort if the callee graph contains control flow.
-      if (!FLAG_inline_control_flow &&
-          (callee_graph->preorder().length() != 2)) {
-        function.set_is_inlinable(false);
-        isolate->set_long_jump_base(base);
-        isolate->set_ic_data_array(prev_ic_data.raw());
-        TRACE_INLINING(OS::Print("     Bailout: control flow\n"));
-        return false;
-      }
-
       // Compute SSA on the callee graph, catching bailouts.
       callee_graph->ComputeSSA(next_ssa_temp_index_);
       callee_graph->ComputeUseLists();
 
       // TODO(zerny): Do more optimization passes on the callee graph.
       FlowGraphOptimizer optimizer(callee_graph);
       optimizer.ApplyICData();
       callee_graph->ComputeUseLists();
 
       if (FLAG_trace_inlining && FLAG_print_flow_graph) {
@@ skipping 43 matching lines @@
       }
       ASSERT(arg_index == arguments->length());
 
       // Replace callee's null constant with caller's null constant.
       callee_graph->graph_entry()->constant_null()->ReplaceUsesWith(
           caller_graph_->graph_entry()->constant_null());
 
       TRACE_INLINING(OS::Print("     Success\n"));
 
       // Add the function to the cache.
-      if (!in_cache) function_cache.Add(parsed_function);
+      if (!in_cache) function_cache_.Add(parsed_function);
 
       // Check that inlining maintains use lists.
       DEBUG_ASSERT(!FLAG_verify_compiler || caller_graph_->ValidateUseLists());
 
       // Build succeeded so we restore the bailout jump.
       inlined_ = true;
       inlined_size_ += size;
       isolate->set_long_jump_base(base);
       isolate->set_deopt_id(prev_deopt_id);
       isolate->set_ic_data_array(prev_ic_data.raw());
       return true;
     } else {
       Error& error = Error::Handle();
       error = isolate->object_store()->sticky_error();
       isolate->object_store()->clear_sticky_error();
       isolate->set_long_jump_base(base);
       isolate->set_deopt_id(prev_deopt_id);
       isolate->set_ic_data_array(prev_ic_data.raw());
       TRACE_INLINING(OS::Print("     Bailout: %s\n", error.ToErrorCString()));
       return false;
     }
   }
 
   // Parse a function reusing the cache if possible. Returns true if the
   // function was in the cache.
-  ParsedFunction* ParseFunction(const Function& function, bool* in_cache) {
+  ParsedFunction* GetParsedFunction(const Function& function, bool* in_cache) {
     // TODO(zerny): Use a hash map for the cache.
-    for (intptr_t i = 0; i < function_cache.length(); ++i) {
-      ParsedFunction* parsed_function = function_cache[i];
+    for (intptr_t i = 0; i < function_cache_.length(); ++i) {
+      ParsedFunction* parsed_function = function_cache_[i];
       if (parsed_function->function().raw() == function.raw()) {
         *in_cache = true;
         SourceLabelResetter reset;
         parsed_function->node_sequence()->Visit(&reset);
         return parsed_function;
       }
     }
     *in_cache = false;
     ParsedFunction* parsed_function = new ParsedFunction(function);
     Parser::ParseFunction(parsed_function);
@@ skipping 63 matching lines @@
   }
 
   FlowGraph* caller_graph_;
   intptr_t next_ssa_temp_index_;
   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<ParsedFunction*> function_cache_;
 
   DISALLOW_COPY_AND_ASSIGN(CallSiteInliner);
 };
 
 
 void FlowGraphInliner::Inline() {
   if ((FLAG_inlining_filter != NULL) &&
       (strstr(flow_graph_->
               parsed_function().function().ToFullyQualifiedCString(),
               FLAG_inlining_filter) == NULL)) {
@@ skipping 21 matching lines @@
         OS::Print("After Inlining of %s\n", flow_graph_->
                   parsed_function().function().ToFullyQualifiedCString());
         FlowGraphPrinter printer(*flow_graph_);
         printer.PrintBlocks();
       }
     }
   }
 }
 
 }  // namespace dart