Copy of Issue 247503003: Fix inline tree printing and add more information to it.

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 44 matching lines @@
 DECLARE_FLAG(bool, print_flow_graph_optimized);
 DECLARE_FLAG(int, deoptimization_counter_threshold);
 DECLARE_FLAG(bool, verify_compiler);
 DECLARE_FLAG(bool, compiler_stats);
 
 #define TRACE_INLINING(statement)                                              \
   do {                                                                         \
     if (FLAG_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)                                                              \
+
 
 // Test if a call is recursive by looking in the deoptimization environment.
 static bool IsCallRecursive(const Code& code, Definition* call) {
   Environment* env = call->env();
   while (env != NULL) {
     if (code.raw() == env->code().raw()) {
       return true;
     }
     env = env->outer();
   }
@@ skipping 85 matching lines @@
 struct InlinedInfo {
   const Function* caller;
   const Function* inlined;
   intptr_t inlined_depth;
   const Definition* call_instr;
   const char* bailout_reason;
   InlinedInfo(const Function* caller_function,
               const Function* inlined_function,
               const intptr_t depth,
               const Definition* call,
-              const char* reason = NULL)
+              const char* reason)
       : caller(caller_function),
         inlined(inlined_function),
         inlined_depth(depth),
         call_instr(call),
         bailout_reason(reason) {}
 };
 
 
 // A collection of call sites to consider for inlining.
 class CallSites : public ValueObject {
@@ skipping 88 matching lines @@
           0.0 : static_cast<double>(instance_call_counts[i]) / max_count;
       instance_calls_[i + instance_call_start_ix].ratio = ratio;
     }
     for (intptr_t i = 0; i < num_static_calls; ++i) {
       const double ratio = (max_count == 0) ?
           0.0 : static_cast<double>(static_call_counts[i]) / max_count;
       static_calls_[i + static_call_start_ix].ratio = ratio;
     }
   }
 
+  static void RecordAllNotInlinedFunction(
+      FlowGraph* graph,
+      intptr_t depth,
+      GrowableArray<InlinedInfo>* inlined_info) {
+    const Function* caller = &graph->parsed_function().function();
+    Function& target  = Function::ZoneHandle();
+    for (BlockIterator block_it = graph->postorder_iterator();
+         !block_it.Done();
+         block_it.Advance()) {
+      for (ForwardInstructionIterator it(block_it.Current());
+           !it.Done();
+           it.Advance()) {
+        Instruction* current = it.Current();
+        Definition* call = NULL;
+        if (current->IsPolymorphicInstanceCall()) {
+          PolymorphicInstanceCallInstr* instance_call =
+              current->AsPolymorphicInstanceCall();
+          target = instance_call->ic_data().GetTargetAt(0);
+          call = instance_call;
+        } else if (current->IsStaticCall()) {
+          StaticCallInstr* static_call = current->AsStaticCall();
+          target = static_call->function().raw();
+          call = static_call;
+        } else if (current->IsClosureCall()) {
+          // TODO(srdjan): Add data for closure calls.
+        }
+        if (call != NULL) {
+          inlined_info->Add(InlinedInfo(
+              caller, &target, depth + 1, call, "Too deep"));
+        }
+      }
+    }
+  }
+
+
   void FindCallSites(FlowGraph* graph,
                      intptr_t depth,
                      GrowableArray<InlinedInfo>* inlined_info) {
     ASSERT(graph != NULL);
-
-    if (depth > FLAG_inlining_depth_threshold) return;
+    if (depth > FLAG_inlining_depth_threshold) {
+      if (FLAG_print_inlining_tree) {
+        RecordAllNotInlinedFunction(graph, depth, inlined_info);
+      }
+      return;
+    }
 
     // Recognized methods are not treated as normal calls. They don't have
     // calls in themselves, so we keep adding those even when at the threshold.
     const bool inline_only_recognized_methods =
         (depth == FLAG_inlining_depth_threshold);
 
     const intptr_t instance_call_start_ix = instance_calls_.length();
     const intptr_t static_call_start_ix = static_calls_.length();
     for (BlockIterator block_it = graph->postorder_iterator();
          !block_it.Done();
@@ skipping 11 matching lines @@
             instance_calls_.Add(InstanceCallInfo(instance_call, graph));
           } else {
             // Method not inlined because inlining too deep and method
             // not recognized.
             if (FLAG_print_inlining_tree) {
               const Function* caller = &graph->parsed_function().function();
               const Function* target =
                   &Function::ZoneHandle(
                       instance_call->ic_data().GetTargetAt(0));
               inlined_info->Add(InlinedInfo(
-                  caller, target, depth, instance_call, "Too deep"));
+                  caller, target, depth + 1, instance_call, "Too deep"));
             }
           }
         } else if (current->IsStaticCall()) {
           StaticCallInstr* static_call = current->AsStaticCall();
           if (!inline_only_recognized_methods ||
               static_call->function().is_recognized()) {
             static_calls_.Add(StaticCallInfo(static_call, graph));
           } else {
             // Method not inlined because inlining too deep and method
             // not recognized.
             if (FLAG_print_inlining_tree) {
               const Function* caller = &graph->parsed_function().function();
               const Function* target = &static_call->function();
               inlined_info->Add(InlinedInfo(
-                  caller, target, depth, static_call, "Too deep"));
+                  caller, target, depth + 1, static_call, "Too deep"));
             }
           }
         } else if (current->IsClosureCall()) {
           if (!inline_only_recognized_methods) {
             ClosureCallInstr* closure_call = current->AsClosureCall();
             closure_calls_.Add(ClosureCallInfo(closure_call, graph));
           }
         }
       }
     }
