Initial commit for ProcControlAPI on BG/Q
[dyninst.git] / proccontrol / src / int_process.h
1 /*
2  * Copyright (c) 1996-2011 Barton P. Miller
3  * 
4  * We provide the Paradyn Parallel Performance Tools (below
5  * described as "Paradyn") on an AS IS basis, and do not warrant its
6  * validity or performance.  We reserve the right to update, modify,
7  * or discontinue this software at any time.  We shall have no
8  * obligation to supply such updates or modifications or any other
9  * form of support to you.
10  * 
11  * By your use of Paradyn, you understand and agree that we (or any
12  * other person or entity with proprietary rights in Paradyn) are
13  * under no obligation to provide either maintenance services,
14  * update services, notices of latent defects, or correction of
15  * defects for Paradyn.
16  * 
17  * This library is free software; you can redistribute it and/or
18  * modify it under the terms of the GNU Lesser General Public
19  * License as published by the Free Software Foundation; either
20  * version 2.1 of the License, or (at your option) any later version.
21  * 
22  * This library is distributed in the hope that it will be useful,
23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
25  * Lesser General Public License for more details.
26  * 
27  * You should have received a copy of the GNU Lesser General Public
28  * License along with this library; if not, write to the Free Software
29  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
30  */
31
32 #if !defined(INT_PROCESS_H_)
33 #define INT_PROCESS_H_
34
35 #include "proccontrol/h/Process.h"
36 #include "proccontrol/h/PCErrors.h"
37 #include "proccontrol/h/Event.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 using namespace Dyninst;
55 using namespace ProcControlAPI;
56
57 class int_thread;
58 class int_threadPool;
59 class handlerpool;
60 class int_iRPC;
61
62 typedef dyn_detail::boost::shared_ptr<int_iRPC> int_iRPC_ptr;
63 typedef std::map<Dyninst::MachRegister, std::pair<unsigned int, unsigned int> > dynreg_to_user_t;
64
65 typedef std::list<int_iRPC_ptr> rpc_list_t;
66
67 class installed_breakpoint;
68 class int_library;
69 class int_process;
70 class emulated_singlestep;
71
72 class mem_state
73 {
74   public:
75    typedef mem_state* ptr;
76    mem_state(int_process *proc);
77    mem_state(mem_state &m, int_process *proc);
78    ~mem_state();
79
80    void addProc(int_process *p);
81    void rmProc(int_process *p, bool &should_clean);
82
83    std::set<int_process *> procs;
84    std::set<int_library *> libs;
85    std::map<Dyninst::Address, installed_breakpoint *> breakpoints;
86    std::map<Dyninst::Address, unsigned long> inf_malloced_memory;
87 };
88
89 class Counter {
90   public:
91    static const int NumCounterTypes = 11;
92    enum CounterType {
93       HandlerRunningThreads = 0,
94       GeneratorRunningThreads = 1,
95       SyncRPCs = 2,
96       SyncRPCRunningThreads = 3,
97       PendingStops = 4,
98       ClearingBPs = 5,
99       ProcStopRPCs = 6,
100       AsyncEvents = 7,
101       ForceGeneratorBlock = 8,
102       GeneratorNonExitedThreads = 9,
103       StartupTeardownProcesses = 10
104    };
105
106    Counter(CounterType ct_);
107    ~Counter();
108
109    void inc();
110    void dec();
111
112    bool local() const;
113    int localCount() const;
114    static bool global(CounterType ct);
115    static int globalCount(CounterType ct);
116
117   private:
118    int local_count;
119    CounterType ct;
120
121    void adjust(int val);
122
123    static Mutex locks[NumCounterTypes];
124    static int global_counts[NumCounterTypes];
125 };
126
127 class ProcStopEventManager {
128   private:
129    int_process *proc;
130    std::set<Event::ptr> held_pstop_events;
131   public:
132    ProcStopEventManager(int_process *p);
133    ~ProcStopEventManager();
134
135    bool prepEvent(Event::ptr ev);
136    void checkEvents();
137
138    bool processStoppedTo(int state_id);
139    bool threadStoppedTo(int_thread *thr, int state_id);
140 };
141
142 class int_process
143 {
144    friend class Dyninst::ProcControlAPI::Process;
145  protected:
146    int_process(Dyninst::PID p, std::string e, std::vector<std::string> a, 
147            std::vector<std::string> envp, std::map<int,int> f);
148    int_process(Dyninst::PID pid_, int_process *p);
149  public:
150    static int_process *createProcess(Dyninst::PID p, std::string e);
151    static int_process *createProcess(std::string e, std::vector<std::string> a, 
152            std::vector<std::string> envp, std::map<int,int> f);
153    static int_process *createProcess(Dyninst::PID pid_, int_process *p);
154    virtual ~int_process();
155  protected:
156    bool create();
157    virtual bool plat_create() = 0;
158    virtual bool post_create();
159
160    bool attach();
161    bool reattach();
162    virtual bool plat_attach(bool allStopped, bool &should_sync) = 0;
163    bool attachThreads();
164    virtual bool post_attach(bool wasDetached);
165
166    bool initializeAddressSpace();
167
168    virtual bool plat_syncRunState() = 0;
169    bool syncRunState();
170
171   public:
172
173    typedef enum {
174       ct_fork,
175       ct_launch,
176       ct_attach
177    } creationMode_t;
178    creationMode_t getCreationMode() const;
179
180    void setContSignal(int sig);
181    int getContSignal() const;
182    virtual bool forked();
183
184    virtual OSType getOS() const = 0;
185   protected:
186    virtual bool plat_forked() = 0;
187    virtual bool post_forked();
188
189   public:
190    bool execed();
191    virtual bool plat_detach(result_response::ptr resp) = 0;
192   protected:
193    virtual bool plat_execed();
194    virtual bool plat_terminate(bool &needs_sync) = 0;
195
196    virtual bool needIndividualThreadAttach() = 0;
197    virtual bool getThreadLWPs(std::vector<Dyninst::LWP> &lwps);
198
199    bool waitfor_startup();
200
201    void setPid(Dyninst::PID pid);
202    int_thread *findStoppedThread();
203
204   public:
205    virtual bool plat_processGroupContinues();
206
207    typedef enum {
208       neonatal = 0,
209       neonatal_intermediate,
210       detached,
211       running,
212       exited,
213       errorstate
214    } State;
215    State getState() const;
216    void setState(State s);
217
218    Dyninst::PID getPid() const;
219    int_threadPool *threadPool() const;
220
221    Process::ptr proc() const;
222    mem_state::ptr memory() const;
223
224    //Detach is static because proc could be cleaned 
225    static bool detach(int_process *proc, bool temporary);
226
227    virtual bool preTerminate();
228    bool terminate(bool &needs_sync);
229    void updateSyncState(Event::ptr ev, bool gen);
230    virtual Dyninst::Architecture getTargetArch() = 0;
231    virtual unsigned getTargetPageSize() = 0;
232    virtual unsigned plat_getRecommendedReadSize();
233    virtual Dyninst::Address mallocExecMemory(unsigned size);
234    virtual Dyninst::Address plat_mallocExecMemory(Dyninst::Address min, unsigned size) = 0;
235    virtual void freeExecMemory(Dyninst::Address addr);
236
237    static bool waitAndHandleEvents(bool block);
238    static bool waitAndHandleForProc(bool block, int_process *proc, bool &proc_exited);
239    static bool waitForAsyncEvent(response::ptr resp);
240    static bool waitForAsyncEvent(std::set<response::ptr> resp);
241
242    Counter &asyncEventCount();
243    Counter &getForceGeneratorBlockCount();
244    Counter &getStartupTeardownProcs();
245
246    static const char *stateName(State s);
247
248    void initializeProcess(Process::ptr p);
249
250    void setExitCode(int c);
251    void setCrashSignal(int s);
252    bool getExitCode(int &c);
253    bool getCrashSignal(int &s);
254    bool wasForcedTerminated() const;
255
256    virtual bool plat_individualRegAccess() = 0;
257    virtual bool plat_individualRegRead();
258    virtual bool plat_individualRegSet();
259
260    int getAddressWidth();
261    HandlerPool *handlerPool() const;
262
263    bool addBreakpoint(Dyninst::Address addr, int_breakpoint *bp);
264    bool rmBreakpoint(Dyninst::Address addr, int_breakpoint *bp, result_response::ptr async_resp);
265    installed_breakpoint *getBreakpoint(Dyninst::Address addr);
266
267    virtual unsigned plat_breakpointSize() = 0;
268    virtual void plat_breakpointBytes(char *buffer) = 0;
269    virtual bool plat_breakpointAdvancesPC() const = 0;
270
271    virtual bool plat_createDeallocationSnippet(Dyninst::Address addr, unsigned long size, void* &buffer, 
272                                                unsigned long &buffer_size, unsigned long &start_offset) = 0;
273    virtual bool plat_createAllocationSnippet(Dyninst::Address addr, bool use_addr, unsigned long size, 
274                                              void* &buffer, unsigned long &buffer_size, 
275                                              unsigned long &start_offset) = 0;
276    virtual bool plat_collectAllocationResult(int_thread *thr, reg_response::ptr resp) = 0;
277    virtual bool plat_threadOpsNeedProcStop();
278    virtual SymbolReaderFactory *plat_defaultSymReader();
279    Dyninst::Address infMalloc(unsigned long size, bool use_addr = false, Dyninst::Address addr = 0x0);
280    bool infFree(Dyninst::Address addr);
281
282    bool readMem(Dyninst::Address remote, mem_response::ptr result, int_thread *thr = NULL);
283    bool writeMem(const void *local, Dyninst::Address remote, size_t size, result_response::ptr result, int_thread *thr = NULL);
284
285    virtual bool plat_readMem(int_thread *thr, void *local, 
286                              Dyninst::Address remote, size_t size) = 0;
287    virtual bool plat_writeMem(int_thread *thr, const void *local, 
288                               Dyninst::Address remote, size_t size) = 0;
289
290    //For a platform, if plat_needsAsyncIO returns true then the async
291    // set of functions need to be implemented.  Currently plat_needsAsyncIO
292    // only returns true for bluegene family.  By default these are otherwise
293    // unimplemented.
294    virtual bool plat_needsAsyncIO() const;
295    virtual bool plat_readMemAsync(int_thread *thr, Dyninst::Address addr, 
296                                   mem_response::ptr result);
297    virtual bool plat_writeMemAsync(int_thread *thr, const void *local, Dyninst::Address addr,
298                                    size_t size, result_response::ptr result);
299    memCache *getMemCache();
300
301    virtual bool plat_getOSRunningStates(std::map<Dyninst::LWP, bool> &runningStates) = 0;
302    
303    virtual void noteNewDequeuedEvent(Event::ptr ev);
304
305    static bool isInCB();
306    static void setInCB(bool b);
307
308    void throwNopEvent();
309    void throwRPCPostEvent();
310
311    virtual bool plat_supportFork();
312    virtual bool plat_supportExec();
313    virtual bool plat_supportDOTF();
314
315    virtual bool plat_supportThreadEvents();
316    virtual bool plat_supportLWPCreate();
317    virtual bool plat_supportLWPPreDestroy();
318    virtual bool plat_supportLWPPostDestroy();
319
320    virtual bool plat_preHandleEvent();
321    virtual bool plat_postHandleEvent();
322
323    virtual bool plat_needsPCSaveBeforeSingleStep();
324    virtual async_ret_t plat_needsEmulatedSingleStep(int_thread *thr, std::vector<Dyninst::Address> &result);
325    virtual void plat_getEmulatedSingleStepAsyncs(int_thread *thr, std::set<response::ptr> resps);
326
327    int_library *getLibraryByName(std::string s) const;
328    size_t numLibs() const;
329    virtual bool refresh_libraries(std::set<int_library *> &added_libs,
330                                   std::set<int_library *> &rmd_libs,
331                                   bool &waiting_for_async,
332                                   std::set<response::ptr> &async_responses) = 0;
333
334    virtual bool initLibraryMechanism() = 0;
335    virtual bool plat_isStaticBinary() = 0;
336    virtual int_library *plat_getExecutable() = 0;
337
338    void setForceGeneratorBlock(bool b);
339
340    std::string getExecutable() const;
341    static bool isInCallback();
342
343    static int_process *in_waitHandleProc;
344
345    ProcStopEventManager &getProcStopManager();
346
347    std::map<int, int> &getProcDesyncdStates();
348
349    bool isRunningSilent(); //No callbacks
350    void setRunningSilent(bool b);
351    
352  protected:
353    State state;
354    Dyninst::PID pid;
355    creationMode_t creation_mode;
356    std::string executable;
357    std::vector<std::string> argv;
358    std::vector<std::string> env;
359    std::map<int,int> fds;
360    Dyninst::Architecture arch;
361    int_threadPool *threadpool;
362    Process::ptr up_proc;
363    HandlerPool *handlerpool;
364    LibraryPool libpool;
365    bool hasCrashSignal;
366    int crashSignal;
367    bool hasExitCode;
368    bool forcedTermination;
369    bool silent_mode;
370    int exitCode;
371    static bool in_callback;
372    mem_state::ptr mem;
373    std::map<Dyninst::Address, unsigned> exec_mem_cache;
374    int continueSig;
375    memCache mem_cache;
376    Counter async_event_count;
377    Counter force_generator_block_count;
378    Counter startupteardown_procs;
379    ProcStopEventManager proc_stop_manager;
380    std::map<int, int> proc_desyncd_states;
381 };
382
383 class indep_lwp_control_process : virtual public int_process
384 {
385   protected:
386    virtual bool plat_syncRunState();
387   public:
388    indep_lwp_control_process(Dyninst::PID p, std::string e, std::vector<std::string> a, 
389                              std::vector<std::string> envp, std::map<int,int> f);
390    indep_lwp_control_process(Dyninst::PID pid_, int_process *p);
391    virtual ~indep_lwp_control_process();
392 };
393
394 class unified_lwp_control_process : virtual public int_process
395 {
396   protected:
397    virtual bool plat_syncRunState();
398   public:
399    unified_lwp_control_process(Dyninst::PID p, std::string e, std::vector<std::string> a, 
400                                std::vector<std::string> envp, std::map<int,int> f);
401    unified_lwp_control_process(Dyninst::PID pid_, int_process *p);
402    virtual ~unified_lwp_control_process();
403
404    virtual bool plat_processGroupContinues();
405 };
406
407 class hybrid_lwp_control_process : virtual public int_process
408 {
409   protected:
410    virtual bool plat_syncRunState();
411    virtual bool plat_suspendThread(int_thread *thr) = 0;
412    virtual bool plat_resumeThread(int_thread *thr) = 0;
413    virtual bool plat_debuggerSuspended() = 0;
414   public:
415    hybrid_lwp_control_process(Dyninst::PID p, std::string e, std::vector<std::string> a, 
416                               std::vector<std::string> envp, std::map<int,int> f);
417    hybrid_lwp_control_process(Dyninst::PID pid_, int_process *p);
418    virtual ~hybrid_lwp_control_process();
419
420    virtual bool suspendThread(int_thread *thr);
421    virtual bool resumeThread(int_thread *thr);
422
423    virtual bool plat_processGroupContinues();
424 };
425
426 class int_registerPool
427 {
428  public:
429    int_registerPool();
430    int_registerPool(const int_registerPool &c);
431    ~int_registerPool();
432
433    typedef std::map<Dyninst::MachRegister, Dyninst::MachRegisterVal> reg_map_t;
434    reg_map_t regs;
435    bool full;
436    int_thread *thread;
437
438    typedef reg_map_t::iterator iterator;
439    typedef reg_map_t::const_iterator const_iterator;
440 };
441
442 class thread_exitstate
443 {
444   public:
445    Dyninst::LWP lwp;
446    Dyninst::THR_ID thr_id;
447    Process::ptr proc_ptr;
448 };
449
450 class proc_exitstate
451 {
452   public:
453    Dyninst::PID pid;
454    bool exited;
455    bool crashed;
456    int crash_signal;
457    int exit_code;
458 };
459
460 /**
461  * ON THREADING STATES:
462  *
463  * Each thread has four different states, which mostly monitor running/stopped
464  * status :
465  *   GeneratorState - Thread state as seen by the generator object
466  *   HandlerState - Thread state as seen by the handler object
467  *   InternalState - Target thread state desired by int_* layer
468  *   UserState - Target Thread state as desired by the user
469  *
470  * The GeneratorState and HandlerState represent an event as it moves through the 
471  * system.  For example, an event that stops the thread may first appear
472  * in the Generator object, and move the GeneratorState to 'stopped'.  It is then
473  * seen by the handler, which moves the HandlerState to 'stopped'.  If the thread is 
474  * then continued, the HandlerState and GeneratorStates will go back to 'running'.
475  * These are primarily seperated to prevent race conditions with the handler and
476  * generators modifying the same variable, since they run in seperate threads.
477  * 
478  * The InternalState and UserState are used to make policy decisions about whether
479  * a thread should be running or stopped.  For example, after handling an event
480  * we may check the UserState to see if the user wants us to run/stop a thread.
481  * The InternalState usually matches the UserState, but may override it for 
482  * stop/run decisions in a few scenarios.  For example, if the user posts a iRPC
483  * to a running process (UserState = running) we may have to temporarily stop the
484  * process to install the iRPC.  We don't want to change the UserState, since the user
485  * still wants the process running, so we set the InternalState to stopped while we
486  * set up the iRPC, and then return it to the UserState value when the iRPC is ready.
487  *
488  * There are a couple of important assertions about the relationship between these thread
489  * states :
490  *  (GeneratorState == running) implies (HandlerState == running)
491  *  (HandlerState == running)  implies (InternalState == running)
492  *  (InternalState == stopped)  implies (HandlerState == stopped)
493  *  (HandlerState == stopped)  implies (GeneratorState == stopped)
494  **/
495 class int_thread
496 {
497    friend class int_threadPool;
498    friend class ProcStopEventManager;
499  protected:
500    int_thread(int_process *p, Dyninst::THR_ID t, Dyninst::LWP l);
501    static int_thread *createThreadPlat(int_process *proc, 
502                                        Dyninst::THR_ID thr_id, 
503                                        Dyninst::LWP lwp_id,
504                                        bool initial_thrd);
505  public:
506    static int_thread *createThread(int_process *proc, 
507                                    Dyninst::THR_ID thr_id, 
508                                    Dyninst::LWP lwp_id,
509                                    bool initial_thrd);
510    Process::ptr proc() const;
511    int_process *llproc() const;
512
513    Dyninst::LWP getLWP() const;
514
515 #define RUNNING_STATE(S) (S == int_thread::running || S == int_thread::neonatal_intermediate)
516    typedef enum {
517       none=0,
518       neonatal=1,
519       neonatal_intermediate=2,
520       running=3,
521       stopped=4,
522       dontcare=5,
523       ditto=6,
524       exited=7,
525       detached=8,
526       errorstate=9
527    } State;
528    //The order of these is very important.  Lower numbered
529    // states take precedence over higher numbered states.
530    static const int NumStateIDs = 15;
531    static const int NumTargetStateIDs = (NumStateIDs-2); //Handler and Generator states aren't target states
532
533    static const int AsyncStateID            = 0;
534    static const int CallbackStateID         = 1;
535    static const int PendingStopStateID      = 2;
536    static const int IRPCStateID             = 3;
537    static const int IRPCSetupStateID        = 4;
538    static const int IRPCWaitStateID         = 5;
539    static const int BreakpointStateID       = 6;
540    static const int InternalStateID         = 7;
541    static const int BreakpointResumeStateID = 8;
542    static const int ExitingStateID          = 9;
543    static const int StartupStateID          = 10;
544    static const int DetachStateID           = 11;
545    static const int UserStateID             = 12;
546    static const int HandlerStateID          = 13;
547    static const int GeneratorStateID        = 14;
548    static std::string stateIDToName(int id);
549
550    class StateTracker {
551      protected:
552       State state;
553       int id;
554       int sync_level;
555       int_thread *up_thr;
556      public:
557       StateTracker(int_thread *t, int id, int_thread::State initial);
558
559       void desyncState(State ns = int_thread::none);
560       void desyncStateProc(State ns = int_thread::none);
561
562       bool setState(State ns = int_thread::none);
563       bool setStateProc(State ns = int_thread::none);
564
565       void restoreState();
566       void restoreStateProc();
567       State getState() const;
568
569       std::string getName() const;
570       int getID() const;
571    };
572
573    //State management, see above comment on states
574    StateTracker &getExitingState();
575    StateTracker &getStartupState();
576    StateTracker &getBreakpointState();
577    StateTracker &getBreakpointResumeState();
578    StateTracker &getCallbackState();
579    StateTracker &getIRPCState();
580    StateTracker &getIRPCSetupState();
581    StateTracker &getIRPCWaitState();
582    StateTracker &getAsyncState();
583    StateTracker &getInternalState();
584    StateTracker &getDetachState();
585    StateTracker &getUserState();
586    StateTracker &getHandlerState();
587    StateTracker &getGeneratorState();
588    StateTracker &getPendingStopState();
589
590    StateTracker &getStateByID(int id);
591    StateTracker &getActiveState();
592    static char stateLetter(State s);
593
594    Counter &handlerRunningThreadsCount();
595    Counter &generatorRunningThreadsCount();
596    Counter &syncRPCCount();
597    Counter &runningSyncRPCThreadCount();
598    Counter &pendingStopsCount();
599    Counter &clearingBPCount();
600    Counter &procStopRPCCount();
601    Counter &getGeneratorNonExitedThreadCount();
602       
603    //Process control
604    bool intStop();
605    bool intCont();
606    async_ret_t handleSingleStepContinue();
607
608    void setContSignal(int sig);
609    int getContSignal();
610
611    virtual bool plat_cont() = 0;
612    virtual bool plat_stop() = 0;
613    void setPendingStop(bool b);
614    bool hasPendingStop() const;
615
616    bool wasRunningWhenAttached() const;
617    void setRunningWhenAttached(bool b);
618    bool isStopped(int state_id);
619
620    //Single-step
621    bool singleStepMode() const;
622    void setSingleStepMode(bool s);
623    bool singleStepUserMode() const;
624    void setSingleStepUserMode(bool s);
625    bool singleStep() const;
626    void markClearingBreakpoint(installed_breakpoint *bp);
627    installed_breakpoint *isClearingBreakpoint();
628    void markStoppedOnBP(installed_breakpoint *bp);
629    installed_breakpoint *isStoppedOnBP();
630
631    // Emulating single steps with breakpoints
632    void addEmulatedSingleStep(emulated_singlestep *es);
633    void rmEmulatedSingleStep(emulated_singlestep *es);
634    emulated_singlestep *getEmulatedSingleStep();
635
636    //RPC Management
637    void addPostedRPC(int_iRPC_ptr rpc_);
638    rpc_list_t *getPostedRPCs();
639    bool hasPostedRPCs();
640    void setRunningRPC(int_iRPC_ptr rpc_);
641    void clearRunningRPC();
642    int_iRPC_ptr runningRPC() const;
643    bool saveRegsForRPC(allreg_response::ptr response);
644    bool restoreRegsForRPC(bool clear, result_response::ptr response);
645    bool hasSavedRPCRegs();
646    void incSyncRPCCount();
647    void decSyncRPCCount();
648    bool hasSyncRPC();
649    int_iRPC_ptr nextPostedIRPC() const;
650
651
652    //Register Management
653    bool getAllRegisters(allreg_response::ptr result);
654    bool getRegister(Dyninst::MachRegister reg, reg_response::ptr result);
655    bool setAllRegisters(int_registerPool &pool, result_response::ptr result);
656    bool setRegister(Dyninst::MachRegister reg, Dyninst::MachRegisterVal val, result_response::ptr result);
657
658    virtual bool plat_getAllRegisters(int_registerPool &pool) = 0;
659    virtual bool plat_getRegister(Dyninst::MachRegister reg, 
660                                  Dyninst::MachRegisterVal &val) = 0;
661    virtual bool plat_setAllRegisters(int_registerPool &pool) = 0;
662    virtual bool plat_setRegister(Dyninst::MachRegister reg, 
663                                  Dyninst::MachRegisterVal val) = 0;
664
665    virtual bool plat_getAllRegistersAsync(allreg_response::ptr result);
666    virtual bool plat_getRegisterAsync(Dyninst::MachRegister reg, 
667                                       reg_response::ptr result);
668    virtual bool plat_setAllRegistersAsync(int_registerPool &pool,
669                                           result_response::ptr result);
670    virtual bool plat_setRegisterAsync(Dyninst::MachRegister reg, 
671                                       Dyninst::MachRegisterVal val,
672                                       result_response::ptr result);
673
674    void updateRegCache(int_registerPool &pool);
675    void updateRegCache(Dyninst::MachRegister reg, Dyninst::MachRegisterVal val);
676    void clearRegCache();
677
678    // The exiting property is separate from the main state because an
679    // exiting thread can either be running or stopped (depending on the
680    // desires of the user).
681    bool isExiting() const;
682    void setExiting(bool b);
683    bool isExitingInGenerator() const;
684    void setExitingInGenerator(bool b);
685
686    static void cleanFromHandler(int_thread *thr, bool should_delete);
687
688    //Misc
689    virtual bool attach() = 0;
690    Thread::ptr thread();
691
692    typedef void(*continue_cb_t)(int_thread *thrd);
693    static void addContinueCB(continue_cb_t cb);
694    void triggerContinueCBs();
695
696    void throwEventsBeforeContinue();
697
698    //User level thread info
699    void setTID(Dyninst::THR_ID tid_);
700    virtual bool haveUserThreadInfo();
701    virtual bool getTID(Dyninst::THR_ID &tid);
702    virtual bool getStartFuncAddress(Dyninst::Address &addr);
703    virtual bool getStackBase(Dyninst::Address &addr);
704    virtual bool getStackSize(unsigned long &size);
705    virtual bool getTLSPtr(Dyninst::Address &addr);
706       
707    virtual ~int_thread();
708    static const char *stateStr(int_thread::State s);
709
710    State getTargetState() const;
711    void setTargetState(State s);
712
713    void setSuspended(bool b);
714    bool isSuspended() const;
715  protected:
716    Dyninst::THR_ID tid;
717    Dyninst::LWP lwp;
718    int_process *proc_;
719    Thread::ptr up_thread;
720    int continueSig_;
721
722    Counter handler_running_thrd_count;
723    Counter generator_running_thrd_count;
724    Counter sync_rpc_count;
725    Counter sync_rpc_running_thr_count;
726    Counter pending_stop;
727    Counter clearing_bp_count;
728    Counter proc_stop_rpc_count;
729    Counter generator_nonexited_thrd_count;
730
731    StateTracker exiting_state;
732    StateTracker startup_state;
733    StateTracker pending_stop_state;
734    StateTracker callback_state;
735    StateTracker breakpoint_state;
736    StateTracker breakpoint_resume_state;
737    StateTracker irpc_setup_state;
738    StateTracker irpc_wait_state;
739    StateTracker irpc_state;
740    StateTracker async_state;
741    StateTracker internal_state;
742    StateTracker detach_state;
743    StateTracker user_state;
744    StateTracker handler_state;
745    StateTracker generator_state;
746    StateTracker *all_states[NumStateIDs];
747
748    State target_state;
749    State saved_user_state;
750
751    int_registerPool cached_regpool;
752    Mutex regpool_lock;
753    int_iRPC_ptr running_rpc;
754    int_iRPC_ptr writing_rpc;
755    rpc_list_t posted_rpcs;
756    int_registerPool rpc_regs;
757
758    bool user_single_step;
759    bool single_step;
760    bool handler_exiting_state;
761    bool generator_exiting_state;
762    bool running_when_attached;
763    bool suspended;
764
765    Address stopped_on_breakpoint_addr;
766
767    installed_breakpoint *clearing_breakpoint;
768    emulated_singlestep *em_singlestep;
769
770    static std::set<continue_cb_t> continue_cbs;
771 };
772
773 class int_threadPool {
774    friend class Dyninst::ProcControlAPI::ThreadPool;
775    friend class Dyninst::ProcControlAPI::ThreadPool::iterator;
776  private:
777    std::vector<int_thread *> threads;
778    std::vector<Thread::ptr> hl_threads;
779    std::map<Dyninst::LWP, int_thread *> thrds_by_lwp;
780
781    int_thread *initial_thread;
782    int_process *proc_;
783    ThreadPool *up_pool;
784    bool had_multiple_threads;
785  public:
786    int_threadPool(int_process *p);
787    ~int_threadPool();
788
789    void setInitialThread(int_thread *thrd);
790    void addThread(int_thread *thrd);
791    void rmThread(int_thread *thrd);
792    void clear();
793    bool hadMultipleThreads() const;
794
795    typedef std::vector<int_thread *>::iterator iterator;
796    iterator begin() { return threads.begin(); }
797    iterator end() { return threads.end(); }
798
799    unsigned size() const;
800
801    int_process *proc() const;
802    ThreadPool *pool() const;
803
804    int_thread *findThreadByLWP(Dyninst::LWP lwp);
805    int_thread *initialThread() const;
806    bool allHandlerStopped();
807    bool allStopped(int state_id);
808    
809    void saveUserState(Event::ptr ev);
810    void restoreUserState();
811 };
812
813 class int_library
814 {
815    friend class Dyninst::ProcControlAPI::LibraryPool;
816    friend class Dyninst::ProcControlAPI::LibraryPool::iterator;
817    friend class Dyninst::ProcControlAPI::LibraryPool::const_iterator;
818   private:
819    std::string name;
820    Dyninst::Address load_address;
821    Dyninst::Address data_load_address;
822    Dyninst::Address dynamic_address;
823    bool has_data_load;
824    bool marked;
825    void *user_data;
826    Library::ptr up_lib;
827   public:
828    int_library(std::string n, 
829                Dyninst::Address load_addr,
830                Dyninst::Address dynamic_load_addr, 
831                Dyninst::Address data_load_addr = 0, 
832                bool has_data_load_addr = false);
833    int_library(int_library *l);
834    ~int_library();
835    std::string getName();
836    Dyninst::Address getAddr();
837    Dyninst::Address getDataAddr();
838    Dyninst::Address getDynamicAddr();
839    bool hasDataAddr();
840    
841    void setMark(bool b);
842    bool isMarked() const;
843    
844    void setUserData(void *d);
845    void *getUserData();
846
847    Library::ptr getUpPtr() const;
848    void markAsCleanable();
849 };
850
851 class int_breakpoint
852 {
853    friend class installed_breakpoint;
854  private:
855    Breakpoint::weak_ptr up_bp;
856    Dyninst::Address to;
857    bool isCtrlTransfer_;
858    void *data;
859
860    bool onetime_bp;
861    bool onetime_bp_hit;
862    bool procstopper;
863    std::set<Thread::const_ptr> thread_specific;
864  public:
865    int_breakpoint(Breakpoint::ptr up);
866    int_breakpoint(Dyninst::Address to, Breakpoint::ptr up);
867    ~int_breakpoint();
868
869    bool isCtrlTransfer() const;
870    Dyninst::Address toAddr() const;
871    Dyninst::Address getAddress(int_process *p) const;
872    void *getData() const;
873    void setData(void *v);
874    
875    void setOneTimeBreakpoint(bool b);
876    void markOneTimeHit();
877    bool isOneTimeBreakpoint() const;
878    bool isOneTimeBreakpointHit() const;
879
880    void setThreadSpecific(Thread::const_ptr p);
881    bool isThreadSpecific() const;
882    bool isThreadSpecificTo(Thread::const_ptr p) const;
883
884    void setProcessStopper(bool b);
885    bool isProcessStopper() const;
886    
887    Breakpoint::weak_ptr upBreakpoint() const;
888 };
889
890 //At least as large as any arch's trap instruction
891 #define BP_BUFFER_SIZE 8
892 //Long breakpoints can be used to artifically increase the size of the BP write,
893 // which fools the BG breakpoint interception code that looks for 4 byte writes.
894 #define BP_LONG_SIZE 4
895 class installed_breakpoint
896 {
897    friend class Dyninst::ProcControlAPI::EventBreakpoint;
898  private:
899    mem_state::ptr memory;
900    std::set<int_breakpoint *> bps;
901    std::set<Breakpoint::ptr> hl_bps;
902
903    char buffer[BP_BUFFER_SIZE];
904    int buffer_size;
905    bool prepped;
906    bool installed;
907    bool long_breakpoint;
908    int suspend_count;
909    Dyninst::Address addr;
910
911    result_response::ptr write_response;
912    mem_response::ptr read_response;
913
914    bool writeBreakpoint(int_process *proc, result_response::ptr write_response);
915    bool saveBreakpointData(int_process *proc, mem_response::ptr read_response);
916    bool restoreBreakpointData(int_process *proc, result_response::ptr res_resp);
917
918  public:
919    installed_breakpoint(mem_state::ptr memory_, Dyninst::Address addr_);
920    installed_breakpoint(mem_state::ptr memory_, const installed_breakpoint *ip);
921    ~installed_breakpoint();
922
923    //Use these three functions to add a breakpoint
924    bool prepBreakpoint(int_process *proc, mem_response::ptr mem_resp);
925    bool insertBreakpoint(int_process *proc, result_response::ptr res_resp);
926    bool addBreakpoint(int_breakpoint *bp);
927    bool containsIntBreakpoint(int_breakpoint *bp);
928    int_breakpoint *getCtrlTransferBP(int_thread *thread);
929    
930    bool rmBreakpoint(int_process *proc, int_breakpoint *bp, bool &empty, result_response::ptr async_resp);
931    bool uninstall(int_process *proc, result_response::ptr async_resp);
932    bool suspend(int_process *proc, result_response::ptr result_resp);
933    bool resume(int_process *proc, result_response::ptr async_resp);
934
935    bool isInstalled() const;
936    Dyninst::Address getAddr() const;
937
938    typedef std::set<int_breakpoint *>::iterator iterator;
939    iterator begin();
940    iterator end();
941
942    unsigned getNumIntBreakpoints() const;
943 };
944
945 class emulated_singlestep {
946    // Breakpoints that are added and removed in a group to emulate
947    // a single step with breakpoints
948   private:
949    bool saved_user_single_step;
950    bool saved_single_step;
951    int_breakpoint *bp;
952    int_thread *thr;
953    std::set<Address> addrs;
954
955   public:
956    emulated_singlestep(int_thread *thr);
957    ~emulated_singlestep();
958    
959    bool containsBreakpoint(Address addr) const;
960    async_ret_t add(Address addr);
961    async_ret_t clear();
962    void restoreSSMode();
963
964    std::set<response::ptr> clear_resps;
965 };
966
967 class int_notify {
968    friend int_notify *notify();
969    friend EventNotify *Dyninst::ProcControlAPI::evNotify();
970  private:
971    static int_notify *the_notify;
972    EventNotify *up_notify;
973    std::set<EventNotify::notify_cb_t> cbs;
974    int pipe_in;
975    int pipe_out;
976    int pipe_count;
977    int events_noted;
978    void writeToPipe();
979    void readFromPipe();
980    bool createPipe();
981  public:
982    int_notify();
983    
984    void noteEvent();
985    void clearEvent();
986    void registerCB(EventNotify::notify_cb_t cb);
987    void removeCB(EventNotify::notify_cb_t cb);
988    bool hasEvents();
989    int getPipeIn();
990 };
991 int_notify *notify();
992
993 extern void setGeneratorThread(long t);
994 void setHandlerThread(long t);
995 bool isGeneratorThread();
996 bool isHandlerThread();
997 bool isUserThread();
998 HandlerPool *createDefaultHandlerPool(int_process *p);
999 HandlerPool *plat_createDefaultHandlerPool(HandlerPool *hpool);
1000
1001 class MTManager {
1002   friend MTManager *mt();
1003   friend class MTLock;
1004 private:
1005   static MTManager *mt_;
1006   DThread evhandler_thread;
1007   CondVar pending_event_lock;
1008   Mutex work_lock;
1009   bool have_queued_events;
1010   bool is_running;
1011   bool should_exit;
1012   Process::thread_mode_t threadMode;
1013   
1014   void evhandler_main();
1015   static void evhandler_main_wrapper(void *);
1016   void eventqueue_cb();
1017   
1018 public:
1019   static const Process::thread_mode_t default_thread_mode = Process::HandlerThreading;
1020   MTManager();
1021   ~MTManager();
1022   
1023   void run();
1024   void stop();
1025
1026   void startWork();
1027   void endWork();
1028   
1029   bool handlerThreading();
1030   Process::thread_mode_t getThreadMode();
1031   bool setThreadMode(Process::thread_mode_t tm, bool init = false);
1032
1033   static void eventqueue_cb_wrapper();
1034 }; 
1035
1036 inline MTManager *mt() { 
1037    return MTManager::mt_; 
1038 }
1039
1040 class MTLock
1041 {
1042  private:
1043    bool should_unlock;
1044  public:
1045    typedef enum {allow_init} initialize;
1046    typedef enum {allow_generator} generator;
1047    typedef enum {nocb, deliver_callbacks} callbacks;
1048    MTLock(initialize, callbacks c = nocb)
1049    {
1050       should_unlock = true;
1051       if (!MTManager::mt_) {
1052          MTManager::mt_ = new MTManager();
1053          if (MTManager::default_thread_mode == Process::HandlerThreading ||
1054              MTManager::default_thread_mode == Process::CallbackThreading) {
1055             mt()->startWork();
1056          }
1057          mt()->setThreadMode(MTManager::default_thread_mode, true);
1058       }
1059       else if (mt()->handlerThreading()) {
1060          mt()->startWork();
1061          if (c == deliver_callbacks && 
1062              MTManager::default_thread_mode == Process::HandlerThreading && 
1063              notify()->hasEvents()) 
1064          {
1065             pthrd_printf("MTLock triggered event handling\n");
1066             int_process::waitAndHandleEvents(false);
1067             pthrd_printf("MTLock triggered event handling finished\n");
1068          }
1069       }
1070    }
1071
1072    MTLock(generator)
1073    {
1074       if (isGeneratorThread()) {
1075          should_unlock = false;
1076          return;
1077       }
1078       should_unlock = true;
1079       if (mt()->handlerThreading()) {
1080          mt()->startWork();
1081       }
1082    }
1083
1084    MTLock(callbacks) 
1085    {
1086       assert(!isGeneratorThread());
1087       should_unlock = true;
1088       if (mt()->handlerThreading()) {
1089          mt()->startWork();
1090          if (notify()->hasEvents() && 
1091              MTManager::default_thread_mode == Process::HandlerThreading) 
1092          {
1093             pthrd_printf("MTLock triggered event handling\n");
1094             int_process::waitAndHandleEvents(false);
1095             pthrd_printf("MTLock triggered event handling finished\n");
1096          }
1097       }
1098    }
1099
1100    MTLock()
1101    {
1102       assert(!isGeneratorThread());
1103       should_unlock = true;
1104       if (mt()->handlerThreading())
1105          mt()->startWork();
1106    }
1107
1108    ~MTLock() {
1109       if (should_unlock && mt()->handlerThreading())
1110          mt()->endWork();
1111    }
1112 };
1113
1114 // A class to stop the various threads that have been started when
1115 // the library is deinitialized
1116 class int_cleanup {
1117     public:
1118         ~int_cleanup();
1119 };
1120
1121 #endif