proccontrol/src/process.C

   1 #include "proccontrol/src/int_process.h"
   2 #include "proccontrol/src/irpc.h"
   3 #include "proccontrol/src/procpool.h"
   4 #include "proccontrol/src/int_handler.h"
   5 #include "proccontrol/h/Mailbox.h"
   6 #include "proccontrol/h/PCErrors.h"
   7 #include "proccontrol/h/Generator.h"
   8 #include "proccontrol/h/Event.h"
   9 #include "proccontrol/h/Handler.h"
  10
  11 #include <cstring>
  12 #include <cassert>
  13
  14 using namespace Dyninst;
  15 using namespace std;
  16
  17 Process::thread_mode_t threadingMode = Process::GeneratorThreading;
  18 bool int_process::in_callback = false;
  19
  20 bool int_process::create()
  21 {
  22    ProcPool()->condvar()->lock();
  23
  24    bool result = plat_create();
  25    if (!result) {
  26       pthrd_printf("Could not create debuggee, %s\n", executable.c_str());
  27       ProcPool()->condvar()->unlock();
  28       return false;
  29    }
  30
  31    int_thread *initial_thread;
  32    initial_thread = int_thread::createThread(this, NULL_THR_ID, NULL_LWP, true);
  33
  34    ProcPool()->addProcess(this);
  35    setState(neonatal_intermediate);
  36
  37    ProcPool()->condvar()->broadcast();
  38    ProcPool()->condvar()->unlock();
  39
  40    pthrd_printf("Created debugged %s on pid %d\n", executable.c_str(), pid);
  41    result = waitfor_startup();
  42    if (getState() == int_process::exited) {
  43       pthrd_printf("Process %s exited during create\n", executable.c_str());
  44       return false;
  45    }
  46    if (!result) {
  47       pthrd_printf("Error during process create for %d\n", pid);
  48       return false;
  49    }
  50    result = post_create();
  51    if (!result) {
  52       pthrd_printf("Error during post create for %d\n", pid);
  53       return false;
  54    }
  55
  56    assert(getState() == running);
  57    return true;
  58 }
  59
  60 bool int_process::waitfor_startup()
  61 {
  62    bool proc_exited;
  63    for (;;) {
  64       bool result;
  65
  66       pthrd_printf("Waiting for startup to complete for %d\n", pid);
  67       result = waitAndHandleForProc(true, this, proc_exited);
  68       if (proc_exited || getState() == exited) {
  69          pthrd_printf("Error.  Proces exited during create/attach\n");
  70          return false;
  71       }
  72       if (!result || getState() == errorstate) {
  73          pthrd_printf("Error.  Process %d errored during create/attach\n", pid);
  74          return false;
  75       }
  76       if (getState() == running) {
  77          pthrd_printf("Successfully completed create/attach on %d\n", pid);
  78          return true;
  79       }
  80    }
  81 }
  82
  83 bool int_process::multi_attach(std::vector<int_process *> &pids)
  84 {
  85    bool result;
  86    bool had_error = false;
  87    std::vector<int_process *>::iterator i;
  88
  89 #define for_each_procdebug(func, err_msg)                      \
  90    for (i = pids.begin(); i != pids.end(); i++) {              \
  91       int_process *pd = (*i);                                  \
  92       if (!pd)                                                 \
  93          continue;                                             \
  94       result = pd->func();                                     \
  95       if (!result) {                                           \
  96          pthrd_printf("Could not %s to %d", err_msg, pd->pid); \
  97          delete pd;                                            \
  98          *i = NULL;                                            \
  99          had_error = true;                                     \
 100       }                                                        \
 101    }
 102
 103    ProcPool()->condvar()->lock();
 104
 105    for_each_procdebug(plat_attach, "attach");
 106    //MATT TODO: Add to ProcPool
 107
 108    ProcPool()->condvar()->broadcast();
 109    ProcPool()->condvar()->unlock();
 110
 111    for_each_procdebug(waitfor_startup, "wait for attach");
 112
 113    for_each_procdebug(post_attach, "post attach");
 114
 115    return had_error;
 116 }
 117
 118 bool int_process::attachThreads()
 119 {
 120    if (!needIndividualThreadAttach())
 121       return true;
 122
 123    /**
 124     * This OS (linux) needs us to attach to each thread manually.
 125     * Get all the thread LWPs and create new thread objects for them.
 126     * After we have all the threads, check again to see if there are any
 127     * new ones.  We're dealing with the race condition where we could get
 128     * a list of LWPs, but then new threads are created before we attach to
 129     * all the existing threads.
 130     **/
 131    bool found_new_threads;
 132    do {
 133       found_new_threads = false;
 134       vector<Dyninst::LWP> lwps;
 135       bool result = getThreadLWPs(lwps);
 136       if (!result) {
 137          perr_printf("Failed to get thread LWPs for %d\n", pid);
 138          return false;
 139       }
 140
 141       ProcPool()->condvar()->lock();
 142       for (vector<Dyninst::LWP>::iterator i = lwps.begin(); i != lwps.end(); i++) {
 143          int_thread *thr = threadpool->findThreadByLWP(*i);
 144          if (thr) {
 145             pthrd_printf("Already have thread %d in process %d\n", *i, pid);
 146             continue;
 147          }
 148          pthrd_printf("Creating new thread for %d/%d during attach\n", pid, *i);
 149          thr = int_thread::createThread(this, NULL_THR_ID, *i, false);
 150          found_new_threads = true;
 151       }
 152       ProcPool()->condvar()->broadcast();
 153       ProcPool()->condvar()->unlock();
 154    } while (found_new_threads);
 155    return true;
 156 }
 157
 158 bool int_process::attach()
 159 {
 160    ProcPool()->condvar()->lock();
 161
 162    pthrd_printf("Attaching to process %d\n", pid);
 163    bool result = plat_attach();
 164    if (!result) {
 165       ProcPool()->condvar()->broadcast();
 166       ProcPool()->condvar()->unlock();
 167       pthrd_printf("Could not attach to debuggee, %d\n", pid);
 168       return false;
 169    }
 170
 171    int_thread *initial_thread;
 172    initial_thread = int_thread::createThread(this, NULL_THR_ID, NULL_LWP, true);
 173
 174    ProcPool()->addProcess(this);
 175
 176    setState(neonatal_intermediate);
 177
 178    ProcPool()->condvar()->broadcast();
 179    ProcPool()->condvar()->unlock();
 180
 181    result = attachThreads();
 182    if (!result) {
 183       pthrd_printf("Failed to attach to threads in %d\n", pid);
 184       setLastError(err_internal, "Could not attach to process' threads");
 185       goto error;
 186    }
 187
 188    pthrd_printf("Wait for attach from process %d\n", pid);
 189    result = waitfor_startup();
 190    if (!result) {
 191       pthrd_printf("Error waiting for attach to %d\n", pid);
 192       setLastError(err_internal, "Process failed to startup");
 193       goto error;
 194    }
 195
 196    result = post_attach();
 197    if (!result) {
 198       pthrd_printf("Error on post attach for %d\n", pid);
 199       setLastError(err_internal, "Process failed post-startup");
 200       goto error;
 201    }
 202
 203    return true;
 204
 205   error:
 206    if (getState() == exited) {
 207       setLastError(err_exited, "Process exited unexpectedly during attach\n");
 208       return false;
 209    }
 210    pthrd_printf("Error during process attach for %d\n", pid);
 211    return false;
 212 }
 213
 214 bool int_process::execed()
 215 {
 216    ProcPool()->condvar()->lock();
 217
 218    bool should_clean = false;
 219    mem->rmProc(this, should_clean);
 220    if (should_clean)
 221       delete mem;
 222    mem = new mem_state(this);
 223
 224    arch = Dyninst::Arch_none;
 225    exec_mem_cache.clear();
 226
 227    while (!proc_stoppers.empty()) proc_stoppers.pop();
 228
 229    int_threadPool::iterator i = threadpool->begin();
 230    for (; i != threadpool->end(); i++) {
 231       int_thread *thrd = *i;
 232       thrd->setHandlerState(int_thread::exited);
 233       thrd->setInternalState(int_thread::exited);
 234       thrd->setUserState(int_thread::exited);
 235       thrd->setGeneratorState(int_thread::exited);
 236       ProcPool()->rmThread(thrd);
 237       delete thrd;
 238    }
 239    threadpool->clear();
 240
 241
 242    int_thread *initial_thread;
 243    initial_thread = int_thread::createThread(this, NULL_THR_ID, NULL_LWP, true);
 244    initial_thread->setGeneratorState(int_thread::stopped);
 245    initial_thread->setHandlerState(int_thread::stopped);
 246    initial_thread->setInternalState(int_thread::running);
 247    initial_thread->setUserState(int_thread::running);
 248
 249
 250    ProcPool()->condvar()->broadcast();
 251    ProcPool()->condvar()->unlock();
 252
 253    bool result = plat_execed();
 254
 255    return result;
 256 }
 257
 258 bool int_process::forked()
 259 {
 260    ProcPool()->condvar()->lock();
 261
 262    pthrd_printf("Setting up forked process %d\n", pid);
 263    bool result = plat_forked();
 264    if (!result) {
 265       pthrd_printf("Could not handle forked debuggee, %d\n", pid);
 266       return false;
 267    }
 268
 269    int_thread *initial_thread;
 270    initial_thread = int_thread::createThread(this, NULL_THR_ID, NULL_LWP, true);
 271
 272    ProcPool()->addProcess(this);
 273
 274    ProcPool()->condvar()->broadcast();
 275    ProcPool()->condvar()->unlock();
 276
 277    result = attachThreads();
 278    if (!result) {
 279       pthrd_printf("Failed to attach to threads in %d\n", pid);
 280       setLastError(err_internal, "Could not attach to process' threads");
 281       goto error;
 282    }
 283
 284    result = post_forked();
 285    if (!result) {
 286       pthrd_printf("Post-fork failed on %d\n", pid);
 287       setLastError(err_internal, "Error handling forked process");
 288       goto error;
 289    }
 290    return true;
 291
 292   error:
 293    if (getState() == exited) {
 294       setLastError(err_exited, "Process exited unexpectedly during attach\n");
 295       return false;
 296    }
 297    pthrd_printf("Error during process attach for %d\n", pid);
 298    return false;
 299 }
 300
 301 bool int_process::post_forked()
 302 {
 303    setState(running);
 304    return true;
 305 }
 306
 307 bool int_process::post_attach()
 308 {
 309    bool result = initLibraryMechanism();
 310    if (!result) {
 311       pthrd_printf("Error initializing library mechanism\n");
 312       return false;
 313    }
 314
 315    std::set<int_library*> added, rmd;
 316    result = refresh_libraries(added, rmd);
 317
 318    return true;
 319 }
 320
 321 bool int_process::post_create()
 322 {
 323    return initLibraryMechanism();
 324 }
 325
 326 bool int_process::getThreadLWPs(std::vector<Dyninst::LWP> &)
 327 {
 328    return false;
 329 }
 330
 331 const char *int_process::stateName(int_process::State s)
 332 {
 333    switch (s) {
 334       case neonatal: return "neonatal";
 335       case neonatal_intermediate: return "neonatal_intermediate";
 336       case running: return "running";
 337       case exited: return "exited";
 338       case errorstate: return "errorstate";
 339    }
 340    assert(0);
 341    return NULL;
 342 }
 343
 344 void int_process::setState(int_process::State s)
 345 {
 346    int old_state = (int) state;
 347    int new_state = (int) s;
 348
 349    if (new_state < old_state) {
 350       perr_printf("Regression of state %s to %s on %d\n",
 351                   stateName(state), stateName(s), pid);
 352       return;
 353    }
 354    pthrd_printf("Changing state of process from %s to %s on %d\n",
 355                 stateName(state), stateName(s), pid);
 356    state = s;
 357
 358    int_thread::State new_thr_state = int_thread::errorstate;
 359    switch (s) {
 360       case neonatal: new_thr_state = int_thread::neonatal; break;
 361       case neonatal_intermediate: new_thr_state = int_thread::neonatal_intermediate; break;
 362       case running: new_thr_state = int_thread::stopped; break;
 363       case exited: new_thr_state = int_thread::exited; break;
 364       case errorstate: new_thr_state = int_thread::errorstate; break;
 365    }
 366    pthrd_printf("Setting state of all threads in %d to %s\n", pid,
 367                 int_thread::stateStr(new_thr_state));
 368    for (int_threadPool::iterator i = threadpool->begin(); i != threadpool->end(); i++)
 369    {
 370       (*i)->setUserState(new_thr_state);
 371       (*i)->setInternalState(new_thr_state);
 372       (*i)->setHandlerState(new_thr_state);
 373       (*i)->setGeneratorState(new_thr_state);
 374    }
 375 }
 376
 377 int_process::State int_process::getState() const
 378 {
 379    return state;
 380 }
 381
 382 void int_process::setContSignal(int sig) {
 383     continueSig = sig;
 384 }
 385
 386 int int_process::getContSignal() const {
 387     return continueSig;
 388 }
 389
 390 void int_process::setPid(Dyninst::PID p)
 391 {
 392    pthrd_printf("Setting int_process %p to pid %d\n", this, p);
 393    pid = p;
 394 }
 395
 396 Dyninst::PID int_process::getPid() const
 397 {
 398    return pid;
 399 }
 400
 401 int_threadPool *int_process::threadPool() const
 402 {
 403    return threadpool;
 404 }
 405
 406 Process::ptr int_process::proc() const
 407 {
 408    return up_proc;
 409 }
 410
 411 struct syncRunStateRet_t {
 412    bool hasRunningThread;
 413    bool hasSyncRPC;
 414    bool hasStopPending;
 415    bool hasContinuePending;
 416    bool hasClearingBP;
 417    bool hasProcStopRPC;
 418    std::vector<int_process *> readyProcStoppers;
 419    syncRunStateRet_t() :
 420       hasRunningThread(false),
 421       hasSyncRPC(false),
 422       hasStopPending(false),
 423       hasContinuePending(false),
 424       hasClearingBP(false),
 425       hasProcStopRPC(false)
 426    {
 427    }
 428 };
 429
 430 bool syncRunState(int_process *p, void *r)
 431 {
 432    int_threadPool *tp = p->threadPool();
 433    syncRunStateRet_t *ret = (syncRunStateRet_t *) r;
 434    assert(ret);
 435
 436    if (p->hasQueuedProcStoppers() && p->threadPool()->allStopped()) {
 437       ret->readyProcStoppers.push_back(p);
 438    }
 439    if (p->forceGeneratorBlock()) {
 440       pthrd_printf("Process %d is forcing blocking via generator block\n", p->getPid());
 441       ret->hasRunningThread = true;
 442    }
 443
 444    if (dyninst_debug_proccontrol) {
 445       for (int_threadPool::iterator i = tp->begin(); i != tp->end(); i++)
 446       {
 447          int_thread *thr = *i;
 448          pthrd_printf("Pre-Thread %d/%d is in handler state %s with internal state %s (user is %s)\n",
 449                       p->getPid(), thr->getLWP(),
 450                       int_thread::stateStr(thr->getHandlerState()),
 451                       int_thread::stateStr(thr->getInternalState()),
 452                       int_thread::stateStr(thr->getUserState()));
 453       }
 454    }
 455
 456    /**
 457     * RPC Handling.
 458     **/
 459    bool force_leave_stopped = false;
 460    for (int_threadPool::iterator i = tp->begin(); i != tp->end(); i++)
 461    {
 462       int_thread *thr = *i;
 463       thr->handleNextPostedIRPC(false);
 464
 465       int_iRPC::ptr rpc = thr->hasRunningProcStopperRPC();
 466       if (!rpc)
 467          continue;
 468       ret->hasProcStopRPC = true;
 469       if (rpc->getState() >= int_iRPC::Prepping) {
 470          pthrd_printf("Thread %d/%d has pending proc stopper RPC, leaving other threads stopped\n",
 471                       p->getPid(), thr->getLWP());
 472          force_leave_stopped = true;
 473       }
 474    }
 475
 476    for (int_threadPool::iterator i = tp->begin(); i != tp->end(); i++)
 477    {
 478       int_thread *thr = *i;
 479
 480       if (thr->hasPendingStop()) {
 481          ret->hasStopPending = true;
 482       }
 483       if (thr->hasPendingUserContinue()) {
 484           ret->hasContinuePending = true;
 485       }
 486       if (thr->isClearingBreakpoint()) {
 487          ret->hasClearingBP = true;
 488       }
 489
 490       int_iRPC::ptr pstop_rpc = thr->hasRunningProcStopperRPC();
 491       if (thr->hasPendingStop() && thr->getHandlerState() == int_thread::stopped) {
 492          pthrd_printf("Continuing thread %d/%d to clear out pending stop\n",
 493                       thr->llproc()->getPid(), thr->getLWP());
 494          thr->intCont();
 495       }
 496       else if (thr->getInternalState() == int_thread::stopped && pstop_rpc &&
 497                (pstop_rpc->getState() == int_iRPC::Running ||
 498                 pstop_rpc->getState() == int_iRPC::Ready))
 499       {
 500          pthrd_printf("Continuing thread %d/%d due to pending procstop iRPC\n",
 501                       p->getPid(), thr->getLWP());
 502          thr->intCont();
 503       }
 504       else if (pstop_rpc &&
 505                thr->getInternalState() == int_thread::running &&
 506                thr->getHandlerState() == int_thread::stopped &&
 507                pstop_rpc == thr->runningRPC())
 508       {
 509          pthrd_printf("Thread %d/%d was stopped during proccstopper (maybe due to signal).",
 510                       p->getPid(), thr->getLWP());
 511          thr->intCont();
 512       }
 513       else if (thr->getInternalState() == int_thread::running &&
 514                thr->getHandlerState() == int_thread::stopped &&
 515                !force_leave_stopped)
 516       {
 517          //The thread is stopped, but the user wants it running (we probably just finished
 518          // handling a sync event). Go ahead and continue the thread.
 519          pthrd_printf("Continuing thread %d/%d to match internal state after events\n",
 520                       p->getPid(), thr->getLWP());
 521          thr->intCont();
 522       }
 523
 524       if (thr->getInternalState() == int_thread::running ||
 525           thr->getInternalState() == int_thread::neonatal_intermediate) {
 526          //Keep track if any threads are running and running synchronous RPCs
 527          ret->hasRunningThread = true;
 528          if (thr->hasSyncRPC()) {
 529             ret->hasSyncRPC = true;
 530          }
 531       }
 532    }
 533    pthrd_printf("Finished syncing runState for %d\n", p->getPid());
 534    if (dyninst_debug_proccontrol) {
 535       for (int_threadPool::iterator i = tp->begin(); i != tp->end(); i++)
 536       {
 537          int_thread *thr = *i;
 538          pthrd_printf("Post-Thread %d/%d is in handler state %s with internal state %s (user is %s)\n",
 539                       p->getPid(), thr->getLWP(),
 540                       int_thread::stateStr(thr->getHandlerState()),
 541                       int_thread::stateStr(thr->getInternalState()),
 542                       int_thread::stateStr(thr->getUserState()));
 543       }
 544    }
 545    return true;
 546 }
 547
 548 static
 549 bool doPlatContProcess(int_process *p, void * /*unused*/) {
 550     bool hasPendingContinue = false;
 551     int_threadPool::iterator i;
 552     for(i = p->threadPool()->begin(); i != p->threadPool()->end(); ++i) {
 553         if( (*i)->hasPendingContinue() ) {
 554             // These continues require handler attention -- postpone until then
 555             if( !(*i)->hasPendingUserContinue() ) {
 556                 hasPendingContinue = true;
 557                 pthrd_printf("Unsetting pending continue for %d/%d\n",
 558                         p->getPid(), (*i)->getLWP());
 559
 560                 (*i)->setPendingContinue(false);
 561             }
 562         }
 563     }
 564
 565     if( hasPendingContinue ) {
 566         if( !p->plat_contProcess() ) {
 567             perr_printf("Failed to continue whole process\n");
 568             return false;
 569         }
 570     }else{
 571         pthrd_printf("No pending continue found for PID %d, skipping continue\n",
 572                 p->getPid());
 573     }
 574
 575     return true;
 576 }
 577
 578 int_process *int_process::in_waitHandleProc = NULL;
 579 bool int_process::waitAndHandleForProc(bool block, int_process *proc, bool &proc_exited)
 580 {
 581    assert(in_waitHandleProc == NULL);
 582    in_waitHandleProc = proc;
 583
 584    bool result = waitAndHandleEvents(block);
 585
 586
 587    if (proc->getState() == int_process::exited) {
 588       pthrd_printf("Deleting proc %d from waitAndHandleForProc\n", proc->getPid());
 589       delete proc;
 590       proc_exited = true;
 591    }
 592    else {
 593       proc_exited = false;
 594    }
 595
 596    in_waitHandleProc = NULL;
 597    return result;
 598 }
 599
 600
 601 bool int_process::waitAndHandleEvents(bool block)
 602 {
 603    bool gotEvent = false;
 604    assert(!int_process::in_callback);
 605    bool error = false;
 606
 607    static bool recurse = false;
 608    assert(!recurse);
 609    recurse = true;
 610
 611    for (;;)
 612    {
 613       /**
 614        * Check status of threads
 615        **/
 616       pthrd_printf("Updating state of each process\n");
 617       syncRunStateRet_t ret;
 618       ProcPool()->for_each(syncRunState, &ret);
 619
 620       if( getThreadControlMode() == HybridLWPControl ) {
 621         ProcPool()->for_each(doPlatContProcess, NULL);
 622       }
 623
 624       if (ret.readyProcStoppers.size()) {
 625          int_process *proc = ret.readyProcStoppers[0];
 626          Event::ptr ev = proc->removeProcStopper();
 627          if (ev->triggersCB() &&
 628              isHandlerThread() &&
 629              mt()->getThreadMode() == Process::HandlerThreading)
 630          {
 631             pthrd_printf("Handler thread sees postponed callback requiring "
 632                          "event '%s', not taking\n",
 633                          ev->name().c_str());
 634             notify()->noteEvent();
 635             goto done;
 636          }
 637
 638          pthrd_printf("Handling postponed proc stopper event on %d\n", proc->getPid());
 639          proc->handlerpool->handleEvent(ev);
 640          continue;
 641       }
 642
 643       /**
 644        * Check for possible error combinations from syncRunState
 645        **/
 646       if (!ret.hasRunningThread) {
 647          if (gotEvent) {
 648             //We've successfully handled an event, but no longer have any running threads
 649             pthrd_printf("Returning after handling events, no threads running\n");
 650             goto done;
 651          }
 652          if (isHandlerThread()) {
 653             //Not an error for the handler thread to get no events.
 654             pthrd_printf("Returning to handler due to no running threads\n");
 655             goto done;
 656          }
 657          //The user called us with no running threads
 658          setLastError(err_notrunning, "No running processes or threads to receive events on");
 659          pthrd_printf("No running threads, returning from waitAndHandleEvents\n");
 660          error = true;
 661          goto done;
 662       }
 663
 664       /**
 665        * The handler thread doesn't want to pick up anything that
 666        * requires a callback, leaving that for the user.  Peek ahead
 667        * in the mailbox and abort out if we're the handler thread and
 668        * the next event will require a callback.
 669        **/
 670       if (isHandlerThread() && mt()->getThreadMode() == Process::HandlerThreading) {
 671          Event::ptr ev = mbox()->peek();
 672          if (ev == Event::ptr())
 673          {
 674             pthrd_printf("Handler thread returning due to lack of events\n");
 675             goto done;
 676          }
 677          if (ev->triggersCB())
 678          {
 679             pthrd_printf("Handler thread sees callback requiring event '%s', "
 680                          "not taking\n", ev->name().c_str());
 681             notify()->noteEvent();
 682             goto done;
 683          }
 684       }
 685       /**
 686        * Check for new events
 687        **/
 688       bool should_block = ((block && !gotEvent) || ret.hasStopPending ||
 689                            ret.hasSyncRPC || ret.hasClearingBP || ret.hasProcStopRPC ||
 690                            ret.hasContinuePending);
 691       pthrd_printf("%s for events (%d %d %d %d %d %d %d)\n",
 692                    should_block ? "Blocking" : "Polling",
 693                    (int) block, (int) gotEvent, (int) ret.hasStopPending,
 694                    (int) ret.hasSyncRPC, (int) ret.hasClearingBP, (int) ret.hasProcStopRPC,
 695                    (int) ret.hasContinuePending);
 696       Event::ptr ev = mbox()->dequeue(should_block);
 697
 698       if (ev == Event::ptr())
 699       {
 700          if (block && gotEvent) {
 701             pthrd_printf("Returning after handling events\n");
 702             goto done;
 703          }
 704          if (should_block) {
 705             perr_printf("Blocking wait failed to get events\n");
 706             setLastError(err_internal, "Blocking wait returned without events");
 707             error = true;
 708             goto done;
 709          }
 710          if (isHandlerThread()) {
 711             pthrd_printf("Handler thread found nothing to do\n");
 712             goto done;
 713          }
 714          setLastError(err_noevents, "Poll failed to find events");
 715          pthrd_printf("Poll failed to find events\n");
 716          error = true;
 717          goto done;
 718       }
 719       if (mt()->getThreadMode() == Process::NoThreads ||
 720           mt()->getThreadMode() == Process::GeneratorThreading)
 721       {
 722          pthrd_printf("Clearing event from pipe after dequeue\n");
 723          notify()->clearEvent();
 724       }
 725       gotEvent = true;
 726
 727       ev->getProcess()->llproc()->updateSyncState(ev, false);
 728
 729       if (ev->procStopper()) {
 730          /**
 731           * This event wants the process stopped before it gets handled.
 732           * We'll start that here, and then postpone the event until it's
 733           * stopped.  It's up to the event to continue the process again.
 734           **/
 735          int_process *proc = ev->getProcess()->llproc();
 736          proc->threadPool()->desyncInternalState();
 737          bool result = proc->threadPool()->intStop(false);
 738          if (!result) {
 739             pthrd_printf("Failed to stop process for event.\n");
 740          }
 741          else {
 742             proc->addProcStopper(ev);
 743          }
 744          continue;
 745       }
 746
 747       HandlerPool *hpool = ev->getProcess()->llproc()->handlerpool;
 748       hpool->handleEvent(ev);
 749
 750       if (!ev->getProcess()->llproc())
 751       {
 752          //Special case event handling, the process cleaned itself
 753          // under this event (likely post-exit or post-crash), but was
 754          // unable to clean its handlerpool (as we were using it).
 755          // Clean this for the process now.
 756          delete hpool;
 757       }
 758    }
 759   done:
 760    recurse = false;
 761    return !error;
 762 }
 763
 764 bool int_process::detach(bool &should_delete)
 765 {
 766    should_delete = false;
 767    bool had_error = true;
 768    bool result;
 769    int_threadPool *tp = threadPool();
 770    pthrd_printf("Detach requested on %d\n", getPid());
 771    while (!tp->allStopped()) {
 772       pthrd_printf("Stopping process for detach\n");
 773       tp->intStop(true);
 774    }
 775
 776    while (!mem->breakpoints.empty())
 777    {
 778       std::map<Dyninst::Address, installed_breakpoint *>::iterator i = mem->breakpoints.begin();
 779       bool result = i->second->uninstall(this);
 780       if (!result) {
 781          perr_printf("Error removing breakpoint at %lx\n", i->first);
 782          setLastError(err_internal, "Error removing breakpoint before detach\n");
 783          goto done;
 784       }
 785    }
 786
 787    ProcPool()->condvar()->lock();
 788
 789    result = plat_detach();
 790    if (!result) {
 791       pthrd_printf("Error performing lowlevel detach\n");
 792       goto done;
 793    }
 794
 795    had_error = false;
 796   done:
 797    ProcPool()->condvar()->signal();
 798    ProcPool()->condvar()->unlock();
 799
 800    if (had_error)
 801       return false;
 802    should_delete = true;
 803    return true;
 804 }
 805
 806 bool int_process::terminate(bool &needs_sync)
 807 {
 808    pthrd_printf("Terminate requested on process %d\n", getPid());
 809    bool had_error = true;
 810    ProcPool()->condvar()->lock();
 811    bool result = plat_terminate(needs_sync);
 812    if (!result) {
 813       pthrd_printf("plat_terminate failed on %d\n", getPid());
 814       goto done;
 815    }
 816    setForceGeneratorBlock(true);
 817    had_error = false;
 818   done:
 819    ProcPool()->condvar()->signal();
 820    ProcPool()->condvar()->unlock();
 821    return !had_error;
 822 }
 823
 824 int_process::int_process(Dyninst::PID p, std::string e, std::vector<std::string> a) :
 825    state(neonatal),
 826    pid(p),
 827    executable(e),
 828    argv(a),
 829    arch(Dyninst::Arch_none),
 830    threadpool(NULL),
 831    up_proc(Process::ptr()),
 832    handlerpool(NULL),
 833    hasCrashSignal(false),
 834    crashSignal(0),
 835    hasExitCode(false),
 836    forceGenerator(false),
 837    exitCode(0),
 838    mem(NULL),
 839    continueSig(0)
 840 {
 841    //Put any object initialization in 'initializeProcess', below.
 842 }
 843
 844 int_process::int_process(Dyninst::PID pid_, int_process *p) :
 845    state(int_process::running),
 846    pid(pid_),
 847    executable(p->executable),
 848    argv(p->argv),
 849    arch(p->arch),
 850    hasCrashSignal(p->hasCrashSignal),
 851    crashSignal(p->crashSignal),
 852    hasExitCode(p->hasExitCode),
 853    forceGenerator(false),
 854    exitCode(p->exitCode),
 855    exec_mem_cache(exec_mem_cache),
 856    continueSig(p->continueSig)
 857 {
 858    Process::ptr hlproc = Process::ptr(new Process());
 859    mem = new mem_state(*p->mem, this);
 860    initializeProcess(hlproc);
 861 }
 862
 863 void int_process::initializeProcess(Process::ptr p)
 864 {
 865    p->llproc_ = this;
 866    up_proc = p;
 867    threadpool = new int_threadPool(this);
 868    handlerpool = createDefaultHandlerPool();
 869    libpool.proc = this;
 870    if (!mem)
 871       mem = new mem_state(this);
 872    Generator::getDefaultGenerator(); //May create generator thread
 873 }
 874
 875 int_thread *int_process::findStoppedThread()
 876 {
 877    ProcPool()->condvar()->lock();
 878    int_thread *result = NULL;
 879    for (int_threadPool::iterator i = threadpool->begin(); i != threadpool->end(); i++)
 880    {
 881       int_thread *thr = *i;
 882       if (thr->getHandlerState() == int_thread::stopped) {
 883          result = thr;
 884          break;
 885       }
 886    }
 887    ProcPool()->condvar()->unlock();
 888    if (result) {
 889       assert(result->getGeneratorState() == int_thread::stopped);
 890    }
 891    return result;
 892 }
 893
 894 bool int_process::readMem(void *local, Dyninst::Address remote, size_t size)
 895 {
 896    int_thread *thr = findStoppedThread();
 897    if (!thr) {
 898       setLastError(err_notstopped, "A thread must be stopped to read from memory");
 899       perr_printf("Unable to find a stopped thread for read in process %d\n", getPid());
 900       return false;
 901    }
 902    pthrd_printf("Reading from remote memory %lx to %p, size = %lu on %d/%d\n",
 903                 remote, local, (unsigned long) size, getPid(), thr->getLWP());
 904    return plat_readMem(thr, local, remote, size);
 905 }
 906
 907 bool int_process::writeMem(void *local, Dyninst::Address remote, size_t size)
 908 {
 909    int_thread *thr = findStoppedThread();
 910    if (!thr) {
 911       setLastError(err_notstopped, "A thread must be stopped to write to memory");
 912       perr_printf("Unable to find a stopped thread for write in process %d\n", getPid());
 913       return false;
 914    }
 915    pthrd_printf("Writing to remote memory %lx from %p, size = %lu on %d/%d\n",
 916                 remote, local, (unsigned long) size, getPid(), thr->getLWP());
 917    return plat_writeMem(thr, local, remote, size);
 918 }
 919
 920 Dyninst::Address int_process::mallocExecMemory(unsigned size)
 921 {
 922    Dyninst::Address max = 0;
 923    std::map<Dyninst::Address, unsigned>::iterator i;
 924    for (i = exec_mem_cache.begin(); i != exec_mem_cache.end(); i++) {
 925       if (i->first + i->second > max)
 926          max = i->first + i->second;
 927    }
 928
 929    Dyninst::Address addr = plat_mallocExecMemory(max, size);
 930    exec_mem_cache[addr] = size;
 931    return addr;
 932 }
 933
 934 void int_process::freeExecMemory(Dyninst::Address addr)
 935 {
 936    std::map<Dyninst::Address, unsigned>::iterator i;
 937    i = exec_mem_cache.find(addr);
 938    assert(i != exec_mem_cache.end());
 939    exec_mem_cache.erase(i);
 940 }
 941
 942 Dyninst::Address int_process::infMalloc(unsigned long size, bool use_addr, Dyninst::Address addr)
 943 {
 944    pthrd_printf("Process %d is allocating memory of size %lu at 0x%lx\n", getPid(), size, addr);
 945    int_iRPC::ptr rpc = rpcMgr()->createInfMallocRPC(this, size, use_addr, addr);
 946    assert(rpc);
 947    rpcMgr()->postRPCToProc(this, rpc);
 948
 949    int_thread *thr = rpc->thread();
 950    bool result = thr->handleNextPostedIRPC(true);
 951    if (!result) {
 952       pthrd_printf("Failed to handleNextPostedIRPC\n");
 953       return 0;
 954    }
 955
 956    if (rpc->getState() != int_iRPC::Finished)
 957    {
 958       bool proc_exited;
 959       result = waitAndHandleForProc(true, this, proc_exited);
 960       if (proc_exited) {
 961          perr_printf("Process exited during infMalloc\n");
 962          setLastError(err_exited, "Process exited during infMalloc\n");
 963          return 0;
 964       }
 965       if (!result) {
 966          pthrd_printf("Error in waitAndHandleEvents");
 967          return 0;
 968       }
 969    }
 970    assert(rpc->getState() == int_iRPC::Finished);
 971
 972    Dyninst::Address aresult = rpc->infMallocResult();
 973    pthrd_printf("Inferior malloc returning %lx\n", aresult);
 974    mem->inf_malloced_memory[aresult] = size;
 975    return aresult;
 976 }
 977
 978 bool int_process::infFree(Dyninst::Address addr)
 979 {
 980    std::map<Dyninst::Address, unsigned long>::iterator i = mem->inf_malloced_memory.find(addr);
 981    if (i == mem->inf_malloced_memory.end()) {
 982       setLastError(err_badparam, "Unknown address passed to freeMemory");
 983       perr_printf("Passed bad address, %lx, to infFree\n", addr);
 984       return false;
 985    }
 986    unsigned long size = i->second;
 987
 988    int_iRPC::ptr rpc = rpcMgr()->createInfFreeRPC(this, size, addr);
 989    assert(rpc);
 990    pthrd_printf("Process %d is freeing memory of size %lu at 0x%lx with rpc %lu\n", getPid(), size, addr,
 991                 rpc->id());
 992    rpcMgr()->postRPCToProc(this, rpc);
 993
 994    int_thread *thr = rpc->thread();
 995    bool result = thr->handleNextPostedIRPC(true);
 996    if (!result) {
 997       pthrd_printf("Failed to handleNextPostedIRPC\n");
 998       return 0;
 999    }
1000
1001    if (rpc->getState() != int_iRPC::Finished)
1002    {
1003       bool proc_exited;
1004       result = waitAndHandleForProc(true, this, proc_exited);
1005       if (proc_exited) {
1006          perr_printf("Process exited during infFree\n");
1007          setLastError(err_exited, "Process exited during infFree\n");
1008          return false;
1009       }
1010       if (!result) {
1011          pthrd_printf("Error in waitAndHandleEvents");
1012          return false;
1013       }
1014    }
1015    assert(rpc->getState() == int_iRPC::Finished);
1016
1017    pthrd_printf("Inferior free returning successfully\n");
1018    mem->inf_malloced_memory.erase(i);
1019    return true;
1020 }
1021
1022 void int_process::addProcStopper(Event::ptr ev)
1023 {
1024    proc_stoppers.push(ev);
1025 }
1026
1027 bool int_process::forceGeneratorBlock() const
1028 {
1029    return forceGenerator;
1030 }
1031
1032 void int_process::setForceGeneratorBlock(bool b)
1033 {
1034    forceGenerator = b;
1035 }
1036
1037 Event::ptr int_process::removeProcStopper()
1038 {
1039    assert(proc_stoppers.size());
1040    Event::ptr ret = proc_stoppers.front();
1041    proc_stoppers.pop();
1042    return ret;
1043 }
1044
1045 bool int_process::hasQueuedProcStoppers() const
1046 {
1047    return !proc_stoppers.empty();
1048 }
1049
1050 int int_process::getAddressWidth()
1051 {
1052    switch (getTargetArch()) {
1053       case Arch_x86:
1054       case Arch_ppc32:
1055          return 4;
1056       case Arch_x86_64:
1057       case Arch_ppc64:
1058          return 8;
1059       case Arch_none:
1060          assert(0);
1061    }
1062    return 0;
1063 }
1064
1065 HandlerPool *int_process::handlerPool() const
1066 {
1067    return handlerpool;
1068 }
1069
1070 bool int_process::addBreakpoint(Dyninst::Address addr, int_breakpoint *bp)
1071 {
1072    if (getState() != running) {
1073       perr_printf("Attempted to add breakpoint at %lx to stopped process %d\n", addr, getPid());
1074       setLastError(err_exited, "Attempted to insert breakpoint into exited process\n");
1075       return false;
1076    }
1077
1078    pthrd_printf("Installing new breakpoint at %lx into %d\n", addr, getPid());
1079    installed_breakpoint *ibp = NULL;
1080    map<Address, installed_breakpoint *>::iterator i = mem->breakpoints.find(addr);
1081    if (i == mem->breakpoints.end()) {
1082       pthrd_printf("Adding new breakpoint to %d\n", getPid());
1083       ibp = new installed_breakpoint(mem, addr);
1084       ibp->addBreakpoint(this, bp);
1085       bool result = ibp->install(this);
1086       if (!result) {
1087          pthrd_printf("Failed to install new breakpoint\n");
1088          return false;
1089       }
1090       return true;
1091    }
1092    ibp = i->second;
1093    assert(ibp && ibp->isInstalled());
1094    bool result = ibp->addBreakpoint(this, bp);
1095    if (!result) {
1096       pthrd_printf("Failed to install new breakpoint\n");
1097       return false;
1098    }
1099
1100    return true;
1101 }
1102
1103 bool int_process::rmBreakpoint(Dyninst::Address addr, int_breakpoint *bp)
1104 {
1105    map<Address, installed_breakpoint *>::iterator i = mem->breakpoints.find(addr);
1106    if (i == mem->breakpoints.end()) {
1107       perr_printf("Attempted to removed breakpoint that isn't installed\n");
1108       return false;
1109    }
1110    installed_breakpoint *ibp = i->second;
1111    assert(ibp && ibp->isInstalled());
1112
1113    bool empty;
1114    bool result = ibp->rmBreakpoint(this, bp, empty);
1115    if (!result) {
1116       pthrd_printf("rmBreakpoint failed on breakpoint at %lx in %d\n", addr, getPid());
1117       return false;
1118    }
1119    if (empty) {
1120       delete ibp;
1121    }
1122
1123    return true;
1124 }
1125
1126 installed_breakpoint *int_process::getBreakpoint(Dyninst::Address addr)
1127 {
1128    std::map<Dyninst::Address, installed_breakpoint *>::iterator  i = mem->breakpoints.find(addr);
1129    if (i == mem->breakpoints.end())
1130       return NULL;
1131    return i->second;
1132 }
1133
1134 int_library *int_process::getLibraryByName(std::string s) const
1135 {
1136    for (set<int_library *>::iterator i = mem->libs.begin();
1137         i != mem->libs.end(); i++)
1138    {
1139       if (s == (*i)->getName())
1140          return *i;
1141    }
1142    return NULL;
1143 }
1144
1145 size_t int_process::numLibs() const
1146 {
1147    return mem->libs.size();
1148 }
1149
1150 std::string int_process::getExecutable() const
1151 {
1152    return executable;
1153 }
1154
1155 bool int_process::isInCallback()
1156 {
1157    return in_callback;
1158 }
1159
1160 mem_state::ptr int_process::memory() const
1161 {
1162    return mem;
1163 }
1164
1165 void int_process::setExitCode(int c)
1166 {
1167    assert(!hasCrashSignal);
1168    hasExitCode = true;
1169    exitCode = c;
1170 }
1171
1172 void int_process::setCrashSignal(int s)
1173 {
1174    assert(!hasExitCode);
1175    hasCrashSignal = true;
1176    crashSignal = s;
1177 }
1178
1179 bool int_process::getExitCode(int &c)
1180 {
1181    c = exitCode;
1182    return hasExitCode;
1183 }
1184
1185 bool int_process::getCrashSignal(int &s)
1186 {
1187    s = crashSignal;
1188    return hasCrashSignal;
1189 }
1190
1191 bool int_process::isInCB()
1192 {
1193    return in_callback;
1194 }
1195
1196 void int_process::setInCB(bool b)
1197 {
1198    assert(in_callback == !b);
1199    in_callback = b;
1200 }
1201
1202 void int_process::updateSyncState(Event::ptr ev, bool gen)
1203 {
1204    EventType etype = ev->getEventType();
1205    switch (ev->getSyncType()) {
1206       case Event::async:
1207          pthrd_printf("Event %s is asynchronous\n", etype.name().c_str());
1208          break;
1209       case Event::sync_thread: {
1210          int_thread *thrd = ev->getThread()->llthrd();
1211          if (!thrd)
1212             return;
1213
1214          pthrd_printf("Event %s is thread synchronous, marking thread %d stopped\n",
1215                       etype.name().c_str(), thrd->getLWP());
1216
1217          int_thread::State old_state = gen ? thrd->getGeneratorState() : thrd->getHandlerState();
1218          assert(old_state == int_thread::running ||
1219                 old_state == int_thread::neonatal_intermediate);
1220          if (old_state == int_thread::errorstate)
1221             break;
1222          if (gen)
1223             thrd->setGeneratorState(int_thread::stopped);
1224          else
1225             thrd->setHandlerState(int_thread::stopped);
1226
1227          break;
1228       }
1229       case Event::sync_process: {
1230          pthrd_printf("Event %s is process synchronous, marking process %d stopped\n",
1231                       etype.name().c_str(), getPid());
1232          int_threadPool *tp = threadPool();
1233          for (int_threadPool::iterator i = tp->begin(); i != tp->end(); i++) {
1234             int_thread *thrd = *i;
1235             int_thread::State old_state = gen ? thrd->getGeneratorState() : thrd->getHandlerState();
1236             if (old_state != int_thread::running &&
1237                 old_state != int_thread::neonatal_intermediate)
1238                continue;
1239             if (gen)
1240                thrd->setGeneratorState(int_thread::stopped);
1241             else
1242                thrd->setHandlerState(int_thread::stopped);
1243          }
1244          break;
1245       }
1246       case Event::unset: {
1247          assert(0);
1248       }
1249    }
1250 }
1251
1252 int_process::~int_process()
1253 {
1254    if (up_proc != Process::ptr())
1255    {
1256       proc_exitstate *exitstate = new proc_exitstate();
1257       exitstate->pid = pid;
1258       exitstate->exited = hasExitCode;
1259       exitstate->exit_code = exitCode;
1260       exitstate->crashed = hasCrashSignal;
1261       exitstate->crash_signal = crashSignal;
1262       assert(!up_proc->exitstate_);
1263       up_proc->exitstate_ = exitstate;
1264       up_proc->llproc_ = NULL;
1265    }
1266
1267    if (threadpool) {
1268       delete threadpool;
1269       threadpool = NULL;
1270    }
1271    //Do not delete handlerpool yet, we're currently under
1272    // an event handler.  We do want to delete this if called
1273    // from detach.
1274    bool should_clean;
1275    mem->rmProc(this, should_clean);
1276    if (should_clean) {
1277       delete mem;
1278    }
1279    mem = NULL;
1280 }
1281
1282 bool int_threadPool::userCont()
1283 {
1284    return cont(true);
1285 }
1286
1287 bool int_threadPool::intCont()
1288 {
1289    return cont(false);
1290 }
1291
1292 bool int_threadPool::cont(bool user_cont)
1293 {
1294    pthrd_printf("%s continuing process %d\n", user_cont ? "User" : "Int", proc()->getPid());
1295
1296    Dyninst::PID pid = proc()->getPid();
1297    bool had_error = false;
1298    bool cont_something = false;
1299
1300    ProcPool()->condvar()->lock();
1301
1302    bool needs_sync = false;
1303    for (iterator i = begin(); i != end(); i++) {
1304       int_thread *thr = *i;
1305       assert(thr);
1306
1307       pthrd_printf("Continuing thread %d on process %d\n", thr->getLWP(), pid);
1308       int_thread::stopcont_ret_t ret = thr->cont(user_cont, true);
1309       switch (ret) {
1310          case int_thread::sc_skip:
1311             break;
1312          case int_thread::sc_error:
1313             had_error = true;
1314             break;
1315          case int_thread::sc_success_pending:
1316             needs_sync = true;
1317          case int_thread::sc_success:
1318             cont_something = true;
1319             break;
1320       }
1321    }
1322
1323    ProcPool()->condvar()->signal();
1324    ProcPool()->condvar()->unlock();
1325
1326    if (!cont_something) {
1327       perr_printf("Failed to continue exited process %d\n", pid);
1328       setLastError(err_exited, "Continue attempted on exited process\n");
1329       return false;
1330    }
1331
1332    if (user_cont && needs_sync)
1333    {
1334       pthrd_printf("Attempting to handle pending user continue\n");
1335       bool proc_exited;
1336       bool result = int_process::waitAndHandleForProc(true, proc(), proc_exited);
1337       if (proc_exited) {
1338          pthrd_printf("Process exited during continue\n");
1339          setLastError(err_exited, "Process exited during continue\n");
1340          return false;
1341       }
1342       if (!result) {
1343          perr_printf("Error waiting for events after continue on %d\n", proc()->getPid());
1344          return false;
1345       }
1346    }
1347
1348    return !had_error;
1349 }
1350
1351 bool int_thread::userCont()
1352 {
1353    return cont(true);
1354 }
1355
1356 bool int_thread::intCont()
1357 {
1358    return cont(false);
1359 }
1360
1361 bool int_thread::cont(bool user_cont)
1362 {
1363    pthrd_printf("%s continuing single thread %d/%d\n", user_cont ? "User" : "Int",
1364                 llproc()->getPid(), getLWP());
1365
1366    bool result = rpcMgr()->handleThreadContinue(this, user_cont);
1367    if (!result) {
1368       pthrd_printf("Error handling IRPC during continue\n");
1369       return false;
1370    }
1371
1372    if ( int_process::getThreadControlMode() == int_process::NoLWPControl ) {
1373       pthrd_printf("%s continuing entire process %d on thread operation on %d\n",
1374                    user_cont ? "User" : "Int", llproc()->getPid(), getLWP());
1375       if (user_cont) {
1376          return llproc()->threadPool()->userCont();
1377       }
1378       else {
1379          return llproc()->threadPool()->intCont();
1380       }
1381    }
1382    stopcont_ret_t ret = cont(user_cont, false);
1383
1384    if (ret == sc_skip) {
1385       perr_printf("Attempted to continue exited thread\n");
1386       setLastError(err_exited, "Attempted thread continue on exited thread\n");
1387       return false;
1388    }
1389    if (ret == sc_error) {
1390       if (user_cont) {
1391          //The internal state is running, so there was an internal error during continue, but
1392          // the user state was stopped.  We won't treat this as a user error and instead
1393          // just change the user state.
1394          pthrd_printf("Ignoring previous error on %d/%d\n", llproc()->getPid(), getLWP());
1395       }
1396       else {
1397          pthrd_printf("Error continuing thread %d/%d\n", llproc()->getPid(), getLWP());
1398          return false;
1399       }
1400    }
1401
1402    if (user_cont)
1403    {
1404       if( ret == sc_success_pending ) {
1405          pthrd_printf("Attempting to handle pending user continue\n");
1406          bool proc_exited;
1407          result = int_process::waitAndHandleForProc(true, llproc(), proc_exited);
1408          if (proc_exited) {
1409             pthrd_printf("Process exited during thread continue\n");
1410             setLastError(err_exited, "Process exited during continue\n");
1411             return false;
1412          }
1413          if (!result) {
1414             perr_printf("Error waiting for events after continue on %d\n", getLWP());
1415             return false;
1416          }
1417       }
1418
1419       bool result = setUserState(int_thread::running);
1420       if (!result) {
1421          setLastError(err_exited, "Attempted thread continue on exited thread\n");
1422          perr_printf("Failed to continue thread %d/%d--bad state\n", llproc()->getPid(), getLWP());
1423          return false;
1424       }
1425    }
1426    return true;
1427 }
1428
1429 int_thread::stopcont_ret_t int_thread::cont(bool user_cont, bool have_proc_lock)
1430 {
1431    Dyninst::PID pid = proc()->getPid();
1432
1433    pthrd_printf("Top level %s continue for %d/%d\n",
1434                 user_cont ? "user" : "int", pid, lwp);
1435
1436    if (getHandlerState() == errorstate) {
1437       pthrd_printf("thread %d on process %d in error state\n", getLWP(), pid);
1438       return sc_skip;
1439    }
1440    if (getHandlerState() == exited) {
1441       pthrd_printf("thread %d on process %d already exited\n", getLWP(), pid);
1442       return sc_skip;
1443    }
1444
1445    if (user_cont) {
1446       setUserState(running);
1447    }
1448
1449    if (getHandlerState() != stopped) {
1450       perr_printf("Error. continue attempted on running thread %d/%d\n", pid, lwp);
1451       setLastError(err_notstopped, "Continue attempted on running thread\n");
1452       return sc_error;
1453    }
1454
1455    if (!have_proc_lock) {
1456       ProcPool()->condvar()->lock();
1457    }
1458
1459    regpool_lock.lock();
1460    cached_regpool.regs.clear();
1461    cached_regpool.full = false;
1462    regpool_lock.unlock();
1463
1464    bool result = plat_cont(user_cont);
1465    if (result && !hasPendingUserContinue()) {
1466       setInternalState(running);
1467       setHandlerState(running);
1468       setGeneratorState(running);
1469    }
1470
1471    if (!have_proc_lock) {
1472       ProcPool()->condvar()->signal();
1473       ProcPool()->condvar()->unlock();
1474    }
1475
1476    if (!result) {
1477       pthrd_printf("Could not resume debugee %d, thread %d\n", pid, lwp);
1478       return sc_error;
1479    }
1480
1481    if( hasPendingUserContinue() ) return sc_success_pending;
1482
1483    return sc_success;
1484 }
1485
1486 bool int_threadPool::userStop()
1487 {
1488    return stop(true, true);
1489 }
1490
1491 bool int_threadPool::intStop(bool sync)
1492 {
1493    return stop(false, sync);
1494 }
1495
1496 bool int_threadPool::stop(bool user_stop, bool sync)
1497 {
1498    bool stopped_something = false;
1499    bool had_error = false;
1500    bool needs_sync = false;
1501    for (iterator i = begin(); i != end(); i++) {
1502       int_thread *thr = *i;
1503
1504       pthrd_printf("Process %d performing %s stop on thread %d\n", proc()->getPid(),
1505                    user_stop ? "user" : "int",  thr->getLWP());
1506       int_thread::stopcont_ret_t ret = thr->stop(user_stop);
1507       switch (ret) {
1508          case int_thread::sc_skip:
1509             pthrd_printf("int_thread::stop on %d/%d returned sc_skip\n",
1510                          proc()->getPid(), thr->getLWP());
1511             break;
1512          case int_thread::sc_error:
1513             pthrd_printf("int_thread::stop on %d/%d returned sc_error\n",
1514                          proc()->getPid(), thr->getLWP());
1515             if (getLastError() == err_noproc)
1516                pthrd_printf("int_thread::stop thread exit on %d/%d, skipping stop\n",
1517                             proc()->getPid(), thr->getLWP());
1518             else
1519                had_error = true;
1520             break;
1521          case int_thread::sc_success_pending:
1522             pthrd_printf("int_thread::stop on %d/%d return sc_success_pending\n",
1523                          proc()->getPid(), thr->getLWP());
1524             stopped_something = true;
1525             needs_sync = true;
1526             break;
1527          case int_thread::sc_success:
1528             pthrd_printf("int_thread::stop on %d/%d returned sc_success\n",
1529                          proc()->getPid(), thr->getLWP());
1530             stopped_something = true;
1531             break;
1532       }
1533    }
1534
1535    if (had_error) {
1536       pthrd_printf("Error while stopping threads on %d\n", proc()->getPid());
1537       setLastError(err_internal, "Could not stop process\n");
1538       return false;
1539    }
1540    if (!stopped_something) {
1541       perr_printf("No threads can be stopped on %d\n", proc()->getPid());
1542       setLastError(err_notrunning, "Attempt to stop a process that isn't running\n");
1543       return false;
1544    }
1545
1546    if (needs_sync && sync)
1547    {
1548       bool proc_exited;
1549       bool result = int_process::waitAndHandleForProc(true, proc(), proc_exited);
1550       if (proc_exited) {
1551          pthrd_printf("Process exited during stop\n");
1552          setLastError(err_exited, "Process exited during stop\n");
1553          return false;
1554       }
1555       if (!result) {
1556          perr_printf("Error waiting for events after stop on %d\n", proc()->getPid());
1557          return false;
1558       }
1559    }
1560
1561    return true;
1562 }
1563
1564 int_thread::stopcont_ret_t int_thread::stop(bool user_stop)
1565 {
1566    Dyninst::PID pid = proc()->getPid();
1567    pthrd_printf("Top level %s thread pause for %d/%d\n",
1568                 user_stop ? "user" : "int", pid, lwp);
1569
1570    if (getHandlerState() == errorstate) {
1571       pthrd_printf("thread %d on process %d in error state\n", getLWP(), pid);
1572       return sc_skip;
1573    }
1574    if (getHandlerState() == exited) {
1575       pthrd_printf("thread %d on process %d already exited\n", getLWP(), pid);
1576       return sc_skip;
1577    }
1578
1579    if (pending_stop) {
1580       pthrd_printf("thread %d has in-progress stop on process %d\n", getLWP(), pid);
1581       return sc_success;
1582    }
1583    if (getHandlerState() == stopped) {
1584       pthrd_printf("thread %d on process %d is already handler stopped, leaving\n",
1585                    getLWP(), pid);
1586       if (user_stop)
1587          setUserState(stopped);
1588       setInternalState(stopped);
1589       return sc_success;
1590    }
1591    if (getInternalState() == stopped) {
1592       pthrd_printf("thread %d is already stopped on process %d\n", getLWP(), pid);
1593       if (user_stop)
1594          setUserState(stopped);
1595       return sc_success;
1596    }
1597    if (getHandlerState() != running)
1598    {
1599       perr_printf("Attempt to stop thread %d/%d in bad state %d\n",
1600                   pid, lwp, getHandlerState());
1601       setLastError(err_internal, "Bad state during thread stop attempt\n");
1602       return sc_error;
1603    }
1604
1605    assert(!pending_stop);
1606    pending_stop = true;
1607    if (user_stop) {
1608       assert(!pending_user_stop);
1609       pending_user_stop = true;
1610    }
1611
1612    bool result = plat_stop();
1613    if (!result) {
1614       pthrd_printf("Could not pause debuggee %d, thr %d\n", pid, lwp);
1615       pending_stop = false;
1616       return sc_error;
1617    }
1618
1619    if (pending_stop)
1620       return sc_success_pending;
1621    else
1622       return sc_success;
1623 }
1624
1625 bool int_thread::stop(bool user_stop, bool sync)
1626 {
1627    if ( int_process::getThreadControlMode() == int_process::NoLWPControl ) {
1628       if (user_stop) {
1629          pthrd_printf("User stopping entire process %d on thread operation on %d\n",
1630                       llproc()->getPid(), getLWP());
1631          return llproc()->threadPool()->userStop();
1632       }
1633       else {
1634          pthrd_printf("Int stopping entire process %d on thread operation on %d\n",
1635                       llproc()->getPid(), getLWP());
1636          return llproc()->threadPool()->intStop();
1637       }
1638    }
1639
1640    pthrd_printf("%s stopping single thread %d/%d\n", user_stop ? "User" : "Int",
1641                 llproc()->getPid(), getLWP());
1642
1643    stopcont_ret_t ret = stop(user_stop);
1644    if (ret == sc_skip) {
1645       perr_printf("Thread %d/%d was not in a stoppable state\n",
1646                   llproc()->getPid(), getLWP());
1647       setLastError(err_notrunning, "Attempt to stop a thread that isn't running\n");
1648       return false;
1649    }
1650    if (ret == sc_error) {
1651       pthrd_printf("Thread %d/%d returned error during stop\n",
1652                    llproc()->getPid(), getLWP());
1653       return false;
1654    }
1655    if (ret == sc_success) {
1656       pthrd_printf("Thread %d/%d successfully stopped\n",
1657                    llproc()->getPid(), getLWP());
1658       return true;
1659    }
1660    assert(ret == sc_success_pending);
1661    if (!sync) {
1662       pthrd_printf("Thread %d/%d successfully stopped, but not sync'd\n",
1663                    llproc()->getPid(), getLWP());
1664       return true;
1665    }
1666
1667    bool proc_exited;
1668    bool result = int_process::waitAndHandleForProc(true, llproc(), proc_exited);
1669    if (proc_exited) {
1670       pthrd_printf("Process exited during thread stop\n");
1671       setLastError(err_exited, "Process exited during stop\n");
1672       return false;
1673    }
1674    if (!result) {
1675       perr_printf("Error waiting for events after stop on %d\n", getLWP());
1676       return false;
1677    }
1678    return true;
1679 }
1680
1681 bool int_thread::userStop()
1682 {
1683    return stop(true, true);
1684 }
1685
1686 bool int_thread::intStop(bool sync)
1687 {
1688    return stop(false, sync);
1689 }
1690
1691 void int_thread::setPendingUserStop(bool b)
1692 {
1693    pending_user_stop = b;
1694 }
1695
1696 bool int_thread::hasPendingUserStop() const
1697 {
1698    return pending_user_stop;
1699 }
1700
1701 void int_thread::setPendingStop(bool b)
1702 {
1703    pending_stop = b;
1704 }
1705
1706 bool int_thread::hasPendingStop() const
1707 {
1708    return pending_stop;
1709 }
1710
1711 void int_thread::setPendingUserContinue(bool b)
1712 {
1713     pending_user_continue = b;
1714 }
1715
1716 bool int_thread::hasPendingUserContinue() const
1717 {
1718     return pending_user_continue;
1719 }
1720
1721 void int_thread::setPendingContinue(bool b)
1722 {
1723     pending_continue = b;
1724 }
1725
1726 bool int_thread::hasPendingContinue() const
1727 {
1728     return pending_continue;
1729 }
1730
1731 Process::ptr int_thread::proc() const
1732 {
1733    return proc_->proc();
1734 }
1735
1736 int_process *int_thread::llproc() const
1737 {
1738    return proc_;
1739 }
1740
1741 Dyninst::THR_ID int_thread::getTid() const
1742 {
1743    return tid;
1744 }
1745
1746 Dyninst::LWP int_thread::getLWP() const
1747 {
1748    return lwp;
1749 }
1750
1751 int_thread::State int_thread::getHandlerState() const
1752 {
1753    return handler_state;
1754 }
1755
1756 int_thread::State int_thread::getUserState() const
1757 {
1758    return user_state;
1759 }
1760
1761 int_thread::State int_thread::getGeneratorState() const
1762 {
1763    return generator_state;
1764 }
1765
1766 int_thread::State int_thread::getInternalState() const
1767 {
1768    return internal_state;
1769 }
1770
1771 const char *int_thread::stateStr(int_thread::State s)
1772 {
1773    switch (s) {
1774       case neonatal: return "neonatal";
1775       case neonatal_intermediate: return "neonatal_intermediate";
1776       case running: return "running";
1777       case stopped: return "stopped";
1778       case exited: return "exited";
1779       case errorstate: return "errorstate";
1780    }
1781    assert(0);
1782    return NULL;
1783 }
1784
1785 bool int_thread::setAnyState(int_thread::State *from, int_thread::State to)
1786 {
1787    const char *s = NULL;
1788    if (from == &handler_state) {
1789       s = "handler state";
1790    }
1791    else if (from == &user_state) {
1792       s = "user state";
1793    }
1794    else if (from == &generator_state) {
1795       s = "generator state";
1796    }
1797    else if (from == &internal_state) {
1798       s = "internal state";
1799    }
1800    assert(s);
1801
1802    if (*from == to) {
1803       pthrd_printf("Leaving %s for %d in state %s\n", s, lwp, stateStr(to));
1804       return true;
1805    }
1806    if (to == errorstate) {
1807       perr_printf("Setting %s for %d from %s to errorstate\n",
1808                   s, lwp, stateStr(*from));
1809       *from = to;
1810       return true;
1811    }
1812    if (*from == errorstate) {
1813       perr_printf("Attempted %s reversion for %d from errorstate to %s\n",
1814                   s, lwp, stateStr(to));
1815       return false;
1816    }
1817    if (*from == exited) {
1818       perr_printf("Attempted %s reversion for %d from exited to %s\n",
1819                   s, lwp, stateStr(to));
1820       return false;
1821    }
1822    if (to == neonatal && *from != neonatal) {
1823       perr_printf("Attempted %s reversion for %d from %s to neonatal\n",
1824                   s, lwp, stateStr(*from));
1825       return false;
1826    }
1827
1828    pthrd_printf("Changing %s for %d/%d from %s to %s\n", s, llproc()->getPid(), lwp,
1829                 stateStr(*from), stateStr(to));
1830    *from = to;
1831
1832    if (internal_state == stopped)  assert(handler_state == stopped || handler_state == exited );
1833    if (handler_state == stopped)   assert(generator_state == stopped || generator_state == exited);
1834    if (generator_state == running) assert(handler_state == running);
1835    if (handler_state == running)   assert(internal_state == running);
1836    return true;
1837 }
1838
1839 bool int_thread::setHandlerState(int_thread::State s)
1840 {
1841    return setAnyState(&handler_state, s);
1842 }
1843
1844 bool int_thread::setUserState(int_thread::State s)
1845 {
1846    return setAnyState(&user_state, s);
1847 }
1848
1849 bool int_thread::setGeneratorState(int_thread::State s)
1850 {
1851    return setAnyState(&generator_state, s);
1852 }
1853
1854 bool int_thread::setInternalState(int_thread::State s)
1855 {
1856    return setAnyState(&internal_state, s);
1857 }
1858
1859 void int_thread::desyncInternalState()
1860 {
1861    pthrd_printf("Thread %d/%d is desyncing int from user state %d\n",
1862                 llproc()->getPid(), getLWP(), num_locked_stops+1);
1863    num_locked_stops++;
1864 }
1865
1866 void int_thread::restoreInternalState(bool sync)
1867 {
1868    pthrd_printf("Thread %d/%d is restoring int to user state, %d\n",
1869                 llproc()->getPid(), getLWP(), num_locked_stops-1);
1870    assert(num_locked_stops > 0);
1871    num_locked_stops--;
1872    if (num_locked_stops > 0)
1873       return;
1874
1875    pthrd_printf("Changing internal state, %s, to user state, %s.\n",
1876                 int_thread::stateStr(internal_state), int_thread::stateStr(user_state));
1877
1878    if (internal_state == user_state)
1879    {
1880       return;
1881    }
1882    else if (internal_state == int_thread::exited ||
1883             user_state == int_thread::exited)
1884    {
1885       setInternalState(int_thread::exited);
1886    }
1887    else if (internal_state == int_thread::stopped &&
1888             user_state == int_thread::running)
1889    {
1890       bool result = intCont();
1891       if (!result) {
1892          perr_printf("Error continuing internal process %d/%d when resyncing\n",
1893                      llproc()->getPid(), getLWP());
1894          return;
1895       }
1896    }
1897    else if (internal_state == int_thread::running &&
1898             user_state == int_thread::stopped)
1899    {
1900       bool result = intStop(sync);
1901       if (!result) {
1902          perr_printf("Error stopping internal process %d/%d when resyncing\n",
1903                      llproc()->getPid(), getLWP());
1904          return;
1905       }
1906    }
1907    else {
1908       setInternalState(user_state);
1909    }
1910 }
1911
1912 void int_thread::setContSignal(int sig)
1913 {
1914    continueSig_ = sig;
1915 }
1916
1917 int int_thread::getContSignal() {
1918     return continueSig_;
1919 }
1920
1921 int_thread::int_thread(int_process *p, Dyninst::THR_ID t, Dyninst::LWP l) :
1922    tid(t),
1923    lwp(l),
1924    proc_(p),
1925    continueSig_(0),
1926    handler_state(neonatal),
1927    user_state(neonatal),
1928    generator_state(neonatal),
1929    internal_state(neonatal),
1930    sync_rpc_count(0),
1931    pending_user_stop(false),
1932    pending_stop(false),
1933    pending_user_continue(false),
1934    pending_continue(false),
1935    num_locked_stops(0),
1936    user_single_step(false),
1937    single_step(false),
1938    clearing_breakpoint(false)
1939 {
1940    Thread::ptr new_thr(new Thread());
1941
1942    new_thr->llthread_ = this;
1943    up_thread = new_thr;
1944 }
1945
1946 int_thread::~int_thread()
1947 {
1948    assert(!up_thread->exitstate_);
1949
1950    up_thread->exitstate_ = new thread_exitstate();
1951    up_thread->exitstate_->lwp = lwp;
1952    up_thread->exitstate_->thr_id = tid;
1953    up_thread->llthread_ = NULL;
1954 }
1955
1956 int_thread *int_thread::createThread(int_process *proc,
1957                                      Dyninst::THR_ID thr_id,
1958                                      Dyninst::LWP lwp_id,
1959                                      bool initial_thrd)
1960 {
1961    int_thread *newthr = createThreadPlat(proc, thr_id, lwp_id, initial_thrd);
1962    pthrd_printf("Creating %s thread %d/%d, thr_id = %d\n",
1963                 initial_thrd ? "initial" : "new",
1964                 proc->getPid(), newthr->getLWP(), thr_id);
1965    proc->threadPool()->addThread(newthr);
1966    if (initial_thrd) {
1967       proc->threadPool()->setInitialThread(newthr);
1968    }
1969    ProcPool()->addThread(proc, newthr);
1970    bool result = newthr->attach();
1971    if (!result) {
1972       pthrd_printf("Failed to attach to new thread %d/%d\n", proc->getPid(), lwp_id);
1973       return NULL;
1974    }
1975    newthr->setUserState(neonatal_intermediate);
1976    newthr->setInternalState(neonatal_intermediate);
1977    newthr->setHandlerState(neonatal_intermediate);
1978    newthr->setGeneratorState(neonatal_intermediate);
1979
1980    return newthr;
1981 }
1982
1983 Thread::ptr int_thread::thread()
1984 {
1985    return up_thread;
1986 }
1987
1988 bool int_thread::getAllRegisters(int_registerPool &pool)
1989 {
1990    bool result = false;
1991
1992    pthrd_printf("Reading registers for thread %d\n", getLWP());
1993    regpool_lock.lock();
1994    if (cached_regpool.full) {
1995       pool = cached_regpool;
1996       pthrd_printf("Returning cached register set\n");
1997       result = true;
1998       goto done;
1999    }
2000    result = plat_getAllRegisters(cached_regpool);
2001    if (!result) {
2002       pthrd_printf("plat_getAllRegisters returned error on %d\n", getLWP());
2003       goto done;
2004    }
2005    cached_regpool.full = true;
2006    pool = cached_regpool;
2007    pool.thread = this;
2008    pthrd_printf("Successfully retrieved all registers for %d\n", getLWP());
2009    result = true;
2010   done:
2011    regpool_lock.unlock();
2012    return result;
2013 }
2014
2015 bool int_thread::setAllRegisters(int_registerPool &pool)
2016 {
2017    assert(getHandlerState() == int_thread::stopped);
2018    assert(getGeneratorState() == int_thread::stopped);
2019    regpool_lock.lock();
2020
2021    pthrd_printf("Setting registers for thread %d\n", getLWP());
2022    bool result = plat_setAllRegisters(pool);
2023    if (!result) {
2024       pthrd_printf("plat_setAllRegisters returned error on %d\n", getLWP());
2025       goto done;
2026    }
2027    cached_regpool = pool;
2028    cached_regpool.full = true;
2029    pthrd_printf("Successfully set all registers for %d\n", getLWP());
2030   done:
2031    regpool_lock.unlock();
2032    return result;
2033 }
2034
2035 bool int_thread::getRegister(Dyninst::MachRegister reg, Dyninst::MachRegisterVal &val)
2036 {
2037    bool result = false;
2038    pthrd_printf("Get register value for thread %d, register %s\n", lwp, reg.name());
2039
2040    if (!llproc()->plat_individualRegAccess())
2041    {
2042       pthrd_printf("Platform does not support individual register access, "
2043                    "getting everything\n");
2044       int_registerPool pool;
2045       result = getAllRegisters(pool);
2046       if (!result) {
2047          pthrd_printf("Unable to access full register set\n");
2048          return false;
2049       }
2050       val = pool.regs[reg];
2051       return true;
2052    }
2053
2054    regpool_lock.lock();
2055
2056    int_registerPool::reg_map_t::iterator i = cached_regpool.regs.find(reg);
2057    if (i != cached_regpool.regs.end()) {
2058       val = i->second;
2059       pthrd_printf("Returning cached register value %lx for register %s on %d\n",
2060                    val, reg.name(), lwp);
2061       result = true;
2062       goto done;
2063    }
2064
2065    result = plat_getRegister(reg, val);
2066    if (!result) {
2067       pthrd_printf("Error reading register value for %s on %d\n", reg.name(), lwp);
2068       goto done;
2069    }
2070
2071    pthrd_printf("Returning register value %lx for register %s on %d\n",
2072                 val, reg.name(), lwp);
2073   done:
2074    regpool_lock.unlock();
2075    return result;
2076 }
2077
2078 bool int_thread::setRegister(Dyninst::MachRegister reg, Dyninst::MachRegisterVal val)
2079 {
2080    assert(getHandlerState() == int_thread::stopped);
2081    assert(getGeneratorState() == int_thread::stopped);
2082
2083    if (!llproc()->plat_individualRegAccess())
2084    {
2085       pthrd_printf("Platform does not support individual register access, "
2086                    "setting everything\n");
2087       int_registerPool pool;
2088       bool result = getAllRegisters(pool);
2089       if (!result) {
2090          pthrd_printf("Unable to access full register set\n");
2091          return false;
2092       }
2093       pool.regs[reg] = val;
2094       result = setAllRegisters(pool);
2095       if (!result) {
2096          pthrd_printf("Unable to set full register set\n");
2097          return false;
2098       }
2099       return true;
2100    }
2101
2102    regpool_lock.lock();
2103
2104    pthrd_printf("Setting register %s for thread %d to %lx\n", reg.name(), getLWP(), val);
2105    MachRegister base_register = reg.getBaseRegister();
2106    bool result = plat_setRegister(base_register, val);
2107    if (!result) {
2108       pthrd_printf("Error setting register %s\n", base_register.name());
2109       goto done;
2110    }
2111
2112    cached_regpool.regs[base_register] = val;
2113   done:
2114    regpool_lock.unlock();
2115    return true;
2116 }
2117
2118 void int_thread::addPostedRPC(int_iRPC::ptr rpc_)
2119 {
2120    assert(rpc_);
2121    posted_rpcs.push_back(rpc_);
2122 }
2123
2124 rpc_list_t *int_thread::getPostedRPCs()
2125 {
2126    return &posted_rpcs;
2127 }
2128
2129 bool int_thread::hasPostedRPCs()
2130 {
2131    return (posted_rpcs.size() != 0);
2132 }
2133
2134 void int_thread::setRunningRPC(int_iRPC::ptr rpc_)
2135 {
2136    assert(!running_rpc);
2137    running_rpc = rpc_;
2138 }
2139
2140 int_iRPC::ptr int_thread::runningRPC() const
2141 {
2142    return running_rpc;
2143 }
2144
2145 void int_thread::clearRunningRPC()
2146 {
2147    running_rpc = int_iRPC::ptr();
2148 }
2149 bool int_thread::saveRegsForRPC()
2150 {
2151    assert(!rpc_regs.full);
2152    return getAllRegisters(rpc_regs);
2153 }
2154
2155 bool int_thread::restoreRegsForRPC(bool clear)
2156 {
2157    assert(rpc_regs.full);
2158    bool result = setAllRegisters(rpc_regs);
2159    if (clear && result) {
2160       rpc_regs.regs.clear();
2161       rpc_regs.full = false;
2162    }
2163    return result;
2164 }
2165
2166 bool int_thread::hasSavedRPCRegs()
2167 {
2168    return rpc_regs.full;
2169 }
2170
2171 bool int_thread::runningInternalRPC() const
2172 {
2173    if (runningRPC() && runningRPC()->isInternalRPC()) {
2174       return true;
2175    }
2176    if (posted_rpcs.size() && posted_rpcs.front()->isInternalRPC()) {
2177       return true;
2178    }
2179    return false;
2180 }
2181
2182 void int_thread::incSyncRPCCount()
2183 {
2184    sync_rpc_count++;
2185 }
2186
2187 void int_thread::decSyncRPCCount()
2188 {
2189    assert(sync_rpc_count > 0);
2190    sync_rpc_count--;
2191 }
2192
2193 bool int_thread::hasSyncRPC()
2194 {
2195    return (sync_rpc_count != 0);
2196 }
2197
2198 int_iRPC::ptr int_thread::nextPostedIRPC() const
2199 {
2200    if (!posted_rpcs.size())
2201       return int_iRPC::ptr();
2202    return posted_rpcs.front();
2203 }
2204
2205 bool int_thread::handleNextPostedIRPC(bool block)
2206 {
2207    int_iRPC::ptr posted_rpc = nextPostedIRPC();
2208    if (!posted_rpc || runningRPC())
2209       return true;
2210
2211    bool ret_result = false;
2212    pthrd_printf("Handling next postd irpc %lu on %d/%d of type %s in state %s\n",
2213                 posted_rpc->id(), llproc()->getPid(), getLWP(),
2214                 posted_rpc->getStrType(), posted_rpc->getStrState());
2215    assert(posted_rpc->getState() == int_iRPC::Posted ||
2216           posted_rpc->getState() == int_iRPC::Prepping ||
2217           posted_rpc->getState() == int_iRPC::Prepped);
2218
2219    if (posted_rpc->getState() == int_iRPC::Posted) {
2220       bool error = false;
2221       pthrd_printf("Prepping next rpc to run on %d/%d\n", llproc()->getPid(), getLWP());
2222       bool result = rpcMgr()->prepNextRPC(this, block, error);
2223       if (!result && error) {
2224          perr_printf("Failed to prep RPC\n");
2225          goto done;
2226       }
2227    }
2228    if (posted_rpc->getState() == int_iRPC::Prepping) {
2229       pthrd_printf("Checking if rpc is prepped on %d/%d\n", llproc()->getPid(), getLWP());
2230       posted_rpc->isRPCPrepped();
2231    }
2232    if (posted_rpc->getState() == int_iRPC::Prepped) {
2233       pthrd_printf("Running next RPC on %d/%d\n", llproc()->getPid(), getLWP());
2234       rpcMgr()->runNextRPC(this, block);
2235    }
2236
2237    ret_result = true;
2238   done:
2239    return ret_result;
2240 }
2241
2242 int_iRPC::ptr int_thread::hasRunningProcStopperRPC() const
2243 {
2244    int_iRPC::ptr running = runningRPC();
2245    if (running && running->isProcStopRPC()) {
2246       return running;
2247    }
2248    int_iRPC::ptr nextposted = nextPostedIRPC();
2249    if (!running && nextposted && nextposted->isProcStopRPC() &&
2250        nextposted->getState() != int_iRPC::Posted)
2251    {
2252       return nextposted;
2253    }
2254    return int_iRPC::ptr();
2255 }
2256
2257 bool int_thread::singleStepMode() const
2258 {
2259    return single_step;
2260 }
2261
2262 void int_thread::setSingleStepMode(bool s)
2263 {
2264    single_step = s;
2265 }
2266
2267 bool int_thread::singleStepUserMode() const
2268 {
2269    return user_single_step;
2270 }
2271
2272 void int_thread::setSingleStepUserMode(bool s)
2273 {
2274    user_single_step = s;
2275 }
2276
2277 bool int_thread::singleStep() const
2278 {
2279    return single_step || user_single_step;
2280 }
2281
2282 void int_thread::markClearingBreakpoint(installed_breakpoint *bp)
2283 {
2284    assert(!clearing_breakpoint || bp == NULL);
2285    clearing_breakpoint = bp;
2286 }
2287
2288 installed_breakpoint *int_thread::isClearingBreakpoint()
2289 {
2290    return clearing_breakpoint;
2291 }
2292
2293 int_thread *int_threadPool::findThreadByLWP(Dyninst::LWP lwp)
2294 {
2295    std::map<Dyninst::LWP, int_thread *>::iterator i = thrds_by_lwp.find(lwp);
2296    if (i == thrds_by_lwp.end())
2297       return NULL;
2298    return i->second;
2299 }
2300
2301 int_thread *int_threadPool::initialThread() const
2302 {
2303    return initial_thread;
2304 }
2305
2306 bool int_threadPool::allStopped()
2307 {
2308    for (iterator i = begin(); i != end(); i++) {
2309       if ((*i)->getInternalState() == int_thread::running)
2310          return false;
2311    }
2312    return true;
2313 }
2314
2315 void int_threadPool::addThread(int_thread *thrd)
2316 {
2317    Dyninst::LWP lwp = thrd->getLWP();
2318    std::map<Dyninst::LWP, int_thread *>::iterator i = thrds_by_lwp.find(lwp);
2319    assert (i == thrds_by_lwp.end());
2320    thrds_by_lwp[lwp] = thrd;
2321    threads.push_back(thrd);
2322    hl_threads.push_back(thrd->thread());
2323 }
2324
2325 void int_threadPool::rmThread(int_thread *thrd)
2326 {
2327    assert(thrd != initial_thread);
2328    Dyninst::LWP lwp = thrd->getLWP();
2329    std::map<Dyninst::LWP, int_thread *>::iterator i = thrds_by_lwp.find(lwp);
2330    assert (i != thrds_by_lwp.end());
2331    thrds_by_lwp.erase(i);
2332
2333    for (unsigned i=0; i<threads.size(); i++) {
2334       if (threads[i] != thrd)
2335          continue;
2336       threads[i] = threads[threads.size()-1];
2337       threads.pop_back();
2338       hl_threads[i] = hl_threads[hl_threads.size()-1];
2339       hl_threads.pop_back();
2340    }
2341 }
2342
2343 void int_threadPool::clear()
2344 {
2345    threads.clear();
2346    hl_threads.clear();
2347    thrds_by_lwp.clear();
2348    initial_thread = NULL;
2349 }
2350
2351 void int_threadPool::desyncInternalState()
2352 {
2353    for (iterator i = begin(); i != end(); i++) {
2354       (*i)->desyncInternalState();
2355    }
2356 }
2357
2358 void int_threadPool::restoreInternalState(bool sync)
2359 {
2360    for (iterator i = begin(); i != end(); i++) {
2361       (*i)->restoreInternalState(false);
2362    }
2363    if (sync)
2364       int_process::waitAndHandleEvents(false);
2365 }
2366
2367 void int_threadPool::setInitialThread(int_thread *thrd)
2368 {
2369    initial_thread = thrd;
2370 }
2371
2372 int_process *int_threadPool::proc() const
2373 {
2374    return proc_;
2375 }
2376
2377 unsigned int_threadPool::size() const
2378 {
2379    return threads.size();
2380 }
2381
2382 ThreadPool *int_threadPool::pool() const
2383 {
2384    return up_pool;
2385 }
2386
2387 int_threadPool::int_threadPool(int_process *p) :
2388    proc_(p)
2389 {
2390    up_pool = new ThreadPool();
2391    up_pool->threadpool = this;
2392 }
2393
2394 int_threadPool::~int_threadPool()
2395 {
2396    assert(up_pool);
2397    delete up_pool;
2398
2399    for (vector<int_thread*>::iterator i = threads.begin(); i != threads.end(); i++)
2400    {
2401       delete *i;
2402    }
2403 }
2404
2405 int_breakpoint::int_breakpoint(Breakpoint::ptr up) :
2406    up_bp(up),
2407    to(0x0),
2408    isCtrlTransfer_(false),
2409    data(false)
2410 {
2411 }
2412
2413 int_breakpoint::int_breakpoint(Dyninst::Address to_, Breakpoint::ptr up) :
2414    up_bp(up),
2415    to(to_),
2416    isCtrlTransfer_(true),
2417    data(false)
2418 {
2419 }
2420
2421 int_breakpoint::~int_breakpoint()
2422 {
2423 }
2424
2425 bool int_breakpoint::isCtrlTransfer() const
2426 {
2427    return isCtrlTransfer_;
2428 }
2429
2430 Address int_breakpoint::toAddr() const
2431 {
2432    return to;
2433 }
2434
2435 void *int_breakpoint::getData() const
2436 {
2437    return data;
2438 }
2439
2440 void int_breakpoint::setData(void *v)
2441 {
2442    data = v;
2443 }
2444
2445 Breakpoint::weak_ptr int_breakpoint::upBreakpoint() const
2446 {
2447    return up_bp;
2448 }
2449
2450 installed_breakpoint::installed_breakpoint(mem_state::ptr memory_, Address addr_) :
2451    memory(memory_),
2452    buffer_size(0),
2453    installed(false),
2454    suspend_count(0),
2455    addr(addr_)
2456 {
2457 }
2458
2459 installed_breakpoint::installed_breakpoint(mem_state::ptr memory_,
2460                                            const installed_breakpoint *ip) :
2461    memory(memory_),
2462    bps(ip->bps),
2463    hl_bps(ip->hl_bps),
2464    buffer_size(ip->buffer_size),
2465    installed(ip->installed),
2466    suspend_count(ip->suspend_count),
2467    addr(ip->addr)
2468 {
2469    memcpy(buffer, ip->buffer, sizeof(buffer));
2470 }
2471
2472 installed_breakpoint::~installed_breakpoint()
2473 {
2474 }
2475
2476 bool installed_breakpoint::isInstalled() const
2477 {
2478    return installed;
2479 }
2480
2481 bool installed_breakpoint::install(int_process *proc)
2482 {
2483    if (installed)
2484       return true;
2485    assert(bps.size());
2486
2487    bool result = plat_install(proc, true);
2488    if (!result) {
2489       pthrd_printf("Error installing breakpoint\n");
2490       return false;
2491    }
2492    assert(buffer && buffer_size);
2493    installed = true;
2494    memory->breakpoints[addr] = this;
2495    return true;
2496 }
2497
2498 bool installed_breakpoint::uninstall(int_process *proc)
2499 {
2500    assert(installed);
2501
2502    if (proc->getState() != int_process::exited)
2503    {
2504       bool result = proc->writeMem(&buffer, addr, buffer_size);
2505       if (!result) {
2506          pthrd_printf("Failed to remove breakpoint at %lx from process %d\n",
2507                       addr, proc->getPid());
2508          return false;
2509       }
2510    }
2511    installed = false;
2512    buffer_size = 0;
2513
2514    std::map<Dyninst::Address, installed_breakpoint *>::iterator i;
2515    i = memory->breakpoints.find(addr);
2516    if (i == memory->breakpoints.end()) {
2517       perr_printf("Failed to remove breakpoint from list\n");
2518       return false;
2519    }
2520    memory->breakpoints.erase(i);
2521
2522    return true;
2523 }
2524
2525 bool installed_breakpoint::suspend(int_process *proc)
2526 {
2527    suspend_count++;
2528    if (suspend_count > 1) {
2529       pthrd_printf("Breakpoint already suspended, suspend_count = %d\n",
2530                    suspend_count);
2531       return true;
2532    }
2533    bool result = proc->writeMem(&buffer, addr, buffer_size);
2534    if (!result) {
2535       pthrd_printf("Failed to suspend breakpoint at %lx from process %d\n",
2536                    addr, proc->getPid());
2537       return false;
2538    }
2539    return true;
2540 }
2541
2542 bool installed_breakpoint::resume(int_process *proc)
2543 {
2544    suspend_count--;
2545    assert(suspend_count >= 0);
2546    if (suspend_count > 0) {
2547       pthrd_printf("Breakpoint remaining suspended, suspend_count = %d\n", suspend_count);
2548       return true;
2549    }
2550    bool result = plat_install(proc, false);
2551    if (!result) {
2552       pthrd_printf("Failed to install breakpoint at %lx in process %d\n",
2553                    addr, proc->getPid());
2554       return false;
2555    }
2556    return true;
2557 }
2558
2559 bool installed_breakpoint::addBreakpoint(int_process *proc, int_breakpoint *bp)
2560 {
2561    pthrd_printf("Adding breakpoint at %lx\n", addr);
2562    if (bp->isCtrlTransfer()) {
2563       for (set<int_breakpoint *>::iterator i = bps.begin(); i != bps.end(); i++)
2564       {
2565          if ((*i)->isCtrlTransfer()) {
2566             perr_printf("Error.  Attempted to add to control transfer breakpoints "
2567                         "at same place");
2568             setLastError(err_badparam, "Attempted two control transfer breakpoints at "
2569                          "same location\n");
2570             return false;
2571          }
2572       }
2573    }
2574
2575    bps.insert(bp);
2576    Breakpoint::ptr upbp = bp->upBreakpoint().lock();
2577    if (upbp != Breakpoint::ptr()) {
2578       //We keep the set of installed Breakpoints  to keep the breakpoint shared
2579       // pointer reference counter from cleaning a Breakpoint while installed.
2580       hl_bps.insert(upbp);
2581    }
2582
2583    if (!installed) {
2584       bool result = install(proc);
2585       if (!result) {
2586          pthrd_printf("Error failed to install breakpoint at %lx\n", addr);
2587          return false;
2588       }
2589    }
2590
2591    return true;
2592 }
2593
2594 bool installed_breakpoint::rmBreakpoint(int_process *proc, int_breakpoint *bp, bool &empty)
2595 {
2596    pthrd_printf("Removing breakpoint at %lx\n", addr);
2597    empty = false;
2598    set<int_breakpoint *>::iterator i = bps.find(bp);
2599    if (i == bps.end()) {
2600       perr_printf("Attempted to remove a non-installed breakpoint\n");
2601       setLastError(err_badparam, "Breakpoint was not installed in process\n");
2602       empty = false;
2603       return false;
2604    }
2605    bps.erase(i);
2606
2607    set<Breakpoint::ptr>::iterator j = hl_bps.find(bp->upBreakpoint().lock());
2608    if (j != hl_bps.end()) {
2609       hl_bps.erase(j);
2610    }
2611
2612    if (bps.empty()) {
2613       empty = true;
2614       bool result = uninstall(proc);
2615       if (!result) {
2616          perr_printf("Failed to remove breakpoint at %lx\n", addr);
2617          setLastError(err_internal, "Could not remove breakpoint\n");
2618          return false;
2619       }
2620    }
2621
2622    return true;
2623 }
2624
2625 Dyninst::Address installed_breakpoint::getAddr() const
2626 {
2627    return addr;
2628 }
2629
2630 int_library::int_library(std::string n, Dyninst::Address load_addr) :
2631    name(n),
2632    load_address(load_addr),
2633    data_load_address(0),
2634    has_data_load(false),
2635    marked(false)
2636 {
2637    up_lib = new Library();
2638    up_lib->lib = this;
2639 }
2640
2641 int_library::int_library(std::string n, Dyninst::Address load_addr, Dyninst::Address data_load_addr) :
2642    name(n),
2643    load_address(load_addr),
2644    data_load_address(data_load_addr),
2645    has_data_load(true),
2646    marked(false)
2647 {
2648    up_lib = new Library();
2649    up_lib->lib = this;
2650 }
2651
2652 int_library::int_library(int_library *l) :
2653    name(l->name),
2654    load_address(l->load_address),
2655    data_load_address(l->data_load_address),
2656    has_data_load(l->has_data_load),
2657    marked(l->marked)
2658 {
2659    up_lib = new Library();
2660    up_lib->lib = this;
2661 }
2662
2663 int_library::~int_library()
2664 {
2665 }
2666
2667 std::string int_library::getName()
2668 {
2669    return name;
2670 }
2671
2672 Dyninst::Address int_library::getAddr()
2673 {
2674    return load_address;
2675 }
2676
2677 Dyninst::Address int_library::getDataAddr()
2678 {
2679    return data_load_address;
2680 }
2681
2682 bool int_library::hasDataAddr()
2683 {
2684    return has_data_load;
2685 }
2686
2687 void int_library::setMark(bool b)
2688 {
2689    marked = b;
2690 }
2691
2692 bool int_library::isMarked() const
2693 {
2694    return marked;
2695 }
2696
2697 Library::ptr int_library::getUpPtr() const
2698 {
2699    return up_lib;
2700 }
2701
2702 mem_state::mem_state(int_process *proc)
2703 {
2704    procs.insert(proc);
2705 }
2706
2707 mem_state::mem_state(mem_state &m, int_process *p)
2708 {
2709    pthrd_printf("Copying mem_state to new process %d\n", p->getPid());
2710    procs.insert(p);
2711    set<int_library *>::iterator i;
2712    for (i = m.libs.begin(); i != m.libs.end(); i++)
2713    {
2714       int_library *orig_lib = *i;
2715       int_library *new_lib = new int_library(orig_lib);
2716       libs.insert(new_lib);
2717    }
2718    map<Dyninst::Address, installed_breakpoint *>::iterator j;
2719    for (j = m.breakpoints.begin(); j != m.breakpoints.end(); j++)
2720    {
2721       Address orig_addr = j->first;
2722       installed_breakpoint *orig_bp = j->second;
2723       installed_breakpoint *new_bp = new installed_breakpoint(this, orig_bp);
2724       breakpoints[orig_addr] = new_bp;
2725    }
2726    inf_malloced_memory = m.inf_malloced_memory;
2727 }
2728
2729 mem_state::~mem_state()
2730 {
2731    pthrd_printf("Destroy memory image of old process\n");
2732    set<int_library *>::iterator i;
2733    for (i = libs.begin(); i != libs.end(); i++)
2734    {
2735       int_library *lib = *i;
2736       delete lib;
2737    }
2738    libs.clear();
2739
2740    map<Dyninst::Address, installed_breakpoint *>::iterator j;
2741    for (j = breakpoints.begin(); j != breakpoints.end(); j++)
2742    {
2743       installed_breakpoint *ibp = j->second;
2744       delete ibp;
2745    }
2746    breakpoints.clear();
2747 }
2748
2749 void mem_state::addProc(int_process *p)
2750 {
2751    pthrd_printf("Adding process %d as sharing a memory state with existing proc\n",
2752                 p->getPid());
2753    procs.insert(p);
2754 }
2755
2756 void mem_state::rmProc(int_process *p, bool &should_clean)
2757 {
2758    set<int_process *>::iterator i = procs.find(p);
2759    assert(i != procs.end());
2760    procs.erase(i);
2761
2762    if (procs.empty()) {
2763       should_clean = true;
2764       pthrd_printf("Removed process %d from memory image, should clean image\n",
2765                    p->getPid());
2766    }
2767    else {
2768       should_clean = false;
2769       pthrd_printf("Removed process %d from memory image, others remain\n",
2770                    p->getPid());
2771    }
2772 }
2773
2774
2775 int_notify *int_notify::the_notify = NULL;
2776 int_notify::int_notify() :
2777    pipe_in(-1),
2778    pipe_out(-1),
2779    pipe_count(0),
2780    events_noted(0)
2781 {
2782    the_notify = this;
2783    up_notify = new EventNotify();
2784    up_notify->llnotify = this;
2785 }
2786
2787 int_notify *notify()
2788 {
2789    if (int_notify::the_notify)
2790       return int_notify::the_notify;
2791
2792    static Mutex init_lock;
2793    init_lock.lock();
2794    if (!int_notify::the_notify) {
2795       int_notify::the_notify = new int_notify();
2796    }
2797    init_lock.unlock();
2798    return int_notify::the_notify;
2799 }
2800
2801 void int_notify::noteEvent()
2802 {
2803    assert(isHandlerThread());
2804    assert(events_noted == 0);
2805    writeToPipe();
2806    events_noted++;
2807    pthrd_printf("noteEvent - %d\n", events_noted);
2808    set<EventNotify::notify_cb_t>::iterator i;
2809    for (i = cbs.begin(); i != cbs.end(); i++) {
2810       pthrd_printf("Calling notification CB\n");
2811       (*i)();
2812    }
2813 }
2814
2815 static void notifyNewEvent()
2816 {
2817    notify()->noteEvent();
2818 }
2819
2820
2821 void int_notify::clearEvent()
2822 {
2823    assert(!isHandlerThread());
2824    events_noted--;
2825    pthrd_printf("clearEvent - %d\n", events_noted);
2826    assert(events_noted == 0);
2827    readFromPipe();
2828 }
2829
2830 bool int_notify::hasEvents()
2831 {
2832    return (events_noted > 0);
2833 }
2834
2835 void int_notify::registerCB(EventNotify::notify_cb_t cb)
2836 {
2837    cbs.insert(cb);
2838 }
2839
2840 void int_notify::removeCB(EventNotify::notify_cb_t cb)
2841 {
2842    set<EventNotify::notify_cb_t>::iterator i = cbs.find(cb);
2843    if (i == cbs.end())
2844       return;
2845    cbs.erase(i);
2846 }
2847
2848 int int_notify::getPipeIn()
2849 {
2850    if (pipe_in == -1)
2851       createPipe();
2852    return pipe_in;
2853 }
2854
2855 Decoder::Decoder()
2856 {
2857 }
2858
2859 Decoder::~Decoder()
2860 {
2861 }
2862
2863 RegisterPool::RegisterPool()
2864 {
2865    llregpool = new int_registerPool();
2866 }
2867
2868 RegisterPool::RegisterPool(const RegisterPool &rp)
2869 {
2870    llregpool = new int_registerPool();
2871    *llregpool = *rp.llregpool;
2872 }
2873
2874 RegisterPool::~RegisterPool()
2875 {
2876    delete llregpool;
2877 }
2878
2879 RegisterPool::iterator RegisterPool::begin()
2880 {
2881    return RegisterPool::iterator(llregpool->regs.begin());
2882 }
2883
2884 RegisterPool::iterator RegisterPool::end()
2885 {
2886    return RegisterPool::iterator(llregpool->regs.end());
2887 }
2888
2889 RegisterPool::iterator RegisterPool::find(MachRegister r)
2890 {
2891    return RegisterPool::iterator(llregpool->regs.find(r));
2892 }
2893
2894 RegisterPool::const_iterator RegisterPool::begin() const
2895 {
2896    return RegisterPool::const_iterator(llregpool->regs.begin());
2897 }
2898
2899 RegisterPool::const_iterator RegisterPool::end() const
2900 {
2901    return RegisterPool::const_iterator(llregpool->regs.end());
2902 }
2903
2904 RegisterPool::const_iterator RegisterPool::find(MachRegister r) const
2905 {
2906    return RegisterPool::const_iterator(llregpool->regs.find(r));
2907 }
2908
2909 MachRegisterVal& RegisterPool::operator[](MachRegister r)
2910 {
2911    return llregpool->regs[r];
2912 }
2913
2914 const MachRegisterVal& RegisterPool::operator[](MachRegister r) const
2915 {
2916    return llregpool->regs[r];
2917 }
2918
2919 size_t RegisterPool::size() const
2920 {
2921    return llregpool->regs.size();
2922 }
2923
2924 Thread::ptr RegisterPool::getThread() const
2925 {
2926    return llregpool->thread->thread();
2927 }
2928
2929 RegisterPool::iterator::iterator()
2930 {
2931 }
2932
2933 RegisterPool::iterator::iterator(int_iter i_) :
2934    i(i_)
2935 {
2936 }
2937
2938 RegisterPool::iterator::~iterator()
2939 {
2940 }
2941
2942 std::pair<Dyninst::MachRegister, Dyninst::MachRegisterVal> RegisterPool::iterator::operator*()
2943 {
2944    return *i;
2945 }
2946
2947 RegisterPool::iterator RegisterPool::iterator::operator++()
2948 {
2949    int_iter orig = i;
2950    i++;
2951    return RegisterPool::iterator(i);
2952 }
2953
2954 RegisterPool::iterator RegisterPool::iterator::operator++(int)
2955 {
2956    i++;
2957    return *this;
2958 }
2959
2960 RegisterPool::const_iterator::const_iterator()
2961 {
2962 }
2963
2964 RegisterPool::const_iterator::const_iterator(int_iter i_) :
2965    i(i_)
2966 {
2967 }
2968
2969 RegisterPool::const_iterator::~const_iterator()
2970 {
2971 }
2972
2973 std::pair<Dyninst::MachRegister, Dyninst::MachRegisterVal> RegisterPool::const_iterator::operator*() const
2974 {
2975    return *i;
2976 }
2977
2978 RegisterPool::const_iterator RegisterPool::const_iterator::operator++()
2979 {
2980    int_iter orig = i;
2981    i++;
2982    return RegisterPool::const_iterator(i);
2983 }
2984
2985 RegisterPool::const_iterator RegisterPool::const_iterator::operator++(int)
2986 {
2987    i++;
2988    return *this;
2989 }
2990
2991
2992 int_registerPool::int_registerPool() :
2993    full(false),
2994    thread(NULL)
2995 {
2996 }
2997
2998 int_registerPool::int_registerPool(const int_registerPool &c) :
2999    regs(c.regs),
3000    full(c.full),
3001    thread(c.thread)
3002 {
3003 }
3004
3005 int_registerPool::~int_registerPool()
3006 {
3007 }
3008
3009 Library::Library()
3010 {
3011 }
3012
3013 Library::~Library()
3014 {
3015    if (lib) {
3016       delete lib;
3017       lib = NULL;
3018    }
3019 }
3020
3021 std::string Library::getName() const
3022 {
3023    return lib->getName();
3024 }
3025
3026 Dyninst::Address Library::getLoadAddress() const
3027 {
3028    return lib->getAddr();
3029 }
3030
3031 Dyninst::Address Library::getDataLoadAddress() const
3032 {
3033    return lib->getDataAddr();
3034 }
3035
3036 LibraryPool::LibraryPool()
3037 {
3038 }
3039
3040 LibraryPool::~LibraryPool()
3041 {
3042 }
3043
3044 size_t LibraryPool::size() const
3045 {
3046    return proc->numLibs();
3047 }
3048
3049 Library::ptr LibraryPool::getLibraryByName(std::string s)
3050 {
3051    int_library *int_lib = proc->getLibraryByName(s);
3052    if (!int_lib)
3053       return NULL;
3054    return int_lib->up_lib;
3055 }
3056
3057 const Library::ptr LibraryPool::getLibraryByName(std::string s) const
3058 {
3059    int_library *int_lib = proc->getLibraryByName(s);
3060    if (!int_lib)
3061       return NULL;
3062    return int_lib->up_lib;
3063 }
3064
3065 LibraryPool::iterator::iterator()
3066 {
3067 }
3068
3069 LibraryPool::iterator::~iterator()
3070 {
3071 }
3072
3073 Library::ptr LibraryPool::iterator::operator*() const
3074 {
3075    return (*int_iter)->up_lib;
3076 }
3077
3078 LibraryPool::iterator LibraryPool::iterator::operator++()
3079 {
3080    LibraryPool::iterator orig = *this;
3081    ++int_iter;
3082    return orig;
3083 }
3084
3085 LibraryPool::iterator LibraryPool::iterator::operator++(int)
3086 {
3087    ++int_iter;
3088    return *this;
3089 }
3090
3091 LibraryPool::iterator LibraryPool::begin()
3092 {
3093    LibraryPool::iterator i;
3094    i.int_iter = proc->memory()->libs.begin();
3095    return i;
3096 }
3097
3098 LibraryPool::iterator LibraryPool::end()
3099 {
3100    LibraryPool::iterator i;
3101    i.int_iter = proc->memory()->libs.end();
3102    return i;
3103 }
3104
3105 bool LibraryPool::iterator::operator==(const LibraryPool::iterator &i) const
3106 {
3107    return int_iter == i.int_iter;
3108 }
3109
3110 bool LibraryPool::iterator::operator!=(const LibraryPool::iterator &i) const
3111 {
3112    return int_iter != i.int_iter;
3113 }
3114
3115 LibraryPool::const_iterator LibraryPool::begin() const
3116 {
3117    LibraryPool::const_iterator i;
3118    i.int_iter = proc->memory()->libs.begin();
3119    return i;
3120 }
3121
3122 LibraryPool::const_iterator LibraryPool::end() const
3123 {
3124    LibraryPool::const_iterator i;
3125    i.int_iter = proc->memory()->libs.end();
3126    return i;
3127 }
3128
3129 LibraryPool::const_iterator::const_iterator()
3130 {
3131 }
3132
3133 LibraryPool::const_iterator::~const_iterator()
3134 {
3135 }
3136
3137 const Library::const_ptr LibraryPool::const_iterator::operator*() const
3138 {
3139    return (*int_iter)->up_lib;
3140 }
3141
3142 bool LibraryPool::const_iterator::operator==(const LibraryPool::const_iterator &i)
3143 {
3144    return int_iter == i.int_iter;
3145 }
3146
3147 bool LibraryPool::const_iterator::operator!=(const LibraryPool::const_iterator &i)
3148 {
3149    return int_iter != i.int_iter;
3150 }
3151
3152 LibraryPool::const_iterator LibraryPool::const_iterator::operator++()
3153 {
3154    LibraryPool::const_iterator orig = *this;
3155    ++int_iter;
3156    return orig;
3157 }
3158
3159 LibraryPool::const_iterator LibraryPool::const_iterator::operator++(int)
3160 {
3161    ++int_iter;
3162    return *this;
3163 }
3164
3165 bool Process::registerEventCallback(EventType evt, Process::cb_func_t cbfunc)
3166 {
3167    MTLock lock_this_func(MTLock::allow_init);
3168    HandleCallbacks *cbhandler = HandleCallbacks::getCB();
3169    return cbhandler->registerCallback(evt, cbfunc);
3170 }
3171
3172 bool Process::removeEventCallback(EventType evt, cb_func_t cbfunc)
3173 {
3174    MTLock lock_this_func(MTLock::allow_init);
3175    HandleCallbacks *cbhandler = HandleCallbacks::getCB();
3176    return cbhandler->removeCallback(evt, cbfunc);
3177 }
3178
3179 bool Process::removeEventCallback(EventType evt)
3180 {
3181    MTLock lock_this_func(MTLock::allow_init);
3182    HandleCallbacks *cbhandler = HandleCallbacks::getCB();
3183    return cbhandler->removeCallback(evt);
3184 }
3185
3186 bool Process::removeEventCallback(cb_func_t cbfunc)
3187 {
3188    MTLock lock_this_func(MTLock::allow_init);
3189    HandleCallbacks *cbhandler = HandleCallbacks::getCB();
3190    return cbhandler->removeCallback(cbfunc);
3191 }
3192
3193 bool Process::handleEvents(bool block)
3194 {
3195    // One might think we should be delivering callbacks when taking this lock,
3196    //  but we'll do it under waitAndHandleEvent instead.
3197    MTLock lock_this_func(MTLock::allow_init);
3198
3199    pthrd_printf("User triggered event handling\n");
3200    if (int_process::isInCB()) {
3201       perr_printf("User attempted call on process while in CB, erroring.");
3202       setLastError(err_incallback, "Cannot handleEvents from callback\n");
3203       return false;
3204    }
3205
3206    bool result = int_process::waitAndHandleEvents(block);
3207    if (!result) {
3208       pthrd_printf("Error handling events for user\n");
3209       return false;
3210    }
3211    return true;
3212 }
3213
3214 bool Process::setThreadingMode(thread_mode_t tm)
3215 {
3216    MTLock lock_this_func(MTLock::allow_init);
3217    return mt()->setThreadMode(tm);
3218 }
3219
3220 Process::ptr Process::createProcess(std::string executable, const std::vector<std::string> &argv)
3221 {
3222    MTLock lock_this_func(MTLock::allow_init, MTLock::deliver_callbacks);
3223
3224    pthrd_printf("User asked to launch executable %s\n", executable.c_str());
3225    if (int_process::isInCB()) {
3226       perr_printf("User attempted call on process create while in CB, erroring.");
3227       setLastError(err_incallback, "Cannot createProcess from callback\n");
3228       return Process::ptr();
3229    }
3230
3231    Process::ptr newproc(new Process());
3232    int_process *llproc = int_process::createProcess(executable, argv);
3233    llproc->initializeProcess(newproc);
3234
3235    bool result = llproc->create();
3236    if (!result) {
3237       pthrd_printf("Unable to create process %s\n", executable.c_str());
3238       return Process::ptr();
3239    }
3240
3241    return newproc;
3242 }
3243
3244 Process::ptr Process::attachProcess(Dyninst::PID pid, std::string executable)
3245 {
3246    MTLock lock_this_func(MTLock::allow_init, MTLock::deliver_callbacks);
3247    pthrd_printf("User asked to attach to process %d (%s)\n", pid, executable.c_str());
3248    if (int_process::isInCB()) {
3249       perr_printf("User attempted call on process attach while in CB, erroring.\n");
3250       setLastError(err_incallback, "Cannot attachProcess from callback\n");
3251       return Process::ptr();
3252    }
3253    Process::ptr newproc(new Process());
3254    int_process *llproc = int_process::createProcess(pid, executable);
3255    llproc->initializeProcess(newproc);
3256
3257    bool result = llproc->attach();
3258    if (!result) {
3259       pthrd_printf("Unable to attach to process %d\n", pid);
3260       delete llproc;
3261       return Process::ptr();
3262    }
3263
3264    return newproc;
3265 }
3266
3267 Process::Process() :
3268    llproc_(NULL),
3269    exitstate_(NULL)
3270 {
3271 }
3272
3273 Process::~Process()
3274 {
3275    if (exitstate_) {
3276       delete exitstate_;
3277       exitstate_ = NULL;
3278    }
3279 }
3280
3281
3282 Dyninst::PID Process::getPid() const
3283 {
3284    MTLock lock_this_func(MTLock::allow_generator);
3285    if (!llproc_) {
3286       assert(exitstate_);
3287       return exitstate_->pid;
3288    }
3289    return llproc_->getPid();
3290 }
3291
3292 int_process *Process::llproc() const
3293 {
3294    return llproc_;
3295 }
3296
3297 const ThreadPool &Process::threads() const
3298 {
3299    MTLock lock_this_func;
3300    static ThreadPool *err_pool;
3301    if (!llproc_) {
3302       perr_printf("threads on deleted process\n");
3303       setLastError(err_exited, "Process is exited\n");
3304       if (!err_pool) {
3305          err_pool = new ThreadPool();
3306       }
3307       return *err_pool;
3308    }
3309
3310    return *(llproc_->threadPool()->pool());
3311 }
3312
3313 ThreadPool &Process::threads()
3314 {
3315    MTLock lock_this_func;
3316    static ThreadPool *err_pool;
3317    if (!llproc_) {
3318       perr_printf("threads on deleted process\n");
3319       setLastError(err_exited, "Process is exited\n");
3320       if (!err_pool) {
3321          err_pool = new ThreadPool();
3322       }
3323       return *err_pool;
3324    }
3325
3326    return *(llproc_->threadPool()->pool());
3327 }
3328
3329 const LibraryPool &Process::libraries() const
3330 {
3331    MTLock lock_this_func;
3332    static LibraryPool *err_pool;
3333    if (!llproc_) {
3334       perr_printf("libraries on deleted process\n");
3335       setLastError(err_exited, "Process is exited\n");
3336       if (!err_pool) {
3337          err_pool = new LibraryPool();
3338       }
3339       return *err_pool;
3340    }
3341
3342    return llproc_->libpool;
3343 }
3344
3345 LibraryPool &Process::libraries()
3346 {
3347    MTLock lock_this_func;
3348    static LibraryPool *err_pool;
3349    if (!llproc_) {
3350       perr_printf("libraries on deleted process\n");
3351       setLastError(err_exited, "Process is exited\n");
3352       if (!err_pool) {
3353          err_pool = new LibraryPool();
3354       }
3355       return *err_pool;
3356    }
3357
3358    return llproc_->libpool;
3359 }
3360
3361 bool Process::continueProc()
3362 {
3363    MTLock lock_this_func(MTLock::deliver_callbacks);
3364    if (!llproc_) {
3365       perr_printf("coninueProc on deleted process\n");
3366       setLastError(err_exited, "Process is exited\n");
3367       return false;
3368    }
3369
3370    pthrd_printf("User continuing entire process %d\n", getPid());
3371    if (int_process::isInCB()) {
3372       perr_printf("User attempted call on process while in CB, erroring.");
3373       setLastError(err_incallback, "Cannot continueProc from callback\n");
3374       return false;
3375    }
3376
3377    return llproc_->threadPool()->userCont();
3378 }
3379
3380 bool Process::isCrashed() const
3381 {
3382    MTLock lock_this_func;
3383    if (!llproc_) {
3384       assert(exitstate_);
3385       return exitstate_->crashed;
3386    }
3387    int crashSignal = 0;
3388    return (llproc_->getState() == int_process::exited && llproc_->getCrashSignal(crashSignal));
3389 }
3390
3391 bool Process::isExited() const
3392 {
3393    MTLock lock_this_func;
3394    int exitCode = 0;
3395    if (!llproc_) {
3396       assert(exitstate_);
3397       return exitstate_->exited;
3398    }
3399    return (llproc_->getState() == int_process::exited && llproc_->getExitCode(exitCode));
3400 }
3401
3402 int Process::getCrashSignal() const
3403 {
3404    MTLock lock_this_func;
3405    if (!llproc_) {
3406       assert(exitstate_);
3407       return exitstate_->crashed ? exitstate_->crash_signal : 0;
3408    }
3409
3410    int crashSignal = 0;
3411    if (!(llproc_->getState() == int_process::exited && llproc_->getCrashSignal(crashSignal)))
3412       return 0;
3413    return crashSignal;
3414 }
3415
3416 int Process::getExitCode() const
3417 {
3418    MTLock lock_this_func;
3419    if (!llproc_) {
3420       assert(exitstate_);
3421       return !exitstate_->crashed ? exitstate_->exit_code : 0;
3422    }
3423
3424    int exitCode = 0;
3425    if (!(llproc_->getState() == int_process::exited && llproc_->getExitCode(exitCode)))
3426       return 0;
3427    return exitCode;
3428 }
3429
3430 bool Process::stopProc()
3431 {
3432    MTLock lock_this_func(MTLock::deliver_callbacks);
3433    if (!llproc_) {
3434       perr_printf("stopProc on deleted process\n");
3435       setLastError(err_exited, "Process is exited\n");
3436       return false;
3437    }
3438
3439    pthrd_printf("User stopping entire process %d\n", getPid());
3440    if (int_process::isInCB()) {
3441       perr_printf("User attempted call on process while in CB, erroring.");
3442       setLastError(err_incallback, "Cannot continueProc from callback\n");
3443       return false;
3444    }
3445
3446    return llproc_->threadPool()->userStop();
3447 }
3448
3449 bool Process::detach()
3450 {
3451    MTLock lock_this_func(MTLock::deliver_callbacks);
3452    if (!llproc_) {
3453       perr_printf("detach on deleted process\n");
3454       setLastError(err_exited, "Process is exited\n");
3455       return false;
3456    }
3457    bool should_delete;
3458    bool result = llproc_->detach(should_delete);
3459    if (!result) {
3460       pthrd_printf("Failed to detach from process\n");
3461       return false;
3462    }
3463    if (should_delete) {
3464       HandlerPool *hp = llproc_->handlerPool();
3465       delete llproc_;
3466       delete hp;
3467       assert(!llproc_);
3468    }
3469    return true;
3470 }
3471
3472 bool Process::terminate()
3473 {
3474    MTLock lock_this_func(MTLock::deliver_callbacks);
3475    if (!llproc_) {
3476       perr_printf("terminate on deleted process\n");
3477       setLastError(err_exited, "Process is exited\n");
3478       return false;
3479    }
3480
3481    pthrd_printf("User terminating process %d\n", llproc_->getPid());
3482    bool needsSync = false;
3483    bool result = llproc_->terminate(needsSync);
3484    if (!result) {
3485       pthrd_printf("Terminating process %d failed\n", llproc_->getPid());
3486       return false;
3487    }
3488
3489    if (needsSync) {
3490       bool proc_exited = false;
3491       while (!proc_exited) {
3492          bool result = int_process::waitAndHandleForProc(true, llproc(), proc_exited);
3493          if (!result) {
3494             perr_printf("Error waiting for process to terminate\n");
3495             return false;
3496          }
3497       }
3498    }
3499    else {
3500       HandlerPool *hp = llproc_->handlerPool();
3501       delete llproc_;
3502       delete hp;
3503       assert(!llproc_);
3504    }
3505
3506    return true;
3507 }
3508
3509 bool Process::isTerminated() const
3510 {
3511    MTLock lock_this_func;
3512    if (!llproc_) {
3513       return true;
3514    }
3515    return (llproc_->getState() == int_process::exited);
3516 }
3517
3518 bool Process::hasStoppedThread() const
3519 {
3520    MTLock lock_this_func;
3521    if (!llproc_) {
3522       perr_printf("hasStoppedThread on deleted process\n");
3523       setLastError(err_exited, "Process is exited\n");
3524       return false;
3525    }
3526
3527    int_threadPool::iterator i;
3528    for (i = llproc_->threadPool()->begin(); i != llproc_->threadPool()->end(); i++) {
3529       if ((*i)->getUserState() == int_thread::stopped)
3530          return true;
3531    }
3532    return false;
3533 }
3534
3535 bool Process::hasRunningThread() const
3536 {
3537    MTLock lock_this_func;
3538    if (!llproc_) {
3539       perr_printf("hasRunningThread on deleted process\n");
3540       setLastError(err_exited, "Process is exited\n");
3541       return false;
3542    }
3543
3544    int_threadPool::iterator i;
3545    for (i = llproc_->threadPool()->begin(); i != llproc_->threadPool()->end(); i++) {
3546       if ((*i)->getUserState() == int_thread::running)
3547          return true;
3548    }
3549    return false;
3550 }
3551
3552 bool Process::allThreadsStopped() const
3553 {
3554    MTLock lock_this_func;
3555    if (!llproc_) {
3556       perr_printf("allThreadsStopped on deleted process\n");
3557       setLastError(err_exited, "Process is exited\n");
3558       return false;
3559    }
3560
3561    int_threadPool::iterator i;
3562    for (i = llproc_->threadPool()->begin(); i != llproc_->threadPool()->end(); i++) {
3563       if ((*i)->getUserState() == int_thread::running)
3564          return false;
3565    }
3566    return true;
3567 }
3568
3569 bool Process::allThreadsRunning() const
3570 {
3571    MTLock lock_this_func;
3572    if (!llproc_) {
3573       perr_printf("allThreadsRunning on deleted process\n");
3574       setLastError(err_exited, "Process is exited\n");
3575       return false;
3576    }
3577
3578    int_threadPool::iterator i;
3579    for (i = llproc_->threadPool()->begin(); i != llproc_->threadPool()->end(); i++) {
3580       if ((*i)->getUserState() == int_thread::stopped)
3581          return false;
3582    }
3583    return true;
3584 }
3585
3586 Thread::ptr Process::postIRPC(IRPC::ptr irpc) const
3587 {
3588    MTLock lock_this_func;
3589    if (!llproc_) {
3590       perr_printf("postIRPC on deleted process\n");
3591       setLastError(err_exited, "Process is exited\n");
3592       return Thread::ptr();
3593    }
3594
3595    int_process *proc = llproc();
3596    int_iRPC::ptr rpc = irpc->llrpc()->rpc;
3597    bool result = rpcMgr()->postRPCToProc(proc, rpc);
3598    if (!result) {
3599       pthrd_printf("postRPCToProc failed on %d\n", proc->getPid());
3600       return Thread::ptr();
3601    }
3602
3603    if (int_process::in_callback) {
3604       pthrd_printf("Returning from postIRPC in callback\n");
3605       return rpc->thread()->thread();
3606    }
3607    int_thread *thr = rpc->thread();
3608    if (thr->getInternalState() == int_thread::running) {
3609       //The thread is running, let's go ahead and start the RPC going.
3610       bool result = thr->handleNextPostedIRPC(true);
3611       if (!result) {
3612          pthrd_printf("handleNextPostedIRPC failed\n");
3613          return Thread::ptr();
3614       }
3615    }
3616    return thr->thread();
3617 }
3618
3619 bool Process::getPostedIRPCs(std::vector<IRPC::ptr> &rpcs) const
3620 {
3621    MTLock lock_this_func;
3622    if (!llproc_) {
3623       perr_printf("postIRPC on deleted process\n");
3624       setLastError(err_exited, "Process is exited\n");
3625       return false;
3626    }
3627    int_threadPool *tp = llproc()->threadPool();
3628    for (int_threadPool::iterator i = tp->begin(); i != tp->end(); i++)
3629    {
3630       int_thread *thr = *i;
3631       rpc_list_t *rpc_list = thr->getPostedRPCs();
3632       for (rpc_list_t::iterator j = rpc_list->begin(); j != rpc_list->end(); j++) {
3633          IRPC::ptr up_rpc = (*j)->getIRPC().lock();
3634          if (up_rpc == IRPC::ptr())
3635             continue;
3636          rpcs.push_back(up_rpc);
3637       }
3638    }
3639    return true;
3640 }
3641
3642 Dyninst::Architecture Process::getArchitecture() const
3643 {
3644    MTLock lock_this_func;
3645    if (!llproc_) {
3646       perr_printf("getArchitecture on deleted process\n");
3647       setLastError(err_exited, "Process is exited\n");
3648       return Dyninst::Arch_none;
3649    }
3650    return llproc_->getTargetArch();
3651 }
3652
3653 Dyninst::Address Process::mallocMemory(size_t size, Dyninst::Address addr)
3654 {
3655    MTLock lock_this_func(MTLock::deliver_callbacks);
3656    if (!llproc_) {
3657       perr_printf("mallocMemory on deleted process\n");
3658       setLastError(err_exited, "Process is exited\n");
3659       return false;
3660    }
3661
3662    if (int_process::isInCB()) {
3663       perr_printf("User attempted call on process while in CB, erroring.");
3664       setLastError(err_incallback, "Cannot mallocMemory from callback\n");
3665       return false;
3666    }
3667    return llproc_->infMalloc(size, true, addr);
3668 }
3669
3670 Dyninst::Address Process::mallocMemory(size_t size)
3671 {
3672    MTLock lock_this_func(MTLock::deliver_callbacks);
3673    if (!llproc_) {
3674       perr_printf("mallocMemory on deleted process\n");
3675       setLastError(err_exited, "Process is exited\n");
3676       return false;
3677    }
3678
3679    if (int_process::isInCB()) {
3680       perr_printf("User attempted call on process while in CB, erroring.");
3681       setLastError(err_incallback, "Cannot mallocMemory from callback\n");
3682       return false;
3683    }
3684    return llproc_->infMalloc(size, false, 0x0);
3685 }
3686
3687 bool Process::freeMemory(Dyninst::Address addr)
3688 {
3689    MTLock lock_this_func(MTLock::deliver_callbacks);
3690    if (!llproc_) {
3691       perr_printf("freeMemory on deleted process\n");
3692       setLastError(err_exited, "Process is exited\n");
3693       return false;
3694    }
3695
3696    if (int_process::isInCB()) {
3697       perr_printf("User attempted call on process while in CB, erroring.");
3698       setLastError(err_incallback, "Cannot freeMemory from callback\n");
3699       return false;
3700    }
3701    return llproc_->infFree(addr);
3702 }
3703
3704 bool Process::writeMemory(Dyninst::Address addr, void *buffer, size_t size) const
3705 {
3706    MTLock lock_this_func;
3707    if (!llproc_) {
3708       perr_printf("writeMemory on deleted process\n");
3709       setLastError(err_exited, "Process is exited\n");
3710       return false;
3711    }
3712
3713    pthrd_printf("User wants to write memory from 0x%lx to 0x%p of size %lu\n",
3714                 addr, buffer, (unsigned long) size);
3715    return llproc_->writeMem(buffer, addr, size);
3716 }
3717
3718 bool Process::readMemory(void *buffer, Dyninst::Address addr, size_t size) const
3719 {
3720    MTLock lock_this_func;
3721    if (!llproc_) {
3722       perr_printf("readMemory on deleted process\n");
3723       setLastError(err_exited, "Process is exited\n");
3724       return false;
3725    }
3726
3727    pthrd_printf("User wants to read memory from 0x%lx to 0x%p of size %lu\n",
3728                 addr, buffer, (unsigned long) size);
3729    return llproc_->readMem(buffer, addr, size);
3730 }
3731
3732 bool Process::addBreakpoint(Address addr, Breakpoint::ptr bp) const
3733 {
3734    MTLock lock_this_func;
3735    if (!llproc_) {
3736       perr_printf("addBreakpoint on deleted process\n");
3737       setLastError(err_exited, "Process is exited\n");
3738       return false;
3739    }
3740
3741    if (hasRunningThread()) {
3742       perr_printf("User attempted to add breakpoint to running process\n");
3743       setLastError(err_notstopped, "Attempted to insert breakpoint into running process\n");
3744       return false;
3745    }
3746    return llproc_->addBreakpoint(addr, bp->llbp());
3747 }
3748
3749 bool Process::rmBreakpoint(Dyninst::Address addr, Breakpoint::ptr bp) const
3750 {
3751    MTLock lock_this_func;
3752    if (!llproc_) {
3753       perr_printf("rmBreakpoint on deleted process\n");
3754       setLastError(err_exited, "Process is exited\n");
3755       return false;
3756    }
3757
3758    if (hasRunningThread()) {
3759       perr_printf("User attempted to add breakpoint to running process\n");
3760       setLastError(err_notstopped, "Attempted to insert breakpoint into running process\n");
3761       return false;
3762    }
3763    return llproc_->rmBreakpoint(addr, bp->llbp());
3764 }
3765
3766 Thread::Thread() :
3767    llthread_(NULL),
3768    exitstate_(NULL)
3769 {
3770 }
3771
3772 Thread::~Thread()
3773 {
3774    if (exitstate_) {
3775       delete exitstate_;
3776       exitstate_ = NULL;
3777    }
3778 }
3779
3780 Process::ptr Thread::getProcess() const
3781 {
3782    MTLock lock_this_func;
3783    if (!llthread_) {
3784       assert(exitstate_);
3785       return exitstate_->proc_ptr;
3786    }
3787    return llthread_->proc();
3788 }
3789
3790 int_thread *Thread::llthrd() const
3791 {
3792    return llthread_;
3793 }
3794
3795 bool Thread::isStopped() const
3796 {
3797    MTLock lock_this_func;
3798    if (!llthread_) {
3799       perr_printf("isStopped called on exited thread\n");
3800       setLastError(err_exited, "Thread is exited\n");
3801       return false;
3802    }
3803    return llthread_->getUserState() == int_thread::stopped;
3804 }
3805
3806 bool Thread::isRunning() const
3807 {
3808    MTLock lock_this_func;
3809    if (!llthread_) {
3810       perr_printf("isRunning called on exited thread\n");
3811       setLastError(err_exited, "Thread is exited\n");
3812       return false;
3813    }
3814    return llthread_->getUserState() == int_thread::running;
3815 }
3816
3817 bool Thread::isLive() const
3818 {
3819    MTLock lock_this_func;
3820    if (!llthread_) {
3821       return false;
3822    }
3823    return (llthread_->getUserState() == int_thread::stopped ||
3824            llthread_->getUserState() == int_thread::running);
3825 }
3826
3827 bool Thread::stopThread()
3828 {
3829    MTLock lock_this_func(MTLock::deliver_callbacks);
3830    if (!llthread_) {
3831       perr_printf("stopThread called on exited thread\n");
3832       setLastError(err_exited, "Thread is exited\n");
3833       return false;
3834    }
3835
3836    if (int_process::isInCB()) {
3837       perr_printf("User attempted continue call on thread while in CB, erroring.");
3838       setLastError(err_incallback, "Cannot continueThread from callback\n");
3839       return false;
3840    }
3841
3842    return llthread_->userStop();
3843 }
3844
3845 bool Thread::continueThread()
3846 {
3847    MTLock lock_this_func(MTLock::deliver_callbacks);
3848    if (!llthread_) {
3849       perr_printf("continueThread called on exited thread\n");
3850       setLastError(err_exited, "Thread is exited\n");
3851       return false;
3852    }
3853
3854    if (int_process::isInCB()) {
3855       perr_printf("User attempted continue call on thread while in CB, erroring.");
3856       setLastError(err_incallback, "Cannot continueThread from callback\n");
3857       return false;
3858    }
3859
3860    return llthread_->userCont();
3861 }
3862
3863 bool Thread::getAllRegisters(RegisterPool &pool) const
3864 {
3865    MTLock lock_this_func;
3866    if (!llthread_) {
3867       perr_printf("getAllRegisters called on exited thread\n");
3868       setLastError(err_exited, "Thread is exited\n");
3869       return false;
3870    }
3871
3872    if (llthread_->getUserState() != int_thread::stopped) {
3873       setLastError(err_notstopped, "Thread must be stopped before getting registers");
3874       perr_printf("User called getAllRegisters on running thread %d\n", llthread_->getLWP());
3875       return false;
3876    }
3877    return llthread_->getAllRegisters(*pool.llregpool);
3878 }
3879
3880 bool Thread::setAllRegisters(RegisterPool &pool) const
3881 {
3882    MTLock lock_this_func;
3883    if (!llthread_) {
3884       perr_printf("setAllRegisters called on exited thread\n");
3885       setLastError(err_exited, "Thread is exited\n");
3886       return false;
3887    }
3888    if (llthread_->getUserState() != int_thread::stopped) {
3889       setLastError(err_notstopped, "Thread must be stopped before setting registers");
3890       perr_printf("User called setAllRegisters on running thread %d\n", llthread_->getLWP());
3891       return false;
3892    }
3893    return llthread_->setAllRegisters(*pool.llregpool);
3894 }
3895
3896 bool Thread::getRegister(Dyninst::MachRegister reg, Dyninst::MachRegisterVal &val) const
3897 {
3898    MTLock lock_this_func;
3899    if (!llthread_) {
3900       perr_printf("getRegister called on exited thread\n");
3901       setLastError(err_exited, "Thread is exited\n");
3902       return false;
3903    }
3904    if (llthread_->getUserState() != int_thread::stopped) {
3905       setLastError(err_notstopped, "Thread must be stopped before getting registers");
3906       perr_printf("User called getRegister on running thread %d\n", llthread_->getLWP());
3907       return false;
3908    }
3909    return llthread_->getRegister(reg, val);
3910 }
3911
3912 bool Thread::setRegister(Dyninst::MachRegister reg, Dyninst::MachRegisterVal val) const
3913 {
3914    MTLock lock_this_func;
3915    if (!llthread_) {
3916       perr_printf("setRegister called on exited thread\n");
3917       setLastError(err_exited, "Thread is exited\n");
3918       return false;
3919    }
3920    if (llthread_->getUserState() != int_thread::stopped) {
3921       setLastError(err_notstopped, "Thread must be stopped before setting registers");
3922       perr_printf("User called setRegister on running thread %d\n", llthread_->getLWP());
3923       return false;
3924    }
3925    return llthread_->setRegister(reg, val);
3926 }
3927
3928 bool Thread::isInitialThread() const
3929 {
3930    MTLock lock_this_func;
3931    if (!llthread_) {
3932       perr_printf("isInitialThrad called on exited thread\n");
3933       setLastError(err_exited, "Thread is exited\n");
3934       return false;
3935    }
3936    return llthread_->llproc()->threadPool()->initialThread() == llthread_;
3937 }
3938
3939 void Thread::setSingleStepMode(bool