Implement backtracing and toggling of execution tracing in ARM simulator.

runtime/vm/stack_frame.h

 // Copyright (c) 2011, 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 VM_STACK_FRAME_H_
 #define VM_STACK_FRAME_H_
 
 #include "vm/allocation.h"
 #include "vm/object.h"
 #include "vm/stub_code.h"
@@ skipping 18 matching lines @@
 
 
 // Generic stack frame.
 class StackFrame : public ValueObject {
  public:
   virtual ~StackFrame() { }
 
   // Accessors to get the pc, sp and fp of a frame.
   uword sp() const { return sp_; }
   uword fp() const { return fp_; }
-  uword pc() const {
-    return *reinterpret_cast<uword*>(sp_ + (kSavedPcSlotFromSp * kWordSize));
-  }
+  uword pc() const { return pc_; }
 
   // The pool pointer is not implemented on all architectures.
   static int SavedCallerPpSlotFromFp() {
     if (kSavedCallerPpSlotFromFp != kSavedCallerFpSlotFromFp) {
       return kSavedCallerPpSlotFromFp;
     }
     UNREACHABLE();
     return 0;
   }
 
@@ skipping 20 matching lines @@
   virtual bool IsExitFrame() const { return false; }
 
   RawFunction* LookupDartFunction() const;
   RawCode* LookupDartCode() const;
   bool FindExceptionHandler(uword* handler_pc) const;
   // Returns token_pos of the pc(), or -1 if none exists.
   intptr_t GetTokenPos() const;
 
 
  protected:
-  StackFrame() : fp_(0), sp_(0) { }
+  StackFrame() : fp_(0), sp_(0), pc_(0) { }
 
   // Name of the frame, used for generic frame printing functionality.
   virtual const char* GetName() const { return IsStubFrame()? "stub" : "dart"; }
 
  private:
   RawCode* GetCodeObject() const;
 
   uword GetCallerSp() const {
     return fp() + (kCallerSpSlotFromFp * kWordSize);
   }
   uword GetCallerFp() const {
     return *(reinterpret_cast<uword*>(
         fp() + (kSavedCallerFpSlotFromFp * kWordSize)));
   }
+  uword GetCallerPc() const {
+    return *(reinterpret_cast<uword*>(
+        fp() + (kSavedCallerPcSlotFromFp * kWordSize)));
+  }
 
   uword fp_;
   uword sp_;
+  uword pc_;
 
   // The iterators FrameSetIterator and StackFrameIterator set the private
   // fields fp_ and sp_ when they return the respective frame objects.
   friend class FrameSetIterator;
   friend class StackFrameIterator;
   DISALLOW_COPY_AND_ASSIGN(StackFrame);
 };
 
 
 // Exit frame is used to mark the transition from dart code into dart VM
@@ skipping 37 matching lines @@
   virtual const char* GetName() const { return "entry"; }
 
  private:
   EntryFrame() { }
 
   friend class StackFrameIterator;
   DISALLOW_COPY_AND_ASSIGN(EntryFrame);
 };
 
 
-// Iterator for iterating over all frames from the last ExitFrame to the
-// first EntryFrame.
 class StackFrameIterator : public ValueObject {
  public:
   static const bool kValidateFrames = true;
   static const bool kDontValidateFrames = false;
 
+  // Iterators for iterating over all frames from the last ExitFrame to the
+  // first EntryFrame.
   explicit StackFrameIterator(bool validate);
   StackFrameIterator(uword last_fp, bool validate);
 
+  // Iterator for iterating over all frames from the current frame (given by its
+  // fp, sp, and pc) to the first EntryFrame.
+  StackFrameIterator(uword fp, uword sp, uword pc, bool validate);
+
   // Checks if a next frame exists.
   bool HasNextFrame() const { return frames_.fp_ != 0; }
 
   // Get next frame.
   StackFrame* NextFrame();
 
  private:
   // Iterator for iterating over the set of frames (dart or stub) which exist
   // in one EntryFrame and ExitFrame block.
   class FrameSetIterator : public ValueObject {
    public:
     // Checks if a next non entry/exit frame exists in the set.
     bool HasNext() const {
       if (fp_ == 0) {
         return false;
       }
       const uword pc = *(reinterpret_cast<uword*>(
           sp_ + (kSavedPcSlotFromSp * kWordSize)));
       return !StubCode::InInvocationStub(pc);
     }
 
     // Get next non entry/exit frame in the set (assumes a next frame exists).
     StackFrame* NextFrame(bool validate);
 
    private:
-    FrameSetIterator() : fp_(0), sp_(0), stack_frame_() { }
+    FrameSetIterator() : fp_(0), sp_(0), pc_(0), stack_frame_() { }
 
     uword fp_;
     uword sp_;
+    uword pc_;
     StackFrame stack_frame_;  // Singleton frame returned by NextFrame().
 
     friend class StackFrameIterator;
     DISALLOW_COPY_AND_ASSIGN(FrameSetIterator);
   };
 
   // Get next exit frame.
   ExitFrame* NextExitFrame();
 
   // Get next entry frame.
@@ skipping 76 matching lines @@
   GrowableArray<DeoptInstr*> deopt_instructions_;
   Array& object_table_;
 
   DISALLOW_COPY_AND_ASSIGN(InlinedFunctionsIterator);
 };
 
 }  // namespace dart
 
 #endif  // VM_STACK_FRAME_H_