Encode inlining information in CodeSourceMap and remove inlining interval arrays.

runtime/vm/profiler_service.cc

 // Copyright (c) 2015, 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/profiler_service.h"
 
 #include "vm/growable_array.h"
 #include "vm/hash_map.h"
 #include "vm/log.h"
 #include "vm/native_symbol.h"
@@ skipping 1031 matching lines @@
       OS::Print("LOOKUPS: %" Pd " HITS: %" Pd " MISSES: %" Pd "\n", total,
                 cache_hit_, cache_miss_);
     }
   }
 
   void Get(uword pc,
            const Code& code,
            ProcessedSample* sample,
            intptr_t frame_index,
            // Outputs:
-           GrowableArray<Function*>** inlined_functions,
+           GrowableArray<const Function*>** inlined_functions,
            GrowableArray<TokenPosition>** inlined_token_positions,
            TokenPosition* token_position) {
     const intptr_t offset = OffsetForPC(pc, code, sample, frame_index);
     if (FindInCache(pc, offset, inlined_functions, inlined_token_positions,
                     token_position)) {
       // Found in cache.
       return;
     }
     Add(pc, code, sample, frame_index, inlined_functions,
         inlined_token_positions, token_position);
   }
 
  private:
   bool FindInCache(uword pc,
                    intptr_t offset,
-                   GrowableArray<Function*>** inlined_functions,
+                   GrowableArray<const Function*>** inlined_functions,
                    GrowableArray<TokenPosition>** inlined_token_positions,
                    TokenPosition* token_position) {
     // Simple linear scan.
     for (intptr_t i = 0; i < kCacheSize; i++) {
       intptr_t index = (last_hit_ + i) % kCacheSize;
       if ((cache_[index].pc == pc) && (cache_[index].offset == offset)) {
         // Hit.
         if (cache_[index].inlined_functions.length() == 0) {
           *inlined_functions = NULL;
           *inlined_token_positions = NULL;
@@ skipping 10 matching lines @@
     cache_miss_++;
     return false;
   }
 
   // Add to cache and fill in outputs.
   void Add(uword pc,
            const Code& code,
            ProcessedSample* sample,
            intptr_t frame_index,
            // Outputs:
-           GrowableArray<Function*>** inlined_functions,
+           GrowableArray<const Function*>** inlined_functions,
            GrowableArray<TokenPosition>** inlined_token_positions,
            TokenPosition* token_position) {
     const intptr_t offset = OffsetForPC(pc, code, sample, frame_index);
     CacheEntry* cache_entry = &cache_[NextFreeIndex()];
     cache_entry->pc = pc;
     cache_entry->offset = offset;
     code.GetInlinedFunctionsAt(offset, &(cache_entry->inlined_functions),
                                &(cache_entry->inlined_token_positions));
-    cache_entry->token_position = code.GetTokenPositionAt(offset);
-    *token_position = (cache_entry->token_position);
     if (cache_entry->inlined_functions.length() == 0) {
       *inlined_functions = NULL;
       *inlined_token_positions = NULL;
+      *token_position = cache_entry->token_position = TokenPosition();
       return;
     }
-    // The inlined token position table does not include the token position
-    // of the final call. Insert it at the beginning because the table.
-    // is reversed.
-    cache_entry->inlined_token_positions.InsertAt(0,
-                                                  cache_entry->token_position);
 
     // Write outputs.
     *inlined_functions = &(cache_entry->inlined_functions);
     *inlined_token_positions = &(cache_entry->inlined_token_positions);
+    *token_position = cache_entry->token_position =
+        cache_entry->inlined_token_positions[0];
   }
 
   intptr_t NextFreeIndex() {
     cache_cursor_ = (cache_cursor_ + 1) % kCacheSize;
     return cache_cursor_;
   }
 
   intptr_t OffsetForPC(uword pc,
                        const Code& code,
                        ProcessedSample* sample,
@@ skipping 16 matching lines @@
     return offset;
   }
 
   struct CacheEntry {
     void Reset() {
       pc = 0;
       offset = 0;
     }
     uword pc;
     intptr_t offset;
-    GrowableArray<Function*> inlined_functions;
+    GrowableArray<const Function*> inlined_functions;
     GrowableArray<TokenPosition> inlined_token_positions;
     TokenPosition token_position;
   };
 
   static const intptr_t kCacheSize = 128;
   intptr_t cache_cursor_;
   intptr_t last_hit_;
   CacheEntry cache_[kCacheSize];
   intptr_t cache_miss_;
   intptr_t cache_hit_;
@@ skipping 414 matching lines @@
                                         intptr_t sample_index,
                                         ProcessedSample* sample,
                                         intptr_t frame_index) {
     const uword pc = sample->At(frame_index);
     ProfileCode* profile_code = GetProfileCode(pc, sample->timestamp());
     ProfileFunction* function = profile_code->function();
     ASSERT(function != NULL);
     const intptr_t code_index = profile_code->code_table_index();
     ASSERT(profile_code != NULL);
     const Code& code = Code::ZoneHandle(profile_code->code());
-    GrowableArray<Function*>* inlined_functions = NULL;
+    GrowableArray<const Function*>* inlined_functions = NULL;
     GrowableArray<TokenPosition>* inlined_token_positions = NULL;
     TokenPosition token_position = TokenPosition::kNoSource;
     if (!code.IsNull()) {
       inlined_functions_cache_.Get(pc, code, sample, frame_index,
                                    &inlined_functions, &inlined_token_positions,
                                    &token_position);
       if (FLAG_trace_profiler_verbose) {
         for (intptr_t i = 0; i < inlined_functions->length(); i++) {
           const String& name =
               String::Handle((*inlined_functions)[i]->QualifiedScrubbedName());
           THR_Print("InlinedFunction[%" Pd "] = {%s, %s}\n", i,
                     name.ToCString(),
                     (*inlined_token_positions)[i].ToCString());
         }
       }
     }
+
     if (code.IsNull() || (inlined_functions == NULL) ||
-        (inlined_functions->length() == 0)) {
+        (inlined_functions->length() <= 1)) {
       // No inlined functions.
       if (inclusive_tree_) {
         current = AppendKind(code, current);
       }
       current = ProcessFunction(current, sample_index, sample, frame_index,
                                 function, token_position, code_index);
       if (!inclusive_tree_) {
         current = AppendKind(code, current);
       }
       return current;
     }
 
     ASSERT(code.is_optimized());
 
     if (inclusive_tree_) {
-      for (intptr_t i = inlined_functions->length() - 1; i >= 0; i--) {
-        Function* inlined_function = (*inlined_functions)[i];
+      for (intptr_t i = 0; i < inlined_functions->length(); i++) {
+        const Function* inlined_function = (*inlined_functions)[i];
         ASSERT(inlined_function != NULL);
         ASSERT(!inlined_function->IsNull());
         TokenPosition inlined_token_position = (*inlined_token_positions)[i];
-        const bool inliner = i == (inlined_functions->length() - 1);
+        const bool inliner = i == 0;
         if (inliner) {
           current = AppendKind(code, current);
         }
         current = ProcessInlinedFunction(current, sample_index, sample,
                                          frame_index, inlined_function,
                                          inlined_token_position, code_index);
         if (inliner) {
           current = AppendKind(kInlineStart, current);
         }
       }
       current = AppendKind(kInlineFinish, current);
     } else {
       // Append the inlined children.
       current = AppendKind(kInlineFinish, current);
-      for (intptr_t i = 0; i < inlined_functions->length(); i++) {
-        Function* inlined_function = (*inlined_functions)[i];
+      for (intptr_t i = inlined_functions->length() - 1; i >= 0; i--) {
+        const Function* inlined_function = (*inlined_functions)[i];
         ASSERT(inlined_function != NULL);
         ASSERT(!inlined_function->IsNull());
         TokenPosition inlined_token_position = (*inlined_token_positions)[i];
-        const bool inliner = i == (inlined_functions->length() - 1);
+        const bool inliner = i == 0;
         if (inliner) {
           current = AppendKind(kInlineStart, current);
         }
         current = ProcessInlinedFunction(current, sample_index, sample,
                                          frame_index + i, inlined_function,
                                          inlined_token_position, code_index);
         if (inliner) {
           current = AppendKind(code, current);
         }
       }
     }
 
     return current;
   }
 
   ProfileFunctionTrieNode* ProcessInlinedFunction(
       ProfileFunctionTrieNode* current,
       intptr_t sample_index,
       ProcessedSample* sample,
       intptr_t frame_index,
-      Function* inlined_function,
+      const Function* inlined_function,
       TokenPosition inlined_token_position,
       intptr_t code_index) {
     ProfileFunctionTable* function_table = profile_->functions_;
     ProfileFunction* function = function_table->LookupOrAdd(*inlined_function);
     ASSERT(function != NULL);
     return ProcessFunction(current, sample_index, sample, frame_index, function,
                            inlined_token_position, code_index);
   }
 
   bool ShouldTickNode(ProcessedSample* sample, intptr_t frame_index) {
@@ skipping 1080 matching lines @@
   // Disable thread interrupts while processing the buffer.
   DisableThreadInterruptsScope dtis(thread);
 
   ClearProfileVisitor clear_profile(isolate);
   sample_buffer->VisitSamples(&clear_profile);
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart