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