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