Add inlining ranges/intervals to code objects so that we can map a pc to the inlined stack. The map…

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 456 matching lines @@
         return true;
       }
     }
   }
   return false;
 }
 
 
 class CallSiteInliner : public ValueObject {
  public:
-  explicit CallSiteInliner(FlowGraph* flow_graph)
-      : caller_graph_(flow_graph),
+  explicit CallSiteInliner(FlowGraphInliner* inliner)
+      : inliner_(inliner),
+        caller_graph_(inliner->flow_graph()),
         inlined_(false),
-        initial_size_(flow_graph->InstructionCount()),
+        initial_size_(inliner->flow_graph()->InstructionCount()),
         inlined_size_(0),
         inlined_recursive_call_(false),
         inlining_depth_(1),
         inlining_recursion_depth_(0),
         collected_call_sites_(NULL),
         inlining_call_sites_(NULL),
         function_cache_(),
         inlined_info_() { }
 
   FlowGraph* caller_graph() const { return caller_graph_; }
@@ skipping 313 matching lines @@
                                  "const args: %" Pd "\n",
                                  size,
                                  call_site_count,
                                  constants_count));
         PRINT_INLINING_TREE("Heuristic fail",
             &call_data->caller, &function, call_data->call);
         return false;
       }
 
       // Inline dispatcher methods regardless of the current depth.
-      intptr_t depth =
+      const intptr_t depth =
           (function.IsInvokeFieldDispatcher() ||
            function.IsNoSuchMethodDispatcher()) ? 0 : inlining_depth_;
       collected_call_sites_->FindCallSites(callee_graph, depth, &inlined_info_);
 
       // Add the function to the cache.
       if (!in_cache) {
         function_cache_.Add(parsed_function);
       }
 
       // Build succeeded so we restore the bailout jump.
@@ skipping 11 matching lines @@
       // When inlined, we add the guarded fields of the callee to the caller's
       // 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]);
       }
       // When inlined, we add the deferred prefixes of the callee to the
       // caller's list of deferred prefixes.
       caller_graph()->AddToDeferredPrefixes(callee_graph->deferred_prefixes());
 
+      FlowGraphInliner::SetInliningId(*callee_graph,
+          inliner_->NextInlineId(callee_graph->parsed_function()->function()));
       // 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"));
       PRINT_INLINING_TREE(NULL,
           &call_data->caller, &function, call);
       return true;
     } else {
       Error& error = Error::Handle();
       error = isolate()->object_store()->sticky_error();
@@ skipping 367 matching lines @@
       if (arg != NULL) {
         param_stubs->Add(CreateParameterStub(i, arg, callee_graph));
       } else {
         param_stubs->Add(
             GetDefaultValue(i - fixed_param_count, parsed_function));
       }
     }
     return argument_names_count == match_count;
   }
 
+  FlowGraphInliner* inliner_;
   FlowGraph* caller_graph_;
   bool inlined_;
   const intptr_t initial_size_;
   intptr_t inlined_size_;
   bool inlined_recursive_call_;
   intptr_t inlining_depth_;
   intptr_t inlining_recursion_depth_;
   CallSites* collected_call_sites_;
   CallSites* inlining_call_sites_;
   GrowableArray<ParsedFunction*> function_cache_;
@@ skipping 480 matching lines @@
     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()));
   }
 }
 
 
+// TODO(srdjan): This is only needed when disassembling and/or profiling.
+void FlowGraphInliner::SetInliningId(const FlowGraph& flow_graph,
+                                     intptr_t inlining_id) {
+  for (BlockIterator block_it = flow_graph.postorder_iterator();
+       !block_it.Done();
+       block_it.Advance()) {
+    for (ForwardInstructionIterator it(block_it.Current());
+         !it.Done();
+         it.Advance()) {
+      Instruction* current = it.Current();
+      // Do not overwrite owner function.
+      ASSERT(!current->has_inlining_id());
+      current->set_inlining_id(inlining_id);
+    }
+  }
+}
+
+
 bool FlowGraphInliner::AlwaysInline(const Function& function) {
   const char* kAlwaysInlineAnnotation = "AlwaysInline";
   if (FLAG_enable_inlining_annotations &&
       HasAnnotation(function, kAlwaysInlineAnnotation)) {
     TRACE_INLINING(OS::Print("AlwaysInline annotation for %s\n",
                              function.ToCString()));
     return true;
   }
 
   if (function.IsImplicitGetterFunction() || function.IsGetterFunction() ||
@@ skipping 21 matching lines @@
   TRACE_INLINING(OS::Print("Inlining calls in %s\n", top.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(this);
   inliner.InlineCalls();
   if (FLAG_print_inlining_tree) {
     inliner.PrintInlinedInfo(top);
   }
 
   if (inliner.inlined()) {
     flow_graph_->DiscoverBlocks();
     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();
       }
     }
   }
 }
 
+
+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