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