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