contrib/llvm/tools/lldb/source/API/SBThread.cpp

   1 //===-- SBThread.cpp --------------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "lldb/lldb-python.h"
  11
  12 #include "lldb/API/SBThread.h"
  13
  14 #include "lldb/API/SBSymbolContext.h"
  15 #include "lldb/API/SBFileSpec.h"
  16 #include "lldb/API/SBStream.h"
  17 #include "lldb/Breakpoint/BreakpointLocation.h"
  18 #include "lldb/Core/Debugger.h"
  19 #include "lldb/Core/State.h"
  20 #include "lldb/Core/Stream.h"
  21 #include "lldb/Core/StreamFile.h"
  22 #include "lldb/Interpreter/CommandInterpreter.h"
  23 #include "lldb/Target/SystemRuntime.h"
  24 #include "lldb/Target/Thread.h"
  25 #include "lldb/Target/Process.h"
  26 #include "lldb/Symbol/SymbolContext.h"
  27 #include "lldb/Symbol/CompileUnit.h"
  28 #include "lldb/Target/StopInfo.h"
  29 #include "lldb/Target/Target.h"
  30 #include "lldb/Target/ThreadPlan.h"
  31 #include "lldb/Target/ThreadPlanStepInstruction.h"
  32 #include "lldb/Target/ThreadPlanStepOut.h"
  33 #include "lldb/Target/ThreadPlanStepRange.h"
  34 #include "lldb/Target/ThreadPlanStepInRange.h"
  35
  36
  37 #include "lldb/API/SBAddress.h"
  38 #include "lldb/API/SBDebugger.h"
  39 #include "lldb/API/SBEvent.h"
  40 #include "lldb/API/SBFrame.h"
  41 #include "lldb/API/SBProcess.h"
  42 #include "lldb/API/SBValue.h"
  43
  44 using namespace lldb;
  45 using namespace lldb_private;
  46
  47 const char *
  48 SBThread::GetBroadcasterClassName ()
  49 {
  50     return Thread::GetStaticBroadcasterClass().AsCString();
  51 }
  52
  53 //----------------------------------------------------------------------
  54 // Constructors
  55 //----------------------------------------------------------------------
  56 SBThread::SBThread () :
  57     m_opaque_sp (new ExecutionContextRef())
  58 {
  59 }
  60
  61 SBThread::SBThread (const ThreadSP& lldb_object_sp) :
  62     m_opaque_sp (new ExecutionContextRef(lldb_object_sp))
  63 {
  64 }
  65
  66 SBThread::SBThread (const SBThread &rhs) :
  67     m_opaque_sp (new ExecutionContextRef(*rhs.m_opaque_sp))
  68 {
  69
  70 }
  71
  72 //----------------------------------------------------------------------
  73 // Assignment operator
  74 //----------------------------------------------------------------------
  75
  76 const lldb::SBThread &
  77 SBThread::operator = (const SBThread &rhs)
  78 {
  79     if (this != &rhs)
  80         *m_opaque_sp = *rhs.m_opaque_sp;
  81     return *this;
  82 }
  83
  84 //----------------------------------------------------------------------
  85 // Destructor
  86 //----------------------------------------------------------------------
  87 SBThread::~SBThread()
  88 {
  89 }
  90
  91 bool
  92 SBThread::IsValid() const
  93 {
  94     return m_opaque_sp->GetThreadSP().get() != NULL;
  95 }
  96
  97 void
  98 SBThread::Clear ()
  99 {
 100     m_opaque_sp->Clear();
 101 }
 102
 103
 104 StopReason
 105 SBThread::GetStopReason()
 106 {
 107     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
 108
 109     StopReason reason = eStopReasonInvalid;
 110     Mutex::Locker api_locker;
 111     ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
 112
 113     if (exe_ctx.HasThreadScope())
 114     {
 115         Process::StopLocker stop_locker;
 116         if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock()))
 117         {
 118             return exe_ctx.GetThreadPtr()->GetStopReason();
 119         }
 120         else
 121         {
 122             if (log)
 123                 log->Printf ("SBThread(%p)::GetStopReason() => error: process is running", exe_ctx.GetThreadPtr());
 124         }
 125     }
 126
 127     if (log)
 128         log->Printf ("SBThread(%p)::GetStopReason () => %s", exe_ctx.GetThreadPtr(),
 129                      Thread::StopReasonAsCString (reason));
 130
 131     return reason;
 132 }
 133
 134 size_t
 135 SBThread::GetStopReasonDataCount ()
 136 {
 137     Mutex::Locker api_locker;
 138     ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
 139
 140     if (exe_ctx.HasThreadScope())
 141     {
 142         Process::StopLocker stop_locker;
 143         if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock()))
 144         {
 145             StopInfoSP stop_info_sp = exe_ctx.GetThreadPtr()->GetStopInfo ();
 146             if (stop_info_sp)
 147             {
 148                 StopReason reason = stop_info_sp->GetStopReason();
 149                 switch (reason)
 150                 {
 151                 case eStopReasonInvalid:
 152                 case eStopReasonNone:
 153                 case eStopReasonTrace:
 154                 case eStopReasonExec:
 155                 case eStopReasonPlanComplete:
 156                 case eStopReasonThreadExiting:
 157                     // There is no data for these stop reasons.
 158                     return 0;
 159
 160                 case eStopReasonBreakpoint:
 161                     {
 162                         break_id_t site_id = stop_info_sp->GetValue();
 163                         lldb::BreakpointSiteSP bp_site_sp (exe_ctx.GetProcessPtr()->GetBreakpointSiteList().FindByID (site_id));
 164                         if (bp_site_sp)
 165                             return bp_site_sp->GetNumberOfOwners () * 2;
 166                         else
 167                             return 0; // Breakpoint must have cleared itself...
 168                     }
 169                     break;
 170
 171                 case eStopReasonWatchpoint:
 172                     return 1;
 173
 174                 case eStopReasonSignal:
 175                     return 1;
 176
 177                 case eStopReasonException:
 178                     return 1;
 179                 }
 180             }
 181         }
 182         else
 183         {
 184             Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
 185             if (log)
 186                 log->Printf ("SBThread(%p)::GetStopReasonDataCount() => error: process is running", exe_ctx.GetThreadPtr());
 187         }
 188     }
 189     return 0;
 190 }
 191
 192 uint64_t
 193 SBThread::GetStopReasonDataAtIndex (uint32_t idx)
 194 {
 195     Mutex::Locker api_locker;
 196     ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
 197
 198     if (exe_ctx.HasThreadScope())
 199     {
 200         Process::StopLocker stop_locker;
 201         if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock()))
 202         {
 203             Thread *thread = exe_ctx.GetThreadPtr();
 204             StopInfoSP stop_info_sp = thread->GetStopInfo ();
 205             if (stop_info_sp)
 206             {
 207                 StopReason reason = stop_info_sp->GetStopReason();
 208                 switch (reason)
 209                 {
 210                 case eStopReasonInvalid:
 211                 case eStopReasonNone:
 212                 case eStopReasonTrace:
 213                 case eStopReasonExec:
 214                 case eStopReasonPlanComplete:
 215                 case eStopReasonThreadExiting:
 216                     // There is no data for these stop reasons.
 217                     return 0;
 218
 219                 case eStopReasonBreakpoint:
 220                     {
 221                         break_id_t site_id = stop_info_sp->GetValue();
 222                         lldb::BreakpointSiteSP bp_site_sp (exe_ctx.GetProcessPtr()->GetBreakpointSiteList().FindByID (site_id));
 223                         if (bp_site_sp)
 224                         {
 225                             uint32_t bp_index = idx / 2;
 226                             BreakpointLocationSP bp_loc_sp (bp_site_sp->GetOwnerAtIndex (bp_index));
 227                             if (bp_loc_sp)
 228                             {
 229                                 if (bp_index & 1)
 230                                 {
 231                                     // Odd idx, return the breakpoint location ID
 232                                     return bp_loc_sp->GetID();
 233                                 }
 234                                 else
 235                                 {
 236                                     // Even idx, return the breakpoint ID
 237                                     return bp_loc_sp->GetBreakpoint().GetID();
 238                                 }
 239                             }
 240                         }
 241                         return LLDB_INVALID_BREAK_ID;
 242                     }
 243                     break;
 244
 245                 case eStopReasonWatchpoint:
 246                     return stop_info_sp->GetValue();
 247
 248                 case eStopReasonSignal:
 249                     return stop_info_sp->GetValue();
 250
 251                 case eStopReasonException:
 252                     return stop_info_sp->GetValue();
 253                 }
 254             }
 255         }
 256         else
 257         {
 258             Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
 259             if (log)
 260                 log->Printf ("SBThread(%p)::GetStopReasonDataAtIndex() => error: process is running", exe_ctx.GetThreadPtr());
 261         }
 262     }
 263     return 0;
 264 }
 265
 266 size_t
 267 SBThread::GetStopDescription (char *dst, size_t dst_len)
 268 {
 269     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
 270
 271     Mutex::Locker api_locker;
 272     ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
 273
 274     if (exe_ctx.HasThreadScope())
 275     {
 276         Process::StopLocker stop_locker;
 277         if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock()))
 278         {
 279
 280             StopInfoSP stop_info_sp = exe_ctx.GetThreadPtr()->GetStopInfo ();
 281             if (stop_info_sp)
 282             {
 283                 const char *stop_desc = stop_info_sp->GetDescription();
 284                 if (stop_desc)
 285                 {
 286                     if (log)
 287                         log->Printf ("SBThread(%p)::GetStopDescription (dst, dst_len) => \"%s\"",
 288                                      exe_ctx.GetThreadPtr(), stop_desc);
 289                     if (dst)
 290                         return ::snprintf (dst, dst_len, "%s", stop_desc);
 291                     else
 292                     {
 293                         // NULL dst passed in, return the length needed to contain the description
 294                         return ::strlen (stop_desc) + 1; // Include the NULL byte for size
 295                     }
 296                 }
 297                 else
 298                 {
 299                     size_t stop_desc_len = 0;
 300                     switch (stop_info_sp->GetStopReason())
 301                     {
 302                     case eStopReasonTrace:
 303                     case eStopReasonPlanComplete:
 304                         {
 305                             static char trace_desc[] = "step";
 306                             stop_desc = trace_desc;
 307                             stop_desc_len = sizeof(trace_desc); // Include the NULL byte for size
 308                         }
 309                         break;
 310
 311                     case eStopReasonBreakpoint:
 312                         {
 313                             static char bp_desc[] = "breakpoint hit";
 314                             stop_desc = bp_desc;
 315                             stop_desc_len = sizeof(bp_desc); // Include the NULL byte for size
 316                         }
 317                         break;
 318
 319                     case eStopReasonWatchpoint:
 320                         {
 321                             static char wp_desc[] = "watchpoint hit";
 322                             stop_desc = wp_desc;
 323                             stop_desc_len = sizeof(wp_desc); // Include the NULL byte for size
 324                         }
 325                         break;
 326
 327                     case eStopReasonSignal:
 328                         {
 329                             stop_desc = exe_ctx.GetProcessPtr()->GetUnixSignals ().GetSignalAsCString (stop_info_sp->GetValue());
 330                             if (stop_desc == NULL || stop_desc[0] == '\0')
 331                             {
 332                                 static char signal_desc[] = "signal";
 333                                 stop_desc = signal_desc;
 334                                 stop_desc_len = sizeof(signal_desc); // Include the NULL byte for size
 335                             }
 336                         }
 337                         break;
 338
 339                     case eStopReasonException:
 340                         {
 341                             char exc_desc[] = "exception";
 342                             stop_desc = exc_desc;
 343                             stop_desc_len = sizeof(exc_desc); // Include the NULL byte for size
 344                         }
 345                         break;
 346
 347                     case eStopReasonExec:
 348                         {
 349                             char exc_desc[] = "exec";
 350                             stop_desc = exc_desc;
 351                             stop_desc_len = sizeof(exc_desc); // Include the NULL byte for size
 352                         }
 353                         break;
 354
 355                     case eStopReasonThreadExiting:
 356                         {
 357                             char limbo_desc[] = "thread exiting";
 358                             stop_desc = limbo_desc;
 359                             stop_desc_len = sizeof(limbo_desc);
 360                         }
 361                         break;
 362                     default:
 363                         break;
 364                     }
 365
 366                     if (stop_desc && stop_desc[0])
 367                     {
 368                         if (log)
 369                             log->Printf ("SBThread(%p)::GetStopDescription (dst, dst_len) => '%s'",
 370                                          exe_ctx.GetThreadPtr(), stop_desc);
 371
 372                         if (dst)
 373                             return ::snprintf (dst, dst_len, "%s", stop_desc) + 1; // Include the NULL byte
 374
 375                         if (stop_desc_len == 0)
 376                             stop_desc_len = ::strlen (stop_desc) + 1; // Include the NULL byte
 377
 378                         return stop_desc_len;
 379                     }
 380                 }
 381             }
 382         }
 383         else
 384         {
 385             Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
 386             if (log)
 387                 log->Printf ("SBThread(%p)::GetStopDescription() => error: process is running", exe_ctx.GetThreadPtr());
 388         }
 389     }
 390     if (dst)
 391         *dst = 0;
 392     return 0;
 393 }
 394
 395 SBValue
 396 SBThread::GetStopReturnValue ()
 397 {
 398     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
 399     ValueObjectSP return_valobj_sp;
 400     Mutex::Locker api_locker;
 401     ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
 402
 403     if (exe_ctx.HasThreadScope())
 404     {
 405         Process::StopLocker stop_locker;
 406         if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock()))
 407         {
 408             StopInfoSP stop_info_sp = exe_ctx.GetThreadPtr()->GetStopInfo ();
 409             if (stop_info_sp)
 410             {
 411                 return_valobj_sp = StopInfo::GetReturnValueObject (stop_info_sp);
 412             }
 413         }
 414         else
 415         {
 416             if (log)
 417                 log->Printf ("SBThread(%p)::GetStopReturnValue() => error: process is running", exe_ctx.GetThreadPtr());
 418         }
 419     }
 420
 421     if (log)
 422         log->Printf ("SBThread(%p)::GetStopReturnValue () => %s", exe_ctx.GetThreadPtr(),
 423                                                                   return_valobj_sp.get()
 424                                                                       ? return_valobj_sp->GetValueAsCString()
 425                                                                         : "<no return value>");
 426
 427     return SBValue (return_valobj_sp);
 428 }
 429
 430 void
 431 SBThread::SetThread (const ThreadSP& lldb_object_sp)
 432 {
 433     m_opaque_sp->SetThreadSP (lldb_object_sp);
 434 }
 435
 436
 437 lldb::tid_t
 438 SBThread::GetThreadID () const
 439 {
 440     ThreadSP thread_sp(m_opaque_sp->GetThreadSP());
 441     if (thread_sp)
 442         return thread_sp->GetID();
 443     return LLDB_INVALID_THREAD_ID;
 444 }
 445
 446 uint32_t
 447 SBThread::GetIndexID () const
 448 {
 449     ThreadSP thread_sp(m_opaque_sp->GetThreadSP());
 450     if (thread_sp)
 451         return thread_sp->GetIndexID();
 452     return LLDB_INVALID_INDEX32;
 453 }
 454
 455 const char *
 456 SBThread::GetName () const
 457 {
 458     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
 459     const char *name = NULL;
 460     Mutex::Locker api_locker;
 461     ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
 462
 463     if (exe_ctx.HasThreadScope())
 464     {
 465         Process::StopLocker stop_locker;
 466         if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock()))
 467         {
 468             name = exe_ctx.GetThreadPtr()->GetName();
 469         }
 470         else
 471         {
 472             if (log)
 473                 log->Printf ("SBThread(%p)::GetName() => error: process is running", exe_ctx.GetThreadPtr());
 474         }
 475     }
 476
 477     if (log)
 478         log->Printf ("SBThread(%p)::GetName () => %s", exe_ctx.GetThreadPtr(), name ? name : "NULL");
 479
 480     return name;
 481 }
 482
 483 const char *
 484 SBThread::GetQueueName () const
 485 {
 486     const char *name = NULL;
 487     Mutex::Locker api_locker;
 488     ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
 489
 490     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
 491     if (exe_ctx.HasThreadScope())
 492     {
 493         Process::StopLocker stop_locker;
 494         if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock()))
 495         {
 496             name = exe_ctx.GetThreadPtr()->GetQueueName();
 497         }
 498         else
 499         {
 500             if (log)
 501                 log->Printf ("SBThread(%p)::GetQueueName() => error: process is running", exe_ctx.GetThreadPtr());
 502         }
 503     }
 504
 505     if (log)
 506         log->Printf ("SBThread(%p)::GetQueueName () => %s", exe_ctx.GetThreadPtr(), name ? name : "NULL");
 507
 508     return name;
 509 }
 510
 511 lldb::queue_id_t
 512 SBThread::GetQueueID () const
 513 {
 514     queue_id_t id = LLDB_INVALID_QUEUE_ID;
 515     Mutex::Locker api_locker;
 516     ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
 517
 518     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
 519     if (exe_ctx.HasThreadScope())
 520     {
 521         Process::StopLocker stop_locker;
 522         if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock()))
 523         {
 524             id = exe_ctx.GetThreadPtr()->GetQueueID();
 525         }
 526         else
 527         {
 528             if (log)
 529                 log->Printf ("SBThread(%p)::GetQueueID() => error: process is running", exe_ctx.GetThreadPtr());
 530         }
 531     }
 532
 533     if (log)
 534         log->Printf ("SBThread(%p)::GetQueueID () => 0x%" PRIx64, exe_ctx.GetThreadPtr(), id);
 535
 536     return id;
 537 }
 538
 539 SBError
 540 SBThread::ResumeNewPlan (ExecutionContext &exe_ctx, ThreadPlan *new_plan)
 541 {
 542     SBError sb_error;
 543
 544     Process *process = exe_ctx.GetProcessPtr();
 545     if (!process)
 546     {
 547         sb_error.SetErrorString("No process in SBThread::ResumeNewPlan");
 548         return sb_error;
 549     }
 550
 551     Thread *thread = exe_ctx.GetThreadPtr();
 552     if (!thread)
 553     {
 554         sb_error.SetErrorString("No thread in SBThread::ResumeNewPlan");
 555         return sb_error;
 556     }
 557
 558     // User level plans should be Master Plans so they can be interrupted, other plans executed, and
 559     // then a "continue" will resume the plan.
 560     if (new_plan != NULL)
 561     {
 562         new_plan->SetIsMasterPlan(true);
 563         new_plan->SetOkayToDiscard(false);
 564     }
 565
 566     // Why do we need to set the current thread by ID here???
 567     process->GetThreadList().SetSelectedThreadByID (thread->GetID());
 568     sb_error.ref() = process->Resume();
 569
 570     if (sb_error.Success())
 571     {
 572         // If we are doing synchronous mode, then wait for the
 573         // process to stop yet again!
 574         if (process->GetTarget().GetDebugger().GetAsyncExecution () == false)
 575             process->WaitForProcessToStop (NULL);
 576     }
 577
 578     return sb_error;
 579 }
 580
 581 void
 582 SBThread::StepOver (lldb::RunMode stop_other_threads)
 583 {
 584     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
 585
 586     Mutex::Locker api_locker;
 587     ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
 588
 589
 590     if (log)
 591         log->Printf ("SBThread(%p)::StepOver (stop_other_threads='%s')", exe_ctx.GetThreadPtr(),
 592                      Thread::RunModeAsCString (stop_other_threads));
 593
 594     if (exe_ctx.HasThreadScope())
 595     {
 596         Thread *thread = exe_ctx.GetThreadPtr();
 597         bool abort_other_plans = false;
 598         StackFrameSP frame_sp(thread->GetStackFrameAtIndex (0));
 599
 600         ThreadPlanSP new_plan_sp;
 601         if (frame_sp)
 602         {
 603             if (frame_sp->HasDebugInformation ())
 604             {
 605                 SymbolContext sc(frame_sp->GetSymbolContext(eSymbolContextEverything));
 606                 new_plan_sp = thread->QueueThreadPlanForStepOverRange (abort_other_plans,
 607                                                                     sc.line_entry.range,
 608                                                                     sc,
 609                                                                     stop_other_threads);
 610             }
 611             else
 612             {
 613                 new_plan_sp = thread->QueueThreadPlanForStepSingleInstruction (true,
 614                                                                             abort_other_plans,
 615                                                                             stop_other_threads);
 616             }
 617         }
 618
 619         // This returns an error, we should use it!
 620         ResumeNewPlan (exe_ctx, new_plan_sp.get());
 621     }
 622 }
 623
 624 void
 625 SBThread::StepInto (lldb::RunMode stop_other_threads)
 626 {
 627     StepInto (NULL, stop_other_threads);
 628 }
 629
 630 void
 631 SBThread::StepInto (const char *target_name, lldb::RunMode stop_other_threads)
 632 {
 633     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
 634
 635     Mutex::Locker api_locker;
 636     ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
 637
 638     if (log)
 639         log->Printf ("SBThread(%p)::StepInto (target_name='%s', stop_other_threads='%s')",
 640                      exe_ctx.GetThreadPtr(),
 641                      target_name? target_name: "<NULL>",
 642                      Thread::RunModeAsCString (stop_other_threads));
 643
 644     if (exe_ctx.HasThreadScope())
 645     {
 646         bool abort_other_plans = false;
 647
 648         Thread *thread = exe_ctx.GetThreadPtr();
 649         StackFrameSP frame_sp(thread->GetStackFrameAtIndex (0));
 650         ThreadPlanSP new_plan_sp;
 651
 652         if (frame_sp && frame_sp->HasDebugInformation ())
 653         {
 654             bool avoid_code_without_debug_info = true;
 655             SymbolContext sc(frame_sp->GetSymbolContext(eSymbolContextEverything));
 656             new_plan_sp = thread->QueueThreadPlanForStepInRange (abort_other_plans,
 657                                                               sc.line_entry.range,
 658                                                               sc,
 659                                                               target_name,
 660                                                               stop_other_threads,
 661                                                               avoid_code_without_debug_info);
 662         }
 663         else
 664         {
 665             new_plan_sp = thread->QueueThreadPlanForStepSingleInstruction (false,
 666                                                                         abort_other_plans,
 667                                                                         stop_other_threads);
 668         }
 669
 670         // This returns an error, we should use it!
 671         ResumeNewPlan (exe_ctx, new_plan_sp.get());
 672     }
 673 }
 674
 675 void
 676 SBThread::StepOut ()
 677 {
 678     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
 679
 680     Mutex::Locker api_locker;
 681     ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
 682
 683
 684     if (log)
 685         log->Printf ("SBThread(%p)::StepOut ()", exe_ctx.GetThreadPtr());
 686
 687     if (exe_ctx.HasThreadScope())
 688     {
 689         bool abort_other_plans = false;
 690         bool stop_other_threads = false;
 691
 692         Thread *thread = exe_ctx.GetThreadPtr();
 693
 694         ThreadPlanSP new_plan_sp(thread->QueueThreadPlanForStepOut (abort_other_plans,
 695                                                                   NULL,
 696                                                                   false,
 697                                                                   stop_other_threads,
 698                                                                   eVoteYes,
 699                                                                   eVoteNoOpinion,
 700                                                                   0));
 701
 702         // This returns an error, we should use it!
 703         ResumeNewPlan (exe_ctx, new_plan_sp.get());
 704     }
 705 }
 706
 707 void
 708 SBThread::StepOutOfFrame (lldb::SBFrame &sb_frame)
 709 {
 710     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
 711
 712     Mutex::Locker api_locker;
 713     ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
 714
 715     StackFrameSP frame_sp (sb_frame.GetFrameSP());
 716     if (log)
 717     {
 718         SBStream frame_desc_strm;
 719         sb_frame.GetDescription (frame_desc_strm);
 720         log->Printf ("SBThread(%p)::StepOutOfFrame (frame = SBFrame(%p): %s)", exe_ctx.GetThreadPtr(), frame_sp.get(), frame_desc_strm.GetData());
 721     }
 722
 723     if (exe_ctx.HasThreadScope())
 724     {
 725         bool abort_other_plans = false;
 726         bool stop_other_threads = false;
 727         Thread *thread = exe_ctx.GetThreadPtr();
 728
 729         ThreadPlanSP new_plan_sp(thread->QueueThreadPlanForStepOut (abort_other_plans,
 730                                                                     NULL,
 731                                                                     false,
 732                                                                     stop_other_threads,
 733                                                                     eVoteYes,
 734                                                                     eVoteNoOpinion,
 735                                                                     frame_sp->GetFrameIndex()));
 736
 737         // This returns an error, we should use it!
 738         ResumeNewPlan (exe_ctx, new_plan_sp.get());
 739     }
 740 }
 741
 742 void
 743 SBThread::StepInstruction (bool step_over)
 744 {
 745     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
 746
 747     Mutex::Locker api_locker;
 748     ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
 749
 750
 751
 752     if (log)
 753         log->Printf ("SBThread(%p)::StepInstruction (step_over=%i)", exe_ctx.GetThreadPtr(), step_over);
 754
 755     if (exe_ctx.HasThreadScope())
 756     {
 757         Thread *thread = exe_ctx.GetThreadPtr();
 758         ThreadPlanSP new_plan_sp(thread->QueueThreadPlanForStepSingleInstruction (step_over, true, true));
 759
 760         // This returns an error, we should use it!
 761         ResumeNewPlan (exe_ctx, new_plan_sp.get());
 762     }
 763 }
 764
 765 void
 766 SBThread::RunToAddress (lldb::addr_t addr)
 767 {
 768     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
 769
 770     Mutex::Locker api_locker;
 771     ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
 772
 773
 774     if (log)
 775         log->Printf ("SBThread(%p)::RunToAddress (addr=0x%" PRIx64 ")", exe_ctx.GetThreadPtr(), addr);
 776
 777     if (exe_ctx.HasThreadScope())
 778     {
 779         bool abort_other_plans = false;
 780         bool stop_other_threads = true;
 781
 782         Address target_addr (addr);
 783
 784         Thread *thread = exe_ctx.GetThreadPtr();
 785
 786         ThreadPlanSP new_plan_sp(thread->QueueThreadPlanForRunToAddress (abort_other_plans, target_addr, stop_other_threads));
 787
 788         // This returns an error, we should use it!
 789         ResumeNewPlan (exe_ctx, new_plan_sp.get());
 790     }
 791 }
 792
 793 SBError
 794 SBThread::StepOverUntil (lldb::SBFrame &sb_frame,
 795                          lldb::SBFileSpec &sb_file_spec,
 796                          uint32_t line)
 797 {
 798     SBError sb_error;
 799     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
 800     char path[PATH_MAX];
 801
 802     Mutex::Locker api_locker;
 803     ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
 804
 805     StackFrameSP frame_sp (sb_frame.GetFrameSP());
 806
 807     if (log)
 808     {
 809         SBStream frame_desc_strm;
 810         sb_frame.GetDescription (frame_desc_strm);
 811         sb_file_spec->GetPath (path, sizeof(path));
 812         log->Printf ("SBThread(%p)::StepOverUntil (frame = SBFrame(%p): %s, file+line = %s:%u)",
 813                      exe_ctx.GetThreadPtr(),
 814                      frame_sp.get(),
 815                      frame_desc_strm.GetData(),
 816                      path, line);
 817     }
 818
 819     if (exe_ctx.HasThreadScope())
 820     {
 821         Target *target = exe_ctx.GetTargetPtr();
 822         Thread *thread = exe_ctx.GetThreadPtr();
 823
 824         if (line == 0)
 825         {
 826             sb_error.SetErrorString("invalid line argument");
 827             return sb_error;
 828         }
 829
 830         if (!frame_sp)
 831         {
 832             frame_sp = thread->GetSelectedFrame ();
 833             if (!frame_sp)
 834                 frame_sp = thread->GetStackFrameAtIndex (0);
 835         }
 836
 837         SymbolContext frame_sc;
 838         if (!frame_sp)
 839         {
 840             sb_error.SetErrorString("no valid frames in thread to step");
 841             return sb_error;
 842         }
 843
 844         // If we have a frame, get its line
 845         frame_sc = frame_sp->GetSymbolContext (eSymbolContextCompUnit  |
 846                                                eSymbolContextFunction  |
 847                                                eSymbolContextLineEntry |
 848                                                eSymbolContextSymbol    );
 849
 850         if (frame_sc.comp_unit == NULL)
 851         {
 852             sb_error.SetErrorStringWithFormat("frame %u doesn't have debug information", frame_sp->GetFrameIndex());
 853             return sb_error;
 854         }
 855
 856         FileSpec step_file_spec;
 857         if (sb_file_spec.IsValid())
 858         {
 859             // The file spec passed in was valid, so use it
 860             step_file_spec = sb_file_spec.ref();
 861         }
 862         else
 863         {
 864             if (frame_sc.line_entry.IsValid())
 865                 step_file_spec = frame_sc.line_entry.file;
 866             else
 867             {
 868                 sb_error.SetErrorString("invalid file argument or no file for frame");
 869                 return sb_error;
 870             }
 871         }
 872
 873         // Grab the current function, then we will make sure the "until" address is
 874         // within the function.  We discard addresses that are out of the current
 875         // function, and then if there are no addresses remaining, give an appropriate
 876         // error message.
 877
 878         bool all_in_function = true;
 879         AddressRange fun_range = frame_sc.function->GetAddressRange();
 880
 881         std::vector<addr_t> step_over_until_addrs;
 882         const bool abort_other_plans = false;
 883         const bool stop_other_threads = false;
 884         const bool check_inlines = true;
 885         const bool exact = false;
 886
 887         SymbolContextList sc_list;
 888         const uint32_t num_matches = frame_sc.comp_unit->ResolveSymbolContext (step_file_spec,
 889                                                                                line,
 890                                                                                check_inlines,
 891                                                                                exact,
 892                                                                                eSymbolContextLineEntry,
 893                                                                                sc_list);
 894         if (num_matches > 0)
 895         {
 896             SymbolContext sc;
 897             for (uint32_t i=0; i<num_matches; ++i)
 898             {
 899                 if (sc_list.GetContextAtIndex(i, sc))
 900                 {
 901                     addr_t step_addr = sc.line_entry.range.GetBaseAddress().GetLoadAddress(target);
 902                     if (step_addr != LLDB_INVALID_ADDRESS)
 903                     {
 904                         if (fun_range.ContainsLoadAddress(step_addr, target))
 905                             step_over_until_addrs.push_back(step_addr);
 906                         else
 907                             all_in_function = false;
 908                     }
 909                 }
 910             }
 911         }
 912
 913         if (step_over_until_addrs.empty())
 914         {
 915             if (all_in_function)
 916             {
 917                 step_file_spec.GetPath (path, sizeof(path));
 918                 sb_error.SetErrorStringWithFormat("No line entries for %s:%u", path, line);
 919             }
 920             else
 921                 sb_error.SetErrorString ("step until target not in current function");
 922         }
 923         else
 924         {
 925             ThreadPlanSP new_plan_sp(thread->QueueThreadPlanForStepUntil (abort_other_plans,
 926                                                                         &step_over_until_addrs[0],
 927                                                                         step_over_until_addrs.size(),
 928                                                                         stop_other_threads,
 929                                                                         frame_sp->GetFrameIndex()));
 930
 931             sb_error = ResumeNewPlan (exe_ctx, new_plan_sp.get());
 932         }
 933     }
 934     else
 935     {
 936         sb_error.SetErrorString("this SBThread object is invalid");
 937     }
 938     return sb_error;
 939 }
 940
 941 SBError
 942 SBThread::JumpToLine (lldb::SBFileSpec &file_spec, uint32_t line)
 943 {
 944     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
 945     SBError sb_error;
 946
 947     Mutex::Locker api_locker;
 948     ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
 949
 950     if (log)
 951         log->Printf ("SBThread(%p)::JumpToLine (file+line = %s:%u)", exe_ctx.GetThreadPtr(), file_spec->GetPath().c_str(), line);
 952
 953     if (!exe_ctx.HasThreadScope())
 954     {
 955         sb_error.SetErrorString("this SBThread object is invalid");
 956         return sb_error;
 957     }
 958
 959     Thread *thread = exe_ctx.GetThreadPtr();
 960
 961     Error err = thread->JumpToLine (file_spec.get(), line, true);
 962     sb_error.SetError (err);
 963     return sb_error;
 964 }
 965
 966 SBError
 967 SBThread::ReturnFromFrame (SBFrame &frame, SBValue &return_value)
 968 {
 969     SBError sb_error;
 970
 971     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
 972
 973     Mutex::Locker api_locker;
 974     ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
 975
 976
 977     if (log)
 978         log->Printf ("SBThread(%p)::ReturnFromFrame (frame=%d)", exe_ctx.GetThreadPtr(), frame.GetFrameID());
 979
 980     if (exe_ctx.HasThreadScope())
 981     {
 982         Thread *thread = exe_ctx.GetThreadPtr();
 983         sb_error.SetError (thread->ReturnFromFrame(frame.GetFrameSP(), return_value.GetSP()));
 984     }
 985
 986     return sb_error;
 987 }
 988
 989
 990 bool
 991 SBThread::Suspend()
 992 {
 993     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
 994     ExecutionContext exe_ctx (m_opaque_sp.get());
 995     bool result = false;
 996     if (exe_ctx.HasThreadScope())
 997     {
 998         Process::StopLocker stop_locker;
 999         if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock()))
