Fix ProcControlAPI issue where continuing a stopped thread that had a running rpc...
[dyninst.git] / proccontrol / src / process.C
1 #include "proccontrol/src/int_process.h"
2 #include "proccontrol/src/irpc.h"
3 #include "proccontrol/src/procpool.h"
4 #include "proccontrol/src/int_handler.h"
5 #include "proccontrol/h/Mailbox.h"
6 #include "proccontrol/h/PCErrors.h"
7 #include "proccontrol/h/Generator.h"
8 #include "proccontrol/h/Event.h"
9 #include "proccontrol/h/Handler.h"
10
11 #include <cstring>
12 #include <cassert>
13
14 using namespace Dyninst;
15 using namespace std;
16
17 Process::thread_mode_t threadingMode = Process::GeneratorThreading;
18 bool int_process::in_callback = false;
19
20 bool int_process::create()
21 {
22    ProcPool()->condvar()->lock();
23    
24    bool result = plat_create();
25    if (!result) {
26       pthrd_printf("Could not create debuggee, %s\n", executable.c_str());
27       ProcPool()->condvar()->unlock();
28       return false;
29    }
30
31    int_thread *initial_thread;
32    initial_thread = int_thread::createThread(this, NULL_THR_ID, NULL_LWP, true);
33
34    ProcPool()->addProcess(this);
35    setState(neonatal_intermediate);
36
37    ProcPool()->condvar()->broadcast();
38    ProcPool()->condvar()->unlock();
39
40    pthrd_printf("Created debugged %s on pid %d\n", executable.c_str(), pid);
41    result = waitfor_startup();
42    if (getState() == int_process::exited) {
43       pthrd_printf("Process %s exited during create\n", executable.c_str());
44       return false;
45    }
46    if (!result) {
47       pthrd_printf("Error during process create for %d\n", pid);
48       return false;
49    }
50    result = post_create();
51    if (!result) {
52       pthrd_printf("Error during post create for %d\n", pid);
53       return false;
54    }
55   
56    assert(getState() == running);
57    return true;
58 }
59
60 bool int_process::waitfor_startup()
61 {
62    bool proc_exited;
63    for (;;) {
64       bool result;
65       
66       pthrd_printf("Waiting for startup to complete for %d\n", pid);
67       result = waitAndHandleForProc(true, this, proc_exited);
68       if (proc_exited || getState() == exited) {
69          pthrd_printf("Error.  Proces exited during create/attach\n");
70          return false;
71       }
72       if (!result || getState() == errorstate) {
73          pthrd_printf("Error.  Process %d errored during create/attach\n", pid);
74          return false;
75       }
76       if (getState() == running) {
77          pthrd_printf("Successfully completed create/attach on %d\n", pid);
78          return true;
79       }
80    }
81 }
82
83 bool int_process::multi_attach(std::vector<int_process *> &pids)
84 {
85    bool result;
86    bool had_error = false;
87    std::vector<int_process *>::iterator i;
88
89 #define for_each_procdebug(func, err_msg)                      \
90    for (i = pids.begin(); i != pids.end(); i++) {              \
91       int_process *pd = (*i);                                  \
92       if (!pd)                                                 \
93          continue;                                             \
94       result = pd->func();                                     \
95       if (!result) {                                           \
96          pthrd_printf("Could not %s to %d", err_msg, pd->pid); \
97          delete pd;                                            \
98          *i = NULL;                                            \
99          had_error = true;                                     \
100       }                                                        \
101    }
102
103    ProcPool()->condvar()->lock();
104
105    for_each_procdebug(plat_attach, "attach");
106    //MATT TODO: Add to ProcPool
107
108    ProcPool()->condvar()->broadcast();
109    ProcPool()->condvar()->unlock();
110
111    for_each_procdebug(waitfor_startup, "wait for attach");
112
113    for_each_procdebug(post_attach, "post attach");
114
115    return had_error;
116 }
117
118 bool int_process::attachThreads()
119 {
120    if (!needIndividualThreadAttach())
121       return true;
122
123    /**
124     * This OS (linux) needs us to attach to each thread manually.
125     * Get all the thread LWPs and create new thread objects for them.
126     * After we have all the threads, check again to see if there are any
127     * new ones.  We're dealing with the race condition where we could get
128     * a list of LWPs, but then new threads are created before we attach to 
129     * all the existing threads.
130     **/
131    bool found_new_threads;
132    do {
133       found_new_threads = false;
134       vector<Dyninst::LWP> lwps;
135       bool result = getThreadLWPs(lwps);
136       if (!result) {
137          perr_printf("Failed to get thread LWPs for %d\n", pid);
138          return false;
139       }
140       
141       ProcPool()->condvar()->lock();      
142       for (vector<Dyninst::LWP>::iterator i = lwps.begin(); i != lwps.end(); i++) {
143          int_thread *thr = threadpool->findThreadByLWP(*i);
144          if (thr) {
145             pthrd_printf("Already have thread %d in process %d\n", *i, pid);
146             continue;
147          }
148          pthrd_printf("Creating new thread for %d/%d during attach\n", pid, *i);
149          thr = int_thread::createThread(this, NULL_THR_ID, *i, false);
150          found_new_threads = true;         
151       }
152       ProcPool()->condvar()->broadcast();
153       ProcPool()->condvar()->unlock();
154    } while (found_new_threads);
155    return true;
156 }
157
158 bool int_process::attach()
159 {
160    ProcPool()->condvar()->lock();
161
162    pthrd_printf("Attaching to process %d\n", pid);
163    bool result = plat_attach();
164    if (!result) {
165       ProcPool()->condvar()->broadcast();
166       ProcPool()->condvar()->unlock();
167       pthrd_printf("Could not attach to debuggee, %d\n", pid);
168       return false;
169    }
170
171    int_thread *initial_thread;
172    initial_thread = int_thread::createThread(this, NULL_THR_ID, NULL_LWP, true);
173
174    ProcPool()->addProcess(this);
175
176    setState(neonatal_intermediate);
177
178    ProcPool()->condvar()->broadcast();
179    ProcPool()->condvar()->unlock();
180
181    result = attachThreads();
182    if (!result) {
183       pthrd_printf("Failed to attach to threads in %d\n", pid);
184       setLastError(err_internal, "Could not attach to process' threads");
185       goto error;
186    }
187
188    pthrd_printf("Wait for attach from process %d\n", pid);
189    result = waitfor_startup();
190    if (!result) {
191       pthrd_printf("Error waiting for attach to %d\n", pid);
192       setLastError(err_internal, "Process failed to startup");
193       goto error;
194    }
195
196    result = post_attach();
197    if (!result) {
198       pthrd_printf("Error on post attach for %d\n", pid);
199       setLastError(err_internal, "Process failed post-startup");
200       goto error;
201    }
202
203    return true;
204
205   error:
206    if (getState() == exited) {
207       setLastError(err_exited, "Process exited unexpectedly during attach\n");
208       return false;
209    }
210    pthrd_printf("Error during process attach for %d\n", pid);
211    return false;
212 }
213
214 bool int_process::execed()
215 {
216    ProcPool()->condvar()->lock();
217
218    bool should_clean = false;
219    mem->rmProc(this, should_clean);
220    if (should_clean)
221       delete mem;
222    mem = new mem_state(this);
223
224    arch = Dyninst::Arch_none;
225    exec_mem_cache.clear();
226    
227    while (!proc_stoppers.empty()) proc_stoppers.pop();
228
229    int_threadPool::iterator i = threadpool->begin(); 
230    for (; i != threadpool->end(); i++) {
231       int_thread *thrd = *i;
232       thrd->setHandlerState(int_thread::exited);
233       thrd->setInternalState(int_thread::exited);
234       thrd->setUserState(int_thread::exited);
235       thrd->setGeneratorState(int_thread::exited);
236       ProcPool()->rmThread(thrd);
237       delete thrd;
238    }
239    threadpool->clear();
240
241
242    int_thread *initial_thread;
243    initial_thread = int_thread::createThread(this, NULL_THR_ID, NULL_LWP, true);
244    initial_thread->setGeneratorState(int_thread::stopped);
245    initial_thread->setHandlerState(int_thread::stopped);
246    initial_thread->setInternalState(int_thread::running);
247    initial_thread->setUserState(int_thread::running);
248
249
250    ProcPool()->condvar()->broadcast();
251    ProcPool()->condvar()->unlock();
252    
253    bool result = plat_execed();
254
255    return result;
256 }
257
258 bool int_process::forked()
259 {
260    ProcPool()->condvar()->lock();
261
262    pthrd_printf("Setting up forked process %d\n", pid);
263    bool result = plat_forked();
264    if (!result) {
265       pthrd_printf("Could not handle forked debuggee, %d\n", pid);
266       return false;
267    }
268
269    int_thread *initial_thread;
270    initial_thread = int_thread::createThread(this, NULL_THR_ID, NULL_LWP, true);
271
272    ProcPool()->addProcess(this);
273
274    ProcPool()->condvar()->broadcast();
275    ProcPool()->condvar()->unlock();
276
277    result = attachThreads();
278    if (!result) {
279       pthrd_printf("Failed to attach to threads in %d\n", pid);
280       setLastError(err_internal, "Could not attach to process' threads");
281       goto error;
282    }
283
284    result = post_forked();
285    if (!result) {
286       pthrd_printf("Post-fork failed on %d\n", pid);
287       setLastError(err_internal, "Error handling forked process");
288       goto error;
289    }
290    return true;
291
292   error:
293    if (getState() == exited) {
294       setLastError(err_exited, "Process exited unexpectedly during attach\n");
295       return false;
296    }
297    pthrd_printf("Error during process attach for %d\n", pid);
298    return false;
299 }
300
301 bool int_process::post_forked()
302 {
303    setState(running);
304    return true;
305 }
306
307 bool int_process::post_attach()
308 {
309    bool result = initLibraryMechanism();
310    if (!result) {
311       pthrd_printf("Error initializing library mechanism\n");
312       return false;
313    }
314
315    std::set<int_library*> added, rmd;
316    result = refresh_libraries(added, rmd);
317    
318    return true;
319 }
320
321 bool int_process::post_create()
322 {
323    return initLibraryMechanism();
324 }
325
326 bool int_process::getThreadLWPs(std::vector<Dyninst::LWP> &)
327 {
328    return false;
329 }
330
331 const char *int_process::stateName(int_process::State s)
332 {
333    switch (s) {
334       case neonatal: return "neonatal";
335       case neonatal_intermediate: return "neonatal_intermediate";
336       case running: return "running";
337       case exited: return "exited";
338       case errorstate: return "errorstate";
339    }
340    assert(0);
341    return NULL;
342 }
343
344 void int_process::setState(int_process::State s)
345 {
346    int old_state = (int) state;
347    int new_state = (int) s;
348    
349    if (new_state < old_state) {
350       perr_printf("Regression of state %s to %s on %d\n",
351                   stateName(state), stateName(s), pid);
352       return;      
353    }
354    pthrd_printf("Changing state of process from %s to %s on %d\n",
355                 stateName(state), stateName(s), pid);
356    state = s;
357
358    int_thread::State new_thr_state = int_thread::errorstate;
359    switch (s) {
360       case neonatal: new_thr_state = int_thread::neonatal; break;
361       case neonatal_intermediate: new_thr_state = int_thread::neonatal_intermediate; break;
362       case running: new_thr_state = int_thread::stopped; break;
363       case exited: new_thr_state = int_thread::exited; break;
364       case errorstate: new_thr_state = int_thread::errorstate; break;
365    }
366    pthrd_printf("Setting state of all threads in %d to %s\n", pid, 
367                 int_thread::stateStr(new_thr_state));
368    for (int_threadPool::iterator i = threadpool->begin(); i != threadpool->end(); i++)
369    {
370       (*i)->setUserState(new_thr_state);
371       (*i)->setInternalState(new_thr_state);
372       (*i)->setHandlerState(new_thr_state);
373       (*i)->setGeneratorState(new_thr_state);
374    }
375 }
376
377 int_process::State int_process::getState() const
378 {
379    return state;
380 }
381
382 void int_process::setPid(Dyninst::PID p)
383 {
384    pthrd_printf("Setting int_process %p to pid %d\n", this, p);
385    pid = p;
386 }
387
388 Dyninst::PID int_process::getPid() const
389 {
390    return pid;
391 }
392
393 int_threadPool *int_process::threadPool() const
394 {
395    return threadpool;
396 }
397
398 Process::ptr int_process::proc() const
399 {
400    return up_proc;
401 }
402
403 struct syncRunStateRet_t {
404    bool hasRunningThread;
405    bool hasSyncRPC;
406    bool hasStopPending;
407    bool hasClearingBP;
408    bool hasProcStopRPC;
409    std::vector<int_process *> readyProcStoppers;
410    syncRunStateRet_t() :
411       hasRunningThread(false),
412       hasSyncRPC(false),
413       hasStopPending(false),
414       hasClearingBP(false),
415       hasProcStopRPC(false)
416    {
417    }
418 };
419
420 bool syncRunState(int_process *p, void *r)
421 {
422    int_threadPool *tp = p->threadPool();
423    syncRunStateRet_t *ret = (syncRunStateRet_t *) r;
424    assert(ret);
425    
426    if (p->hasQueuedProcStoppers() && p->threadPool()->allStopped()) {
427       ret->readyProcStoppers.push_back(p);
428    }
429    if (p->forceGeneratorBlock()) {
430       pthrd_printf("Process %d is forcing blocking via generator block\n", p->getPid());
431       ret->hasRunningThread = true;
432    }
433
434    if (dyninst_debug_proccontrol) {
435       for (int_threadPool::iterator i = tp->begin(); i != tp->end(); i++)
436       {
437          int_thread *thr = *i;
438          pthrd_printf("Pre-Thread %d/%d is in handler state %s with internal state %s (user is %s)\n",
439                       p->getPid(), thr->getLWP(), 
440                       int_thread::stateStr(thr->getHandlerState()),
441                       int_thread::stateStr(thr->getInternalState()),
442                       int_thread::stateStr(thr->getUserState()));
443       }
444    }
445
446    /**
447     * RPC Handling. 
448     **/
449    bool force_leave_stopped = false;
450    for (int_threadPool::iterator i = tp->begin(); i != tp->end(); i++)
451    {
452       int_thread *thr = *i;
453       thr->handleNextPostedIRPC(false);
454
455       int_iRPC::ptr rpc = thr->hasRunningProcStopperRPC();
456       if (!rpc)
457          continue;
458       ret->hasProcStopRPC = true;
459       if (rpc->getState() >= int_iRPC::Prepping) {
460          pthrd_printf("Thread %d/%d has pending proc stopper RPC, leaving other threads stopped\n",
461                       p->getPid(), thr->getLWP());
462          force_leave_stopped = true;            
463       }
464    }
465    
466    for (int_threadPool::iterator i = tp->begin(); i != tp->end(); i++)
467    {
468       int_thread *thr = *i;
469
470       if (thr->hasPendingStop()) {
471          ret->hasStopPending = true;
472       }
473       if (thr->isClearingBreakpoint()) {
474          ret->hasClearingBP = true;
475       }
476
477       int_iRPC::ptr pstop_rpc = thr->hasRunningProcStopperRPC();
478       if (thr->hasPendingStop() && thr->getHandlerState() == int_thread::stopped) {
479          pthrd_printf("Continuing thread %d/%d to clear out pending stop\n", 
480                       thr->llproc()->getPid(), thr->getLWP());
481          thr->intCont();
482       }
483       else if (thr->getInternalState() == int_thread::stopped && pstop_rpc && 
484                (pstop_rpc->getState() == int_iRPC::Running ||
485                 pstop_rpc->getState() == int_iRPC::Ready))
486       {
487          pthrd_printf("Continuing thread %d/%d due to pending procstop iRPC\n",
488                       p->getPid(), thr->getLWP());
489          thr->intCont();                      
490       }
491       else if (thr->getInternalState() == int_thread::running && 
492                thr->getHandlerState() == int_thread::stopped &&
493                !force_leave_stopped)
494       {
495          //The thread is stopped, but the user wants it running (we probably just finished 
496          // handling a sync event). Go ahead and continue the thread.
497          pthrd_printf("Continuing thread %d/%d to match internal state after events\n",
498                       p->getPid(), thr->getLWP());
499          thr->intCont();
500       }
501
502       if (thr->getInternalState() == int_thread::running || 
503           thr->getInternalState() == int_thread::neonatal_intermediate) {
504          //Keep track if any threads are running and running synchronous RPCs
505          ret->hasRunningThread = true;
506          if (thr->hasSyncRPC()) {
507             ret->hasSyncRPC = true;
508          }
509       }
510    }
511    pthrd_printf("Finished syncing runState for %d\n", p->getPid());
512    if (dyninst_debug_proccontrol) {
513       for (int_threadPool::iterator i = tp->begin(); i != tp->end(); i++)
514       {
515          int_thread *thr = *i;
516          pthrd_printf("Post-Thread %d/%d is in handler state %s with internal state %s (user is %s)\n",
517                       p->getPid(), thr->getLWP(), 
518                       int_thread::stateStr(thr->getHandlerState()),
519                       int_thread::stateStr(thr->getInternalState()),
520                       int_thread::stateStr(thr->getUserState()));
521       }
522    }
523    return true;
524 }
525
526 int_process *int_process::in_waitHandleProc = NULL;
527 bool int_process::waitAndHandleForProc(bool block, int_process *proc, bool &proc_exited)
528 {
529    assert(in_waitHandleProc == NULL);
530    in_waitHandleProc = proc;
531
532    bool result = waitAndHandleEvents(block);
533
534
535    if (proc->getState() == int_process::exited) {
536       pthrd_printf("Deleting proc %d from waitAndHandleForProc\n", proc->getPid());
537       delete proc;
538       proc_exited = true;
539    }
540    else {
541       proc_exited = false;
542    }
543
544    in_waitHandleProc = NULL;
545    return result;
546 }
547
548
549 bool int_process::waitAndHandleEvents(bool block)
550 {
551    bool gotEvent = false;
552    assert(!int_process::in_callback);
553    bool error = false;
554
555    static bool recurse = false;
556    assert(!recurse);
557    recurse = true;
558
559    for (;;)
560    {
561       /**
562        * Check status of threads
563        **/
564       pthrd_printf("Updating state of each process\n");
565       syncRunStateRet_t ret;
566       ProcPool()->for_each(syncRunState, &ret);
567
568       if (ret.readyProcStoppers.size()) {
569          int_process *proc = ret.readyProcStoppers[0];
570          Event::ptr ev = proc->removeProcStopper();
571          if (ev->triggersCB() &&
572              isHandlerThread() && 
573              mt()->getThreadMode() == Process::HandlerThreading) 
574          {
575             pthrd_printf("Handler thread sees postponed callback requiring " 
576                          "event '%s', not taking\n",
577                          ev->name().c_str());
578             notify()->noteEvent();
579             goto done;
580          }
581
582          pthrd_printf("Handling postponed proc stopper event on %d\n", proc->getPid());
583          proc->handlerpool->handleEvent(ev);
584          continue;
585       }
586
587       /**
588        * Check for possible error combinations from syncRunState
589        **/
590       if (!ret.hasRunningThread) {
591          if (gotEvent) {
592             //We've successfully handled an event, but no longer have any running threads
593             pthrd_printf("Returning after handling events, no threads running\n");
594             goto done;
595          }
596          if (isHandlerThread()) {
597             //Not an error for the handler thread to get no events.
598             pthrd_printf("Returning to handler due to no running threads\n");
599             goto done;
600          }
601          //The user called us with no running threads
602          setLastError(err_notrunning, "No running processes or threads to receive events on");
603          pthrd_printf("No running threads, returning from waitAndHandleEvents\n");
604          error = true;
605          goto done;
606       }
607
608       /**
609        * The handler thread doesn't want to pick up anything that
610        * requires a callback, leaving that for the user.  Peek ahead
611        * in the mailbox and abort out if we're the handler thread and
612        * the next event will require a callback.
613        **/
614       if (isHandlerThread() && mt()->getThreadMode() == Process::HandlerThreading) {
615          Event::ptr ev = mbox()->peek();
616          if (ev == Event::ptr()) 
617          {
618             pthrd_printf("Handler thread returning due to lack of events\n");
619             goto done;
620          }
621          if (ev->triggersCB())
622          {
623             pthrd_printf("Handler thread sees callback requiring event '%s', "
624                          "not taking\n", ev->name().c_str());
625             notify()->noteEvent();
626             goto done;
627          }
628       }
629       /**
630        * Check for new events
631        **/
632       bool should_block = ((block && !gotEvent) || ret.hasStopPending || 
633                            ret.hasSyncRPC || ret.hasClearingBP || ret.hasProcStopRPC);
634       pthrd_printf("%s for events (%d %d %d %d %d %d)\n", 
635                    should_block ? "Blocking" : "Polling",
636                    (int) block, (int) gotEvent, (int) ret.hasStopPending, 
637                    (int) ret.hasSyncRPC, (int) ret.hasClearingBP, (int) ret.hasProcStopRPC);
638       Event::ptr ev = mbox()->dequeue(should_block);
639
640       if (ev == Event::ptr())
641       {
642          if (block && gotEvent) {
643             pthrd_printf("Returning after handling events\n");
644             goto done;
645          }
646          if (should_block) {
647             perr_printf("Blocking wait failed to get events\n");
648             setLastError(err_internal, "Blocking wait returned without events");
649             error = true;
650             goto done;
651          }
652          if (isHandlerThread()) {
653             pthrd_printf("Handler thread found nothing to do\n");
654             goto done;
655          }
656          setLastError(err_noevents, "Poll failed to find events");
657          pthrd_printf("Poll failed to find events\n");
658          error = true;
659          goto done;
660       }
661       if (mt()->getThreadMode() == Process::NoThreads ||
662           mt()->getThreadMode() == Process::GeneratorThreading) 
663       {
664          pthrd_printf("Clearing event from pipe after dequeue\n");
665          notify()->clearEvent();
666       }
667       gotEvent = true;
668
669       ev->getProcess()->llproc()->updateSyncState(ev, false);
670
671       if (ev->procStopper()) {
672          /**
673           * This event wants the process stopped before it gets handled.
674           * We'll start that here, and then postpone the event until it's 
675           * stopped.  It's up to the event to continue the process again.
676           **/
677          int_process *proc = ev->getProcess()->llproc();
678          proc->threadPool()->desyncInternalState();
679          bool result = proc->threadPool()->intStop(false);
680          if (!result) {
681             pthrd_printf("Failed to stop process for event.\n");
682          }
683          else {
684             proc->addProcStopper(ev);
685          }
686          continue;
687       }
688
689       HandlerPool *hpool = ev->getProcess()->llproc()->handlerpool;
690       hpool->handleEvent(ev);
691
692       if (!ev->getProcess()->llproc())
693       {
694          //Special case event handling, the process cleaned itself
695          // under this event (likely post-exit or post-crash), but was 
696          // unable to clean its handlerpool (as we were using it).  
697          // Clean this for the process now.
698          delete hpool;
699       }
700    }
701   done:
702    recurse = false;
703    return !error;
704 }
705
706 bool int_process::detach(bool &should_delete)
707 {
708    should_delete = false;
709    bool had_error = true;
710    bool result;
711    int_threadPool *tp = threadPool();
712    pthrd_printf("Detach requested on %d\n", getPid());
713    while (!tp->allStopped()) {
714       pthrd_printf("Stopping process for detach\n");
715       tp->intStop(true);
716    }
717    
718    while (!mem->breakpoints.empty())
719    {      
720       std::map<Dyninst::Address, installed_breakpoint *>::iterator i = mem->breakpoints.begin();
721       bool result = i->second->uninstall(this);
722       if (!result) {
723          perr_printf("Error removing breakpoint at %lx\n", i->first);
724          setLastError(err_internal, "Error removing breakpoint before detach\n");
725          goto done;
726       }
727    }
728
729    ProcPool()->condvar()->lock();
730
731    result = plat_detach();
732    if (!result) {
733       pthrd_printf("Error performing lowlevel detach\n");
734       goto done;
735    }
736
737    had_error = false;
738   done:
739    ProcPool()->condvar()->signal();
740    ProcPool()->condvar()->unlock();
741
742    if (had_error) 
743       return false;
744    should_delete = true;
745    return true;
746 }
747
748 bool int_process::terminate(bool &needs_sync)
749 {
750    pthrd_printf("Terminate requested on process %d\n", getPid());
751    bool had_error = true;
752    ProcPool()->condvar()->lock();
753    bool result = plat_terminate(needs_sync);
754    if (!result) {
755       pthrd_printf("plat_terminate failed on %d\n", getPid());
756       goto done;
757    }
758    setForceGeneratorBlock(true);
759    had_error = false;
760   done:
761    ProcPool()->condvar()->signal();
762    ProcPool()->condvar()->unlock();
763    return !had_error;
764 }
765
766 int_process::int_process(Dyninst::PID p, std::string e, std::vector<std::string> a) :
767    state(neonatal),
768    pid(p),
769    executable(e),
770    argv(a),
771    arch(Dyninst::Arch_none),
772    threadpool(NULL),
773    up_proc(Process::ptr()),
774    handlerpool(NULL),
775    hasCrashSignal(false),
776    crashSignal(0),
777    hasExitCode(false),
778    forceGenerator(false),
779    exitCode(0),
780    mem(NULL)
781 {
782    //Put any object initialization in 'initializeProcess', below.
783 }
784
785 int_process::int_process(Dyninst::PID pid_, int_process *p) :
786    state(int_process::running),
787    pid(pid_),
788    executable(p->executable),
789    argv(p->argv),
790    arch(p->arch),
791    hasCrashSignal(p->hasCrashSignal),
792    crashSignal(p->crashSignal),
793    hasExitCode(p->hasExitCode),
794    forceGenerator(false),
795    exitCode(p->exitCode),
796    exec_mem_cache(exec_mem_cache)
797 {
798    Process::ptr hlproc = Process::ptr(new Process());
799    mem = new mem_state(*p->mem, this);
800    initializeProcess(hlproc);
801 }
802
803 void int_process::initializeProcess(Process::ptr p)
804 {
805    p->llproc_ = this;
806    up_proc = p;
807    threadpool = new int_threadPool(this);
808    handlerpool = createDefaultHandlerPool();
809    libpool.proc = this;
810    if (!mem)
811       mem = new mem_state(this);
812    Generator::getDefaultGenerator(); //May create generator thread
813 }
814
815 int_thread *int_process::findStoppedThread()
816 {
817    ProcPool()->condvar()->lock();
818    int_thread *result = NULL;
819    for (int_threadPool::iterator i = threadpool->begin(); i != threadpool->end(); i++)
820    {
821       int_thread *thr = *i;
822       if (thr->getHandlerState() == int_thread::stopped) {
823          result = thr;
824          break;
825       }
826    }   
827    ProcPool()->condvar()->unlock();
828    if (result) {
829       assert(result->getGeneratorState() == int_thread::stopped);
830    }
831    return result;
832 }
833
834 bool int_process::readMem(void *local, Dyninst::Address remote, size_t size)
835 {
836    int_thread *thr = findStoppedThread();
837    if (!thr) {
838       setLastError(err_notstopped, "A thread must be stopped to read from memory");
839       perr_printf("Unable to find a stopped thread for read in process %d\n", getPid());
840       return false;
841    }
842    pthrd_printf("Reading from remote memory %lx to %p, size = %lu on %d/%d\n",
843                 remote, local, (unsigned long) size, getPid(), thr->getLWP());
844    return plat_readMem(thr, local, remote, size);
845 }
846
847 bool int_process::writeMem(void *local, Dyninst::Address remote, size_t size)
848 {
849    int_thread *thr = findStoppedThread();
850    if (!thr) {
851       setLastError(err_notstopped, "A thread must be stopped to write to memory");
852       perr_printf("Unable to find a stopped thread for write in process %d\n", getPid());
853       return false;
854    }
855    pthrd_printf("Writing to remote memory %lx from %p, size = %lu on %d/%d\n",
856                 remote, local, (unsigned long) size, getPid(), thr->getLWP());
857    return plat_writeMem(thr, local, remote, size);
858 }
859
860 Dyninst::Address int_process::mallocExecMemory(unsigned size)
861 {
862    Dyninst::Address max = 0;
863    std::map<Dyninst::Address, unsigned>::iterator i;
864    for (i = exec_mem_cache.begin(); i != exec_mem_cache.end(); i++) {
865       if (i->first + i->second > max)
866          max = i->first + i->second;
867    }
868
869    Dyninst::Address addr = plat_mallocExecMemory(max, size);
870    exec_mem_cache[addr] = size;
871    return addr;
872 }
873
874 void int_process::freeExecMemory(Dyninst::Address addr)
875 {
876    std::map<Dyninst::Address, unsigned>::iterator i;
877    i = exec_mem_cache.find(addr);
878    assert(i != exec_mem_cache.end());
879    exec_mem_cache.erase(i);
880 }
881
882 Dyninst::Address int_process::infMalloc(unsigned long size, bool use_addr, Dyninst::Address addr)
883 {
884    pthrd_printf("Process %d is allocating memory of size %lu at 0x%lx\n", getPid(), size, addr);
885    int_iRPC::ptr rpc = rpcMgr()->createInfMallocRPC(this, size, use_addr, addr);
886    assert(rpc);
887    rpcMgr()->postRPCToProc(this, rpc);
888
889    int_thread *thr = rpc->thread();
890    bool result = thr->handleNextPostedIRPC(true);
891    if (!result) {
892       pthrd_printf("Failed to handleNextPostedIRPC\n");
893       return 0;
894    }
895
896    if (rpc->getState() != int_iRPC::Finished) 
897    {
898       bool proc_exited;
899       result = waitAndHandleForProc(true, this, proc_exited);
900       if (proc_exited) {
901          perr_printf("Process exited during infMalloc\n");
902          setLastError(err_exited, "Process exited during infMalloc\n");
903          return 0;
904       }
905       if (!result) {
906          pthrd_printf("Error in waitAndHandleEvents");
907          return 0;
908       }
909    }
910    assert(rpc->getState() == int_iRPC::Finished);
911
912    Dyninst::Address aresult = rpc->infMallocResult();
913    pthrd_printf("Inferior malloc returning %lx\n", aresult);
914    mem->inf_malloced_memory[aresult] = size;
915    return aresult;
916 }
917
918 bool int_process::infFree(Dyninst::Address addr)
919 {
920    std::map<Dyninst::Address, unsigned long>::iterator i = mem->inf_malloced_memory.find(addr);
921    if (i == mem->inf_malloced_memory.end()) {
922       setLastError(err_badparam, "Unknown address passed to freeMemory");
923       perr_printf("Passed bad address, %lx, to infFree\n", addr);
924       return false;
925    }
926    unsigned long size = i->second;
927
928    int_iRPC::ptr rpc = rpcMgr()->createInfFreeRPC(this, size, addr);
929    assert(rpc);
930    pthrd_printf("Process %d is freeing memory of size %lu at 0x%lx with rpc %lu\n", getPid(), size, addr,
931                 rpc->id());
932    rpcMgr()->postRPCToProc(this, rpc);
933
934    int_thread *thr = rpc->thread();
935    bool result = thr->handleNextPostedIRPC(true);
936    if (!result) {
937       pthrd_printf("Failed to handleNextPostedIRPC\n");
938       return 0;
939    }
940
941    if (rpc->getState() != int_iRPC::Finished) 
942    {
943       bool proc_exited;
944       result = waitAndHandleForProc(true, this, proc_exited);
945       if (proc_exited) {
946          perr_printf("Process exited during infFree\n");
947          setLastError(err_exited, "Process exited during infFree\n");
948          return false;
949       }
950       if (!result) {
951          pthrd_printf("Error in waitAndHandleEvents");
952          return false;
953       }
954    }
955    assert(rpc->getState() == int_iRPC::Finished);
956
957    pthrd_printf("Inferior free returning successfully\n");
958    mem->inf_malloced_memory.erase(i);
959    return true;
960 }
961
962 void int_process::addProcStopper(Event::ptr ev)
963 {
964    proc_stoppers.push(ev);
965 }
966
967 bool int_process::forceGeneratorBlock() const
968 {
969    return forceGenerator;
970 }
971
972 void int_process::setForceGeneratorBlock(bool b)
973 {
974    forceGenerator = b;
975 }
976
977 Event::ptr int_process::removeProcStopper()
978 {
979    assert(proc_stoppers.size());
980    Event::ptr ret = proc_stoppers.front();
981    proc_stoppers.pop();
982    return ret;
983 }
984
985 bool int_process::hasQueuedProcStoppers() const
986 {
987    return !proc_stoppers.empty();
988 }
989
990 int int_process::getAddressWidth()
991 {
992    switch (getTargetArch()) {
993       case Arch_x86:
994       case Arch_ppc32:
995          return 4;
996       case Arch_x86_64:
997       case Arch_ppc64:
998          return 8;
999       case Arch_none:
1000          assert(0);
1001    }
1002    return 0;
1003 }
1004
1005 HandlerPool *int_process::handlerPool() const
1006 {
1007    return handlerpool;
1008 }
1009
1010 bool int_process::addBreakpoint(Dyninst::Address addr, int_breakpoint *bp)
1011 {
1012    if (getState() != running) {
1013       perr_printf("Attempted to add breakpoint at %lx to stopped process %d\n", addr, getPid());
1014       setLastError(err_exited, "Attempted to insert breakpoint into exited process\n");
1015       return false;
1016    }
1017
1018    pthrd_printf("Installing new breakpoint at %lx into %d\n", addr, getPid());
1019    installed_breakpoint *ibp = NULL;
1020    map<Address, installed_breakpoint *>::iterator i = mem->breakpoints.find(addr);
1021    if (i == mem->breakpoints.end()) {
1022       pthrd_printf("Adding new breakpoint to %d\n", getPid());
1023       ibp = new installed_breakpoint(mem, addr);
1024       ibp->addBreakpoint(this, bp);
1025       bool result = ibp->install(this);
1026       if (!result) {
1027          pthrd_printf("Failed to install new breakpoint\n");
1028          return false;
1029       }
1030       return true;
1031    }
1032    ibp = i->second;
1033    assert(ibp && ibp->isInstalled());
1034    bool result = ibp->addBreakpoint(this, bp);
1035    if (!result) {
1036       pthrd_printf("Failed to install new breakpoint\n");
1037       return false;
1038    }
1039
1040    return true;
1041 }
1042
1043 bool int_process::rmBreakpoint(Dyninst::Address addr, int_breakpoint *bp)
1044 {
1045    map<Address, installed_breakpoint *>::iterator i = mem->breakpoints.find(addr);
1046    if (i == mem->breakpoints.end()) {
1047       perr_printf("Attempted to removed breakpoint that isn't installed\n");
1048       return false;
1049    }
1050    installed_breakpoint *ibp = i->second;
1051    assert(ibp && ibp->isInstalled());
1052
1053    bool empty;
1054    bool result = ibp->rmBreakpoint(this, bp, empty);
1055    if (!result) {
1056       pthrd_printf("rmBreakpoint failed on breakpoint at %lx in %d\n", addr, getPid());
1057       return false;
1058    }
1059    if (empty) {
1060       delete ibp;
1061    }
1062
1063    return true;
1064 }
1065
1066 installed_breakpoint *int_process::getBreakpoint(Dyninst::Address addr)
1067 {
1068    std::map<Dyninst::Address, installed_breakpoint *>::iterator  i = mem->breakpoints.find(addr);
1069    if (i == mem->breakpoints.end())
1070       return NULL;
1071    return i->second;
1072 }
1073
1074 int_library *int_process::getLibraryByName(std::string s) const
1075 {
1076    for (set<int_library *>::iterator i = mem->libs.begin(); 
1077         i != mem->libs.end(); i++) 
1078    {
1079       if (s == (*i)->getName())
1080          return *i;
1081    }
1082    return NULL;
1083 }
1084
1085 size_t int_process::numLibs() const
1086 {
1087    return mem->libs.size();
1088 }
1089
1090 std::string int_process::getExecutable() const
1091 {
1092    return executable;
1093 }
1094
1095 bool int_process::isInCallback()
1096 {
1097    return in_callback;
1098 }
1099
1100 mem_state::ptr int_process::memory() const
1101 {
1102    return mem;
1103 }
1104
1105 void int_process::setExitCode(int c)
1106 {
1107    assert(!hasCrashSignal);
1108    hasExitCode = true;
1109    exitCode = c;
1110 }
1111
1112 void int_process::setCrashSignal(int s)
1113 {
1114    assert(!hasExitCode);
1115    hasCrashSignal = true;
1116    crashSignal = s;
1117 }
1118
1119 bool int_process::getExitCode(int &c)
1120 {
1121    c = exitCode;
1122    return hasExitCode;
1123 }
1124
1125 bool int_process::getCrashSignal(int &s)
1126 {
1127    s = crashSignal;
1128    return hasCrashSignal;
1129 }
1130
1131 bool int_process::isInCB()
1132 {
1133    return in_callback;
1134 }
1135
1136 void int_process::setInCB(bool b)
1137 {
1138    assert(in_callback == !b);
1139    in_callback = b;
1140 }
1141
1142 void int_process::updateSyncState(Event::ptr ev, bool gen)
1143 {
1144    EventType etype = ev->getEventType();
1145    switch (ev->getSyncType()) {
1146       case Event::async:
1147          pthrd_printf("Event %s is asynchronous\n", etype.name().c_str());
1148          break;
1149       case Event::sync_thread: {
1150          int_thread *thrd = ev->getThread()->llthrd();
1151          if (!thrd)
1152             return;
1153          pthrd_printf("Event %s is thread synchronous, marking thread %d stopped\n", 
1154                       etype.name().c_str(), thrd->getLWP());
1155          int_thread::State old_state = gen ? thrd->getGeneratorState() : thrd->getHandlerState();
1156          assert(old_state == int_thread::running ||
1157                 old_state == int_thread::neonatal_intermediate);
1158          if (old_state == int_thread::errorstate)
1159             break;
1160          if (gen)
1161             thrd->setGeneratorState(int_thread::stopped);
1162          else
1163             thrd->setHandlerState(int_thread::stopped);
1164          break;
1165       }
1166       case Event::sync_process: {
1167          pthrd_printf("Event %s is process synchronous, marking process %d stopped\n", 
1168                       etype.name().c_str(), getPid());
1169          int_threadPool *tp = threadPool();
1170          for (int_threadPool::iterator i = tp->begin(); i != tp->end(); i++) {
1171             int_thread *thrd = *i;
1172             int_thread::State old_state = gen ? thrd->getGeneratorState() : thrd->getHandlerState();
1173             if (old_state != int_thread::running &&
1174                 old_state != int_thread::neonatal_intermediate)
1175                continue;
1176             if (gen)
1177                thrd->setGeneratorState(int_thread::stopped);
1178             else
1179                thrd->setHandlerState(int_thread::stopped);
1180          }
1181          break;
1182       }
1183       case Event::unset: {
1184          assert(0);
1185       }
1186    }
1187 }
1188
1189 int_process::~int_process()
1190 {
1191    if (up_proc != Process::ptr())
1192    {
1193       proc_exitstate *exitstate = new proc_exitstate();
1194       exitstate->pid = pid;
1195       exitstate->exited = hasExitCode;
1196       exitstate->exit_code = exitCode;
1197       exitstate->crashed = hasCrashSignal;
1198       exitstate->crash_signal = crashSignal;
1199       assert(!up_proc->exitstate_);
1200       up_proc->exitstate_ = exitstate;
1201       up_proc->llproc_ = NULL;
1202    }
1203
1204    if (threadpool) {
1205       delete threadpool;
1206       threadpool = NULL;
1207    }
1208    //Do not delete handlerpool yet, we're currently under
1209    // an event handler.  We do want to delete this if called
1210    // from detach.
1211    bool should_clean;
1212    mem->rmProc(this, should_clean);
1213    if (should_clean) {
1214       delete mem;
1215    }
1216    mem = NULL;
1217 }
1218
1219 bool int_threadPool::userCont()
1220 {
1221    return cont(true);
1222 }
1223
1224 bool int_threadPool::intCont()
1225 {
1226    return cont(false);
1227 }
1228
1229 bool int_threadPool::cont(bool user_cont)
1230 {
1231    pthrd_printf("%s continuing process %d\n", user_cont ? "User" : "Int", proc()->getPid());
1232
1233    Dyninst::PID pid = proc()->getPid();
1234    bool had_error = false;
1235    bool cont_something = false;
1236
1237    ProcPool()->condvar()->lock();
1238
1239    for (iterator i = begin(); i != end(); i++) {
1240       int_thread *thr = *i;
1241       assert(thr);
1242
1243       pthrd_printf("Continuing thread %d on process %d\n", thr->getLWP(), pid);
1244       int_thread::stopcont_ret_t ret = thr->cont(user_cont, true);
1245       switch (ret) {
1246          case int_thread::sc_skip:
1247             break;
1248          case int_thread::sc_error:
1249             had_error = true;
1250             break;
1251          case int_thread::sc_success:
1252          case int_thread::sc_success_pending:
1253             cont_something = true;
1254             break;
1255       }
1256    }
1257
1258    ProcPool()->condvar()->signal();
1259    ProcPool()->condvar()->unlock();
1260
1261    if (!cont_something) {
1262       perr_printf("Failed to continue exited process %d\n", pid);
1263       setLastError(err_exited, "Continue attempted on exited process\n");
1264       return false;
1265    }
1266
1267    return !had_error;
1268 }
1269
1270 bool int_thread::userCont()
1271 {
1272    return cont(true);
1273 }
1274
1275 bool int_thread::intCont()
1276 {
1277    return cont(false);
1278 }
1279
1280 bool int_thread::cont(bool user_cont)
1281 {
1282    pthrd_printf("%s continuing single thread %d/%d\n", user_cont ? "User" : "Int",
1283                 llproc()->getPid(), getLWP());
1284
1285    bool result = rpcMgr()->handleThreadContinue(this, user_cont);
1286    if (!result) {
1287       pthrd_printf("Error handling IRPC during continue\n");
1288       return false;
1289    }
1290
1291    if (!llproc()->independentLWPControl()) {
1292       pthrd_printf("%s continuing entire process %d on thread operation on %d\n",
1293                    user_cont ? "User" : "Int", llproc()->getPid(), getLWP());
1294       if (user_cont) {
1295          return llproc()->threadPool()->userCont();
1296       }
1297       else {
1298          return llproc()->threadPool()->intCont();
1299       }
1300    }
1301    stopcont_ret_t ret = cont(user_cont, false);
1302
1303    if (ret == sc_skip) {
1304       perr_printf("Attempted to continue exited thread\n");
1305       setLastError(err_exited, "Attempted thread continue on exited thread\n");
1306       return false;
1307    }
1308    if (ret == sc_error) {
1309       if (user_cont) {
1310          //The internal state is running, so there was an internal error during continue, but
1311          // the user state was stopped.  We won't treat this as a user error and instead
1312          // just change the user state.
1313          pthrd_printf("Ignoring previous error on %d/%d\n", llproc()->getPid(), getLWP());
1314       }
1315       else {
1316          pthrd_printf("Error continuing thread %d/%d\n", llproc()->getPid(), getLWP());
1317          return false;
1318       }
1319    }
1320
1321    if (user_cont) 
1322    {
1323       bool result = setUserState(int_thread::running);
1324       if (!result) {
1325          setLastError(err_exited, "Attempted thread continue on exited thread\n");
1326          perr_printf("Failed to continue thread %d/%d--bad state\n", llproc()->getPid(), getLWP());
1327          return false;
1328       }
1329    }
1330
1331    return true;
1332 }
1333
1334 int_thread::stopcont_ret_t int_thread::cont(bool user_cont, bool have_proc_lock)
1335 {
1336    Dyninst::PID pid = proc()->getPid();
1337
1338    pthrd_printf("Top level %s continue for %d/%d\n",
1339                 user_cont ? "user" : "int", pid, lwp);
1340
1341    if (getHandlerState() == errorstate) {
1342       pthrd_printf("thread %d on process %d in error state\n", getLWP(), pid);
1343       return sc_skip;
1344    }
1345    if (getHandlerState() == exited) {
1346       pthrd_printf("thread %d on process %d already exited\n", getLWP(), pid);
1347       return sc_skip;
1348    }
1349
1350    if (user_cont) {
1351       setUserState(running);
1352    }
1353
1354    if (getHandlerState() != stopped) {
1355       perr_printf("Error. continue attempted on running thread %d/%d\n", pid, lwp);
1356       setLastError(err_notstopped, "Continue attempted on running thread\n");
1357       return sc_error;
1358    }
1359
1360    if (!have_proc_lock) {
1361       ProcPool()->condvar()->lock();
1362    }
1363
1364    regpool_lock.lock();
1365    cached_regpool.regs.clear();
1366    cached_regpool.full = false;
1367    regpool_lock.unlock();
1368
1369    bool result = plat_cont();
1370    if (result) {
1371       setInternalState(running);
1372       setHandlerState(running);
1373       setGeneratorState(running);
1374    }
1375
1376    if (!have_proc_lock) {
1377       ProcPool()->condvar()->signal();
1378       ProcPool()->condvar()->unlock();
1379    }
1380
1381    if (!result) {
1382       pthrd_printf("Could not resume debugee %d, thread %d\n", pid, lwp);
1383       return sc_error;
1384    }
1385
1386    return sc_success;
1387 }
1388
1389 bool int_threadPool::userStop()
1390 {
1391    return stop(true, true);
1392 }
1393
1394 bool int_threadPool::intStop(bool sync)
1395 {
1396    return stop(false, sync);
1397 }
1398
1399 bool int_threadPool::stop(bool user_stop, bool sync)
1400 {
1401    bool stopped_something = false;
1402    bool had_error = false;
1403    bool needs_sync = false;
1404    for (iterator i = begin(); i != end(); i++) {
1405       int_thread *thr = *i;
1406
1407       pthrd_printf("Process %d performing %s stop on thread %d\n", proc()->getPid(),
1408                    user_stop ? "user" : "int",  thr->getLWP());
1409       int_thread::stopcont_ret_t ret = thr->stop(user_stop);
1410       switch (ret) {
1411          case int_thread::sc_skip:
1412             pthrd_printf("int_thread::stop on %d/%d returned sc_skip\n", 
1413                          proc()->getPid(), thr->getLWP());
1414             break;
1415          case int_thread::sc_error:            
1416             pthrd_printf("int_thread::stop on %d/%d returned sc_error\n", 
1417                          proc()->getPid(), thr->getLWP());
1418             if (getLastError() == err_noproc) 
1419                pthrd_printf("int_thread::stop thread exit on %d/%d, skipping stop\n",
1420                             proc()->getPid(), thr->getLWP());
1421             else
1422                had_error = true;
1423             break;
1424          case int_thread::sc_success_pending:
1425             pthrd_printf("int_thread::stop on %d/%d return sc_success_pending\n",
1426                          proc()->getPid(), thr->getLWP());
1427             stopped_something = true;
1428             needs_sync = true;
1429             break;
1430          case int_thread::sc_success:
1431             pthrd_printf("int_thread::stop on %d/%d returned sc_success\n", 
1432                          proc()->getPid(), thr->getLWP());
1433             stopped_something = true;
1434             break;
1435       }
1436    }
1437
1438    if (had_error) {
1439       pthrd_printf("Error while stopping threads on %d\n", proc()->getPid());
1440       setLastError(err_internal, "Could not stop process\n");
1441       return false;
1442    }
1443    if (!stopped_something) {
1444       perr_printf("No threads can be stopped on %d\n", proc()->getPid());
1445       setLastError(err_notrunning, "Attempt to stop a process that isn't running\n");
1446       return false;
1447    }
1448
1449    if (needs_sync && sync)
1450    {
1451       bool proc_exited;
1452       bool result = int_process::waitAndHandleForProc(true, proc(), proc_exited);
1453       if (proc_exited) {
1454          pthrd_printf("Process exited during stop\n");
1455          setLastError(err_exited, "Process exited during stop\n");
1456          return false;
1457       }
1458       if (!result) {
1459          perr_printf("Error waiting for events after stop on %d\n", proc()->getPid());
1460          return false;
1461       }
1462    }
1463
1464    return true;
1465 }
1466
1467 int_thread::stopcont_ret_t int_thread::stop(bool user_stop)
1468 {
1469    Dyninst::PID pid = proc()->getPid();
1470    pthrd_printf("Top level %s thread pause for %d/%d\n", 
1471                 user_stop ? "user" : "int", pid, lwp);
1472
1473    if (getHandlerState() == errorstate) {
1474       pthrd_printf("thread %d on process %d in error state\n", getLWP(), pid);
1475       return sc_skip;
1476    }
1477    if (getHandlerState() == exited) {
1478       pthrd_printf("thread %d on process %d already exited\n", getLWP(), pid);
1479       return sc_skip;
1480    }
1481
1482    if (pending_stop) {
1483       pthrd_printf("thread %d has in-progress stop on process %d\n", getLWP(), pid);
1484       return sc_success;
1485    }
1486    if (getHandlerState() == stopped) {         
1487       pthrd_printf("thread %d on process %d is already handler stopped, leaving\n", 
1488                    getLWP(), pid);
1489       if (user_stop)
1490          setUserState(stopped);
1491       setInternalState(stopped);
1492       return sc_success;
1493    }
1494    if (getInternalState() == stopped) {
1495       pthrd_printf("thread %d is already stopped on process %d\n", getLWP(), pid);
1496       if (user_stop)
1497          setUserState(stopped);
1498       return sc_success;
1499    }
1500    if (getHandlerState() != running)
1501    {
1502       perr_printf("Attempt to stop thread %d/%d in bad state %d\n", 
1503                   pid, lwp, getHandlerState());
1504       setLastError(err_internal, "Bad state during thread stop attempt\n");
1505       return sc_error;
1506    }
1507
1508    assert(!pending_stop);
1509    pending_stop = true;
1510    if (user_stop) {
1511       assert(!pending_user_stop);
1512       pending_user_stop = true;
1513    }
1514
1515    bool result = plat_stop();
1516    if (!result) {
1517       pthrd_printf("Could not pause debuggee %d, thr %d\n", pid, lwp);
1518       pending_stop = false;
1519       return sc_error;
1520    }
1521
1522    if (pending_stop)
1523       return sc_success_pending;
1524    else
1525       return sc_success;
1526 }
1527
1528 bool int_thread::stop(bool user_stop, bool sync)
1529 {
1530    if (!llproc()->independentLWPControl()) {
1531       if (user_stop) {
1532          pthrd_printf("User stopping entire process %d on thread operation on %d\n",
1533                       llproc()->getPid(), getLWP());
1534          return llproc()->threadPool()->userStop();
1535       }
1536       else {
1537          pthrd_printf("Int stopping entire process %d on thread operation on %d\n",
1538                       llproc()->getPid(), getLWP());
1539          return llproc()->threadPool()->intStop();
1540       }
1541    }
1542
1543    pthrd_printf("%s stopping single thread %d/%d\n", user_stop ? "User" : "Int",
1544                 llproc()->getPid(), getLWP());
1545
1546    stopcont_ret_t ret = stop(user_stop);
1547    if (ret == sc_skip) {
1548       perr_printf("Thread %d/%d was not in a stoppable state\n", 
1549                   llproc()->getPid(), getLWP());
1550       setLastError(err_notrunning, "Attempt to stop a thread that isn't running\n");
1551       return false;
1552    }
1553    if (ret == sc_error) {
1554       pthrd_printf("Thread %d/%d returned error during stop\n",
1555                    llproc()->getPid(), getLWP());
1556       return false;
1557    }
1558    if (ret == sc_success) {
1559       pthrd_printf("Thread %d/%d successfully stopped\n",
1560                    llproc()->getPid(), getLWP());
1561       return true;
1562    }
1563    assert(ret == sc_success_pending);
1564    if (!sync) {
1565       pthrd_printf("Thread %d/%d successfully stopped, but not sync'd\n",
1566                    llproc()->getPid(), getLWP());
1567       return true;
1568    }
1569
1570    bool proc_exited;
1571    bool result = int_process::waitAndHandleForProc(true, llproc(), proc_exited);
1572    if (proc_exited) {
1573       pthrd_printf("Process exited during thread stop\n");
1574       setLastError(err_exited, "Process exited during stop\n");
1575       return false;
1576    }
1577    if (!result) {
1578       perr_printf("Error waiting for events after stop on %d\n", getLWP());
1579       return false;
1580    }
1581    return true;
1582 }
1583
1584 bool int_thread::userStop()
1585 {
1586    return stop(true, true);
1587 }
1588
1589 bool int_thread::intStop(bool sync)
1590 {
1591    return stop(false, sync);
1592 }
1593
1594 void int_thread::setPendingUserStop(bool b)
1595 {
1596    pending_user_stop = b;
1597 }
1598
1599 bool int_thread::hasPendingUserStop() const
1600 {
1601    return pending_user_stop;
1602 }
1603
1604 void int_thread::setPendingStop(bool b)
1605 {
1606    pending_stop = b;
1607 }
1608
1609 bool int_thread::hasPendingStop() const
1610 {
1611    return pending_stop;
1612 }
1613
1614 Process::ptr int_thread::proc() const
1615 {
1616    return proc_->proc();
1617 }
1618
1619 int_process *int_thread::llproc() const
1620 {
1621    return proc_;
1622 }
1623
1624 Dyninst::THR_ID int_thread::getTid() const
1625 {
1626    return tid;
1627 }
1628
1629 Dyninst::LWP int_thread::getLWP() const
1630 {
1631    return lwp;
1632 }
1633
1634 int_thread::State int_thread::getHandlerState() const
1635 {
1636    return handler_state;
1637 }
1638
1639 int_thread::State int_thread::getUserState() const
1640 {
1641    return user_state;
1642 }
1643
1644 int_thread::State int_thread::getGeneratorState() const
1645 {
1646    return generator_state;
1647 }
1648
1649 int_thread::State int_thread::getInternalState() const
1650 {
1651    return internal_state;
1652 }
1653
1654 const char *int_thread::stateStr(int_thread::State s)
1655 {
1656    switch (s) {
1657       case neonatal: return "neonatal";
1658       case neonatal_intermediate: return "neonatal_intermediate";
1659       case running: return "running";
1660       case stopped: return "stopped";
1661       case exited: return "exited";
1662       case errorstate: return "errorstate";
1663    }
1664    assert(0);
1665    return NULL;
1666 }
1667
1668 bool int_thread::setAnyState(int_thread::State *from, int_thread::State to)
1669 {
1670    const char *s = NULL;
1671    if (from == &handler_state) {
1672       s = "handler state";
1673    }
1674    else if (from == &user_state) {
1675       s = "user state";
1676    }
1677    else if (from == &generator_state) {
1678       s = "generator state";
1679    }
1680    else if (from == &internal_state) {
1681       s = "internal state";
1682    }
1683    assert(s);
1684
1685    if (*from == to) {
1686       pthrd_printf("Leaving %s for %d in state %s\n", s, lwp, stateStr(to));
1687       return true;
1688    }
1689    if (to == errorstate) {
1690       perr_printf("Setting %s for %d from %s to errorstate\n", 
1691                   s, lwp, stateStr(*from));
1692       *from = to;
1693       return true;
1694    }
1695    if (*from == errorstate) {
1696       perr_printf("Attempted %s reversion for %d from errorstate to %s\n", 
1697                   s, lwp, stateStr(to));
1698       return false;
1699    }
1700    if (*from == exited) {
1701       perr_printf("Attempted %s reversion for %d from exited to %s\n", 
1702                   s, lwp, stateStr(to));
1703       return false;
1704    }
1705    if (to == neonatal && *from != neonatal) {
1706       perr_printf("Attempted %s reversion for %d from %s to neonatal\n", 
1707                   s, lwp, stateStr(*from));
1708       return false;
1709    }
1710
1711    pthrd_printf("Changing %s for %d/%d from %s to %s\n", s, llproc()->getPid(), lwp, 
1712                 stateStr(*from), stateStr(to));
1713    *from = to;
1714
1715    if (internal_state == stopped)  assert(handler_state == stopped);
1716    if (handler_state == stopped)   assert(generator_state == stopped || generator_state == exited);
1717    if (generator_state == running) assert(handler_state == running);
1718    if (handler_state == running)   assert(internal_state == running);
1719    return true;
1720 }
1721
1722 bool int_thread::setHandlerState(int_thread::State s)
1723 {
1724    return setAnyState(&handler_state, s);
1725 }
1726
1727 bool int_thread::setUserState(int_thread::State s)
1728 {
1729    return setAnyState(&user_state, s);
1730 }
1731
1732 bool int_thread::setGeneratorState(int_thread::State s)
1733 {
1734    return setAnyState(&generator_state, s);
1735 }
1736
1737 bool int_thread::setInternalState(int_thread::State s)
1738 {
1739    return setAnyState(&internal_state, s);
1740 }
1741
1742 void int_thread::desyncInternalState()
1743 {
1744    pthrd_printf("Thread %d/%d is desyncing int from user state %d\n",
1745                 llproc()->getPid(), getLWP(), num_locked_stops+1);
1746    num_locked_stops++;
1747 }
1748
1749 void int_thread::restoreInternalState(bool sync)
1750 {
1751    pthrd_printf("Thread %d/%d is restoring int to user state, %d\n",
1752                 llproc()->getPid(), getLWP(), num_locked_stops-1);
1753    assert(num_locked_stops > 0);
1754    num_locked_stops--;
1755    if (num_locked_stops > 0) 
1756       return;
1757    
1758    pthrd_printf("Changing internal state, %s, to user state, %s.\n",
1759                 int_thread::stateStr(internal_state), int_thread::stateStr(user_state));
1760
1761    if (internal_state == user_state)
1762    {
1763       return;
1764    }
1765    else if (internal_state == int_thread::exited ||
1766             user_state == int_thread::exited) 
1767    {
1768       setInternalState(int_thread::exited);
1769    }
1770    else if (internal_state == int_thread::stopped &&
1771             user_state == int_thread::running)
1772    {
1773       bool result = intCont();
1774       if (!result) {
1775          perr_printf("Error continuing internal process %d/%d when resyncing\n",
1776                      llproc()->getPid(), getLWP());
1777          return;
1778       }
1779    }
1780    else if (internal_state == int_thread::running &&
1781             user_state == int_thread::stopped) 
1782    {
1783       bool result = intStop(sync);
1784       if (!result) {
1785          perr_printf("Error stopping internal process %d/%d when resyncing\n",
1786                      llproc()->getPid(), getLWP());
1787          return;
1788       }
1789    }
1790    else {
1791       setInternalState(user_state);
1792    }
1793 }
1794
1795 void int_thread::setContSignal(int sig)
1796 {
1797    continueSig_ = sig;
1798 }
1799
1800 int_thread::int_thread(int_process *p, Dyninst::THR_ID t, Dyninst::LWP l) :
1801    tid(t),
1802    lwp(l),
1803    proc_(p),
1804    continueSig_(0),
1805    handler_state(neonatal),
1806    user_state(neonatal),
1807    generator_state(neonatal),
1808    internal_state(neonatal),
1809    sync_rpc_count(0),
1810    pending_user_stop(false),
1811    pending_stop(false),
1812    num_locked_stops(0),
1813    user_single_step(false),
1814    single_step(false),
1815    clearing_breakpoint(false)
1816 {
1817    Thread::ptr new_thr(new Thread());
1818
1819    new_thr->llthread_ = this;
1820    up_thread = new_thr;
1821 }
1822
1823 int_thread::~int_thread()
1824 {
1825    assert(!up_thread->exitstate_);
1826
1827    up_thread->exitstate_ = new thread_exitstate();
1828    up_thread->exitstate_->lwp = lwp;
1829    up_thread->exitstate_->thr_id = tid;
1830    up_thread->llthread_ = NULL;
1831 }
1832
1833 int_thread *int_thread::createThread(int_process *proc, 
1834                                      Dyninst::THR_ID thr_id, 
1835                                      Dyninst::LWP lwp_id,
1836                                      bool initial_thrd)
1837 {
1838    int_thread *newthr = createThreadPlat(proc, thr_id, lwp_id, initial_thrd);
1839    pthrd_printf("Creating %s thread %d/%d, thr_id = %d\n", 
1840                 initial_thrd ? "initial" : "new",
1841                 proc->getPid(), newthr->getLWP(), thr_id);
1842    proc->threadPool()->addThread(newthr);
1843    if (initial_thrd) {
1844       proc->threadPool()->setInitialThread(newthr);
1845    }
1846    ProcPool()->addThread(proc, newthr);
1847    bool result = newthr->attach();
1848    if (!result) {
1849       pthrd_printf("Failed to attach to new thread %d/%d\n", proc->getPid(), lwp_id);
1850       return NULL;
1851    }
1852    newthr->setUserState(neonatal_intermediate);
1853    newthr->setInternalState(neonatal_intermediate);
1854    newthr->setHandlerState(neonatal_intermediate);
1855    newthr->setGeneratorState(neonatal_intermediate);
1856
1857    return newthr;
1858 }
1859
1860 Thread::ptr int_thread::thread()
1861 {
1862    return up_thread;
1863 }
1864
1865 bool int_thread::getAllRegisters(int_registerPool &pool)
1866 {
1867    bool result = false;
1868
1869    pthrd_printf("Reading registers for thread %d\n", getLWP());
1870    regpool_lock.lock();
1871    if (cached_regpool.full) {
1872       pool = cached_regpool;
1873       pthrd_printf("Returning cached register set\n");
1874       result = true;
1875       goto done;
1876    }
1877    result = plat_getAllRegisters(cached_regpool);
1878    if (!result) {
1879       pthrd_printf("plat_getAllRegisters returned error on %d\n", getLWP());
1880       goto done;
1881    }
1882    cached_regpool.full = true;
1883    pool = cached_regpool;
1884    pool.thread = this;
1885    pthrd_printf("Successfully retrieved all registers for %d\n", getLWP());
1886    result = true;
1887   done:
1888    regpool_lock.unlock();
1889    return result;
1890 }
1891
1892 bool int_thread::setAllRegisters(int_registerPool &pool)
1893 {
1894    assert(getHandlerState() == int_thread::stopped);
1895    assert(getGeneratorState() == int_thread::stopped);
1896    regpool_lock.lock();
1897
1898    pthrd_printf("Setting registers for thread %d\n", getLWP());
1899    bool result = plat_setAllRegisters(pool);
1900    if (!result) {
1901       pthrd_printf("plat_setAllRegisters returned error on %d\n", getLWP());
1902       goto done;
1903    }
1904    cached_regpool = pool;
1905    cached_regpool.full = true;
1906    pthrd_printf("Successfully set all registers for %d\n", getLWP());
1907   done:
1908    regpool_lock.unlock();
1909    return result;
1910 }
1911
1912 bool int_thread::getRegister(Dyninst::MachRegister reg, Dyninst::MachRegisterVal &val)
1913 {
1914    bool result = false;
1915    pthrd_printf("Get register value for thread %d, register %s\n", lwp, reg.name());
1916
1917    if (!llproc()->plat_individualRegAccess())
1918    {
1919       pthrd_printf("Platform does not support individual register access, " 
1920                    "getting everyting\n");
1921       int_registerPool pool;
1922       result = getAllRegisters(pool);
1923       if (!result) {
1924          pthrd_printf("Unable to access full register set\n");
1925          return false;
1926       }
1927       val = pool.regs[reg];
1928       return true;
1929    }
1930
1931    regpool_lock.lock();
1932
1933    int_registerPool::reg_map_t::iterator i = cached_regpool.regs.find(reg);
1934    if (i != cached_regpool.regs.end()) {
1935       val = i->second;
1936       pthrd_printf("Returning cached register value %lx for register %s on %d\n", 
1937                    val, reg.name(), lwp);
1938       result = true;
1939       goto done;
1940    }
1941
1942    result = plat_getRegister(reg, val);
1943    if (!result) {
1944       pthrd_printf("Error reading register value for %s on %d\n", reg.name(), lwp);
1945       goto done;
1946    }
1947
1948    pthrd_printf("Returning register value %lx for register %s on %d\n", 
1949                 val, reg.name(), lwp);
1950   done:
1951    regpool_lock.unlock();
1952    return result;
1953 }
1954
1955 bool int_thread::setRegister(Dyninst::MachRegister reg, Dyninst::MachRegisterVal val)
1956 {
1957    assert(getHandlerState() == int_thread::stopped);
1958    assert(getGeneratorState() == int_thread::stopped);
1959
1960    if (!llproc()->plat_individualRegAccess())
1961    {
1962       pthrd_printf("Platform does not support individual register access, " 
1963                    "setting everyting\n");
1964       int_registerPool pool;
1965       bool result = getAllRegisters(pool);
1966       if (!result) {
1967          pthrd_printf("Unable to access full register set\n");
1968          return false;
1969       }
1970       pool.regs[reg] = val;
1971       result = setAllRegisters(pool);
1972       if (!result) {
1973          pthrd_printf("Unable to set full register set\n");
1974          return false;
1975       }
1976       return true;
1977    }
1978
1979    regpool_lock.lock();
1980
1981    pthrd_printf("Setting register %s for thread %d to %lx\n", reg.name(), getLWP(), val);
1982    MachRegister base_register = reg.getBaseRegister();
1983    bool result = plat_setRegister(base_register, val);
1984    if (!result) {
1985       pthrd_printf("Error setting register %s\n", base_register.name());
1986       goto done;
1987    }
1988
1989    cached_regpool.regs[base_register] = val;
1990   done:
1991    regpool_lock.unlock();
1992    return true;
1993 }
1994
1995 void int_thread::addPostedRPC(int_iRPC::ptr rpc_)
1996 {
1997    assert(rpc_);
1998    posted_rpcs.push_back(rpc_);
1999 }
2000
2001 rpc_list_t *int_thread::getPostedRPCs()
2002 {
2003    return &posted_rpcs;
2004 }
2005
2006 bool int_thread::hasPostedRPCs()
2007 {
2008    return (posted_rpcs.size() != 0);
2009 }
2010
2011 void int_thread::setRunningRPC(int_iRPC::ptr rpc_)
2012 {
2013    assert(!running_rpc);
2014    running_rpc = rpc_;
2015 }
2016
2017 int_iRPC::ptr int_thread::runningRPC() const
2018 {
2019    return running_rpc;
2020 }
2021
2022 void int_thread::clearRunningRPC()
2023 {
2024    running_rpc = int_iRPC::ptr();
2025 }
2026 bool int_thread::saveRegsForRPC()
2027 {
2028    assert(!rpc_regs.full);
2029    return getAllRegisters(rpc_regs);
2030 }
2031
2032 bool int_thread::restoreRegsForRPC(bool clear)
2033 {
2034    assert(rpc_regs.full);
2035    bool result = setAllRegisters(rpc_regs);
2036    if (clear && result) {
2037       rpc_regs.regs.clear();
2038       rpc_regs.full = false;
2039    }
2040    return result;
2041 }
2042
2043 bool int_thread::hasSavedRPCRegs()
2044 {
2045    return rpc_regs.full;
2046 }
2047
2048 bool int_thread::runningInternalRPC() const
2049 {
2050    if (runningRPC() && runningRPC()->isInternalRPC()) {
2051       return true;
2052    }
2053    if (posted_rpcs.size() && posted_rpcs.front()->isInternalRPC()) {
2054       return true;
2055    }
2056    return false;
2057 }
2058
2059 void int_thread::incSyncRPCCount()
2060 {
2061    sync_rpc_count++;
2062 }
2063
2064 void int_thread::decSyncRPCCount()
2065 {
2066    assert(sync_rpc_count > 0);
2067    sync_rpc_count--;
2068 }
2069
2070 bool int_thread::hasSyncRPC()
2071 {
2072    return (sync_rpc_count != 0);
2073 }
2074
2075 int_iRPC::ptr int_thread::nextPostedIRPC() const
2076 {
2077    if (!posted_rpcs.size())
2078       return int_iRPC::ptr();
2079    return posted_rpcs.front();
2080 }
2081
2082 bool int_thread::handleNextPostedIRPC(bool block)
2083 {
2084    int_iRPC::ptr posted_rpc = nextPostedIRPC();
2085    if (!posted_rpc || runningRPC())
2086       return true;
2087
2088    bool ret_result = false;
2089    pthrd_printf("Handling next postd irpc %lu on %d/%d of type %s in state %s\n",
2090                 posted_rpc->id(), llproc()->getPid(), getLWP(), 
2091                 posted_rpc->getStrType(), posted_rpc->getStrState());
2092    assert(posted_rpc->getState() == int_iRPC::Posted ||
2093           posted_rpc->getState() == int_iRPC::Prepping ||
2094           posted_rpc->getState() == int_iRPC::Prepped);
2095    
2096    if (posted_rpc->getState() == int_iRPC::Posted) {
2097       bool error = false;
2098       pthrd_printf("Prepping next rpc to run on %d/%d\n", llproc()->getPid(), getLWP());
2099       bool result = rpcMgr()->prepNextRPC(this, block, error);
2100       if (!result && error) {
2101          perr_printf("Failed to prep RPC\n");
2102          goto done;
2103       }
2104    }
2105    if (posted_rpc->getState() == int_iRPC::Prepping) {
2106       pthrd_printf("Checking if rpc is prepped on %d/%d\n", llproc()->getPid(), getLWP());
2107       posted_rpc->isRPCPrepped();
2108    }
2109    if (posted_rpc->getState() == int_iRPC::Prepped) {
2110       pthrd_printf("Running next RPC on %d/%d\n", llproc()->getPid(), getLWP());
2111       rpcMgr()->runNextRPC(this, block);
2112    }
2113
2114    ret_result = true;
2115   done:
2116    return ret_result;
2117 }
2118
2119 int_iRPC::ptr int_thread::hasRunningProcStopperRPC() const
2120 {
2121    int_iRPC::ptr running = runningRPC();
2122    if (running && running->isProcStopRPC()) {
2123       return running;
2124    }
2125    int_iRPC::ptr nextposted = nextPostedIRPC();
2126    if (!running && nextposted && nextposted->isProcStopRPC() && 
2127        nextposted->getState() != int_iRPC::Posted) 
2128    {
2129       return nextposted;
2130    }
2131    return int_iRPC::ptr();
2132 }
2133
2134 bool int_thread::singleStepMode() const
2135 {
2136    return single_step;
2137 }
2138
2139 void int_thread::setSingleStepMode(bool s)
2140 {
2141    single_step = s;
2142 }
2143
2144 bool int_thread::singleStepUserMode() const
2145 {
2146    return user_single_step;
2147 }
2148
2149 void int_thread::setSingleStepUserMode(bool s)
2150 {
2151    user_single_step = s;
2152 }
2153
2154 bool int_thread::singleStep() const
2155 {
2156    return single_step || user_single_step;
2157 }
2158
2159 void int_thread::markClearingBreakpoint(installed_breakpoint *bp)
2160 {
2161    assert(!clearing_breakpoint || bp == NULL);
2162    clearing_breakpoint = bp;
2163 }
2164
2165 installed_breakpoint *int_thread::isClearingBreakpoint()
2166 {
2167    return clearing_breakpoint;
2168 }
2169
2170 int_thread *int_threadPool::findThreadByLWP(Dyninst::LWP lwp)
2171 {
2172    std::map<Dyninst::LWP, int_thread *>::iterator i = thrds_by_lwp.find(lwp);
2173    if (i == thrds_by_lwp.end())
2174       return NULL;
2175    return i->second;
2176 }
2177
2178 int_thread *int_threadPool::initialThread() const
2179 {
2180    return initial_thread;
2181 }
2182
2183 bool int_threadPool::allStopped()
2184 {
2185    for (iterator i = begin(); i != end(); i++) {
2186       if ((*i)->getInternalState() == int_thread::running)
2187          return false;
2188    }
2189    return true;
2190 }
2191
2192 void int_threadPool::addThread(int_thread *thrd)
2193 {
2194    Dyninst::LWP lwp = thrd->getLWP();
2195    std::map<Dyninst::LWP, int_thread *>::iterator i = thrds_by_lwp.find(lwp);
2196    assert (i == thrds_by_lwp.end());
2197    thrds_by_lwp[lwp] = thrd;
2198    threads.push_back(thrd);
2199    hl_threads.push_back(thrd->thread());
2200 }
2201
2202 void int_threadPool::rmThread(int_thread *thrd)
2203 {
2204    assert(thrd != initial_thread);
2205    Dyninst::LWP lwp = thrd->getLWP();
2206    std::map<Dyninst::LWP, int_thread *>::iterator i = thrds_by_lwp.find(lwp);
2207    assert (i != thrds_by_lwp.end());
2208    thrds_by_lwp.erase(i);
2209
2210    for (unsigned i=0; i<threads.size(); i++) {
2211       if (threads[i] != thrd)
2212          continue;
2213       threads[i] = threads[threads.size()-1];
2214       threads.pop_back();
2215       hl_threads[i] = hl_threads[hl_threads.size()-1];
2216       hl_threads.pop_back();
2217    }
2218 }
2219
2220 void int_threadPool::clear()
2221 {
2222    threads.clear();
2223    hl_threads.clear();
2224    thrds_by_lwp.clear();
2225    initial_thread = NULL;
2226 }
2227
2228 void int_threadPool::desyncInternalState()
2229 {
2230    for (iterator i = begin(); i != end(); i++) {
2231       (*i)->desyncInternalState();
2232    }
2233 }
2234
2235 void int_threadPool::restoreInternalState(bool sync)
2236 {
2237    for (iterator i = begin(); i != end(); i++) {
2238       (*i)->restoreInternalState(false);
2239    }
2240    if (sync)
2241       int_process::waitAndHandleEvents(false);
2242 }
2243
2244 void int_threadPool::setInitialThread(int_thread *thrd)
2245 {
2246    initial_thread = thrd;
2247 }
2248
2249 int_process *int_threadPool::proc() const
2250 {
2251    return proc_;
2252 }
2253
2254 unsigned int_threadPool::size() const
2255 {
2256    return threads.size();
2257 }
2258
2259 ThreadPool *int_threadPool::pool() const
2260 {
2261    return up_pool;
2262 }
2263
2264 int_threadPool::int_threadPool(int_process *p) :
2265    proc_(p)
2266 {
2267    up_pool = new ThreadPool();
2268    up_pool->threadpool = this;
2269 }
2270
2271 int_threadPool::~int_threadPool()
2272 {
2273    assert(up_pool);
2274    delete up_pool;
2275
2276    for (vector<int_thread*>::iterator i = threads.begin(); i != threads.end(); i++)
2277    {
2278       delete *i;
2279    }
2280 }
2281
2282 int_breakpoint::int_breakpoint(Breakpoint::ptr up) :
2283    up_bp(up),
2284    to(0x0),
2285    isCtrlTransfer_(false),
2286    data(false)
2287 {
2288 }
2289
2290 int_breakpoint::int_breakpoint(Dyninst::Address to_, Breakpoint::ptr up) :
2291    up_bp(up),
2292    to(to_),
2293    isCtrlTransfer_(true),
2294    data(false)
2295 {
2296 }
2297
2298 int_breakpoint::~int_breakpoint()
2299 {
2300 }
2301
2302 bool int_breakpoint::isCtrlTransfer() const
2303 {
2304    return isCtrlTransfer_;
2305 }
2306
2307 Address int_breakpoint::toAddr() const
2308 {
2309    return to;
2310 }
2311
2312 void *int_breakpoint::getData() const
2313 {
2314    return data;
2315 }
2316
2317 void int_breakpoint::setData(void *v)
2318 {
2319    data = v;
2320 }
2321
2322 Breakpoint::weak_ptr int_breakpoint::upBreakpoint() const
2323 {
2324    return up_bp;
2325 }
2326
2327 installed_breakpoint::installed_breakpoint(mem_state::ptr memory_, Address addr_) :
2328    memory(memory_),
2329    buffer_size(0),
2330    installed(false),
2331    suspend_count(0),
2332    addr(addr_)
2333 {
2334 }
2335
2336 installed_breakpoint::installed_breakpoint(mem_state::ptr memory_, 
2337                                            const installed_breakpoint *ip) :
2338    memory(memory_),
2339    bps(ip->bps),
2340    hl_bps(ip->hl_bps),
2341    buffer_size(ip->buffer_size),
2342    installed(ip->installed),
2343    suspend_count(ip->suspend_count),
2344    addr(ip->addr)
2345 {
2346    memcpy(buffer, ip->buffer, sizeof(buffer));
2347 }
2348
2349 installed_breakpoint::~installed_breakpoint()
2350 {
2351 }
2352
2353 bool installed_breakpoint::isInstalled() const
2354 {
2355    return installed;
2356 }
2357
2358 bool installed_breakpoint::install(int_process *proc)
2359 {
2360    if (installed)
2361       return true;
2362    assert(bps.size());
2363
2364    bool result = plat_install(proc, true);
2365    if (!result) {
2366       pthrd_printf("Error installing breakpoint\n");
2367       return false;
2368    }
2369    assert(buffer && buffer_size);
2370    installed = true;
2371    memory->breakpoints[addr] = this;
2372    return true;
2373 }
2374
2375 bool installed_breakpoint::uninstall(int_process *proc)
2376 {
2377    assert(installed);
2378
2379    if (proc->getState() != int_process::exited)
2380    {
2381       bool result = proc->writeMem(&buffer, addr, buffer_size);
2382       if (!result) {
2383          pthrd_printf("Failed to remove breakpoint at %lx from process %d\n", 
2384                       addr, proc->getPid());
2385          return false;
2386       }
2387    }
2388    installed = false;
2389    buffer_size = 0;
2390
2391    std::map<Dyninst::Address, installed_breakpoint *>::iterator i;
2392    i = memory->breakpoints.find(addr);
2393    if (i == memory->breakpoints.end()) {
2394       perr_printf("Failed to remove breakpoint from list\n");
2395       return false;
2396    }
2397    memory->breakpoints.erase(i);
2398
2399    return true;
2400 }
2401
2402 bool installed_breakpoint::suspend(int_process *proc)
2403 {
2404    suspend_count++;
2405    if (suspend_count > 1) {
2406       pthrd_printf("Breakpoint already suspended, suspend_count = %d\n", 
2407                    suspend_count);
2408       return true;
2409    }
2410    bool result = proc->writeMem(&buffer, addr, buffer_size);
2411    if (!result) {
2412       pthrd_printf("Failed to suspend breakpoint at %lx from process %d\n", 
2413                    addr, proc->getPid());
2414       return false;
2415    }
2416    return true;
2417 }
2418
2419 bool installed_breakpoint::resume(int_process *proc)
2420 {
2421    suspend_count--;
2422    assert(suspend_count >= 0);
2423    if (suspend_count > 0) {
2424       pthrd_printf("Breakpoint remaining suspended, suspend_count = %d\n", suspend_count);
2425       return true;
2426    }
2427    bool result = plat_install(proc, false);
2428    if (!result) {
2429       pthrd_printf("Failed to install breakpoint at %lx in process %d\n",
2430                    addr, proc->getPid());
2431       return false;
2432    }
2433    return true;
2434 }
2435
2436 bool installed_breakpoint::addBreakpoint(int_process *proc, int_breakpoint *bp)
2437 {
2438    pthrd_printf("Adding breakpoint at %lx\n", addr);
2439    if (bp->isCtrlTransfer()) {
2440       for (set<int_breakpoint *>::iterator i = bps.begin(); i != bps.end(); i++)
2441       {
2442          if ((*i)->isCtrlTransfer()) {
2443             perr_printf("Error.  Attempted to add to control transfer breakpoints " 
2444                         "at same place");
2445             setLastError(err_badparam, "Attempted two control transfer breakpoints at " 
2446                          "same location\n");
2447             return false;
2448          }
2449       }
2450    }
2451
2452    bps.insert(bp);
2453    Breakpoint::ptr upbp = bp->upBreakpoint().lock();
2454    if (upbp != Breakpoint::ptr()) {
2455       //We keep the set of installed Breakpoints  to keep the breakpoint shared
2456       // pointer reference counter from cleaning a Breakpoint while installed.
2457       hl_bps.insert(upbp);
2458    }
2459
2460    if (!installed) {
2461       bool result = install(proc);
2462       if (!result) {
2463          pthrd_printf("Error failed to install breakpoint at %lx\n", addr);
2464          return false;
2465       }
2466    }
2467
2468    return true;
2469 }
2470
2471 bool installed_breakpoint::rmBreakpoint(int_process *proc, int_breakpoint *bp, bool &empty)
2472 {
2473    pthrd_printf("Removing breakpoint at %lx\n", addr);
2474    empty = false;
2475    set<int_breakpoint *>::iterator i = bps.find(bp);
2476    if (i == bps.end()) {
2477       perr_printf("Attempted to remove a non-installed breakpoint\n");
2478       setLastError(err_badparam, "Breakpoint was not installed in process\n");
2479       empty = false;
2480       return false;
2481    }
2482    bps.erase(i);
2483
2484    set<Breakpoint::ptr>::iterator j = hl_bps.find(bp->upBreakpoint().lock());
2485    if (j != hl_bps.end()) {
2486       hl_bps.erase(j);
2487    }
2488
2489    if (bps.empty()) {
2490       empty = true;
2491       bool result = uninstall(proc);
2492       if (!result) {
2493          perr_printf("Failed to remove breakpoint at %lx\n", addr);
2494          setLastError(err_internal, "Could not remove breakpoint\n");
2495          return false;
2496       }
2497    }
2498    
2499    return true;
2500 }
2501
2502 Dyninst::Address installed_breakpoint::getAddr() const
2503 {
2504    return addr;
2505 }
2506
2507 int_library::int_library(std::string n, Dyninst::Address load_addr) :
2508    name(n),
2509    load_address(load_addr),
2510    data_load_address(0),
2511    has_data_load(false),
2512    marked(false)
2513 {
2514    up_lib = new Library();
2515    up_lib->lib = this;
2516 }
2517
2518 int_library::int_library(std::string n, Dyninst::Address load_addr, Dyninst::Address data_load_addr) :
2519    name(n),
2520    load_address(load_addr),
2521    data_load_address(data_load_addr),
2522    has_data_load(true),
2523    marked(false)
2524 {
2525    up_lib = new Library();
2526    up_lib->lib = this;
2527 }
2528
2529 int_library::int_library(int_library *l) :
2530    name(l->name),
2531    load_address(l->load_address),
2532    data_load_address(l->data_load_address),
2533    has_data_load(l->has_data_load),
2534    marked(l->marked)
2535 {
2536    up_lib = new Library();
2537    up_lib->lib = this;
2538 }
2539
2540 int_library::~int_library()
2541 {
2542 }
2543
2544 std::string int_library::getName()
2545 {
2546    return name;
2547 }
2548
2549 Dyninst::Address int_library::getAddr()
2550 {
2551    return load_address;
2552 }
2553
2554 Dyninst::Address int_library::getDataAddr()
2555 {
2556    return data_load_address;
2557 }
2558
2559 bool int_library::hasDataAddr()
2560 {
2561    return has_data_load;
2562 }
2563
2564 void int_library::setMark(bool b)
2565 {
2566    marked = b;
2567 }
2568
2569 bool int_library::isMarked() const
2570 {
2571    return marked;
2572 }
2573
2574 Library::ptr int_library::getUpPtr() const
2575 {
2576    return up_lib;
2577 }
2578
2579 mem_state::mem_state(int_process *proc)
2580 {
2581    procs.insert(proc);
2582 }
2583
2584 mem_state::mem_state(mem_state &m, int_process *p)
2585 {
2586    pthrd_printf("Copying mem_state to new process %d\n", p->getPid());
2587    procs.insert(p);
2588    set<int_library *>::iterator i;
2589    for (i = m.libs.begin(); i != m.libs.end(); i++)
2590    {
2591       int_library *orig_lib = *i;
2592       int_library *new_lib = new int_library(orig_lib);
2593       libs.insert(new_lib);
2594    }
2595    map<Dyninst::Address, installed_breakpoint *>::iterator j;
2596    for (j = m.breakpoints.begin(); j != m.breakpoints.end(); j++)
2597    {
2598       Address orig_addr = j->first;
2599       installed_breakpoint *orig_bp = j->second;
2600       installed_breakpoint *new_bp = new installed_breakpoint(this, orig_bp);
2601       breakpoints[orig_addr] = new_bp;
2602    }
2603    inf_malloced_memory = m.inf_malloced_memory;
2604 }
2605
2606 mem_state::~mem_state()
2607 {
2608    pthrd_printf("Destroy memory image of old process\n");
2609    set<int_library *>::iterator i;
2610    for (i = libs.begin(); i != libs.end(); i++)
2611    {
2612       int_library *lib = *i;
2613       delete lib;
2614    }
2615    libs.clear();
2616
2617    map<Dyninst::Address, installed_breakpoint *>::iterator j;
2618    for (j = breakpoints.begin(); j != breakpoints.end(); j++)
2619    {
2620       installed_breakpoint *ibp = j->second;
2621       delete ibp;
2622    }   
2623    breakpoints.clear();
2624 }
2625
2626 void mem_state::addProc(int_process *p)
2627 {
2628    pthrd_printf("Adding process %d as sharing a memory state with existing proc\n",
2629                 p->getPid());
2630    procs.insert(p);
2631 }
2632
2633 void mem_state::rmProc(int_process *p, bool &should_clean)
2634 {
2635    set<int_process *>::iterator i = procs.find(p);
2636    assert(i != procs.end());
2637    procs.erase(i);
2638
2639    if (procs.empty()) {
2640       should_clean = true;
2641       pthrd_printf("Removed process %d from memory image, should clean image\n",
2642                    p->getPid());
2643    }
2644    else {
2645       should_clean = false;
2646       pthrd_printf("Removed process %d from memory image, others remain\n",
2647                    p->getPid());
2648    }
2649 }
2650
2651
2652 int_notify *int_notify::the_notify = NULL;
2653 int_notify::int_notify() :
2654    pipe_in(-1),
2655    pipe_out(-1),
2656    pipe_count(0),
2657    events_noted(0)
2658 {
2659    the_notify = this;
2660    up_notify = new EventNotify();
2661    up_notify->llnotify = this;
2662 }
2663
2664 int_notify *notify()
2665 {
2666    if (int_notify::the_notify)
2667       return int_notify::the_notify;
2668
2669    static Mutex init_lock;
2670    init_lock.lock();
2671    if (!int_notify::the_notify) {
2672       int_notify::the_notify = new int_notify();
2673    }
2674    init_lock.unlock();
2675    return int_notify::the_notify;
2676 }
2677
2678 void int_notify::noteEvent()
2679 {
2680    assert(isHandlerThread());
2681    assert(events_noted == 0);
2682    writeToPipe();
2683    events_noted++;
2684    pthrd_printf("noteEvent - %d\n", events_noted);
2685    set<EventNotify::notify_cb_t>::iterator i;
2686    for (i = cbs.begin(); i != cbs.end(); i++) {
2687       pthrd_printf("Calling notification CB\n");
2688       (*i)();
2689    }
2690 }
2691
2692 static void notifyNewEvent()
2693 {
2694    notify()->noteEvent();
2695 }
2696
2697
2698 void int_notify::clearEvent()
2699 {
2700    assert(!isHandlerThread());
2701    events_noted--;
2702    pthrd_printf("clearEvent - %d\n", events_noted);
2703    assert(events_noted == 0);
2704    readFromPipe();
2705 }
2706
2707 bool int_notify::hasEvents()
2708 {
2709    return (events_noted > 0);
2710 }
2711
2712 void int_notify::registerCB(EventNotify::notify_cb_t cb)
2713 {
2714    cbs.insert(cb);
2715 }
2716
2717 void int_notify::removeCB(EventNotify::notify_cb_t cb)
2718 {
2719    set<EventNotify::notify_cb_t>::iterator i = cbs.find(cb);
2720    if (i == cbs.end())
2721       return;
2722    cbs.erase(i);
2723 }
2724
2725 int int_notify::getPipeIn()
2726 {
2727    if (pipe_in == -1)
2728       createPipe();
2729    return pipe_in;
2730 }
2731
2732 Decoder::Decoder()
2733 {
2734 }
2735
2736 Decoder::~Decoder()
2737 {
2738 }
2739
2740 RegisterPool::RegisterPool()
2741 {
2742    llregpool = new int_registerPool();
2743 }
2744
2745 RegisterPool::RegisterPool(const RegisterPool &rp)
2746 {
2747    llregpool = new int_registerPool();
2748    *llregpool = *rp.llregpool;
2749 }
2750
2751 RegisterPool::~RegisterPool()
2752 {
2753    delete llregpool;
2754 }
2755
2756 RegisterPool::iterator RegisterPool::begin()
2757 {
2758    return RegisterPool::iterator(llregpool->regs.begin());
2759 }
2760
2761 RegisterPool::iterator RegisterPool::end()
2762 {
2763    return RegisterPool::iterator(llregpool->regs.end());
2764 }
2765
2766 RegisterPool::iterator RegisterPool::find(MachRegister r)
2767 {
2768    return RegisterPool::iterator(llregpool->regs.find(r));
2769 }
2770
2771 RegisterPool::const_iterator RegisterPool::begin() const
2772 {
2773    return RegisterPool::const_iterator(llregpool->regs.begin());
2774 }
2775
2776 RegisterPool::const_iterator RegisterPool::end() const
2777 {
2778    return RegisterPool::const_iterator(llregpool->regs.end());
2779 }
2780
2781 RegisterPool::const_iterator RegisterPool::find(MachRegister r) const
2782 {
2783    return RegisterPool::const_iterator(llregpool->regs.find(r));
2784 }
2785
2786 MachRegisterVal& RegisterPool::operator[](MachRegister r)
2787 {
2788    return llregpool->regs[r];
2789 }
2790
2791 const MachRegisterVal& RegisterPool::operator[](MachRegister r) const
2792 {
2793    return llregpool->regs[r];
2794 }
2795
2796 size_t RegisterPool::size() const
2797 {
2798    return llregpool->regs.size();
2799 }
2800
2801 Thread::ptr RegisterPool::getThread() const
2802 {
2803    return llregpool->thread->thread();
2804 }
2805
2806 RegisterPool::iterator::iterator()
2807 {
2808 }
2809
2810 RegisterPool::iterator::iterator(int_iter i_) :
2811    i(i_)
2812 {
2813 }
2814
2815 RegisterPool::iterator::~iterator()
2816 {
2817 }
2818
2819 std::pair<Dyninst::MachRegister, Dyninst::MachRegisterVal> RegisterPool::iterator::operator*()
2820 {
2821    return *i;
2822 }
2823
2824 RegisterPool::iterator RegisterPool::iterator::operator++()
2825 {
2826    int_iter orig = i;
2827    i++;
2828    return RegisterPool::iterator(i);
2829 }
2830
2831 RegisterPool::iterator RegisterPool::iterator::operator++(int)
2832 {
2833    i++;
2834    return *this;
2835 }
2836
2837 RegisterPool::const_iterator::const_iterator()
2838 {
2839 }
2840
2841 RegisterPool::const_iterator::const_iterator(int_iter i_) :
2842    i(i_)
2843 {
2844 }
2845
2846 RegisterPool::const_iterator::~const_iterator()
2847 {
2848 }
2849
2850 std::pair<Dyninst::MachRegister, Dyninst::MachRegisterVal> RegisterPool::const_iterator::operator*() const
2851 {
2852    return *i;
2853 }
2854
2855 RegisterPool::const_iterator RegisterPool::const_iterator::operator++()
2856 {
2857    int_iter orig = i;
2858    i++;
2859    return RegisterPool::const_iterator(i);
2860 }
2861
2862 RegisterPool::const_iterator RegisterPool::const_iterator::operator++(int)
2863 {
2864    i++;
2865    return *this;
2866 }
2867
2868
2869 int_registerPool::int_registerPool() :
2870    full(false),
2871    thread(NULL)
2872 {
2873 }
2874
2875 int_registerPool::int_registerPool(const int_registerPool &c) :
2876    regs(c.regs),
2877    full(c.full),
2878    thread(c.thread)
2879 {
2880 }
2881
2882 int_registerPool::~int_registerPool()
2883 {
2884 }
2885
2886 Library::Library()
2887 {
2888 }
2889
2890 Library::~Library()
2891 {
2892    if (lib) {
2893       delete lib;
2894       lib = NULL;
2895    }
2896 }
2897
2898 std::string Library::getName() const
2899 {
2900    return lib->getName();
2901 }
2902
2903 Dyninst::Address Library::getLoadAddress() const
2904 {
2905    return lib->getAddr();
2906 }
2907
2908 Dyninst::Address Library::getDataLoadAddress() const
2909 {
2910    return lib->getDataAddr();
2911 }
2912
2913 LibraryPool::LibraryPool()
2914 {
2915 }
2916
2917 LibraryPool::~LibraryPool()
2918 {
2919 }
2920
2921 size_t LibraryPool::size() const
2922 {
2923    return proc->numLibs();
2924 }
2925
2926 Library::ptr LibraryPool::getLibraryByName(std::string s)
2927 {
2928    int_library *int_lib = proc->getLibraryByName(s);
2929    if (!int_lib)
2930       return NULL;
2931    return int_lib->up_lib;
2932 }
2933
2934 const Library::ptr LibraryPool::getLibraryByName(std::string s) const
2935 {
2936    int_library *int_lib = proc->getLibraryByName(s);
2937    if (!int_lib)
2938       return NULL;
2939    return int_lib->up_lib;
2940 }
2941
2942 LibraryPool::iterator::iterator()
2943 {
2944 }
2945
2946 LibraryPool::iterator::~iterator()
2947 {
2948 }
2949
2950 Library::ptr LibraryPool::iterator::operator*() const
2951 {
2952    return (*int_iter)->up_lib;
2953 }
2954
2955 LibraryPool::iterator LibraryPool::iterator::operator++()
2956 {
2957    LibraryPool::iterator orig = *this;
2958    ++int_iter;
2959    return orig;
2960 }
2961
2962 LibraryPool::iterator LibraryPool::iterator::operator++(int)
2963 {
2964    ++int_iter;
2965    return *this;
2966 }
2967
2968 LibraryPool::iterator LibraryPool::begin()
2969 {
2970    LibraryPool::iterator i;
2971    i.int_iter = proc->memory()->libs.begin();
2972    return i;
2973 }
2974
2975 LibraryPool::iterator LibraryPool::end()
2976 {
2977    LibraryPool::iterator i;
2978    i.int_iter = proc->memory()->libs.end();
2979    return i;
2980 }
2981
2982 bool LibraryPool::iterator::operator==(const LibraryPool::iterator &i) const
2983 {
2984    return int_iter == i.int_iter;
2985 }
2986
2987 bool LibraryPool::iterator::operator!=(const LibraryPool::iterator &i) const
2988 {
2989    return int_iter != i.int_iter;
2990 }
2991
2992 LibraryPool::const_iterator LibraryPool::begin() const
2993 {
2994    LibraryPool::const_iterator i;
2995    i.int_iter = proc->memory()->libs.begin();
2996    return i;
2997 }
2998
2999 LibraryPool::const_iterator LibraryPool::end() const
3000 {
3001    LibraryPool::const_iterator i;
3002    i.int_iter = proc->memory()->libs.end();
3003    return i;
3004 }
3005
3006 LibraryPool::const_iterator::const_iterator()
3007 {
3008 }
3009
3010 LibraryPool::const_iterator::~const_iterator()
3011 {
3012 }
3013
3014 const Library::const_ptr LibraryPool::const_iterator::operator*() const
3015 {
3016    return (*int_iter)->up_lib;
3017 }
3018
3019 bool LibraryPool::const_iterator::operator==(const LibraryPool::const_iterator &i)
3020 {
3021    return int_iter == i.int_iter;
3022 }
3023
3024 bool LibraryPool::const_iterator::operator!=(const LibraryPool::const_iterator &i)
3025 {
3026    return int_iter != i.int_iter;
3027 }
3028
3029 LibraryPool::const_iterator LibraryPool::const_iterator::operator++()
3030 {
3031    LibraryPool::const_iterator orig = *this;
3032    ++int_iter;
3033    return orig;
3034 }
3035
3036 LibraryPool::const_iterator LibraryPool::const_iterator::operator++(int)
3037 {
3038    ++int_iter;
3039    return *this;
3040 }
3041
3042 bool Process::registerEventCallback(EventType evt, Process::cb_func_t cbfunc)
3043 {
3044    MTLock lock_this_func(MTLock::allow_init);
3045    HandleCallbacks *cbhandler = HandleCallbacks::getCB();
3046    return cbhandler->registerCallback(evt, cbfunc);
3047 }
3048
3049 bool Process::removeEventCallback(EventType evt, cb_func_t cbfunc)
3050 {
3051    MTLock lock_this_func(MTLock::allow_init);
3052    HandleCallbacks *cbhandler = HandleCallbacks::getCB();
3053    return cbhandler->removeCallback(evt, cbfunc);
3054 }
3055
3056 bool Process::removeEventCallback(EventType evt)
3057 {
3058    MTLock lock_this_func(MTLock::allow_init);
3059    HandleCallbacks *cbhandler = HandleCallbacks::getCB();
3060    return cbhandler->removeCallback(evt);
3061 }
3062
3063 bool Process::removeEventCallback(cb_func_t cbfunc)
3064 {
3065    MTLock lock_this_func(MTLock::allow_init);
3066    HandleCallbacks *cbhandler = HandleCallbacks::getCB();
3067    return cbhandler->removeCallback(cbfunc);
3068 }
3069
3070 bool Process::handleEvents(bool block)
3071 {
3072    // One might think we should be delivering callbacks when taking this lock,
3073    //  but we'll do it under waitAndHandleEvent instead.
3074    MTLock lock_this_func(MTLock::allow_init);
3075
3076    pthrd_printf("User triggered event handling\n");
3077    if (int_process::isInCB()) {
3078       perr_printf("User attempted call on process while in CB, erroring.");
3079       setLastError(err_incallback, "Cannot handleEvents from callback\n");
3080       return false;
3081    }
3082
3083    bool result = int_process::waitAndHandleEvents(block);
3084    if (!result) {
3085       pthrd_printf("Error handling events for user\n");
3086       return false;
3087    }
3088    return true;
3089 }
3090
3091 bool Process::setThreadingMode(thread_mode_t tm)
3092 {
3093    MTLock lock_this_func(MTLock::allow_init);
3094    return mt()->setThreadMode(tm);
3095 }
3096
3097 Process::ptr Process::createProcess(std::string executable, const std::vector<std::string> &argv)
3098 {
3099    MTLock lock_this_func(MTLock::allow_init, MTLock::deliver_callbacks);
3100
3101    pthrd_printf("User asked to launch executable %s\n", executable.c_str());
3102    if (int_process::isInCB()) {
3103       perr_printf("User attempted call on process create while in CB, erroring.");
3104       setLastError(err_incallback, "Cannot createProcess from callback\n");
3105       return Process::ptr();
3106    }
3107
3108    Process::ptr newproc(new Process());
3109    int_process *llproc = int_process::createProcess(executable, argv);
3110    llproc->initializeProcess(newproc);
3111    
3112    bool result = llproc->create();
3113    if (!result) {
3114       pthrd_printf("Unable to create process %s\n", executable.c_str());
3115       return Process::ptr();
3116    }
3117
3118    return newproc;
3119 }
3120
3121 Process::ptr Process::attachProcess(Dyninst::PID pid, std::string executable)
3122 {
3123    MTLock lock_this_func(MTLock::allow_init, MTLock::deliver_callbacks);
3124    pthrd_printf("User asked to attach to process %d (%s)\n", pid, executable.c_str());
3125    if (int_process::isInCB()) {
3126       perr_printf("User attempted call on process attach while in CB, erroring.\n");
3127       setLastError(err_incallback, "Cannot attachProcess from callback\n");
3128       return Process::ptr();
3129    }
3130    Process::ptr newproc(new Process());
3131    int_process *llproc = int_process::createProcess(pid, executable);
3132    llproc->initializeProcess(newproc);
3133
3134    bool result = llproc->attach();
3135    if (!result) {
3136       pthrd_printf("Unable to attach to process %d\n", pid);
3137       delete llproc;
3138       return Process::ptr();
3139    }
3140
3141    return newproc;
3142 }
3143
3144 Process::Process() :
3145    llproc_(NULL),
3146    exitstate_(NULL)
3147 {
3148 }
3149
3150 Process::~Process()
3151 {
3152    if (exitstate_) {
3153       delete exitstate_;
3154       exitstate_ = NULL;
3155    }
3156 }
3157
3158
3159 Dyninst::PID Process::getPid() const 
3160 {
3161    MTLock lock_this_func(MTLock::allow_generator);
3162    if (!llproc_) {
3163       assert(exitstate_);
3164       return exitstate_->pid;
3165    }
3166    return llproc_->getPid();
3167 }
3168
3169 int_process *Process::llproc() const
3170 {
3171    return llproc_;
3172 }
3173
3174 const ThreadPool &Process::threads() const
3175 {
3176    MTLock lock_this_func;
3177    static ThreadPool *err_pool;
3178    if (!llproc_) {
3179       perr_printf("threads on deleted process\n");
3180       setLastError(err_exited, "Process is exited\n");
3181       if (!err_pool) {
3182          err_pool = new ThreadPool();
3183       }
3184       return *err_pool;
3185    }
3186
3187    return *(llproc_->threadPool()->pool());
3188 }
3189
3190 ThreadPool &Process::threads()
3191 {
3192    MTLock lock_this_func;
3193    static ThreadPool *err_pool;
3194    if (!llproc_) {
3195       perr_printf("threads on deleted process\n");
3196       setLastError(err_exited, "Process is exited\n");
3197       if (!err_pool) {
3198          err_pool = new ThreadPool();
3199       }
3200       return *err_pool;
3201    }
3202
3203    return *(llproc_->threadPool()->pool());
3204 }
3205
3206 const LibraryPool &Process::libraries() const
3207 {
3208    MTLock lock_this_func;
3209    static LibraryPool *err_pool;
3210    if (!llproc_) {
3211       perr_printf("libraries on deleted process\n");
3212       setLastError(err_exited, "Process is exited\n");
3213       if (!err_pool) {
3214          err_pool = new LibraryPool();
3215       }
3216       return *err_pool;
3217    }
3218
3219    return llproc_->libpool;
3220 }
3221
3222 LibraryPool &Process::libraries()
3223 {
3224    MTLock lock_this_func;
3225    static LibraryPool *err_pool;
3226    if (!llproc_) {
3227       perr_printf("libraries on deleted process\n");
3228       setLastError(err_exited, "Process is exited\n");
3229       if (!err_pool) {
3230          err_pool = new LibraryPool();
3231       }
3232       return *err_pool;
3233    }
3234
3235    return llproc_->libpool;
3236 }
3237
3238 bool Process::continueProc()
3239 {
3240    MTLock lock_this_func(MTLock::deliver_callbacks);
3241    if (!llproc_) {
3242       perr_printf("coninueProc on deleted process\n");
3243       setLastError(err_exited, "Process is exited\n");
3244       return false;
3245    }
3246
3247    pthrd_printf("User continuing entire process %d\n", getPid());
3248    if (int_process::isInCB()) {
3249       perr_printf("User attempted call on process while in CB, erroring.");
3250       setLastError(err_incallback, "Cannot continueProc from callback\n");
3251       return false;
3252    }
3253
3254    return llproc_->threadPool()->userCont();
3255 }
3256
3257 bool Process::isCrashed() const
3258 {
3259    MTLock lock_this_func;
3260    if (!llproc_) {
3261       assert(exitstate_);
3262       return exitstate_->crashed;
3263    }
3264    int crashSignal = 0;
3265    return (llproc_->getState() == int_process::exited && llproc_->getCrashSignal(crashSignal));
3266 }
3267
3268 bool Process::isExited() const
3269 {
3270    MTLock lock_this_func;
3271    int exitCode = 0;
3272    if (!llproc_) {
3273       assert(exitstate_);
3274       return exitstate_->exited;
3275    }
3276    return (llproc_->getState() == int_process::exited && llproc_->getExitCode(exitCode));
3277 }
3278
3279 int Process::getCrashSignal() const
3280 {
3281    MTLock lock_this_func;
3282    if (!llproc_) {
3283       assert(exitstate_);
3284       return exitstate_->crashed ? exitstate_->crash_signal : 0;
3285    }
3286
3287    int crashSignal = 0;
3288    if (!(llproc_->getState() == int_process::exited && llproc_->getCrashSignal(crashSignal)))
3289       return 0;
3290    return crashSignal;
3291 }
3292
3293 int Process::getExitCode() const
3294 {
3295    MTLock lock_this_func;
3296    if (!llproc_) {
3297       assert(exitstate_);
3298       return !exitstate_->crashed ? exitstate_->exit_code : 0;
3299    }
3300
3301    int exitCode = 0;
3302    if (!(llproc_->getState() == int_process::exited && llproc_->getExitCode(exitCode)))
3303       return 0;
3304    return exitCode;
3305 }
3306
3307 bool Process::stopProc()
3308 {
3309    MTLock lock_this_func(MTLock::deliver_callbacks);
3310    if (!llproc_) {
3311       perr_printf("stopProc on deleted process\n");
3312       setLastError(err_exited, "Process is exited\n");
3313       return false;
3314    }
3315
3316    pthrd_printf("User stopping entire process %d\n", getPid());
3317    if (int_process::isInCB()) {
3318       perr_printf("User attempted call on process while in CB, erroring.");
3319       setLastError(err_incallback, "Cannot continueProc from callback\n");
3320       return false;
3321    }
3322
3323    return llproc_->threadPool()->userStop();
3324 }
3325
3326 bool Process::detach()
3327 {
3328    MTLock lock_this_func(MTLock::deliver_callbacks);
3329    if (!llproc_) {
3330       perr_printf("detach on deleted process\n");
3331       setLastError(err_exited, "Process is exited\n");
3332       return false;
3333    }
3334    bool should_delete;
3335    bool result = llproc_->detach(should_delete);
3336    if (!result) {
3337       pthrd_printf("Failed to detach from process\n");
3338       return false;
3339    }
3340    if (should_delete) {
3341       HandlerPool *hp = llproc_->handlerPool();
3342       delete llproc_;
3343       delete hp;
3344       assert(!llproc_);
3345    }
3346    return true;
3347 }
3348
3349 bool Process::terminate()
3350 {
3351    MTLock lock_this_func(MTLock::deliver_callbacks);
3352    if (!llproc_) {
3353       perr_printf("terminate on deleted process\n");
3354       setLastError(err_exited, "Process is exited\n");
3355       return false;
3356    }
3357
3358    pthrd_printf("User terminating process %d\n", llproc_->getPid());
3359    bool needsSync = false;
3360    bool result = llproc_->terminate(needsSync);
3361    if (!result) {
3362       pthrd_printf("Terminating process %d failed\n", llproc_->getPid());
3363       return false;
3364    }
3365
3366    if (needsSync) {
3367       bool proc_exited = false;
3368       while (!proc_exited) {
3369          bool result = int_process::waitAndHandleForProc(true, llproc(), proc_exited);
3370          if (!result) {
3371             perr_printf("Error waiting for process to terminate\n");
3372             return false;
3373          }
3374       }
3375    }
3376    else {
3377       HandlerPool *hp = llproc_->handlerPool();
3378       delete llproc_;
3379       delete hp;
3380       assert(!llproc_);
3381    }
3382
3383    return true;
3384 }
3385
3386 bool Process::isTerminated() const
3387 {
3388    MTLock lock_this_func;
3389    if (!llproc_) {
3390       return true;
3391    }
3392    return (llproc_->getState() == int_process::exited);
3393 }
3394
3395 bool Process::hasStoppedThread() const
3396 {
3397    MTLock lock_this_func;
3398    if (!llproc_) {
3399       perr_printf("hasStoppedThread on deleted process\n");
3400       setLastError(err_exited, "Process is exited\n");
3401       return false;
3402    }
3403
3404    int_threadPool::iterator i;
3405    for (i = llproc_->threadPool()->begin(); i != llproc_->threadPool()->end(); i++) {
3406       if ((*i)->getUserState() == int_thread::stopped)
3407          return true;
3408    }
3409    return false;
3410 }
3411
3412 bool Process::hasRunningThread() const
3413 {
3414    MTLock lock_this_func;
3415    if (!llproc_) {
3416       perr_printf("hasRunningThread on deleted process\n");
3417       setLastError(err_exited, "Process is exited\n");
3418       return false;
3419    }
3420
3421    int_threadPool::iterator i;
3422    for (i = llproc_->threadPool()->begin(); i != llproc_->threadPool()->end(); i++) {
3423       if ((*i)->getUserState() == int_thread::running)
3424          return true;
3425    }
3426    return false;
3427 }
3428
3429 bool Process::allThreadsStopped() const
3430 {
3431    MTLock lock_this_func;
3432    if (!llproc_) {
3433       perr_printf("allThreadsStopped on deleted process\n");
3434       setLastError(err_exited, "Process is exited\n");
3435       return false;
3436    }
3437
3438    int_threadPool::iterator i;
3439    for (i = llproc_->threadPool()->begin(); i != llproc_->threadPool()->end(); i++) {
3440       if ((*i)->getUserState() == int_thread::running)
3441          return false;
3442    }
3443    return true;
3444 }
3445
3446 bool Process::allThreadsRunning() const
3447 {
3448    MTLock lock_this_func;
3449    if (!llproc_) {
3450       perr_printf("allThreadsRunning on deleted process\n");
3451       setLastError(err_exited, "Process is exited\n");
3452       return false;
3453    }
3454
3455    int_threadPool::iterator i;
3456    for (i = llproc_->threadPool()->begin(); i != llproc_->threadPool()->end(); i++) {
3457       if ((*i)->getUserState() == int_thread::stopped)
3458          return false;
3459    }
3460    return true;
3461 }
3462
3463 Thread::ptr Process::postIRPC(IRPC::ptr irpc) const
3464 {
3465    MTLock lock_this_func;
3466    if (!llproc_) {
3467       perr_printf("postIRPC on deleted process\n");
3468       setLastError(err_exited, "Process is exited\n");
3469       return Thread::ptr();
3470    }
3471
3472    int_process *proc = llproc();
3473    int_iRPC::ptr rpc = irpc->llrpc()->rpc;
3474    bool result = rpcMgr()->postRPCToProc(proc, rpc);
3475    if (!result) {
3476       pthrd_printf("postRPCToProc failed on %d\n", proc->getPid());
3477       return Thread::ptr();
3478    }
3479
3480    if (int_process::in_callback) {
3481       pthrd_printf("Returning from postIRPC in callback\n");
3482       return rpc->thread()->thread();
3483    }
3484    int_thread *thr = rpc->thread();
3485    if (thr->getInternalState() == int_thread::running) {
3486       //The thread is running, let's go ahead and start the RPC going.
3487       bool result = thr->handleNextPostedIRPC(true);
3488       if (!result) {
3489          pthrd_printf("handleNextPostedIRPC failed\n");
3490          return Thread::ptr();
3491       }
3492    }
3493    return thr->thread();
3494 }
3495
3496 bool Process::getPostedIRPCs(std::vector<IRPC::ptr> &rpcs) const
3497 {
3498    MTLock lock_this_func;
3499    if (!llproc_) {
3500       perr_printf("postIRPC on deleted process\n");
3501       setLastError(err_exited, "Process is exited\n");
3502       return false;
3503    }
3504    int_threadPool *tp = llproc()->threadPool();
3505    for (int_threadPool::iterator i = tp->begin(); i != tp->end(); i++)
3506    {
3507       int_thread *thr = *i;
3508       rpc_list_t *rpc_list = thr->getPostedRPCs();
3509       for (rpc_list_t::iterator j = rpc_list->begin(); j != rpc_list->end(); j++) {
3510          IRPC::ptr up_rpc = (*j)->getIRPC().lock();
3511          if (up_rpc == IRPC::ptr()) 
3512             continue;
3513          rpcs.push_back(up_rpc);
3514       }
3515    }
3516    return true;
3517 }
3518
3519 Dyninst::Architecture Process::getArchitecture() const
3520 {
3521    MTLock lock_this_func;
3522    if (!llproc_) {
3523       perr_printf("getArchitecture on deleted process\n");
3524       setLastError(err_exited, "Process is exited\n");
3525       return Dyninst::Arch_none;
3526    }
3527    return llproc_->getTargetArch();
3528 }
3529
3530 Dyninst::Address Process::mallocMemory(size_t size, Dyninst::Address addr)
3531 {
3532    MTLock lock_this_func(MTLock::deliver_callbacks);
3533    if (!llproc_) {
3534       perr_printf("mallocMemory on deleted process\n");
3535       setLastError(err_exited, "Process is exited\n");
3536       return false;
3537    }
3538
3539    if (int_process::isInCB()) {
3540       perr_printf("User attempted call on process while in CB, erroring.");
3541       setLastError(err_incallback, "Cannot mallocMemory from callback\n");
3542       return false;
3543    }
3544    return llproc_->infMalloc(size, true, addr);
3545 }
3546
3547 Dyninst::Address Process::mallocMemory(size_t size)
3548 {
3549    MTLock lock_this_func(MTLock::deliver_callbacks);
3550    if (!llproc_) {
3551       perr_printf("mallocMemory on deleted process\n");
3552       setLastError(err_exited, "Process is exited\n");
3553       return false;
3554    }
3555
3556    if (int_process::isInCB()) {
3557       perr_printf("User attempted call on process while in CB, erroring.");
3558       setLastError(err_incallback, "Cannot mallocMemory from callback\n");
3559       return false;
3560    }
3561    return llproc_->infMalloc(size, false, 0x0);
3562 }
3563
3564 bool Process::freeMemory(Dyninst::Address addr)
3565 {
3566    MTLock lock_this_func(MTLock::deliver_callbacks);
3567    if (!llproc_) {
3568       perr_printf("freeMemory on deleted process\n");
3569       setLastError(err_exited, "Process is exited\n");
3570       return false;
3571    }
3572
3573    if (int_process::isInCB()) {
3574       perr_printf("User attempted call on process while in CB, erroring.");
3575       setLastError(err_incallback, "Cannot freeMemory from callback\n");
3576       return false;
3577    }
3578    return llproc_->infFree(addr);
3579 }
3580
3581 bool Process::writeMemory(Dyninst::Address addr, void *buffer, size_t size) const
3582 {
3583    MTLock lock_this_func;
3584    if (!llproc_) {
3585       perr_printf("writeMemory on deleted process\n");
3586       setLastError(err_exited, "Process is exited\n");
3587       return false;
3588    }
3589
3590    pthrd_printf("User wants to write memory from 0x%lx to 0x%p of size %lu\n", 
3591                 addr, buffer, (unsigned long) size);
3592    return llproc_->writeMem(buffer, addr, size);
3593 }
3594
3595 bool Process::readMemory(void *buffer, Dyninst::Address addr, size_t size) const
3596 {
3597    MTLock lock_this_func;
3598    if (!llproc_) {
3599       perr_printf("readMemory on deleted process\n");
3600       setLastError(err_exited, "Process is exited\n");
3601       return false;
3602    }
3603
3604    pthrd_printf("User wants to read memory from 0x%lx to 0x%p of size %lu\n", 
3605                 addr, buffer, (unsigned long) size);
3606    return llproc_->readMem(buffer, addr, size);
3607 }
3608
3609 bool Process::addBreakpoint(Address addr, Breakpoint::ptr bp) const
3610 {
3611    MTLock lock_this_func;
3612    if (!llproc_) {
3613       perr_printf("addBreakpoint on deleted process\n");
3614       setLastError(err_exited, "Process is exited\n");
3615       return false;
3616    }
3617
3618    if (hasRunningThread()) {
3619       perr_printf("User attempted to add breakpoint to running process\n");
3620       setLastError(err_notstopped, "Attempted to insert breakpoint into running process\n");
3621       return false;
3622    }
3623    return llproc_->addBreakpoint(addr, bp->llbp());
3624 }
3625
3626 bool Process::rmBreakpoint(Dyninst::Address addr, Breakpoint::ptr bp) const
3627 {
3628    MTLock lock_this_func;
3629    if (!llproc_) {
3630       perr_printf("rmBreakpoint on deleted process\n");
3631       setLastError(err_exited, "Process is exited\n");
3632       return false;
3633    }
3634
3635    if (hasRunningThread()) {
3636       perr_printf("User attempted to add breakpoint to running process\n");
3637       setLastError(err_notstopped, "Attempted to insert breakpoint into running process\n");
3638       return false;
3639    }
3640    return llproc_->rmBreakpoint(addr, bp->llbp());
3641 }
3642
3643 Thread::Thread() :
3644    llthread_(NULL),
3645    exitstate_(NULL)
3646 {
3647 }
3648
3649 Thread::~Thread()
3650 {
3651    if (exitstate_) {
3652       delete exitstate_;
3653       exitstate_ = NULL;
3654    }
3655 }
3656
3657 Process::ptr Thread::getProcess() const
3658 {
3659    MTLock lock_this_func;
3660    if (!llthread_) {
3661       assert(exitstate_);
3662       return exitstate_->proc_ptr;
3663    }
3664    return llthread_->proc();
3665 }
3666
3667 int_thread *Thread::llthrd() const
3668 {
3669    return llthread_;
3670 }
3671
3672 bool Thread::isStopped() const
3673 {
3674    MTLock lock_this_func;
3675    if (!llthread_) {
3676       perr_printf("isStopped called on exited thread\n");
3677       setLastError(err_exited, "Thread is exited\n");
3678       return false;
3679    }
3680    return llthread_->getUserState() == int_thread::stopped;
3681 }
3682
3683 bool Thread::isRunning() const
3684 {
3685    MTLock lock_this_func;
3686    if (!llthread_) {
3687       perr_printf("isRunning called on exited thread\n");
3688       setLastError(err_exited, "Thread is exited\n");
3689       return false;
3690    }
3691    return llthread_->getUserState() == int_thread::running;
3692 }
3693
3694 bool Thread::isLive() const
3695 {
3696    MTLock lock_this_func;
3697    if (!llthread_) {
3698       return false;
3699    }
3700    return (llthread_->getUserState() == int_thread::stopped ||
3701            llthread_->getUserState() == int_thread::running);
3702 }
3703
3704 bool Thread::stopThread()
3705 {
3706    MTLock lock_this_func(MTLock::deliver_callbacks);
3707    if (!llthread_) {
3708       perr_printf("stopThread called on exited thread\n");
3709       setLastError(err_exited, "Thread is exited\n");
3710       return false;
3711    }
3712
3713    if (int_process::isInCB()) {
3714       perr_printf("User attempted continue call on thread while in CB, erroring.");
3715       setLastError(err_incallback, "Cannot continueThread from callback\n");
3716       return false;
3717    }
3718
3719    return llthread_->userStop();   
3720 }
3721
3722 bool Thread::continueThread()
3723 {
3724    MTLock lock_this_func(MTLock::deliver_callbacks);
3725    if (!llthread_) {
3726       perr_printf("continueThread called on exited thread\n");
3727       setLastError(err_exited, "Thread is exited\n");
3728       return false;
3729    }
3730
3731    if (int_process::isInCB()) {
3732       perr_printf("User attempted continue call on thread while in CB, erroring.");
3733       setLastError(err_incallback, "Cannot continueThread from callback\n");
3734       return false;
3735    }
3736
3737    return llthread_->userCont();
3738 }
3739
3740 bool Thread::getAllRegisters(RegisterPool &pool) const
3741 {
3742    MTLock lock_this_func;
3743    if (!llthread_) {
3744       perr_printf("getAllRegisters called on exited thread\n");
3745       setLastError(err_exited, "Thread is exited\n");
3746       return false;
3747    }
3748
3749    if (llthread_->getUserState() != int_thread::stopped) {
3750       setLastError(err_notstopped, "Thread must be stopped before getting registers");
3751       perr_printf("User called getAllRegisters on running thread %d\n", llthread_->getLWP());
3752       return false;
3753    }
3754    return llthread_->getAllRegisters(*pool.llregpool);
3755 }
3756
3757 bool Thread::setAllRegisters(RegisterPool &pool) const
3758 {
3759    MTLock lock_this_func;
3760    if (!llthread_) {
3761       perr_printf("setAllRegisters called on exited thread\n");
3762       setLastError(err_exited, "Thread is exited\n");
3763       return false;
3764    }
3765    if (llthread_->getUserState() != int_thread::stopped) {
3766       setLastError(err_notstopped, "Thread must be stopped before setting registers");
3767       perr_printf("User called setAllRegisters on running thread %d\n", llthread_->getLWP());
3768       return false;
3769    }
3770    return llthread_->setAllRegisters(*pool.llregpool);
3771 }
3772
3773 bool Thread::getRegister(Dyninst::MachRegister reg, Dyninst::MachRegisterVal &val) const
3774 {
3775    MTLock lock_this_func;
3776    if (!llthread_) {
3777       perr_printf("getRegister called on exited thread\n");
3778       setLastError(err_exited, "Thread is exited\n");
3779       return false;
3780    }
3781    if (llthread_->getUserState() != int_thread::stopped) {
3782       setLastError(err_notstopped, "Thread must be stopped before getting registers");
3783       perr_printf("User called getRegister on running thread %d\n", llthread_->getLWP());
3784       return false;
3785    }
3786    return llthread_->getRegister(reg, val);
3787 }
3788
3789 bool Thread::setRegister(Dyninst::MachRegister reg, Dyninst::MachRegisterVal val) const
3790 {
3791    MTLock lock_this_func;
3792    if (!llthread_) {
3793       perr_printf("setRegister called on exited thread\n");
3794       setLastError(err_exited, "Thread is exited\n");
3795       return false;
3796    }
3797    if (llthread_->getUserState() != int_thread::stopped) {
3798       setLastError(err_notstopped, "Thread must be stopped before setting registers");
3799       perr_printf("User called setRegister on running thread %d\n", llthread_->getLWP());
3800       return false;
3801    }
3802    return llthread_->setRegister(reg, val);
3803 }
3804
3805 bool Thread::isInitialThread() const
3806 {
3807    MTLock lock_this_func;
3808    if (!llthread_) {
3809       perr_printf("isInitialThrad called on exited thread\n");
3810       setLastError(err_exited, "Thread is exited\n");
3811       return false;
3812    }
3813    return llthread_->llproc()->threadPool()->initialThread() == llthread_;
3814 }
3815
3816 void Thread::setSingleStepMode(bool s) const
3817 {
3818    MTLock lock_this_func;
3819    if (!llthread_) {
3820       perr_printf("setSingleStepMode called on exited thread\n");
3821       setLastError(err_exited, "Thread is exited\n");
3822       return;
3823    }
3824    llthread_->setSingleStepUserMode(s);
3825 }
3826
3827 bool Thread::getSingleStepMode() const
3828 {
3829    MTLock lock_this_func;
3830    if (!llthread_) {
3831       perr_printf("getSingleStepMode called on exited thread\n");
3832       setLastError(err_exited, "Thread is exited\n");
3833       return false;
3834    }
3835    return llthread_->singleStepUserMode();
3836 }
3837
3838 Dyninst::LWP Thread::getLWP() const
3839 {
3840    MTLock lock_this_func;
3841    if (!llthread_) {
3842       assert(exitstate_);
3843       return exitstate_->lwp;
3844    }
3845    return llthread_->getLWP();
3846 }
3847
3848 bool Thread::postIRPC(IRPC::ptr irpc) const
3849 {
3850    MTLock lock_this_func;
3851    if (!llthread_) {
3852       perr_printf("postIRPC on deleted thread\n");
3853       setLastError(err_exited, "Thread is exited\n");
3854       return false;
3855    }
3856
3857    int_thread *thr = llthread_;
3858    int_process *proc = thr->llproc();
3859    int_iRPC::ptr rpc = irpc->llrpc()->rpc;
3860    bool result = rpcMgr()->postRPCToThread(thr, rpc);
3861    if (!result) {
3862       pthrd_printf("postRPCToThread failed on %d\n", proc->getPid());
3863       return false;
3864    }
3865
3866    if (int_process::isInCallback()) {
3867       pthrd_printf("Returning from postIRPC in callback\n");
3868       return true;
3869    }
3870    if (thr->getInternalState() == int_thread::running) {
3871       //The thread is running, let's go ahead and start the RPC going.
3872       bool result = thr->handleNextPostedIRPC(true);
3873       if (!result) {
3874          pthrd_printf("handleNextPostedIRPC failed\n");
3875          return false;
3876       }
3877    }
3878    return true;
3879 }
3880
3881 bool Thread::getPostedIRPCs(std::vector<IRPC::ptr> &rpcs) const
3882 {
3883    MTLock lock_this_func;
3884    if (!llthread_) {
3885       perr_printf("postIRPC on deleted thread\n");
3886       setLastError(err_exited, "Thread is exited\n");
3887       return false;
3888    }
3889    rpc_list_t *rpc_list = llthread_->getPostedRPCs();
3890    for (rpc_list_t::iterator j = rpc_list->begin(); j != rpc_list->end(); j++) {
3891       IRPC::ptr up_rpc = (*j)->getIRPC().lock();
3892       if (up_rpc == IRPC::ptr()) 
3893          continue;
3894       rpcs.push_back(up_rpc);
3895    }
3896    return true;
3897 }
3898
3899 IRPC::const_ptr Thread::getRunningIRPC() const
3900 {
3901    MTLock lock_this_func;
3902    if (!llthread_) {
3903       perr_printf("getRunningIRPC on deleted thread\n");
3904       setLastError(err_exited, "Thread is exited\n");
3905       return IRPC::const_ptr();
3906    }
3907    int_iRPC::ptr running = llthread_->runningRPC();
3908    if (running == int_iRPC::ptr())
3909       return IRPC::const_ptr();
3910    IRPC::ptr irpc = running->getIRPC().lock();
3911    return irpc;
3912 }
3913
3914 ThreadPool::ThreadPool()
3915 {
3916 }
3917
3918 ThreadPool::~ThreadPool()
3919 {
3920 }
3921
3922 Thread::ptr ThreadPool::getInitialThread()
3923 {
3924    return threadpool->initialThread()->thread();
3925 }
3926
3927 const Thread::ptr ThreadPool::getInitialThread() const
3928 {
3929    return threadpool->initialThread()->thread();
3930 }
3931
3932 ThreadPool::iterator::iterator()
3933 {
3934    curp = NULL;
3935    curi = -1;
3936    curh = Thread::ptr();
3937 }
3938
3939 ThreadPool::iterator::~iterator()
3940 {
3941 }
3942
3943 bool ThreadPool::iterator::operator==(const iterator &i)
3944 {
3945    return (i.curh == curh);
3946 }
3947
3948 bool ThreadPool::iterator::operator!=(const iterator &i)
3949 {
3950    return (i.curh != curh);