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