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