New walker to walk out of Instrimentation Frames FP
[dyninst.git] / stackwalk / h / framestepper.h
1 /*
2  * See the dyninst/COPYRIGHT file for copyright information.
3  *
4  * We provide the Paradyn Tools (below described as "Paradyn")
5  * on an AS IS basis, and do not warrant its validity or performance.
6  * We reserve the right to update, modify, or discontinue this
7  * software at any time.  We shall have no obligation to supply such
8  * updates or modifications or any other form of support to you.
9  *
10  * By your use of Paradyn, you understand and agree that we (or any
11  * other person or entity with proprietary rights in Paradyn) are
12  * under no obligation to provide either maintenance services,
13  * update services, notices of latent defects, or correction of
14  * defects for Paradyn.
15  *
16  * This library is free software; you can redistribute it and/or
17  * modify it under the terms of the GNU Lesser General Public
18  * License as published by the Free Software Foundation; either
19  * version 2.1 of the License, or (at your option) any later version.
20  *
21  * This library is distributed in the hope that it will be useful,
22  * but WITHOUT ANY WARRANTY; without even the implied warranty of
23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
24  * Lesser General Public License for more details.
25  *
26  * You should have received a copy of the GNU Lesser General Public
27  * License along with this library; if not, write to the Free Software
28  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
29  */
30
31 #ifndef FRAMESTEPPER_H_
32 #define FRAMESTEPPER_H_
33
34 #include "basetypes.h"
35 #include "procstate.h"
36 #include <vector>
37
38 namespace Dyninst {
39
40 namespace SymtabAPI {
41    class Symtab;
42 }
43
44 namespace Stackwalker {
45
46 class Walker;
47 class Frame;
48 class ProcessState;
49 class StepperGroup;
50
51 typedef enum { gcf_success, gcf_stackbottom, gcf_not_me, gcf_error } gcframe_ret_t;
52
53 class SW_EXPORT FrameStepper {
54 protected:
55   Walker *walker;
56 public:
57   FrameStepper(Walker *w);
58
59   virtual gcframe_ret_t getCallerFrame(const Frame &in, Frame &out) = 0;
60   virtual unsigned getPriority() const = 0;
61
62   virtual ProcessState *getProcessState();
63   virtual Walker *getWalker();
64
65   virtual void newLibraryNotification(LibAddrPair *libaddr,
66                                       lib_change_t change);
67   virtual void registerStepperGroup(StepperGroup *group);
68   virtual const char *getName() const = 0;
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 analysis_priority = 0x10058;
77   static const unsigned debugstepper_priority = 0x10040;
78   static const unsigned frame_priority = 0x10050;
79   static const unsigned wanderer_priority = 0x10060;
80 };
81
82 class SW_EXPORT FrameFuncHelper
83 {
84  protected:
85    ProcessState *proc;
86  public:
87    typedef enum {
88       unknown_t=0,
89       no_frame,
90       standard_frame,
91       savefp_only_frame,
92    } frame_type;
93    typedef enum {
94       unknown_s=0,
95       unset_frame,
96       halfset_frame,
97       set_frame
98    } frame_state;
99    typedef std::pair<frame_type, frame_state> alloc_frame_t;
100    FrameFuncHelper(ProcessState *proc_);
101    virtual alloc_frame_t allocatesFrame(Address addr) = 0;
102    virtual ~FrameFuncHelper();
103 };
104
105 /*
106 class ARM_FrameHelper : public FrameFuncHelper {
107   private:
108     //PCProcess *proc_;
109
110   public:
111     //ARM_FrameHelper(PCProcess *pc);
112     virtual FrameFuncHelper::alloc_frame_t allocatesFrame(Address addr);
113     virtual ~ARM_FrameHelper();
114 };
115 */
116
117 class FrameFuncStepperImpl;
118 class SW_EXPORT FrameFuncStepper : public FrameStepper {
119 private:
120    FrameFuncStepperImpl *impl;
121 public:
122   FrameFuncStepper(Walker *w, FrameFuncHelper *helper = NULL);
123   virtual gcframe_ret_t getCallerFrame(const Frame &in, Frame &out);
124   virtual unsigned getPriority() const;
125   virtual ~FrameFuncStepper();
126   virtual void registerStepperGroup(StepperGroup *group);
127   virtual const char *getName() const;
128 };
129
130 class DebugStepperImpl;
131 class SW_EXPORT DebugStepper : public FrameStepper {
132 private:
133    DebugStepperImpl *impl;
134 public:
135   DebugStepper(Walker *w);
136   virtual gcframe_ret_t getCallerFrame(const Frame &in, Frame &out);
137   virtual unsigned getPriority() const;
138   virtual void registerStepperGroup(StepperGroup *group);
139   virtual ~DebugStepper();
140   virtual const char *getName() const;
141 };
142
143 class CallChecker;
144 class SW_EXPORT WandererHelper
145 {
146  private:
147    ProcessState *proc;
148    CallChecker * callchecker;
149  public:
150    typedef enum {
151       unknown_s = 0,
152       in_func,
153       outside_func
154    } pc_state;
155    WandererHelper(ProcessState *proc_);
156    virtual bool isPrevInstrACall(Address addr, Address &target);
157    virtual pc_state isPCInFunc(Address func_entry, Address pc);
158    virtual bool requireExactMatch();
159    virtual ~WandererHelper();
160 };
161
162 class StepperWandererImpl;
163 class SW_EXPORT StepperWanderer : public FrameStepper {
164  private:
165    StepperWandererImpl *impl;
166  public:
167    StepperWanderer(Walker *w, WandererHelper *whelper = NULL,
168                    FrameFuncHelper *fhelper = NULL);
169    virtual gcframe_ret_t getCallerFrame(const Frame &in, Frame &out);
170    virtual unsigned getPriority() const;
171    virtual void registerStepperGroup(StepperGroup *group);
172    virtual ~StepperWanderer();
173    virtual const char *getName() const;
174 };
175
176 class SigHandlerStepperImpl;
177 class SW_EXPORT SigHandlerStepper : public FrameStepper {
178  private:
179    SigHandlerStepperImpl *impl;
180  public:
181    SigHandlerStepper(Walker *w);
182    virtual gcframe_ret_t getCallerFrame(const Frame &in, Frame &out);
183    virtual unsigned getPriority() const;
184    virtual void newLibraryNotification(LibAddrPair *la, lib_change_t change);
185    virtual void registerStepperGroup(StepperGroup *group);
186    virtual ~SigHandlerStepper();
187    virtual const char *getName() const;
188 };
189
190 class BottomOfStackStepperImpl;
191 class SW_EXPORT BottomOfStackStepper : public FrameStepper {
192  private:
193    BottomOfStackStepperImpl *impl;
194  public:
195    BottomOfStackStepper(Walker *w);
196    virtual gcframe_ret_t getCallerFrame(const Frame &in, Frame &out);
197    virtual unsigned getPriority() const;
198    virtual void newLibraryNotification(LibAddrPair *la, lib_change_t change);
199    virtual void registerStepperGroup(StepperGroup *group);
200    virtual ~BottomOfStackStepper();
201    virtual const char *getName() const;
202 };
203
204 class DyninstInstrStepperImpl;
205 class SW_EXPORT DyninstInstrStepper : public FrameStepper {
206  private:
207    DyninstInstrStepperImpl *impl;
208  public:
209    DyninstInstrStepper(Walker *w);
210    virtual gcframe_ret_t getCallerFrame(const Frame &in, Frame &out);
211    virtual unsigned getPriority() const;
212    virtual void registerStepperGroup(StepperGroup *group);
213    virtual ~DyninstInstrStepper();
214    virtual const char *getName() const;
215 };
216
217 class AnalysisStepperImpl;
218 class SW_EXPORT AnalysisStepper : public FrameStepper {
219   private:
220    AnalysisStepperImpl *impl;
221   public:
222    AnalysisStepper(Walker *w);
223    virtual gcframe_ret_t getCallerFrame(const Frame &in, Frame &out);
224    virtual unsigned getPriority() const;
225    virtual void registerStepperGroup(StepperGroup *group);
226    virtual ~AnalysisStepper();
227    virtual const char *getName() const;
228 };
229
230 class SW_EXPORT DyninstDynamicHelper
231 {
232  public:
233    virtual bool isInstrumentation(Address ra, Address *orig_ra,
234                                   unsigned *stack_height, bool *aligned, bool *entryExit) = 0;
235    virtual ~DyninstDynamicHelper();
236 };
237
238 class DyninstDynamicStepperImpl;
239 class SW_EXPORT DyninstDynamicStepper : public FrameStepper {
240  private:
241    DyninstDynamicStepperImpl *impl;
242  public:
243    DyninstDynamicStepper(Walker *w, DyninstDynamicHelper *dihelper = NULL);
244    virtual gcframe_ret_t getCallerFrame(const Frame &in, Frame &out);
245    virtual unsigned getPriority() const;
246    virtual void registerStepperGroup(StepperGroup *group);
247    virtual ~DyninstDynamicStepper();
248    virtual const char *getName() const;
249 };
250
251 class DyninstInstFrameStepperImpl;
252 class SW_EXPORT DyninstInstFrameStepper : public FrameStepper {
253  private:
254    DyninstInstFrameStepperImpl *impl;
255  public:
256    DyninstInstFrameStepper(Walker *w);
257    virtual gcframe_ret_t getCallerFrame(const Frame &in, Frame &out);
258    virtual unsigned getPriority() const;
259    virtual void registerStepperGroup(StepperGroup *group);
260    virtual ~DyninstInstFrameStepper();
261    virtual const char *getName() const;
262 };
263
264 }
265 }
266
267 #endif