@@ skipping 153 matching lines @@
                    const Array& argument_names,
                    InlinedCallData* call_data) {
     TRACE_INLINING(OS::Print("  => %s (deopt count %d)\n",
                              function.ToCString(),
                              function.deoptimization_counter()));
 
     // TODO(fschneider): Enable inlining inside try-blocks.
     if (call_data->call->GetBlock()->try_index() !=
         CatchClauseNode::kInvalidTryIndex) {
       TRACE_INLINING(OS::Print("     Bailout: inside try-block\n"));
-      if (FLAG_print_inlining_tree) {
-        inlined_info_.Add(InlinedInfo(
-            &call_data->caller, &function, inlining_depth_, call_data->call,
-            "Inside try-block"));
-      }
+      PRINT_INLINING_TREE("Inside try-block",
+          &call_data->caller, &function, call_data->call);
       return false;
     }
 
     // Make a handle for the unoptimized code so that it is not disconnected
     // from the function while we are trying to inline it.
     const Code& unoptimized_code = Code::Handle(function.unoptimized_code());
     // Abort if the inlinable bit on the function is low.
     if (!function.IsInlineable()) {
       TRACE_INLINING(OS::Print("     Bailout: not inlinable\n"));
-      if (FLAG_print_inlining_tree) {
-        inlined_info_.Add(InlinedInfo(
-            &call_data->caller, &function, inlining_depth_, call_data->call,
-            "Not inlinable"));
-      }
+      PRINT_INLINING_TREE("Not inlinable",
+          &call_data->caller, &function, call_data->call);
       return false;
     }
 
     // Abort if this function has deoptimized too much.
     if (function.deoptimization_counter() >=
         FLAG_deoptimization_counter_threshold) {
       function.set_is_inlinable(false);
       TRACE_INLINING(OS::Print("     Bailout: deoptimization threshold\n"));
-      if (FLAG_print_inlining_tree) {
-        inlined_info_.Add(InlinedInfo(
-            &call_data->caller, &function, inlining_depth_, call_data->call,
-            "Deoptimization threshold exceeded"));
-      }
+      PRINT_INLINING_TREE("Deoptimization threshold exceeded",
+          &call_data->caller, &function, call_data->call);
       return false;
     }
 
     GrowableArray<Value*>* arguments = call_data->arguments;
     const intptr_t constant_arguments = CountConstants(*arguments);
     if (!ShouldWeInline(function,
                         function.optimized_instruction_count(),
                         function.optimized_call_site_count(),
                         constant_arguments)) {
       TRACE_INLINING(OS::Print("     Bailout: early heuristics with "
                                "code size:  %" Pd ", "
                                "call sites: %" Pd ", "
                                "const args: %" Pd "\n",
                                function.optimized_instruction_count(),
                                function.optimized_call_site_count(),
                                constant_arguments));
-      if (FLAG_print_inlining_tree) {
-        inlined_info_.Add(InlinedInfo(
-            &call_data->caller, &function, inlining_depth_, call_data->call,
-            "Early heuristic"));
-      }
+      PRINT_INLINING_TREE("Early heuristic",
+          &call_data->caller, &function, call_data->call);
       return false;
     }
 
     // Abort if this is a recursive occurrence.
     Definition* call = call_data->call;
     if (!FLAG_inline_recursive && IsCallRecursive(unoptimized_code, call)) {
       function.set_is_inlinable(false);
       TRACE_INLINING(OS::Print("     Bailout: recursive function\n"));
+      PRINT_INLINING_TREE("Recursive function",
+          &call_data->caller, &function, call_data->call);
       return false;
     }
 
     Isolate* isolate = Isolate::Current();
     // Save and clear deopt id.
     const intptr_t prev_deopt_id = isolate->deopt_id();
     isolate->set_deopt_id(0);
     // Install bailout jump.
     LongJumpScope jump;
     if (setjmp(*jump.Set()) == 0) {
@@ skipping 49 matching lines @@
       // parameters.
       if (function.HasOptionalParameters()) {
         TRACE_INLINING(OS::Print("     adjusting for optional parameters\n"));
         if (!AdjustForOptionalParameters(*parsed_function,
                                          argument_names,
                                          arguments,
                                          param_stubs,
                                          callee_graph)) {
           function.set_is_inlinable(false);
           TRACE_INLINING(OS::Print("     Bailout: optional arg mismatch\n"));
+          PRINT_INLINING_TREE("Optional arg mismatch",
+              &call_data->caller, &function, call_data->call);
           return false;
         }
       }
 
       // After treating optional parameters the actual/formal count must match.
       ASSERT(arguments->length() == function.NumParameters());
       ASSERT(param_stubs->length() == callee_graph->parameter_count());
 
       BlockScheduler block_scheduler(callee_graph);
       block_scheduler.AssignEdgeWeights();
@@ skipping 54 matching lines @@
           function.set_is_inlinable(false);
         }
         isolate->set_deopt_id(prev_deopt_id);
         TRACE_INLINING(OS::Print("     Bailout: heuristics with "
                                  "code size:  %" Pd ", "
                                  "call sites: %" Pd ", "
                                  "const args: %" Pd "\n",
                                  size,
                                  call_site_count,
                                  constants_count));
-        if (FLAG_print_inlining_tree) {
-          inlined_info_.Add(InlinedInfo(
-              &call_data->caller, &function, inlining_depth_, call_data->call,
-              "Heuristic fail"));
-        }
+        PRINT_INLINING_TREE("Heuristic fail",
+            &call_data->caller, &function, call_data->call);
         return false;
       }
 
       if (function.IsInvokeFieldDispatcher() ||
           function.IsNoSuchMethodDispatcher()) {
         // Append call sites to the currently processed list so that dispatcher
         // methods get inlined regardless of the current depth.
         inlining_call_sites_->FindCallSites(callee_graph,
                                             0,
                                             &inlined_info_);
@@ skipping 21 matching lines @@
       // list of guarded fields.
       for (intptr_t i = 0; i < callee_graph->guarded_fields()->length(); ++i) {
         FlowGraph::AddToGuardedFields(caller_graph_->guarded_fields(),
                                       (*callee_graph->guarded_fields())[i]);
       }
 
       // We allocate a ZoneHandle for the unoptimized code so that it cannot be
       // disconnected from its function during the rest of compilation.
       Code::ZoneHandle(unoptimized_code.raw());
       TRACE_INLINING(OS::Print("     Success\n"));
-      if (FLAG_print_inlining_tree) {
-        inlined_info_.Add(
-            InlinedInfo(&call_data->caller, &function, inlining_depth_, call));
-      }
+      PRINT_INLINING_TREE(NULL,
+          &call_data->caller, &function, call);
       return true;
     } else {
       Error& error = Error::Handle();
       error = isolate->object_store()->sticky_error();
       isolate->object_store()->clear_sticky_error();
       isolate->set_deopt_id(prev_deopt_id);
       TRACE_INLINING(OS::Print("     Bailout: %s\n", error.ToErrorCString()));
+      PRINT_INLINING_TREE("Bailout",
+          &call_data->caller, &function, call);
       return false;
     }
   }
 
   void PrintInlinedInfo(const Function& top) {
     if (inlined_info_.length() > 0) {
       OS::Print("Inlining into: '%s' growth: %f (%" Pd " -> %" Pd ")\n",
           top.ToFullyQualifiedCString(),
           GrowthFactor(),
           initial_size_,
           inlined_size_);
       PrintInlinedInfoFor(top, 1);
     }
   }
 
  private:
   friend class PolymorphicInliner;
 
   void PrintInlinedInfoFor(const Function& caller, intptr_t depth) {
     // Print those that were inlined.
     for (intptr_t i = 0; i < inlined_info_.length(); i++) {
       const InlinedInfo& info = inlined_info_[i];
-      if (info.bailout_reason != NULL) continue;
+      if (info.bailout_reason != NULL) {
+        continue;
+      }
       if ((info.inlined_depth == depth) &&
           (info.caller->raw() == caller.raw())) {
         for (int t = 0; t < depth; t++) {
           OS::Print("  ");
         }
         OS::Print("%" Pd " %s\n",
             info.call_instr->GetDeoptId(),
             info.inlined->ToQualifiedCString());
         PrintInlinedInfoFor(*info.inlined, depth + 1);
       }
     }
     // Print those that were not inlined.
     for (intptr_t i = 0; i < inlined_info_.length(); i++) {
       const InlinedInfo& info = inlined_info_[i];
-      if (info.bailout_reason == NULL) continue;
+      if (info.bailout_reason == NULL) {
+        continue;
+      }
       if ((info.inlined_depth == depth) &&
           (info.caller->raw() == caller.raw())) {
         for (int t = 0; t < depth; t++) {
           OS::Print("  ");
         }
         OS::Print("NO %" Pd " %s - %s\n",
             info.call_instr->GetDeoptId(),
             info.inlined->ToQualifiedCString(),
             info.bailout_reason);
       }
@@ skipping 109 matching lines @@
         }
       }
       const Function& target = call->function();
       if (!FlowGraphInliner::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));
