Add source position information to profile

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/log.h"
 #include "vm/native_symbol.h"
 #include "vm/object.h"
 #include "vm/os.h"
 #include "vm/profiler.h"
 #include "vm/reusable_handles.h"
 #include "vm/scope_timer.h"
 
 namespace dart {
 
 DECLARE_FLAG(int, max_profile_depth);
@@ skipping 64 matching lines @@
     return size;
   }
 
   // Array holding code that is being kept around only for the profiler.
   const GrowableObjectArray& previous_;
   // Array holding code that should continue to be kept around for the profiler.
   const GrowableObjectArray& current_;
 };
 
 
+ProfileFunctionSourcePosition::ProfileFunctionSourcePosition(
+    TokenPosition token_pos)
+    : token_pos_(token_pos),
+      exclusive_ticks_(0),
+      inclusive_ticks_(0) {
+}
+
+
+void ProfileFunctionSourcePosition::Tick(bool exclusive) {
+  if (exclusive) {
+    exclusive_ticks_++;
+  } else {
+    inclusive_ticks_++;
+  }
+}
+
+
 ProfileFunction::ProfileFunction(Kind kind,
                   const char* name,
                   const Function& function,
                   const intptr_t table_index)
     : kind_(kind),
       name_(name),
       function_(Function::ZoneHandle(function.raw())),
       table_index_(table_index),
       profile_codes_(0),
+      source_position_ticks_(0),
       exclusive_ticks_(0),
       inclusive_ticks_(0),
       inclusive_serial_(-1) {
   ASSERT((kind_ != kDartFunction) || !function_.IsNull());
   ASSERT((kind_ != kDartFunction) || (table_index_ >= 0));
   ASSERT(profile_codes_.length() == 0);
 }
 
 
 const char* ProfileFunction::Name() const {
   if (name_ != NULL) {
     return name_;
   }
   ASSERT(!function_.IsNull());
   const String& func_name =
       String::Handle(function_.QualifiedUserVisibleName());
   return func_name.ToCString();
 }
 
