Have StackwalkerAPI use ProcControlAPI for debug interface, works on x86 family
[dyninst.git] / stackwalk / h / procstate.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 //TODO: isRunning(), isStopped()...
33 //TODO: Bug if trying to stop an already stopped process
34
35 #ifndef PROCSTATE_H_
36 #define PROCSTATE_H_
37
38 #include "basetypes.h"
39 #include "dyn_regs.h"
40 #include "Process.h"
41
42 #include <vector>
43 #include <map>
44 #include <queue>
45 #include <string>
46
47 namespace Dyninst {
48 namespace Stackwalker {
49
50 class LibraryState;
51 class ThreadState;
52 class Walker;
53
54 class ProcessState {
55    friend class Walker;
56 protected:
57    Dyninst::PID pid;
58    LibraryState *library_tracker;
59    Walker *walker;
60    static std::map<Dyninst::PID, ProcessState *> proc_map;
61
62    ProcessState(Dyninst::PID pid_ = 0);
63    void setPid(Dyninst::PID pid_);
64 public:
65
66   //look-up Process-State by pid
67   static ProcessState* getProcessStateByPid(Dyninst::PID pid);
68
69   //Read register in thread
70   virtual bool getRegValue(Dyninst::MachRegister reg, Dyninst::THR_ID thread, Dyninst::MachRegisterVal &val) = 0;
71   
72   //Read memory in process
73   virtual bool readMem(void *dest, Dyninst::Address source, size_t size) = 0;
74
75   //Return list of available threads
76   virtual bool getThreadIds(std::vector<Dyninst::THR_ID> &threads) = 0;
77   
78   //Return the default thread
79   virtual bool getDefaultThread(Dyninst::THR_ID &default_tid) = 0;
80
81   //Return PID
82   virtual Dyninst::PID getProcessId();
83
84   //Return the size of an address in process in bytes
85   virtual unsigned getAddressWidth() = 0;
86
87   //Get Architecture, see dyn_regs.h
88   virtual Dyninst::Architecture getArchitecture() = 0;
89
90   virtual ~ProcessState();
91
92   Walker *getWalker() const;
93
94   void setLibraryTracker(LibraryState *);
95   void setDefaultLibraryTracker();
96   virtual LibraryState *getLibraryTracker();
97
98   //Allow initialization/uninitialization
99   virtual bool preStackwalk(Dyninst::THR_ID tid);
100   virtual bool postStackwalk(Dyninst::THR_ID tid);
101
102   virtual bool isFirstParty() = 0;
103 };
104
105 class ProcSelf : public ProcessState {
106  public:
107   ProcSelf();
108   void initialize();
109
110   virtual bool getRegValue(Dyninst::MachRegister reg, Dyninst::THR_ID thread, Dyninst::MachRegisterVal &val);
111   virtual bool readMem(void *dest, Dyninst::Address source, size_t size);
112   virtual bool getThreadIds(std::vector<Dyninst::THR_ID> &threads);
113   virtual bool getDefaultThread(Dyninst::THR_ID &default_tid);
114   virtual unsigned getAddressWidth();
115   virtual bool isFirstParty();
116   virtual Dyninst::Architecture getArchitecture();
117   virtual ~ProcSelf();
118 };
119
120 class ProcDebug : public ProcessState {
121  protected:
122    Dyninst::ProcControlAPI::Process::ptr proc;
123    ProcDebug(Dyninst::ProcControlAPI::Process::ptr p);
124
125    std::set<Dyninst::ProcControlAPI::Thread::ptr> needs_resume;
126  public:
127   
128   static ProcDebug *newProcDebug(Dyninst::PID pid, std::string executable="");
129   static bool newProcDebugSet(const std::vector<Dyninst::PID> &pids,
130                               std::vector<ProcDebug *> &out_set);
131   static ProcDebug *newProcDebug(std::string executable, 
132                                  const std::vector<std::string> &argv);
133   virtual ~ProcDebug();
134
135   virtual bool getRegValue(Dyninst::MachRegister reg, Dyninst::THR_ID thread, Dyninst::MachRegisterVal &val);
136   virtual bool readMem(void *dest, Dyninst::Address source, size_t size);
137   virtual bool getThreadIds(std::vector<Dyninst::THR_ID> &thrds);
138   virtual bool getDefaultThread(Dyninst::THR_ID &default_tid);
139   virtual unsigned getAddressWidth();
140
141   virtual bool preStackwalk(Dyninst::THR_ID tid);
142   virtual bool postStackwalk(Dyninst::THR_ID tid);
143
144   
145   virtual bool pause(Dyninst::THR_ID tid = NULL_THR_ID);
146   virtual bool resume(Dyninst::THR_ID tid = NULL_THR_ID);
147   virtual bool isTerminated();
148
149   virtual bool detach(bool leave_stopped = false);
150
151   Dyninst::ProcControlAPI::Process::ptr getProc();
152
153   static int getNotificationFD();
154   std::string getExecutablePath();
155
156   static bool handleDebugEvent(bool block = false);
157   virtual bool isFirstParty();
158
159   virtual Dyninst::Architecture getArchitecture();
160 };
161
162 class ProcDebug;
163
164 //LibAddrPair.first = path to library, LibAddrPair.second = load address
165 typedef std::pair<std::string, Address> LibAddrPair;
166 typedef enum { library_load, library_unload } lib_change_t;
167 class LibraryState {
168  protected:
169    ProcessState *procstate;
170    std::vector<std::pair<LibAddrPair, unsigned int> > arch_libs;
171  public:
172    LibraryState(ProcessState *parent);
173    virtual bool getLibraryAtAddr(Address addr, LibAddrPair &lib) = 0;
174    virtual bool getLibraries(std::vector<LibAddrPair> &libs) = 0;
175    virtual void notifyOfUpdate() = 0;
176    virtual Address getLibTrapAddress() = 0;
177    virtual bool getLibc(LibAddrPair &lc);
178    virtual bool getLibthread(LibAddrPair &lt);
179    virtual bool getAOut(LibAddrPair &ao) = 0;
180    virtual ~LibraryState();
181
182    virtual bool updateLibsArch(std::vector<std::pair<LibAddrPair, unsigned int> > &alibs);
183 };
184
185 }
186 }
187
188 #endif