More fixes for local variable support for StackwalkerAPI
[dyninst.git] / stackwalk / h / framestepper.h
1 /*
2  * Copyright (c) 1996-2008 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
73 class FrameFuncHelper
74 {
75  protected:
76    ProcessState *proc;
77  public:
78    typedef enum {
79       unknown_t=0,
80       no_frame,
81       standard_frame,
82       savefp_only_frame,
83    } frame_type;
84    typedef enum {
85       unknown_s=0,
86       unset_frame,
87       halfset_frame,
88       set_frame
89    } frame_state;
90    typedef std::pair<frame_type, frame_state> alloc_frame_t;
91    FrameFuncHelper(ProcessState *proc_);
92    virtual alloc_frame_t allocatesFrame(Address addr) = 0;
93    virtual ~FrameFuncHelper();
94 };
95
96 class FrameFuncStepperImpl;
97 class FrameFuncStepper : public FrameStepper {
98 private:
99    FrameFuncStepperImpl *impl;
100 public:
101   FrameFuncStepper(Walker *w, FrameFuncHelper *helper = NULL);
102   virtual gcframe_ret_t getCallerFrame(const Frame &in, Frame &out);
103   virtual unsigned getPriority() const;
104   virtual ~FrameFuncStepper();
105   virtual void registerStepperGroup(StepperGroup *group);
106 };
107
108 class DebugStepperImpl;
109 class DebugStepper : public FrameStepper {
110 private:
111    DebugStepperImpl *impl;
112 public:
113   DebugStepper(Walker *w);
114   virtual gcframe_ret_t getCallerFrame(const Frame &in, Frame &out);
115   virtual unsigned getPriority() const;
116   virtual void registerStepperGroup(StepperGroup *group);
117   virtual ~DebugStepper();  
118 };
119
120 class WandererHelper
121 {
122  private:
123    ProcessState *proc;
124  public:
125    WandererHelper(ProcessState *proc_);
126    virtual bool isPrevInstrACall(Address addr, Address &target);
127    virtual bool isPCInFunc(Address func_entry, Address pc);
128    virtual ~WandererHelper();
129 };
130
131 class StepperWandererImpl;
132 class StepperWanderer : public FrameStepper {
133  private:
134    StepperWandererImpl *impl;
135  public:
136    StepperWanderer(Walker *w, WandererHelper *whelper = NULL, 
137                    FrameFuncHelper *fhelper = NULL);
138    virtual gcframe_ret_t getCallerFrame(const Frame &in, Frame &out);
139    virtual unsigned getPriority() const;
140    virtual ~StepperWanderer();
141 };
142
143 class SigHandlerStepperImpl;
144 class SigHandlerStepper : public FrameStepper {
145  private:
146    SigHandlerStepperImpl *impl;
147  public:
148    SigHandlerStepper(Walker *w);
149    virtual gcframe_ret_t getCallerFrame(const Frame &in, Frame &out);
150    virtual unsigned getPriority() const;
151    virtual void registerStepperGroup(StepperGroup *group);
152    virtual ~SigHandlerStepper();  
153 };
154
155 class BottomOfStackStepperImpl;
156 class BottomOfStackStepper : public FrameStepper {
157  private:
158    BottomOfStackStepperImpl *impl;
159  public:
160    BottomOfStackStepper(Walker *w);
161    virtual gcframe_ret_t getCallerFrame(const Frame &in, Frame &out);
162    virtual unsigned getPriority() const;
163    virtual void registerStepperGroup(StepperGroup *group);
164    virtual ~BottomOfStackStepper();
165 };
166
167 }
168 }
169
170 #endif