Expand SW calltree interface to allow expanding and modifying CallTree. Needed for...
[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 class FrameFuncStepperImpl;
106 class SW_EXPORT FrameFuncStepper : public FrameStepper {
107 private:
108    FrameFuncStepperImpl *impl;
109 public:
110   FrameFuncStepper(Walker *w, FrameFuncHelper *helper = NULL);
111   virtual gcframe_ret_t getCallerFrame(const Frame &in, Frame &out);
112   virtual unsigned getPriority() const;
113   virtual ~FrameFuncStepper();
114   virtual void registerStepperGroup(StepperGroup *group);
115   virtual const char *getName() const;
116 };
117
118 class DebugStepperImpl;
119 class SW_EXPORT DebugStepper : public FrameStepper {
120 private:
121    DebugStepperImpl *impl;
122 public:
123   DebugStepper(Walker *w);
124   virtual gcframe_ret_t getCallerFrame(const Frame &in, Frame &out);
125   virtual unsigned getPriority() const;
126   virtual void registerStepperGroup(StepperGroup *group);
127   virtual ~DebugStepper();  
128   virtual const char *getName() const;
129 };
130
131 class CallChecker;
132 class SW_EXPORT WandererHelper
133 {
134  private:
135    ProcessState *proc;
136    CallChecker * callchecker;
137  public:
138    typedef enum {
139       unknown_s = 0,
140       in_func,
141       outside_func
142    } pc_state;
143    WandererHelper(ProcessState *proc_);
144    virtual bool isPrevInstrACall(Address addr, Address &target);
145    virtual pc_state isPCInFunc(Address func_entry, Address pc);
146    virtual bool requireExactMatch();
147    virtual ~WandererHelper();
148 };
149
150 class StepperWandererImpl;
151 class SW_EXPORT StepperWanderer : public FrameStepper {
152  private:
153    StepperWandererImpl *impl;
154  public:
155    StepperWanderer(Walker *w, WandererHelper *whelper = NULL, 
156                    FrameFuncHelper *fhelper = NULL);
157    virtual gcframe_ret_t getCallerFrame(const Frame &in, Frame &out);
158    virtual unsigned getPriority() const;
159    virtual void registerStepperGroup(StepperGroup *group);
160    virtual ~StepperWanderer();
161    virtual const char *getName() const;
162 };
163
164 class SigHandlerStepperImpl;
165 class SW_EXPORT SigHandlerStepper : public FrameStepper {
166  private:
167    SigHandlerStepperImpl *impl;
168  public:
169    SigHandlerStepper(Walker *w);
170    virtual gcframe_ret_t getCallerFrame(const Frame &in, Frame &out);
171    virtual unsigned getPriority() const;
172    virtual void newLibraryNotification(LibAddrPair *la, lib_change_t change);
173    virtual void registerStepperGroup(StepperGroup *group);
174    virtual ~SigHandlerStepper();  
175    virtual const char *getName() const;
176 };
177
178 class BottomOfStackStepperImpl;
179 class SW_EXPORT BottomOfStackStepper : public FrameStepper {
180  private:
181    BottomOfStackStepperImpl *impl;
182  public:
183    BottomOfStackStepper(Walker *w);
184    virtual gcframe_ret_t getCallerFrame(const Frame &in, Frame &out);
185    virtual unsigned getPriority() const;
186    virtual void newLibraryNotification(LibAddrPair *la, lib_change_t change);
187    virtual void registerStepperGroup(StepperGroup *group);
188    virtual ~BottomOfStackStepper();
189    virtual const char *getName() const;
190 };
191
192 class DyninstInstrStepperImpl;
193 class SW_EXPORT DyninstInstrStepper : public FrameStepper {
194  private:
195    DyninstInstrStepperImpl *impl;
196  public:
197    DyninstInstrStepper(Walker *w);
198    virtual gcframe_ret_t getCallerFrame(const Frame &in, Frame &out);
199    virtual unsigned getPriority() const;
200    virtual void registerStepperGroup(StepperGroup *group);
201    virtual ~DyninstInstrStepper();
202    virtual const char *getName() const;
203 };
204
205 class AnalysisStepperImpl;
206 class SW_EXPORT AnalysisStepper : public FrameStepper {
207   private:
208    AnalysisStepperImpl *impl;
209   public:
210    AnalysisStepper(Walker *w);
211    virtual gcframe_ret_t getCallerFrame(const Frame &in, Frame &out);
212    virtual unsigned getPriority() const;
213    virtual void registerStepperGroup(StepperGroup *group);
214    virtual ~AnalysisStepper();
215    virtual const char *getName() const;
216 };
217
218 class SW_EXPORT DyninstDynamicHelper
219 {
220  public:
221    virtual bool isInstrumentation(Address ra, Address *orig_ra,
222                                   unsigned *stack_height, bool *aligned, bool *entryExit) = 0;
223    virtual ~DyninstDynamicHelper();
224 };
225
226 class DyninstDynamicStepperImpl;
227 class SW_EXPORT DyninstDynamicStepper : public FrameStepper {
228  private:
229    DyninstDynamicStepperImpl *impl;
230  public:
231    DyninstDynamicStepper(Walker *w, DyninstDynamicHelper *dihelper = NULL);
232    virtual gcframe_ret_t getCallerFrame(const Frame &in, Frame &out);
233    virtual unsigned getPriority() const;
234    virtual void registerStepperGroup(StepperGroup *group);
235    virtual ~DyninstDynamicStepper();
236    virtual const char *getName() const;
237 };
238
239 }
240 }
241
242 #endif