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