1000         {
1001             exe_ctx.GetThreadPtr()->SetResumeState (eStateSuspended);
1002             result = true;
1003         }
1004         else
1005         {
1006             if (log)
1007                 log->Printf ("SBThread(%p)::Suspend() => error: process is running", exe_ctx.GetThreadPtr());
1008         }
1009     }
1010     if (log)
1011         log->Printf ("SBThread(%p)::Suspend() => %i", exe_ctx.GetThreadPtr(), result);
1012     return result;
1013 }
1014
1015 bool
1016 SBThread::Resume ()
1017 {
1018     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1019     ExecutionContext exe_ctx (m_opaque_sp.get());
1020     bool result = false;
1021     if (exe_ctx.HasThreadScope())
1022     {
1023         Process::StopLocker stop_locker;
1024         if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock()))
1025         {
1026             exe_ctx.GetThreadPtr()->SetResumeState (eStateRunning);
1027             result = true;
1028         }
1029         else
1030         {
1031             if (log)
1032                 log->Printf ("SBThread(%p)::Resume() => error: process is running", exe_ctx.GetThreadPtr());
1033         }
1034     }
1035     if (log)
1036         log->Printf ("SBThread(%p)::Resume() => %i", exe_ctx.GetThreadPtr(), result);
1037     return result;
1038 }
1039
1040 bool
1041 SBThread::IsSuspended()
1042 {
1043     ExecutionContext exe_ctx (m_opaque_sp.get());
1044     if (exe_ctx.HasThreadScope())
1045         return exe_ctx.GetThreadPtr()->GetResumeState () == eStateSuspended;
1046     return false;
1047 }
1048
1049 bool
1050 SBThread::IsStopped()
1051 {
1052     ExecutionContext exe_ctx (m_opaque_sp.get());
1053     if (exe_ctx.HasThreadScope())
1054         return StateIsStoppedState(exe_ctx.GetThreadPtr()->GetState(), true);
1055     return false;
1056 }
1057
1058 SBProcess
1059 SBThread::GetProcess ()
1060 {
1061     SBProcess sb_process;
1062     ExecutionContext exe_ctx (m_opaque_sp.get());
1063     if (exe_ctx.HasThreadScope())
1064     {
1065         // Have to go up to the target so we can get a shared pointer to our process...
1066         sb_process.SetSP (exe_ctx.GetProcessSP());
1067     }
1068
1069     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1070     if (log)
1071     {
1072         SBStream frame_desc_strm;
1073         sb_process.GetDescription (frame_desc_strm);
1074         log->Printf ("SBThread(%p)::GetProcess () => SBProcess(%p): %s", exe_ctx.GetThreadPtr(),
1075                      sb_process.GetSP().get(), frame_desc_strm.GetData());
1076     }
1077
1078     return sb_process;
1079 }
1080
1081 uint32_t
1082 SBThread::GetNumFrames ()
1083 {
1084     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1085
1086     uint32_t num_frames = 0;
1087     Mutex::Locker api_locker;
1088     ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
1089
1090     if (exe_ctx.HasThreadScope())
1091     {
1092         Process::StopLocker stop_locker;
1093         if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock()))
1094         {
1095             num_frames = exe_ctx.GetThreadPtr()->GetStackFrameCount();
1096         }
1097         else
1098         {
1099             if (log)
1100                 log->Printf ("SBThread(%p)::GetNumFrames() => error: process is running", exe_ctx.GetThreadPtr());
1101         }
1102     }
1103
1104     if (log)
1105         log->Printf ("SBThread(%p)::GetNumFrames () => %u", exe_ctx.GetThreadPtr(), num_frames);
1106
1107     return num_frames;
1108 }
1109
1110 SBFrame
1111 SBThread::GetFrameAtIndex (uint32_t idx)
1112 {
1113     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1114
1115     SBFrame sb_frame;
1116     StackFrameSP frame_sp;
1117     Mutex::Locker api_locker;
1118     ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
1119
1120     if (exe_ctx.HasThreadScope())
1121     {
1122         Process::StopLocker stop_locker;
1123         if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock()))
1124         {
1125             frame_sp = exe_ctx.GetThreadPtr()->GetStackFrameAtIndex (idx);
1126             sb_frame.SetFrameSP (frame_sp);
1127         }
1128         else
1129         {
1130             if (log)
1131                 log->Printf ("SBThread(%p)::GetFrameAtIndex() => error: process is running", exe_ctx.GetThreadPtr());
1132         }
1133     }
1134
1135     if (log)
1136     {
1137         SBStream frame_desc_strm;
1138         sb_frame.GetDescription (frame_desc_strm);
1139         log->Printf ("SBThread(%p)::GetFrameAtIndex (idx=%d) => SBFrame(%p): %s",
1140                      exe_ctx.GetThreadPtr(), idx, frame_sp.get(), frame_desc_strm.GetData());
1141     }
1142
1143     return sb_frame;
1144 }
1145
1146 lldb::SBFrame
1147 SBThread::GetSelectedFrame ()
1148 {
1149     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1150
1151     SBFrame sb_frame;
1152     StackFrameSP frame_sp;
1153     Mutex::Locker api_locker;
1154     ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
1155
1156     if (exe_ctx.HasThreadScope())
1157     {
1158         Process::StopLocker stop_locker;
1159         if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock()))
1160         {
1161             frame_sp = exe_ctx.GetThreadPtr()->GetSelectedFrame ();
1162             sb_frame.SetFrameSP (frame_sp);
1163         }
1164         else
1165         {
1166             if (log)
1167                 log->Printf ("SBThread(%p)::GetSelectedFrame() => error: process is running", exe_ctx.GetThreadPtr());
1168         }
1169     }
1170
1171     if (log)
1172     {
1173         SBStream frame_desc_strm;
1174         sb_frame.GetDescription (frame_desc_strm);
1175         log->Printf ("SBThread(%p)::GetSelectedFrame () => SBFrame(%p): %s",
1176                      exe_ctx.GetThreadPtr(), frame_sp.get(), frame_desc_strm.GetData());
1177     }
1178
1179     return sb_frame;
1180 }
1181
1182 lldb::SBFrame
1183 SBThread::SetSelectedFrame (uint32_t idx)
1184 {
1185     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1186
1187     SBFrame sb_frame;
1188     StackFrameSP frame_sp;
1189     Mutex::Locker api_locker;
1190     ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
1191
1192     if (exe_ctx.HasThreadScope())
1193     {
1194         Process::StopLocker stop_locker;
1195         if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock()))
1196         {
1197             Thread *thread = exe_ctx.GetThreadPtr();
1198             frame_sp = thread->GetStackFrameAtIndex (idx);
1199             if (frame_sp)
1200             {
1201                 thread->SetSelectedFrame (frame_sp.get());
1202                 sb_frame.SetFrameSP (frame_sp);
1203             }
1204         }
1205         else
1206         {
1207             if (log)
1208                 log->Printf ("SBThread(%p)::SetSelectedFrame() => error: process is running", exe_ctx.GetThreadPtr());
1209         }
1210     }
1211
1212     if (log)
1213     {
1214         SBStream frame_desc_strm;
1215         sb_frame.GetDescription (frame_desc_strm);
1216         log->Printf ("SBThread(%p)::SetSelectedFrame (idx=%u) => SBFrame(%p): %s",
1217                      exe_ctx.GetThreadPtr(), idx, frame_sp.get(), frame_desc_strm.GetData());
1218     }
1219     return sb_frame;
1220 }
1221
1222 bool
1223 SBThread::EventIsThreadEvent (const SBEvent &event)
1224 {
1225     return Thread::ThreadEventData::GetEventDataFromEvent(event.get()) != NULL;
1226 }
1227
1228 SBFrame
1229 SBThread::GetStackFrameFromEvent (const SBEvent &event)
1230 {
1231     return Thread::ThreadEventData::GetStackFrameFromEvent (event.get());
1232
1233 }
1234
1235 SBThread
1236 SBThread::GetThreadFromEvent (const SBEvent &event)
1237 {
1238     return Thread::ThreadEventData::GetThreadFromEvent (event.get());
1239 }
1240
1241 bool
1242 SBThread::operator == (const SBThread &rhs) const
1243 {
1244     return m_opaque_sp->GetThreadSP().get() == rhs.m_opaque_sp->GetThreadSP().get();
1245 }
1246
1247 bool
1248 SBThread::operator != (const SBThread &rhs) const
1249 {
1250     return m_opaque_sp->GetThreadSP().get() != rhs.m_opaque_sp->GetThreadSP().get();
1251 }
1252
1253 bool
1254 SBThread::GetStatus (SBStream &status) const
1255 {
1256     Stream &strm = status.ref();
1257
1258     ExecutionContext exe_ctx (m_opaque_sp.get());
1259     if (exe_ctx.HasThreadScope())
1260     {
1261         exe_ctx.GetThreadPtr()->GetStatus(strm, 0, 1, 1);
1262     }
1263     else
1264         strm.PutCString ("No status");
1265
1266     return true;
1267 }
1268
1269 bool
1270 SBThread::GetDescription (SBStream &description) const
1271 {
1272     Stream &strm = description.ref();
1273
1274     ExecutionContext exe_ctx (m_opaque_sp.get());
1275     if (exe_ctx.HasThreadScope())
1276     {
1277         strm.Printf("SBThread: tid = 0x%4.4" PRIx64, exe_ctx.GetThreadPtr()->GetID());
1278     }
1279     else
1280         strm.PutCString ("No value");
1281
1282     return true;
1283 }
1284
1285 SBThread
1286 SBThread::GetExtendedBacktrace (const char *type)
1287 {
1288     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1289     Mutex::Locker api_locker;
1290     ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
1291     SBThread sb_origin_thread;
1292
1293     if (exe_ctx.HasThreadScope())
1294     {
1295         Process::StopLocker stop_locker;
1296         if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock()))
1297         {
1298             ThreadSP real_thread(exe_ctx.GetThreadPtr());
1299             if (real_thread)
1300             {
1301                 ConstString type_const (type);
1302                 SystemRuntime *runtime = exe_ctx.GetProcessPtr()->GetSystemRuntime();
1303                 if (runtime)
1304                 {
1305                     ThreadSP origin_thread = runtime->GetExtendedBacktrace (real_thread, type_const);
1306                     sb_origin_thread.SetThread (origin_thread);
1307                 }
1308             }
1309         }
1310         else
1311         {
1312             if (log)
1313                 log->Printf ("SBThread(%p)::GetExtendedBacktrace() => error: process is running", exe_ctx.GetThreadPtr());
1314         }
1315     }
1316
1317     return sb_origin_thread;
1318 }