Encode inlining information in CodeSourceMap and remove inlining interval arrays.

runtime/vm/disassembler.cc

 // Copyright (c) 2011, 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/disassembler.h"
 
 #include "vm/assembler.h"
 #include "vm/deopt_instructions.h"
 #include "vm/globals.h"
 #include "vm/il_printer.h"
 #include "vm/instructions.h"
 #include "vm/json_stream.h"
 #include "vm/log.h"
 #include "vm/os.h"
 #include "vm/code_patcher.h"
 
 
 namespace dart {
 
 #ifndef PRODUCT
 
 DECLARE_FLAG(bool, trace_inlining_intervals);
+DEFINE_FLAG(bool, trace_source_positions, false, "Source position diagnostics");
 
 void DisassembleToStdout::ConsumeInstruction(const Code& code,
                                              char* hex_buffer,
                                              intptr_t hex_size,
                                              char* human_buffer,
                                              intptr_t human_size,
                                              Object* object,
                                              uword pc) {
   static const int kHexColumnWidth = 23;
   uint8_t* pc_ptr = reinterpret_cast<uint8_t*>(pc);
@@ skipping 72 matching lines @@
                                uword end,
                                DisassemblyFormatter* formatter,
                                const Code& code) {
   const Code::Comments& comments =
       code.IsNull() ? Code::Comments::New(0) : code.comments();
   ASSERT(formatter != NULL);
   char hex_buffer[kHexadecimalBufferSize];  // Instruction in hexadecimal form.
   char human_buffer[kUserReadableBufferSize];  // Human-readable instruction.
   uword pc = start;
   intptr_t comment_finger = 0;
-  GrowableArray<Function*> inlined_functions;
+  GrowableArray<const Function*> inlined_functions;
+  GrowableArray<TokenPosition> token_positions;
   while (pc < end) {
     const intptr_t offset = pc - start;
     const intptr_t old_comment_finger = comment_finger;
     while (comment_finger < comments.Length() &&
            comments.PCOffsetAt(comment_finger) <= offset) {
       formatter->Print(
           "        ;; %s\n",
           String::Handle(comments.CommentAt(comment_finger)).ToCString());
       comment_finger++;
     }
     if (old_comment_finger != comment_finger) {
       char str[4000];
       BufferFormatter f(str, sizeof(str));
       // Comment emitted, emit inlining information.
-      code.GetInlinedFunctionsAt(offset, &inlined_functions);
+      code.GetInlinedFunctionsAt(offset, &inlined_functions, &token_positions);
       // Skip top scope function printing (last entry in 'inlined_functions').
       bool first = true;
-      for (intptr_t i = inlined_functions.length() - 2; i >= 0; i--) {
+      for (intptr_t i = 1; i < inlined_functions.length(); i++) {
         const char* name = inlined_functions[i]->ToQualifiedCString();
         if (first) {
           f.Print("        ;; Inlined [%s", name);
           first = false;
         } else {
           f.Print(" -> %s", name);
         }
       }
       if (!first) {
         f.Print("]\n");
@@ skipping 139 matching lines @@
                     start + offset.Value(), cls.ToCString(), code.raw());
         }
       } else {
         THR_Print("  0x%" Px ": %s, %p\n", start + offset.Value(),
                   function.ToFullyQualifiedCString(), code.raw());
       }
     }
     THR_Print("}\n");
   }
   if (optimized && FLAG_trace_inlining_intervals) {
-    code.DumpInlinedIntervals();
+    code.DumpInlineIntervals();
+  }
+  if (FLAG_trace_source_positions) {
+    code.DumpSourcePositions();
   }
 }
 
 
 void Disassembler::DisassembleCode(const Function& function, bool optimized) {
   const char* function_fullname = function.ToFullyQualifiedCString();
   const Code& code = Code::Handle(function.CurrentCode());
   DisassembleCodeHelper(function_fullname, code, optimized);
 }
 
 
 void Disassembler::DisassembleCodeUnoptimized(const Function& function,
                                               bool optimized) {
   const char* function_fullname = function.ToFullyQualifiedCString();
   const Code& code = Code::Handle(function.unoptimized_code());
   DisassembleCodeHelper(function_fullname, code, optimized);
 }
 
 
 #endif  // !PRODUCT
 
 }  // namespace dart