Merge branch 'dyninst-master' into dyn_pc_integration
[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   virtual const char *getName() const = 0;
70   
71   virtual ~FrameStepper();
72
73   //Default priorities for built in wanderers.
74   static const unsigned stackbottom_priority = 0x10000;
75   static const unsigned dyninstr_priority = 0x10010;
76   static const unsigned sighandler_priority = 0x10020;
77   static const unsigned analysis_priority = 0x10030;
78   static const unsigned debugstepper_priority = 0x10040;
79   static const unsigned frame_priority = 0x10050;
80   static const unsigned wanderer_priority = 0x10060;
81 };
82
83 class FrameFuncHelper
84 {
85  protected:
86    ProcessState *proc;
87  public:
88    typedef enum {
89       unknown_t=0,
90       no_frame,
91       standard_frame,
92       savefp_only_frame,
93    } frame_type;
94    typedef enum {
95       unknown_s=0,
96       unset_frame,
97       halfset_frame,
98       set_frame
99    } frame_state;
100    typedef std::pair<frame_type, frame_state> alloc_frame_t;
101    FrameFuncHelper(ProcessState *proc_);
102    virtual alloc_frame_t allocatesFrame(Address addr) = 0;
103    virtual ~FrameFuncHelper();
104 };
105
106 class FrameFuncStepperImpl;
107 class FrameFuncStepper : public FrameStepper {
108 private:
109    FrameFuncStepperImpl *impl;
110 public:
111   FrameFuncStepper(Walker *w, FrameFuncHelper *helper = NULL);
112   virtual gcframe_ret_t getCallerFrame(const Frame &in, Frame &out);
113   virtual unsigned getPriority() const;
114   virtual ~FrameFuncStepper();
115   virtual void registerStepperGroup(StepperGroup *group);
116   virtual const char *getName() const;
117 };
118
119 class DebugStepperImpl;
120 class DebugStepper : public FrameStepper {
121 private:
122    DebugStepperImpl *impl;
123 public:
124   DebugStepper(Walker *w);
125   virtual gcframe_ret_t getCallerFrame(const Frame &in, Frame &out);
126   virtual unsigned getPriority() const;
127   virtual void registerStepperGroup(StepperGroup *group);
128   virtual ~DebugStepper();  
129   virtual const char *getName() const;
130 };
131
132 class WandererHelper
133 {
134  private:
135    ProcessState *proc;
136  public:
137    typedef enum {
138       unknown_s = 0,
139       in_func,
140       outside_func
141    } pc_state;
142    WandererHelper(ProcessState *proc_);
143    virtual bool isPrevInstrACall(Address addr, Address &target);
144    virtual pc_state isPCInFunc(Address func_entry, Address pc);
145    virtual bool requireExactMatch();
146    virtual ~WandererHelper();
147 };
148
149 class StepperWandererImpl;
150 class StepperWanderer : public FrameStepper {
151  private:
152    StepperWandererImpl *impl;
153  public:
154    StepperWanderer(Walker *w, WandererHelper *whelper = NULL, 
155                    FrameFuncHelper *fhelper = NULL);
156    virtual gcframe_ret_t getCallerFrame(const Frame &in, Frame &out);
157    virtual unsigned getPriority() const;
158    virtual void registerStepperGroup(StepperGroup *group);
159    virtual ~StepperWanderer();
160    virtual const char *getName() const;
161 };
162
163 class SigHandlerStepperImpl;
164 class SigHandlerStepper : public FrameStepper {
165  private:
166    SigHandlerStepperImpl *impl;
167  public:
168    SigHandlerStepper(Walker *w);
169    virtual gcframe_ret_t getCallerFrame(const Frame &in, Frame &out);
170    virtual unsigned getPriority() const;
171    virtual void newLibraryNotification(LibAddrPair *la, lib_change_t change);
172    virtual void registerStepperGroup(StepperGroup *group);
173    virtual ~SigHandlerStepper();  
174    virtual const char *getName() const;
175 };
176
177 class BottomOfStackStepperImpl;
178 class BottomOfStackStepper : public FrameStepper {
179  private:
180    BottomOfStackStepperImpl *impl;
181  public:
182    BottomOfStackStepper(Walker *w);
183    virtual gcframe_ret_t getCallerFrame(const Frame &in, Frame &out);
184    virtual unsigned getPriority() const;
185    virtual void newLibraryNotification(LibAddrPair *la, lib_change_t change);
186    virtual void registerStepperGroup(StepperGroup *group);
187    virtual ~BottomOfStackStepper();
188    virtual const char *getName() const;
189 };
190
191 class DyninstInstrStepperImpl;
192 class DyninstInstrStepper : public FrameStepper {
193  private:
194    DyninstInstrStepperImpl *impl;
195  public:
196    DyninstInstrStepper(Walker *w);
197    virtual gcframe_ret_t getCallerFrame(const Frame &in, Frame &out);
198    virtual unsigned getPriority() const;
199    virtual void registerStepperGroup(StepperGroup *group);
200    virtual ~DyninstInstrStepper();
201    virtual const char *getName() const;
202 };
203
204 class AnalysisStepperImpl;
205 class AnalysisStepper : public FrameStepper {
206   private:
207    AnalysisStepperImpl *impl;
208   public:
209    AnalysisStepper(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 ~AnalysisStepper();
214    virtual const char *getName() const;
215 };
216
217 class DyninstDynamicHelper
218 {
219  public:
220    virtual bool isInstrumentation(Address ra, Address *orig_ra,
221                                   unsigned *stack_height, bool *entryExit) = 0;
222    virtual ~DyninstDynamicHelper();
223 };
224
225 class DyninstDynamicStepperImpl;
226 class DyninstDynamicStepper : public FrameStepper {
227  private:
228    DyninstDynamicStepperImpl *impl;
229  public:
230    DyninstDynamicStepper(Walker *w, DyninstDynamicHelper *dihelper = NULL);
231    virtual gcframe_ret_t getCallerFrame(const Frame &in, Frame &out);
232    virtual unsigned getPriority() const;
233    virtual void registerStepperGroup(StepperGroup *group);
234    virtual ~DyninstDynamicStepper();
235    virtual const char *getName() const;
236 };
237
238 }
239 }
240
241 #endif