-        if (FLAG_print_inlining_tree) {
-          inlined_info_.Add(InlinedInfo(
-              call_info[call_idx].caller,
-              &call->function(),
-              inlining_depth_,
-              call,
-              "Too cold"));
-        }
+        PRINT_INLINING_TREE("Too cold",
+            call_info[call_idx].caller, &call->function(), call);
         continue;
       }
       GrowableArray<Value*> arguments(call->ArgumentCount());
       for (int i = 0; i < call->ArgumentCount(); ++i) {
         arguments.Add(call->PushArgumentAt(i)->value());
       }
       InlinedCallData call_data(call, &arguments, *call_info[call_idx].caller);
       if (TryInlining(call->function(), call->argument_names(), &call_data)) {
         InlineCall(&call_data);
       }
@@ skipping 11 matching lines @@
       ASSERT(call->ArgumentCount() > 0);
       Function& target = Function::ZoneHandle();
       AllocateObjectInstr* alloc =
           call->ArgumentAt(0)->AsAllocateObject();
       if ((alloc != NULL) && !alloc->closure_function().IsNull()) {
         target ^= alloc->closure_function().raw();
         ASSERT(target.signature_class() == alloc->cls().raw());
       }
       if (target.IsNull()) {
         TRACE_INLINING(OS::Print("     Bailout: non-closure operator\n"));
+        PRINT_INLINING_TREE("Non-closure operator",
+            call_info[call_idx].caller, &target, call);
         continue;
       }
       GrowableArray<Value*> arguments(call->ArgumentCount());
       for (int i = 0; i < call->ArgumentCount(); ++i) {
         arguments.Add(call->PushArgumentAt(i)->value());
       }
       InlinedCallData call_data(call, &arguments, *call_info[call_idx].caller);
       if (TryInlining(target,
                       call->argument_names(),
                       &call_data)) {
@@ skipping 18 matching lines @@
 
       const ICData& ic_data = call->ic_data();
       const Function& target = Function::ZoneHandle(ic_data.GetTargetAt(0));
       if (!FlowGraphInliner::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));
-        if (FLAG_print_inlining_tree) {
-          inlined_info_.Add(InlinedInfo(
-              call_info[call_idx].caller,
-              &target,
-              inlining_depth_,
-              call,
-              "Too cold"));
-        }
+        PRINT_INLINING_TREE("Too cold",
+            call_info[call_idx].caller, &target, call);
         continue;
       }
       GrowableArray<Value*> arguments(call->ArgumentCount());
       for (int arg_i = 0; arg_i < call->ArgumentCount(); ++arg_i) {
         arguments.Add(call->PushArgumentAt(arg_i)->value());
       }
       InlinedCallData call_data(call, &arguments, *call_info[call_idx].caller);
       if (TryInlining(target,
                       call->instance_call()->argument_names(),
                       &call_data)) {
@@ skipping 631 matching lines @@
         OS::Print("After Inlining of %s\n", flow_graph_->
                   parsed_function().function().ToFullyQualifiedCString());
         FlowGraphPrinter printer(*flow_graph_);
         printer.PrintBlocks();
       }
     }
   }
 }
 
 }  // namespace dart