Restore code index tracking

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/native_symbol.h"
 #include "vm/object.h"
 #include "vm/os.h"
@@ skipping 1272 matching lines @@
   }
 
   ProfileFunctionTrieNode* ProcessFrame(
       ProfileFunctionTrieNode* current,
       intptr_t sample_index,
       ProcessedSample* sample,
       intptr_t frame_index) {
     const uword pc = sample->At(frame_index);
     ProfileCode* profile_code = GetProfileCode(pc,
                                                sample->timestamp());
+    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;
     if (!code.IsNull()) {
       intptr_t offset = pc - code.EntryPoint();
       code.GetInlinedFunctionsAt(offset, &inlined_functions);
     }
     if (code.IsNull() || (inlined_functions.length() == 0)) {
       // No inlined functions.
       ProfileFunction* function = profile_code->function();
       ASSERT(function != NULL);
       current = ProcessFunction(current,
                                 sample_index,
                                 sample,
                                 frame_index,
-                                function);
+                                function,
+                                code_index);
       return current;
     }
 
     if (inclusive_tree_) {
       for (intptr_t i = inlined_functions.length() - 1; i >= 0; i--) {
         Function* inlined_function = inlined_functions[i];
         ASSERT(inlined_function != NULL);
         ASSERT(!inlined_function->IsNull());
         current = ProcessInlinedFunction(current,
                                          sample_index,
                                          sample,
                                          frame_index,
-                                         inlined_function);
+                                         inlined_function,
+                                         code_index);
       }
     } else {
       for (intptr_t i = 0; i < inlined_functions.length(); i++) {
         Function* inlined_function = inlined_functions[i];
         ASSERT(inlined_function != NULL);
         ASSERT(!inlined_function->IsNull());
         current = ProcessInlinedFunction(current,
                                          sample_index,
                                          sample,
                                          frame_index + i,
-                                         inlined_function);
+                                         inlined_function,
+                                         code_index);
       }
     }
 
     return current;
   }
 
   ProfileFunctionTrieNode* ProcessInlinedFunction(
       ProfileFunctionTrieNode* current,
       intptr_t sample_index,
       ProcessedSample* sample,
       intptr_t frame_index,
-      Function* inlined_function) {
+      Function* inlined_function,
+      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);
+                           function,
+                           code_index);
   }
 
   ProfileFunctionTrieNode* ProcessFunction(ProfileFunctionTrieNode* current,
                                            intptr_t sample_index,
                                            ProcessedSample* sample,
                                            intptr_t frame_index,
-                                           ProfileFunction* function) {
+                                           ProfileFunction* function,
+                                           intptr_t code_index) {
     if (tick_functions_) {
       function->Tick(IsExecutingFrame(sample, frame_index), sample_index);
     }
+    function->AddProfileCode(code_index);
     current = current->GetChild(function->table_index());
+    current->AddCodeObjectIndex(code_index);
     current->Tick();
     return current;
   }
 
   // Tick the truncated tag's inclusive tick count.
   void InclusiveTickTruncatedTag() {
     ProfileCodeTable* tag_table = profile_->tag_code_;
     intptr_t index = tag_table->FindCodeIndexForPC(VMTag::kTruncatedTagId);
     ASSERT(index >= 0);
     ProfileCode* code = tag_table->At(index);
@@ skipping 701 matching lines @@
   ASSERT(sample_buffer != NULL);
 
   ClearProfileVisitor clear_profile(isolate);
   sample_buffer->VisitSamples(&clear_profile);
 
   // Enable profile interrupts.
   Profiler::BeginExecution(isolate);
 }
 
 }  // namespace dart