-void ProfileFunction::Tick(bool exclusive, intptr_t inclusive_serial) {
+
+void ProfileFunction::Tick(bool exclusive,
+                           intptr_t inclusive_serial,
+                           TokenPosition token_position) {
   if (exclusive) {
     exclusive_ticks_++;
+    TickSourcePosition(token_position, exclusive);
   }
   // Fall through and tick inclusive count too.
   if (inclusive_serial_ == inclusive_serial) {
     // Already ticked.
     return;
   }
   inclusive_serial_ = inclusive_serial;
   inclusive_ticks_++;
+  TickSourcePosition(token_position, false);
 }
 
 
+void ProfileFunction::TickSourcePosition(TokenPosition token_position,
+                                         bool exclusive) {
+  for (intptr_t i = 0; i < source_position_ticks_.length(); i++) {
+    ProfileFunctionSourcePosition& position = source_position_ticks_[i];
+    if (position.token_pos() == token_position) {
+      // Found existing position, tick it.
+      position.Tick(exclusive);
+      return;
+    }
+  }
+  // Add new one.
+  ProfileFunctionSourcePosition pfsp(token_position);
+  pfsp.Tick(exclusive);
+  source_position_ticks_.Add(pfsp);
+}
+
+
 const char* ProfileFunction::KindToCString(Kind kind) {
   switch (kind) {
     case kDartFunction:
       return "Dart";
     case kNativeFunction:
       return "Native";
     case kTagFunction:
       return "Tag";
     case kStubFunction:
       return "Stub";
@@ skipping 38 matching lines @@
 void ProfileFunction::AddProfileCode(intptr_t code_table_index) {
   for (intptr_t i = 0; i < profile_codes_.length(); i++) {
     if (profile_codes_[i] == code_table_index) {
       return;
     }
   }
   profile_codes_.Add(code_table_index);
 }
 
 
+bool ProfileFunction::GetSinglePosition(ProfileFunctionSourcePosition* pfsp) {
+  if (pfsp == NULL) {
+    return false;
+  }
+  if (source_position_ticks_.length() != 1) {
+    return false;
+  }
+  *pfsp = source_position_ticks_[0];
+  return true;
+}
+
+
 ProfileCodeAddress::ProfileCodeAddress(uword pc)
     : pc_(pc),
       exclusive_ticks_(0),
       inclusive_ticks_(0) {
 }
 
 
 void ProfileCodeAddress::Tick(bool exclusive) {
   if (exclusive) {
     exclusive_ticks_++;
@@ skipping 1179 matching lines @@
       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;
+    GrowableArray<TokenPosition> inlined_token_positions;
+    TokenPosition token_position = TokenPosition::kNoSource;
     if (!code.IsNull()) {
       intptr_t offset = pc - code.EntryPoint();
       if (frame_index != 0) {
         // The PC of frames below the top frame is a call's return address,
         // which can belong to a different inlining interval than the call.
         offset--;
+      } else if (sample->IsAllocationSample()) {
+        // Allocation samples skip the top frame, so the top frame's pc is
+        // also a call's return address.
+        offset--;
       }
-      code.GetInlinedFunctionsAt(offset, &inlined_functions);
+      code.GetInlinedFunctionsAt(offset,
+                                 &inlined_functions,
+                                 &inlined_token_positions);
+      token_position = code.GetTokenPositionAt(offset);
+      if (inlined_functions.length() > 0) {
+        // 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.
+        inlined_token_positions.InsertAt(0, token_position);
+      }
+      ASSERT(inlined_functions.length() <= inlined_token_positions.length());
+      if (FLAG_trace_profiler) {
+        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.length() == 0)) {
       // 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];
         ASSERT(inlined_function != NULL);
         ASSERT(!inlined_function->IsNull());
+        TokenPosition inlined_token_position = inlined_token_positions[i];
         const bool inliner = i == (inlined_functions.length() - 1);
         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];
         ASSERT(inlined_function != NULL);
         ASSERT(!inlined_function->IsNull());
+        TokenPosition inlined_token_position = inlined_token_positions[i];
         const bool inliner = i == (inlined_functions.length() - 1);
         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,
+      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) {
     if (frame_index != 0) {
       return true;
     }
     // Only tick the first frame's node, if we are executing OR
     // vm tags have been emitted.
     return IsExecutingFrame(sample, frame_index) || vm_tags_emitted();
   }
 
   ProfileFunctionTrieNode* ProcessFunction(ProfileFunctionTrieNode* current,
                                            intptr_t sample_index,
                                            ProcessedSample* sample,
                                            intptr_t frame_index,
                                            ProfileFunction* function,
+                                           TokenPosition token_position,
                                            intptr_t code_index) {
+    if (FLAG_trace_profiler) {
+      THR_Print("S[%" Pd "]F[%" Pd "] %s %s\n",
+                sample_index,
+                frame_index,
+                function->Name(), token_position.ToCString());
+    }
     if (tick_functions_) {
-      function->Tick(IsExecutingFrame(sample, frame_index), sample_index);
+      function->Tick(IsExecutingFrame(sample, frame_index),
+                     sample_index,
+                     token_position);
     }
     function->AddProfileCode(code_index);
     current = current->GetChild(function->table_index());
     if (ShouldTickNode(sample, frame_index)) {
       current->Tick();
     }
     current->AddCodeObjectIndex(code_index);
     return current;
   }
 
@@ skipping 727 matching lines @@
     ProfileCode* code = profile_->GetCode(current_->table_index());
     return code->exclusive_ticks();
   } else {
     ProfileFunction* func = profile_->GetFunction(current_->table_index());
     return func->exclusive_ticks();
   }
   UNREACHABLE();
 }
 
 
+const char* ProfileTrieWalker::CurrentToken() {
+  if (current_ == NULL) {
+    return NULL;
+  }
+  if (code_trie_) {
+    return NULL;
+  }
+  ProfileFunction* func = profile_->GetFunction(current_->table_index());
+  const Function& function = Function::Handle(func->function());
+  if (function.IsNull()) {
+    // No function.
+    return NULL;
+  }
+  const Script& script = Script::Handle(function.script());
+  if (script.IsNull()) {
+    // No script.
+    return NULL;
+  }
+  const TokenStream& token_stream = TokenStream::Handle(script.tokens());
+  if (token_stream.IsNull()) {
+    // No token position.
+    return NULL;
+  }
+  ProfileFunctionSourcePosition pfsp(TokenPosition::kNoSource);
+  if (!func->GetSinglePosition(&pfsp)) {
+    // Not exactly one source position.
+    return NULL;
+  }
+  TokenPosition token_pos = pfsp.token_pos();
+  if (!token_pos.IsReal() && !token_pos.IsSynthetic()) {
+    // Not a location in a script.
+    return NULL;
+  }
+  if (token_pos.IsSynthetic()) {
+    token_pos = token_pos.FromSynthetic();
+  }
+  TokenStream::Iterator iterator(token_stream, token_pos);
+  const String& str = String::Handle(iterator.CurrentLiteral());
+  if (str.IsNull()) {
+    return NULL;
+  }
+  return str.ToCString();
+}
+
 bool ProfileTrieWalker::Down() {
   if ((current_ == NULL) || (current_->NumChildren() == 0)) {
     return false;
   }
   parent_ = current_;
   current_ = current_->At(0);
   return true;
 }
 
 
@@ skipping 146 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