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