Merge branch 'master' into bgq_ramdisk_io
[dyninst.git] / proccontrol / src / process.C
1 /*
2  * See the dyninst/COPYRIGHT file for copyright information.
3  * 
4  * We provide the Paradyn Tools (below described as "Paradyn")
5  * on an AS IS basis, and do not warrant its validity or performance.
6  * We reserve the right to update, modify, or discontinue this
7  * software at any time.  We shall have no obligation to supply such
8  * updates or modifications or any other form of support to you.
9  * 
10  * By your use of Paradyn, you understand and agree that we (or any
11  * other person or entity with proprietary rights in Paradyn) are
12  * under no obligation to provide either maintenance services,
13  * update services, notices of latent defects, or correction of
14  * defects for Paradyn.
15  * 
16  * This library is free software; you can redistribute it and/or
17  * modify it under the terms of the GNU Lesser General Public
18  * License as published by the Free Software Foundation; either
19  * version 2.1 of the License, or (at your option) any later version.
20  * 
21  * This library is distributed in the hope that it will be useful,
22  * but WITHOUT ANY WARRANTY; without even the implied warranty of
23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
24  * Lesser General Public License for more details.
25  * 
26  * You should have received a copy of the GNU Lesser General Public
27  * License along with this library; if not, write to the Free Software
28  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
29  */
30
31 #include "proccontrol/src/int_process.h"
32 #include "proccontrol/src/irpc.h"
33 #include "proccontrol/src/procpool.h"
34 #include "proccontrol/src/int_handler.h"
35 #include "proccontrol/src/response.h"
36 #include "proccontrol/src/int_event.h"
37 #include "proccontrol/src/processplat.h"
38 #include "proccontrol/h/Mailbox.h"
39 #include "proccontrol/h/PCErrors.h"
40 #include "proccontrol/h/Generator.h"
41 #include "proccontrol/h/Event.h"
42 #include "proccontrol/h/Handler.h"
43 #include "proccontrol/h/ProcessSet.h"
44 #include "proccontrol/h/PlatFeatures.h"
45
46 #if defined(os_windows)
47 #include "proccontrol/src/windows_process.h"
48 #include "proccontrol/src/windows_thread.h"
49 #endif
50
51 #include <climits>
52 #include <cstring>
53 #include <cassert>
54 #include <map>
55 #include <sstream>
56 #include <iostream>
57 #include <iterator>
58
59 #if defined(os_windows)
60 #pragma warning(disable:4355)
61 #endif
62
63 using namespace Dyninst;
64 using namespace ProcControlAPI;
65 using namespace std;
66
67 const map<int,int> Process::emptyFDs;
68 const vector<string> Process::emptyEnvp;
69 Process::thread_mode_t threadingMode = Process::GeneratorThreading;
70 bool int_process::in_callback = false;
71 std::set<int_thread::continue_cb_t> int_thread::continue_cbs;
72 SymbolReaderFactory *int_process::user_set_symbol_reader = NULL;
73
74 static const int ProcControl_major_version = 8;
75 static const int ProcControl_minor_version = 0;
76 static const int ProcControl_maintenance_version = 0;
77
78 void Process::version(int& major, int& minor, int& maintenance)
79 {
80     major = ProcControl_major_version;
81     minor = ProcControl_minor_version;
82     maintenance = ProcControl_maintenance_version;
83 }
84
85 bool int_process::create(int_processSet *ps) {
86    bool had_error = false;
87    set<int_process *> procs;
88    transform(ps->begin(), ps->end(), inserter(procs, procs.end()), ProcToIntProc());
89
90    //Should be called with procpool lock held
91    pthrd_printf("Calling plat_create for %d processes\n", (int) procs.size());
92    for (set<int_process *>::iterator i = procs.begin(); i != procs.end(); ) {
93       int_process *proc = *i;
94       bool result = proc->plat_create();
95       if (!result) {
96          pthrd_printf("Could not create debuggee, %s\n", proc->executable.c_str());
97          proc->setLastError(err_noproc, "Could not create process");
98          procs.erase(i++);
99          had_error = true;
100          continue;
101       }
102       i++;
103    }
104
105    pthrd_printf("Creating initial threads for %d processes\n", (int) procs.size());
106    for (set<int_process *>::iterator i = procs.begin(); i != procs.end(); i++) {
107       int_process *proc = *i;
108           // Because yo, windows processes have threads when they're created...
109           if (proc->threadPool()->empty()) {
110         int_thread::createThread(proc, NULL_THR_ID, NULL_LWP, true, int_thread::as_created_attached);
111           }
112           ProcPool()->addProcess(proc);
113       proc->setState(neonatal_intermediate);
114       pthrd_printf("Created debugged %s on pid %d\n", proc->executable.c_str(), proc->pid);
115    }
116
117    ProcPool()->condvar()->broadcast();
118    ProcPool()->condvar()->unlock();
119       
120    
121    pthrd_printf("Waiting for startup for %d processes\n", (int) procs.size());
122    for (set<int_process *>::iterator i = procs.begin(); i != procs.end(); ) {
123       int_process *proc = *i;
124
125       bool result = proc->waitfor_startup();
126       if (proc->getState() == int_process::exited) {
127          pthrd_printf("Process %s/%d exited during create\n", proc->executable.c_str(), proc->pid);
128          procs.erase(i++);
129          had_error = true;
130          continue;
131       }
132       if (!result) {
133          pthrd_printf("Error during process create for %d\n", proc->pid);
134          procs.erase(i++);
135          had_error = true;
136          continue;
137       }
138       i++;
139    }
140
141    pthrd_printf("Triggering post-create for %d processes\n", (int) procs.size());
142    while (!procs.empty()) {
143       set<response::ptr> async_responses;
144       bool ret_async = false;
145       for (set<int_process *>::iterator i = procs.begin(); i != procs.end(); ) {
146          int_process *proc = *i;
147
148          async_ret_t result = proc->post_create(async_responses);
149          if (result == aret_error) {
150             pthrd_printf("Error during post create for %d\n", proc->pid);
151             had_error = true;
152             procs.erase(i++);
153          }
154          else if (result == aret_success) {
155             assert(proc->getState() == running);
156             pthrd_printf("Finished post-create for %d.  Process is ready\n", proc->pid);
157             procs.erase(i++);
158          }
159          else {
160             pthrd_printf("post-create for %d return async\n", proc->pid);
161             ret_async = true;
162             i++;
163          }
164       }
165       if (ret_async) {
166          waitForAsyncEvent(async_responses);
167       }
168    }
169
170    return !had_error;
171 }
172
173 bool int_process::waitfor_startup()
174 {
175    bool proc_exited = false;
176    while (getState() != running) {
177       if (proc_exited || getState() == exited) {
178          pthrd_printf("Error.  Process exited during create/attach\n");
179          globalSetLastError(err_exited, "Process exited during startup");
180          return false;
181       }
182       pthrd_printf("Waiting for startup to complete for %d\n", pid);
183       bool result = waitAndHandleForProc(true, this, proc_exited);
184       if (!proc_exited && (!result || getState() == errorstate)) {
185          pthrd_printf("Error.  Process %d errored during create/attach\n", pid);
186          globalSetLastError(err_internal, "Process failed to startup");
187          return false;
188       }
189       if (proc_exited || getState() == exited) {
190          pthrd_printf("Error.  Proces exited during create/attach\n");
191          globalSetLastError(err_exited, "Process exited during startup");
192          return false;
193       }
194    }
195    return true;
196 }
197
198 void int_process::plat_threadAttachDone()
199 {
200 }
201
202 bool int_process::attachThreads()
203 {
204    if (!needIndividualThreadAttach())
205       return true;
206
207    /**
208     * This OS (linux) needs us to attach to each thread manually.
209     * Get all the thread LWPs and create new thread objects for them.
210     * After we have all the threads, check again to see if there are any
211     * new ones.  We're dealing with the race condition where we could get
212     * a list of LWPs, but then new threads are created before we attach to 
213     * all the existing threads.
214     **/
215    bool found_new_threads;
216    do {
217       found_new_threads = false;
218       vector<Dyninst::LWP> lwps;
219       bool result = getThreadLWPs(lwps);
220       if (!result) {
221          pthrd_printf("Failed to get thread LWPs for %d\n", pid);
222          return false;
223       }
224       
225       for (vector<Dyninst::LWP>::iterator i = lwps.begin(); i != lwps.end(); ++i) {
226          int_thread *thr = threadpool->findThreadByLWP(*i);
227          if (thr) {
228             pthrd_printf("Already have thread %d in process %d\n", *i, pid);
229             continue;
230          }
231          pthrd_printf("Creating new thread for %d/%d during attach\n", pid, *i);
232          thr = int_thread::createThread(this, NULL_THR_ID, *i, false, int_thread::as_needs_attach);
233          found_new_threads = true;         
234       }
235    } while (found_new_threads);
236
237    return true;
238 }
239
240 bool int_process::attach(int_processSet *ps, bool reattach)
241 {
242    bool had_error = false, should_sync = false;
243    set<int_process *> procs;
244    vector<Event::ptr> observedEvents;
245    set<response::ptr> async_responses;
246    transform(ps->begin(), ps->end(), inserter(procs, procs.end()), ProcToIntProc());
247
248    //Should be called with procpool lock held
249
250         pthrd_printf("Calling plat_attach for %d processes\n", (int) procs.size());
251    map<pair<int_process *, Dyninst::LWP>, bool> runningStates;
252    for (set<int_process *>::iterator i = procs.begin(); i != procs.end();) {
253            int_process *proc = *i;
254       if (!proc) {
255          procs.erase(i++);
256          continue;
257       }
258       if (reattach && proc->getState() != int_process::detached) {
259          perr_printf("Attempted to reattach to attached process %d\n", proc->getPid());
260          proc->setLastError(err_attached, "Cannot reAttach to attached process.\n");
261          procs.erase(i++);
262          continue;
263       }
264
265       // Determine the running state of all threads before attaching
266       map<Dyninst::LWP, bool> temp_runningStates;
267       if (!proc->plat_getOSRunningStates(temp_runningStates)) {
268          pthrd_printf("Could not get OS running states for %d\n", proc->getPid());
269          procs.erase(i++);
270          had_error = true;
271          continue;
272       }
273
274       //Keep track of the initial running states for each thread.  We'll fill them in latter
275       // after we create the int_thread objects.
276       bool allStopped = true;
277       for(map<Dyninst::LWP, bool>::iterator j = temp_runningStates.begin(); j != temp_runningStates.end(); ++j) {
278          if (j->second) {
279             allStopped = false;
280          }
281          runningStates[pair<int_process *, LWP>(proc, j->first)] = j->second;
282       }
283
284       bool local_should_sync = false;
285       pthrd_printf("Calling plat_attach for process %d\n", proc->getPid());
286       bool result = proc->plat_attach(allStopped, local_should_sync);
287       if (!result) {
288          pthrd_printf("Failed to plat_attach to %d\n", proc->getPid());
289          procs.erase(i++);
290          proc->setLastError(err_noproc, "Could not attach to process");
291          had_error = true;
292          continue;
293       }
294       if (local_should_sync)
295          should_sync = true;
296       i++;
297    }
298
299    //Create the int_thread objects via attach_threads
300    if (!reattach) {
301       for (set<int_process *>::iterator i = procs.begin(); i != procs.end(); i++) {
302          int_process *proc = *i;
303          ProcPool()->addProcess(proc);
304          int_thread::createThread(proc, NULL_THR_ID, NULL_LWP, true,
305                                   int_thread::as_created_attached); //initial thread
306       }
307    }
308
309    if (should_sync) {
310       ProcPool()->condvar()->broadcast();
311       ProcPool()->condvar()->unlock();
312       for (;;) {
313          bool have_neonatal = false;
314          for (set<int_process *>::iterator i = procs.begin(); i != procs.end(); i++) {
315             int_process *proc = *i;
316             if (proc->getState() == neonatal) {
317                have_neonatal = true;
318                break;
319             }
320          }
321          if (!have_neonatal)
322             break;
323          bool result = waitAndHandleEvents(true);
324          if (!result) {
325             pthrd_printf("Error during waitAndHandleEvents during attach\n");
326             return false;
327          }
328       }
329       ProcPool()->condvar()->lock();
330    }
331    else {
332       pthrd_printf("Attach done, moving processes to neonatal_intermediate\n");
333       for (set<int_process *>::iterator i = procs.begin(); i != procs.end(); i++) {
334          int_process *proc = *i;
335          proc->setState(neonatal_intermediate);
336       }
337    }
338
339
340    for (set<int_process *>::iterator i = procs.begin(); i != procs.end(); ) {
341       int_process *proc = *i;
342       pthrd_printf("Attaching to threads for %d\n", proc->getPid());
343       bool result = proc->attachThreads();
344       if (!result) {
345          pthrd_printf("Could not attach to threads in %d--will try again\n", proc->pid);
346          procs.erase(i++);
347       }
348
349       if (reattach) {
350          // Now, go back and set non-existing threads to detached to exclude them
351          // from the bootstrap handling, creating thread destruction events for
352          // these non-existing threads
353          //
354          // Also, at the same time issue attaches to existing threads
355          int_threadPool *tp = proc->threadPool();
356          for(int_threadPool::iterator j = tp->begin(); j != tp->end(); j++)
357          {
358             int_thread *thr = *j;
359
360             if (thr->getDetachState().getState() != int_thread::detached) {
361                //Small hack: This thread is new since we're reattaching.  Every old
362                //thread has it's DetachState in 'detached', and we'd like to unset
363                //those for the entire process.  Temporarily set this thread to detached
364                //so that it gets properly restored with the rest.
365                thr->getDetachState().desyncState(int_thread::detached);
366                continue;
367             }
368
369             pair<int_process *, LWP> key(proc, thr->getLWP());
370             map<pair<int_process *, LWP>, bool>::iterator findIter = runningStates.find(key);
371             
372             pthrd_printf("Re-attaching to thread %d/%d\n", proc->getPid(), thr->getLWP());
373             if (findIter == runningStates.end() || !thr->attach()) {
374                pthrd_printf("Creating thread destroy event for thread %d/%d\n", proc->getPid(), thr->getLWP());
375                thr->getGeneratorState().setState(int_thread::detached);
376                thr->getHandlerState().setState(int_thread::detached);
377                thr->getUserState().setState(int_thread::detached);
378                thr->getDetachState().setState(int_thread::detached);
379                
380                Event::ptr destroyEv;
381                if (proc->plat_supportLWPPostDestroy()) {
382                   destroyEv = Event::ptr(new EventLWPDestroy(EventType::Post));
383                }
384                else if (proc->plat_supportThreadEvents()) {
385                   destroyEv = Event::ptr(new EventUserThreadDestroy(EventType::Post));
386                }
387                else {
388                   perr_printf("Platform does not support any thread destroy events.  Now what?\n");
389                   assert(0);
390                }
391                
392                destroyEv->setProcess(proc->proc());
393                destroyEv->setThread(thr->thread());
394                destroyEv->setSyncType(Event::async);
395                destroyEv->setUserEvent(true);
396                observedEvents.push_back(destroyEv);
397             }
398          }
399          proc->threadPool()->initialThread()->getDetachState().restoreStateProc();         
400       }
401       i++;
402    }
403
404    ProcPool()->condvar()->broadcast();
405    ProcPool()->condvar()->unlock();
406
407    //Wait for each process to make it to the 'running' state.
408    for (set<int_process *>::iterator i = procs.begin(); i != procs.end(); ) {
409       int_process *proc = *i;
410       pthrd_printf("Wait for attach from process %d\n", proc->pid);
411
412           bool result = proc->waitfor_startup();
413
414           if (!result) {
415          pthrd_printf("Error waiting for attach to %d\n", proc->pid);
416          procs.erase(i++);
417          had_error = true;
418       }
419       i++;
420    }
421
422    //Some OSs need to do their attachThreads here.  Since the operation is supposed to be
423    //idempotent after success, then just do it again.
424    for (set<int_process *>::iterator i = procs.begin(); i != procs.end(); ) {
425       int_process *proc = *i;
426       bool result = proc->attachThreads();
427       if (!result) {
428          pthrd_printf("Failed to attach to threads in %d--now an error\n", proc->pid);
429          proc->setLastError(err_internal, "Could not get threads during attach\n");
430          procs.erase(i++);
431          had_error = true;
432          continue;
433       }
434
435       // Now that all the threads are created, set their running states
436       int_threadPool *tp = proc->threadPool();
437       for(int_threadPool::iterator j = tp->begin(); j != tp->end(); j++) {
438          int_thread *thr = *j;
439          pair<int_process *, LWP> key(proc, thr->getLWP());
440          map<pair<int_process *, LWP>, bool>::iterator findIter = runningStates.find(key);
441       
442          // There is a race that could be visible here where we are not
443          // guaranteed to determine the running state of all threads in a process
444          // before we attach -- if for some reason we don't know the running
445          // state, assume it was running
446          thr->setRunningWhenAttached(findIter == runningStates.end() ? true : findIter->second);
447       }
448
449       pthrd_printf("Thread attach is done for process %d\n", proc->getPid());
450       proc->plat_threadAttachDone();
451       i++;
452    }
453
454    pthrd_printf("Triggering post-attach for %d processes\n", (int) procs.size());
455    std::set<int_process *> pa_procs = procs;
456    while (!pa_procs.empty()) {
457       async_responses.clear();
458       bool ret_async = false;
459       for (set<int_process *>::iterator i = pa_procs.begin(); i != pa_procs.end(); ) {
460          int_process *proc = *i;
461
462          async_ret_t result = proc->post_attach(false, async_responses);
463          if (result == aret_error) {
464             pthrd_printf("Error during post attach for %d\n", proc->pid);
465             had_error = true;
466             pa_procs.erase(i++);
467          }
468          else if (result == aret_success) {
469             assert(proc->getState() == running);
470             pthrd_printf("Finished post-attach for %d.  Process is ready\n", proc->pid);
471             pa_procs.erase(i++);
472          }
473          else {
474             pthrd_printf("post-attach for %d return async\n", proc->pid);
475             ret_async = true;
476             i++;
477          }
478       }
479       if (ret_async) {
480          waitForAsyncEvent(async_responses);
481       }
482    }
483
484    //
485    //Everything below this point is targeted at DOTF reattach--
486    //reinstalling BPs and throwing dead thread events.
487    if (!reattach)
488       return !had_error;
489    
490    async_responses.clear();
491    for (set<int_process *>::iterator i = procs.begin(); i != procs.end(); i++) {
492       // Resume all breakpoints
493       int_process *proc = *i;
494       for(std::map<Dyninst::Address, sw_breakpoint *>::iterator j = proc->mem->breakpoints.begin();
495           j != proc->mem->breakpoints.end(); j++)
496       {
497          pthrd_printf("Resuming breakpoint at 0x%lx in process %d\n", j->first, proc->getPid());
498          bool result = j->second->resume(proc, async_responses);
499          if(!result) {
500             pthrd_printf("Error resuming breakpoint at %lx\n", j->first);
501             //Drop this error.  The library containing this BP was likely unloaded.
502          }
503       }
504    }
505    waitForAsyncEvent(async_responses);
506
507    // Report all events for observed process state changes
508    for(vector<Event::ptr>::iterator i = observedEvents.begin(); i!= observedEvents.end(); i++)
509    {
510        int_thread *thrd = (*i)->getThread()->llthrd();
511        pthrd_printf("Queuing event %s for thread %d/%d\n",
512                     (*i)->getEventType().name().c_str(), (*i)->getProcess()->getPid(),
513                     (*i)->getThread()->getLWP());
514        
515        // Make sure the thread is the correct state while in event handling
516        thrd->getGeneratorState().setState(int_thread::detached);
517        thrd->getHandlerState().setState(int_thread::detached);
518        thrd->getUserState().setState(int_thread::detached);
519        thrd->getDetachState().setState(int_thread::detached);
520
521            mbox()->enqueue(*i);
522    }
523
524    if (!observedEvents.empty()) {
525       // As a sanity check, don't block
526       bool result = waitAndHandleEvents(false);
527       if (!result) {
528          perr_printf("Internal error in waitAndHandleEvents under reattach\n");
529       }
530    }
531
532    return !had_error;
533 }
534
535 bool int_process::reattach(int_processSet *pset)
536 {
537    return attach(pset, true);
538 }
539
540 bool int_process::execed()
541 {
542    ProcPool()->condvar()->lock();
543
544    bool should_clean = false;
545    mem->rmProc(this, should_clean);
546    if (should_clean)
547       delete mem;
548    mem = new mem_state(this);
549
550    arch = Dyninst::Arch_none;
551    exec_mem_cache.clear();
552
553    int_thread::State user_initial_thrd_state = threadpool->initialThread()->getUserState().getState();
554    int_thread::State gen_initial_thrd_state = threadpool->initialThread()->getGeneratorState().getState();
555    int_thread::State handler_initial_thrd_state = threadpool->initialThread()->getHandlerState().getState();
556
557    int_threadPool::iterator i = threadpool->begin(); 
558    for (; i != threadpool->end(); ++i) {
559       int_thread *thrd = *i;
560       thrd->getUserState().setState(int_thread::exited);
561       thrd->getGeneratorState().setState(int_thread::exited);
562       ProcPool()->rmThread(thrd);
563       delete thrd;
564    }
565    threadpool->clear();
566
567    int_thread *initial_thread = int_thread::createThread(this, NULL_THR_ID, NULL_LWP,
568                                                          true, int_thread::as_created_attached);
569    initial_thread->getUserState().setState(user_initial_thrd_state);
570    initial_thread->getGeneratorState().setState(gen_initial_thrd_state);
571    initial_thread->getHandlerState().setState(handler_initial_thrd_state);
572
573    ProcPool()->condvar()->broadcast();
574    ProcPool()->condvar()->unlock();
575    
576    bool result = plat_execed();
577
578    return result;
579 }
580
581 bool int_process::plat_execed()
582 {
583    return true;
584 }
585
586
587 bool int_process::forked()
588 {
589    ProcPool()->condvar()->lock();
590
591    pthrd_printf("Setting up forked process %d\n", pid);
592    creation_mode = ct_fork;
593    bool result = plat_forked();
594    if (!result) {
595       pthrd_printf("Could not handle forked debuggee, %d\n", pid);
596       return false;
597    }
598
599    int_thread *initial_thread;
600    initial_thread = int_thread::createThread(this, NULL_THR_ID, NULL_LWP, true, int_thread::as_created_attached);
601
602    ProcPool()->addProcess(this);
603
604    result = attachThreads();
605    if (!result) {
606       pthrd_printf("Failed to attach to threads in %d\n", pid);
607       setLastError(err_internal, "Could not attach to process' threads");
608       goto error;
609    }
610
611    ProcPool()->condvar()->broadcast();
612    ProcPool()->condvar()->unlock();
613
614    result = post_forked();
615    if (!result) {
616       pthrd_printf("Post-fork failed on %d\n", pid);
617       setLastError(err_internal, "Error handling forked process");
618       goto error;
619    }
620    return true;
621
622   error:
623    if (getState() == exited) {
624       setLastError(err_exited, "Process exited unexpectedly during attach\n");
625       return false;
626    }
627    pthrd_printf("Error during process attach for %d\n", pid);
628    return false;
629 }
630
631 bool int_process::post_forked()
632 {
633    setState(running);
634    return true;
635 }
636
637 async_ret_t int_process::initializeAddressSpace(std::set<response::ptr> &async_responses)
638 {
639    std::set<int_library*> added, rmd;
640
641    //This call will determine and cache the appropriate symbol reader, or NOP
642    // if that's already been done.
643    getSymReader();
644
645    bool have_asyncs = false;
646    bool result = refresh_libraries(added, rmd, have_asyncs, async_responses);
647    if (!result && have_asyncs) {
648       pthrd_printf("Postponing initializeAddressSpace of %d for async operations\n", getPid());
649       return aret_async;
650
651    }
652    if (!result) {
653       pthrd_printf("Failure refreshing libraries for %d\n", getPid());
654       return aret_error;
655    }
656    pthrd_printf("Successfully initialized address space for %d\n", getPid());
657    return aret_success;
658 }
659
660 async_ret_t int_process::post_attach(bool, std::set<response::ptr> &async_responses)
661 {
662    pthrd_printf("Starting post_attach for process %d\n", getPid());
663    return initializeAddressSpace(async_responses);
664 }
665
666 async_ret_t int_process::post_create(std::set<response::ptr> &async_responses)
667 {
668    pthrd_printf("Starting post_create for process %d\n", getPid());
669    return initializeAddressSpace(async_responses);
670 }
671
672 bool int_process::plat_processGroupContinues()
673 {
674    return false;
675 }
676
677 bool int_process::getThreadLWPs(std::vector<Dyninst::LWP> &)
678 {
679    return false;
680 }
681
682 const char *int_process::stateName(int_process::State s)
683 {
684    switch (s) {
685       case neonatal: return "neonatal";
686       case neonatal_intermediate: return "neonatal_intermediate";
687       case detached: return "detached";
688       case running: return "running";
689       case exited: return "exited";
690       case errorstate: return "errorstate";
691    }
692    assert(0);
693    return NULL;
694 }
695
696 void int_process::setState(int_process::State s)
697 {
698    int old_state = (int) state;
699    int new_state = (int) s;
700    
701    if (new_state < old_state && new_state != detached && old_state != detached) {
702       perr_printf("Regression of state %s to %s on %d\n",
703                   stateName(state), stateName(s), pid);
704       return;      
705    }
706    pthrd_printf("Changing state of process from %s to %s on %d\n",
707                 stateName(state), stateName(s), pid);
708    state = s;
709
710
711    int_thread::State new_thr_state = int_thread::errorstate;
712    switch (s) {
713       case neonatal: new_thr_state = int_thread::neonatal; break;
714       case neonatal_intermediate: new_thr_state = int_thread::neonatal_intermediate; break;
715       case running: new_thr_state = threadpool->initialThread()->getHandlerState().getState(); break;
716       case exited: new_thr_state = int_thread::exited; break;
717       case detached: new_thr_state = int_thread::detached; break;
718       case errorstate: new_thr_state = int_thread::errorstate; break;
719    }
720    pthrd_printf("Setting state of all threads in %d to %s\n", pid, 
721                 int_thread::stateStr(new_thr_state));
722    for (int_threadPool::iterator i = threadpool->begin(); i != threadpool->end(); ++i)
723    {
724       (*i)->getUserState().setState(new_thr_state);
725       (*i)->getHandlerState().setState(new_thr_state);
726       (*i)->getGeneratorState().setState(new_thr_state);
727           if(new_thr_state == int_thread::exited)
728           {
729         if((*i)->getPendingStopState().getState() != int_thread::dontcare) {
730            (*i)->getPendingStopState().restoreState();
731            (*i)->pendingStopsCount().dec();
732         }
733      }
734    }
735 }
736
737 int_process::State int_process::getState() const
738 {
739    return state;
740 }
741
742 int_process::creationMode_t int_process::getCreationMode() const
743 {
744    return creation_mode;
745 }
746 void int_process::setContSignal(int sig) {
747     continueSig = sig;
748 }
749
750 int int_process::getContSignal() const {
751     return continueSig;
752 }
753
754 void int_process::setPid(Dyninst::PID p)
755 {
756    pthrd_printf("Setting int_process %p to pid %d\n", this, p);
757    pid = p;
758 }
759
760 Dyninst::PID int_process::getPid() const
761 {
762    return pid;
763 }
764
765 int_threadPool *int_process::threadPool() const
766 {
767    return threadpool;
768 }
769
770 Process::ptr int_process::proc() const
771 {
772    return up_proc;
773 }
774
775 bool int_process::syncRunState()
776 {
777    pthrd_printf("At top of syncRunState for %d\n", getPid());
778    int_threadPool *tp = threadPool();
779
780    /**
781     * We can have some events (currently BreakpointClear and RPCLaunch) that
782     * get thrown when a thread is continued.  We'll create and throw those
783     * events here.
784     * 1), we'll identify each thread that would be continued.  We calculate
785     * this ahead of time as the act of throwing one of these events on a thread
786     * can change the running state of another thread.
787     * 2), for each thread that would run, we check if it has one of these
788     * events and throw it.
789     * 3), Check if any proc stopper events are ready, and if so then re-throw them
790     * 4), we redo the target_state calculation in-case anything changed.
791     **/
792    //1)
793    for (int_threadPool::iterator i = tp->begin(); i != tp->end(); i++) {
794       int_thread *thr = *i;
795       int_thread::State new_state = thr->getActiveState().getState();
796       if (new_state == int_thread::ditto)
797          new_state = thr->getHandlerState().getState();
798       thr->setTargetState(new_state);
799    }
800
801    //2)
802    for (int_threadPool::iterator i = tp->begin(); i != tp->end(); i++) {
803       int_thread *thr = *i;
804       if (!RUNNING_STATE(thr->getTargetState()))
805          continue;
806       if (thr->getActiveState().getID() == int_thread::PendingStopStateID) {
807          //A pending-stop-state continue isn't a real continue.  Don't throw
808          // new events.
809          continue;
810       }
811       thr->throwEventsBeforeContinue();
812    }
813    //3)
814    pthrd_printf("Checking if any ProcStop events on %d are ready\n", getPid());
815    getProcStopManager().checkEvents();
816    //4)
817    for (int_threadPool::iterator i = tp->begin(); i != tp->end(); i++) {
818       int_thread *thr = *i;
819       int_thread::State new_state = thr->getActiveState().getState();
820       if (new_state == int_thread::ditto)
821          new_state = thr->getHandlerState().getState();
822       thr->setTargetState(new_state);
823    }
824    if (dyninst_debug_proccontrol) {
825       pc_print_lock();
826       pthrd_printf("Current Threading State for %d:\n", getPid());
827       for (int_threadPool::iterator i = tp->begin(); i != tp->end(); i++) {
828          int_thread *thr = *i;
829          int_thread::StateTracker &target = thr->getActiveState();
830          
831          char state_code[int_thread::NumStateIDs+1];
832          for (int i = 0; i < int_thread::NumStateIDs; i++) {
833             state_code[i] = int_thread::stateLetter(thr->getStateByID(i).getState());
834          }
835          state_code[int_thread::NumStateIDs] = '\0';
836          pthrd_printf("%d/%d hand: %s, gen: %s, %s: %s, code: %s\n",
837                       getPid(), thr->getLWP(), 
838                       int_thread::stateStr(thr->getHandlerState().getState()),
839                       int_thread::stateStr(thr->getGeneratorState().getState()),
840                       int_thread::stateIDToName(target.getID()).c_str(),
841                       int_thread::stateStr(target.getState()),
842                       state_code);
843       }
844           if(tp->empty())
845           {
846                   pthrd_printf("Threadpool for %d is empty\n", getPid());
847           }
848      pc_print_unlock();
849    }
850
851    pthrd_printf("Running plat_syncRunState on %d\n", getPid());
852    bool result = plat_syncRunState();
853
854    return result;
855 }
856
857 bool int_process::waitForAsyncEvent(response::ptr resp)
858 {
859   if (resp) {
860     int_process *proc = resp->getProcess();
861     if (proc)
862        proc->plat_preAsyncWait();
863   }
864   return getResponses().waitFor(resp);
865 }
866
867 bool int_process::waitForAsyncEvent(std::set<response::ptr> resp)
868 {
869    for (set<response::ptr>::iterator i = resp.begin(); i != resp.end(); i++) {
870      response::ptr r = *i;
871      if (!r)
872        continue;
873      int_process *proc = r->getProcess();
874      assert(proc);
875      proc->plat_preAsyncWait();
876    }
877
878    bool has_error = false;
879    for (set<response::ptr>::iterator i = resp.begin(); i != resp.end(); i++) {
880       bool result = getResponses().waitFor(*i);
881       if (!result)
882          has_error = true;
883    }
884
885    return !has_error;
886 }
887
888 Counter &int_process::asyncEventCount()
889 {
890    return async_event_count;
891 }
892
893 Counter &int_process::getForceGeneratorBlockCount()
894 {
895    return force_generator_block_count;
896 }
897
898 Counter &int_process::getStartupTeardownProcs()
899 {
900    return startupteardown_procs;
901 }
902
903 bool int_process::plat_waitAndHandleForProc()
904 {
905   return true;
906 }
907
908 int_process *int_process::in_waitHandleProc = NULL;
909 bool int_process::waitAndHandleForProc(bool block, int_process *proc, bool &proc_exited)
910 {
911    assert(in_waitHandleProc == NULL);
912    in_waitHandleProc = proc;
913
914    if (!proc->plat_waitAndHandleForProc()) {
915      perr_printf("Failed platform specific waitAndHandle for %d\n", proc->getPid());
916      return false;
917    }
918
919    bool result = waitAndHandleEvents(block);
920
921    if (proc->getState() == int_process::exited) {
922       pthrd_printf("Deleting proc %d from waitAndHandleForProc\n", proc->getPid());
923       delete proc;
924       proc_exited = true;
925    }
926    else {
927       proc_exited = false;
928    }
929
930    in_waitHandleProc = NULL;
931    return result;
932 }
933
934 #define checkHandlerThread      (hasHandlerThread      = (int) isHandlerThread())
935 #define checkBlock              (hasBlock              = (int) block)
936 #define checkGotEvent           (hasGotEvent           = (int) gotEvent)
937 #define checkAsyncPending       (hasAsyncPending       = (int) HandlerPool::hasProcAsyncPending())
938 #define checkRunningThread      (hasRunningThread      = (int) Counter::global(Counter::HandlerRunningThreads))
939 #define checkClearingBP         (hasClearingBP         = (int) Counter::global(Counter::ClearingBPs))
940 #define checkStopPending        (hasStopPending        = (int) Counter::global(Counter::PendingStops))
941 #define checkSyncRPCRunningThrd (hasSyncRPCRunningThrd = (int) Counter::global(Counter::SyncRPCRunningThreads))
942 #define checkProcStopRPC        (hasProcStopRPC        = (int) Counter::global(Counter::ProcStopRPCs))
943 #define checkStartupTeardownProcs (hasStartupTeardownProc = (int) Counter::global(Counter::StartupTeardownProcesses))
944 #define checkNeonatalThreads     (hasNeonatalThreads   = (int) Counter::global(Counter::NeonatalThreads))
945 #define UNSET_CHECK        -8
946 #define printCheck(VAL)    (((int) VAL) == UNSET_CHECK ? '?' : (VAL ? 'T' : 'F'))
947
948 bool int_process::waitAndHandleEvents(bool block)
949 {
950    pthrd_printf("Top of waitAndHandleEvents.  Block = %s\n", block ? "true" : "false");
951    bool gotEvent = false;
952    assert(!int_process::in_callback);
953    bool error = false;
954
955    static bool recurse = false;
956    assert(!recurse);
957    recurse = true;
958
959    for (;;)
960    {
961       /**
962        * Check for possible blocking combinations using Counters
963        *
964        * The weirdness in the #defines and variables here is to record the result of
965        * each check, which is used if debug printing is turned on, while also letting the 
966        * C++ partial evaluator not check parts this expression (as the checks involve an 
967        * expensive locking operation).  
968        *
969        * For most people, just ignore the #defines.  The important bit is that we're really
970        * calling the Counter::global(...) function to determine whether we should block.
971        **/
972       int hasHandlerThread = UNSET_CHECK, hasAsyncPending = UNSET_CHECK, hasRunningThread = UNSET_CHECK;
973       int hasClearingBP = UNSET_CHECK, hasStopPending = UNSET_CHECK, hasSyncRPCRunningThrd = UNSET_CHECK;
974       int hasProcStopRPC  = UNSET_CHECK, hasBlock = UNSET_CHECK, hasGotEvent = UNSET_CHECK;
975       int hasStartupTeardownProc = UNSET_CHECK, hasNeonatalThreads = UNSET_CHECK;
976
977       bool should_block = (!checkHandlerThread && 
978                            ((checkBlock && !checkGotEvent && checkRunningThread) ||
979                             (checkSyncRPCRunningThrd) ||
980                             (checkStopPending) ||
981                             (checkClearingBP) ||
982                             (checkProcStopRPC) ||
983                             (checkAsyncPending) ||
984                             (checkStartupTeardownProcs) ||
985                             (checkNeonatalThreads)
986                            )
987                           );
988       //Entry for this print match the above tests in order and one-for-one.
989       pthrd_printf("%s for events = !%c && ((%c && !%c && %c) || %c || %c || %c || %c || %c || %c || %c)\n",
990                    should_block ? "Blocking" : "Polling",
991                    printCheck(hasHandlerThread),
992                    printCheck(hasBlock), printCheck(hasGotEvent), printCheck(hasRunningThread), 
993                    printCheck(hasSyncRPCRunningThrd), 
994                    printCheck(hasStopPending),
995                    printCheck(hasClearingBP), 
996                    printCheck(hasProcStopRPC),
997                    printCheck(hasAsyncPending),
998                    printCheck(hasStartupTeardownProc),
999                    printCheck(hasNeonatalThreads));
1000
1001       //TODO: If/When we move to per-process locks, then we'll need a smarter should_block check
1002       //      We don't want the should_block changing between the above measurement
1003       //      and the below dequeue.  Perhaps dequeue should alway poll, and the user thread loops
1004       //      over it while (should_block == true), with a condition variable signaling when the 
1005       //      should_block would go to false (so we don't just spin).
1006
1007       if (should_block && Counter::globalCount(Counter::ForceGeneratorBlock)) {
1008          // Entirely possible we didn't continue anything, but we want the generator to 
1009          // wake up anyway
1010          ProcPool()->condvar()->broadcast();
1011       }
1012          
1013       Event::ptr ev = mbox()->dequeue(should_block);
1014
1015       if (ev == Event::ptr())
1016       {
1017          if (gotEvent) {
1018             pthrd_printf("Returning after handling events\n");
1019             goto done;
1020          }
1021          if (should_block) {
1022             perr_printf("Blocking wait failed to get events\n");
1023             ProcControlAPI::globalSetLastError(err_internal, "Blocking wait returned without events");
1024             error = true;
1025             goto done;
1026          }
1027          if (hasHandlerThread) {
1028             pthrd_printf("Handler thread found nothing to do\n");
1029             goto done;
1030          }
1031          if (!hasRunningThread) {
1032             pthrd_printf("No threads are running to produce events\n");
1033             ProcControlAPI::globalSetLastError(err_notrunning, "No threads are running to produce events\n");
1034             error = true;
1035             goto done;
1036          }
1037
1038          ProcControlAPI::globalSetLastError(err_noevents, "Poll failed to find events");
1039          pthrd_printf("Poll failed to find events\n");
1040          error = true;
1041          goto done;
1042       }
1043       if (mt()->getThreadMode() == Process::NoThreads ||
1044           mt()->getThreadMode() == Process::GeneratorThreading) 
1045       {
1046          pthrd_printf("Clearing event from pipe after dequeue\n");
1047          notify()->clearEvent();
1048       }
1049
1050       gotEvent = true;
1051
1052 #if defined(os_linux)
1053       // Linux is bad about enforcing event ordering, and so we will get 
1054       // thread events after a process has exited.
1055 //      bool terminating = (ev->getProcess()->isTerminated()) ||
1056 //         (ev->getProcess()->llproc() && ev->getProcess()->llproc()->wasForcedTerminated());
1057       bool terminating = (ev->getProcess()->isTerminated());
1058
1059       bool exitEvent = (ev->getEventType().time() == EventType::Post &&
1060                         ev->getEventType().code() == EventType::Exit);
1061       if (terminating && !exitEvent) {
1062          // Since the user will never handle this one...
1063         pthrd_printf("Received event %s on terminated process, ignoring\n",
1064                      ev->name().c_str());
1065         if (!isHandlerThread() && ev->noted_event) notify()->clearEvent();
1066         continue;
1067       }
1068 #endif
1069
1070       int_process* llp = ev->getProcess()->llproc();
1071       if(!llp) {
1072          error = true;
1073          goto done;
1074       }
1075
1076       Process::const_ptr proc = ev->getProcess();
1077       int_process *llproc = proc->llproc();
1078       if (!llproc) {
1079          //Seen on Linux--a event comes in on an exited process because the kernel
1080          // doesn't synchronize events across threads.  We thus get a thread exit
1081          // event after a process exit event.  Just drop this event on the
1082          // floor.
1083          pthrd_printf("Dropping %s event from process %d due to process already exited\n",
1084                       ev->getEventType().name().c_str(), proc->getPid());
1085          continue;
1086       }
1087       HandlerPool *hpool = llproc->handlerpool;
1088
1089       if (!ev->handling_started) {
1090          llproc->updateSyncState(ev, false);
1091          llproc->noteNewDequeuedEvent(ev);
1092          ev->handling_started = true;
1093       }
1094
1095       llproc->plat_preHandleEvent();
1096
1097       bool should_handle_ev = llproc->getProcStopManager().prepEvent(ev);
1098       if (should_handle_ev) {
1099          hpool->handleEvent(ev);
1100       }
1101     
1102       llproc = proc->llproc();
1103
1104       if (llproc) {
1105          bool result = llproc->syncRunState();
1106          if (!result) {
1107             pthrd_printf("syncRunState failed.  Returning error from waitAndHandleEvents\n");
1108             error = true;
1109             goto done;
1110          }
1111          llproc->plat_postHandleEvent();
1112       }
1113       else
1114       {
1115          //Special case event handling, the process cleaned itself
1116          // under this event (likely post-exit or post-crash), but was 
1117          // unable to clean its handlerpool (as we were using it).  
1118          // Clean this for the process now.
1119                         pthrd_printf("Process is gone, skipping syncRunState and deleting handler pool\n");
1120                   delete hpool;
1121       }
1122    }
1123   done:
1124    pthrd_printf("Leaving WaitAndHandleEvents 'cause we're done\n");
1125    recurse = false;
1126    return !error;
1127 }
1128
1129 void int_process::throwDetachEvent(bool temporary, bool leaveStopped)
1130 {
1131    pthrd_printf("%s detaching from process %d\n", temporary ? "Temporary" : "Permanent", getPid());
1132    EventDetach::ptr detach_ev = EventDetach::ptr(new EventDetach());
1133    detach_ev->getInternal()->temporary_detach = temporary;
1134    detach_ev->getInternal()->leave_stopped = leaveStopped;
1135    detach_ev->setProcess(proc());
1136    detach_ev->setThread(threadPool()->initialThread()->thread());
1137    detach_ev->setSyncType(Event::async);
1138    
1139    getStartupTeardownProcs().inc();
1140    threadPool()->initialThread()->getDetachState().desyncStateProc(int_thread::stopped);
1141    
1142    mbox()->enqueue(detach_ev);
1143 }
1144
1145 bool int_process::plat_detachDone() {
1146    return true;
1147 }
1148
1149 bool int_process::terminate(bool &needs_sync)
1150 {
1151    
1152    //Should be called with the ProcPool lock held.
1153    pthrd_printf("Terminate requested on process %d\n", getPid());
1154    getStartupTeardownProcs().inc();
1155
1156    bool result = plat_terminate(needs_sync);
1157    if (!result) {
1158       pthrd_printf("plat_terminate failed on %d\n", getPid());
1159       return false;
1160    }
1161    forcedTermination = true;
1162
1163         // On windows this leads to doubling up events
1164 #if defined(os_windows) 
1165    // If we're on windows, we want to force the generator thread into waiting for a debug
1166    // event _if the process is stopped_. If the process is running then we're already
1167    // waiting (or will wait) for a debug event, and forcing the generator to block may
1168    // lead to doubling up. 
1169    
1170    // The following code is similar to GeneratorWindows::hasLiveProc. This is not a coincidence.
1171         bool all_stopped = true;
1172    for (int_threadPool::iterator iter = threadpool->begin(); iter != threadpool->end(); ++iter) {
1173                 if (RUNNING_STATE((*iter)->getActiveState().getState())) {
1174                         all_stopped = false;
1175                         break;
1176                 }
1177    }
1178    if (all_stopped) {
1179            setForceGeneratorBlock(true);
1180    }
1181 #else
1182    // Do it all the time
1183    setForceGeneratorBlock(true);
1184 #endif
1185
1186    return true;
1187 }
1188
1189 bool int_process::preTerminate() {
1190     return true;
1191 }
1192
1193 int_libraryTracking *int_process::getLibraryTracking()
1194 {
1195    if (LibraryTracking_set)
1196       return pLibraryTracking;
1197    LibraryTracking_set = true;
1198    pLibraryTracking = dynamic_cast<int_libraryTracking *>(this);
1199    if (!pLibraryTracking)
1200       return NULL;
1201    if (!pLibraryTracking->up_ptr)
1202       pLibraryTracking->up_ptr = new LibraryTracking(proc());
1203    return pLibraryTracking;
1204 }
1205
1206 int_LWPTracking *int_process::getLWPTracking()
1207 {
1208    if (LWPTracking_set)
1209       return pLWPTracking;
1210    LWPTracking_set = true;
1211    pLWPTracking = dynamic_cast<int_LWPTracking *>(this);
1212    if (!pLWPTracking)
1213       return NULL;
1214    if (!pLWPTracking->up_ptr)
1215       pLWPTracking->up_ptr = new LWPTracking(proc());
1216    return pLWPTracking;
1217 }
1218
1219 int_threadTracking *int_process::getThreadTracking()
1220 {
1221    if (ThreadTracking_set)
1222       return pThreadTracking;
1223    ThreadTracking_set = true;
1224    pThreadTracking = dynamic_cast<int_threadTracking *>(this);
1225    if (!pThreadTracking)
1226       return NULL;
1227    if (!pThreadTracking->up_ptr)
1228       pThreadTracking->up_ptr = new ThreadTracking(proc());
1229    return pThreadTracking;
1230 }
1231
1232 int_followFork *int_process::getFollowFork()
1233 {
1234    if (FollowFork_set)
1235       return pFollowFork;
1236    FollowFork_set = true;
1237    pFollowFork = dynamic_cast<int_followFork *>(this);
1238    if (!pFollowFork)
1239       return NULL;
1240    if (!pFollowFork->up_ptr)
1241       pFollowFork->up_ptr = new FollowFork(proc());
1242    return pFollowFork;
1243 }
1244
1245 int_callStackUnwinding *int_process::getCallStackUnwinding()
1246 {
1247    if (CallStackUnwinding_set)
1248       return pCallStackUnwinding;
1249    CallStackUnwinding_set = true;
1250    pCallStackUnwinding = dynamic_cast<int_callStackUnwinding *>(this);
1251    return pCallStackUnwinding;
1252 }
1253
1254 int_multiToolControl *int_process::getMultiToolControl()
1255 {
1256    if (MultiToolControl_set)
1257       return pMultiToolControl;
1258    MultiToolControl_set = true;
1259    pMultiToolControl = dynamic_cast<int_multiToolControl *>(this);
1260    if (!pMultiToolControl)
1261       return NULL;
1262    if (!pMultiToolControl->up_ptr)
1263       pMultiToolControl->up_ptr = new MultiToolControl(proc());
1264    return pMultiToolControl;
1265 }
1266
1267 int_signalMask *int_process::getSignalMask()
1268 {
1269    if (SignalMask_set)
1270       return pSignalMask;
1271    SignalMask_set = true;
1272    pSignalMask = dynamic_cast<int_signalMask *>(this);
1273    if (!pSignalMask)
1274       return NULL;
1275    if (!pSignalMask->up_ptr)
1276       pSignalMask->up_ptr = new SignalMask(proc());
1277    return pSignalMask;
1278 }
1279
1280 int_BGQData *int_process::getBGQData() 
1281 {
1282    if (BGQData_set)
1283       return pBGQData;
1284    BGQData_set = true;
1285    pBGQData = dynamic_cast<int_BGQData *>(this);
1286    if (!pBGQData)
1287       return NULL;
1288    if (!pBGQData->up_ptr)
1289       pBGQData->up_ptr = new BGQData(proc());
1290    return pBGQData;
1291 }
1292
1293 int_remoteIO *int_process::getRemoteIO()
1294 {
1295    if (remoteIO_set)
1296       return pRemoteIO;
1297    remoteIO_set = true;
1298    pRemoteIO = dynamic_cast<int_remoteIO *>(this);
1299    if (!pRemoteIO)
1300       return NULL;
1301    if (!pRemoteIO->up_ptr)
1302       pRemoteIO->up_ptr = new RemoteIO(proc());
1303    return pRemoteIO;
1304 }
1305
1306 int_process::int_process(Dyninst::PID p, std::string e,
1307                          std::vector<std::string> a,
1308                          std::vector<std::string> envp,
1309                          std::map<int,int> f) :
1310    state(neonatal),
1311    pid(p),
1312    creation_mode(ct_launch),
1313    executable(e),
1314    argv(a),
1315    env(envp),
1316    fds(f),
1317    arch(Dyninst::Arch_none),
1318    threadpool(NULL),
1319    up_proc(Process::ptr()),
1320    handlerpool(NULL),
1321    hasCrashSignal(false),
1322    crashSignal(0),
1323    hasExitCode(false),
1324    forcedTermination(false),
1325    silent_mode(false),
1326    exitCode(0),
1327    mem(NULL),
1328    continueSig(0),
1329    mem_cache(this),
1330    async_event_count(Counter::AsyncEvents),
1331    force_generator_block_count(Counter::ForceGeneratorBlock),
1332    startupteardown_procs(Counter::StartupTeardownProcesses),
1333    proc_stop_manager(this),
1334    user_data(NULL),
1335    last_error_string(NULL),
1336    symbol_reader(NULL),
1337    pLibraryTracking(NULL),
1338    pLWPTracking(NULL),
1339    pThreadTracking(NULL),
1340    pFollowFork(NULL),
1341    pMultiToolControl(NULL),
1342    pSignalMask(NULL),
1343    pCallStackUnwinding(NULL),
1344    pBGQData(NULL),
1345    LibraryTracking_set(false),
1346    LWPTracking_set(false),
1347    ThreadTracking_set(false),
1348    FollowFork_set(false),
1349    MultiToolControl_set(false),
1350    SignalMask_set(false),
1351    CallStackUnwinding_set(false),
1352    BGQData_set(false),
1353    remoteIO_set(false)
1354 {
1355    pthrd_printf("New int_process at %p\n", this);
1356    clearLastError();
1357         wasCreatedViaAttach(pid == 0);
1358    //Put any object initialization in 'initializeProcess', below.
1359 }
1360
1361 int_process::int_process(Dyninst::PID pid_, int_process *p) :
1362    state(int_process::running),
1363    pid(pid_),
1364    creation_mode(ct_attach),
1365    executable(p->executable),
1366    argv(p->argv),
1367    env(p->env),
1368    arch(p->arch),
1369    hasCrashSignal(p->hasCrashSignal),
1370    crashSignal(p->crashSignal),
1371    hasExitCode(p->hasExitCode),
1372    forcedTermination(false),
1373    silent_mode(false),
1374    exitCode(p->exitCode),
1375    exec_mem_cache(exec_mem_cache),
1376    continueSig(p->continueSig),
1377    mem_cache(this),
1378    async_event_count(Counter::AsyncEvents),
1379    force_generator_block_count(Counter::ForceGeneratorBlock),
1380    startupteardown_procs(Counter::StartupTeardownProcesses),
1381    proc_stop_manager(this),
1382    user_data(NULL),
1383    last_error_string(NULL),
1384    symbol_reader(NULL),
1385    pLibraryTracking(NULL),
1386    pLWPTracking(NULL),
1387    pThreadTracking(NULL),
1388    pFollowFork(NULL),
1389    pMultiToolControl(NULL),
1390    pSignalMask(NULL),
1391    pCallStackUnwinding(NULL),
1392    pBGQData(NULL),
1393    pRemoteIO(NULL),
1394    LibraryTracking_set(false),
1395    LWPTracking_set(false),
1396    ThreadTracking_set(false),
1397    FollowFork_set(false),
1398    MultiToolControl_set(false),
1399    SignalMask_set(false),
1400    CallStackUnwinding_set(false),
1401    BGQData_set(false),
1402    remoteIO_set(false)
1403 {
1404    pthrd_printf("New int_process at %p\n", this);
1405    Process::ptr hlproc = Process::ptr(new Process());
1406    clearLastError();
1407    mem = new mem_state(*p->mem, this);
1408    initializeProcess(hlproc);
1409 }
1410
1411 void int_process::initializeProcess(Process::ptr p)
1412 {
1413    assert(!p->llproc_);
1414    p->llproc_ = this;
1415    up_proc = p;
1416    threadpool = new int_threadPool(this);
1417    handlerpool = createDefaultHandlerPool(this);
1418    libpool.proc = this;
1419    if (!mem)
1420       mem = new mem_state(this);
1421    Generator::getDefaultGenerator(); //May create generator thread
1422 }
1423
1424 int_thread *int_process::findStoppedThread()
1425 {
1426    int_thread *result = NULL;
1427    for (int_threadPool::iterator i = threadpool->begin(); i != threadpool->end(); ++i)
1428    {
1429       int_thread *thr = *i;
1430       if (thr->getHandlerState().getState() == int_thread::stopped) {
1431          result = thr;
1432          break;
1433       }
1434    }   
1435    return result;
1436 }
1437
1438 bool int_process::readMem(Dyninst::Address remote, mem_response::ptr result, int_thread *thr)
1439 {
1440    if (getAddressWidth() == 4) {
1441       Address old = remote;
1442       remote &= 0xffffffff;
1443       pthrd_printf("Address cropping for 32-bit: 0x%lx to 0x%lx\n",
1444                    old, remote);
1445    }
1446    
1447    if (!thr && plat_needsThreadForMemOps())
1448    {
1449       thr = findStoppedThread();
1450       if (!thr) {
1451          setLastError(err_notstopped, "A thread must be stopped to read from memory");
1452          perr_printf("Unable to find a stopped thread for read in process %d\n", getPid());
1453          return false;
1454       }
1455    }
1456
1457    result->setProcess(this);
1458    bool bresult;
1459
1460
1461    if (!plat_needsAsyncIO()) {
1462       pthrd_printf("Reading from remote memory %lx to %p, size = %lu on %d/%d\n",
1463                    remote, result->getBuffer(), (unsigned long) result->getSize(),
1464                                    getPid(), thr ? thr->getLWP() : (Dyninst::LWP)(-1));
1465
1466       bresult = plat_readMem(thr, result->getBuffer(), remote, result->getSize());
1467       if (!bresult) {
1468          result->markError();
1469       }
1470       result->setResponse();
1471
1472       int_eventAsyncIO *iev = result->getAsyncIOEvent();
1473       if (iev) {
1474          pthrd_printf("Enqueueing new EventAsyncRead into mailbox on synchronous platform\n");
1475          EventAsyncRead::ptr ev = EventAsyncRead::ptr(new EventAsyncRead(iev));
1476          ev->setProcess(proc());
1477          ev->setThread(threadPool()->initialThread()->thread());
1478          ev->setSyncType(Event::async);
1479          mbox()->enqueue(ev);
1480       }
1481    }
1482    else {
1483       pthrd_printf("Async read from remote memory %lx to %p, size = %lu on %d/%d\n",
1484                    remote, result->getBuffer(), (unsigned long) result->getSize(), 
1485                    getPid(), thr ? thr->getLWP() : (Dyninst::LWP)(-1));
1486
1487       getResponses().lock();
1488       bresult = plat_readMemAsync(thr, remote, result);
1489       if (bresult) {
1490          getResponses().addResponse(result, this);
1491       }
1492       getResponses().unlock();
1493       getResponses().noteResponse();
1494    }
1495    return bresult;
1496 }
1497
1498 bool int_process::writeMem(const void *local, Dyninst::Address remote, size_t size, result_response::ptr result, int_thread *thr, bp_write_t bp_write)
1499 {
1500    if (getAddressWidth() == 4) {
1501       Address old = remote;
1502       remote &= 0xffffffff;
1503       pthrd_printf("Address cropping for 32-bit: 0x%lx to 0x%lx\n",
1504                    old, remote);
1505    }
1506    
1507    if (!thr && plat_needsThreadForMemOps()) 
1508    {
1509       thr = findStoppedThread();
1510       if (!thr) {
1511          setLastError(err_notstopped, "A thread must be stopped to write to memory");
1512          perr_printf("Unable to find a stopped thread for write in process %d\n", getPid());
1513          return false;
1514       }
1515    }
1516    result->setProcess(this);
1517    bool bresult;
1518    if (!plat_needsAsyncIO()) {
1519       pthrd_printf("Writing to remote memory %lx from %p, size = %lu on %d/%d\n",
1520                    remote, local, (unsigned long) size,
1521                    getPid(), thr ? thr->getLWP() : (Dyninst::LWP)(-1));
1522       bresult = plat_writeMem(thr, local, remote, size, bp_write);
1523       if (!bresult) {
1524          result->markError();
1525       }
1526       result->setResponse(bresult);
1527
1528       int_eventAsyncIO *iev = result->getAsyncIOEvent();
1529       if (iev) {
1530          pthrd_printf("Enqueueing new EventAsyncWrite into mailbox on synchronous platform\n");
1531          EventAsyncWrite::ptr ev = EventAsyncWrite::ptr(new EventAsyncWrite(iev));
1532          ev->setProcess(proc());
1533          ev->setThread(threadPool()->initialThread()->thread());
1534          ev->setSyncType(Event::async);
1535          mbox()->enqueue(ev);
1536       }
1537    }
1538    else {
1539       pthrd_printf("Async writing to remote memory %lx from %p, size = %lu on %d/%d\n",
1540                    remote, local, (unsigned long) size,
1541                    getPid(), thr ? thr->getLWP() : (Dyninst::LWP)(-1));
1542
1543       getResponses().lock();
1544       bresult = plat_writeMemAsync(thr, local, remote, size, result, bp_write);
1545       if (bresult) {
1546          getResponses().addResponse(result, this);
1547       }
1548       getResponses().unlock();
1549       getResponses().noteResponse();
1550    }
1551    return bresult;
1552 }
1553
1554 unsigned int_process::plat_getRecommendedReadSize()
1555 {
1556    return getTargetPageSize();
1557 }
1558
1559 Dyninst::Address int_process::mallocExecMemory(unsigned size)
1560 {
1561    Dyninst::Address max = 0;
1562    std::map<Dyninst::Address, unsigned>::iterator i;
1563    for (i = exec_mem_cache.begin(); i != exec_mem_cache.end(); ++i) {
1564       if (i->first + i->second > max)
1565          max = i->first + i->second;
1566    }
1567
1568    Dyninst::Address addr = plat_mallocExecMemory(max, size);
1569    exec_mem_cache[addr] = size;
1570    return addr;
1571 }
1572
1573 void int_process::freeExecMemory(Dyninst::Address addr)
1574 {
1575    std::map<Dyninst::Address, unsigned>::iterator i;
1576    i = exec_mem_cache.find(addr);
1577    assert(i != exec_mem_cache.end());
1578    exec_mem_cache.erase(i);
1579 }
1580
1581 Dyninst::Address int_process::direct_infMalloc(unsigned long, bool, Dyninst::Address) 
1582 {
1583    assert(0);
1584    return 0;
1585 }
1586
1587 bool int_process::direct_infFree(Dyninst::Address)
1588 {
1589    assert(0);
1590    return false;
1591 }
1592
1593 bool int_process::infMalloc(unsigned long size, int_addressSet *aset, bool use_addr)
1594 {
1595    bool had_error = false;
1596    set<pair<int_process *, int_iRPC::ptr> > active_mallocs;
1597    int_addressSet direct_results;
1598
1599    for (int_addressSet::iterator i = aset->begin(); i != aset->end(); i++) {
1600       Process::ptr p = i->second;
1601       Address addr = i->first;
1602       if (!p)
1603          continue;
1604       int_process *proc = p->llproc();
1605       if (proc->getState() == int_process::detached)
1606          continue;
1607       pthrd_printf("Process %d is allocating memory of size %lu at 0x%lx\n", proc->getPid(), size, addr);
1608       
1609       if (proc->plat_supportDirectAllocation()) {
1610          //Platforms like Windows don't need IRPCs for allocation.  Just do it and put the results
1611          // in direct_results, which will be unioned with aset latter.
1612          Dyninst::Address addr_result = proc->direct_infMalloc(size, use_addr, addr);
1613          if (addr_result == 0) {
1614             had_error = true;
1615             continue;
1616          }
1617          direct_results.insert(make_pair(addr_result, p));
1618          continue;
1619       }
1620
1621       int_iRPC::ptr rpc = rpcMgr()->createInfMallocRPC(proc, size, use_addr, addr);
1622       assert(rpc);
1623       bool result = rpcMgr()->postRPCToProc(proc, rpc);
1624       if (!result) {
1625          p->setLastError(err_internal, "Error posting infMalloc RPC to process\n");
1626          pthrd_printf("Error posting RPC to thread");
1627          had_error = true;
1628          continue;
1629       }
1630       
1631       int_thread *thr = rpc->thread();
1632       assert(thr);
1633       active_mallocs.insert(make_pair(proc, rpc));
1634       thr->getInternalState().desyncState(int_thread::running);
1635       rpc->setRestoreInternal(true);
1636       proc->throwNopEvent();
1637    }
1638
1639    if (!active_mallocs.empty()) {
1640       bool result = int_process::waitAndHandleEvents(false);
1641       if (!result) {
1642          perr_printf("Internal error calling waitAndHandleEvents\n");
1643          for_each(aset->begin(), aset->end(), 
1644                   setError(err_internal, "Error while calling waitAndHandleForProc from infMalloc\n"));
1645          return false;
1646       }
1647    }
1648
1649    if (!use_addr)
1650       aset->clear();
1651    if (!direct_results.empty())
1652       aset->insert(direct_results.begin(), direct_results.end());
1653
1654
1655    for (set<pair<int_process *, int_iRPC::ptr> >::iterator i = active_mallocs.begin(); 
1656         i != active_mallocs.end(); i++)
1657    {
1658       int_process *proc = i->first;
1659       int_iRPC::ptr rpc = i->second;
1660       assert(rpc->getState() == int_iRPC::Finished);
1661       Dyninst::Address aresult = rpc->infMallocResult();
1662       pthrd_printf("Inferior malloc returning %lx on %d\n", aresult, proc->getPid());
1663       if (aresult == (unsigned long) -1) {
1664          perr_printf("infMalloc returned invalid address\n");
1665          proc->setLastError(err_procread, "Unable to allocate memory at given address");
1666          had_error = true;
1667          continue;
1668       }
1669       proc->memory()->inf_malloced_memory.insert(make_pair(aresult, size));
1670       if (use_addr)
1671          continue;
1672       aset->insert(make_pair(aresult, proc->proc()));
1673    }
1674
1675    return !had_error;
1676 }
1677
1678 bool int_process::infFree(int_addressSet *aset)
1679 {
1680    bool had_error = false;
1681    set<pair<Process::ptr, int_iRPC::ptr> > active_frees;
1682
1683    for (int_addressSet::iterator i = aset->begin(); i != aset->end(); i++) {
1684       Address addr = i->first;
1685       Process::ptr p = i->second;
1686       if (!p) {
1687          had_error = true;
1688          continue;
1689       }
1690       int_process *proc = p->llproc();
1691       if (!proc || proc->getState() == int_process::detached) {
1692          had_error = true;
1693          continue;
1694       }
1695
1696       std::map<Dyninst::Address, unsigned long>::iterator j = proc->mem->inf_malloced_memory.find(addr);
1697       if (j == proc->mem->inf_malloced_memory.end()) {
1698          proc->setLastError(err_badparam, "Unknown address passed to freeMemory");
1699          perr_printf("Passed bad address, %lx, to infFree on %d\n", addr, proc->getPid());
1700          had_error = true;
1701          continue;
1702       }
1703       unsigned long size = j->second;
1704
1705       if (proc->plat_supportDirectAllocation()) {
1706          bool result = proc->direct_infFree(addr);
1707          if (!result)
1708             had_error = true;
1709          continue;
1710       }
1711
1712       int_iRPC::ptr rpc = rpcMgr()->createInfFreeRPC(proc, size, addr);
1713       assert(rpc);
1714       pthrd_printf("Process %d is freeing memory of size %lu at 0x%lx with rpc %lu\n", proc->getPid(),
1715                    size, addr, rpc->id());
1716       bool result = rpcMgr()->postRPCToProc(proc, rpc);
1717       if (!result) {
1718          pthrd_printf("Failed to post free rpc to process\n");
1719          had_error = true;
1720          continue;
1721       }
1722
1723       int_thread *thr = rpc->thread();
1724       assert(thr);
1725       thr->getInternalState().desyncState(int_thread::running);
1726       rpc->setRestoreInternal(true);
1727       
1728       proc->throwNopEvent();
1729       active_frees.insert(make_pair(p, rpc));
1730    }
1731
1732    if (!active_frees.empty()) {
1733       bool result = int_process::waitAndHandleEvents(false);
1734       if (!result) {
1735          perr_printf("Internal error calling waitAndHandleEvents\n");
1736          for_each(aset->begin(), aset->end(), 
1737                   setError(err_internal, "Error while calling waitAndHandleForProc from infFree\n"));
1738          return false;
1739       }
1740    }
1741    
1742    for (set<pair<Process::ptr, int_iRPC::ptr> >::iterator i = active_frees.begin(); i != active_frees.end(); i++) {
1743       Process::ptr p = i->first;
1744       int_iRPC::ptr rpc = i->second;
1745       int_process *proc = p->llproc();
1746       
1747       if (!proc) {
1748          perr_printf("Process %d exited during infFree\n", p->getPid());
1749          p->setLastError(err_exited, "Process exited during infFree\n");
1750          had_error = true;
1751          continue;
1752       }
1753       assert(rpc->getState() == int_iRPC::Finished);
1754       Address addr = rpc->getInfFreeTarget();
1755       map<Dyninst::Address, unsigned long>::iterator j = proc->mem->inf_malloced_memory.find(addr);
1756       proc->mem->inf_malloced_memory.erase(j);
1757    }
1758
1759    return !had_error;
1760 }
1761
1762 bool int_process::plat_decodeMemoryRights(Process::mem_perm& rights_internal,
1763                                           unsigned long rights) {
1764     (void)rights_internal;
1765     (void)rights;
1766     perr_printf("Called decodeMemoryRights on unspported platform\n");
1767     setLastError(err_unsupported, "Decode Mem Permission not supported on this platform\n");
1768         return false;
1769 }
1770
1771 bool int_process::plat_encodeMemoryRights(Process::mem_perm rights_internal,
1772                                           unsigned long& rights) {
1773     (void)rights_internal;
1774     (void)rights;
1775     perr_printf("Called encodeMemoryRights on unspported platform\n");
1776     setLastError(err_unsupported, "Encode Memory Permission not supported on this platform\n");
1777         return false;
1778 }
1779
1780 bool int_process::getMemoryAccessRights(Dyninst::Address addr, size_t size,
1781                                         Process::mem_perm& rights) {
1782     if (!plat_getMemoryAccessRights(addr, size, rights)) {
1783         pthrd_printf("Error get rights from memory %lx on target process %d\n",
1784                      addr, getPid());
1785         return false;
1786     }
1787
1788     return true;
1789 }
1790
1791 bool int_process::plat_getMemoryAccessRights(Dyninst::Address addr, size_t size,
1792                                              Process::mem_perm& rights) {
1793     (void)addr;
1794     (void)size;
1795     (void)rights;
1796     perr_printf("Called getMemoryAccessRights on unspported platform\n");
1797     setLastError(err_unsupported, "Get Memory Permission not supported on this platform\n");
1798         return false;
1799 }
1800
1801 bool int_process::setMemoryAccessRights(Dyninst::Address addr, size_t size,
1802                                         Process::mem_perm rights,
1803                                         Process::mem_perm& oldRights) {
1804     if (!plat_setMemoryAccessRights(addr, size, rights, oldRights)) {
1805         pthrd_printf("ERROR: set rights to %s from memory %lx on target process %d\n",
1806                      rights.getPermName().c_str(), addr, getPid());
1807         return false;
1808     }
1809     
1810     return true;
1811 }
1812
1813 bool int_process::plat_setMemoryAccessRights(Dyninst::Address addr, size_t size,
1814                                              Process::mem_perm rights,
1815                                              Process::mem_perm& oldRights) {
1816     (void)addr;
1817     (void)size;
1818     (void)rights;
1819     (void)oldRights;
1820     perr_printf("Called setMemoryAccessRights on unspported platform\n");
1821     setLastError(err_unsupported, "Set Memory Permission not supported on this platform\n");
1822         return false;
1823 }
1824
1825 bool int_process::findAllocatedRegionAround(Dyninst::Address addr,
1826                                             Process::MemoryRegion& memRegion) {
1827     if (!plat_findAllocatedRegionAround(addr, memRegion)) {
1828         pthrd_printf("Error when find allocated memory region"
1829                      " for %lx on target process %d\n", addr, getPid());
1830         return false;
1831     }
1832
1833     return true;
1834 }
1835
1836 bool int_process::plat_findAllocatedRegionAround(Dyninst::Address addr,
1837                                                  Process::MemoryRegion& memRegion) {
1838     (void)addr;
1839     memRegion.first  = NULL;
1840     memRegion.second = NULL;
1841     perr_printf("Called findAllocatedRegionAround on unspported platform\n");
1842     setLastError(err_unsupported,
1843                  "Find Allocated Region Addr not supported on this platform\n");
1844         return false;
1845 }
1846
1847 SymbolReaderFactory *int_process::getSymReader()
1848 {
1849    if (symbol_reader) {
1850       return symbol_reader;
1851    }
1852    else if (user_set_symbol_reader) {
1853       symbol_reader = user_set_symbol_reader;
1854       return symbol_reader;
1855    }
1856    symbol_reader = plat_defaultSymReader();
1857    return symbol_reader;
1858 }
1859
1860 void int_process::setSymReader(SymbolReaderFactory *fact)
1861 {
1862    symbol_reader = fact;
1863 }
1864
1865 SymbolReaderFactory *int_process::plat_defaultSymReader()
1866 {
1867    //Default version of function for systems without symbol readers
1868    return NULL;
1869 }
1870
1871 void int_process::setForceGeneratorBlock(bool b)
1872 {
1873    if (b) {
1874       force_generator_block_count.inc();
1875    }
1876    else {
1877       if (force_generator_block_count.local())
1878          force_generator_block_count.dec();
1879    }
1880
1881    pthrd_printf("forceGeneratorBlock - Count is now %d/%d\n", 
1882                 force_generator_block_count.localCount(),
1883                 Counter::globalCount(Counter::ForceGeneratorBlock));
1884 }
1885
1886 int int_process::getAddressWidth()
1887 {
1888    switch (getTargetArch()) {
1889       case Arch_x86:
1890       case Arch_ppc32:
1891          return 4;
1892       case Arch_x86_64:
1893       case Arch_ppc64:
1894          return 8;
1895       case Arch_none:
1896          assert(0);
1897    }
1898    return 0;
1899 }
1900
1901 HandlerPool *int_process::handlerPool() const
1902 {
1903    return handlerpool;
1904 }
1905
1906 bool int_process::addBreakpoint_phase1(bp_install_state *is)
1907 {
1908    is->ibp = NULL;
1909    map<Address, sw_breakpoint *>::iterator i = mem->breakpoints.find(is->addr);
1910    is->do_install = (i == mem->breakpoints.end());
1911    if (!is->do_install) {
1912      is->ibp = i->second;
1913      assert(is->ibp && is->ibp->isInstalled());
1914      bool result = is->ibp->addToIntBreakpoint(is->bp, this);
1915      if (!result) {
1916        pthrd_printf("Failed to install new breakpoint\n");
1917        return false;
1918      }
1919      return true;
1920    }
1921
1922    is->ibp = new sw_breakpoint(mem, is->addr);
1923
1924    if (!is->ibp->checkBreakpoint(is->bp, this)) {
1925       pthrd_printf("Failed check breakpoint\n");
1926       delete is->ibp;
1927       is->ibp = NULL;
1928       return false;
1929    }
1930
1931    is->mem_resp = mem_response::createMemResponse();
1932    is->mem_resp->markSyncHandled();
1933    bool result = is->ibp->prepBreakpoint(this, is->mem_resp);
1934    if (!result) {
1935       pthrd_printf("Failed to prep breakpoint\n");
1936       delete is->ibp;
1937       return false;
1938    }
1939    return true;
1940 }
1941
1942 bool int_process::addBreakpoint_phase2(bp_install_state *is)
1943 {
1944    if (!is->do_install)
1945       return true;   
1946
1947    if (is->mem_resp->hasError()) {
1948       pthrd_printf("Error prepping breakpoint\n");
1949       delete is->ibp;
1950       return false;
1951    }
1952
1953    is->res_resp = result_response::createResultResponse();
1954    is->res_resp->markSyncHandled();
1955    bool result = is->ibp->insertBreakpoint(this, is->res_resp);
1956    if (!result) {
1957       pthrd_printf("Error writing new breakpoint\n");
1958       delete is->ibp;
1959       return false;
1960    }
1961    return true;
1962 }
1963
1964 bool int_process::addBreakpoint_phase3(bp_install_state *is)
1965 {
1966    if (!is->do_install)
1967       return true;
1968
1969    bool result = is->ibp->addToIntBreakpoint(is->bp, this);
1970    if (!result) {
1971       pthrd_printf("Failed to install new breakpoint\n");
1972       return false;
1973    }   
1974
1975    if (is->res_resp->hasError()) {
1976       pthrd_printf("Error writing new breakpoint\n");
1977       delete is->ibp;
1978       return false;
1979    }
1980    
1981    return true;
1982 }
1983
1984 bool int_process::addBreakpoint(Dyninst::Address addr, int_breakpoint *bp)
1985 {
1986    if (getState() != running) {
1987       perr_printf("Attempted to add breakpoint at %lx to exited process %d\n", addr, getPid());
1988       setLastError(err_exited, "Attempted to insert breakpoint into exited process\n");
1989       return false;
1990    }
1991
1992    bp_instance *instance = NULL;
1993    if (bp->isHW()) {
1994       instance = hw_breakpoint::create(this, bp, addr);
1995    }
1996    else {
1997       instance = sw_breakpoint::create(this, bp, addr);
1998    }
1999    return (instance != NULL);
2000 }
2001
2002 bool int_process::removeAllBreakpoints() {
2003    if (!mem) return true;
2004    bool ret = true;
2005
2006    for (std::map<Dyninst::Address, sw_breakpoint *>::iterator iter = mem->breakpoints.begin();
2007         iter != mem->breakpoints.end(); ++iter) {
2008       std::set<response::ptr> resps;
2009       if (!iter->second->uninstall(this, resps)) ret = false;
2010       assert(resps.empty());
2011    }
2012    return ret;
2013 }
2014
2015 bool int_process::removeBreakpoint(Dyninst::Address addr, int_breakpoint *bp, set<response::ptr> &resps)
2016 {
2017    pthrd_printf("Removing breakpoint at %lx in %d\n", addr, getPid());
2018    set<bp_instance *> bps_to_remove;
2019    map<Address, sw_breakpoint *>::iterator i = mem->breakpoints.find(addr);
2020    if (i != mem->breakpoints.end()) {
2021       sw_breakpoint *swbp = i->second;
2022       assert(swbp && swbp->isInstalled());
2023       if (swbp->containsIntBreakpoint(bp))
2024           bps_to_remove.insert(static_cast<bp_instance *>(swbp));
2025    }
2026    
2027    for (int_threadPool::iterator i = threadPool()->begin(); i != threadPool()->end(); i++) {
2028       int_thread *thr = *i;
2029       hw_breakpoint *hwbp = thr->getHWBreakpoint(addr);
2030       if (hwbp && hwbp->containsIntBreakpoint(bp)) {
2031          bps_to_remove.insert(static_cast<bp_instance *>(hwbp));
2032       }
2033    }
2034
2035    if (bps_to_remove.empty()) {
2036       perr_printf("Attempted to removed breakpoint that isn't installed\n");
2037       setLastError(err_notfound, "Tried to uninstall breakpoint that isn't installed.\n");
2038       return false;
2039    }
2040
2041    for (set<bp_instance *>::iterator i = bps_to_remove.begin(); i != bps_to_remove.end(); i++) {
2042       bool empty;
2043       bp_instance *ibp = *i;
2044       bool result = ibp->rmBreakpoint(this, bp, empty, resps);
2045       if (!result) {
2046          pthrd_printf("rmBreakpoint failed on breakpoint at %lx in %d\n", addr, getPid());
2047          return false;
2048       }
2049       if (empty) {
2050          delete ibp;
2051       }
2052    }
2053
2054    return true;
2055 }
2056
2057 sw_breakpoint *int_process::getBreakpoint(Dyninst::Address addr)
2058 {
2059    std::map<Dyninst::Address, sw_breakpoint *>::iterator  i = mem->breakpoints.find(addr);
2060    if (i == mem->breakpoints.end())
2061       return NULL;
2062    return i->second;
2063 }
2064
2065 int_library *int_process::getLibraryByName(std::string s) const
2066 {
2067         // Exact matches first, but find substring matches and return if unique.
2068         // TODO: is this the behavior we actually want?
2069         bool substring_unique = true;
2070         std::set<int_library*>::iterator substring_match = mem->libs.end();
2071    for (set<int_library *>::iterator i = mem->libs.begin(); 
2072         i != mem->libs.end(); ++i) 
2073    {
2074            std::string n = (*i)->getName();
2075       if (s == n)
2076          return *i;
2077           if((n.find(s) != std::string::npos)) {
2078                   if(substring_match == mem->libs.end()) {
2079                         substring_match = i;
2080                   }
2081                   else {
2082                         substring_unique = false;
2083                   }
2084           }
2085    }
2086         if(substring_match != mem->libs.end() && substring_unique)
2087         {
2088                 return *substring_match;
2089         }
2090    return NULL;
2091 }
2092
2093 unsigned int int_process::plat_getCapabilities()
2094 {
2095    return (Process::pc_read | Process::pc_write | Process::pc_irpc | Process::pc_control);
2096 }
2097
2098 Event::ptr int_process::plat_throwEventsBeforeContinue(int_thread *)
2099 {
2100    return Event::ptr();
2101 }
2102
2103 bool int_process::plat_threadOpsNeedProcStop() 
2104 {
2105    return false;
2106 }
2107
2108 size_t int_process::numLibs() const
2109 {
2110    return mem->libs.size();
2111 }
2112
2113 std::string int_process::getExecutable() const
2114 {
2115    return executable; //The name of the exec passed to PC
2116 }
2117
2118 bool int_process::isInCallback()
2119 {
2120    return in_callback;
2121 }
2122
2123 mem_state::ptr int_process::memory() const
2124 {
2125    return mem;
2126 }
2127
2128 err_t int_process::getLastError() {
2129    return last_error;
2130 }
2131
2132 const char *int_process::getLastErrorMsg() {
2133    return last_error_string;
2134 }
2135
2136 void int_process::clearLastError() {
2137    last_error = err_none;
2138    last_error_string = "ok";
2139 }
2140
2141 void int_process::setLastError(err_t err, const char *str) {
2142    last_error = err;
2143    last_error_string = str;
2144    ProcControlAPI::globalSetLastError(err, str);
2145 }
2146
2147 void int_process::setExitCode(int c)
2148 {
2149    assert(!hasCrashSignal);
2150    hasExitCode = true;
2151    exitCode = c;
2152 }
2153
2154 void int_process::setCrashSignal(int s)
2155 {
2156    assert(!hasExitCode);
2157    hasCrashSignal = true;
2158    crashSignal = s;
2159 }
2160
2161 bool int_process::getExitCode(int &c)
2162 {
2163    c = exitCode;
2164    return hasExitCode;
2165 }
2166
2167 bool int_process::getCrashSignal(int &s)
2168 {
2169    s = crashSignal;
2170    return hasCrashSignal;
2171 }
2172
2173 bool int_process::wasForcedTerminated() const
2174 {
2175    return forcedTermination;
2176 }
2177
2178 bool int_process::plat_individualRegRead()
2179 {
2180    return plat_individualRegAccess();
2181 }
2182
2183 bool int_process::plat_individualRegSet()
2184 {
2185    return plat_individualRegAccess();   
2186 }
2187
2188 bool int_process::isInCB()
2189 {
2190    return in_callback;
2191 }
2192
2193 void int_process::setInCB(bool b)
2194 {
2195    assert(in_callback == !b);
2196    in_callback = b;
2197 }
2198
2199 void int_process::throwNopEvent()
2200 {
2201    EventNop::ptr ev = EventNop::ptr(new EventNop());
2202    ev->setProcess(proc());
2203    ev->setThread(threadPool()->initialThread()->thread());
2204    ev->setSyncType(Event::async);
2205    
2206    mbox()->enqueue(ev);
2207 }
2208
2209 bool int_process::plat_needsAsyncIO() const
2210 {
2211    return false;
2212 }
2213
2214 bool int_process::plat_readMemAsync(int_thread *, Dyninst::Address, 
2215                                     mem_response::ptr )
2216 {
2217    assert(0);
2218    return false;
2219 }
2220
2221 bool int_process::plat_writeMemAsync(int_thread *, const void *, Dyninst::Address,
2222                                      size_t, result_response::ptr, bp_write_t)
2223 {
2224    assert(0);
2225    return false;
2226 }
2227
2228 memCache *int_process::getMemCache()
2229 {
2230    return &mem_cache;
2231 }
2232
2233 void int_process::updateSyncState(Event::ptr ev, bool gen)
2234 {
2235    // This works around a Linux bug where a continue races with a whole-process exit
2236    plat_adjustSyncType(ev, gen);
2237
2238    EventType etype = ev->getEventType();
2239    switch (ev->getSyncType()) {
2240           case Event::async: {
2241          break;
2242      }
2243       case Event::sync_thread: {
2244          int_thread *thrd = ev->getThread()->llthrd();
2245          int_thread::StateTracker &st = gen ? thrd->getGeneratorState() : thrd->getHandlerState();
2246          if (!thrd) {
2247             pthrd_printf("No thread for sync thread event, assuming thread exited\n");
2248             return;
2249          }
2250          int_thread::State old_state = st.getState();
2251          if (old_state == int_thread::exited) {
2252             //Silly, linux.  Giving us events on processes that have exited.
2253             pthrd_printf("Recieved events for exited thread, not changing thread state\n");
2254             break;
2255          }
2256          pthrd_printf("Event %s is thread synchronous, marking thread %d %s stopped\n", 
2257                       etype.name().c_str(), thrd->getLWP(), gen ? "generator" : "handler");
2258          assert(RUNNING_STATE(old_state) || 
2259                 thrd->llproc()->wasForcedTerminated() ||
2260                 (old_state == int_thread::stopped && (thrd->isExiting() || thrd->isExitingInGenerator())));
2261          if (old_state == int_thread::errorstate)
2262             break;
2263          st.setState(int_thread::stopped);
2264          break;
2265       }
2266       case Event::sync_process: {
2267          pthrd_printf("Event %s is process synchronous, marking process %d %s stopped\n", 
2268                       etype.name().c_str(), getPid(), gen ? "generator" : "handler");
2269          int_threadPool *tp = threadPool();
2270          for (int_threadPool::iterator i = tp->begin(); i != tp->end(); ++i) {
2271             int_thread *thrd = *i;
2272             int_thread::StateTracker &st = gen ? thrd->getGeneratorState() : thrd->getHandlerState();
2273             int_thread::State old_state = st.getState();
2274             if (!RUNNING_STATE(old_state))
2275                continue;
2276             st.setState(int_thread::stopped);
2277          }
2278          break;
2279       }
2280       case Event::unset: {
2281          assert(0);
2282       }
2283    }
2284 }
2285
2286 ProcStopEventManager &int_process::getProcStopManager()
2287 {
2288    return proc_stop_manager;
2289 }
2290
2291 bool int_process::plat_supportThreadEvents()
2292 {
2293    return false;
2294 }
2295
2296 bool int_process::plat_supportLWPCreate() 
2297 {
2298    return false;
2299 }
2300
2301 bool int_process::plat_supportLWPPreDestroy()
2302 {
2303    return false;
2304 }
2305
2306 bool int_process::plat_supportLWPPostDestroy()
2307 {
2308    return false;
2309 }
2310
2311 bool int_process::plat_supportHWBreakpoint()
2312 {
2313    return false;
2314 }
2315
2316 bool int_process::plat_supportFork()
2317 {
2318    return false;
2319 }
2320
2321 bool int_process::plat_supportExec()
2322 {
2323    return false;
2324 }
2325
2326 async_ret_t int_process::plat_needsEmulatedSingleStep(int_thread *, std::vector<Address> &) {
2327    return aret_success;
2328 }
2329
2330 void int_process::plat_getEmulatedSingleStepAsyncs(int_thread *, std::set<response::ptr>) {
2331    assert(0);
2332 }
2333
2334 bool int_process::plat_needsPCSaveBeforeSingleStep() 
2335 {
2336    return false;
2337 }
2338
2339 map<int, int> &int_process::getProcDesyncdStates()
2340 {
2341    return proc_desyncd_states;
2342 }
2343
2344 bool int_process::isRunningSilent()
2345 {
2346    return silent_mode;
2347 }
2348
2349 void int_process::setRunningSilent(bool b)
2350 {
2351    silent_mode = b;
2352 }
2353
2354 bool int_process::plat_supportDOTF()
2355 {
2356    return true;
2357 }
2358
2359 void int_process::noteNewDequeuedEvent(Event::ptr)
2360 {
2361 }
2362
2363 bool int_process::plat_preHandleEvent()
2364 {
2365    return true;
2366 }
2367
2368 bool int_process::plat_postHandleEvent()
2369 {
2370    return true;
2371 }
2372
2373 bool int_process::plat_preAsyncWait()
2374 {
2375   return true;
2376 }
2377
2378 int_process::~int_process()
2379 {
2380    pthrd_printf("Deleting int_process at %p\n", this);
2381    if (up_proc != Process::ptr())
2382    {
2383       proc_exitstate *exitstate = new proc_exitstate();
2384       exitstate->pid = pid;
2385       exitstate->exited = hasExitCode && !forcedTermination;
2386       exitstate->exit_code = exitCode;
2387       exitstate->crashed = hasCrashSignal;
2388       exitstate->crash_signal = crashSignal;
2389       exitstate->user_data = user_data;
2390       assert(!up_proc->exitstate_);
2391       up_proc->exitstate_ = exitstate;
2392       up_proc->llproc_ = NULL;
2393    }
2394
2395    if (threadpool) {
2396       delete threadpool;
2397       threadpool = NULL;
2398    }
2399    
2400    //Do not delete handlerpool yet, we're currently under
2401    // an event handler.  We do want to delete this if called
2402    // from detach.
2403    bool should_clean;
2404    mem->rmProc(this, should_clean);
2405    if (should_clean) {
2406       delete mem;
2407    }
2408    mem = NULL;
2409
2410    if(ProcPool()->findProcByPid(getPid())) ProcPool()->rmProcess(this);
2411 }
2412
2413 indep_lwp_control_process::indep_lwp_control_process(Dyninst::PID p, std::string e, std::vector<std::string> a, 
2414                                                      std::vector<std::string> envp, std::map<int,int> f) :
2415    int_process(p, e, a, envp, f)
2416 {
2417 }
2418
2419 indep_lwp_control_process::indep_lwp_control_process(Dyninst::PID pid_, int_process *p) :
2420    int_process(pid_, p)
2421 {
2422 }
2423
2424 bool indep_lwp_control_process::plat_syncRunState()
2425 {
2426    for (int_threadPool::iterator i = threadPool()->begin(); i != threadPool()->end(); i++) {
2427       int_thread *thr = *i;
2428       int_thread::State handler_state = thr->getHandlerState().getState();
2429       int_thread::State target_state = thr->getTargetState();
2430       bool result = true;
2431             
2432       if (handler_state == target_state) {
2433          continue;
2434       }
2435       else if (handler_state == int_thread::stopped && RUNNING_STATE(target_state)) {
2436          result = thr->intCont();
2437       }
2438       else if (RUNNING_STATE(handler_state) && target_state == int_thread::stopped) {
2439          result = thr->intStop();
2440       }
2441       if (!result && getLastError() == err_exited) {
2442          pthrd_printf("Suppressing error of continue on exited process\n");
2443          pthrd_printf("TESTING: setting handler to running anyway\n");
2444          thr->getHandlerState().setState(int_thread::running);
2445       }
2446       else if (!result) {
2447          pthrd_printf("Error changing process state from plat_syncRunState\n");
2448          return false;
2449       }
2450    }
2451    return true;
2452 }
2453
2454 indep_lwp_control_process::~indep_lwp_control_process()
2455 {
2456 }
2457
2458 unified_lwp_control_process::unified_lwp_control_process(Dyninst::PID p, std::string e, 
2459                                                          std::vector<std::string> a, 
2460                                                          std::vector<std::string> envp, 
2461                                                          std::map<int,int> f) :
2462    int_process(p, e, a, envp, f)
2463 {
2464 }
2465
2466 unified_lwp_control_process::unified_lwp_control_process(Dyninst::PID pid_, int_process *p) :
2467    int_process(pid_, p)
2468 {
2469 }
2470
2471 unified_lwp_control_process::~unified_lwp_control_process()
2472 {
2473 }
2474
2475 bool unified_lwp_control_process::plat_syncRunState()
2476 {
2477    bool want_ss_running = false;
2478    bool result = true;
2479
2480    bool want_all_stopped = true;
2481    bool want_all_running = true;
2482    bool want_some_stopped = false;
2483    bool want_some_running = false;
2484
2485    bool is_all_stopped = true;
2486    bool is_all_running = true;
2487
2488    if (getState() == detached || getState() == exited || getState() == errorstate) {
2489       pthrd_printf("Process %d is in state %s, doing nothing in plat_syncRunState\n", 
2490                    getPid(), int_process::stateName(getState()));
2491       return true;
2492    }
2493
2494    for (int_threadPool::iterator i = threadPool()->begin(); i != threadPool()->end(); i++) {
2495       int_thread *thr = *i;
2496       int_thread::State handler_state = thr->getHandlerState().getState();
2497       int_thread::State target_state = thr->getTargetState();
2498       if (target_state == int_thread::ditto) 
2499          target_state = thr->getHandlerState().getState();
2500       
2501       if (RUNNING_STATE(target_state)) {
2502          want_some_running = true;
2503          want_all_stopped = false;
2504       }
2505       else if (target_state == int_thread::stopped) {
2506          want_some_stopped = true;
2507          want_all_running = false;
2508       }
2509       else {
2510          want_all_stopped = false;
2511          want_all_running = false;
2512       }
2513
2514       if (RUNNING_STATE(handler_state)) {
2515          is_all_stopped = false;
2516       }
2517       else if (handler_state == int_thread::stopped) {
2518          is_all_running = false;
2519       }
2520       else {
2521          is_all_stopped = false;
2522          is_all_running = false;
2523       }
2524
2525       if (!RUNNING_STATE(handler_state) && RUNNING_STATE(target_state) && thr->singleStep()) {
2526          want_ss_running = true;
2527       }
2528    }
2529
2530    pthrd_printf("In plat_syncRunState: want_all_stopped = %s, want_all_running = %s, want_some_stopped = %s, want_some_running = %s, is_all_stopped = %s, is_all_running = %s, want_ss_running = %s\n",
2531                 want_all_stopped ? "t" : "f",
2532                 want_all_running ? "t" : "f",
2533                 want_some_stopped ? "t" : "f",
2534                 want_some_running ? "t" : "f",
2535                 is_all_stopped ? "t" : "f",
2536                 is_all_running ? "t" : "f",
2537                 want_ss_running ? "t" : "f");
2538
2539    if (want_ss_running) {
2540       pthrd_printf("Process %d is single-stepping.  Continuing select threads\n", getPid());
2541       for (int_threadPool::iterator i = threadPool()->begin(); i != threadPool()->end(); i++) {
2542          int_thread *thr = *i;
2543          if (thr->singleStep() && thr->getHandlerState().getState() == int_thread::stopped &&
2544              RUNNING_STATE(thr->getTargetState()))
2545          {
2546             bool tresult = thr->intCont();
2547             if (!tresult) {
2548                pthrd_printf("plat_syncRunState single-step failed on %d/%d\n", getPid(), thr->getLWP());
2549                result = false;
2550             }
2551          }
2552       }
2553    }
2554    else if (want_all_running && is_all_running) {
2555       pthrd_printf("Process %d is running, needs to run.  Doing nothing\n", getPid());
2556    }
2557    else if (want_all_running && is_all_stopped) {
2558       pthrd_printf("Process %d is stopped, needs to run.  Continuing process\n", getPid());
2559       result = threadPool()->initialThread()->intCont();
2560    }
2561    else if (want_all_stopped && is_all_running) {
2562       pthrd_printf("Process %d is running, needs to stop.  Stopping process\n", getPid());
2563       result = threadPool()->initialThread()->intStop();
2564    }
2565    else if (want_all_stopped && is_all_stopped) {
2566       pthrd_printf("Process %d is stopped, needs to stop.  Doing nothing\n", getPid());
2567    }
2568    else if (want_some_stopped && !is_all_stopped) {
2569       pthrd_printf("Process %d is partially stopped, needs to stop.  Stopping process\n", getPid());
2570       result = threadPool()->initialThread()->intStop();
2571    }
2572    else if (want_some_running && !is_all_running) {
2573       pthrd_printf("Process %d is partially running, needs to run.  Continuing process\n", getPid());
2574       result = threadPool()->initialThread()->intCont();
2575    }
2576    else {
2577       pthrd_printf("Process %d is in startup or teardown state.  Doing nothing\n", getPid());
2578    }
2579
2580    if (!result) {
2581       pthrd_printf("plat_syncRunState operation failed.  Returning false\n");
2582       return false;
2583    }
2584
2585    return true;
2586 }
2587
2588 bool unified_lwp_control_process::plat_processGroupContinues()
2589 {
2590    return true;
2591 }
2592
2593 hybrid_lwp_control_process::hybrid_lwp_control_process(Dyninst::PID p, std::string e, 
2594                                                          std::vector<std::string> a, 
2595                                                          std::vector<std::string> envp, 
2596                                                          std::map<int,int> f) :
2597   int_process(p, e, a, envp, f),
2598   debugger_stopped(false)
2599 {
2600 }
2601
2602 hybrid_lwp_control_process::hybrid_lwp_control_process(Dyninst::PID pid_, int_process *p) :
2603   int_process(pid_, p),
2604   debugger_stopped(false)
2605 {
2606   // Clone debugger_stopped from parent
2607   hybrid_lwp_control_process *par = dynamic_cast<hybrid_lwp_control_process *>(p);
2608   assert(par); // Otherwise we have a very, very strange system
2609   debugger_stopped = par->debugger_stopped;
2610   pthrd_printf("Set debugger stopped to %s on %d, matching parent %d\n",
2611                (debugger_stopped ? "true" : "false"),
2612                pid_,
2613                p->getPid());
2614                
2615 }
2616
2617 hybrid_lwp_control_process::~hybrid_lwp_control_process()
2618 {
2619 }
2620
2621 bool hybrid_lwp_control_process::suspendThread(int_thread *thr)
2622 {
2623    if (thr->isSuspended())
2624       return true;
2625
2626    bool result = plat_suspendThread(thr);
2627    if (!result) 
2628       return false;
2629    thr->setSuspended(true);
2630    return true;
2631 }
2632
2633 bool hybrid_lwp_control_process::resumeThread(int_thread *thr)
2634 {
2635    if (!thr->isSuspended())
2636       return true;
2637
2638    bool result = plat_resumeThread(thr);
2639    if (!result) 
2640       return false;
2641    thr->setSuspended(false);
2642    return true;
2643 }
2644
2645 bool hybrid_lwp_control_process::plat_processGroupContinues()
2646 {
2647    return true;
2648 }
2649
2650 void hybrid_lwp_control_process::noteNewDequeuedEvent(Event::ptr ev)
2651 {
2652    if (ev->getSyncType() == Event::sync_process) {
2653            pthrd_printf("Marking %d debugger suspended on event: %s\n", getPid(), ev->name().c_str());
2654       debugger_stopped = true;
2655       pthrd_printf("Setting, debugger stopped: %d (%p) (%d)\n", debugger_stopped, this, getPid());
2656    }
2657 }
2658
2659 bool hybrid_lwp_control_process::plat_debuggerSuspended()
2660 {
2661   pthrd_printf("Querying, debugger stopped: %d (%p) (%p) (%d)\n", debugger_stopped, &debugger_stopped, this, getPid());
2662    return debugger_stopped;
2663 }
2664
2665 bool hybrid_lwp_control_process::plat_syncRunState()
2666 {
2667    bool any_target_stopped = false, any_target_running = false;
2668    bool any_stopped = false, any_running = false;
2669
2670    int_thread *a_running_thread = NULL;
2671
2672    if (getState() == exited) {
2673       pthrd_printf("Returning from plat_syncRunState for exited process %d\n", getPid());
2674       return true;
2675    }
2676
2677    int_threadPool *tp = threadPool();
2678    int_threadPool::iterator i;
2679    for (i = tp->begin(); i != tp->end(); i++) {
2680       int_thread *thr = *i;
2681       pthrd_printf("Checking %d/%d: state %s\n", getPid(), thr->getLWP(), int_thread::stateStr(thr->getUserState().getState()));
2682 #if defined(os_freebsd) 
2683            if (thr->getUserState().getState() == int_thread::exited) {
2684              // Let it go, man...
2685              continue;
2686            }
2687 #endif
2688            if (thr->getDetachState().getState() == int_thread::detached) {
2689              pthrd_printf("%d/%d detached, skipping\n", getPid(), thr->getLWP());
2690              continue;
2691            }
2692            if (!RUNNING_STATE(thr->getHandlerState().getState())) {
2693              pthrd_printf("%d/%d not running, any_stopped = true\n", getPid(), thr->getLWP());
2694              any_stopped = true;
2695            } else {
2696              pthrd_printf("%d/%d running, any_running = true\n", getPid(), thr->getLWP());
2697              any_running = true;
2698              if (!a_running_thread) a_running_thread = thr;
2699            }
2700            if (RUNNING_STATE(thr->getTargetState())) {
2701              pthrd_printf("%d/%d target running, any_target_running = true\n", getPid(), thr->getLWP());
2702              any_target_running = true;
2703            }
2704            if (!RUNNING_STATE(thr->getTargetState())) {
2705              pthrd_printf("%d/%d target stopped, any_target_stopped = true\n", getPid(), thr->getLWP());
2706              any_target_stopped = true;
2707            }
2708    }
2709    if(!a_running_thread) {
2710      a_running_thread = tp->initialThread();
2711    }
2712
2713
2714    if (!any_target_running && !any_running) {
2715       pthrd_printf("Target process state %d is stopped and process is stopped, leaving\n", getPid());
2716       return true;
2717    }
2718    if (!any_target_stopped && !any_stopped) {
2719       pthrd_printf("Target process state %d is running and process is running, leaving\n", getPid());
2720       return true;
2721    }
2722    if (!plat_debuggerSuspended()) {
2723       pthrd_printf("Process %d is not debugger suspended, but have changes.  Stopping process.\n", getPid());
2724       return a_running_thread->intStop();
2725    }
2726
2727    //If we're here, we must be debuggerSuspended, and thus no threads are running (!any_running)
2728    // since we didn't trigger the above if statement, we must have some thread we want to run
2729    // (any_target_running)
2730    assert(!any_running && any_target_running);
2731    pthrd_printf("Begin suspend/resume loop\n");
2732    for (i = tp->begin(); i != tp->end(); i++) {
2733       int_thread *thr = *i;
2734       bool result = true;
2735           if (!thr->isUser()) {
2736                   // Pretend is member of Wu Tang clan -- Bill Williams, 13JUN2012
2737                   resumeThread(thr);
2738                   continue;
2739           }
2740           if (thr->getDetachState().getState() == int_thread::detached)
2741             continue;
2742
2743 #if defined(os_freebsd) 
2744            if (thr->getUserState().getState() == int_thread::exited) {
2745              // Let it go, man...
2746              continue;
2747            }
2748 #endif
2749
2750       if (thr->isSuspended() && RUNNING_STATE(thr->getTargetState())) {
2751          pthrd_printf("Resuming thread %d/%d\n", getPid(), thr->getLWP());
2752          result = resumeThread(thr);
2753       }
2754       if (thr->getDetachState().getState() == int_thread::detached)
2755          continue;
2756       if (RUNNING_STATE(thr->getTargetState())) {
2757          if (thr->isSuspended()) {
2758             pthrd_printf("Resuming thread %d/%d\n", getPid(), thr->getLWP());
2759             result = resumeThread(thr);
2760          }
2761          else {
2762             pthrd_printf("Thread %d/%d is already resumed, not resuming\n", getPid(), thr->getLWP());
2763          }
2764       }
2765       else if (!RUNNING_STATE(thr->getTargetState())) {
2766          if (!thr->isSuspended()) {
2767             pthrd_printf("Suspending thread %d/%d\n", getPid(), thr->getLWP());
2768             result = suspendThread(thr);
2769          }
2770          else {
2771             pthrd_printf("Thread %d/%d is already suspended, not suspending\n", getPid(), thr->getLWP());
2772          }
2773       }
2774       if (!result) {
2775          pthrd_printf("Error suspending/resuming threads\n");
2776          return false;
2777       }
2778    }
2779
2780    pthrd_printf("Continuing process %d after suspend/resume of threads\n", getPid());
2781    debugger_stopped = false;
2782    return threadPool()->initialThread()->intCont();
2783 }
2784
2785 int_thread::int_thread(int_process *p, Dyninst::THR_ID t, Dyninst::LWP l) :
2786    tid(t),
2787    lwp(l),
2788    proc_(p),
2789    continueSig_(0),
2790    attach_status(as_unknown),
2791    handler_running_thrd_count(Counter::HandlerRunningThreads),
2792    generator_running_thrd_count(Counter::GeneratorRunningThreads),
2793    sync_rpc_count(Counter::SyncRPCs),
2794    sync_rpc_running_thr_count(Counter::SyncRPCRunningThreads),
2795    pending_stop(Counter::PendingStops),
2796    clearing_bp_count(Counter::ClearingBPs),
2797    proc_stop_rpc_count(Counter::ProcStopRPCs),
2798    generator_nonexited_thrd_count(Counter::GeneratorNonExitedThreads),
2799    neonatal_threads(Counter::NeonatalThreads),
2800    exiting_state(this, ExitingStateID, dontcare),
2801    startup_state(this, StartupStateID, dontcare),
2802    pending_stop_state(this, PendingStopStateID, dontcare),
2803    callback_state(this, CallbackStateID, dontcare),
2804    breakpoint_state(this, BreakpointStateID, dontcare),
2805    breakpoint_resume_state(this, BreakpointResumeStateID, dontcare),
2806    irpc_setup_state(this, IRPCSetupStateID, dontcare),
2807    irpc_wait_state(this, IRPCWaitStateID, dontcare),
2808    irpc_state(this, IRPCStateID, dontcare),
2809    async_state(this, AsyncStateID, dontcare),
2810    internal_state(this, InternalStateID, dontcare),
2811    detach_state(this, DetachStateID, dontcare),
2812    user_irpc_state(this, UserRPCStateID, dontcare),
2813    control_authority_state(this, ControlAuthorityStateID, dontcare),
2814    user_state(this, UserStateID, neonatal),
2815    handler_state(this, HandlerStateID, neonatal),
2816    generator_state(this, GeneratorStateID, neonatal),
2817    target_state(int_thread::none),
2818    saved_user_state(int_thread::none),
2819    regpool_lock(true),
2820    user_single_step(false),
2821    single_step(false),
2822    handler_exiting_state(false),
2823    generator_exiting_state(false),
2824    running_when_attached(true),
2825    suspended(false),
2826    stopped_on_breakpoint_addr(0x0),
2827    postponed_stopped_on_breakpoint_addr(0x0),
2828    clearing_breakpoint(NULL),
2829    em_singlestep(NULL),
2830    user_data(NULL),
2831    unwinder(NULL)
2832 {
2833    Thread::ptr new_thr(new Thread());
2834
2835    new_thr->llthread_ = this;
2836    up_thread = new_thr;
2837
2838    getGeneratorNonExitedThreadCount().inc();
2839 }
2840
2841 int_thread::~int_thread()
2842 {
2843    assert(!up_thread->exitstate_);
2844
2845    thread_exitstate *tes = new thread_exitstate();
2846    tes->lwp = lwp;
2847    tes->thr_id = tid;
2848    tes->proc_ptr = proc();
2849    tes->user_data = user_data;
2850    up_thread->exitstate_ = tes;
2851    up_thread->llthread_ = NULL;
2852 }
2853
2854 bool int_thread::intStop()
2855 {
2856    pthrd_printf("intStop on thread %d/%d\n", llproc()->getPid(), getLWP());
2857    if (!llproc()->plat_processGroupContinues()) {
2858       assert(!RUNNING_STATE(target_state));
2859       assert(RUNNING_STATE(getHandlerState().getState()));
2860
2861       if (hasPendingStop()) {
2862          pthrd_printf("Not throwing a second stop while another is in flight\n");
2863          return true;
2864       }
2865    }
2866    else {
2867       int_threadPool *tp = llproc()->threadPool();
2868       for (int_threadPool::iterator i = tp->begin(); i != tp->end(); i++) {
2869          if ((*i)->hasPendingStop()) {
2870             pthrd_printf("Not throwing a second stop while another is in flight\n");
2871             return true;
2872          }
2873       }
2874    }
2875
2876    setPendingStop(true);   
2877    bool result = plat_stop();
2878    if (!result) {
2879       setPendingStop(false);
2880       if (getLastError() == err_noproc) {
2881          //Swallow this.
2882          result = true;
2883       }
2884    }
2885    return result;
2886 }
2887
2888 bool int_thread::intCont()
2889 {
2890    pthrd_printf("intCont on thread %d/%d\n", llproc()->getPid(), getLWP());
2891    if (!llproc()->plat_processGroupContinues()) {
2892       assert(RUNNING_STATE(target_state));
2893       assert(!RUNNING_STATE(getHandlerState().getState()));
2894    }
2895
2896    async_ret_t aret = handleSingleStepContinue();
2897    if (aret == aret_async) {
2898       pthrd_printf("Postponing intCont on %d/%d due to single-step handling\n", 
2899                    llproc()->getPid(), getLWP());
2900       return true;
2901    }
2902    else if (aret == aret_error) {
2903       pthrd_printf("Error in intCont %d/%d during single-step handling\n",
2904                    llproc()->getPid(), getLWP());
2905       return false;
2906    }
2907
2908    ProcPool()->condvar()->lock();
2909    
2910    bool result = plat_cont();
2911
2912    if (result) {
2913       if (llproc()->plat_processGroupContinues()) {
2914          int_threadPool *pool = llproc()->threadPool();
2915          for (int_threadPool::iterator i = pool->begin(); i != pool->end(); i++) {
2916             if ((*i)->isSuspended())
2917                continue;
2918             (*i)->getHandlerState().setState(int_thread::running);
2919             (*i)->getGeneratorState().setState(int_thread::running);
2920          }
2921       }
2922       else {
2923          getHandlerState().setState(int_thread::running);
2924          getGeneratorState().setState(int_thread::running);
2925       }
2926       triggerContinueCBs();
2927    }
2928
2929    ProcPool()->condvar()->broadcast();
2930    ProcPool()->condvar()->unlock();
2931
2932    if (!result) {
2933       pthrd_printf("Failed to plat_cont %d/%d\n", llproc()->getPid(), getLWP());
2934       return false;
2935    }
2936
2937    return true;
2938 }
2939
2940 async_ret_t int_thread::handleSingleStepContinue()
2941 {
2942    async_ret_t ret;
2943    set<int_thread *> thrds;
2944
2945    if (llproc()->plat_processGroupContinues()) {
2946       int_threadPool *pool = llproc()->threadPool();
2947       for (int_threadPool::iterator i = pool->begin(); i != pool->end(); i++) {
2948          if (!(*i)->isSuspended() && (*i)->singleStepUserMode()) {
2949             thrds.insert(*i);
2950          }
2951       }
2952       
2953    }
2954    else if (singleStepUserMode()) {
2955       thrds.insert(this);
2956    }
2957
2958    if (thrds.empty()) {
2959       //No threads are single-steping.
2960       return aret_success;
2961    }
2962    pthrd_printf("Found %d threads doing single step under continue.  Handling\n", (int) thrds.size());
2963
2964    if (llproc()->plat_needsAsyncIO()) {
2965       /**
2966        * We want any async responses associated with an event, but this is under
2967        * a continue, which never has an associated event.  We'll make an EventNop
2968        * to accompany the async request.  However, since this isn't going to be 
2969        * a common thing to have happen, we'll set a flag that just tells the 
2970        * HandlerPool to create the nop event lazily only if anyone asks for it.
2971        **/
2972       llproc()->handlerPool()->setNopAsCurEvent();
2973    }
2974
2975    for (set<int_thread *>::iterator i = thrds.begin(); i != thrds.end(); i++) {
2976       int_thread *thr = *i;
2977       vector<Address> addrs;
2978       async_ret_t aresult = llproc()->plat_needsEmulatedSingleStep(thr, addrs);
2979       if (aresult == aret_async) {
2980          pthrd_printf("Async return from plat_needsEmulatedSingleStep on %d/%d\n",
2981                       llproc()->getPid(), thr->getLWP());
2982          //We're not actually under a handler, so fake all the async handling
2983          // the handlerpool would have done if we were.
2984          set<response::ptr> resps;
2985          Event::ptr cur_nop_event = llproc()->handlerPool()->curEvent();
2986          llproc()->plat_getEmulatedSingleStepAsyncs(thr, resps);
2987          llproc()->handlerPool()->notifyOfPendingAsyncs(resps, cur_nop_event);
2988          llproc()->handlerPool()->markEventAsyncPending(cur_nop_event);
2989          ret = aret_async;
2990          goto done;
2991       }
2992       else if (aresult == aret_error) {
2993          pthrd_printf("Error in plat_needsEmultatedSingleStep on %d/%d\n",
2994                       llproc()->getPid(), thr->getLWP());
2995          ret = aret_error;
2996          goto done;
2997       }
2998       else if (addrs.empty()) {
2999          pthrd_printf("Thread %d/%d does not need emulated single-step\n",
3000                       llproc()->getPid(), thr->getLWP());
3001          continue;
3002       }
3003
3004       pthrd_printf("Creating emulated single step for %d/%d\n",
3005                    llproc()->getPid(), thr->getLWP());
3006       emulated_singlestep *new_es = thr->getEmulatedSingleStep();
3007       if (!new_es)
3008          new_es = new emulated_singlestep(thr);
3009       for (vector<Address>::iterator j = addrs.begin(); j != addrs.end(); j++) {
3010          Address addr = *j;
3011          pthrd_printf("Installing emulated single-step breakpoint for %d/%d at %lx\n",
3012                       llproc()->getPid(), thr->getLWP(), addr);                      
3013          aresult = new_es->add(addr);
3014          if (aresult == aret_async) {
3015             pthrd_printf("Async return while installing breakpoint for emulated_singlestep\n");
3016             ret = aret_async;
3017             goto done;
3018          }
3019          if (aresult == aret_error) {
3020             pthrd_printf("Error return while installing breakpoint for emulated_singlestep\n");
3021             ret = aret_error;
3022             goto done;
3023          }
3024       }
3025    }
3026
3027    ret = aret_success;
3028   done:
3029
3030    if (llproc()->plat_needsAsyncIO())
3031       llproc()->handlerPool()->clearNopAsCurEvent();      
3032       
3033    return ret;
3034 }
3035
3036 bool int_thread::isStopped(int state_id)
3037 {
3038    if (getHandlerState().getState() != stopped)
3039       return false;
3040    if (getStateByID(state_id).getState() != stopped &&
3041        getStateByID(state_id).getState() != ditto)
3042       return false;
3043    for (int i=0; i<state_id; i++) {
3044       if (getStateByID(i).getState() != dontcare)
3045          return false;
3046    }
3047    return true;
3048 }
3049
3050 void int_thread::setPendingStop(bool b)
3051 {
3052    pthrd_printf("Setting pending stop to %s, thread %d/%d\n", b ? "true" : "false", proc()->getPid(), getLWP());
3053    if (b) {
3054       pending_stop.inc();
3055
3056       //You may ask why stopping moves the pending stop state to running.
3057       // We've sent the process a stop request, and we need that request to 
3058       // be delivered.  The process won't take delivery of the stop request
3059       // unless it's running.
3060       getPendingStopState().desyncState(int_thread::running);
3061    }
3062    else {
3063       if (getPendingStopState().getState() != int_thread::dontcare) {
3064          getPendingStopState().restoreState();
3065          pending_stop.dec();
3066       }
3067       else {
3068          pthrd_printf("Pending stop state == dontcare, ignoring\n");
3069       }
3070    }
3071    pthrd_printf("\t Pending stop level is %d\n", pending_stop.localCount());
3072 }
3073
3074 bool int_thread::hasPendingStop() const
3075 {
3076    return pending_stop.local();
3077 }
3078
3079 bool int_thread::wasRunningWhenAttached() const {
3080     return running_when_attached;
3081 }
3082
3083 void int_thread::setRunningWhenAttached(bool b) {
3084     running_when_attached = b;
3085 }
3086
3087 Process::ptr int_thread::proc() const
3088 {
3089    return proc_->proc();
3090 }
3091
3092 int_process *int_thread::llproc() const
3093 {
3094    return proc_;
3095 }
3096
3097 Dyninst::LWP int_thread::getLWP() const
3098 {
3099    return lwp;
3100 }
3101
3102 void int_thread::addContinueCB(continue_cb_t cb)
3103 {
3104    continue_cbs.insert(cb);
3105 }
3106
3107 void int_thread::triggerContinueCBs()
3108 {
3109    bool sync_conts = llproc()->plat_processGroupContinues();
3110    for (set<continue_cb_t>::iterator i = continue_cbs.begin(); i != continue_cbs.end(); i++) {
3111       if (!sync_conts) {
3112          //Independent lwp control--only do this thread.
3113          (*i)(this);
3114       }
3115       else {
3116          //Threads are continued at once--do every thread
3117          int_threadPool *tp = llproc()->threadPool();
3118          for (int_threadPool::iterator j = tp->begin(); j != tp->end(); j++) {
3119             if ((*j)->isSuspended())
3120                continue;
3121             (*i)(*j);
3122          }
3123       }
3124    }
3125 }
3126
3127 int_thread::StateTracker &int_thread::getBreakpointState()
3128 {
3129    return breakpoint_state;
3130 }
3131
3132 int_thread::StateTracker &int_thread::getBreakpointResumeState()
3133 {
3134    return breakpoint_resume_state;
3135 }
3136
3137 int_thread::StateTracker &int_thread::getIRPCState()
3138 {
3139    return irpc_state;
3140 }
3141
3142 int_thread::StateTracker &int_thread::getIRPCSetupState()
3143 {
3144    return irpc_setup_state;
3145 }
3146
3147 int_thread::StateTracker &int_thread::getIRPCWaitState()
3148 {
3149    return irpc_wait_state;
3150 }
3151
3152 int_thread::StateTracker &int_thread::getAsyncState()
3153 {
3154    return async_state;
3155 }
3156
3157 int_thread::StateTracker &int_thread::getInternalState()
3158 {
3159    return internal_state;
3160 }
3161
3162 int_thread::StateTracker &int_thread::getDetachState()
3163 {
3164    return detach_state;
3165 }
3166
3167 int_thread::StateTracker &int_thread::getUserRPCState()
3168 {
3169         return user_irpc_state;
3170 }
3171
3172 int_thread::StateTracker &int_thread::getControlAuthorityState()
3173 {
3174    return control_authority_state;
3175 }
3176
3177 int_thread::StateTracker &int_thread::getUserState()
3178 {
3179    return user_state;
3180 }
3181
3182 int_thread::StateTracker &int_thread::getHandlerState()
3183 {
3184    return handler_state;
3185 }
3186
3187 int_thread::StateTracker &int_thread::getGeneratorState()
3188 {
3189    return generator_state;
3190 }
3191
3192 int_thread::StateTracker &int_thread::getExitingState()
3193 {
3194    return exiting_state;
3195 }
3196
3197 int_thread::StateTracker &int_thread::getStartupState()
3198 {
3199    return startup_state;
3200 }
3201
3202 int_thread::StateTracker &int_thread::getCallbackState()
3203 {
3204    return callback_state;
3205 }
3206
3207 int_thread::StateTracker &int_thread::getPendingStopState()
3208 {
3209    return pending_stop_state;
3210 }
3211
3212 int_thread::State int_thread::getTargetState() const
3213 {
3214    return target_state;
3215 }
3216
3217 void int_thread::setTargetState(State s)
3218 {
3219         pthrd_printf("%d/%d: setting target state to %s\n", proc_->getPid(), getLWP(),
3220                 RUNNING_STATE(s) ? "Running" : "Stopped");
3221    target_state = s;
3222 }
3223
3224 int_thread::StateTracker &int_thread::getActiveState() {
3225    for (int i=0; i<int_thread::NumTargetStateIDs; i++) {
3226       if (all_states[i]->getState() != int_thread::dontcare) {
3227          return *all_states[i];
3228       }
3229    }
3230    assert(0); //At least user state should never be 'dontcare'
3231    return *all_states[0];
3232 }
3233
3234 int_thread::StateTracker &int_thread::getStateByID(int id)
3235 {
3236    switch (id) {
3237       case ExitingStateID: return exiting_state;
3238       case StartupStateID: return startup_state;
3239       case AsyncStateID: return async_state;
3240       case CallbackStateID: return callback_state;
3241       case PendingStopStateID: return pending_stop_state;
3242       case IRPCStateID: return irpc_state;
3243       case IRPCSetupStateID: return irpc_setup_state;
3244       case IRPCWaitStateID: return irpc_wait_state;
3245       case BreakpointStateID: return breakpoint_state;
3246       case BreakpointResumeStateID: return breakpoint_resume_state;
3247       case InternalStateID: return internal_state;
3248       case DetachStateID: return detach_state;
3249       case UserRPCStateID: return user_irpc_state;
3250       case ControlAuthorityStateID: return control_authority_state;
3251       case UserStateID: return user_state;
3252       case HandlerStateID: return handler_state;
3253       case GeneratorStateID: return generator_state;
3254    }
3255    assert(0);
3256    return exiting_state; 
3257 }
3258
3259 std::string int_thread::stateIDToName(int id)
3260 {
3261    switch (id) {
3262       case ExitingStateID: return "exiting";      
3263       case StartupStateID: return "startup";
3264       case AsyncStateID: return "async";
3265       case CallbackStateID: return "callback";
3266       case PendingStopStateID: return "pending stop";
3267       case IRPCStateID: return "irpc";
3268       case IRPCSetupStateID: return "irpc setup";
3269       case IRPCWaitStateID: return "irpc wait";
3270       case BreakpointStateID: return "breakpoint";
3271       case BreakpointResumeStateID: return "breakpoint resume";
3272       case InternalStateID: return "internal";
3273       case UserRPCStateID: return "irpc user";
3274       case ControlAuthorityStateID: return "control authority";
3275       case UserStateID: return "user";
3276       case DetachStateID: return "detach";
3277       case HandlerStateID: return "handler";
3278       case GeneratorStateID: return "generator";
3279    }
3280    assert(0);
3281    return "";
3282 }
3283
3284
3285 const char *int_thread::stateStr(int_thread::State s)
3286 {
3287    switch (s) {
3288       case none: return "none";
3289       case neonatal: return "neonatal";
3290       case neonatal_intermediate: return "neonatal_intermediate";
3291       case running: return "running";
3292       case stopped: return "stopped";
3293       case dontcare: return "dontcare";
3294       case ditto: return "ditto";
3295       case exited: return "exited";
3296       case detached: return "detached";
3297       case errorstate: return "errorstate";
3298    } 
3299    assert(0);
3300    return NULL;
3301 }
3302
3303 char int_thread::stateLetter(int_thread::State s)
3304 {
3305    switch (s) {
3306       case none: return '0';
3307       case neonatal: return 'N';
3308       case neonatal_intermediate: return 'I';
3309       case running: return 'R';
3310       case stopped: return 'S';
3311       case dontcare: return '-';
3312       case ditto: return 'H';
3313       case exited: return 'X';
3314       case detached: return 'D';
3315       case errorstate: return 'E';
3316    }
3317    assert(0);
3318    return '\0';
3319 }
3320
3321 Counter &int_thread::handlerRunningThreadsCount()
3322 {
3323    return handler_running_thrd_count;
3324 }
3325
3326 Counter &int_thread::generatorRunningThreadsCount()
3327 {
3328    return generator_running_thrd_count;
3329 }
3330
3331 Counter &int_thread::syncRPCCount()
3332 {
3333    return sync_rpc_count;
3334 }
3335
3336 Counter &int_thread::runningSyncRPCThreadCount()
3337 {
3338    return sync_rpc_running_thr_count;
3339 }
3340
3341 Counter &int_thread::pendingStopsCount()
3342 {
3343    return pending_stop;
3344 }
3345
3346 Counter &int_thread::clearingBPCount()
3347 {
3348    return clearing_bp_count;
3349 }
3350
3351 Counter &int_thread::procStopRPCCount()
3352 {
3353    return proc_stop_rpc_count;
3354 }
3355
3356 Counter &int_thread::getGeneratorNonExitedThreadCount()
3357 {
3358    return generator_nonexited_thrd_count;
3359 }
3360
3361 Counter &int_thread::neonatalThreadCount()
3362 {
3363    return neonatal_threads;
3364 }
3365
3366 void int_thread::setContSignal(int sig)
3367 {
3368    continueSig_ = sig;
3369 }
3370
3371 int int_thread::getContSignal() {
3372     return continueSig_;
3373 }
3374
3375 int_thread *int_thread::createThread(int_process *proc, 
3376                                      Dyninst::THR_ID thr_id, 
3377                                      Dyninst::LWP lwp_id,
3378                                      bool initial_thrd,
3379                                      attach_status_t astatus)
3380 {
3381    // See if we already created a skeleton/dummy thread for this thread ID.
3382    int_thread *newthr = proc->threadPool()->findThreadByLWP(lwp_id);
3383    if (newthr) return newthr;
3384
3385    newthr = createThreadPlat(proc, thr_id, lwp_id, initial_thrd);
3386    if(!newthr)
3387    {
3388            pthrd_printf("createThreadPlat failed, returning NULL\n");
3389            return NULL;
3390    }
3391    pthrd_printf("Creating %s thread %d/%d, thr_id = 0x%lx\n", 
3392                 initial_thrd ? "initial" : "new",
3393                 proc->getPid(), newthr->getLWP(), thr_id);
3394
3395    proc->threadPool()->addThread(newthr);
3396    if (initial_thrd) {
3397       proc->threadPool()->setInitialThread(newthr);
3398    }
3399    ProcPool()->addThread(proc, newthr);
3400    newthr->attach_status = astatus;
3401
3402    bool result = newthr->attach();
3403    if (!result) {
3404       pthrd_printf("Failed to attach to new thread %d/%d\n", proc->getPid(), lwp_id);
3405       return NULL;
3406    }
3407    if (newthr->isUser() && newthr->getUserState().getState() == neonatal) {
3408            newthr->getUserState().setState(neonatal_intermediate);
3409            newthr->getHandlerState().setState(neonatal_intermediate);
3410                 newthr->getGeneratorState().setState(neonatal_intermediate);
3411    }
3412
3413    return newthr;
3414 }
3415
3416 void int_thread::changeLWP(Dyninst::LWP new_lwp)
3417 {
3418   pthrd_printf("Changing LWP of %d/%d to %d\n", llproc()->getPid(), lwp, new_lwp);
3419
3420   int_threadPool *tpool = llproc()->threadPool();
3421   map<Dyninst::LWP, int_thread *>::iterator i = tpool->thrds_by_lwp.find(lwp);
3422   assert(i != tpool->thrds_by_lwp.end());
3423   tpool->thrds_by_lwp.erase(i);
3424   tpool->thrds_by_lwp.insert(make_pair(new_lwp, this));
3425
3426   ProcPool()->condvar()->lock();
3427   ProcPool()->rmThread(this);
3428   lwp = new_lwp;
3429   ProcPool()->addThread(llproc(), this);
3430   ProcPool()->condvar()->unlock();
3431 }
3432
3433 void int_thread::throwEventsBeforeContinue()
3434 {
3435   pthrd_printf("Checking thread %d/%d for events thrown before continue\n",
3436                llproc()->getPid(), getLWP());
3437    if (llproc()->wasForcedTerminated()) return;
3438
3439    Event::ptr new_ev;
3440
3441    int_iRPC::ptr rpc = nextPostedIRPC();
3442    bp_instance *bpi = isStoppedOnBP();
3443    if (rpc && !runningRPC() && rpc->getState() == int_iRPC::Posted) {
3444       pthrd_printf("Found thread %d/%d ready to run IRPC, not continuing\n", llproc()->getPid(), getLWP());
3445
3446       if (rpc->isProcStopRPC() || llproc()->plat_threadOpsNeedProcStop()) {
3447          getIRPCSetupState().desyncStateProc(int_thread::stopped);
3448       }
3449       else {
3450          getIRPCSetupState().desyncState(int_thread::stopped);
3451       }
3452       rpc->setState(int_iRPC::Prepping);
3453       new_ev = EventRPCLaunch::ptr(new EventRPCLaunch());
3454    }
3455    else if (bpi) {
3456       if (bpi->swBP()) {
3457          //Stop the process to clear a software breakpoint
3458          pthrd_printf("Found thread %d/%d to be stopped on a software BP, not continuing\n",
3459                       llproc()->getPid(), getLWP());
3460          getBreakpointState().desyncStateProc(int_thread::stopped);
3461          EventBreakpointClear::ptr evclear =  EventBreakpointClear::ptr(new EventBreakpointClear());
3462          evclear->getInternal()->stopped_proc = true;
3463          new_ev = evclear;
3464       }
3465       else {
3466          //No process stop needed for a hardware breakpoint
3467          pthrd_printf("Found thread %d/%d to be stopped on a hardware BP, not continuing\n",
3468                       llproc()->getPid(), getLWP());
3469          getBreakpointState().desyncState(int_thread::stopped);
3470          new_ev = EventBreakpointClear::ptr(new EventBreakpointClear());
3471       }
3472    }
3473    else {
3474       new_ev = llproc()->plat_throwEventsBeforeContinue(this);
3475    }
3476
3477    if (new_ev) {
3478       new_ev->setProcess(proc());
3479       new_ev->setThread(thread());
3480       new_ev->setSyncType(Event::async);
3481       new_ev->setSuppressCB(true);
3482       mbox()->enqueue(new_ev);
3483    }
3484 }
3485
3486 bool int_thread::isExiting() const
3487 {
3488     return handler_exiting_state;
3489 }
3490
3491 void int_thread::setExiting(bool b)
3492 {
3493     handler_exiting_state = b;
3494 }
3495
3496 bool int_thread::isExitingInGenerator() const
3497 {
3498     return generator_exiting_state;
3499 }
3500
3501 void int_thread::setExitingInGenerator(bool b)
3502 {
3503     generator_exiting_state = b;
3504 }
3505
3506 void int_thread::cleanFromHandler(int_thread *thrd, bool should_delete)
3507 {
3508    ProcPool()->condvar()->lock();
3509
3510 #if !defined(os_freebsd)   
3511    thrd->getUserState().setState(int_thread::exited);
3512 #else
3513    thrd->setExiting(true);
3514 #endif
3515
3516    if (should_delete) {
3517       thrd->getExitingState().setState(int_thread::exited);
3518           if(ProcPool()->findThread(thrd->getLWP()) != NULL) {
3519               ProcPool()->rmThread(thrd);
3520           }
3521           else {
3522                         pthrd_printf("%d/%d already gone from top level ProcPool(), not removing\n",
3523                                 thrd->llproc()->getPid(), thrd->getLWP());
3524           }
3525       thrd->llproc()->threadPool()->rmThread(thrd);
3526       delete thrd;
3527    }
3528    else {
3529       //If we're not yet deleting this thread, then we're dealing with
3530       // a pre-mature exit event.  The thread will be exiting soon, but
3531       // isn't there yet.  We'll run the thread instead to make sure it
3532       // reaches a proper exit.
3533       
3534       // If we're freeBSD, they don't give us a thread exit event and
3535       // so running only the exiting thread can result in a process
3536       // that is "executing" with no continued threads. That is bad. 
3537 #if !defined(os_freebsd)
3538       thrd->getExitingState().setState(int_thread::running);
3539 #endif
3540    }
3541    ProcPool()->condvar()->broadcast();
3542    ProcPool()->condvar()->unlock();
3543 }
3544
3545 Thread::ptr int_thread::thread()
3546 {
3547    return up_thread;
3548 }
3549
3550 bool int_thread::getAllRegisters(allreg_response::ptr response)
3551 {
3552    response->setThread(this);
3553    response->setProcess(llproc());
3554
3555    pthrd_printf("Reading registers for thread %d\n", getLWP());
3556
3557    regpool_lock.lock();
3558    if (cached_regpool.full && 0) {
3559       *response->getRegPool() = cached_regpool;
3560       response->getRegPool()->thread = this;
3561       response->markReady();
3562       pthrd_printf("Returning cached register set\n");
3563       regpool_lock.unlock();
3564       return true;
3565    }
3566
3567    if (!llproc()->plat_needsAsyncIO())
3568    {
3569       pthrd_printf("plat_getAllRegisters on %d/%d\n", llproc()->getPid(), getLWP());
3570       bool result = plat_getAllRegisters(cached_regpool);
3571       if (!result) {
3572          pthrd_printf("plat_getAllRegisters returned error on %d\n", getLWP());
3573          response->markError();
3574          regpool_lock.unlock();
3575          return false;
3576       }
3577       cached_regpool.full = true;
3578       *(response->getRegPool()) = cached_regpool;
3579       response->getRegPool()->thread = this;
3580       response->markReady();
3581       regpool_lock.unlock();
3582
3583       int_eventAsyncIO *iev = response->getAsyncIOEvent();
3584       if (iev) {
3585          pthrd_printf("Enqueueing new EventAsyncReadAllRegs into mailbox on synchronous platform\n");
3586          EventAsyncReadAllRegs::ptr ev = EventAsyncReadAllRegs::ptr(new EventAsyncReadAllRegs(iev));
3587          ev->setProcess(proc());
3588          ev->setThread(thread());
3589          ev->setSyncType(Event::async);
3590          mbox()->enqueue(ev);
3591       }
3592
3593       pthrd_printf("Successfully retrieved all registers for %d\n", getLWP());
3594    }
3595    else
3596    {
3597       pthrd_printf("Async plat_getAllRegisters on %d/%d\n", llproc()->getPid(), 
3598                    getLWP());
3599       regpool_lock.unlock();
3600       getResponses().lock();
3601       bool result = plat_getAllRegistersAsync(response);
3602       if (result) {
3603          getResponses().addResponse(response, llproc());
3604       }
3605       getResponses().unlock();
3606       getResponses().noteResponse();
3607       if (!result) {
3608          pthrd_printf("plat_getAllRegistersAsync returned error on %d\n", getLWP());
3609          return false;
3610       }
3611    }
3612
3613    return true;
3614 }
3615
3616 bool int_thread::setAllRegisters(int_registerPool &pool, result_response::ptr response)
3617 {
3618    assert(getHandlerState().getState() == int_thread::stopped);
3619    assert(getGeneratorState().getState() == int_thread::stopped);
3620    response->setProcess(llproc());
3621
3622    if (!llproc()->plat_needsAsyncIO()) {
3623       pthrd_printf("Setting registers for thread %d\n", getLWP());
3624       bool result = plat_setAllRegisters(pool);
3625       response->setResponse(result);
3626       if (!result) {
3627          pthrd_printf("plat_setAllRegisters returned error on %d\n", getLWP());
3628          return false;
3629       }
3630
3631       int_eventAsyncIO *iev = response->getAsyncIOEvent();
3632       if (iev) {
3633          pthrd_printf("Enqueueing new EventAsyncSetAllRegs into mailbox on synchronous platform\n");
3634          EventAsyncSetAllRegs::ptr ev = EventAsyncSetAllRegs::ptr(new EventAsyncSetAllRegs(iev));
3635          ev->setProcess(proc());
3636          ev->setThread(thread());
3637          ev->setSyncType(Event::async);
3638          mbox()->enqueue(ev);
3639       }
3640       pthrd_printf("Successfully set all registers for %d\n", getLWP());
3641    }
3642    else {
3643       pthrd_printf("Async setting registers for thread %d\n", getLWP());
3644       getResponses().lock();
3645       bool result = plat_setAllRegistersAsync(pool, response);
3646       if (result) {
3647          getResponses().addResponse(response, llproc());
3648       }
3649       getResponses().unlock();
3650       getResponses().noteResponse();
3651       if (!result) {
3652          pthrd_printf("Error async setting registers on %d\n", getLWP());
3653          return false;
3654       }
3655    }
3656
3657    regpool_lock.lock();
3658    cached_regpool = pool;
3659    cached_regpool.full = true;
3660    regpool_lock.unlock();
3661
3662    return true;
3663 }
3664
3665 bool int_thread::getRegister(Dyninst::MachRegister reg, reg_response::ptr response)
3666 {
3667    bool ret_result = false;
3668    pthrd_printf("Get register value for thread %d, register %s\n", lwp, reg.name().c_str());
3669    response->setRegThread(reg, this);
3670    response->setProcess(llproc());
3671
3672    if (!llproc()->plat_individualRegRead())
3673    {
3674       //Convert the single get register access into a get all registers
3675       pthrd_printf("Platform does not support individual register access, " 
3676                    "getting everything\n");
3677       if (!llproc()->plat_needsAsyncIO()) {
3678          int_registerPool pool;
3679          allreg_response::ptr allreg_resp = allreg_response::createAllRegResponse(&pool);
3680          bool result = getAllRegisters(allreg_resp);
3681          bool is_ready = allreg_resp->isReady();
3682          if (!result || allreg_resp->hasError()) {
3683             pthrd_printf("Unable to access full register set\n");
3684             return false;
3685          }
3686          assert(is_ready);
3687          response->setResponse(pool.regs[reg]);
3688       }
3689       else {
3690          allreg_response::ptr allreg_resp = allreg_response::createAllRegResponse(&cached_regpool);
3691          allreg_resp->setIndividualRegAccess(response, reg);
3692          getResponses().lock();
3693          getResponses().addResponse(response, llproc());
3694          getResponses().unlock();
3695          bool result = getAllRegisters(allreg_resp);
3696          if (!result) {
3697             pthrd_printf("Error accessing full register set\n");
3698             return false;
3699          }
3700          allreg_resp->isReady();
3701       }
3702       return true;
3703    }
3704
3705    regpool_lock.lock();
3706
3707    int_registerPool::reg_map_t::iterator i = cached_regpool.regs.find(reg);
3708    if (i != cached_regpool.regs.end()) {
3709       pthrd_printf("Had cached register value\n");
3710       response->setResponse(i->second);
3711    }
3712    else if (!llproc()->plat_needsAsyncIO()) {
3713       MachRegisterVal val = 0;
3714       bool result = plat_getRegister(reg, val);
3715       if (!result) {
3716          pthrd_printf("Error reading register value for %s on %d\n", reg.name().c_str(), lwp);
3717          response->markError(getLastError());
3718          goto done;
3719       }
3720       response->setResponse(val);
3721    }
3722    else {      
3723       pthrd_printf("Async getting register for thread %d\n", getLWP());
3724       getResponses().lock();
3725       bool result = plat_getRegisterAsync(reg, response);
3726       if (result) {
3727          getResponses().addResponse(response, llproc());
3728       }
3729       getResponses().unlock();
3730       getResponses().noteResponse();
3731       if (!result) {
3732          pthrd_printf("Error getting async register for thread %d\n", getLWP());
3733          goto done;
3734       }
3735       ret_result = true;
3736       goto done;
3737    }
3738
3739    pthrd_printf("Returning register value %lx for register %s on %d\n", 
3740                 response->getResult(), reg.name().c_str(), lwp);
3741
3742    ret_result = true;
3743   done: