Fix inlining information:

runtime/vm/flow_graph_compiler.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/globals.h"  // Needed here to get TARGET_ARCH_XXX.
 
 #include "vm/flow_graph_compiler.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cha.h"
@@ skipping 407 matching lines @@
 }
 
 
 // We collect intervals while generating code.
 struct IntervalStruct {
   // 'start' and 'end' are pc-offsets.
   intptr_t start;
   intptr_t inlining_id;
   IntervalStruct(intptr_t s, intptr_t id) : start(s), inlining_id(id) {}
   void Dump() {
-    OS::Print("start: %" Px " id: %" Pd "",  start, inlining_id);
+    ISL_Print("start: 0x%" Px " iid: %" Pd " ",  start, inlining_id);
   }
 };
 
 
 void FlowGraphCompiler::VisitBlocks() {
   CompactBlocks();
   const ZoneGrowableArray<BlockEntryInstr*>* loop_headers = NULL;
   if (Assembler::EmittingComments()) {
     // 'loop_headers' were cleared, recompute.
     loop_headers = flow_graph().ComputeLoops();
@@ skipping 24 matching lines @@
     LoopInfoComment(assembler(), *entry, *loop_headers);
 
     entry->set_offset(assembler()->CodeSize());
     entry->EmitNativeCode(this);
     // Compile all successors until an exit, branch, or a block entry.
     for (ForwardInstructionIterator it(entry); !it.Done(); it.Advance()) {
       Instruction* instr = it.Current();
       // Compose intervals.
       if (instr->has_inlining_id() && is_optimizing()) {
         if (prev_inlining_id != instr->inlining_id()) {
-          intervals.Add(IntervalStruct(prev_offset,
-                                       prev_inlining_id));
+          intervals.Add(IntervalStruct(prev_offset, prev_inlining_id));
           prev_offset = assembler()->CodeSize();
           prev_inlining_id = instr->inlining_id();
           if (prev_inlining_id > max_inlining_id) {
             max_inlining_id = prev_inlining_id;
           }
         }
       }
       if (FLAG_code_comments ||
-          FLAG_disassemble ||
-          FLAG_disassemble_optimized) {
+          FLAG_disassemble || FLAG_disassemble_optimized) {
         if (FLAG_source_lines) {
           EmitSourceLine(instr);
         }
         EmitComment(instr);
       }
       if (instr->IsParallelMove()) {
         parallel_move_resolver_.EmitNativeCode(instr->AsParallelMove());
       } else {
         EmitInstructionPrologue(instr);
         ASSERT(pending_deoptimization_env_ == NULL);
@@ skipping 14 matching lines @@
     ASSERT(is_optimizing() || FrameStateIsSafeToCall());
 #endif
   }
 
   if (inline_id_to_function_.length() > max_inlining_id + 1) {
     // TODO(srdjan): Some inlined function can disappear,
     // truncate 'inline_id_to_function_'.
   }
 
   if (is_optimizing()) {
+    LogBlock lb(Isolate::Current());
     intervals.Add(IntervalStruct(prev_offset, prev_inlining_id));
     inlined_code_intervals_ =
         Array::New(intervals.length() * Code::kInlIntNumEntries, Heap::kOld);
     Smi& start_h = Smi::Handle();
     Smi& caller_inline_id = Smi::Handle();
     Smi& inline_id = Smi::Handle();
     for (intptr_t i = 0; i < intervals.length(); i++) {
       if (FLAG_trace_inlining_intervals && is_optimizing()) {
-        const Function* function =
-            inline_id_to_function_.At(intervals[i].inlining_id);
+        const Function& function =
+            *inline_id_to_function_.At(intervals[i].inlining_id);
         intervals[i].Dump();
-        OS::Print(" %s parent %" Pd "\n",
-            function->ToQualifiedCString(),
-            caller_inline_id_[intervals[i].inlining_id]);
+        ISL_Print(" parent iid %" Pd " %s\n",
+            caller_inline_id_[intervals[i].inlining_id],
+            function.ToQualifiedCString());
       }
+
       const intptr_t id = intervals[i].inlining_id;
       start_h = Smi::New(intervals[i].start);
       inline_id = Smi::New(id);
       caller_inline_id = Smi::New(caller_inline_id_[intervals[i].inlining_id]);
 
       const intptr_t p = i * Code::kInlIntNumEntries;
       inlined_code_intervals_.SetAt(p + Code::kInlIntStart, start_h);
       inlined_code_intervals_.SetAt(p + Code::kInlIntInliningId, inline_id);
-      inlined_code_intervals_.SetAt(
-          p + Code::kInlIntCallerId, caller_inline_id);
     }
   }
   set_current_block(NULL);
   if (FLAG_trace_inlining_intervals && is_optimizing()) {
-    OS::Print("Intervals:\n");
+    LogBlock lb(Isolate::Current());
+    ISL_Print("Intervals:\n");
+    for (intptr_t cc = 0; cc < caller_inline_id_.length(); cc++) {
+      ISL_Print("  iid: %" Pd " caller iid: %" Pd "\n",
+          cc, caller_inline_id_[cc]);
+    }
     Smi& temp = Smi::Handle();
     for (intptr_t i = 0; i < inlined_code_intervals_.Length();
          i += Code::kInlIntNumEntries) {
       temp ^= inlined_code_intervals_.At(i + Code::kInlIntStart);
       ASSERT(!temp.IsNull());
-      OS::Print("% " Pd " start: %" Px " ", i, temp.Value());
+      ISL_Print("% " Pd " start: 0x%" Px " ", i, temp.Value());
       temp ^= inlined_code_intervals_.At(i + Code::kInlIntInliningId);
-      OS::Print("inl-id: %" Pd " ", temp.Value());
-      temp ^= inlined_code_intervals_.At(i + Code::kInlIntCallerId);
-      OS::Print("caller-id: %" Pd " \n", temp.Value());
+      ISL_Print("iid: %" Pd " ", temp.Value());
     }
   }
 }
 
 
 void FlowGraphCompiler::Bailout(const char* reason) {
   const Function& function = parsed_function_.function();
   Report::MessageF(Report::kBailout,
                    Script::Handle(function.script()),
                    function.token_pos(),
@@ skipping 1121 matching lines @@
   }
   const Array& res = Array::Handle(
       Array::New(inline_id_to_function_.length(), Heap::kOld));
   for (intptr_t i = 0; i < inline_id_to_function_.length(); i++) {
     res.SetAt(i, *inline_id_to_function_[i]);
   }
   return res.raw();
 }
 
 
+RawArray* FlowGraphCompiler::CallerInliningIdMap() const {
+  if (caller_inline_id_.length() == 0) {
+    return Object::empty_array().raw();
+  }
+  const Array& res = Array::Handle(
+      Array::New(caller_inline_id_.length(), Heap::kOld));
+  Smi& smi = Smi::Handle();
+  for (intptr_t i = 0; i < caller_inline_id_.length(); i++) {
+    smi = Smi::New(caller_inline_id_[i]);
+    res.SetAt(i, smi);
+  }
+  return res.raw();
+}
+
+
 void FlowGraphCompiler::EmitPolymorphicInstanceCall(
     const ICData& ic_data,
     intptr_t argument_count,
     const Array& argument_names,
     intptr_t deopt_id,
     intptr_t token_pos,
     LocationSummary* locs) {
   if (FLAG_polymorphic_with_deopt) {
     Label* deopt = AddDeoptStub(deopt_id,
                                 ICData::kDeoptPolymorphicInstanceCallTestFail);
@@ skipping 89 matching lines @@
 
 
 void FlowGraphCompiler::FrameStateClear() {
   ASSERT(!is_optimizing());
   frame_state_.TruncateTo(0);
 }
 #endif
 
 
 }  // namespace dart