Support for conversion from Instruction API objects to Rose SgAsmInstruction objects...
[dyninst.git] / proccontrol / h / PCProcess.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 #if !defined(PROCESSPC_H_)
32 #define PROCESSPC_H_
33
34 #include <string>
35 #include <vector>
36 #include <map>
37 #include <set>
38 #include <iterator>
39
40 #include "dyntypes.h"
41 #include "dyn_regs.h"
42 #include "EventType.h"
43 #include "util.h"
44 #include "PCErrors.h"
45 #include "boost/checked_delete.hpp"
46 #include "boost/shared_ptr.hpp"
47 #include "boost/weak_ptr.hpp"
48 #include "boost/enable_shared_from_this.hpp"
49
50
51 class int_process;
52 class int_breakpoint;
53 class proc_exitstate;
54 class thread_exitstate;
55 class int_library;
56 class int_thread;
57 class int_threadPool;
58 class int_registerPool;
59 class rpc_wrapper;
60 class int_iRPC;
61 class int_notify;
62 class HandlerPool;
63 class MTLock;
64
65 #define PC_VERSION_8_0_0
66 #define PC_VERSION_8_1_0
67 #define PC_VERSION_8_2_0
68
69 #define pc_const_cast boost::const_pointer_cast
70
71 namespace Dyninst {
72
73 class SymbolReaderFactory;
74
75 namespace ProcControlAPI {
76
77    extern PC_EXPORT bool is_restricted_ptrace;
78   
79
80 class Process;
81 class ThreadPool;
82 class Thread;
83 class EventDecoder;
84 class EventGenerator;
85 class EventHandler;
86 class Event;
87 class RegisterPool;
88 class Breakpoint;
89 class ProcessSet;
90 class ThreadSet;
91 class LibraryTracking;
92 class ThreadTracking;
93 class LWPTracking;
94 class CallStackUnwinding;
95 class FollowFork;
96 class SignalMask;
97 class BGQData;
98 class RemoteIO;
99 class MemoryUsage;
100
101 class ExecFileInfo;
102
103 class PC_EXPORT Breakpoint 
104 {
105    friend class ::int_breakpoint;
106    friend void boost::checked_delete<Breakpoint>(Breakpoint *);
107    friend void boost::checked_delete<const Breakpoint>(const Breakpoint *);
108  private:
109    int_breakpoint *llbreakpoint_;
110    Breakpoint();
111    ~Breakpoint();
112  public:
113    static const int BP_X = 1;
114    static const int BP_W = 2;
115    static const int BP_R = 4;
116
117    int_breakpoint *llbp() const;
118    typedef boost::shared_ptr<Breakpoint> ptr;
119    typedef boost::shared_ptr<const Breakpoint> const_ptr;
120    typedef boost::weak_ptr<Breakpoint> weak_ptr;
121
122    static Breakpoint::ptr newBreakpoint();
123    static Breakpoint::ptr newTransferBreakpoint(Dyninst::Address to);
124    static Breakpoint::ptr newTransferOffsetBreakpoint(signed long shift);
125    static Breakpoint::ptr newHardwareBreakpoint(unsigned int mode, unsigned int size);
126
127    void *getData() const;
128    void setData(void *p) const;
129
130    bool isCtrlTransfer() const;
131    Dyninst::Address getToAddress() const;
132
133    void setSuppressCallbacks(bool);
134    bool suppressCallbacks() const;
135 };
136
137 class PC_EXPORT Library
138 {
139    friend class ::int_library;
140    friend void boost::checked_delete<Library>(Library *);
141    friend void boost::checked_delete<const Library>(const Library *);
142  private:
143    int_library *lib;
144    Library();
145    ~Library();
146  public:
147    typedef boost::shared_ptr<Library> ptr;
148    typedef boost::shared_ptr<const Library> const_ptr;
149
150    std::string getName() const;
151    std::string getAbsoluteName() const;
152    Dyninst::Address getLoadAddress() const;
153    Dyninst::Address getDataLoadAddress() const;
154    Dyninst::Address getDynamicAddress() const;
155    int_library *debug() const { return lib; }
156    bool isSharedLib() const;
157
158    void *getData() const;
159    void setData(void *p) const;
160 };
161
162 class PC_EXPORT LibraryPool
163 {
164    friend class ::int_process;
165    friend class Dyninst::ProcControlAPI::Process;
166  private:
167    int_process *proc;
168    LibraryPool();
169    ~LibraryPool();
170  public:
171    class PC_EXPORT iterator  {
172       friend class Dyninst::ProcControlAPI::LibraryPool;
173    private:
174       std::set<int_library *>::iterator int_iter;
175    public:
176       iterator();
177       ~iterator();
178       Library::ptr operator*() const;
179       bool operator==(const iterator &i) const;
180       bool operator!=(const iterator &i) const;
181       LibraryPool::iterator operator++();
182       LibraryPool::iterator operator++(int);
183
184       typedef Library::ptr value_type;
185       typedef int difference_type;
186       typedef Library::ptr *pointer;
187       typedef Library::ptr &reference;
188       typedef std::forward_iterator_tag iterator_category;
189   };
190
191    class PC_EXPORT const_iterator  {
192      friend class Dyninst::ProcControlAPI::LibraryPool;
193   private:
194      std::set<int_library *>::iterator int_iter;
195   public:
196      const_iterator();
197      ~const_iterator();
198      Library::const_ptr operator*() const;
199      bool operator==(const const_iterator &i);
200      bool operator!=(const const_iterator &i);
201      LibraryPool::const_iterator operator++();
202      LibraryPool::const_iterator operator++(int);
203
204       typedef Library::const_ptr value_type;
205       typedef int difference_type;
206       typedef Library::const_ptr *pointer;
207       typedef Library::const_ptr &reference;
208       typedef std::forward_iterator_tag iterator_category;
209   };
210
211   iterator begin();
212   iterator end();
213   const_iterator begin() const;
214   const_iterator end() const;
215
216   size_t size() const;
217
218   Library::ptr getExecutable();
219   Library::const_ptr getExecutable() const;
220
221   Library::ptr getLibraryByName(std::string s);
222   Library::const_ptr getLibraryByName(std::string s) const;
223
224   iterator find(Library::ptr lib);
225   const_iterator find(Library::ptr lib) const;
226
227 };
228
229 class PC_EXPORT IRPC
230 {
231    friend class ::int_iRPC;
232    friend void boost::checked_delete<IRPC>(IRPC *);
233    friend void boost::checked_delete<const IRPC>(const IRPC *);
234  private:
235    rpc_wrapper *wrapper;
236    IRPC(rpc_wrapper *wrapper_);
237    ~IRPC();
238  public:
239          typedef enum {
240           Error = 0,
241           Created = 1,
242           Posted = 2,
243           Running = 3,
244           // Callback = 4,
245           Done = 5 } State;
246
247    typedef boost::shared_ptr<IRPC> ptr;
248    typedef boost::shared_ptr<const IRPC> const_ptr;
249    typedef boost::weak_ptr<IRPC> weak_ptr;
250    
251    static IRPC::ptr createIRPC(void *binary_blob, unsigned size, 
252                                bool non_blocking = false);
253    static IRPC::ptr createIRPC(void *binary_blob, unsigned size,
254                                Dyninst::Address addr, bool non_blocking = false);
255    static IRPC::ptr createIRPC(IRPC::ptr orig);
256    static IRPC::ptr createIRPC(IRPC::ptr orig, Address addr);
257    
258    rpc_wrapper *llrpc() const;
259
260    Dyninst::Address getAddress() const;
261    void *getBinaryCode() const;
262    unsigned getBinaryCodeSize() const;
263    unsigned long getID() const;
264    void setStartOffset(unsigned long);
265    unsigned long getStartOffset() const;
266    bool isBlocking() const;
267
268    // user-defined data retrievable during a callback
269    void *getData() const;
270    void setData(void *p) const;
271
272    State state() const;
273
274    // Continues the thread this RPC is running on.
275    // Useful if you don't know the thread assigned to an IRPC
276    bool continueStoppedIRPC();
277 };
278
279 class PC_EXPORT Process : public boost::enable_shared_from_this<Process>
280 {
281  private:
282    friend class ::int_process;
283    friend class ProcessSet;
284
285    int_process *llproc_;
286    proc_exitstate *exitstate_;
287    
288    Process();
289    ~Process();
290    friend void boost::checked_delete<Process>(Process *);
291    friend void boost::checked_delete<const Process>(const Process *);
292  public:
293    typedef boost::shared_ptr<Process> ptr;
294    typedef boost::shared_ptr<const Process> const_ptr;
295    typedef boost::weak_ptr<Process> weak_ptr;
296    typedef boost::weak_ptr<const Process> const_weak_ptr;
297
298    static void version(int& major, int& minor, int& maintenance);
299
300    //These four functions are not for end-users.  
301    int_process *llproc() const { return llproc_; }
302    proc_exitstate *exitstate() const { return exitstate_; }
303    void setLastError(ProcControlAPI::err_t err_code, const char *err_str) const;
304    void clearLastError() const;
305    
306    /**
307     * Threading modes control
308     **/
309    typedef enum {
310      NoThreads,
311      GeneratorThreading,
312      HandlerThreading,
313      CallbackThreading
314    } thread_mode_t;
315    static bool setThreadingMode(thread_mode_t tm);
316    static thread_mode_t getThreadingMode();
317
318    /**
319     * Create and attach to new processes
320     **/
321    static const std::map<int,int> emptyFDs;
322    static const std::vector<std::string> emptyEnvp;
323    static Process::ptr createProcess(std::string executable,
324                                      const std::vector<std::string> &argv,
325                                      const std::vector<std::string> &envp = emptyEnvp,
326                                      const std::map<int,int> &fds = emptyFDs);
327    static Process::ptr attachProcess(Dyninst::PID pid, std::string executable = "");
328
329    /**
330     * Event Management
331     **/
332    enum cb_action_t {
333      cbDefault,
334      cbThreadContinue,
335      cbThreadStop,
336      cbProcContinue,
337      cbProcStop
338    };
339    struct cb_ret_t {
340       cb_ret_t(cb_action_t p) : parent(p), child(cbDefault) {}
341       cb_ret_t(cb_action_t p, cb_action_t c) : parent(p), child(c) {}
342       cb_action_t parent;
343       cb_action_t child;
344    };
345    
346    //cb_func_t really takes an 'Event::const_ptr' as parameter, but this declaration
347    // defines the shared_ptr declaration due to Event::const_ptr not being defined yet.
348    typedef cb_ret_t(*cb_func_t)(boost::shared_ptr<const Event>);
349
350    static bool handleEvents(bool block);
351    static bool registerEventCallback(EventType evt, cb_func_t cbfunc);
352    static bool removeEventCallback(EventType evt, cb_func_t cbfunc);
353    static bool removeEventCallback(EventType evt);
354    static bool removeEventCallback(cb_func_t cbfunc);
355
356    // user-defined data retrievable during a callback
357    void *getData() const;
358    void setData(void *p) const;
359
360    Dyninst::PID getPid() const;
361
362    /**
363     * Threads
364     **/
365    const ThreadPool &threads() const;
366    ThreadPool &threads();
367    
368    /**
369     * Test state of process
370     **/
371    bool isTerminated() const;
372    bool isExited() const;
373    bool isCrashed() const;
374    bool isDetached() const;
375    int getExitCode() const;
376    int getCrashSignal() const;
377
378    bool hasStoppedThread() const;
379    bool hasRunningThread() const;
380    bool allThreadsStopped() const;
381    bool allThreadsRunning() const;
382    bool allThreadsRunningWhenAttached() const;
383
384    /**
385     * What capabilities do we have on this process
386     **/
387    static const unsigned int pc_read      = (1<<0);
388    static const unsigned int pc_write     = (1<<1);
389    static const unsigned int pc_irpc      = (1<<2);   
390    static const unsigned int pc_control   = (1<<3);
391    unsigned int getCapabilities() const;
392    
393    /**
394     * Queries for machine info
395     **/
396    Dyninst::Architecture getArchitecture() const;
397    Dyninst::OSType getOS() const;
398
399    /**
400     * Query what kind of events this process supports
401     **/
402    bool supportsLWPEvents() const;
403    bool supportsUserThreadEvents() const;
404    bool supportsFork() const;
405    bool supportsExec() const;
406
407    /**
408     * Control process
409     **/
410    bool continueProc();
411    bool stopProc();
412    bool detach(bool leaveStopped = false);
413    bool terminate();
414    bool temporaryDetach();
415    bool reAttach();
416
417    /**
418     * Memory management
419     **/
420    class PC_EXPORT mem_perm {
421        bool read;
422        bool write;
423        bool execute;
424
425        int permVal() const;
426
427    public:
428        mem_perm() : read(false), write(false), execute(false) {} 
429        mem_perm(const mem_perm& p) : read(p.read), write(p.write),
430                                      execute(p.execute) {}
431        mem_perm(bool r, bool w, bool x) : read(r), write(w), execute(x) {} 
432
433        bool getR() const { return read;    }
434        bool getW() const { return write;   }
435        bool getX() const { return execute; }
436
437        bool isNone() const { return !read && !write && !execute; }
438        bool isR()    const { return  read && !write && !execute; }
439        bool isX()    const { return !read && !write &&  execute; }
440        bool isRW()   const { return  read &&  write && !execute; }
441        bool isRX()   const { return  read && !write &&  execute; }
442        bool isRWX()  const { return  read &&  write &&  execute; }
443
444        mem_perm& setR() { read    = true;  return *this; }
445        mem_perm& setW() { write   = true;  return *this; }
446        mem_perm& setX() { execute = true;  return *this; }
447
448        mem_perm& clrR() { read    = false; return *this; }
449        mem_perm& clrW() { write   = false; return *this; }
450        mem_perm& clrX() { execute = false; return *this; }
451
452        bool operator< (const mem_perm& p) const;
453        bool operator==(const mem_perm& p) const;
454        bool operator!=(const mem_perm& p) const;
455
456        std::string getPermName() const;
457    };
458
459    unsigned getMemoryPageSize() const;
460
461    Dyninst::Address mallocMemory(size_t size);
462    Dyninst::Address mallocMemory(size_t size, Dyninst::Address addr);
463    bool freeMemory(Dyninst::Address addr);
464    bool writeMemory(Dyninst::Address addr, const void *buffer, size_t size) const;
465    bool readMemory(void *buffer, Dyninst::Address addr, size_t size) const;
466
467    bool writeMemoryAsync(Dyninst::Address addr, const void *buffer, size_t size, void *opaque_val = NULL) const;
468    bool readMemoryAsync(void *buffer, Dyninst::Address addr, size_t size, void *opaque_val = NULL) const;
469
470    /** 
471     * Currently Windows-only, needed for the test infrastructure but possibly useful elsewhere 
472     **/
473    Dyninst::Address findFreeMemory(size_t size);
474
475    bool getMemoryAccessRights(Dyninst::Address addr, mem_perm& rights);
476    bool setMemoryAccessRights(Dyninst::Address addr, size_t size,
477                               mem_perm rights, mem_perm& oldRights);
478
479    // MemoryRegion.first = startAddr, MemoryRegion.second = endAddr
480    typedef std::pair<Dyninst::Address, Dyninst::Address> MemoryRegion;
481    bool findAllocatedRegionAround(Dyninst::Address addr, MemoryRegion& memRegion);
482
483    /**
484     * Libraries
485     **/
486    const LibraryPool &libraries() const;
487    LibraryPool &libraries();
488
489    // Cause a library to be loaded into the process (via black magic)
490    bool addLibrary(std::string libname);
491
492    /**
493     * Breakpoints
494     **/
495    bool addBreakpoint(Dyninst::Address addr, Breakpoint::ptr bp) const;
496    bool rmBreakpoint(Dyninst::Address addr, Breakpoint::ptr bp) const;
497    unsigned numHardwareBreakpointsAvail(unsigned mode);
498
499    /**
500     * Post IRPC.  Use continueProc/continueThread to run it,
501     * and handleEvents to wait for a blocking IRPC to complete
502     **/
503    bool postIRPC(IRPC::ptr irpc) const;
504    bool getPostedIRPCs(std::vector<IRPC::ptr> &rpcs) const;
505
506    /**
507     * Post, run, and wait for an IRPC to complete
508     **/
509         bool runIRPCSync(IRPC::ptr irpc);
510
511    /**
512     * Post and run an IRPC; user must wait for completion. 
513     **/
514         bool runIRPCAsync(IRPC::ptr irpc);
515
516    /**
517     * Symbol access
518     **/
519    void setSymbolReader(SymbolReaderFactory *reader) const;
520    SymbolReaderFactory *getSymbolReader() const;
521    static SymbolReaderFactory *getDefaultSymbolReader();
522    static void setDefaultSymbolReader(SymbolReaderFactory *reader);
523
524    /**
525     * Perform specific operations.  Interface objects will only be returned
526     * on appropriately supported platforms, others will return NULL.
527     **/
528    LibraryTracking *getLibraryTracking();
529    ThreadTracking *getThreadTracking();
530    LWPTracking *getLWPTracking();
531    FollowFork *getFollowFork();
532    SignalMask *getSignalMask();
533    BGQData *getBGQ();
534    RemoteIO *getRemoteIO();
535    MemoryUsage *getMemoryUsage();
536    const LibraryTracking *getLibraryTracking() const;
537    const ThreadTracking *getThreadTracking() const;
538    const LWPTracking *getLWPTracking() const;
539    const FollowFork *getFollowFork() const;
540    const SignalMask *getSignalMask() const;
541    const BGQData *getBGQ() const;
542    const RemoteIO *getRemoteIO() const;
543    const MemoryUsage *getMemoryUsage() const;
544
545    /**
546     * Errors that occured on this process
547     **/
548    ProcControlAPI::err_t getLastError() const;
549    const char *getLastErrorMsg() const;
550
551    /**
552     * Executable info
553     **/
554         ExecFileInfo* getExecutableInfo() const;
555 };
556
557 class PC_EXPORT Thread : public boost::enable_shared_from_this<Thread>
558 {
559  protected:
560    friend class ::int_thread;
561    int_thread *llthread_;
562    thread_exitstate *exitstate_;
563
564    Thread();
565    ~Thread();
566    friend void boost::checked_delete<Thread>(Thread *);
567    friend void boost::checked_delete<const Thread>(const Thread *);
568
569  public:
570    typedef boost::shared_ptr<Thread> ptr;
571    typedef boost::shared_ptr<const Thread> const_ptr;
572    typedef boost::weak_ptr<Thread> weak_ptr;
573    typedef boost::weak_ptr<const Thread> const_weak_ptr;
574    int_thread *llthrd() const;
575    void setLastError(err_t ec, const char *es) const;
576
577    Dyninst::LWP getLWP() const;
578    Process::ptr getProcess();
579    Process::const_ptr getProcess() const;
580
581    bool isStopped() const;
582    bool isRunning() const;
583    bool isLive() const;
584    bool isDetached() const;
585    bool isInitialThread() const;
586
587    // Added for Windows. Windows creates internal threads which are bound to 
588    // the process but are used for OS-level work. We hide these from the user,
589    // but need to represent them in ProcControlAPI. 
590    bool isUser() const; 
591
592    bool stopThread();
593    bool continueThread();
594
595    bool setSingleStepMode(bool s) const;
596    bool getSingleStepMode() const;
597
598    bool setSyscallMode(bool s) const;
599    bool getSyscallMode() const;
600
601    bool getRegister(Dyninst::MachRegister reg, Dyninst::MachRegisterVal &val) const;
602    bool getAllRegisters(RegisterPool &pool) const;
603    bool setRegister(Dyninst::MachRegister reg, Dyninst::MachRegisterVal val) const;
604    bool setAllRegisters(RegisterPool &pool) const;
605    bool getAllRegistersAsync(RegisterPool &pool, void *opaque_val = NULL) const;
606    bool setAllRegistersAsync(RegisterPool &pool, void *opaque_val = NULL) const;
607
608    bool readThreadLocalMemory(void *buffer, Library::const_ptr lib, Dyninst::Offset tls_symbol_offset, size_t size) const;
609    bool writeThreadLocalMemory(Library::const_ptr lib, Dyninst::Offset tls_symbol_offset, const void *buffer, size_t size) const;
610    bool getThreadLocalAddress(Library::const_ptr lib, Dyninst::Offset tls_offset, Dyninst::Address &result_addr) const;
611
612    /**
613     * User level thread info.  Only available after a UserThreadCreate event
614     **/
615    bool haveUserThreadInfo() const;
616    Dyninst::THR_ID getTID() const;
617    Dyninst::Address getStartFunction() const;
618    Dyninst::Address getStackBase() const;
619    unsigned long getStackSize() const;
620    Dyninst::Address getTLS() const;
621    Dyninst::Address getThreadInfoBlockAddr() const;
622
623    /**
624     * IRPC
625     **/
626    bool postIRPC(IRPC::ptr irpc) const;
627    bool runIRPCSync(IRPC::ptr irpc);
628    bool runIRPCAsync(IRPC::ptr irpc);
629
630    bool getPostedIRPCs(std::vector<IRPC::ptr> &rpcs) const;
631    IRPC::const_ptr getRunningIRPC() const;
632
633    /**
634     * Returns a stack unwinder on supported platforms (BlueGene/Q).
635     * Returns NULL on unsupported platforms
636     **/
637    CallStackUnwinding *getCallStackUnwinding();
638
639    void *getData() const;
640    void setData(void *p) const;
641 };
642
643 class PC_EXPORT ThreadPool
644 {
645  private:
646    friend class ::int_threadPool;
647    friend class Dyninst::ProcControlAPI::Process;
648    int_threadPool *threadpool;
649    ThreadPool();
650    ~ThreadPool();
651  public:
652    /**
653     * Iterators
654     **/
655    class PC_EXPORT iterator {
656       friend class Dyninst::ProcControlAPI::ThreadPool;
657    private:
658       static const int uninitialized_val = -1;
659       static const int end_val = -2;
660       int_threadPool *curp;
661       Thread::ptr curh;
662       int curi;
663    public:
664       iterator();
665       ~iterator();
666       Thread::ptr operator*() const;
667       bool operator==(const iterator &i);
668       bool operator!=(const iterator &i);
669       ThreadPool::iterator operator++();
670       ThreadPool::iterator operator++(int);
671    };
672    iterator begin();
673    iterator end();
674    iterator find(Dyninst::LWP lwp);
675
676    class PC_EXPORT const_iterator {
677       friend class Dyninst::ProcControlAPI::ThreadPool;
678    private:
679       static const int uninitialized_val = -1;
680       static const int end_val = -2;
681       int_threadPool *curp;
682       Thread::ptr curh;
683       int curi;
684    public:
685       const_iterator();
686       ~const_iterator();
687       Thread::const_ptr operator*() const;
688       bool operator==(const const_iterator &i);
689       bool operator!=(const const_iterator &i);
690       ThreadPool::const_iterator operator++();
691       ThreadPool::const_iterator operator++(int);
692
693           typedef Thread::const_ptr value_type;
694           typedef int difference_type;
695           typedef Thread::const_ptr *pointer;
696           typedef Thread::const_ptr &reference;
697           typedef std::forward_iterator_tag iterator_category;
698    };
699    const_iterator begin() const;
700    const_iterator end() const;
701    const_iterator find(Dyninst::LWP lwp) const;
702
703    size_t size() const;
704    Process::const_ptr getProcess() const;
705    Process::ptr getProcess();
706    Thread::const_ptr getInitialThread() const;
707    Thread::ptr getInitialThread();
708 };
709
710 class PC_EXPORT RegisterPool
711
712    friend class Dyninst::ProcControlAPI::Thread;
713    friend class Dyninst::ProcControlAPI::ThreadSet;
714  private:
715    int_registerPool *llregpool;
716  public:
717    RegisterPool();
718    RegisterPool(const RegisterPool &rp);
719    ~RegisterPool();
720    
721    class PC_EXPORT iterator {
722       friend class Dyninst::ProcControlAPI::RegisterPool;
723    private:
724       typedef std::map<Dyninst::MachRegister, Dyninst::MachRegisterVal>::iterator int_iter; 
725       int_iter i;
726       iterator(int_iter i_);
727    public:
728       iterator();
729       ~iterator();
730       std::pair<Dyninst::MachRegister, Dyninst::MachRegisterVal> operator*();
731       bool operator==(const iterator &i);
732       bool operator!=(const iterator &i);
733       RegisterPool::iterator operator++();
734       RegisterPool::iterator operator++(int);
735    };
736    iterator begin();
737    iterator end();
738    iterator find(Dyninst::MachRegister r);
739
740    class PC_EXPORT const_iterator {
741       friend class Dyninst::ProcControlAPI::RegisterPool;
742    private:
743       typedef std::map<Dyninst::MachRegister, Dyninst::MachRegisterVal>::const_iterator int_iter; 
744       int_iter i;
745       const_iterator(int_iter i_);
746    public:
747       const_iterator();
748       ~const_iterator();
749       std::pair<Dyninst::MachRegister, Dyninst::MachRegisterVal> operator*() const;
750       bool operator==(const const_iterator &i);
751       bool operator!=(const const_iterator &i);
752       RegisterPool::const_iterator operator++();
753       RegisterPool::const_iterator operator++(int);
754    };
755    const_iterator begin() const;
756    const_iterator end() const;
757    const_iterator find(Dyninst::MachRegister r) const;
758
759    Dyninst::MachRegisterVal& operator[](Dyninst::MachRegister r);
760    const Dyninst::MachRegisterVal& operator[](Dyninst::MachRegister r) const;
761
762    size_t size() const;
763    Thread::const_ptr getThread() const;
764    Thread::ptr getThread();
765 };
766
767 class PC_EXPORT EventNotify
768 {
769  private:
770    friend class ::int_notify;
771    int_notify *llnotify;
772    EventNotify();
773    ~EventNotify();
774  public:
775    typedef void (*notify_cb_t)();
776
777    int getFD();
778    void registerCB(notify_cb_t cb);
779    void removeCB(notify_cb_t cb);
780 };
781 PC_EXPORT EventNotify *evNotify();
782
783 class PC_EXPORT ExecFileInfo
784 {
785   public:
786         void* fileHandle;
787         void* processHandle;
788         Address fileBase;
789 };
790
791
792 }
793 }
794
795 #endif