Reapply "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.
-  void GetInlinedFunctionsAt(
+  // The pc offset is interpreted as an instruction address (as needed by the
+  // disassembler or the top frame of a profiler sample).
+  void GetInlinedFunctionsAtInstruction(
       intptr_t pc_offset,
       GrowableArray<const Function*>* functions,
       GrowableArray<TokenPosition>* token_positions) const;
+  // Same as above, expect the pc is intepreted as a return address (as needed
+  // for a stack trace or the bottom frames of a profiler sample).
+  void GetInlinedFunctionsAtReturnAddress(
+      intptr_t pc_offset,
+      GrowableArray<const Function*>* functions,
+      GrowableArray<TokenPosition>* token_positions) const {
+    GetInlinedFunctionsAtInstruction(pc_offset - 1, functions, token_positions);
+  }
 
   NOT_IN_PRODUCT(void PrintJSONInlineIntervals(JSONObject* object) const);
   void DumpInlineIntervals() const;
   void DumpSourcePositions() const;
 
   RawLocalVarDescriptors* var_descriptors() const {
 #if defined(DART_PRECOMPILED_RUNTIME)
     UNREACHABLE();
     return NULL;
 #else
@@ skipping 3588 matching lines @@
   intptr_t Length() const;
 
   RawStackTrace* async_link() const { return raw_ptr()->async_link_; }
   void set_async_link(const StackTrace& async_link) const;
   void set_expand_inlined(bool value) const;
 
   RawArray* code_array() const { return raw_ptr()->code_array_; }
   RawCode* CodeAtFrame(intptr_t frame_index) const;
   void SetCodeAtFrame(intptr_t frame_index, const Code& code) const;
 
-  RawFunction* FunctionAtFrame(intptr_t frame_index) const;
-
   RawArray* pc_offset_array() const { return raw_ptr()->pc_offset_array_; }
   RawSmi* PcOffsetAtFrame(intptr_t frame_index) const;
   void SetPcOffsetAtFrame(intptr_t frame_index, const Smi& pc_offset) const;
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawStackTrace));
   }
   static RawStackTrace* New(const Array& code_array,
                             const Array& pc_offset_array,
                             Heap::Space space = Heap::kNew);
@@ skipping 493 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_