1 //===-- ExecutionContext.h --------------------------------------*- 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 #ifndef liblldb_ExecutionContext_h_ 11 #define liblldb_ExecutionContext_h_ 12 13 #include <mutex> 14 15 #include "lldb/Target/StackID.h" 16 #include "lldb/lldb-private.h" 17 18 namespace lldb_private { 19 20 //===----------------------------------------------------------------------===// 21 /// Execution context objects refer to objects in the execution of the program 22 /// that is being debugged. The consist of one or more of the following 23 /// objects: target, process, thread, and frame. Many objects in the debugger 24 /// need to track different executions contexts. For example, a local function 25 /// variable might have an execution context that refers to a stack frame. A 26 /// global or static variable might refer to a target since a stack frame 27 /// isn't required in order to evaluate a global or static variable (a process 28 /// isn't necessarily needed for a global variable since we might be able to 29 /// read the variable value from a data section in one of the object files in 30 /// a target). There are two types of objects that hold onto execution 31 /// contexts: ExecutionContextRef and ExecutionContext. Both of these objects 32 /// are described below. 33 /// 34 /// Not all objects in an ExecutionContext objects will be valid. If you want 35 /// to refer strongly (ExecutionContext) or weakly (ExecutionContextRef) to a 36 /// process, then only the process and target references will be valid. For 37 /// threads, only the thread, process and target references will be filled in. 38 /// For frames, all of the objects will be filled in. 39 /// 40 /// These classes are designed to be used as baton objects that get passed to 41 /// a wide variety of functions that require execution contexts. 42 //===----------------------------------------------------------------------===// 43 44 //---------------------------------------------------------------------- 45 /// @class ExecutionContextRef ExecutionContext.h 46 /// "lldb/Target/ExecutionContext.h" 47 /// A class that holds a weak reference to an execution context. 48 /// 49 /// ExecutionContextRef objects are designed to hold onto an execution context 50 /// that might change over time. For example, if an object wants to refer to a 51 /// stack frame, it should hold onto an ExecutionContextRef to a frame object. 52 /// The backing object that represents the stack frame might change over time 53 /// and instances of this object can track the logical object that refers to a 54 /// frame even if it does change. 55 /// 56 /// These objects also don't keep execution objects around longer than they 57 /// should since they use weak pointers. For example if an object refers to a 58 /// stack frame and a stack frame is no longer in a thread, then a 59 /// ExecutionContextRef object that refers to that frame will not be able to 60 /// get a shared pointer to those objects since they are no longer around. 61 /// 62 /// ExecutionContextRef objects can also be used as objects in classes that 63 /// want to track a "previous execution context". Since the weak references to 64 /// the execution objects (target, process, thread and frame) don't keep these 65 /// objects around, they are safe to keep around. 66 /// 67 /// The general rule of thumb is all long lived objects that want to refer to 68 /// execution contexts should use ExecutionContextRef objects. The 69 /// ExecutionContext class is used to temporarily get shared pointers to any 70 /// execution context objects that are still around so they are guaranteed to 71 /// exist during a function that requires the objects. ExecutionContext 72 /// objects should NOT be used for long term storage since they will keep 73 /// objects alive with extra shared pointer references to these objects. 74 //---------------------------------------------------------------------- 75 class ExecutionContextRef { 76 public: 77 //------------------------------------------------------------------ 78 /// Default Constructor. 79 //------------------------------------------------------------------ 80 ExecutionContextRef(); 81 82 //------------------------------------------------------------------ 83 /// Copy Constructor. 84 //------------------------------------------------------------------ 85 ExecutionContextRef(const ExecutionContextRef &rhs); 86 87 //------------------------------------------------------------------ 88 /// Construct using an ExecutionContext object that might be nullptr. 89 /// 90 /// If \a exe_ctx_ptr is valid, then make weak references to any valid 91 /// objects in the ExecutionContext, otherwise no weak references to any 92 /// execution context objects will be made. 93 //------------------------------------------------------------------ 94 ExecutionContextRef(const ExecutionContext *exe_ctx_ptr); 95 96 //------------------------------------------------------------------ 97 /// Construct using an ExecutionContext object. 98 /// 99 /// Make weak references to any valid objects in the ExecutionContext. 100 //------------------------------------------------------------------ 101 ExecutionContextRef(const ExecutionContext &exe_ctx); 102 103 //------------------------------------------------------------------ 104 /// Construct using the target and all the selected items inside of it (the 105 /// process and its selected thread, and the thread's selected frame). If 106 /// there is no selected thread, default to the first thread If there is no 107 /// selected frame, default to the first frame. 108 //------------------------------------------------------------------ 109 ExecutionContextRef(Target *target, bool adopt_selected); 110 111 //------------------------------------------------------------------ 112 /// Construct using an execution context scope. 113 /// 114 /// If the ExecutionContextScope object is valid and refers to a frame, make 115 /// weak references too the frame, thread, process and target. If the 116 /// ExecutionContextScope object is valid and refers to a thread, make weak 117 /// references too the thread, process and target. If the 118 /// ExecutionContextScope object is valid and refers to a process, make weak 119 /// references too the process and target. If the ExecutionContextScope 120 /// object is valid and refers to a target, make weak references too the 121 /// target. 122 //------------------------------------------------------------------ 123 ExecutionContextRef(ExecutionContextScope *exe_scope); 124 125 //------------------------------------------------------------------ 126 /// Construct using an execution context scope. 127 /// 128 /// If the ExecutionContextScope object refers to a frame, make weak 129 /// references too the frame, thread, process and target. If the 130 /// ExecutionContextScope object refers to a thread, make weak references 131 /// too the thread, process and target. If the ExecutionContextScope object 132 /// refers to a process, make weak references too the process and target. If 133 /// the ExecutionContextScope object refers to a target, make weak 134 /// references too the target. 135 //------------------------------------------------------------------ 136 ExecutionContextRef(ExecutionContextScope &exe_scope); 137 138 ~ExecutionContextRef(); 139 140 //------------------------------------------------------------------ 141 /// Assignment operator 142 /// 143 /// Copy all weak references in \a rhs. 144 //------------------------------------------------------------------ 145 ExecutionContextRef &operator=(const ExecutionContextRef &rhs); 146 147 //------------------------------------------------------------------ 148 /// Assignment operator from a ExecutionContext 149 /// 150 /// Make weak references to any strongly referenced objects in \a exe_ctx. 151 //------------------------------------------------------------------ 152 ExecutionContextRef &operator=(const ExecutionContext &exe_ctx); 153 154 //------------------------------------------------------------------ 155 /// Clear the object's state. 156 /// 157 /// Sets the process and thread to nullptr, and the frame index to an 158 /// invalid value. 159 //------------------------------------------------------------------ 160 void Clear(); 161 162 //------------------------------------------------------------------ 163 /// Set accessor that creates a weak reference to the target referenced in 164 /// \a target_sp. 165 /// 166 /// If \a target_sp is valid this object will create a weak reference to 167 /// that object, otherwise any previous target weak reference contained in 168 /// this object will be reset. 169 /// 170 /// Only the weak reference to the target will be updated, no other weak 171 /// references will be modified. If you want this execution context to make 172 /// a weak reference to the target's process, use the 173 /// ExecutionContextRef::SetContext() functions. 174 /// 175 /// @see ExecutionContextRef::SetContext(const lldb::TargetSP &, bool) 176 //------------------------------------------------------------------ 177 void SetTargetSP(const lldb::TargetSP &target_sp); 178 179 //------------------------------------------------------------------ 180 /// Set accessor that creates a weak reference to the process referenced in 181 /// \a process_sp. 182 /// 183 /// If \a process_sp is valid this object will create a weak reference to 184 /// that object, otherwise any previous process weak reference contained in 185 /// this object will be reset. 186 /// 187 /// Only the weak reference to the process will be updated, no other weak 188 /// references will be modified. If you want this execution context to make 189 /// a weak reference to the target, use the 190 /// ExecutionContextRef::SetContext() functions. 191 /// 192 /// @see ExecutionContextRef::SetContext(const lldb::ProcessSP &) 193 //------------------------------------------------------------------ 194 void SetProcessSP(const lldb::ProcessSP &process_sp); 195 196 //------------------------------------------------------------------ 197 /// Set accessor that creates a weak reference to the thread referenced in 198 /// \a thread_sp. 199 /// 200 /// If \a thread_sp is valid this object will create a weak reference to 201 /// that object, otherwise any previous thread weak reference contained in 202 /// this object will be reset. 203 /// 204 /// Only the weak reference to the thread will be updated, no other weak 205 /// references will be modified. If you want this execution context to make 206 /// a weak reference to the thread's process and target, use the 207 /// ExecutionContextRef::SetContext() functions. 208 /// 209 /// @see ExecutionContextRef::SetContext(const lldb::ThreadSP &) 210 //------------------------------------------------------------------ 211 void SetThreadSP(const lldb::ThreadSP &thread_sp); 212 213 //------------------------------------------------------------------ 214 /// Set accessor that creates a weak reference to the frame referenced in \a 215 /// frame_sp. 216 /// 217 /// If \a frame_sp is valid this object will create a weak reference to that 218 /// object, otherwise any previous frame weak reference contained in this 219 /// object will be reset. 220 /// 221 /// Only the weak reference to the frame will be updated, no other weak 222 /// references will be modified. If you want this execution context to make 223 /// a weak reference to the frame's thread, process and target, use the 224 /// ExecutionContextRef::SetContext() functions. 225 /// 226 /// @see ExecutionContextRef::SetContext(const lldb::StackFrameSP &) 227 //------------------------------------------------------------------ 228 void SetFrameSP(const lldb::StackFrameSP &frame_sp); 229 230 void SetTargetPtr(Target *target, bool adopt_selected); 231 232 void SetProcessPtr(Process *process); 233 234 void SetThreadPtr(Thread *thread); 235 236 void SetFramePtr(StackFrame *frame); 237 238 //------------------------------------------------------------------ 239 /// Get accessor that creates a strong reference from the weak target 240 /// reference contained in this object. 241 /// 242 /// @returns 243 /// A shared pointer to a target that is not guaranteed to be valid. 244 //------------------------------------------------------------------ 245 lldb::TargetSP GetTargetSP() const; 246 247 //------------------------------------------------------------------ 248 /// Get accessor that creates a strong reference from the weak process 249 /// reference contained in this object. 250 /// 251 /// @returns 252 /// A shared pointer to a process that is not guaranteed to be valid. 253 //------------------------------------------------------------------ 254 lldb::ProcessSP GetProcessSP() const; 255 256 //------------------------------------------------------------------ 257 /// Get accessor that creates a strong reference from the weak thread 258 /// reference contained in this object. 259 /// 260 /// @returns 261 /// A shared pointer to a thread that is not guaranteed to be valid. 262 //------------------------------------------------------------------ 263 lldb::ThreadSP GetThreadSP() const; 264 265 //------------------------------------------------------------------ 266 /// Get accessor that creates a strong reference from the weak frame 267 /// reference contained in this object. 268 /// 269 /// @returns 270 /// A shared pointer to a frame that is not guaranteed to be valid. 271 //------------------------------------------------------------------ 272 lldb::StackFrameSP GetFrameSP() const; 273 274 //------------------------------------------------------------------ 275 /// Create an ExecutionContext object from this object. 276 /// 277 /// Create strong references to any execution context objects that are still 278 /// valid. Any of the returned shared pointers in the ExecutionContext 279 /// objects is not guaranteed to be valid. @returns 280 /// An execution context object that has strong references to 281 /// any valid weak references in this object. 282 //------------------------------------------------------------------ 283 ExecutionContext Lock(bool thread_and_frame_only_if_stopped) const; 284 285 //------------------------------------------------------------------ 286 /// Returns true if this object has a weak reference to a thread. The return 287 /// value is only an indication of whether this object has a weak reference 288 /// and does not indicate whether the weak reference is valid or not. 289 //------------------------------------------------------------------ HasThreadRef()290 bool HasThreadRef() const { return m_tid != LLDB_INVALID_THREAD_ID; } 291 292 //------------------------------------------------------------------ 293 /// Returns true if this object has a weak reference to a frame. The return 294 /// value is only an indication of whether this object has a weak reference 295 /// and does not indicate whether the weak reference is valid or not. 296 //------------------------------------------------------------------ HasFrameRef()297 bool HasFrameRef() const { return m_stack_id.IsValid(); } 298 ClearThread()299 void ClearThread() { 300 m_thread_wp.reset(); 301 m_tid = LLDB_INVALID_THREAD_ID; 302 } 303 ClearFrame()304 void ClearFrame() { m_stack_id.Clear(); } 305 306 protected: 307 //------------------------------------------------------------------ 308 // Member variables 309 //------------------------------------------------------------------ 310 lldb::TargetWP m_target_wp; ///< A weak reference to a target 311 lldb::ProcessWP m_process_wp; ///< A weak reference to a process 312 mutable lldb::ThreadWP m_thread_wp; ///< A weak reference to a thread 313 lldb::tid_t m_tid; ///< The thread ID that this object refers to in case the 314 ///backing object changes 315 StackID m_stack_id; ///< The stack ID that this object refers to in case the 316 ///backing object changes 317 }; 318 319 //---------------------------------------------------------------------- 320 /// @class ExecutionContext ExecutionContext.h 321 /// "lldb/Target/ExecutionContext.h" 322 /// A class that contains an execution context. 323 /// 324 /// This baton object can be passed into any function that requires a context 325 /// that specifies a target, process, thread and frame. These objects are 326 /// designed to be used for short term execution context object storage while 327 /// a function might be trying to evaluate something that requires a thread or 328 /// frame. ExecutionContextRef objects can be used to initialize one of these 329 /// objects to turn the weak execution context object references to the 330 /// target, process, thread and frame into strong references (shared pointers) 331 /// so that functions can guarantee that these objects won't go away in the 332 /// middle of a function. 333 /// 334 /// ExecutionContext objects should be used as short lived objects (typically 335 /// on the stack) in order to lock down an execution context for local use and 336 /// for passing down to other functions that also require specific contexts. 337 /// They should NOT be used for long term storage, for long term storage use 338 /// ExecutionContextRef objects. 339 //---------------------------------------------------------------------- 340 class ExecutionContext { 341 public: 342 //------------------------------------------------------------------ 343 /// Default Constructor. 344 //------------------------------------------------------------------ 345 ExecutionContext(); 346 347 //------------------------------------------------------------------ 348 // Copy constructor 349 //------------------------------------------------------------------ 350 ExecutionContext(const ExecutionContext &rhs); 351 352 //------------------------------------------------------------------ 353 // Adopt the target and optionally its current context. 354 //------------------------------------------------------------------ 355 ExecutionContext(Target *t, bool fill_current_process_thread_frame = true); 356 357 //------------------------------------------------------------------ 358 // Create execution contexts from shared pointers 359 //------------------------------------------------------------------ 360 ExecutionContext(const lldb::TargetSP &target_sp, bool get_process); 361 ExecutionContext(const lldb::ProcessSP &process_sp); 362 ExecutionContext(const lldb::ThreadSP &thread_sp); 363 ExecutionContext(const lldb::StackFrameSP &frame_sp); 364 365 //------------------------------------------------------------------ 366 // Create execution contexts from weak pointers 367 //------------------------------------------------------------------ 368 ExecutionContext(const lldb::TargetWP &target_wp, bool get_process); 369 ExecutionContext(const lldb::ProcessWP &process_wp); 370 ExecutionContext(const lldb::ThreadWP &thread_wp); 371 ExecutionContext(const lldb::StackFrameWP &frame_wp); 372 ExecutionContext(const ExecutionContextRef &exe_ctx_ref); 373 ExecutionContext(const ExecutionContextRef *exe_ctx_ref, 374 bool thread_and_frame_only_if_stopped = false); 375 376 // These two variants take in a locker, and grab the target, lock the API 377 // mutex into locker, then fill in the rest of the shared pointers. 378 ExecutionContext(const ExecutionContextRef &exe_ctx_ref, 379 std::unique_lock<std::recursive_mutex> &locker); 380 ExecutionContext(const ExecutionContextRef *exe_ctx_ref, 381 std::unique_lock<std::recursive_mutex> &locker); 382 //------------------------------------------------------------------ 383 // Create execution contexts from execution context scopes 384 //------------------------------------------------------------------ 385 ExecutionContext(ExecutionContextScope *exe_scope); 386 ExecutionContext(ExecutionContextScope &exe_scope); 387 388 //------------------------------------------------------------------ 389 /// Construct with process, thread, and frame index. 390 /// 391 /// Initialize with process \a p, thread \a t, and frame index \a f. 392 /// 393 /// @param[in] process 394 /// The process for this execution context. 395 /// 396 /// @param[in] thread 397 /// The thread for this execution context. 398 /// 399 /// @param[in] frame 400 /// The frame index for this execution context. 401 //------------------------------------------------------------------ 402 ExecutionContext(Process *process, Thread *thread = nullptr, 403 StackFrame *frame = nullptr); 404 405 ~ExecutionContext(); 406 407 ExecutionContext &operator=(const ExecutionContext &rhs); 408 409 bool operator==(const ExecutionContext &rhs) const; 410 411 bool operator!=(const ExecutionContext &rhs) const; 412 413 //------------------------------------------------------------------ 414 /// Clear the object's state. 415 /// 416 /// Sets the process and thread to nullptr, and the frame index to an 417 /// invalid value. 418 //------------------------------------------------------------------ 419 void Clear(); 420 421 RegisterContext *GetRegisterContext() const; 422 423 ExecutionContextScope *GetBestExecutionContextScope() const; 424 425 uint32_t GetAddressByteSize() const; 426 427 lldb::ByteOrder GetByteOrder() const; 428 429 //------------------------------------------------------------------ 430 /// Returns a pointer to the target object. 431 /// 432 /// The returned pointer might be nullptr. Calling HasTargetScope(), 433 /// HasProcessScope(), HasThreadScope(), or HasFrameScope() can help to pre- 434 /// validate this pointer so that this accessor can freely be used without 435 /// having to check for nullptr each time. 436 /// 437 /// @see ExecutionContext::HasTargetScope() const @see 438 /// ExecutionContext::HasProcessScope() const @see 439 /// ExecutionContext::HasThreadScope() const @see 440 /// ExecutionContext::HasFrameScope() const 441 //------------------------------------------------------------------ 442 Target *GetTargetPtr() const; 443 444 //------------------------------------------------------------------ 445 /// Returns a pointer to the process object. 446 /// 447 /// The returned pointer might be nullptr. Calling HasProcessScope(), 448 /// HasThreadScope(), or HasFrameScope() can help to pre-validate this 449 /// pointer so that this accessor can freely be used without having to check 450 /// for nullptr each time. 451 /// 452 /// @see ExecutionContext::HasProcessScope() const @see 453 /// ExecutionContext::HasThreadScope() const @see 454 /// ExecutionContext::HasFrameScope() const 455 //------------------------------------------------------------------ 456 Process *GetProcessPtr() const; 457 458 //------------------------------------------------------------------ 459 /// Returns a pointer to the thread object. 460 /// 461 /// The returned pointer might be nullptr. Calling HasThreadScope() or 462 /// HasFrameScope() can help to pre-validate this pointer so that this 463 /// accessor can freely be used without having to check for nullptr each 464 /// time. 465 /// 466 /// @see ExecutionContext::HasThreadScope() const @see 467 /// ExecutionContext::HasFrameScope() const 468 //------------------------------------------------------------------ GetThreadPtr()469 Thread *GetThreadPtr() const { return m_thread_sp.get(); } 470 471 //------------------------------------------------------------------ 472 /// Returns a pointer to the frame object. 473 /// 474 /// The returned pointer might be nullptr. Calling HasFrameScope(), can help 475 /// to pre-validate this pointer so that this accessor can freely be used 476 /// without having to check for nullptr each time. 477 /// 478 /// @see ExecutionContext::HasFrameScope() const 479 //------------------------------------------------------------------ GetFramePtr()480 StackFrame *GetFramePtr() const { return m_frame_sp.get(); } 481 482 //------------------------------------------------------------------ 483 /// Returns a reference to the target object. 484 /// 485 /// Clients should call HasTargetScope(), HasProcessScope(), 486 /// HasThreadScope(), or HasFrameScope() prior to calling this function to 487 /// ensure that this ExecutionContext object contains a valid target. 488 /// 489 /// @see ExecutionContext::HasTargetScope() const @see 490 /// ExecutionContext::HasProcessScope() const @see 491 /// ExecutionContext::HasThreadScope() const @see 492 /// ExecutionContext::HasFrameScope() const 493 //------------------------------------------------------------------ 494 Target &GetTargetRef() const; 495 496 //------------------------------------------------------------------ 497 /// Returns a reference to the process object. 498 /// 499 /// Clients should call HasProcessScope(), HasThreadScope(), or 500 /// HasFrameScope() prior to calling this function to ensure that this 501 /// ExecutionContext object contains a valid target. 502 /// 503 /// @see ExecutionContext::HasProcessScope() const @see 504 /// ExecutionContext::HasThreadScope() const @see 505 /// ExecutionContext::HasFrameScope() const 506 //------------------------------------------------------------------ 507 Process &GetProcessRef() const; 508 509 //------------------------------------------------------------------ 510 /// Returns a reference to the thread object. 511 /// 512 /// Clients should call HasThreadScope(), or HasFrameScope() prior to 513 /// calling this function to ensure that this ExecutionContext object 514 /// contains a valid target. 515 /// 516 /// @see ExecutionContext::HasThreadScope() const @see 517 /// ExecutionContext::HasFrameScope() const 518 //------------------------------------------------------------------ 519 Thread &GetThreadRef() const; 520 521 //------------------------------------------------------------------ 522 /// Returns a reference to the thread object. 523 /// 524 /// Clients should call HasFrameScope() prior to calling this function to 525 /// ensure that this ExecutionContext object contains a valid target. 526 /// 527 /// @see ExecutionContext::HasFrameScope() const 528 //------------------------------------------------------------------ 529 StackFrame &GetFrameRef() const; 530 531 //------------------------------------------------------------------ 532 /// Get accessor to get the target shared pointer. 533 /// 534 /// The returned shared pointer is not guaranteed to be valid. 535 //------------------------------------------------------------------ GetTargetSP()536 const lldb::TargetSP &GetTargetSP() const { return m_target_sp; } 537 538 //------------------------------------------------------------------ 539 /// Get accessor to get the process shared pointer. 540 /// 541 /// The returned shared pointer is not guaranteed to be valid. 542 //------------------------------------------------------------------ GetProcessSP()543 const lldb::ProcessSP &GetProcessSP() const { return m_process_sp; } 544 545 //------------------------------------------------------------------ 546 /// Get accessor to get the thread shared pointer. 547 /// 548 /// The returned shared pointer is not guaranteed to be valid. 549 //------------------------------------------------------------------ GetThreadSP()550 const lldb::ThreadSP &GetThreadSP() const { return m_thread_sp; } 551 552 //------------------------------------------------------------------ 553 /// Get accessor to get the frame shared pointer. 554 /// 555 /// The returned shared pointer is not guaranteed to be valid. 556 //------------------------------------------------------------------ GetFrameSP()557 const lldb::StackFrameSP &GetFrameSP() const { return m_frame_sp; } 558 559 //------------------------------------------------------------------ 560 /// Set accessor to set only the target shared pointer. 561 //------------------------------------------------------------------ 562 void SetTargetSP(const lldb::TargetSP &target_sp); 563 564 //------------------------------------------------------------------ 565 /// Set accessor to set only the process shared pointer. 566 //------------------------------------------------------------------ 567 void SetProcessSP(const lldb::ProcessSP &process_sp); 568 569 //------------------------------------------------------------------ 570 /// Set accessor to set only the thread shared pointer. 571 //------------------------------------------------------------------ 572 void SetThreadSP(const lldb::ThreadSP &thread_sp); 573 574 //------------------------------------------------------------------ 575 /// Set accessor to set only the frame shared pointer. 576 //------------------------------------------------------------------ 577 void SetFrameSP(const lldb::StackFrameSP &frame_sp); 578 579 //------------------------------------------------------------------ 580 /// Set accessor to set only the target shared pointer from a target 581 /// pointer. 582 //------------------------------------------------------------------ 583 void SetTargetPtr(Target *target); 584 585 //------------------------------------------------------------------ 586 /// Set accessor to set only the process shared pointer from a process 587 /// pointer. 588 //------------------------------------------------------------------ 589 void SetProcessPtr(Process *process); 590 591 //------------------------------------------------------------------ 592 /// Set accessor to set only the thread shared pointer from a thread 593 /// pointer. 594 //------------------------------------------------------------------ 595 void SetThreadPtr(Thread *thread); 596 597 //------------------------------------------------------------------ 598 /// Set accessor to set only the frame shared pointer from a frame pointer. 599 //------------------------------------------------------------------ 600 void SetFramePtr(StackFrame *frame); 601 602 //------------------------------------------------------------------ 603 // Set the execution context using a target shared pointer. 604 // 605 // If "target_sp" is valid, sets the target context to match and if 606 // "get_process" is true, sets the process shared pointer if the target 607 // currently has a process. 608 //------------------------------------------------------------------ 609 void SetContext(const lldb::TargetSP &target_sp, bool get_process); 610 611 //------------------------------------------------------------------ 612 // Set the execution context using a process shared pointer. 613 // 614 // If "process_sp" is valid, then set the process and target in this context. 615 // Thread and frame contexts will be cleared. If "process_sp" is not valid, 616 // all shared pointers are reset. 617 //------------------------------------------------------------------ 618 void SetContext(const lldb::ProcessSP &process_sp); 619 620 //------------------------------------------------------------------ 621 // Set the execution context using a thread shared pointer. 622 // 623 // If "thread_sp" is valid, then set the thread, process and target in this 624 // context. The frame context will be cleared. If "thread_sp" is not valid, 625 // all shared pointers are reset. 626 //------------------------------------------------------------------ 627 void SetContext(const lldb::ThreadSP &thread_sp); 628 629 //------------------------------------------------------------------ 630 // Set the execution context using a frame shared pointer. 631 // 632 // If "frame_sp" is valid, then set the frame, thread, process and target in 633 // this context If "frame_sp" is not valid, all shared pointers are reset. 634 //------------------------------------------------------------------ 635 void SetContext(const lldb::StackFrameSP &frame_sp); 636 637 //------------------------------------------------------------------ 638 /// Returns true the ExecutionContext object contains a valid target. 639 /// 640 /// This function can be called after initializing an ExecutionContext 641 /// object, and if it returns true, calls to GetTargetPtr() and 642 /// GetTargetRef() do not need to be checked for validity. 643 //------------------------------------------------------------------ 644 bool HasTargetScope() const; 645 646 //------------------------------------------------------------------ 647 /// Returns true the ExecutionContext object contains a valid target and 648 /// process. 649 /// 650 /// This function can be called after initializing an ExecutionContext 651 /// object, and if it returns true, calls to GetTargetPtr() and 652 /// GetTargetRef(), GetProcessPtr(), and GetProcessRef(), do not need to be 653 /// checked for validity. 654 //------------------------------------------------------------------ 655 bool HasProcessScope() const; 656 657 //------------------------------------------------------------------ 658 /// Returns true the ExecutionContext object contains a valid target, 659 /// process, and thread. 660 /// 661 /// This function can be called after initializing an ExecutionContext 662 /// object, and if it returns true, calls to GetTargetPtr(), GetTargetRef(), 663 /// GetProcessPtr(), GetProcessRef(), GetThreadPtr(), and GetThreadRef() do 664 /// not need to be checked for validity. 665 //------------------------------------------------------------------ 666 bool HasThreadScope() const; 667 668 //------------------------------------------------------------------ 669 /// Returns true the ExecutionContext object contains a valid target, 670 /// process, thread and frame. 671 /// 672 /// This function can be called after initializing an ExecutionContext 673 /// object, and if it returns true, calls to GetTargetPtr(), GetTargetRef(), 674 /// GetProcessPtr(), GetProcessRef(), GetThreadPtr(), GetThreadRef(), 675 /// GetFramePtr(), and GetFrameRef() do not need to be checked for validity. 676 //------------------------------------------------------------------ 677 bool HasFrameScope() const; 678 679 protected: 680 //------------------------------------------------------------------ 681 // Member variables 682 //------------------------------------------------------------------ 683 lldb::TargetSP m_target_sp; ///< The target that owns the process/thread/frame 684 lldb::ProcessSP m_process_sp; ///< The process that owns the thread/frame 685 lldb::ThreadSP m_thread_sp; ///< The thread that owns the frame 686 lldb::StackFrameSP m_frame_sp; ///< The stack frame in thread. 687 }; 688 689 } // namespace lldb_private 690 691 #endif // liblldb_ExecutionContext_h_ 692