Merge branch 'master' into bgq_ramdisk_io
[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    bool getMemoryAccessRights(Dyninst::Address addr, size_t size,
438                               Process::mem_perm& rights);
439    bool setMemoryAccessRights(Dyninst::Address addr, size_t size,
440                               Process::mem_perm rights,
441                               Process::mem_perm& oldRights);
442    // FIXME pure virtual function
443    virtual bool plat_getMemoryAccessRights(Dyninst::Address addr, size_t size,
444                                            Process::mem_perm& rights);
445    virtual bool plat_setMemoryAccessRights(Dyninst::Address addr, size_t size,
446                                            Process::mem_perm rights,
447                                            Process::mem_perm& oldRights);
448    virtual bool plat_decodeMemoryRights(Process::mem_perm& rights_internal,
449                                         unsigned long rights);
450    virtual bool plat_encodeMemoryRights(Process::mem_perm rights_internal,
451                                         unsigned long& rights);
452
453    virtual bool findAllocatedRegionAround(Dyninst::Address addr,
454                                           Process::MemoryRegion& memRegion);
455    virtual bool plat_findAllocatedRegionAround(Dyninst::Address addr,
456                                                Process::MemoryRegion& memRegion);
457
458    memCache *getMemCache();
459
460    virtual bool plat_getOSRunningStates(std::map<Dyninst::LWP, bool> &runningStates) = 0;
461         // Windows-only technically
462    virtual void* plat_getDummyThreadHandle() const { return NULL; }
463    
464    virtual void noteNewDequeuedEvent(Event::ptr ev);
465
466    static bool isInCB();
467    static void setInCB(bool b);
468
469    void throwNopEvent();
470    void throwRPCPostEvent();
471    
472    virtual bool plat_supportFork();
473    virtual bool plat_supportExec();
474    virtual bool plat_supportDOTF();
475
476    virtual bool plat_supportThreadEvents();
477    virtual bool plat_supportLWPCreate();
478    virtual bool plat_supportLWPPreDestroy();
479    virtual bool plat_supportLWPPostDestroy();
480
481    virtual bool plat_preHandleEvent();
482    virtual bool plat_postHandleEvent();
483    virtual bool plat_preAsyncWait();
484    virtual bool plat_supportHWBreakpoint();
485
486    virtual bool plat_needsPCSaveBeforeSingleStep();
487    virtual async_ret_t plat_needsEmulatedSingleStep(int_thread *thr, std::vector<Dyninst::Address> &result);
488    virtual bool plat_convertToBreakpointAddress(Address &, int_thread *) { return true; }
489    virtual void plat_getEmulatedSingleStepAsyncs(int_thread *thr, std::set<response::ptr> resps);
490    virtual bool plat_needsThreadForMemOps() const { return true; }
491    virtual unsigned int plat_getCapabilities();
492    virtual Event::ptr plat_throwEventsBeforeContinue(int_thread *thr);
493    
494    int_library *getLibraryByName(std::string s) const;
495    size_t numLibs() const;
496    virtual bool refresh_libraries(std::set<int_library *> &added_libs,
497                                   std::set<int_library *> &rmd_libs,
498                                   bool &waiting_for_async,
499                                   std::set<response::ptr> &async_responses) = 0;
500
501    virtual bool plat_isStaticBinary() = 0;
502    virtual int_library *plat_getExecutable() = 0;
503
504    virtual bool plat_supportDirectAllocation() const { return false; }
505    bool forceGeneratorBlock() const;
506    void setForceGeneratorBlock(bool b);
507
508    std::string getExecutable() const;
509    static bool isInCallback();
510
511    static int_process *in_waitHandleProc;
512    // TODO: clean up w/enum
513    bool wasCreatedViaAttach() const { return createdViaAttach; }
514    void wasCreatedViaAttach(bool val) { createdViaAttach = val; }
515
516    // Platform-specific; is this address in what we consider a system lib.
517    virtual bool addrInSystemLib(Address /*addr*/) { return false; }
518
519    ProcStopEventManager &getProcStopManager();
520
521    std::map<int, int> &getProcDesyncdStates();
522
523    bool isRunningSilent(); //No callbacks
524    void setRunningSilent(bool b);
525
526    virtual ExecFileInfo* plat_getExecutableInfo() const { return NULL; }
527
528    int_libraryTracking *getLibraryTracking();
529    int_LWPTracking *getLWPTracking();
530    int_threadTracking *getThreadTracking();
531    int_followFork *getFollowFork();
532    int_multiToolControl *getMultiToolControl();
533    int_signalMask *getSignalMask();
534    int_callStackUnwinding *getCallStackUnwinding();
535    int_BGQData *getBGQData();
536    int_remoteIO *getRemoteIO();
537
538    //Interface into BGQ-specific process data.
539  protected:
540    State state;
541    Dyninst::PID pid;
542    creationMode_t creation_mode;
543    std::string executable;
544    std::vector<std::string> argv;
545    std::vector<std::string> env;
546    std::map<int,int> fds;
547    Dyninst::Architecture arch;
548    int_threadPool *threadpool;
549    Process::ptr up_proc;
550    HandlerPool *handlerpool;
551    LibraryPool libpool;
552    bool hasCrashSignal;
553    int crashSignal;
554    bool hasExitCode;
555    bool forcedTermination;
556    bool silent_mode;
557    int exitCode;
558    static bool in_callback;
559    mem_state::ptr mem;
560    std::map<Dyninst::Address, unsigned> exec_mem_cache;
561    int continueSig;
562    bool createdViaAttach;
563    memCache mem_cache;
564    Counter async_event_count;
565    Counter force_generator_block_count;
566    Counter startupteardown_procs;
567    ProcStopEventManager proc_stop_manager;
568    std::map<int, int> proc_desyncd_states;
569    void *user_data;
570    err_t last_error;
571    const char *last_error_string;
572    SymbolReaderFactory *symbol_reader;
573    static SymbolReaderFactory *user_set_symbol_reader;
574
575    //Cached PlatFeature pointers, which are used to avoid slow dynamic casts
576    // (they're used frequently in tight loops on BG/Q)
577    int_libraryTracking *pLibraryTracking;
578    int_LWPTracking *pLWPTracking;
579    int_threadTracking *pThreadTracking;
580    int_followFork *pFollowFork;
581    int_multiToolControl *pMultiToolControl;
582    int_signalMask *pSignalMask;
583    int_callStackUnwinding *pCallStackUnwinding;
584    int_BGQData *pBGQData;
585    int_remoteIO *pRemoteIO;
586    bool LibraryTracking_set;
587    bool LWPTracking_set;
588    bool ThreadTracking_set;
589    bool FollowFork_set;
590    bool MultiToolControl_set;
591    bool SignalMask_set;
592    bool CallStackUnwinding_set;
593    bool BGQData_set;
594    bool remoteIO_set;
595 };
596
597 struct ProcToIntProc {
598    int_process *operator()(const Process::ptr &p) const { return p->llproc(); }
599 };
600
601 /**
602  * These processes represent four common models of how to stop/continue threads.
603  * If a new platform follows one of these, then inherit them from the appropriate
604  * class.
605  *
606  * indep_lwp_control_process - Each thread/lwp stops and continues independent from
607  *  each other one.  (Linux)
608  * unified_lwp_control_process - There is no thread-specific control, every thread 
609  *  stops/runs alongside its peers (BG/P)
610  * hybrid_lwp_control_process - All threads in a process are run/stopped when
611  *  a thread stops/runs, but threads can be overridden with a suspend state
612  *  that can keep them stopped when others run (FreeBSD, Windows, BG/Q).
613  **/
614 class indep_lwp_control_process : virtual public int_process
615 {
616   protected:
617    virtual bool plat_syncRunState();
618   public:
619    indep_lwp_control_process(Dyninst::PID p, std::string e, std::vector<std::string> a, 
620                              std::vector<std::string> envp, std::map<int,int> f);
621    indep_lwp_control_process(Dyninst::PID pid_, int_process *p);
622    virtual ~indep_lwp_control_process();
623 };
624
625 class unified_lwp_control_process : virtual public int_process
626 {
627   protected:
628    virtual bool plat_syncRunState();
629   public:
630    unified_lwp_control_process(Dyninst::PID p, std::string e, std::vector<std::string> a, 
631                                std::vector<std::string> envp, std::map<int,int> f);
632    unified_lwp_control_process(Dyninst::PID pid_, int_process *p);
633    virtual ~unified_lwp_control_process();
634
635    virtual bool plat_processGroupContinues();
636 };
637
638 class hybrid_lwp_control_process : virtual public int_process
639 {
640   protected:
641    virtual bool plat_syncRunState();
642    virtual bool plat_suspendThread(int_thread *thr) = 0;
643    virtual bool plat_resumeThread(int_thread *thr) = 0;
644    bool debugger_stopped;
645   public:
646    hybrid_lwp_control_process(Dyninst::PID p, std::string e, std::vector<std::string> a, 
647                               std::vector<std::string> envp, std::map<int,int> f);
648    hybrid_lwp_control_process(Dyninst::PID pid_, int_process *p);
649    virtual ~hybrid_lwp_control_process();
650
651    virtual bool suspendThread(int_thread *thr);
652    virtual bool resumeThread(int_thread *thr);
653
654    virtual void noteNewDequeuedEvent(Event::ptr ev);
655    virtual bool plat_debuggerSuspended();
656
657    virtual bool plat_processGroupContinues();
658 };
659
660 /**
661  * A collection of registers from a thread.
662  **/
663 class int_registerPool
664 {
665  public:
666    int_registerPool();
667    int_registerPool(const int_registerPool &c);
668    ~int_registerPool();
669
670    typedef std::map<Dyninst::MachRegister, Dyninst::MachRegisterVal> reg_map_t;
671    reg_map_t regs;
672    bool full;
673    int_thread *thread;
674
675    typedef reg_map_t::iterator iterator;
676    typedef reg_map_t::const_iterator const_iterator;
677 };
678
679 /**
680  * When a thread/process exits we delete the int_process/int_thread objects.  But,
681  * we leave the UI handles Process/Thread around until the user gets rid of their
682  * last pointer.  There are only a few operations that are legal on an exited process
683  * (such as getting the pid or exitcode).  thread_exitstate and proc_exitstate hold that 
684  * information after a process exits. 
685  **/
686 class thread_exitstate
687 {
688   public:
689    Dyninst::LWP lwp;
690    Dyninst::THR_ID thr_id;
691    Process::ptr proc_ptr;
692    void *user_data;
693 };
694
695 class proc_exitstate
696 {
697   public:
698    Dyninst::PID pid;
699    bool exited;
700    bool crashed;
701    int crash_signal;
702    int exit_code;
703    err_t last_error;
704    const char *last_error_msg;
705    void *user_data;
706
707    void setLastError(err_t e_, const char *m) { last_error = e_; last_error_msg = m; }
708 };
709
710 /**
711  * int_thread repesents a thread/lwp (PC assumes an M:N model of 1:1).  See the comment
712  * above int_process, most of which applies here.
713  *
714  * An int_process also holds the stopped/running state of a process.  See the StateTracker
715  * comment for a longer discussion here.
716  **/
717 class int_thread
718 {
719    friend class Dyninst::ProcControlAPI::Thread;
720    friend class int_threadPool;
721    friend class ProcStopEventManager;
722    friend class hw_breakpoint;
723  protected:
724    int_thread(int_process *p, Dyninst::THR_ID t, Dyninst::LWP l);
725    static int_thread *createThreadPlat(int_process *proc, 
726                                        Dyninst::THR_ID thr_id, 
727                                        Dyninst::LWP lwp_id,
728                                        bool initial_thrd);
729
730 public:
731    enum attach_status_t {
732       as_unknown = 0,          //Threads found by getThreadLWPs come in as_needs_attach, others
733       as_created_attached,     // come int as_created_attached.  Up to platforms to interpret this
734       as_needs_attach          // however they want.
735    };
736
737    static int_thread *createThread(int_process *proc, 
738                                    Dyninst::THR_ID thr_id, 
739                                    Dyninst::LWP lwp_id,
740                                    bool initial_thrd,
741                                    attach_status_t astatus = as_unknown);
742    static int_thread *createRPCThread(int_process *p);
743    Process::ptr proc() const;
744    int_process *llproc() const;
745
746    Dyninst::LWP getLWP() const;
747    void changeLWP(Dyninst::LWP new_lwp);
748
749 #define RUNNING_STATE(S) (S == int_thread::running || S == int_thread::neonatal_intermediate)
750    typedef enum {
751       none=0,
752       neonatal=1,
753       neonatal_intermediate=2,
754       running=3,
755       stopped=4,
756       dontcare=5,
757       ditto=6,
758       exited=7,
759       detached=8,
760       errorstate=9
761    } State;
762    //The order of these is very important.  Lower numbered
763    // states take precedence over higher numbered states.
764    static const int NumStateIDs = 17;
765    static const int NumTargetStateIDs = (NumStateIDs-2); //Handler and Generator states aren't target states
766
767    static const int AsyncStateID            = 0;
768    static const int CallbackStateID         = 1;
769    static const int PendingStopStateID      = 2;
770    static const int IRPCStateID             = 3;
771    static const int IRPCSetupStateID        = 4;
772    static const int IRPCWaitStateID         = 5;
773    static const int BreakpointStateID       = 6;
774    static const int InternalStateID         = 7;
775    static const int BreakpointResumeStateID = 8;
776    static const int ExitingStateID          = 9;
777    static const int StartupStateID          = 10;
778    static const int DetachStateID           = 11;
779    static const int UserRPCStateID          = 12;
780    static const int ControlAuthorityStateID = 13;
781    static const int UserStateID             = 14;
782    static const int HandlerStateID          = 15;
783    static const int GeneratorStateID        = 16;
784    static std::string stateIDToName(int id);
785
786    /**
787     * Documentation on StateTracker.  aka How we stop/continue the process:
788     *
789     * Making a decision on when to stop/continue a thread is complicated,
790     * especially when multiple events are happening on multiple threads.
791     * We have to consider cases like an iRPC running on one thread, while
792     * another thread handles a breakpoint and another thread is being 
793     * stopped by the user.  
794     *
795     * Each of these events might try to change the stop/running states of
796     * other threads, which can lead to conflicts over who's running.
797     * We resolve these conflicts by:
798     * - Giving each PC subsystem (e.g., iRPCs, breakpoints, user stops, ...) its
799     *   variable indicating whether a thread should run.  These are the StateTrackers.
800     * - When we acutually decide whether a thread should stop/run, we use a priority-based
801     *   projection to reduce the multiple StateTrackers from each subsystem into
802     *   a single target state (this happens in int_process::syncRunState).
803     *
804     * As an example, if you look below you'll see that the IRPC subsystem's 
805     * StateTrackers are a higher priority than the Breakpoint handling
806     * subsystem.  That means that if an IRPC and a breakpoint are happening
807     * at the same time, then we'll handle the stop/continues for the IRPC
808     * first.  When those are done (e.g., when the iRPC subsystem sets
809     * its StateTrackers to the dontcare value), then we'll move on to 
810     * handle the breakpoints.
811     *
812     * The UserState is one of the lowest priority StateTrackers--meaning
813     * everything else takes precedence.  This state represents the wishes
814     * of the user.  You can override the user's wishes (i.e, impose a 
815     * temporary stop while handling something) by setting a higher priority
816     * state, doing your work, then clearing that state.
817     *
818     * In general, most people will use StateTrackers from Handlers when
819     * dealing with an event that might have multiple stages.  In these cases,
820     * have the first stage of the event (or the code that starts the events)
821     * set the StateTracker to the desired state.  Have the last stage of the
822     * event clear the StateTracker.  Events that can be handled with a single
823     * stage (e.g, forwarding a signal) don't usually need a StateTracker.
824     *
825     * The HandlerState and GeneratorState are two special case StateTrackers.
826     * Instead of representing a goal state, they represent the actual 
827     * stop/running state of a thread.  The GenratorState is the state
828     * as viewed by PC's generator thread, and similar HandlerState is for
829     * PC's handler thread.  These are seperate variables so that we don't
830     * get races if they both read/update that variable at once.  Most of the
831     * time, you'll want the HandlerState.
832     **/
833    class StateTracker {
834      protected:
835       State state;
836       int id;
837       int sync_level;
838       int_thread *up_thr;
839      public:
840       StateTracker(int_thread *t, int id, int_thread::State initial);
841
842       void desyncState(State ns = int_thread::none);
843       void desyncStateProc(State ns = int_thread::none);
844
845       bool setState(State ns = int_thread::none);
846       bool setStateProc(State ns = int_thread::none);
847       
848       void restoreState();
849       void restoreStateProc();
850       State getState() const;
851       bool isDesynced() const;
852
853       std::string getName() const;
854       int getID() const;
855       
856       int_thread *debugthr() const { return up_thr; }
857    };
858
859    //State management, see above comment on states
860    StateTracker &getExitingState();
861    StateTracker &getStartupState();
862    StateTracker &getBreakpointState();
863    StateTracker &getBreakpointResumeState();
864    StateTracker &getCallbackState();
865    StateTracker &getIRPCState();
866    StateTracker &getIRPCSetupState();
867    StateTracker &getIRPCWaitState();
868    StateTracker &getAsyncState();
869    StateTracker &getInternalState();
870    StateTracker &getDetachState();
871    StateTracker &getControlAuthorityState();
872    StateTracker &getUserRPCState();
873    StateTracker &getUserState();
874    StateTracker &getHandlerState();
875    StateTracker &getGeneratorState();
876    StateTracker &getPendingStopState();
877
878    StateTracker &getStateByID(int id);
879    StateTracker &getActiveState();
880    static char stateLetter(State s);
881
882    Counter &handlerRunningThreadsCount();
883    Counter &generatorRunningThreadsCount();
884    Counter &syncRPCCount();
885    Counter &runningSyncRPCThreadCount();
886    Counter &pendingStopsCount();
887    Counter &clearingBPCount();
888    Counter &procStopRPCCount();
889    Counter &getGeneratorNonExitedThreadCount();
890    Counter &neonatalThreadCount();
891       
892    //Process control
893    bool intStop();
894    bool intCont();
895    async_ret_t handleSingleStepContinue();
896
897    void terminate();
898
899    void setContSignal(int sig);
900    int getContSignal();
901
902    virtual bool plat_cont() = 0;
903    virtual bool plat_stop() = 0;
904    void setPendingStop(bool b);
905    bool hasPendingStop() const;
906
907    bool wasRunningWhenAttached() const;
908    void setRunningWhenAttached(bool b);
909    bool isStopped(int state_id);
910
911    // Is this thread's lifetime only an IRPC and it gets
912    // discarded afterwards?
913    virtual bool isRPCEphemeral() const { return false; }
914
915    //Single-step
916    bool singleStepMode() const;
917    void setSingleStepMode(bool s);
918    bool singleStepUserMode() const;
919    void setSingleStepUserMode(bool s);
920    bool singleStep() const;
921    void markClearingBreakpoint(bp_instance *bp);
922    bp_instance *isClearingBreakpoint();
923    void markStoppedOnBP(bp_instance *bp);
924    bp_instance *isStoppedOnBP();
925
926    // Emulating single steps with breakpoints
927    void addEmulatedSingleStep(emulated_singlestep *es);
928    void rmEmulatedSingleStep(emulated_singlestep *es);
929    emulated_singlestep *getEmulatedSingleStep();
930
931    //RPC Management
932    void addPostedRPC(int_iRPC_ptr rpc_);
933    rpc_list_t *getPostedRPCs();
934    bool hasPostedRPCs();
935    void setRunningRPC(int_iRPC_ptr rpc_);
936    void clearRunningRPC();
937    int_iRPC_ptr runningRPC() const;
938    bool saveRegsForRPC(allreg_response::ptr response);
939    bool restoreRegsForRPC(bool clear, result_response::ptr response);
940    bool hasSavedRPCRegs();
941    void incSyncRPCCount();
942    void decSyncRPCCount();
943    bool hasSyncRPC();
944    int_iRPC_ptr nextPostedIRPC() const;
945
946    int_iRPC_ptr hasRunningProcStopperRPC() const;
947    virtual bool notAvailableForRPC() {
948                 return false;
949    }
950
951    //Register Management
952    bool getAllRegisters(allreg_response::ptr result);
953    bool getRegister(Dyninst::MachRegister reg, reg_response::ptr result);
954    bool setAllRegisters(int_registerPool &pool, result_response::ptr result);
955    bool setRegister(Dyninst::MachRegister reg, Dyninst::MachRegisterVal val, result_response::ptr result);
956
957    virtual bool plat_getAllRegisters(int_registerPool &pool) = 0;
958    virtual bool plat_getRegister(Dyninst::MachRegister reg, 
959                                  Dyninst::MachRegisterVal &val) = 0;
960    virtual bool plat_setAllRegisters(int_registerPool &pool) = 0;
961    virtual bool plat_setRegister(Dyninst::MachRegister reg, 
962                                  Dyninst::MachRegisterVal val) = 0;
963
964    virtual bool plat_getAllRegistersAsync(allreg_response::ptr result);
965    virtual bool plat_getRegisterAsync(Dyninst::MachRegister reg, 
966                                       reg_response::ptr result);
967    virtual bool plat_setAllRegistersAsync(int_registerPool &pool,
968                                           result_response::ptr result);
969    virtual bool plat_setRegisterAsync(Dyninst::MachRegister reg, 
970                                       Dyninst::MachRegisterVal val,
971                                       result_response::ptr result);
972    virtual void plat_terminate();
973
974    void updateRegCache(int_registerPool &pool);
975    void updateRegCache(Dyninst::MachRegister reg, Dyninst::MachRegisterVal val);
976    void clearRegCache();
977
978    // The exiting property is separate from the main state because an
979    // exiting thread can either be running or stopped (depending on the
980    // desires of the user).
981    bool isExiting() const;
982    void setExiting(bool b);
983    bool isExitingInGenerator() const;
984    void setExitingInGenerator(bool b);
985
986    static void cleanFromHandler(int_thread *thr, bool should_delete);
987
988    //Misc
989    virtual bool attach() = 0;
990    Thread::ptr thread();
991
992    typedef void(*continue_cb_t)(int_thread *thrd);
993    static void addContinueCB(continue_cb_t cb);
994    void triggerContinueCBs();
995
996    void throwEventsBeforeContinue();
997
998    //User level thread info
999    void setTID(Dyninst::THR_ID tid_);
1000    virtual bool haveUserThreadInfo();
1001    virtual bool getTID(Dyninst::THR_ID &tid);
1002    virtual bool getStartFuncAddress(Dyninst::Address &addr);
1003    virtual bool getStackBase(Dyninst::Address &addr);
1004    virtual bool getStackSize(unsigned long &size);
1005    virtual bool getTLSPtr(Dyninst::Address &addr);
1006       
1007    // Windows-only; default implementation is "yes, we're a user thread"
1008    virtual bool isUser() const { return true; }
1009
1010    virtual unsigned hwBPAvail(unsigned mode);
1011    virtual bool rmHWBreakpoint(hw_breakpoint *bp,
1012                                bool suspend,
1013                                std::set<response::ptr> &resps,
1014                                bool &done);
1015    virtual bool addHWBreakpoint(hw_breakpoint *bp,
1016                                 bool resume,
1017                                 std::set<response::ptr> &resps,
1018                                 bool &done);
1019    virtual EventBreakpoint::ptr decodeHWBreakpoint(response::ptr &resp,
1020                                                    bool have_reg = false,
1021                                                    Dyninst::MachRegisterVal regval = 0);
1022    virtual bool bpNeedsClear(hw_breakpoint *hwbp);
1023
1024    virtual ~int_thread();
1025    static const char *stateStr(int_thread::State s);
1026
1027    State getTargetState() const;
1028    void setTargetState(State s);
1029
1030    void setSuspended(bool b);
1031    bool isSuspended() const;
1032    void setLastError(err_t ec, const char *es);
1033
1034    hw_breakpoint *getHWBreakpoint(Address addr);
1035
1036  protected:
1037    Dyninst::THR_ID tid;
1038    Dyninst::LWP lwp;
1039    int_process *proc_;
1040    Thread::ptr up_thread;
1041    int continueSig_;
1042    attach_status_t attach_status;
1043
1044    Counter handler_running_thrd_count;
1045    Counter generator_running_thrd_count;
1046    Counter sync_rpc_count;
1047    Counter sync_rpc_running_thr_count;
1048    Counter pending_stop;
1049    Counter clearing_bp_count;
1050    Counter proc_stop_rpc_count;
1051    Counter generator_nonexited_thrd_count;
1052    Counter neonatal_threads;
1053
1054    StateTracker exiting_state;
1055    StateTracker startup_state;
1056    StateTracker pending_stop_state;
1057    StateTracker callback_state;
1058    StateTracker breakpoint_state;
1059    StateTracker breakpoint_resume_state;
1060    StateTracker irpc_setup_state;
1061    StateTracker irpc_wait_state;
1062    StateTracker irpc_state;
1063    StateTracker async_state;
1064    StateTracker internal_state;
1065    StateTracker detach_state;
1066    StateTracker user_irpc_state;
1067    StateTracker control_authority_state;
1068    StateTracker user_state;
1069    StateTracker handler_state;
1070    StateTracker generator_state;
1071    StateTracker *all_states[NumStateIDs];
1072
1073    State target_state;
1074    State saved_user_state;
1075
1076    int_registerPool cached_regpool;
1077    Mutex regpool_lock;
1078    int_iRPC_ptr running_rpc;
1079    int_iRPC_ptr writing_rpc;
1080    rpc_list_t posted_rpcs;
1081    int_registerPool rpc_regs;
1082
1083    bool user_single_step;
1084    bool single_step;
1085    bool handler_exiting_state;
1086    bool generator_exiting_state;
1087    bool running_when_attached;
1088    bool suspended;
1089
1090    Address stopped_on_breakpoint_addr;
1091    Address postponed_stopped_on_breakpoint_addr;
1092
1093    bp_instance *clearing_breakpoint;
1094    emulated_singlestep *em_singlestep;
1095    void *user_data;
1096
1097    std::set<hw_breakpoint *> hw_breakpoints;
1098    static std::set<continue_cb_t> continue_cbs;
1099    CallStackUnwinding *unwinder;
1100 };
1101
1102 /**
1103  * int_threadPool reprents a collection of threads.  Each int_process has one
1104  * int_threadPool, which has multiple threads.
1105  **/
1106 class int_threadPool {
1107    friend class Dyninst::ProcControlAPI::ThreadPool;
1108    friend class Dyninst::ProcControlAPI::ThreadPool::iterator;
1109    friend class int_thread;
1110  private:
1111    std::vector<int_thread *> threads;
1112    std::vector<Thread::ptr> hl_threads;
1113    std::map<Dyninst::LWP, int_thread *> thrds_by_lwp;
1114
1115    mutable int_thread *initial_thread; // may be updated by side effect on Windows
1116    int_process *proc_;
1117    ThreadPool *up_pool;
1118    bool had_multiple_threads;
1119  public:
1120    int_threadPool(int_process *p);
1121    ~int_threadPool();
1122
1123    void setInitialThread(int_thread *thrd);
1124    void addThread(int_thread *thrd);
1125    void rmThread(int_thread *thrd);
1126    void noteUpdatedLWP(int_thread *thrd);
1127    void clear();
1128    bool hadMultipleThreads() const;
1129
1130    typedef std::vector<int_thread *>::iterator iterator;
1131    iterator begin() { return threads.begin(); }
1132    iterator end() { return threads.end(); }
1133    bool empty() { return threads.empty(); }
1134
1135    unsigned size() const;
1136
1137    int_process *proc() const;
1138    ThreadPool *pool() const;
1139
1140    int_thread *findThreadByLWP(Dyninst::LWP lwp);
1141    int_thread *initialThread() const;
1142    bool allHandlerStopped();
1143    bool allStopped(int state_id);
1144    
1145    void saveUserState(Event::ptr ev);
1146    void restoreUserState();
1147 };
1148
1149 /**
1150  * Represents a Dynamic Shared Object (aka DSO, aka .dll/.so) loaded by the process.  
1151  * Each DSO has a library name and load address.
1152  *
1153  * int_library doesn't hang directly from a process, but from its mem_state object.
1154  **/
1155 class int_library
1156 {
1157    friend class Dyninst::ProcControlAPI::LibraryPool;
1158    friend class Dyninst::ProcControlAPI::LibraryPool::iterator;
1159    friend class Dyninst::ProcControlAPI::LibraryPool::const_iterator;
1160   private:
1161    std::string name;
1162    Dyninst::Address load_address;
1163    Dyninst::Address data_load_address;
1164    Dyninst::Address dynamic_address;
1165    bool has_data_load;
1166    bool marked;
1167    void *user_data;
1168    Library::ptr up_lib;
1169    bool is_shared_lib;
1170   public:
1171    int_library(std::string n, 
1172                bool shared_lib,
1173                Dyninst::Address load_addr,
1174                Dyninst::Address dynamic_load_addr, 
1175                Dyninst::Address data_load_addr = 0, 
1176                bool has_data_load_addr = false);
1177    int_library(int_library *l);
1178    ~int_library();
1179    std::string getName();
1180    Dyninst::Address getAddr();
1181    Dyninst::Address getDataAddr();
1182    Dyninst::Address getDynamicAddr();
1183    bool hasDataAddr();
1184    
1185    void setMark(bool b);
1186    bool isMarked() const;
1187    
1188    void setUserData(void *d);
1189    void *getUserData();
1190
1191    bool isSharedLib() const;
1192
1193    Library::ptr getUpPtr() const;
1194    void markAsCleanable();
1195    
1196    void markAOut() { is_shared_lib = false; }
1197 };
1198
1199 /**
1200  * There are five (FIVE!) classes related to breakpoints:
1201  *
1202  * Breakpoint - The user interface to breakpoints.  The user will always 
1203  *  use this when handling breakpoints.  
1204  *
1205  * int_breakpoint - The internal handle for a breakpoint.  A Breakpoint
1206  *  will always have one int_breakpoint.  However, internal breakpoints
1207  *  (ie, the breakpoint used in System V library loading) don't necessary
1208  *  have the UI interface object of Breakpoint.
1209  * 
1210  *  int_breakpoint's aren't process specific (so they can be copied easily)
1211  *  upon fork.  A single int_breakpoint can be inserted into multiple 
1212  *  processes, and multiple times into one int_process.  
1213  * 
1214  *  An int_breakpoint can have properties, like a control transfer 
1215  *  int_breakpoint will transfer control when it executes, a
1216  *  onetime breakpoint will clean itself after being hit, and
1217  *  a thread-specific breakpoint will only trigger if hit by
1218  *  certain threads.
1219  *
1220  *  If internal code wants to keep a handle to a breakpoint, then
1221  *  it should use int_breakpoint.
1222  *
1223  * bp_instance - Each int_breakpoint/process/address triple is
1224  *  represented by a bp_instance.  This reprents an actual
1225  *  low-level breakpoint at some location.  Unless you're
1226  *  writing low-level BP code you can ignore this class.
1227  *
1228  *  bp_instance is an abstract class, implemented by sw_breakpoint
1229  *  and hw_breakpoint.
1230  *
1231  * sw_breakpoint is a type of bp_instance, as implemented by a 
1232  *  trap instruction.  A certain sequence of bytes is written
1233  *  into the process at a code location, which throws a SIGTRAP
1234  *  (or similar) when executed.
1235  *
1236  * hw_breakpoint is a type of bp_instance, as implemented by
1237  *  hardware debug registers.  These are usually used to implement
1238  *  things like watchpoints in debuggers.  They are usually 
1239  *  thread-specific and can set to trigger when code executes
1240  *  or data is read or written.  
1241  **/
1242 class int_breakpoint
1243 {
1244    friend class sw_breakpoint;
1245    friend class hw_breakpoint;
1246  private:
1247    Breakpoint::weak_ptr up_bp;
1248    Dyninst::Address to;
1249    bool isCtrlTransfer_;
1250    void *data;
1251
1252    bool hw;
1253    unsigned int hw_perms;
1254    unsigned int hw_size;
1255    bool onetime_bp;
1256    bool onetime_bp_hit;
1257    bool procstopper;
1258    bool suppress_callbacks;
1259    bool offset_transfer;
1260    std::set<Thread::const_ptr> thread_specific;
1261  public:
1262    int_breakpoint(Breakpoint::ptr up);
1263    int_breakpoint(Dyninst::Address to, Breakpoint::ptr up, bool off);
1264    int_breakpoint(unsigned int hw_prems_, unsigned int hw_size_, Breakpoint::ptr up);
1265    ~int_breakpoint();
1266
1267    bool isCtrlTransfer() const;
1268    Dyninst::Address toAddr() const;
1269    Dyninst::Address getAddress(int_process *p) const;
1270    void *getData() const;
1271    void setData(void *v);
1272    void setOneTimeBreakpoint(bool b);
1273    void markOneTimeHit();
1274    bool isOneTimeBreakpoint() const;
1275    bool isOneTimeBreakpointHit() const;
1276
1277    void setThreadSpecific(Thread::const_ptr p);
1278    bool isThreadSpecific() const;
1279    bool isThreadSpecificTo(Thread::const_ptr p) const;
1280
1281    void setProcessStopper(bool b);
1282    bool isProcessStopper() const;
1283
1284    void setSuppressCallbacks(bool);
1285    bool suppressCallbacks(void) const;
1286    
1287    bool isHW() const;
1288    unsigned getHWSize() const;
1289    unsigned getHWPerms() const;
1290    
1291    bool isOffsetTransfer() const;
1292    Breakpoint::weak_ptr upBreakpoint() const;
1293 };
1294
1295 class bp_instance
1296 {
1297    friend class Dyninst::ProcControlAPI::EventBreakpoint;
1298   protected:
1299    std::set<int_breakpoint *> bps;
1300    std::set<Breakpoint::ptr> hl_bps;
1301    Dyninst::Address addr;
1302    bool installed;
1303    int suspend_count;
1304    
1305    sw_breakpoint *swbp;
1306    hw_breakpoint *hwbp;
1307
1308    bool suspend_common();
1309    bool resume_common();
1310   public:
1311    virtual bool checkBreakpoint(int_breakpoint *bp, int_process *proc);
1312    virtual bool rmBreakpoint(int_process *proc, int_breakpoint *bp,
1313                              bool &empty, std::set<response::ptr> &resps);
1314    virtual async_ret_t uninstall(int_process *proc, std::set<response::ptr> &resps) = 0;
1315
1316    Address getAddr() const;
1317
1318    bp_instance(Address addr);
1319    bp_instance(const bp_instance *ip);
1320
1321    typedef std::set<int_breakpoint *>::iterator iterator;
1322    iterator begin();
1323    iterator end();
1324
1325    bool containsIntBreakpoint(int_breakpoint *bp);
1326    int_breakpoint *getCtrlTransferBP(int_thread *thread);
1327
1328    bool isInstalled() const;
1329    virtual bool needsClear() = 0;
1330
1331    virtual async_ret_t suspend(int_process *proc, std::set<response::ptr> &resps) = 0;
1332    virtual async_ret_t resume(int_process *proc, std::set<response::ptr> &resps) = 0;
1333
1334    sw_breakpoint *swBP();
1335    hw_breakpoint *hwBP();
1336    virtual ~bp_instance();
1337 };
1338  
1339
1340 //At least as large as any arch's trap instruction
1341 #define BP_BUFFER_SIZE 8
1342 //Long breakpoints can be used to artifically increase the size of the BP write,
1343 // which fools the BG breakpoint interception code that looks for 4 byte writes.
1344 #define BP_LONG_SIZE 4
1345 class sw_breakpoint : public bp_instance
1346 {
1347    friend class Dyninst::ProcControlAPI::EventBreakpoint;
1348    friend class int_process;
1349  private:
1350    mem_state::ptr memory;
1351
1352    char buffer[BP_BUFFER_SIZE];
1353    int buffer_size;
1354    bool prepped;
1355    bool long_breakpoint;
1356
1357    result_response::ptr write_response;
1358    mem_response::ptr read_response;
1359
1360    bool writeBreakpoint(int_process *proc, result_response::ptr write_response);
1361    bool saveBreakpointData(int_process *proc, mem_response::ptr read_response);
1362    bool restoreBreakpointData(int_process *proc, result_response::ptr res_resp);
1363
1364    sw_breakpoint(mem_state::ptr memory_, Dyninst::Address addr_);
1365  public:
1366    sw_breakpoint(mem_state::ptr memory_, const sw_breakpoint *ip);
1367    ~sw_breakpoint();
1368
1369    static sw_breakpoint *create(int_process *proc, int_breakpoint *bp, Dyninst::Address addr_);
1370    //Use these three functions to add a breakpoint
1371    bool prepBreakpoint(int_process *proc, mem_response::ptr mem_resp);
1372    bool insertBreakpoint(int_process *proc, result_response::ptr res_resp);
1373    bool addToIntBreakpoint(int_breakpoint *bp, int_process *proc);
1374
1375    virtual async_ret_t uninstall(int_process *proc, std::set<response::ptr> &resps);
1376    virtual async_ret_t suspend(int_process *proc, std::set<response::ptr> &resps);
1377    virtual async_ret_t resume(int_process *proc, std::set<response::ptr> &resps);
1378
1379    unsigned getNumIntBreakpoints() const;
1380    virtual bool needsClear();
1381 };
1382
1383 class hw_breakpoint : public bp_instance {
1384   friend class Dyninst::ProcControlAPI::EventBreakpoint;
1385 private:
1386   unsigned int hw_perms;
1387   unsigned int hw_size;
1388   bool proc_wide;
1389   int_thread *thr;
1390   bool error;
1391
1392   hw_breakpoint(int_thread *thr, unsigned mode, unsigned size,
1393                 bool pwide, Dyninst::Address addr);
1394 public:
1395   virtual async_ret_t uninstall(int_process *proc, std::set<response::ptr> &resps);
1396
1397
1398   static hw_breakpoint *create(int_process *proc, int_breakpoint *bp, Dyninst::Address addr_);
1399   ~hw_breakpoint();
1400   
1401   bool install(bool &done, std::set<response::ptr> &resps);
1402   unsigned int getPerms() const;
1403   unsigned int getSize() const;
1404   bool procWide() const;
1405   int_thread *getThread() const;
1406   virtual bool needsClear();
1407
1408   virtual async_ret_t suspend(int_process *proc, std::set<response::ptr> &resps);
1409   virtual async_ret_t resume(int_process *proc, std::set<response::ptr> &resps);
1410 };
1411
1412 /**
1413  * On PPC64 certain synchronization instructions can mis-behave if we
1414  * try to single-step across them.  This class recognizes these situations
1415  * and replaces a single-step operation with a breakpoint insertion/run over
1416  * the offending code.
1417  **/
1418 class emulated_singlestep {
1419    // Breakpoints that are added and removed in a group to emulate
1420    // a single step with breakpoints
1421   private:
1422    bool saved_user_single_step;
1423    bool saved_single_step;
1424    int_breakpoint *bp;
1425    int_thread *thr;
1426    std::set<Address> addrs;
1427
1428   public:
1429    emulated_singlestep(int_thread *thr);
1430    ~emulated_singlestep();
1431    
1432    bool containsBreakpoint(Address addr) const;
1433    async_ret_t add(Address addr);
1434    async_ret_t clear();
1435    void restoreSSMode();
1436
1437    std::set<response::ptr> clear_resps;
1438 };
1439
1440 struct clearError {
1441    void operator()(Process::ptr p) {
1442       p->clearLastError();
1443    }
1444
1445    template <class T>
1446    void operator()(const std::pair<T, Process::const_ptr> &v) {
1447       v.second->clearLastError();
1448    }
1449    template <class T>
1450    void operator()(const std::pair<Process::const_ptr, T> &v) {
1451       v.first->clearLastError();
1452    }
1453    template <class T>
1454    void operator()(const std::pair<T, Process::ptr> &v) {
1455       v.second->clearLastError();
1456    }
1457    template <class T>
1458    void operator()(const std::pair<Process::ptr, T> &v) {
1459       v.first->clearLastError();
1460    }
1461 };
1462
1463 struct setError {
1464 private:
1465    err_t err;
1466    const char *err_str;
1467 public:
1468    setError(err_t e, const char *s) { err = e; err_str = s; }
1469    void operator()(Process::ptr p) {
1470       p->setLastError(err, err_str);
1471    }
1472    void operator()(const std::pair<Address, Process::ptr> &v) {
1473       v.second->setLastError(err, err_str);
1474    }
1475 };
1476
1477 /**
1478  * The notify class is the internal interface to th UI Notify class.  
1479  * It is used to signal the user (via platform-specific interfaces)
1480  * that an event is ready to be handled.
1481  **/
1482 class int_notify {
1483 #if defined(os_windows)
1484         class windows_details
1485         {
1486                 HANDLE evt;
1487         public:
1488                 windows_details() : evt(INVALID_HANDLE_VALUE)
1489                 {
1490                 }
1491                 typedef HANDLE wait_object_t;
1492                 void noteEvent()
1493                 {
1494                         ::ReleaseSemaphore(evt, 1, NULL);
1495                 }
1496                 void clearEvent()
1497                 {
1498                         // No-op with semaphores
1499                         //::ResetEvent(evt);
1500                 }
1501
1502                 bool createInternals()
1503                 {
1504                         evt = ::CreateSemaphore(NULL, 0, 1000, NULL);
1505                         return evt  != INVALID_HANDLE_VALUE;
1506                 }
1507                 bool internalsValid()
1508                 {
1509                         return evt != INVALID_HANDLE_VALUE;
1510                 }
1511                 wait_object_t getWaitObject()
1512                 {
1513                         return evt;
1514                 }
1515         };
1516         typedef windows_details details_t;
1517 #else
1518         class unix_details
1519         {
1520                 friend class int_notify;
1521                 int pipe_in;
1522                 int pipe_out;
1523                 void writeToPipe();
1524                 void readFromPipe();
1525         public:
1526                 unix_details();
1527                 typedef int wait_object_t;
1528                 void noteEvent();
1529                 void clearEvent();
1530                 bool createInternals();
1531                 bool internalsValid();
1532                 wait_object_t getWaitObject();
1533         };
1534         typedef unix_details details_t;
1535 #endif
1536
1537         typedef details_t::wait_object_t wait_object_t;
1538    friend int_notify *notify();
1539    friend EventNotify *Dyninst::ProcControlAPI::evNotify();
1540  private:
1541    static int_notify *the_notify;
1542    EventNotify *up_notify;
1543    std::set<EventNotify::notify_cb_t> cbs;
1544    int events_noted;
1545    details_t my_internals;
1546  public:
1547    int_notify();
1548    void noteEvent();
1549    void clearEvent();
1550    
1551    void registerCB(EventNotify::notify_cb_t cb);
1552    void removeCB(EventNotify::notify_cb_t cb);
1553    bool hasEvents();
1554    details_t::wait_object_t getWaitable();
1555 };
1556 int_notify *notify();
1557
1558 extern void setGeneratorThread(long t);
1559 void setHandlerThread(long t);
1560 bool isGeneratorThread();
1561 bool isHandlerThread();
1562 bool isUserThread();
1563 HandlerPool *createDefaultHandlerPool(int_process *p);
1564 HandlerPool *plat_createDefaultHandlerPool(HandlerPool *hpool);
1565
1566 class MTManager {
1567   friend MTManager *mt();
1568   friend class MTLock;
1569 private:
1570   static MTManager *mt_;
1571   DThread evhandler_thread;
1572   CondVar pending_event_lock;
1573   Mutex work_lock;
1574   bool have_queued_events;
1575   bool is_running;
1576   bool should_exit;
1577   Process::thread_mode_t threadMode;
1578   
1579   void evhandler_main();
1580 #if defined(os_windows)
1581   static unsigned long WINAPI evhandler_main_wrapper(void *);
1582 #else
1583   static void evhandler_main_wrapper(void *);
1584 #endif
1585   void eventqueue_cb();
1586   
1587 public:
1588   static const Process::thread_mode_t default_thread_mode = Process::HandlerThreading;
1589   MTManager();
1590   ~MTManager();
1591   
1592   void run();
1593   void stop();
1594
1595   void startWork();
1596   void endWork();
1597   
1598   bool handlerThreading();
1599   Process::thread_mode_t getThreadMode();
1600   bool setThreadMode(Process::thread_mode_t tm, bool init = false);
1601
1602   static void eventqueue_cb_wrapper();
1603 }; 
1604
1605 inline MTManager *mt() { 
1606    return MTManager::mt_; 
1607 }
1608
1609 class MTLock
1610 {
1611  private:
1612    bool should_unlock;
1613  public:
1614    typedef enum {allow_init} initialize;
1615    typedef enum {allow_generator} generator;
1616    typedef enum {nocb, deliver_callbacks} callbacks;
1617    MTLock(initialize, callbacks c = nocb)
1618    {
1619       should_unlock = true;
1620       if (!MTManager::mt_) {
1621          MTManager::mt_ = new MTManager();
1622          if ((MTManager::default_thread_mode == Process::HandlerThreading) ||
1623              (MTManager::default_thread_mode == Process::CallbackThreading)) {
1624             mt()->startWork();
1625          }
1626          mt()->setThreadMode(MTManager::default_thread_mode, true);
1627       }
1628       else if (mt()->handlerThreading()) {
1629          mt()->startWork();
1630          if ((c == deliver_callbacks) && 
1631              (MTManager::default_thread_mode == Process::HandlerThreading) && 
1632              notify()->hasEvents()) 
1633          {
1634             pthrd_printf("MTLock triggered event handling\n");
1635             int_process::waitAndHandleEvents(false);
1636             pthrd_printf("MTLock triggered event handling finished\n");
1637          }
1638       }
1639    }
1640
1641    MTLock(generator)
1642    {
1643       if (isGeneratorThread()) {
1644          should_unlock = false;
1645          return;
1646       }
1647       should_unlock = true;
1648       if (mt()->handlerThreading()) {
1649          mt()->startWork();
1650       }
1651    }
1652
1653    MTLock(callbacks) 
1654    {
1655       assert(!isGeneratorThread());
1656       should_unlock = true;
1657       if (mt()->handlerThreading()) {
1658          mt()->startWork();
1659          if (notify()->hasEvents() && 
1660              (MTManager::default_thread_mode == Process::HandlerThreading) )
1661          {
1662             pthrd_printf("MTLock triggered event handling\n");
1663             int_process::waitAndHandleEvents(false);
1664             pthrd_printf("MTLock triggered event handling finished\n");
1665          }
1666       }
1667    }
1668
1669    MTLock()
1670    {
1671       assert(!isGeneratorThread());
1672       should_unlock = true;
1673       if (mt()->handlerThreading())
1674          mt()->startWork();
1675    }
1676
1677    ~MTLock() {
1678       if (should_unlock && mt()->handlerThreading())
1679          mt()->endWork();
1680    }
1681 };
1682
1683 // A class to stop the various threads that have been started when
1684 // the library is deinitialized
1685 class int_cleanup {
1686     public:
1687         ~int_cleanup();
1688 };
1689
1690 #define PROC_EXIT_TEST(STR, RET)                      \
1691    if (!llproc_) {                                    \
1692      perr_printf(STR " on exited process\n");         \
1693      setLastError(err_exited, "Process is exited");   \
1694      return RET;                                      \
1695    }
1696
1697 #define PROC_DETACH_TEST(STR, RET)                       \
1698    if (llproc_->getState() == int_process::detached) {   \
1699      perr_printf(STR " on detached process\n");          \
1700      setLastError(err_detached, "Process is detached");  \
1701      return RET;                                         \
1702    }
1703
1704 #define PROC_CB_TEST(STR, RET)                                          \
1705    if (int_process::isInCB()) {                                         \
1706      perr_printf(STR " while in callback\n");                           \
1707      setLastError(err_incallback, "Cannot do operation from callback"); \
1708      return RET;                                                        \
1709    }
1710
1711 #define PROC_EXIT_DETACH_TEST(STR, RET)         \
1712    PROC_EXIT_TEST(STR, RET)                     \
1713    PROC_DETACH_TEST(STR, RET)
1714
1715 #define PROC_EXIT_DETACH_CB_TEST(STR, RET)      \
1716    PROC_EXIT_TEST(STR, RET)                     \
1717    PROC_DETACH_TEST(STR, RET)                   \
1718    PROC_CB_TEST(STR, RET)
1719
1720 #define THREAD_EXIT_TEST(STR, RET)                    \
1721    if (!llthread_) {                                  \
1722      perr_printf(STR " on exited thread\n");          \
1723      setLastError(err_exited, "Thread is exited");    \
1724      return RET;                                      \
1725    }                                                  \
1726    if (!llthread_->llproc()) {                        \
1727      perr_printf(STR " on exited process\n");         \
1728      setLastError(err_exited, "Process is exited");   \
1729      return RET;                                      \
1730    }
1731
1732 #define THREAD_DETACH_TEST(STR, RET)                                    \
1733    if (llthread_->llproc()->getState() == int_process::detached) {      \
1734      perr_printf(STR " on detached process\n");                         \
1735      setLastError(err_detached, "Process is detached");                 \
1736      return RET;                                                        \
1737    }                                                                    \
1738
1739 #define THREAD_STOP_TEST(STR, RET)                                     \
1740    if (llthread_->getUserState().getState() != int_thread::stopped) {  \
1741       setLastError(err_notstopped, "Thread not stopped");              \
1742       perr_printf(STR " on running thread %d\n", llthread_->getLWP()); \
1743       return RET;                                                      \
1744    }
1745
1746 #define THREAD_EXIT_DETACH_TEST(STR, RET)         \
1747    THREAD_EXIT_TEST(STR, RET)                     \
1748    THREAD_DETACH_TEST(STR, RET)
1749
1750 #define THREAD_EXIT_DETACH_CB_TEST(STR, RET)      \
1751    THREAD_EXIT_TEST(STR, RET)                     \
1752    THREAD_DETACH_TEST(STR, RET)                   \
1753    PROC_CB_TEST(STR, RET)
1754
1755 #define THREAD_EXIT_DETACH_STOP_TEST(STR, RET)    \
1756    THREAD_EXIT_TEST(STR, RET)                     \
1757    THREAD_DETACH_TEST(STR, RET)                   \
1758    THREAD_STOP_TEST(STR, RET)
1759
1760 #define PTR_EXIT_TEST(P, STR, RET)                       \
1761    if (!P || !P->llproc()) {                             \
1762       perr_printf(STR " on exited process\n");           \
1763       P->setLastError(err_exited, "Process is exited");  \
1764       return RET;                                        \
1765    }
1766
1767 #endif