Added code comments to int_process.h
[dyninst.git] / proccontrol / src / int_process.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(INT_PROCESS_H_)
32 #define INT_PROCESS_H_
33
34 #include "proccontrol/h/PCProcess.h"
35 #include "proccontrol/h/PCErrors.h"
36 #include "proccontrol/h/Event.h"
37 #include "proccontrol/h/PlatFeatures.h"
38
39 #include "proccontrol/src/response.h"
40 #include "proccontrol/src/memcache.h"
41
42 #include "dynutil/h/dyn_regs.h"
43 #include "dynutil/h/SymReader.h"
44 #include "common/h/dthread.h"
45
46 #include <vector>
47 #include <map>
48 #include <list>
49 #include <set>
50 #include <utility>
51 #include <queue>
52 #include <stack>
53
54 namespace Dyninst {
55 namespace ProcControlAPI {
56 class ProcessSet;
57 class CallStackCallback;
58 }
59 }
60
61 using namespace Dyninst;
62 using namespace ProcControlAPI;
63
64 class int_thread;
65 class int_threadPool;
66 class handlerpool;
67 class int_iRPC;
68
69 typedef std::multimap<Dyninst::Address, Dyninst::ProcControlAPI::Process::ptr> int_addressSet;
70 typedef std::set<Dyninst::ProcControlAPI::Process::ptr> int_processSet;
71 typedef std::set<Dyninst::ProcControlAPI::Thread::ptr> int_threadSet;
72
73 typedef boost::shared_ptr<int_iRPC> int_iRPC_ptr;
74 typedef std::map<Dyninst::MachRegister, std::pair<unsigned int, unsigned int> > dynreg_to_user_t;
75
76 typedef std::list<int_iRPC_ptr> rpc_list_t;
77
78 typedef void* hwbp_key_t;
79
80 class bp_instance;
81 class sw_breakpoint;
82 class hw_breakpoint;
83 class int_library;
84 class int_process;
85 class emulated_singlestep;
86
87 class int_libraryTracking;
88 class int_LWPTracking;
89 class int_threadTracking;
90 class int_followFork;
91 class int_callStackUnwinding;
92 class int_multiToolControl;
93 class int_signalMask;
94 class int_remoteIO;
95
96 struct bp_install_state {
97    Dyninst::Address addr;
98    int_breakpoint *bp;
99    sw_breakpoint *ibp;
100    bool do_install;
101    mem_response::ptr mem_resp;
102    result_response::ptr res_resp;
103 };
104
105 /**
106  * Data reflecting the contents of a process's memory should be
107  * stored in the mem_state object (e.g, breakpoints, libraries
108  * inferior mallocs).  That way, if two processes ever share memory
109  * (see POSIX vfork), then they can share a mem_state object
110  * and changes to one will be reflected in the other.
111  **/
112 class mem_state
113 {
114   public:
115    typedef mem_state* ptr;
116    mem_state(int_process *proc);
117    mem_state(mem_state &m, int_process *proc);
118    ~mem_state();
119
120    void addProc(int_process *p);
121    void rmProc(int_process *p, bool &should_clean);
122
123    std::set<int_process *> procs;
124    std::set<int_library *> libs;
125    std::map<Dyninst::Address, sw_breakpoint *> breakpoints;
126    std::map<Dyninst::Address, unsigned long> inf_malloced_memory;
127 };
128
129 /**
130  * Counters are usually* used to determine when to return from waitAndHandleEvents.
131  * Each Counter is associated with int_processes or int_threads, and counts how
132  * many of them are in a certain state.  For example, ClearingBPs counts how
133  * many threads have int_threads are currently clearing breakpoints.
134  *
135  * Counters are embedded into their int_process and int_thread objects, and
136  * if one of those objects are deleted the counter will automatically be
137  * decremented.
138  *
139  * int_process::waitAndHandleEvents will check most counters when determining
140  * whether it should return.  For example, if any threads are ClearingBPs then
141  * int_process::waitAndHandleEvents will block until they're done.
142  *
143  * *=Some of the generator counters such as ForceGeneratorBlock and
144  *   GeneratorNonExitedThreads are used in the generator rather than 
145  *   waitAndHandleEvents.
146  **/
147 class Counter {
148   public:
149    static const int NumCounterTypes = 12;
150    enum CounterType {
151       HandlerRunningThreads = 0,
152       GeneratorRunningThreads = 1,
153       SyncRPCs = 2,
154       SyncRPCRunningThreads = 3,
155       PendingStops = 4,
156       ClearingBPs = 5,
157       ProcStopRPCs = 6,
158       AsyncEvents = 7,
159       ForceGeneratorBlock = 8,
160       GeneratorNonExitedThreads = 9,
161       StartupTeardownProcesses = 10,
162       NeonatalThreads = 11
163    };
164
165    Counter(CounterType ct_);
166    ~Counter();
167
168    void inc();
169    void dec();
170
171    bool local() const;
172    int localCount() const;
173    static bool global(CounterType ct);
174    static int globalCount(CounterType ct);
175    static int processCount(CounterType ct, int_process* p);
176
177    static const char *getNameForCounter(int counter_type);
178   private:
179    int local_count;
180    CounterType ct;
181
182    void adjust(int val);
183
184    static Mutex locks[NumCounterTypes];
185    static int global_counts[NumCounterTypes];
186 };
187
188 /**
189  * This class works with the StateTracker (see below) to determine
190  * when an Event should be handled.  Suppose you receive a Breakpoint
191  * event on Linux, which stopped the thread it occured on but you
192  * want the entire process stopped.  
193  *
194  * Override the Event's procStopper() to set a StateTracker describing
195  * the desired state of the process (all threads stopped in the BP case)
196  * then return false from procStopper when the process reaches that state.
197  *
198  * PC will move the process towards your desired state, then handle the event
199  * when procStopper returns false.  ProcStopEventManager will handle much of this,
200  * and it's *StoppedTo functions can be used to see if the process has reached
201  * your desired state.
202  **/
203 class ProcStopEventManager {
204   private:
205    int_process *proc;
206    std::set<Event::ptr> held_pstop_events;
207   public:
208    ProcStopEventManager(int_process *p);
209    ~ProcStopEventManager();
210
211    bool prepEvent(Event::ptr ev);
212    void checkEvents();
213
214    bool processStoppedTo(int state_id);
215    bool threadStoppedTo(int_thread *thr, int state_id);
216 };
217
218 /**
219  * This is the central class in PC, representing both a process and 
220  * and the porting interface needed to move PC to a new platform.
221  *
222  * Most of the information about a process hangs off of here (except
223  * for memory related info, see mem_state above).  This includes
224  * PIDs, execution state, environment, etc.  
225  *
226  * There are numerous pure virtual functions below, most beginning
227  * with plat_*.  To port PC to a new platform make a new class (ie.,
228  * linux_process) that inherits from int_process and fill-in these
229  * pure virtual functions.  Then have int_process::createProcess
230  * return your new class, but cast back to an int_process.
231  *
232  * There are existing child classes of int_process that you can
233  * use if your system shares certain things in common with other
234  * platforms.  For example, several systems (Linux, BlueGene, FreeBSD)
235  * use the System V interfaces for library loading.  Thus there
236  * exists a sysv_process class that inherits from int_process and
237  * fills in the library handling virtual functions of int_process.
238  * Other examples are x86_process, which fill things like how
239  * to build a breakpoint instruction.
240  * 
241  * By having the new platforms inherit from these you leverage
242  * a lot of existing work.  Note that new ports will also have
243  * to implement their own decoders and generators.
244  **/
245 class int_process
246 {
247    friend class Dyninst::ProcControlAPI::Process;
248    friend class Dyninst::ProcControlAPI::ProcessSet;
249  protected:
250    int_process(Dyninst::PID p, std::string e, std::vector<std::string> a, 
251            std::vector<std::string> envp, std::map<int,int> f);
252    int_process(Dyninst::PID pid_, int_process *p);
253  public:
254    static int_process *createProcess(Dyninst::PID p, std::string e);
255    static int_process *createProcess(std::string e, std::vector<std::string> a, 
256            std::vector<std::string> envp, std::map<int,int> f);
257    static int_process *createProcess(Dyninst::PID pid_, int_process *p);
258    virtual ~int_process();
259  protected:
260    static bool create(int_processSet *ps);
261    virtual bool plat_create() = 0;
262    virtual async_ret_t post_create(std::set<response::ptr> &async_responses);
263
264    static bool attach(int_processSet *ps, bool reattach);
265    static bool reattach(int_processSet *pset);
266    virtual bool plat_attach(bool allStopped, bool &should_sync) = 0;
267
268    bool attachThreads();
269    virtual async_ret_t post_attach(bool wasDetached, std::set<response::ptr> &aresps);
270    async_ret_t initializeAddressSpace(std::set<response::ptr> &async_responses);
271
272    virtual bool plat_syncRunState() = 0;
273    bool syncRunState();
274
275   public:
276
277    typedef enum {
278       ct_fork,
279       ct_launch,
280       ct_attach
281    } creationMode_t;
282    creationMode_t getCreationMode() const;
283
284    void setContSignal(int sig);
285    int getContSignal() const;
286    virtual bool forked();
287
288    virtual OSType getOS() const = 0;
289   protected:
290    virtual bool plat_forked() = 0;
291    virtual bool post_forked();
292
293   public:
294    bool execed();
295    virtual bool plat_detach(result_response::ptr resp, bool leave_stopped) = 0;
296    virtual bool plat_detachDone();
297   protected:
298    virtual bool plat_execed();
299    virtual bool plat_terminate(bool &needs_sync) = 0;
300
301    virtual bool needIndividualThreadAttach() = 0;
302    virtual bool getThreadLWPs(std::vector<Dyninst::LWP> &lwps);
303
304    virtual void plat_threadAttachDone();
305    bool waitfor_startup();
306
307    void setPid(Dyninst::PID pid);
308    int_thread *findStoppedThread();
309
310   public:
311    virtual bool plat_processGroupContinues();
312
313    typedef enum {
314       neonatal = 0,
315       neonatal_intermediate,
316       detached,
317       running,
318       exited,
319       errorstate
320    } State;
321    State getState() const;
322    void setState(State s);
323
324    Dyninst::PID getPid() const;
325    int_threadPool *threadPool() const;
326
327    Process::ptr proc() const;
328    mem_state::ptr memory() const;
329
330    err_t getLastError();
331    const char *getLastErrorMsg();
332    void clearLastError();
333    void setLastError(err_t err, const char *err_str);
334
335    void throwDetachEvent(bool temporary, bool leaveStopped);
336
337    virtual bool preTerminate();
338    bool terminate(bool &needs_sync);
339    void updateSyncState(Event::ptr ev, bool gen);
340
341    virtual void plat_adjustSyncType(Event::ptr, bool) {};
342    virtual Dyninst::Architecture getTargetArch() = 0;
343    virtual unsigned getTargetPageSize() = 0;
344    virtual unsigned plat_getRecommendedReadSize();
345    virtual Dyninst::Address mallocExecMemory(unsigned size);
346    virtual Dyninst::Address plat_mallocExecMemory(Dyninst::Address min, unsigned size) = 0;
347    virtual void freeExecMemory(Dyninst::Address addr);
348
349    static bool waitAndHandleEvents(bool block);
350    static bool waitAndHandleForProc(bool block, int_process *proc, bool &proc_exited);
351    static bool waitForAsyncEvent(response::ptr resp);
352    static bool waitForAsyncEvent(std::set<response::ptr> resp);
353
354    virtual bool plat_waitAndHandleForProc();
355
356    Counter &asyncEventCount();
357    Counter &getForceGeneratorBlockCount();
358    Counter &getStartupTeardownProcs();
359
360    static const char *stateName(State s);
361
362    void initializeProcess(Process::ptr p);
363
364    virtual void instantiateRPCThread() {};
365
366    void setExitCode(int c);
367    void setCrashSignal(int s);
368    bool getExitCode(int &c);
369    bool getCrashSignal(int &s);
370    bool wasForcedTerminated() const;
371
372    virtual bool plat_individualRegAccess() = 0;
373    virtual bool plat_individualRegRead();
374    virtual bool plat_individualRegSet();
375
376    int getAddressWidth();
377    HandlerPool *handlerPool() const;
378
379    bool addBreakpoint(Dyninst::Address addr, int_breakpoint *bp);
380    bool addBreakpoint_phase1(bp_install_state *is);
381    bool addBreakpoint_phase2(bp_install_state *is);
382    bool addBreakpoint_phase3(bp_install_state *is);
383
384    bool removeBreakpoint(Dyninst::Address addr, int_breakpoint *bp, std::set<response::ptr> &resps);
385    bool removeAllBreakpoints();
386
387    sw_breakpoint *getBreakpoint(Dyninst::Address addr);
388
389    virtual unsigned plat_breakpointSize() = 0;
390    virtual void plat_breakpointBytes(unsigned char *buffer) = 0;
391    virtual bool plat_breakpointAdvancesPC() const = 0;
392
393    virtual bool plat_createDeallocationSnippet(Dyninst::Address addr, unsigned long size, void* &buffer, 
394                                                unsigned long &buffer_size, unsigned long &start_offset) = 0;
395    virtual bool plat_createAllocationSnippet(Dyninst::Address addr, bool use_addr, unsigned long size, 
396                                              void* &buffer, unsigned long &buffer_size, 
397                                              unsigned long &start_offset) = 0;
398    virtual bool plat_collectAllocationResult(int_thread *thr, reg_response::ptr resp) = 0;
399    virtual bool plat_threadOpsNeedProcStop();
400
401    virtual SymbolReaderFactory *plat_defaultSymReader();
402    virtual SymbolReaderFactory *getSymReader();
403    virtual void setSymReader(SymbolReaderFactory *fact);
404
405    virtual Dyninst::Address direct_infMalloc(unsigned long size, bool use_addr = false, Dyninst::Address addr = 0x0);
406    virtual bool direct_infFree(Dyninst::Address addr);
407
408    static bool infMalloc(unsigned long size, int_addressSet *aset, bool use_addr);
409    static bool infFree(int_addressSet *aset);
410
411    enum bp_write_t {
412       not_bp,
413       bp_install,
414       bp_clear
415    };
416
417    bool readMem(Dyninst::Address remote, mem_response::ptr result, int_thread *thr = NULL);
418    bool writeMem(const void *local, Dyninst::Address remote, size_t size, result_response::ptr result, int_thread *thr = NULL, bp_write_t bp_write = not_bp);
419
420    virtual bool plat_readMem(int_thread *thr, void *local, 
421                              Dyninst::Address remote, size_t size) = 0;
422    virtual bool plat_writeMem(int_thread *thr, const void *local, 
423                               Dyninst::Address remote, size_t size, bp_write_t bp_write) = 0;
424
425    virtual Address plat_findFreeMemory(size_t) { return 0; }
426
427    //For a platform, if plat_needsAsyncIO returns true then the async
428    // set of functions need to be implemented.  Currently plat_needsAsyncIO
429    // only returns true for bluegene family.  By default these are otherwise
430    // unimplemented.
431    virtual bool plat_needsAsyncIO() const;
432    virtual bool plat_readMemAsync(int_thread *thr, Dyninst::Address addr, 
433                                   mem_response::ptr result);
434    virtual bool plat_writeMemAsync(int_thread *thr, const void *local, Dyninst::Address addr,
435                                    size_t size, result_response::ptr result, bp_write_t bp_write);
436
437    memCache *getMemCache();
438
439    virtual bool plat_getOSRunningStates(std::map<Dyninst::LWP, bool> &runningStates) = 0;
440         // Windows-only technically
441    virtual void* plat_getDummyThreadHandle() const { return NULL; }
442    
443    virtual void noteNewDequeuedEvent(Event::ptr ev);
444
445    static bool isInCB();
446    static void setInCB(bool b);
447
448    void throwNopEvent();
449    void throwRPCPostEvent();
450    
451    virtual bool plat_supportFork();
452    virtual bool plat_supportExec();
453    virtual bool plat_supportDOTF();
454
455    virtual bool plat_supportThreadEvents();
456    virtual bool plat_supportLWPCreate();
457    virtual bool plat_supportLWPPreDestroy();
458    virtual bool plat_supportLWPPostDestroy();
459
460    virtual bool plat_preHandleEvent();
461    virtual bool plat_postHandleEvent();
462    virtual bool plat_preAsyncWait();
463    virtual bool plat_supportHWBreakpoint();
464
465    virtual bool plat_needsPCSaveBeforeSingleStep();
466    virtual async_ret_t plat_needsEmulatedSingleStep(int_thread *thr, std::vector<Dyninst::Address> &result);
467    virtual bool plat_convertToBreakpointAddress(Address &, int_thread *) { return true; }
468    virtual void plat_getEmulatedSingleStepAsyncs(int_thread *thr, std::set<response::ptr> resps);
469    virtual bool plat_needsThreadForMemOps() const { return true; }
470    virtual unsigned int plat_getCapabilities();
471    virtual Event::ptr plat_throwEventsBeforeContinue(int_thread *thr);
472    
473    int_library *getLibraryByName(std::string s) const;
474    size_t numLibs() const;
475    virtual bool refresh_libraries(std::set<int_library *> &added_libs,
476                                   std::set<int_library *> &rmd_libs,
477                                   bool &waiting_for_async,
478                                   std::set<response::ptr> &async_responses) = 0;
479
480    virtual bool plat_isStaticBinary() = 0;
481    virtual int_library *plat_getExecutable() = 0;
482
483    virtual bool plat_supportDirectAllocation() const { return false; }
484    bool forceGeneratorBlock() const;
485    void setForceGeneratorBlock(bool b);
486
487    std::string getExecutable() const;
488    static bool isInCallback();
489
490    static int_process *in_waitHandleProc;
491    // TODO: clean up w/enum
492    bool wasCreatedViaAttach() const { return createdViaAttach; }
493    void wasCreatedViaAttach(bool val) { createdViaAttach = val; }
494
495    // Platform-specific; is this address in what we consider a system lib.
496    virtual bool addrInSystemLib(Address /*addr*/) { return false; }
497
498    ProcStopEventManager &getProcStopManager();
499
500    std::map<int, int> &getProcDesyncdStates();
501
502    bool isRunningSilent(); //No callbacks
503    void setRunningSilent(bool b);
504
505    virtual ExecFileInfo* plat_getExecutableInfo() const { return NULL; }
506
507    int_libraryTracking *getLibraryTracking();
508    int_LWPTracking *getLWPTracking();
509    int_threadTracking *getThreadTracking();
510    int_followFork *getFollowFork();
511    int_multiToolControl *getMultiToolControl();
512    int_signalMask *getSignalMask();
513    int_callStackUnwinding *getCallStackUnwinding();
514    int_BGQData *getBGQData();
515    int_remoteIO *getRemoteIO();
516
517    //Interface into BGQ-specific process data.
518  protected:
519    State state;
520    Dyninst::PID pid;
521    creationMode_t creation_mode;
522    std::string executable;
523    std::vector<std::string> argv;
524    std::vector<std::string> env;
525    std::map<int,int> fds;
526    Dyninst::Architecture arch;
527    int_threadPool *threadpool;
528    Process::ptr up_proc;
529    HandlerPool *handlerpool;
530    LibraryPool libpool;
531    bool hasCrashSignal;
532    int crashSignal;
533    bool hasExitCode;
534    bool forcedTermination;
535    bool silent_mode;
536    int exitCode;
537    static bool in_callback;
538    mem_state::ptr mem;
539    std::map<Dyninst::Address, unsigned> exec_mem_cache;
540    int continueSig;
541    bool createdViaAttach;
542    memCache mem_cache;
543    Counter async_event_count;
544    Counter force_generator_block_count;
545    Counter startupteardown_procs;
546    ProcStopEventManager proc_stop_manager;
547    std::map<int, int> proc_desyncd_states;
548    void *user_data;
549    err_t last_error;
550    const char *last_error_string;
551    SymbolReaderFactory *symbol_reader;
552    static SymbolReaderFactory *user_set_symbol_reader;
553
554    //Cached PlatFeature pointers, which are used to avoid slow dynamic casts
555    // (they're used frequently in tight loops on BG/Q)
556    int_libraryTracking *pLibraryTracking;
557    int_LWPTracking *pLWPTracking;
558    int_threadTracking *pThreadTracking;
559    int_followFork *pFollowFork;
560    int_multiToolControl *pMultiToolControl;
561    int_signalMask *pSignalMask;
562    int_callStackUnwinding *pCallStackUnwinding;
563    int_BGQData *pBGQData;
564    int_remoteIO *pRemoteIO;
565    bool LibraryTracking_set;
566    bool LWPTracking_set;
567    bool ThreadTracking_set;
568    bool FollowFork_set;
569    bool MultiToolControl_set;
570    bool SignalMask_set;
571    bool CallStackUnwinding_set;
572    bool BGQData_set;
573    bool remoteIO_set;
574 };
575
576 struct ProcToIntProc {
577    int_process *operator()(const Process::ptr &p) const { return p->llproc(); }
578 };
579
580 /**
581  * These processes represent four common models of how to stop/continue threads.
582  * If a new platform follows one of these, then inherit them from the appropriate
583  * class.
584  *
585  * indep_lwp_control_process - Each thread/lwp stops and continues independent from
586  *  each other one.  (Linux)
587  * unified_lwp_control_process - There is no thread-specific control, every thread 
588  *  stops/runs alongside its peers (BG/P)
589  * hybrid_lwp_control_process - All threads in a process are run/stopped when
590  *  a thread stops/runs, but threads can be overridden with a suspend state
591  *  that can keep them stopped when others run (FreeBSD, Windows, BG/Q).
592  **/
593 class indep_lwp_control_process : virtual public int_process
594 {
595   protected:
596    virtual bool plat_syncRunState();
597   public:
598    indep_lwp_control_process(Dyninst::PID p, std::string e, std::vector<std::string> a, 
599                              std::vector<std::string> envp, std::map<int,int> f);
600    indep_lwp_control_process(Dyninst::PID pid_, int_process *p);
601    virtual ~indep_lwp_control_process();
602 };
603
604 class unified_lwp_control_process : virtual public int_process
605 {
606   protected:
607    virtual bool plat_syncRunState();
608   public:
609    unified_lwp_control_process(Dyninst::PID p, std::string e, std::vector<std::string> a, 
610                                std::vector<std::string> envp, std::map<int,int> f);
611    unified_lwp_control_process(Dyninst::PID pid_, int_process *p);
612    virtual ~unified_lwp_control_process();
613
614    virtual bool plat_processGroupContinues();
615 };
616
617 class hybrid_lwp_control_process : virtual public int_process
618 {
619   protected:
620    virtual bool plat_syncRunState();
621    virtual bool plat_suspendThread(int_thread *thr) = 0;
622    virtual bool plat_resumeThread(int_thread *thr) = 0;
623    bool debugger_stopped;
624   public:
625    hybrid_lwp_control_process(Dyninst::PID p, std::string e, std::vector<std::string> a, 
626                               std::vector<std::string> envp, std::map<int,int> f);
627    hybrid_lwp_control_process(Dyninst::PID pid_, int_process *p);
628    virtual ~hybrid_lwp_control_process();
629
630    virtual bool suspendThread(int_thread *thr);
631    virtual bool resumeThread(int_thread *thr);
632
633    virtual void noteNewDequeuedEvent(Event::ptr ev);
634    virtual bool plat_debuggerSuspended();
635
636    virtual bool plat_processGroupContinues();
637 };
638
639 /**
640  * A collection of registers from a thread.
641  **/
642 class int_registerPool
643 {
644  public:
645    int_registerPool();
646    int_registerPool(const int_registerPool &c);
647    ~int_registerPool();
648
649    typedef std::map<Dyninst::MachRegister, Dyninst::MachRegisterVal> reg_map_t;
650    reg_map_t regs;
651    bool full;
652    int_thread *thread;
653
654    typedef reg_map_t::iterator iterator;
655    typedef reg_map_t::const_iterator const_iterator;
656 };
657
658 /**
659  * When a thread/process exits we delete the int_process/int_thread objects.  But,
660  * we leave the UI handles Process/Thread around until the user gets rid of their
661  * last pointer.  There are only a few operations that are legal on an exited process
662  * (such as getting the pid or exitcode).  thread_exitstate and proc_exitstate hold that 
663  * information after a process exits. 
664  **/
665 class thread_exitstate
666 {
667   public:
668    Dyninst::LWP lwp;
669    Dyninst::THR_ID thr_id;
670    Process::ptr proc_ptr;
671    void *user_data;
672 };
673
674 class proc_exitstate
675 {
676   public:
677    Dyninst::PID pid;
678    bool exited;
679    bool crashed;
680    int crash_signal;
681    int exit_code;
682    err_t last_error;
683    const char *last_error_msg;
684    void *user_data;
685
686    void setLastError(err_t e_, const char *m) { last_error = e_; last_error_msg = m; }
687 };
688
689 /**
690  * int_thread repesents a thread/lwp (PC assumes an M:N model of 1:1).  See the comment
691  * above int_process, most of which applies here.
692  *
693  * An int_process also holds the stopped/running state of a process.  See the StateTracker
694  * comment for a longer discussion here.
695  **/
696 class int_thread
697 {
698    friend class Dyninst::ProcControlAPI::Thread;
699    friend class int_threadPool;
700    friend class ProcStopEventManager;
701    friend class hw_breakpoint;
702  protected:
703    int_thread(int_process *p, Dyninst::THR_ID t, Dyninst::LWP l);
704    static int_thread *createThreadPlat(int_process *proc, 
705                                        Dyninst::THR_ID thr_id, 
706                                        Dyninst::LWP lwp_id,
707                                        bool initial_thrd);
708
709 public:
710    enum attach_status_t {
711       as_unknown = 0,          //Threads found by getThreadLWPs come in as_needs_attach, others
712       as_created_attached,     // come int as_created_attached.  Up to platforms to interpret this
713       as_needs_attach          // however they want.
714    };
715
716    static int_thread *createThread(int_process *proc, 
717                                    Dyninst::THR_ID thr_id, 
718                                    Dyninst::LWP lwp_id,
719                                    bool initial_thrd,
720                                    attach_status_t astatus = as_unknown);
721    static int_thread *createRPCThread(int_process *p);
722    Process::ptr proc() const;
723    int_process *llproc() const;
724
725    Dyninst::LWP getLWP() const;
726    void changeLWP(Dyninst::LWP new_lwp);
727
728 #define RUNNING_STATE(S) (S == int_thread::running || S == int_thread::neonatal_intermediate)
729    typedef enum {
730       none=0,
731       neonatal=1,
732       neonatal_intermediate=2,
733       running=3,
734       stopped=4,
735       dontcare=5,
736       ditto=6,
737       exited=7,
738       detached=8,
739       errorstate=9
740    } State;
741    //The order of these is very important.  Lower numbered
742    // states take precedence over higher numbered states.
743    static const int NumStateIDs = 17;
744    static const int NumTargetStateIDs = (NumStateIDs-2); //Handler and Generator states aren't target states
745
746    static const int AsyncStateID            = 0;
747    static const int CallbackStateID         = 1;
748    static const int PendingStopStateID      = 2;
749    static const int IRPCStateID             = 3;
750    static const int IRPCSetupStateID        = 4;
751    static const int IRPCWaitStateID         = 5;
752    static const int BreakpointStateID       = 6;
753    static const int InternalStateID         = 7;
754    static const int BreakpointResumeStateID = 8;
755    static const int ExitingStateID          = 9;
756    static const int StartupStateID          = 10;
757    static const int DetachStateID           = 11;
758    static const int UserRPCStateID          = 12;
759    static const int ControlAuthorityStateID = 13;
760    static const int UserStateID             = 14;
761    static const int HandlerStateID          = 15;
762    static const int GeneratorStateID        = 16;
763    static std::string stateIDToName(int id);
764
765    /**
766     * Documentation on StateTracker.  aka How we stop/continue the process:
767     *
768     * Making a decision on when to stop/continue a thread is complicated,
769     * especially when multiple events are happening on multiple threads.
770     * We have to consider cases like an iRPC running on one thread, while
771     * another thread handles a breakpoint and another thread is being 
772     * stopped by the user.  
773     *
774     * Each of these events might try to change the stop/running states of
775     * other threads, which can lead to conflicts over who's running.
776     * We resolve these conflicts by:
777     * - Giving each PC subsystem (e.g., iRPCs, breakpoints, user stops, ...) its
778     *   variable indicating whether a thread should run.  These are the StateTrackers.
779     * - When we acutually decide whether a thread should stop/run, we use a priority-based
780     *   projection to reduce the multiple StateTrackers from each subsystem into
781     *   a single target state (this happens in int_process::syncRunState).
782     *
783     * As an example, if you look below you'll see that the IRPC subsystem's 
784     * StateTrackers are a higher priority than the Breakpoint handling
785     * subsystem.  That means that if an IRPC and a breakpoint are happening
786     * at the same time, then we'll handle the stop/continues for the IRPC
787     * first.  When those are done (e.g., when the iRPC subsystem sets
788     * its StateTrackers to the dontcare value), then we'll move on to 
789     * handle the breakpoints.
790     *
791     * The UserState is one of the lowest priority StateTrackers--meaning
792     * everything else takes precedence.  This state represents the wishes
793     * of the user.  You can override the user's wishes (i.e, impose a 
794     * temporary stop while handling something) by setting a higher priority
795     * state, doing your work, then clearing that state.
796     *
797     * In general, most people will use StateTrackers from Handlers when
798     * dealing with an event that might have multiple stages.  In these cases,
799     * have the first stage of the event (or the code that starts the events)
800     * set the StateTracker to the desired state.  Have the last stage of the
801     * event clear the StateTracker.  Events that can be handled with a single
802     * stage (e.g, forwarding a signal) don't usually need a StateTracker.
803     *
804     * The HandlerState and GeneratorState are two special case StateTrackers.
805     * Instead of representing a goal state, they represent the actual 
806     * stop/running state of a thread.  The GenratorState is the state
807     * as viewed by PC's generator thread, and similar HandlerState is for
808     * PC's handler thread.  These are seperate variables so that we don't
809     * get races if they both read/update that variable at once.  Most of the
810     * time, you'll want the HandlerState.
811     **/
812    class StateTracker {
813      protected:
814       State state;
815       int id;
816       int sync_level;
817       int_thread *up_thr;
818      public:
819       StateTracker(int_thread *t, int id, int_thread::State initial);
820
821       void desyncState(State ns = int_thread::none);
822       void desyncStateProc(State ns = int_thread::none);
823
824       bool setState(State ns = int_thread::none);
825       bool setStateProc(State ns = int_thread::none);
826       
827       void restoreState();
828       void restoreStateProc();
829       State getState() const;
830       bool isDesynced() const;
831
832       std::string getName() const;
833       int getID() const;
834       
835       int_thread *debugthr() const { return up_thr; }
836    };
837
838    //State management, see above comment on states
839    StateTracker &getExitingState();
840    StateTracker &getStartupState();
841    StateTracker &getBreakpointState();
842    StateTracker &getBreakpointResumeState();
843    StateTracker &getCallbackState();
844    StateTracker &getIRPCState();
845    StateTracker &getIRPCSetupState();
846    StateTracker &getIRPCWaitState();
847    StateTracker &getAsyncState();
848    StateTracker &getInternalState();
849    StateTracker &getDetachState();
850    StateTracker &getControlAuthorityState();
851    StateTracker &getUserRPCState();
852    StateTracker &getUserState();
853    StateTracker &getHandlerState();
854    StateTracker &getGeneratorState();
855    StateTracker &getPendingStopState();
856
857    StateTracker &getStateByID(int id);
858    StateTracker &getActiveState();
859    static char stateLetter(State s);
860
861    Counter &handlerRunningThreadsCount();
862    Counter &generatorRunningThreadsCount();
863    Counter &syncRPCCount();
864    Counter &runningSyncRPCThreadCount();
865    Counter &pendingStopsCount();
866    Counter &clearingBPCount();
867    Counter &procStopRPCCount();
868    Counter &getGeneratorNonExitedThreadCount();
869    Counter &neonatalThreadCount();
870       
871    //Process control
872    bool intStop();
873    bool intCont();
874    async_ret_t handleSingleStepContinue();
875
876    void terminate();
877
878    void setContSignal(int sig);
879    int getContSignal();
880
881    virtual bool plat_cont() = 0;
882    virtual bool plat_stop() = 0;
883    void setPendingStop(bool b);
884    bool hasPendingStop() const;
885
886    bool wasRunningWhenAttached() const;
887    void setRunningWhenAttached(bool b);
888    bool isStopped(int state_id);
889
890    // Is this thread's lifetime only an IRPC and it gets
891    // discarded afterwards?
892    virtual bool isRPCEphemeral() const { return false; }
893
894    //Single-step
895    bool singleStepMode() const;
896    void setSingleStepMode(bool s);
897    bool singleStepUserMode() const;
898    void setSingleStepUserMode(bool s);
899    bool singleStep() const;
900    void markClearingBreakpoint(bp_instance *bp);
901    bp_instance *isClearingBreakpoint();
902    void markStoppedOnBP(bp_instance *bp);
903    bp_instance *isStoppedOnBP();
904
905    // Emulating single steps with breakpoints
906    void addEmulatedSingleStep(emulated_singlestep *es);
907    void rmEmulatedSingleStep(emulated_singlestep *es);
908    emulated_singlestep *getEmulatedSingleStep();
909
910    //RPC Management
911    void addPostedRPC(int_iRPC_ptr rpc_);
912    rpc_list_t *getPostedRPCs();
913    bool hasPostedRPCs();
914    void setRunningRPC(int_iRPC_ptr rpc_);
915    void clearRunningRPC();
916    int_iRPC_ptr runningRPC() const;
917    bool saveRegsForRPC(allreg_response::ptr response);
918    bool restoreRegsForRPC(bool clear, result_response::ptr response);
919    bool hasSavedRPCRegs();
920    void incSyncRPCCount();
921    void decSyncRPCCount();
922    bool hasSyncRPC();
923    int_iRPC_ptr nextPostedIRPC() const;
924
925    int_iRPC_ptr hasRunningProcStopperRPC() const;
926    virtual bool notAvailableForRPC() {
927                 return false;
928    }
929
930    //Register Management
931    bool getAllRegisters(allreg_response::ptr result);
932    bool getRegister(Dyninst::MachRegister reg, reg_response::ptr result);
933    bool setAllRegisters(int_registerPool &pool, result_response::ptr result);
934    bool setRegister(Dyninst::MachRegister reg, Dyninst::MachRegisterVal val, result_response::ptr result);
935
936    virtual bool plat_getAllRegisters(int_registerPool &pool) = 0;
937    virtual bool plat_getRegister(Dyninst::MachRegister reg, 
938                                  Dyninst::MachRegisterVal &val) = 0;
939    virtual bool plat_setAllRegisters(int_registerPool &pool) = 0;
940    virtual bool plat_setRegister(Dyninst::MachRegister reg, 
941                                  Dyninst::MachRegisterVal val) = 0;
942
943    virtual bool plat_getAllRegistersAsync(allreg_response::ptr result);
944    virtual bool plat_getRegisterAsync(Dyninst::MachRegister reg, 
945                                       reg_response::ptr result);
946    virtual bool plat_setAllRegistersAsync(int_registerPool &pool,
947                                           result_response::ptr result);
948    virtual bool plat_setRegisterAsync(Dyninst::MachRegister reg, 
949                                       Dyninst::MachRegisterVal val,
950                                       result_response::ptr result);
951    virtual void plat_terminate();
952
953    void updateRegCache(int_registerPool &pool);
954    void updateRegCache(Dyninst::MachRegister reg, Dyninst::MachRegisterVal val);
955    void clearRegCache();
956
957    // The exiting property is separate from the main state because an
958    // exiting thread can either be running or stopped (depending on the
959    // desires of the user).
960    bool isExiting() const;
961    void setExiting(bool b);
962    bool isExitingInGenerator() const;
963    void setExitingInGenerator(bool b);
964
965    static void cleanFromHandler(int_thread *thr, bool should_delete);
966
967    //Misc
968    virtual bool attach() = 0;
969    Thread::ptr thread();
970
971    typedef void(*continue_cb_t)(int_thread *thrd);
972    static void addContinueCB(continue_cb_t cb);
973    void triggerContinueCBs();
974
975    void throwEventsBeforeContinue();
976
977    //User level thread info
978    void setTID(Dyninst::THR_ID tid_);
979    virtual bool haveUserThreadInfo();
980    virtual bool getTID(Dyninst::THR_ID &tid);
981    virtual bool getStartFuncAddress(Dyninst::Address &addr);
982    virtual bool getStackBase(Dyninst::Address &addr);
983    virtual bool getStackSize(unsigned long &size);
984    virtual bool getTLSPtr(Dyninst::Address &addr);
985       
986    // Windows-only; default implementation is "yes, we're a user thread"
987    virtual bool isUser() const { return true; }
988
989    virtual unsigned hwBPAvail(unsigned mode);
990    virtual bool rmHWBreakpoint(hw_breakpoint *bp,
991                                bool suspend,
992                                std::set<response::ptr> &resps,
993                                bool &done);
994    virtual bool addHWBreakpoint(hw_breakpoint *bp,
995                                 bool resume,
996                                 std::set<response::ptr> &resps,
997                                 bool &done);
998    virtual EventBreakpoint::ptr decodeHWBreakpoint(response::ptr &resp,
999                                                    bool have_reg = false,
1000                                                    Dyninst::MachRegisterVal regval = 0);
1001    virtual bool bpNeedsClear(hw_breakpoint *hwbp);
1002
1003    virtual ~int_thread();
1004    static const char *stateStr(int_thread::State s);
1005
1006    State getTargetState() const;
1007    void setTargetState(State s);
1008
1009    void setSuspended(bool b);
1010    bool isSuspended() const;
1011    void setLastError(err_t ec, const char *es);
1012
1013    hw_breakpoint *getHWBreakpoint(Address addr);
1014
1015  protected:
1016    Dyninst::THR_ID tid;
1017    Dyninst::LWP lwp;
1018    int_process *proc_;
1019    Thread::ptr up_thread;
1020    int continueSig_;
1021    attach_status_t attach_status;
1022
1023    Counter handler_running_thrd_count;
1024    Counter generator_running_thrd_count;
1025    Counter sync_rpc_count;
1026    Counter sync_rpc_running_thr_count;
1027    Counter pending_stop;
1028    Counter clearing_bp_count;
1029    Counter proc_stop_rpc_count;
1030    Counter generator_nonexited_thrd_count;
1031    Counter neonatal_threads;
1032
1033    StateTracker exiting_state;
1034    StateTracker startup_state;
1035    StateTracker pending_stop_state;
1036    StateTracker callback_state;
1037    StateTracker breakpoint_state;
1038    StateTracker breakpoint_resume_state;
1039    StateTracker irpc_setup_state;
1040    StateTracker irpc_wait_state;
1041    StateTracker irpc_state;
1042    StateTracker async_state;
1043    StateTracker internal_state;
1044    StateTracker detach_state;
1045    StateTracker user_irpc_state;
1046    StateTracker control_authority_state;
1047    StateTracker user_state;
1048    StateTracker handler_state;
1049    StateTracker generator_state;
1050    StateTracker *all_states[NumStateIDs];
1051
1052    State target_state;
1053    State saved_user_state;
1054
1055    int_registerPool cached_regpool;
1056    Mutex regpool_lock;
1057    int_iRPC_ptr running_rpc;
1058    int_iRPC_ptr writing_rpc;
1059    rpc_list_t posted_rpcs;
1060    int_registerPool rpc_regs;
1061
1062    bool user_single_step;
1063    bool single_step;
1064    bool handler_exiting_state;
1065    bool generator_exiting_state;
1066    bool running_when_attached;
1067    bool suspended;
1068
1069    Address stopped_on_breakpoint_addr;
1070    Address postponed_stopped_on_breakpoint_addr;
1071
1072    bp_instance *clearing_breakpoint;
1073    emulated_singlestep *em_singlestep;
1074    void *user_data;
1075
1076    std::set<hw_breakpoint *> hw_breakpoints;
1077    static std::set<continue_cb_t> continue_cbs;
1078    CallStackUnwinding *unwinder;
1079 };
1080
1081 /**
1082  * int_threadPool reprents a collection of threads.  Each int_process has one
1083  * int_threadPool, which has multiple threads.
1084  **/
1085 class int_threadPool {
1086    friend class Dyninst::ProcControlAPI::ThreadPool;
1087    friend class Dyninst::ProcControlAPI::ThreadPool::iterator;
1088    friend class int_thread;
1089  private:
1090    std::vector<int_thread *> threads;
1091    std::vector<Thread::ptr> hl_threads;
1092    std::map<Dyninst::LWP, int_thread *> thrds_by_lwp;
1093
1094    mutable int_thread *initial_thread; // may be updated by side effect on Windows
1095    int_process *proc_;
1096    ThreadPool *up_pool;
1097    bool had_multiple_threads;
1098  public:
1099    int_threadPool(int_process *p);
1100    ~int_threadPool();
1101
1102    void setInitialThread(int_thread *thrd);
1103    void addThread(int_thread *thrd);
1104    void rmThread(int_thread *thrd);
1105    void noteUpdatedLWP(int_thread *thrd);
1106    void clear();
1107    bool hadMultipleThreads() const;
1108
1109    typedef std::vector<int_thread *>::iterator iterator;
1110    iterator begin() { return threads.begin(); }
1111    iterator end() { return threads.end(); }
1112    bool empty() { return threads.empty(); }
1113
1114    unsigned size() const;
1115
1116    int_process *proc() const;
1117    ThreadPool *pool() const;
1118
1119    int_thread *findThreadByLWP(Dyninst::LWP lwp);
1120    int_thread *initialThread() const;
1121    bool allHandlerStopped();
1122    bool allStopped(int state_id);
1123    
1124    void saveUserState(Event::ptr ev);
1125    void restoreUserState();
1126 };
1127
1128 /**
1129  * Represents a Dynamic Shared Object (aka DSO, aka .dll/.so) loaded by the process.  
1130  * Each DSO has a library name and load address.
1131  *
1132  * int_library doesn't hang directly from a process, but from its mem_state object.
1133  **/
1134 class int_library
1135 {
1136    friend class Dyninst::ProcControlAPI::LibraryPool;
1137    friend class Dyninst::ProcControlAPI::LibraryPool::iterator;
1138    friend class Dyninst::ProcControlAPI::LibraryPool::const_iterator;
1139   private:
1140    std::string name;
1141    Dyninst::Address load_address;
1142    Dyninst::Address data_load_address;
1143    Dyninst::Address dynamic_address;
1144    bool has_data_load;
1145    bool marked;
1146    void *user_data;
1147    Library::ptr up_lib;
1148    bool is_shared_lib;
1149   public:
1150    int_library(std::string n, 
1151                bool shared_lib,
1152                Dyninst::Address load_addr,
1153                Dyninst::Address dynamic_load_addr, 
1154                Dyninst::Address data_load_addr = 0, 
1155                bool has_data_load_addr = false);
1156    int_library(int_library *l);
1157    ~int_library();
1158    std::string getName();
1159    Dyninst::Address getAddr();
1160    Dyninst::Address getDataAddr();
1161    Dyninst::Address getDynamicAddr();
1162    bool hasDataAddr();
1163    
1164    void setMark(bool b);
1165    bool isMarked() const;
1166    
1167    void setUserData(void *d);
1168    void *getUserData();
1169
1170    bool isSharedLib() const;
1171
1172    Library::ptr getUpPtr() const;
1173    void markAsCleanable();
1174    
1175    void markAOut() { is_shared_lib = false; }
1176 };
1177
1178 /**
1179  * There are five (FIVE!) classes related to breakpoints:
1180  *
1181  * Breakpoint - The user interface to breakpoints.  The user will always 
1182  *  use this when handling breakpoints.  
1183  *
1184  * int_breakpoint - The internal handle for a breakpoint.  A Breakpoint
1185  *  will always have one int_breakpoint.  However, internal breakpoints
1186  *  (ie, the breakpoint used in System V library loading) don't necessary
1187  *  have the UI interface object of Breakpoint.
1188  * 
1189  *  int_breakpoint's aren't process specific (so they can be copied easily)
1190  *  upon fork.  A single int_breakpoint can be inserted into multiple 
1191  *  processes, and multiple times into one int_process.  
1192  * 
1193  *  An int_breakpoint can have properties, like a control transfer 
1194  *  int_breakpoint will transfer control when it executes, a
1195  *  onetime breakpoint will clean itself after being hit, and
1196  *  a thread-specific breakpoint will only trigger if hit by
1197  *  certain threads.
1198  *
1199  *  If internal code wants to keep a handle to a breakpoint, then
1200  *  it should use int_breakpoint.
1201  *
1202  * bp_instance - Each int_breakpoint/process/address triple is
1203  *  represented by a bp_instance.  This reprents an actual
1204  *  low-level breakpoint at some location.  Unless you're
1205  *  writing low-level BP code you can ignore this class.
1206  *
1207  *  bp_instance is an abstract class, implemented by sw_breakpoint
1208  *  and hw_breakpoint.
1209  *
1210  * sw_breakpoint is a type of bp_instance, as implemented by a 
1211  *  trap instruction.  A certain sequence of bytes is written
1212  *  into the process at a code location, which throws a SIGTRAP
1213  *  (or similar) when executed.
1214  *
1215  * hw_breakpoint is a type of bp_instance, as implemented by
1216  *  hardware debug registers.  These are usually used to implement
1217  *  things like watchpoints in debuggers.  They are usually 
1218  *  thread-specific and can set to trigger when code executes
1219  *  or data is read or written.  
1220  **/
1221 class int_breakpoint
1222 {
1223    friend class sw_breakpoint;
1224    friend class hw_breakpoint;
1225  private:
1226    Breakpoint::weak_ptr up_bp;
1227    Dyninst::Address to;
1228    bool isCtrlTransfer_;
1229    void *data;
1230
1231    bool hw;
1232    unsigned int hw_perms;
1233    unsigned int hw_size;
1234    bool onetime_bp;
1235    bool onetime_bp_hit;
1236    bool procstopper;
1237    bool suppress_callbacks;
1238    bool offset_transfer;
1239    std::set<Thread::const_ptr> thread_specific;
1240  public:
1241    int_breakpoint(Breakpoint::ptr up);
1242    int_breakpoint(Dyninst::Address to, Breakpoint::ptr up, bool off);
1243    int_breakpoint(unsigned int hw_prems_, unsigned int hw_size_, Breakpoint::ptr up);
1244    ~int_breakpoint();
1245
1246    bool isCtrlTransfer() const;
1247    Dyninst::Address toAddr() const;
1248    Dyninst::Address getAddress(int_process *p) const;
1249    void *getData() const;
1250    void setData(void *v);
1251    void setOneTimeBreakpoint(bool b);
1252    void markOneTimeHit();
1253    bool isOneTimeBreakpoint() const;
1254    bool isOneTimeBreakpointHit() const;
1255
1256    void setThreadSpecific(Thread::const_ptr p);
1257    bool isThreadSpecific() const;
1258    bool isThreadSpecificTo(Thread::const_ptr p) const;
1259
1260    void setProcessStopper(bool b);
1261    bool isProcessStopper() const;
1262
1263    void setSuppressCallbacks(bool);
1264    bool suppressCallbacks(void) const;
1265    
1266    bool isHW() const;
1267    unsigned getHWSize() const;
1268    unsigned getHWPerms() const;
1269    
1270    bool isOffsetTransfer() const;
1271    Breakpoint::weak_ptr upBreakpoint() const;
1272 };
1273
1274 class bp_instance
1275 {
1276    friend class Dyninst::ProcControlAPI::EventBreakpoint;
1277   protected:
1278    std::set<int_breakpoint *> bps;
1279    std::set<Breakpoint::ptr> hl_bps;
1280    Dyninst::Address addr;
1281    bool installed;
1282    int suspend_count;
1283    
1284    sw_breakpoint *swbp;
1285    hw_breakpoint *hwbp;
1286
1287    bool suspend_common();
1288    bool resume_common();
1289   public:
1290    virtual bool checkBreakpoint(int_breakpoint *bp, int_process *proc);
1291    virtual bool rmBreakpoint(int_process *proc, int_breakpoint *bp,
1292                              bool &empty, std::set<response::ptr> &resps);
1293    virtual async_ret_t uninstall(int_process *proc, std::set<response::ptr> &resps) = 0;
1294
1295    Address getAddr() const;
1296
1297    bp_instance(Address addr);
1298    bp_instance(const bp_instance *ip);
1299
1300    typedef std::set<int_breakpoint *>::iterator iterator;
1301    iterator begin();
1302    iterator end();
1303
1304    bool containsIntBreakpoint(int_breakpoint *bp);
1305    int_breakpoint *getCtrlTransferBP(int_thread *thread);
1306
1307    bool isInstalled() const;
1308    virtual bool needsClear() = 0;
1309
1310    virtual async_ret_t suspend(int_process *proc, std::set<response::ptr> &resps) = 0;
1311    virtual async_ret_t resume(int_process *proc, std::set<response::ptr> &resps) = 0;
1312
1313    sw_breakpoint *swBP();
1314    hw_breakpoint *hwBP();
1315    virtual ~bp_instance();
1316 };
1317  
1318
1319 //At least as large as any arch's trap instruction
1320 #define BP_BUFFER_SIZE 8
1321 //Long breakpoints can be used to artifically increase the size of the BP write,
1322 // which fools the BG breakpoint interception code that looks for 4 byte writes.
1323 #define BP_LONG_SIZE 4
1324 class sw_breakpoint : public bp_instance
1325 {
1326    friend class Dyninst::ProcControlAPI::EventBreakpoint;
1327    friend class int_process;
1328  private:
1329    mem_state::ptr memory;
1330
1331    char buffer[BP_BUFFER_SIZE];
1332    int buffer_size;
1333    bool prepped;
1334    bool long_breakpoint;
1335
1336    result_response::ptr write_response;
1337    mem_response::ptr read_response;
1338
1339    bool writeBreakpoint(int_process *proc, result_response::ptr write_response);
1340    bool saveBreakpointData(int_process *proc, mem_response::ptr read_response);
1341    bool restoreBreakpointData(int_process *proc, result_response::ptr res_resp);
1342
1343    sw_breakpoint(mem_state::ptr memory_, Dyninst::Address addr_);
1344  public:
1345    sw_breakpoint(mem_state::ptr memory_, const sw_breakpoint *ip);
1346    ~sw_breakpoint();
1347
1348    static sw_breakpoint *create(int_process *proc, int_breakpoint *bp, Dyninst::Address addr_);
1349    //Use these three functions to add a breakpoint
1350    bool prepBreakpoint(int_process *proc, mem_response::ptr mem_resp);
1351    bool insertBreakpoint(int_process *proc, result_response::ptr res_resp);
1352    bool addToIntBreakpoint(int_breakpoint *bp, int_process *proc);
1353
1354    virtual async_ret_t uninstall(int_process *proc, std::set<response::ptr> &resps);
1355    virtual async_ret_t suspend(int_process *proc, std::set<response::ptr> &resps);
1356    virtual async_ret_t resume(int_process *proc, std::set<response::ptr> &resps);
1357
1358    unsigned getNumIntBreakpoints() const;
1359    virtual bool needsClear();
1360 };
1361
1362 class hw_breakpoint : public bp_instance {
1363   friend class Dyninst::ProcControlAPI::EventBreakpoint;
1364 private:
1365   unsigned int hw_perms;
1366   unsigned int hw_size;
1367   bool proc_wide;
1368   int_thread *thr;
1369   bool error;
1370
1371   hw_breakpoint(int_thread *thr, unsigned mode, unsigned size,
1372                 bool pwide, Dyninst::Address addr);
1373 public:
1374   virtual async_ret_t uninstall(int_process *proc, std::set<response::ptr> &resps);
1375
1376
1377   static hw_breakpoint *create(int_process *proc, int_breakpoint *bp, Dyninst::Address addr_);
1378   ~hw_breakpoint();
1379   
1380   bool install(bool &done, std::set<response::ptr> &resps);
1381   unsigned int getPerms() const;
1382   unsigned int getSize() const;
1383   bool procWide() const;
1384   int_thread *getThread() const;
1385   virtual bool needsClear();
1386
1387   virtual async_ret_t suspend(int_process *proc, std::set<response::ptr> &resps);
1388   virtual async_ret_t resume(int_process *proc, std::set<response::ptr> &resps);
1389 };
1390
1391 /**
1392  * On PPC64 certain synchronization instructions can mis-behave if we
1393  * try to single-step across them.  This class recognizes these situations
1394  * and replaces a single-step operation with a breakpoint insertion/run over
1395  * the offending code.
1396  **/
1397 class emulated_singlestep {
1398    // Breakpoints that are added and removed in a group to emulate
1399    // a single step with breakpoints
1400   private:
1401    bool saved_user_single_step;
1402    bool saved_single_step;
1403    int_breakpoint *bp;
1404    int_thread *thr;
1405    std::set<Address> addrs;
1406
1407   public:
1408    emulated_singlestep(int_thread *thr);
1409    ~emulated_singlestep();
1410    
1411    bool containsBreakpoint(Address addr) const;
1412    async_ret_t add(Address addr);
1413    async_ret_t clear();
1414    void restoreSSMode();
1415
1416    std::set<response::ptr> clear_resps;
1417 };
1418
1419 struct clearError {
1420    void operator()(Process::ptr p) {
1421       p->clearLastError();
1422    }
1423
1424    template <class T>
1425    void operator()(const std::pair<T, Process::const_ptr> &v) {
1426       v.second->clearLastError();
1427    }
1428    template <class T>
1429    void operator()(const std::pair<Process::const_ptr, T> &v) {
1430       v.first->clearLastError();
1431    }
1432    template <class T>
1433    void operator()(const std::pair<T, Process::ptr> &v) {
1434       v.second->clearLastError();
1435    }
1436    template <class T>
1437    void operator()(const std::pair<Process::ptr, T> &v) {
1438       v.first->clearLastError();
1439    }
1440 };
1441
1442 struct setError {
1443 private:
1444    err_t err;
1445    const char *err_str;
1446 public:
1447    setError(err_t e, const char *s) { err = e; err_str = s; }
1448    void operator()(Process::ptr p) {
1449       p->setLastError(err, err_str);
1450    }
1451    void operator()(const std::pair<Address, Process::ptr> &v) {
1452       v.second->setLastError(err, err_str);
1453    }
1454 };
1455
1456 /**
1457  * The notify class is the internal interface to th UI Notify class.  
1458  * It is used to signal the user (via platform-specific interfaces)
1459  * that an event is ready to be handled.
1460  **/
1461 class int_notify {
1462 #if defined(os_windows)
1463         class windows_details
1464         {
1465                 HANDLE evt;
1466         public:
1467                 windows_details() : evt(INVALID_HANDLE_VALUE)
1468                 {
1469                 }
1470                 typedef HANDLE wait_object_t;
1471                 void noteEvent()
1472                 {
1473                         ::ReleaseSemaphore(evt, 1, NULL);
1474                 }
1475                 void clearEvent()
1476                 {
1477                         // No-op with semaphores
1478                         //::ResetEvent(evt);
1479                 }
1480
1481                 bool createInternals()
1482                 {
1483                         evt = ::CreateSemaphore(NULL, 0, 1000, NULL);
1484                         return evt  != INVALID_HANDLE_VALUE;
1485                 }
1486                 bool internalsValid()
1487                 {
1488                         return evt != INVALID_HANDLE_VALUE;
1489                 }
1490                 wait_object_t getWaitObject()
1491                 {
1492                         return evt;
1493                 }
1494         };
1495         typedef windows_details details_t;
1496 #else
1497         class unix_details
1498         {
1499                 friend class int_notify;
1500                 int pipe_in;
1501                 int pipe_out;
1502                 void writeToPipe();
1503                 void readFromPipe();
1504         public:
1505                 unix_details();
1506                 typedef int wait_object_t;
1507                 void noteEvent();
1508                 void clearEvent();
1509                 bool createInternals();
1510                 bool internalsValid();
1511                 wait_object_t getWaitObject();
1512         };
1513         typedef unix_details details_t;
1514 #endif
1515
1516         typedef details_t::wait_object_t wait_object_t;
1517    friend int_notify *notify();
1518    friend EventNotify *Dyninst::ProcControlAPI::evNotify();
1519  private:
1520    static int_notify *the_notify;
1521    EventNotify *up_notify;
1522    std::set<EventNotify::notify_cb_t> cbs;
1523    int events_noted;
1524    details_t my_internals;
1525  public:
1526    int_notify();
1527    void noteEvent();
1528    void clearEvent();
1529    
1530    void registerCB(EventNotify::notify_cb_t cb);
1531    void removeCB(EventNotify::notify_cb_t cb);
1532    bool hasEvents();
1533    details_t::wait_object_t getWaitable();
1534 };
1535 int_notify *notify();
1536
1537 extern void setGeneratorThread(long t);
1538 void setHandlerThread(long t);
1539 bool isGeneratorThread();
1540 bool isHandlerThread();
1541 bool isUserThread();
1542 HandlerPool *createDefaultHandlerPool(int_process *p);
1543 HandlerPool *plat_createDefaultHandlerPool(HandlerPool *hpool);
1544
1545 class MTManager {
1546   friend MTManager *mt();
1547   friend class MTLock;
1548 private:
1549   static MTManager *mt_;
1550   DThread evhandler_thread;
1551   CondVar pending_event_lock;
1552   Mutex work_lock;
1553   bool have_queued_events;
1554   bool is_running;
1555   bool should_exit;
1556   Process::thread_mode_t threadMode;
1557   
1558   void evhandler_main();
1559 #if defined(os_windows)
1560   static unsigned long WINAPI evhandler_main_wrapper(void *);
1561 #else
1562   static void evhandler_main_wrapper(void *);
1563 #endif
1564   void eventqueue_cb();
1565   
1566 public:
1567   static const Process::thread_mode_t default_thread_mode = Process::HandlerThreading;
1568   MTManager();
1569   ~MTManager();
1570   
1571   void run();
1572   void stop();
1573
1574   void startWork();
1575   void endWork();
1576   
1577   bool handlerThreading();
1578   Process::thread_mode_t getThreadMode();
1579   bool setThreadMode(Process::thread_mode_t tm, bool init = false);
1580
1581   static void eventqueue_cb_wrapper();
1582 }; 
1583
1584 inline MTManager *mt() { 
1585    return MTManager::mt_; 
1586 }
1587
1588 class MTLock
1589 {
1590  private:
1591    bool should_unlock;
1592  public:
1593    typedef enum {allow_init} initialize;
1594    typedef enum {allow_generator} generator;
1595    typedef enum {nocb, deliver_callbacks} callbacks;
1596    MTLock(initialize, callbacks c = nocb)
1597    {
1598       should_unlock = true;
1599       if (!MTManager::mt_) {
1600          MTManager::mt_ = new MTManager();
1601          if ((MTManager::default_thread_mode == Process::HandlerThreading) ||
1602              (MTManager::default_thread_mode == Process::CallbackThreading)) {
1603             mt()->startWork();
1604          }
1605          mt()->setThreadMode(MTManager::default_thread_mode, true);
1606       }
1607       else if (mt()->handlerThreading()) {
1608          mt()->startWork();
1609          if ((c == deliver_callbacks) && 
1610              (MTManager::default_thread_mode == Process::HandlerThreading) && 
1611              notify()->hasEvents()) 
1612          {
1613             pthrd_printf("MTLock triggered event handling\n");
1614             int_process::waitAndHandleEvents(false);
1615             pthrd_printf("MTLock triggered event handling finished\n");
1616          }
1617       }
1618    }
1619
1620    MTLock(generator)
1621    {
1622       if (isGeneratorThread()) {
1623          should_unlock = false;
1624          return;
1625       }
1626       should_unlock = true;
1627       if (mt()->handlerThreading()) {
1628          mt()->startWork();
1629       }
1630    }
1631
1632    MTLock(callbacks) 
1633    {
1634       assert(!isGeneratorThread());
1635       should_unlock = true;
1636       if (mt()->handlerThreading()) {
1637          mt()->startWork();
1638          if (notify()->hasEvents() && 
1639              (MTManager::default_thread_mode == Process::HandlerThreading) )
1640          {
1641             pthrd_printf("MTLock triggered event handling\n");
1642             int_process::waitAndHandleEvents(false);
1643             pthrd_printf("MTLock triggered event handling finished\n");
1644          }
1645       }
1646    }
1647
1648    MTLock()
1649    {
1650       assert(!isGeneratorThread());
1651       should_unlock = true;
1652       if (mt()->handlerThreading())
1653          mt()->startWork();
1654    }
1655
1656    ~MTLock() {
1657       if (should_unlock && mt()->handlerThreading())
1658          mt()->endWork();
1659    }
1660 };
1661
1662 // A class to stop the various threads that have been started when
1663 // the library is deinitialized
1664 class int_cleanup {
1665     public:
1666         ~int_cleanup();
1667 };
1668
1669 #define PROC_EXIT_TEST(STR, RET)                      \
1670    if (!llproc_) {                                    \
1671      perr_printf(STR " on exited process\n");         \
1672      setLastError(err_exited, "Process is exited");   \
1673      return RET;                                      \
1674    }
1675
1676 #define PROC_DETACH_TEST(STR, RET)                       \
1677    if (llproc_->getState() == int_process::detached) {   \
1678      perr_printf(STR " on detached process\n");          \
1679      setLastError(err_detached, "Process is detached");  \
1680      return RET;                                         \
1681    }
1682
1683 #define PROC_CB_TEST(STR, RET)                                          \
1684    if (int_process::isInCB()) {                                         \
1685      perr_printf(STR " while in callback\n");                           \
1686      setLastError(err_incallback, "Cannot do operation from callback"); \
1687      return RET;                                                        \
1688    }
1689
1690 #define PROC_EXIT_DETACH_TEST(STR, RET)         \
1691    PROC_EXIT_TEST(STR, RET)                     \
1692    PROC_DETACH_TEST(STR, RET)
1693
1694 #define PROC_EXIT_DETACH_CB_TEST(STR, RET)      \
1695    PROC_EXIT_TEST(STR, RET)                     \
1696    PROC_DETACH_TEST(STR, RET)                   \
1697    PROC_CB_TEST(STR, RET)
1698
1699 #define THREAD_EXIT_TEST(STR, RET)                    \
1700    if (!llthread_) {                                  \
1701      perr_printf(STR " on exited thread\n");          \
1702      setLastError(err_exited, "Thread is exited");    \
1703      return RET;                                      \
1704    }                                                  \
1705    if (!llthread_->llproc()) {                        \
1706      perr_printf(STR " on exited process\n");         \
1707      setLastError(err_exited, "Process is exited");   \
1708      return RET;                                      \
1709    }
1710
1711 #define THREAD_DETACH_TEST(STR, RET)                                    \
1712    if (llthread_->llproc()->getState() == int_process::detached) {      \
1713      perr_printf(STR " on detached process\n");                         \
1714      setLastError(err_detached, "Process is detached");                 \
1715      return RET;                                                        \
1716    }                                                                    \
1717
1718 #define THREAD_STOP_TEST(STR, RET)                                     \
1719    if (llthread_->getUserState().getState() != int_thread::stopped) {  \
1720       setLastError(err_notstopped, "Thread not stopped");              \
1721       perr_printf(STR " on running thread %d\n", llthread_->getLWP()); \
1722       return RET;                                                      \
1723    }
1724
1725 #define THREAD_EXIT_DETACH_TEST(STR, RET)         \
1726    THREAD_EXIT_TEST(STR, RET)                     \
1727    THREAD_DETACH_TEST(STR, RET)
1728
1729 #define THREAD_EXIT_DETACH_CB_TEST(STR, RET)      \
1730    THREAD_EXIT_TEST(STR, RET)                     \
1731    THREAD_DETACH_TEST(STR, RET)                   \
1732    PROC_CB_TEST(STR, RET)
1733
1734 #define THREAD_EXIT_DETACH_STOP_TEST(STR, RET)    \
1735    THREAD_EXIT_TEST(STR, RET)                     \
1736    THREAD_DETACH_TEST(STR, RET)                   \
1737    THREAD_STOP_TEST(STR, RET)
1738
1739 #define PTR_EXIT_TEST(P, STR, RET)                       \
1740    if (!P || !P->llproc()) {                             \
1741       perr_printf(STR " on exited process\n");           \
1742       P->setLastError(err_exited, "Process is exited");  \
1743       return RET;                                        \
1744    }
1745
1746 #endif