Add --print-flow-graph-filter to allow filtering debugging output.

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/block_scheduler.h"
 #include "vm/compiler.h"
 #include "vm/flags.h"
 #include "vm/flow_graph.h"
@@ skipping 51 matching lines @@
 DECLARE_FLAG(int, deoptimization_counter_threshold);
 DECLARE_FLAG(bool, print_flow_graph);
 DECLARE_FLAG(bool, print_flow_graph_optimized);
 DECLARE_FLAG(bool, verify_compiler);
 
 // Quick access to the current zone.
 #define Z (zone())
 
 #define TRACE_INLINING(statement)                                              \
   do {                                                                         \
-    if (FLAG_trace_inlining) statement;                                        \
+    if (trace_inlining()) statement;                                           \
   } while (false)
 
 #define PRINT_INLINING_TREE(comment, caller, target, instance_call)            \
   do {                                                                         \
     if (FLAG_print_inlining_tree) {                                            \
       inlined_info_.Add(InlinedInfo(                                           \
           caller, target, inlining_depth_, instance_call, comment));           \
       }                                                                        \
   } while (false)                                                              \
 
@@ skipping 408 matching lines @@
         inlining_call_sites_(NULL),
         function_cache_(),
         inlined_info_() { }
 
   FlowGraph* caller_graph() const { return caller_graph_; }
 
   Thread* thread() const { return caller_graph_->thread(); }
   Isolate* isolate() const { return caller_graph_->isolate(); }
   Zone* zone() const { return caller_graph_->zone(); }
 
+  bool trace_inlining() const { return inliner_->trace_inlining(); }
+
   // Inlining heuristics based on Cooper et al. 2008.
   bool ShouldWeInline(const Function& callee,
                       intptr_t instr_count,
                       intptr_t call_site_count,
                       intptr_t const_arg_count) {
-    if (FlowGraphInliner::AlwaysInline(callee)) {
+    if (inliner_->AlwaysInline(callee)) {
       return true;
     }
     if (inlined_size_ > FLAG_inlining_caller_size_threshold) {
       // Prevent methods becoming humongous and thus slow to compile.
       return false;
     }
     if (const_arg_count > 0) {
       if (instr_count > FLAG_inlining_constant_arguments_max_size_threshold) {
         return false;
       }
@@ skipping 520 matching lines @@
         ASSERT(call->ArgumentCount() <= 2);
         // Arg 0: Instantiator type arguments.
         // Arg 1: Length (optional).
         if ((call->ArgumentCount() == 2) &&
             (!call->PushArgumentAt(1)->value()->BindsToConstant())) {
           // Do not inline since a non-constant argument was passed.
           continue;
         }
       }
       const Function& target = call->function();
-      if (!FlowGraphInliner::AlwaysInline(target) &&
+      if (!inliner_->AlwaysInline(target) &&
           (call_info[call_idx].ratio * 100) < FLAG_inlining_hotness) {
         TRACE_INLINING(OS::Print(
             "  => %s (deopt count %d)\n     Bailout: cold %f\n",
             target.ToCString(),
             target.deoptimization_counter(),
             call_info[call_idx].ratio));
         PRINT_INLINING_TREE("Too cold",
             call_info[call_idx].caller, &call->function(), call);
         continue;
       }
@@ skipping 58 matching lines @@
       PolymorphicInstanceCallInstr* call = call_info[call_idx].call;
       if (call->with_checks()) {
         const Function& cl = *call_info[call_idx].caller;
         PolymorphicInliner inliner(this, call, cl);
         inliner.Inline();
         continue;
       }
 
       const ICData& ic_data = call->ic_data();
       const Function& target = Function::ZoneHandle(ic_data.GetTargetAt(0));
-      if (!FlowGraphInliner::AlwaysInline(target) &&
+      if (!inliner_->AlwaysInline(target) &&
           (call_info[call_idx].ratio * 100) < FLAG_inlining_hotness) {
         TRACE_INLINING(OS::Print(
             "  => %s (deopt count %d)\n     Bailout: cold %f\n",
             target.ToCString(),
             target.deoptimization_counter(),
             call_info[call_idx].ratio));
         PRINT_INLINING_TREE("Too cold",
             call_info[call_idx].caller, &target, call);
         continue;
       }
@@ skipping 590 matching lines @@
   TargetEntryInstr* entry = BuildDecisionGraph();
   exit_collector_->ReplaceCall(entry);
 }
 
 
 static uint16_t ClampUint16(intptr_t v) {
   return (v > 0xFFFF) ? 0xFFFF : static_cast<uint16_t>(v);
 }
 
 
+static bool ShouldTraceInlining(FlowGraph* flow_graph) {
+  const Function& top = flow_graph->parsed_function().function();
+  return FLAG_trace_inlining && FlowGraphPrinter::ShouldPrint(top);
+}
+
+
+FlowGraphInliner::FlowGraphInliner(
+    FlowGraph* flow_graph,
+    GrowableArray<const Function*>* inline_id_to_function)
+    : flow_graph_(flow_graph),
+      inline_id_to_function_(inline_id_to_function),
+      trace_inlining_(ShouldTraceInlining(flow_graph)) {
+}
+
+
 void FlowGraphInliner::CollectGraphInfo(FlowGraph* flow_graph, bool force) {
   const Function& function = flow_graph->function();
   if (force || (function.optimized_instruction_count() == 0)) {
     GraphInfoCollector info;
     info.Collect(*flow_graph);
 
     function.set_optimized_instruction_count(
         ClampUint16(info.instruction_count()));
     function.set_optimized_call_site_count(ClampUint16(info.call_site_count()));
   }
@@ skipping 44 matching lines @@
   CollectGraphInfo(flow_graph_);
 
   const Function& top = flow_graph_->function();
   if ((FLAG_inlining_filter != NULL) &&
       (strstr(top.ToFullyQualifiedCString(), FLAG_inlining_filter) == NULL)) {
     return;
   }
 
   TRACE_INLINING(OS::Print("Inlining calls in %s\n", top.ToCString()));
 
-  if (FLAG_trace_inlining &&
+  if (trace_inlining() &&
       (FLAG_print_flow_graph || FLAG_print_flow_graph_optimized)) {
     OS::Print("Before Inlining of %s\n", flow_graph_->
               function().ToFullyQualifiedCString());
     FlowGraphPrinter printer(*flow_graph_);
     printer.PrintBlocks();
   }
 
   CallSiteInliner inliner(this);
   inliner.InlineCalls();
   if (FLAG_print_inlining_tree) {
     inliner.PrintInlinedInfo(top);
   }
 
   if (inliner.inlined()) {
     flow_graph_->DiscoverBlocks();
-    if (FLAG_trace_inlining) {
+    if (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_->
                   function().ToFullyQualifiedCString());
         FlowGraphPrinter printer(*flow_graph_);
         printer.PrintBlocks();
       }
     }
   }
 }
 
 
 intptr_t FlowGraphInliner::NextInlineId(const Function& function) {
   const intptr_t id = inline_id_to_function_->length();
   inline_id_to_function_->Add(&function);
   return id;
 }
 
 
 }  // namespace dart