Use CodeSourceMap for stack traces (still JIT only).

runtime/vm/object.h

 // Copyright (c) 2012, 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.
 
 #ifndef RUNTIME_VM_OBJECT_H_
 #define RUNTIME_VM_OBJECT_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
@@ skipping 4766 matching lines @@
 
   RawArray* inlined_id_to_function() const;
   void set_inlined_id_to_function(const Array& value) const;
 
   // Provides the call stack at the given pc offset, with the top-of-stack in
   // the last element and the root function (this) as the first element, along
   // with the corresponding source positions. Note the token position for each
   // function except the top-of-stack is the position of the call to the next
   // function. The stack will be empty if we lack the metadata to produce it,
   // which happens for stub code.
+  // The pc offset is interpreted as an instruction address (as needed by the
+  // disassembler or the top frame of a profiler sample), rather than a return
+  // address (as needed for a stack trace or the bottom frames of a profiler
+  // sample). Callers with a return address should subtract one.

[Florian Schneider, 2017/02/08 18:55:20]

Subtracting one from from pc_offset is a bit subtle. Maybe it would be better to
have two functions: GetInlinedFunctionsAtReturnAddress and
GetInlinedFunctionsAtPc?

[rmacnak, 2017/02/08 19:24:26]

Added GetInlinedFunctionsAtReturnAddress and switched the stack trace builder to
use it. Leaving the profiler as always using GetInlinedFunctionsAtPc because it
has its own cache based on instruction addresses 

   void GetInlinedFunctionsAt(
       intptr_t pc_offset,
       GrowableArray<const Function*>* functions,
       GrowableArray<TokenPosition>* token_positions) const;
 
   NOT_IN_PRODUCT(void PrintJSONInlineIntervals(JSONObject* object) const);
   void DumpInlineIntervals() const;
   void DumpSourcePositions() const;
 
   RawLocalVarDescriptors* var_descriptors() const {
@@ skipping 3584 matching lines @@
 };
 
 
 // Internal stacktrace object used in exceptions for printing stack traces.
 class StackTrace : public Instance {
  public:
   static const int kPreallocatedStackdepth = 30;
 
   intptr_t Length() const;
 
-  RawFunction* FunctionAtFrame(intptr_t frame_index) const;
-
   RawCode* CodeAtFrame(intptr_t frame_index) const;
   void SetCodeAtFrame(intptr_t frame_index, const Code& code) const;
 
   RawSmi* PcOffsetAtFrame(intptr_t frame_index) const;
   void SetPcOffsetAtFrame(intptr_t frame_index, const Smi& pc_offset) const;
   void set_expand_inlined(bool value) const;
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawStackTrace));
   }
@@ skipping 490 matching lines @@
 
 inline void TypeArguments::SetHash(intptr_t value) const {
   // This is only safe because we create a new Smi, which does not cause
   // heap allocation.
   StoreSmi(&raw_ptr()->hash_, Smi::New(value));
 }
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_OBJECT_H_