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