contrib/llvm/tools/lldb/source/Target/ExecutionContext.cpp

   1 //===-- ExecutionContext.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/Target/ExecutionContext.h"
  11
  12 #include "lldb/Core/State.h"
  13 #include "lldb/Target/ExecutionContextScope.h"
  14 #include "lldb/Target/StackFrame.h"
  15 #include "lldb/Target/Process.h"
  16 #include "lldb/Target/Target.h"
  17 #include "lldb/Target/Thread.h"
  18
  19 using namespace lldb_private;
  20
  21 ExecutionContext::ExecutionContext() :
  22     m_target_sp (),
  23     m_process_sp (),
  24     m_thread_sp (),
  25     m_frame_sp ()
  26 {
  27 }
  28
  29 ExecutionContext::ExecutionContext (const ExecutionContext &rhs) :
  30     m_target_sp(rhs.m_target_sp),
  31     m_process_sp(rhs.m_process_sp),
  32     m_thread_sp(rhs.m_thread_sp),
  33     m_frame_sp(rhs.m_frame_sp)
  34 {
  35 }
  36
  37 ExecutionContext::ExecutionContext (const lldb::TargetSP &target_sp, bool get_process) :
  38     m_target_sp (),
  39     m_process_sp (),
  40     m_thread_sp (),
  41     m_frame_sp ()
  42 {
  43     if (target_sp)
  44         SetContext (target_sp, get_process);
  45 }
  46
  47 ExecutionContext::ExecutionContext (const lldb::ProcessSP &process_sp) :
  48     m_target_sp (),
  49     m_process_sp (),
  50     m_thread_sp (),
  51     m_frame_sp ()
  52 {
  53     if (process_sp)
  54         SetContext (process_sp);
  55 }
  56
  57 ExecutionContext::ExecutionContext (const lldb::ThreadSP &thread_sp) :
  58     m_target_sp (),
  59     m_process_sp (),
  60     m_thread_sp (),
  61     m_frame_sp ()
  62 {
  63     if (thread_sp)
  64         SetContext (thread_sp);
  65 }
  66
  67 ExecutionContext::ExecutionContext (const lldb::StackFrameSP &frame_sp) :
  68     m_target_sp (),
  69     m_process_sp (),
  70     m_thread_sp (),
  71     m_frame_sp ()
  72 {
  73     if (frame_sp)
  74         SetContext (frame_sp);
  75 }
  76
  77 ExecutionContext::ExecutionContext (const lldb::TargetWP &target_wp, bool get_process) :
  78     m_target_sp (),
  79     m_process_sp (),
  80     m_thread_sp (),
  81     m_frame_sp ()
  82 {
  83     lldb::TargetSP target_sp(target_wp.lock());
  84     if (target_sp)
  85         SetContext (target_sp, get_process);
  86 }
  87
  88 ExecutionContext::ExecutionContext (const lldb::ProcessWP &process_wp) :
  89     m_target_sp (),
  90     m_process_sp (),
  91     m_thread_sp (),
  92     m_frame_sp ()
  93 {
  94     lldb::ProcessSP process_sp(process_wp.lock());
  95     if (process_sp)
  96         SetContext (process_sp);
  97 }
  98
  99 ExecutionContext::ExecutionContext (const lldb::ThreadWP &thread_wp) :
 100     m_target_sp (),
 101     m_process_sp (),
 102     m_thread_sp (),
 103     m_frame_sp ()
 104 {
 105     lldb::ThreadSP thread_sp(thread_wp.lock());
 106     if (thread_sp)
 107         SetContext (thread_sp);
 108 }
 109
 110 ExecutionContext::ExecutionContext (const lldb::StackFrameWP &frame_wp) :
 111     m_target_sp (),
 112     m_process_sp (),
 113     m_thread_sp (),
 114     m_frame_sp ()
 115 {
 116     lldb::StackFrameSP frame_sp(frame_wp.lock());
 117     if (frame_sp)
 118         SetContext (frame_sp);
 119 }
 120
 121 ExecutionContext::ExecutionContext (Target* t, bool fill_current_process_thread_frame) :
 122     m_target_sp (t->shared_from_this()),
 123     m_process_sp (),
 124     m_thread_sp (),
 125     m_frame_sp ()
 126 {
 127     if (t && fill_current_process_thread_frame)
 128     {
 129         m_process_sp = t->GetProcessSP();
 130         if (m_process_sp)
 131         {
 132             m_thread_sp = m_process_sp->GetThreadList().GetSelectedThread();
 133             if (m_thread_sp)
 134                 m_frame_sp = m_thread_sp->GetSelectedFrame();
 135         }
 136     }
 137 }
 138
 139 ExecutionContext::ExecutionContext(Process* process, Thread *thread, StackFrame *frame) :
 140     m_target_sp (),
 141     m_process_sp (process->shared_from_this()),
 142     m_thread_sp (thread->shared_from_this()),
 143     m_frame_sp (frame->shared_from_this())
 144 {
 145     if (process)
 146         m_target_sp = process->GetTarget().shared_from_this();
 147 }
 148
 149 ExecutionContext::ExecutionContext (const ExecutionContextRef &exe_ctx_ref) :
 150     m_target_sp (exe_ctx_ref.GetTargetSP()),
 151     m_process_sp (exe_ctx_ref.GetProcessSP()),
 152     m_thread_sp (exe_ctx_ref.GetThreadSP()),
 153     m_frame_sp (exe_ctx_ref.GetFrameSP())
 154 {
 155 }
 156
 157 ExecutionContext::ExecutionContext (const ExecutionContextRef *exe_ctx_ref_ptr, bool thread_and_frame_only_if_stopped) :
 158     m_target_sp (),
 159     m_process_sp (),
 160     m_thread_sp (),
 161     m_frame_sp ()
 162 {
 163     if (exe_ctx_ref_ptr)
 164     {
 165         m_target_sp  = exe_ctx_ref_ptr->GetTargetSP();
 166         m_process_sp = exe_ctx_ref_ptr->GetProcessSP();
 167         if (!thread_and_frame_only_if_stopped || (m_process_sp && StateIsStoppedState(m_process_sp->GetState(), true)))
 168         {
 169             m_thread_sp = exe_ctx_ref_ptr->GetThreadSP();
 170             m_frame_sp = exe_ctx_ref_ptr->GetFrameSP();
 171         }
 172     }
 173 }
 174
 175 ExecutionContext::ExecutionContext (const ExecutionContextRef *exe_ctx_ref_ptr, Mutex::Locker &locker) :
 176     m_target_sp (),
 177     m_process_sp (),
 178     m_thread_sp (),
 179     m_frame_sp ()
 180 {
 181     if (exe_ctx_ref_ptr)
 182     {
 183         m_target_sp  = exe_ctx_ref_ptr->GetTargetSP();
 184         if (m_target_sp)
 185         {
 186             locker.Lock(m_target_sp->GetAPIMutex());
 187             m_process_sp = exe_ctx_ref_ptr->GetProcessSP();
 188             m_thread_sp = exe_ctx_ref_ptr->GetThreadSP();
 189             m_frame_sp = exe_ctx_ref_ptr->GetFrameSP();
 190         }
 191     }
 192 }
 193
 194 ExecutionContext::ExecutionContext (const ExecutionContextRef &exe_ctx_ref, Mutex::Locker &locker) :
 195     m_target_sp (exe_ctx_ref.GetTargetSP()),
 196     m_process_sp (),
 197     m_thread_sp (),
 198     m_frame_sp ()
 199 {
 200     if (m_target_sp)
 201     {
 202         locker.Lock(m_target_sp->GetAPIMutex());
 203         m_process_sp = exe_ctx_ref.GetProcessSP();
 204         m_thread_sp  = exe_ctx_ref.GetThreadSP();
 205         m_frame_sp   = exe_ctx_ref.GetFrameSP();
 206     }
 207 }
 208
 209 ExecutionContext::ExecutionContext (ExecutionContextScope *exe_scope_ptr) :
 210     m_target_sp (),
 211     m_process_sp (),
 212     m_thread_sp (),
 213     m_frame_sp ()
 214 {
 215     if (exe_scope_ptr)
 216         exe_scope_ptr->CalculateExecutionContext (*this);
 217 }
 218
 219 ExecutionContext::ExecutionContext (ExecutionContextScope &exe_scope_ref)
 220 {
 221     exe_scope_ref.CalculateExecutionContext (*this);
 222 }
 223
 224 void
 225 ExecutionContext::Clear()
 226 {
 227     m_target_sp.reset();
 228     m_process_sp.reset();
 229     m_thread_sp.reset();
 230     m_frame_sp.reset();
 231 }
 232
 233 ExecutionContext::~ExecutionContext()
 234 {
 235 }
 236
 237 uint32_t
 238 ExecutionContext::GetAddressByteSize() const
 239 {
 240     if (m_target_sp && m_target_sp->GetArchitecture().IsValid())
 241         m_target_sp->GetArchitecture().GetAddressByteSize();
 242     if (m_process_sp)
 243         m_process_sp->GetAddressByteSize();
 244     return sizeof(void *);
 245 }
 246
 247 lldb::ByteOrder
 248 ExecutionContext::GetByteOrder() const
 249 {
 250     if (m_target_sp && m_target_sp->GetArchitecture().IsValid())
 251         m_target_sp->GetArchitecture().GetByteOrder();
 252     if (m_process_sp)
 253         m_process_sp->GetByteOrder();
 254     return lldb::endian::InlHostByteOrder();
 255 }
 256
 257 RegisterContext *
 258 ExecutionContext::GetRegisterContext () const
 259 {
 260     if (m_frame_sp)
 261         return m_frame_sp->GetRegisterContext().get();
 262     else if (m_thread_sp)
 263         return m_thread_sp->GetRegisterContext().get();
 264     return NULL;
 265 }
 266
 267 Target *
 268 ExecutionContext::GetTargetPtr () const
 269 {
 270     if (m_target_sp)
 271         return m_target_sp.get();
 272     if (m_process_sp)
 273         return &m_process_sp->GetTarget();
 274     return NULL;
 275 }
 276
 277 Process *
 278 ExecutionContext::GetProcessPtr () const
 279 {
 280     if (m_process_sp)
 281         return m_process_sp.get();
 282     if (m_target_sp)
 283         return m_target_sp->GetProcessSP().get();
 284     return NULL;
 285 }
 286
 287 ExecutionContextScope *
 288 ExecutionContext::GetBestExecutionContextScope () const
 289 {
 290     if (m_frame_sp)
 291         return m_frame_sp.get();
 292     if (m_thread_sp)
 293         return m_thread_sp.get();
 294     if (m_process_sp)
 295         return m_process_sp.get();
 296     return m_target_sp.get();
 297 }
 298
 299 Target &
 300 ExecutionContext::GetTargetRef () const
 301 {
 302 #if defined (LLDB_CONFIGURATION_DEBUG) || defined (LLDB_CONFIGURATION_RELEASE)
 303     assert (m_target_sp.get());
 304 #endif
 305     return *m_target_sp;
 306 }
 307
 308 Process &
 309 ExecutionContext::GetProcessRef () const
 310 {
 311 #if defined (LLDB_CONFIGURATION_DEBUG) || defined (LLDB_CONFIGURATION_RELEASE)
 312     assert (m_process_sp.get());
 313 #endif
 314     return *m_process_sp;
 315 }
 316
 317 Thread &
 318 ExecutionContext::GetThreadRef () const
 319 {
 320 #if defined (LLDB_CONFIGURATION_DEBUG) || defined (LLDB_CONFIGURATION_RELEASE)
 321     assert (m_thread_sp.get());
 322 #endif
 323     return *m_thread_sp;
 324 }
 325
 326 StackFrame &
 327 ExecutionContext::GetFrameRef () const
 328 {
 329 #if defined (LLDB_CONFIGURATION_DEBUG) || defined (LLDB_CONFIGURATION_RELEASE)
 330     assert (m_frame_sp.get());
 331 #endif
 332     return *m_frame_sp;
 333 }
 334
 335 void
 336 ExecutionContext::SetTargetSP (const lldb::TargetSP &target_sp)
 337 {
 338     m_target_sp = target_sp;
 339 }
 340
 341 void
 342 ExecutionContext::SetProcessSP (const lldb::ProcessSP &process_sp)
 343 {
 344     m_process_sp = process_sp;
 345 }
 346
 347 void
 348 ExecutionContext::SetThreadSP (const lldb::ThreadSP &thread_sp)
 349 {
 350     m_thread_sp = thread_sp;
 351 }
 352
 353 void
 354 ExecutionContext::SetFrameSP (const lldb::StackFrameSP &frame_sp)
 355 {
 356     m_frame_sp = frame_sp;
 357 }
 358
 359 void
 360 ExecutionContext::SetTargetPtr (Target* target)
 361 {
 362     if (target)
 363         m_target_sp = target->shared_from_this();
 364     else
 365         m_target_sp.reset();
 366 }
 367
 368 void
 369 ExecutionContext::SetProcessPtr (Process *process)
 370 {
 371     if (process)
 372         m_process_sp = process->shared_from_this();
 373     else
 374         m_process_sp.reset();
 375 }
 376
 377 void
 378 ExecutionContext::SetThreadPtr (Thread *thread)
 379 {
 380     if (thread)
 381         m_thread_sp = thread->shared_from_this();
 382     else
 383         m_thread_sp.reset();
 384 }
 385
 386 void
 387 ExecutionContext::SetFramePtr (StackFrame *frame)
 388 {
 389     if (frame)
 390         m_frame_sp = frame->shared_from_this();
 391     else
 392         m_frame_sp.reset();
 393 }
 394
 395 void
 396 ExecutionContext::SetContext (const lldb::TargetSP &target_sp, bool get_process)
 397 {
 398     m_target_sp = target_sp;
 399     if (get_process && target_sp)
 400         m_process_sp = target_sp->GetProcessSP();
 401     else
 402         m_process_sp.reset();
 403     m_thread_sp.reset();
 404     m_frame_sp.reset();
 405 }
 406
 407 void
 408 ExecutionContext::SetContext (const lldb::ProcessSP &process_sp)
 409 {
 410     m_process_sp = process_sp;
 411     if (process_sp)
 412         m_target_sp = process_sp->GetTarget().shared_from_this();
 413     else
 414         m_target_sp.reset();
 415     m_thread_sp.reset();
 416     m_frame_sp.reset();
 417 }
 418
 419 void
 420 ExecutionContext::SetContext (const lldb::ThreadSP &thread_sp)
 421 {
 422     m_frame_sp.reset();
 423     m_thread_sp = thread_sp;
 424     if (thread_sp)
 425     {
 426         m_process_sp = thread_sp->GetProcess();
 427         if (m_process_sp)
 428             m_target_sp = m_process_sp->GetTarget().shared_from_this();
 429         else
 430             m_target_sp.reset();
 431     }
 432     else
 433     {
 434         m_target_sp.reset();
 435         m_process_sp.reset();
 436     }
 437 }
 438
 439 void
 440 ExecutionContext::SetContext (const lldb::StackFrameSP &frame_sp)
 441 {
 442     m_frame_sp = frame_sp;
 443     if (frame_sp)
 444     {
 445         m_thread_sp = frame_sp->CalculateThread();
 446         if (m_thread_sp)
 447         {
 448             m_process_sp = m_thread_sp->GetProcess();
 449             if (m_process_sp)
 450                 m_target_sp = m_process_sp->GetTarget().shared_from_this();
 451             else
 452                 m_target_sp.reset();
 453         }
 454         else
 455         {
 456             m_target_sp.reset();
 457             m_process_sp.reset();
 458         }
 459     }
 460     else
 461     {
 462         m_target_sp.reset();
 463         m_process_sp.reset();
 464         m_thread_sp.reset();
 465     }
 466 }
 467
 468 ExecutionContext &
 469 ExecutionContext::operator =(const ExecutionContext &rhs)
 470 {
 471     if (this != &rhs)
 472     {
 473         m_target_sp  = rhs.m_target_sp;
 474         m_process_sp = rhs.m_process_sp;
 475         m_thread_sp  = rhs.m_thread_sp;
 476         m_frame_sp   = rhs.m_frame_sp;
 477     }
 478     return *this;
 479 }
 480
 481 bool
 482 ExecutionContext::operator ==(const ExecutionContext &rhs) const
 483 {
 484     // Check that the frame shared pointers match, or both are valid and their stack
 485     // IDs match since sometimes we get new objects that represent the same
 486     // frame within a thread.
 487     if ((m_frame_sp == rhs.m_frame_sp) || (m_frame_sp && rhs.m_frame_sp && m_frame_sp->GetStackID() == rhs.m_frame_sp->GetStackID()))
 488     {
 489         // Check that the thread shared pointers match, or both are valid and
 490         // their thread IDs match since sometimes we get new objects that
 491         // represent the same thread within a process.
 492         if ((m_thread_sp == rhs.m_thread_sp) || (m_thread_sp && rhs.m_thread_sp && m_thread_sp->GetID() == rhs.m_thread_sp->GetID()))
 493         {
 494             // Processes and targets don't change much
 495             return m_process_sp == rhs.m_process_sp && m_target_sp == rhs.m_target_sp;
 496         }
 497     }
 498     return false;
 499 }
 500
 501 bool
 502 ExecutionContext::operator !=(const ExecutionContext &rhs) const
 503 {
 504     return !(*this == rhs);
 505 }
 506
 507 bool
 508 ExecutionContext::HasTargetScope () const
 509 {
 510     return ((bool) m_target_sp
 511             && m_target_sp->IsValid());
 512 }
 513
 514 bool
 515 ExecutionContext::HasProcessScope () const
 516 {
 517     return (HasTargetScope()
 518             && ((bool) m_process_sp && m_process_sp->IsValid()));
 519 }
 520
 521 bool
 522 ExecutionContext::HasThreadScope () const
 523 {
 524     return (HasProcessScope()
 525            && ((bool) m_thread_sp && m_thread_sp->IsValid()));
 526 }
 527
 528 bool
 529 ExecutionContext::HasFrameScope () const
 530 {
 531     return HasThreadScope() && m_frame_sp;
 532 }
 533
 534 ExecutionContextRef::ExecutionContextRef() :
 535     m_target_wp (),
 536     m_process_wp (),
 537     m_thread_wp (),
 538     m_tid(LLDB_INVALID_THREAD_ID),
 539     m_stack_id ()
 540 {
 541 }
 542
 543 ExecutionContextRef::ExecutionContextRef (const ExecutionContext *exe_ctx) :
 544     m_target_wp (),
 545     m_process_wp (),
 546     m_thread_wp (),
 547     m_tid(LLDB_INVALID_THREAD_ID),
 548     m_stack_id ()
 549 {
 550     if (exe_ctx)
 551         *this = *exe_ctx;
 552 }
 553
 554 ExecutionContextRef::ExecutionContextRef (const ExecutionContext &exe_ctx) :
 555     m_target_wp (),
 556     m_process_wp (),
 557     m_thread_wp (),
 558     m_tid(LLDB_INVALID_THREAD_ID),
 559     m_stack_id ()
 560 {
 561     *this = exe_ctx;
 562 }
 563
 564
 565 ExecutionContextRef::ExecutionContextRef (Target *target, bool adopt_selected) :
 566     m_target_wp(),
 567     m_process_wp(),
 568     m_thread_wp(),
 569     m_tid(LLDB_INVALID_THREAD_ID),
 570     m_stack_id ()
 571 {
 572     SetTargetPtr (target, adopt_selected);
 573 }
 574
 575
 576
 577
 578 ExecutionContextRef::ExecutionContextRef (const ExecutionContextRef &rhs) :
 579     m_target_wp (rhs.m_target_wp),
 580     m_process_wp(rhs.m_process_wp),
 581     m_thread_wp (rhs.m_thread_wp),
 582     m_tid       (rhs.m_tid),
 583     m_stack_id  (rhs.m_stack_id)
 584 {
 585 }
 586
 587 ExecutionContextRef &
 588 ExecutionContextRef::operator =(const ExecutionContextRef &rhs)
 589 {
 590     if (this != &rhs)
 591     {
 592         m_target_wp  = rhs.m_target_wp;
 593         m_process_wp = rhs.m_process_wp;
 594         m_thread_wp  = rhs.m_thread_wp;
 595         m_tid        = rhs.m_tid;
 596         m_stack_id   = rhs.m_stack_id;
 597     }
 598     return *this;
 599 }
 600
 601 ExecutionContextRef &
 602 ExecutionContextRef::operator =(const ExecutionContext &exe_ctx)
 603 {
 604     m_target_wp = exe_ctx.GetTargetSP();
 605     m_process_wp = exe_ctx.GetProcessSP();
 606     lldb::ThreadSP thread_sp (exe_ctx.GetThreadSP());
 607     m_thread_wp = thread_sp;
 608     if (thread_sp)
 609         m_tid = thread_sp->GetID();
 610     else
 611         m_tid = LLDB_INVALID_THREAD_ID;
 612     lldb::StackFrameSP frame_sp (exe_ctx.GetFrameSP());
 613     if (frame_sp)
 614         m_stack_id = frame_sp->GetStackID();
 615     else
 616         m_stack_id.Clear();
 617     return *this;
 618 }
 619
 620 void
 621 ExecutionContextRef::Clear()
 622 {
 623     m_target_wp.reset();
 624     m_process_wp.reset();
 625     ClearThread();
 626     ClearFrame();
 627 }
 628
 629 ExecutionContextRef::~ExecutionContextRef()
 630 {
 631 }
 632
 633 void
 634 ExecutionContextRef::SetTargetSP (const lldb::TargetSP &target_sp)
 635 {
 636     m_target_wp = target_sp;
 637 }
 638
 639 void
 640 ExecutionContextRef::SetProcessSP (const lldb::ProcessSP &process_sp)
 641 {
 642     if (process_sp)
 643     {
 644         m_process_wp = process_sp;
 645         SetTargetSP (process_sp->GetTarget().shared_from_this());
 646     }
 647     else
 648     {
 649         m_process_wp.reset();
 650         m_target_wp.reset();
 651     }
 652 }
 653
 654 void
 655 ExecutionContextRef::SetThreadSP (const lldb::ThreadSP &thread_sp)
 656 {
 657     if (thread_sp)
 658     {
 659         m_thread_wp = thread_sp;
 660         m_tid = thread_sp->GetID();
 661         SetProcessSP (thread_sp->GetProcess());
 662     }
 663     else
 664     {
 665         ClearThread();
 666         m_process_wp.reset();
 667         m_target_wp.reset();
 668     }
 669 }
 670
 671 void
 672 ExecutionContextRef::SetFrameSP (const lldb::StackFrameSP &frame_sp)
 673 {
 674     if (frame_sp)
 675     {
 676         m_stack_id = frame_sp->GetStackID();
 677         SetThreadSP (frame_sp->GetThread());
 678     }
 679     else
 680     {
 681         ClearFrame();
 682         ClearThread();
 683         m_process_wp.reset();
 684         m_target_wp.reset();
 685     }
 686
 687 }
 688
 689 void
 690 ExecutionContextRef::SetTargetPtr (Target* target, bool adopt_selected)
 691 {
 692     Clear();
 693     if (target)
 694     {
 695         lldb::TargetSP target_sp (target->shared_from_this());
 696         if (target_sp)
 697         {
 698             m_target_wp = target_sp;
 699             if (adopt_selected)
 700             {
 701                 lldb::ProcessSP process_sp (target_sp->GetProcessSP());
 702                 if (process_sp)
 703                 {
 704                     m_process_wp = process_sp;
 705                     if (process_sp)
 706                     {
 707                         // Only fill in the thread and frame if our process is stopped
 708                         if (StateIsStoppedState (process_sp->GetState(), true))
 709                         {
 710                             lldb::ThreadSP thread_sp (process_sp->GetThreadList().GetSelectedThread());
 711                             if (!thread_sp)
 712                                 thread_sp = process_sp->GetThreadList().GetThreadAtIndex(0);
 713
 714                             if (thread_sp)
 715                             {
 716                                 SetThreadSP (thread_sp);
 717                                 lldb::StackFrameSP frame_sp (thread_sp->GetSelectedFrame());
 718                                 if (!frame_sp)
 719                                     frame_sp = thread_sp->GetStackFrameAtIndex(0);
 720                                 if (frame_sp)
 721                                     SetFrameSP (frame_sp);
 722                             }
 723                         }
 724                     }
 725                 }
 726             }
 727         }
 728     }
 729 }
 730
 731 void
 732 ExecutionContextRef::SetProcessPtr (Process *process)
 733 {
 734     if (process)
 735     {
 736         SetProcessSP(process->shared_from_this());
 737     }
 738     else
 739     {
 740         m_process_wp.reset();
 741         m_target_wp.reset();
 742     }
 743 }
 744
 745 void
 746 ExecutionContextRef::SetThreadPtr (Thread *thread)
 747 {
 748     if (thread)
 749     {
 750         SetThreadSP (thread->shared_from_this());
 751     }
 752     else
 753     {
 754         ClearThread();
 755         m_process_wp.reset();
 756         m_target_wp.reset();
 757     }
 758 }
 759
 760 void
 761 ExecutionContextRef::SetFramePtr (StackFrame *frame)
 762 {
 763     if (frame)
 764         SetFrameSP (frame->shared_from_this());
 765     else
 766         Clear();
 767 }
 768
 769 lldb::TargetSP
 770 ExecutionContextRef::GetTargetSP () const
 771 {
 772     lldb::TargetSP target_sp(m_target_wp.lock());
 773     if (target_sp && !target_sp->IsValid())
 774         target_sp.reset();
 775     return target_sp;
 776 }
 777
 778 lldb::ProcessSP
 779 ExecutionContextRef::GetProcessSP () const
 780 {
 781     lldb::ProcessSP process_sp(m_process_wp.lock());
 782     if (process_sp && !process_sp->IsValid())
 783         process_sp.reset();
 784     return process_sp;
 785 }
 786
 787 lldb::ThreadSP
 788 ExecutionContextRef::GetThreadSP () const
 789 {
 790     lldb::ThreadSP thread_sp (m_thread_wp.lock());
 791
 792     if (m_tid != LLDB_INVALID_THREAD_ID)
 793     {
 794         // We check if the thread has been destroyed in cases where clients
 795         // might still have shared pointer to a thread, but the thread is
 796         // not valid anymore (not part of the process)
 797         if (!thread_sp || !thread_sp->IsValid())
 798         {
 799             lldb::ProcessSP process_sp(GetProcessSP());
 800             if (process_sp && process_sp->IsValid())
 801             {
 802                 thread_sp = process_sp->GetThreadList().FindThreadByID(m_tid);
 803                 m_thread_wp = thread_sp;
 804             }
 805         }
 806     }
 807
 808     // Check that we aren't about to return an invalid thread sp.  We might return a NULL thread_sp,
 809     // but don't return an invalid one.
 810
 811     if (thread_sp && !thread_sp->IsValid())
 812         thread_sp.reset();
 813
 814     return thread_sp;
 815 }
 816
 817 lldb::StackFrameSP
 818 ExecutionContextRef::GetFrameSP () const
 819 {
 820     if (m_stack_id.IsValid())
 821     {
 822         lldb::ThreadSP thread_sp (GetThreadSP());
 823         if (thread_sp)
 824             return thread_sp->GetFrameWithStackID (m_stack_id);
 825     }
 826     return lldb::StackFrameSP();
 827 }
 828
 829 ExecutionContext
 830 ExecutionContextRef::Lock (bool thread_and_frame_only_if_stopped) const
 831 {
 832     return ExecutionContext(this, thread_and_frame_only_if_stopped);
 833 }
 834
 835