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