Support for StackwalkerAPI on AIX
[dyninst.git] / stackwalk / h / framestepper.h
1 /*
2  * Copyright (c) 1996-2009 Barton P. Miller
3  * 
4  * We provide the Paradyn Parallel Performance Tools (below
5  * described as "Paradyn") on an AS IS basis, and do not warrant its
6  * validity or performance.  We reserve the right to update, modify,
7  * or discontinue this software at any time.  We shall have no
8  * obligation to supply such updates or modifications or any other
9  * form of support to you.
10  * 
11  * By your use of Paradyn, you understand and agree that we (or any
12  * other person or entity with proprietary rights in Paradyn) are
13  * under no obligation to provide either maintenance services,
14  * update services, notices of latent defects, or correction of
15  * defects for Paradyn.
16  * 
17  * This library is free software; you can redistribute it and/or
18  * modify it under the terms of the GNU Lesser General Public
19  * License as published by the Free Software Foundation; either
20  * version 2.1 of the License, or (at your option) any later version.
21  * 
22  * This library is distributed in the hope that it will be useful,
23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
25  * Lesser General Public License for more details.
26  * 
27  * You should have received a copy of the GNU Lesser General Public
28  * License along with this library; if not, write to the Free Software
29  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
30  */
31
32 #ifndef FRAMESTEPPER_H_
33 #define FRAMESTEPPER_H_
34
35 #include "basetypes.h"
36 #include "procstate.h"
37 #include <vector>
38
39 namespace Dyninst {
40
41 namespace SymtabAPI {
42    class Symtab;
43 }
44
45 namespace Stackwalker {
46
47 class Walker;
48 class Frame;
49 class ProcessState;
50 class StepperGroup;
51
52 typedef enum { gcf_success, gcf_stackbottom, gcf_not_me, gcf_error } gcframe_ret_t;
53
54 class FrameStepper {
55 protected:
56   Walker *walker;
57 public:
58   FrameStepper(Walker *w);
59   
60   virtual gcframe_ret_t getCallerFrame(const Frame &in, Frame &out) = 0;
61   virtual unsigned getPriority() const = 0;  
62
63   virtual ProcessState *getProcessState();
64   virtual Walker *getWalker();
65   
66   virtual void newLibraryNotification(LibAddrPair *libaddr, 
67                                       lib_change_t change);
68   virtual void registerStepperGroup(StepperGroup *group);
69   
70   virtual ~FrameStepper();
71
72   //Default priorities for built in wanderers.
73   static const unsigned stackbottom_priority = 0x10000;
74   static const unsigned dyninstr_priority = 0x10010;
75   static const unsigned sighandler_priority = 0x10020;
76   static const unsigned debugstepper_priority = 0x10030;
77   static const unsigned frame_priority = 0x10040;
78   static const unsigned wanderer_priority = 0x10050;
79 };
80
81 class FrameFuncHelper
82 {
83  protected:
84    ProcessState *proc;
85  public:
86    typedef enum {
87       unknown_t=0,
88       no_frame,
89       standard_frame,
90       savefp_only_frame,
91    } frame_type;
92    typedef enum {
93       unknown_s=0,
94       unset_frame,
95       halfset_frame,
96       set_frame
97    } frame_state;
98    typedef std::pair<frame_type, frame_state> alloc_frame_t;
99    FrameFuncHelper(ProcessState *proc_);
100    virtual alloc_frame_t allocatesFrame(Address addr) = 0;
101    virtual ~FrameFuncHelper();
102 };
103
104 class FrameFuncStepperImpl;
105 class FrameFuncStepper : public FrameStepper {
106 private:
107    FrameFuncStepperImpl *impl;
108 public:
109   FrameFuncStepper(Walker *w, FrameFuncHelper *helper = NULL);
110   virtual gcframe_ret_t getCallerFrame(const Frame &in, Frame &out);
111   virtual unsigned getPriority() const;
112   virtual ~FrameFuncStepper();
113   virtual void registerStepperGroup(StepperGroup *group);
114 };
115
116 class DebugStepperImpl;
117 class DebugStepper : public FrameStepper {
118 private:
119    DebugStepperImpl *impl;
120 public:
121   DebugStepper(Walker *w);
122   virtual gcframe_ret_t getCallerFrame(const Frame &in, Frame &out);
123   virtual unsigned getPriority() const;
124   virtual void registerStepperGroup(StepperGroup *group);
125   virtual ~DebugStepper();  
126 };
127
128 class WandererHelper
129 {
130  private:
131    ProcessState *proc;
132  public:
133    WandererHelper(ProcessState *proc_);
134    virtual bool isPrevInstrACall(Address addr, Address &target);
135    virtual bool isPCInFunc(Address func_entry, Address pc);
136    virtual ~WandererHelper();
137 };
138
139 class StepperWandererImpl;
140 class StepperWanderer : public FrameStepper {
141  private:
142    StepperWandererImpl *impl;
143  public:
144    StepperWanderer(Walker *w, WandererHelper *whelper = NULL, 
145                    FrameFuncHelper *fhelper = NULL);
146    virtual gcframe_ret_t getCallerFrame(const Frame &in, Frame &out);
147    virtual unsigned getPriority() const;
148    virtual void registerStepperGroup(StepperGroup *group);
149    virtual ~StepperWanderer();
150 };
151
152 class SigHandlerStepperImpl;
153 class SigHandlerStepper : public FrameStepper {
154  private:
155    SigHandlerStepperImpl *impl;
156  public:
157    SigHandlerStepper(Walker *w);
158    virtual gcframe_ret_t getCallerFrame(const Frame &in, Frame &out);
159    virtual unsigned getPriority() const;
160    virtual void registerStepperGroup(StepperGroup *group);
161    virtual ~SigHandlerStepper();  
162 };
163
164 class BottomOfStackStepperImpl;
165 class BottomOfStackStepper : public FrameStepper {
166  private:
167    BottomOfStackStepperImpl *impl;
168  public:
169    BottomOfStackStepper(Walker *w);
170    virtual gcframe_ret_t getCallerFrame(const Frame &in, Frame &out);
171    virtual unsigned getPriority() const;
172    virtual void registerStepperGroup(StepperGroup *group);
173    virtual ~BottomOfStackStepper();
174 };
175
176 class DyninstInstrStepperImpl;
177 class DyninstInstrStepper : public FrameStepper {
178  private:
179    DyninstInstrStepperImpl *impl;
180  public:
181    DyninstInstrStepper(Walker *w);
182    virtual gcframe_ret_t getCallerFrame(const Frame &in, Frame &out);
183    virtual unsigned getPriority() const;
184    virtual void registerStepperGroup(StepperGroup *group);
185    virtual ~DyninstInstrStepper();
186 };
187
188 }
189 }
190
191 #endif