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