Target.h revision 7dd98df0d69447d3f42b8044b7cda2c089aea653
1//===-- Target.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_Target_h_ 11#define liblldb_Target_h_ 12 13// C Includes 14// C++ Includes 15 16// Other libraries and framework includes 17// Project includes 18#include "lldb/lldb-public.h" 19#include "lldb/Breakpoint/BreakpointList.h" 20#include "lldb/Breakpoint/BreakpointLocationCollection.h" 21#include "lldb/Core/Broadcaster.h" 22#include "lldb/Core/Event.h" 23#include "lldb/Core/ModuleList.h" 24#include "lldb/Core/UserSettingsController.h" 25#include "lldb/Expression/ClangPersistentVariables.h" 26#include "lldb/Interpreter/NamedOptionValue.h" 27#include "lldb/Symbol/SymbolContext.h" 28#include "lldb/Target/ABI.h" 29#include "lldb/Target/ExecutionContextScope.h" 30#include "lldb/Target/PathMappingList.h" 31#include "lldb/Target/SectionLoadList.h" 32 33#include "lldb/API/SBTarget.h" 34 35namespace lldb_private { 36 37//---------------------------------------------------------------------- 38// TargetInstanceSettings 39//---------------------------------------------------------------------- 40class TargetInstanceSettings : public InstanceSettings 41{ 42public: 43 static OptionEnumValueElement g_dynamic_value_types[]; 44 45 TargetInstanceSettings (UserSettingsController &owner, bool live_instance = true, const char *name = NULL); 46 47 TargetInstanceSettings (const TargetInstanceSettings &rhs); 48 49 virtual 50 ~TargetInstanceSettings (); 51 52 TargetInstanceSettings& 53 operator= (const TargetInstanceSettings &rhs); 54 55 void 56 UpdateInstanceSettingsVariable (const ConstString &var_name, 57 const char *index_value, 58 const char *value, 59 const ConstString &instance_name, 60 const SettingEntry &entry, 61 VarSetOperationType op, 62 Error &err, 63 bool pending); 64 65 bool 66 GetInstanceSettingsValue (const SettingEntry &entry, 67 const ConstString &var_name, 68 StringList &value, 69 Error *err); 70 71 lldb::DynamicValueType 72 GetPreferDynamicValue() 73 { 74 return (lldb::DynamicValueType) g_dynamic_value_types[m_prefer_dynamic_value].value; 75 } 76 77 bool 78 GetSkipPrologue() 79 { 80 return m_skip_prologue; 81 } 82 83 PathMappingList & 84 GetSourcePathMap () 85 { 86 return m_source_map; 87 } 88 89protected: 90 91 void 92 CopyInstanceSettings (const lldb::InstanceSettingsSP &new_settings, 93 bool pending); 94 95 const ConstString 96 CreateInstanceName (); 97 98 OptionValueFileSpec m_expr_prefix_file; 99 lldb::DataBufferSP m_expr_prefix_contents_sp; 100 int m_prefer_dynamic_value; 101 OptionValueBoolean m_skip_prologue; 102 PathMappingList m_source_map; 103 104 105}; 106 107//---------------------------------------------------------------------- 108// Target 109//---------------------------------------------------------------------- 110class Target : 111 public Broadcaster, 112 public ExecutionContextScope, 113 public TargetInstanceSettings 114{ 115public: 116 friend class TargetList; 117 118 //------------------------------------------------------------------ 119 /// Broadcaster event bits definitions. 120 //------------------------------------------------------------------ 121 enum 122 { 123 eBroadcastBitBreakpointChanged = (1 << 0), 124 eBroadcastBitModulesLoaded = (1 << 1), 125 eBroadcastBitModulesUnloaded = (1 << 2) 126 }; 127 128 static void 129 SettingsInitialize (); 130 131 static void 132 SettingsTerminate (); 133 134 static lldb::UserSettingsControllerSP & 135 GetSettingsController (); 136 137 static ArchSpec 138 GetDefaultArchitecture (); 139 140 static void 141 SetDefaultArchitecture (const ArchSpec &arch); 142 143 void 144 UpdateInstanceName (); 145 146 lldb::ModuleSP 147 GetSharedModule (const FileSpec& file_spec, 148 const ArchSpec& arch, 149 const lldb_private::UUID *uuid = NULL, 150 const ConstString *object_name = NULL, 151 off_t object_offset = 0, 152 Error *error_ptr = NULL); 153private: 154 //------------------------------------------------------------------ 155 /// Construct with optional file and arch. 156 /// 157 /// This member is private. Clients must use 158 /// TargetList::CreateTarget(const FileSpec*, const ArchSpec*) 159 /// so all targets can be tracked from the central target list. 160 /// 161 /// @see TargetList::CreateTarget(const FileSpec*, const ArchSpec*) 162 //------------------------------------------------------------------ 163 Target (Debugger &debugger, 164 const ArchSpec &target_arch, 165 const lldb::PlatformSP &platform_sp); 166 167public: 168 ~Target(); 169 170 Mutex & 171 GetAPIMutex () 172 { 173 return m_mutex; 174 } 175 176 void 177 DeleteCurrentProcess (); 178 179 //------------------------------------------------------------------ 180 /// Dump a description of this object to a Stream. 181 /// 182 /// Dump a description of the contents of this object to the 183 /// supplied stream \a s. The dumped content will be only what has 184 /// been loaded or parsed up to this point at which this function 185 /// is called, so this is a good way to see what has been parsed 186 /// in a target. 187 /// 188 /// @param[in] s 189 /// The stream to which to dump the object descripton. 190 //------------------------------------------------------------------ 191 void 192 Dump (Stream *s, lldb::DescriptionLevel description_level); 193 194 const lldb::ProcessSP & 195 CreateProcess (Listener &listener, const char *plugin_name = NULL); 196 197 const lldb::ProcessSP & 198 GetProcessSP () const; 199 200 lldb::TargetSP 201 GetSP(); 202 203 //------------------------------------------------------------------ 204 // This part handles the breakpoints. 205 //------------------------------------------------------------------ 206 207 BreakpointList & 208 GetBreakpointList(bool internal = false); 209 210 const BreakpointList & 211 GetBreakpointList(bool internal = false) const; 212 213 lldb::BreakpointSP 214 GetLastCreatedBreakpoint () 215 { 216 return m_last_created_breakpoint; 217 } 218 219 lldb::BreakpointSP 220 GetBreakpointByID (lldb::break_id_t break_id); 221 222 // Use this to create a file and line breakpoint to a given module or all module it is NULL 223 lldb::BreakpointSP 224 CreateBreakpoint (const FileSpec *containingModule, 225 const FileSpec &file, 226 uint32_t line_no, 227 bool check_inlines, 228 bool internal = false); 229 230 // Use this to create a breakpoint from a load address 231 lldb::BreakpointSP 232 CreateBreakpoint (lldb::addr_t load_addr, 233 bool internal = false); 234 235 // Use this to create Address breakpoints: 236 lldb::BreakpointSP 237 CreateBreakpoint (Address &addr, 238 bool internal = false); 239 240 // Use this to create a function breakpoint by regexp in containingModule, or all modules if it is NULL 241 // When "skip_prologue is set to eLazyBoolCalculate, we use the current target 242 // setting, else we use the values passed in 243 lldb::BreakpointSP 244 CreateBreakpoint (const FileSpec *containingModule, 245 RegularExpression &func_regexp, 246 bool internal = false, 247 LazyBool skip_prologue = eLazyBoolCalculate); 248 249 // Use this to create a function breakpoint by name in containingModule, or all modules if it is NULL 250 // When "skip_prologue is set to eLazyBoolCalculate, we use the current target 251 // setting, else we use the values passed in 252 lldb::BreakpointSP 253 CreateBreakpoint (const FileSpec *containingModule, 254 const char *func_name, 255 uint32_t func_name_type_mask, 256 bool internal = false, 257 LazyBool skip_prologue = eLazyBoolCalculate); 258 259 // Use this to create a general breakpoint: 260 lldb::BreakpointSP 261 CreateBreakpoint (lldb::SearchFilterSP &filter_sp, 262 lldb::BreakpointResolverSP &resolver_sp, 263 bool internal = false); 264 265 void 266 RemoveAllBreakpoints (bool internal_also = false); 267 268 void 269 DisableAllBreakpoints (bool internal_also = false); 270 271 void 272 EnableAllBreakpoints (bool internal_also = false); 273 274 bool 275 DisableBreakpointByID (lldb::break_id_t break_id); 276 277 bool 278 EnableBreakpointByID (lldb::break_id_t break_id); 279 280 bool 281 RemoveBreakpointByID (lldb::break_id_t break_id); 282 283 void 284 ModulesDidLoad (ModuleList &module_list); 285 286 void 287 ModulesDidUnload (ModuleList &module_list); 288 289 290 //------------------------------------------------------------------ 291 /// Get \a load_addr as a callable code load address for this target 292 /// 293 /// Take \a load_addr and potentially add any address bits that are 294 /// needed to make the address callable. For ARM this can set bit 295 /// zero (if it already isn't) if \a load_addr is a thumb function. 296 /// If \a addr_class is set to eAddressClassInvalid, then the address 297 /// adjustment will always happen. If it is set to an address class 298 /// that doesn't have code in it, LLDB_INVALID_ADDRESS will be 299 /// returned. 300 //------------------------------------------------------------------ 301 lldb::addr_t 302 GetCallableLoadAddress (lldb::addr_t load_addr, AddressClass addr_class = lldb_private::eAddressClassInvalid) const; 303 304 //------------------------------------------------------------------ 305 /// Get \a load_addr as an opcode for this target. 306 /// 307 /// Take \a load_addr and potentially strip any address bits that are 308 /// needed to make the address point to an opcode. For ARM this can 309 /// clear bit zero (if it already isn't) if \a load_addr is a 310 /// thumb function and load_addr is in code. 311 /// If \a addr_class is set to eAddressClassInvalid, then the address 312 /// adjustment will always happen. If it is set to an address class 313 /// that doesn't have code in it, LLDB_INVALID_ADDRESS will be 314 /// returned. 315 //------------------------------------------------------------------ 316 lldb::addr_t 317 GetOpcodeLoadAddress (lldb::addr_t load_addr, AddressClass addr_class = lldb_private::eAddressClassInvalid) const; 318 319protected: 320 void 321 ModuleAdded (lldb::ModuleSP &module_sp); 322 323 void 324 ModuleUpdated (lldb::ModuleSP &old_module_sp, lldb::ModuleSP &new_module_sp); 325 326public: 327 //------------------------------------------------------------------ 328 /// Gets the module for the main executable. 329 /// 330 /// Each process has a notion of a main executable that is the file 331 /// that will be executed or attached to. Executable files can have 332 /// dependent modules that are discovered from the object files, or 333 /// discovered at runtime as things are dynamically loaded. 334 /// 335 /// @return 336 /// The shared pointer to the executable module which can 337 /// contains a NULL Module object if no executable has been 338 /// set. 339 /// 340 /// @see DynamicLoader 341 /// @see ObjectFile::GetDependentModules (FileSpecList&) 342 /// @see Process::SetExecutableModule(lldb::ModuleSP&) 343 //------------------------------------------------------------------ 344 lldb::ModuleSP 345 GetExecutableModule (); 346 347 //------------------------------------------------------------------ 348 /// Set the main executable module. 349 /// 350 /// Each process has a notion of a main executable that is the file 351 /// that will be executed or attached to. Executable files can have 352 /// dependent modules that are discovered from the object files, or 353 /// discovered at runtime as things are dynamically loaded. 354 /// 355 /// Setting the executable causes any of the current dependant 356 /// image information to be cleared and replaced with the static 357 /// dependent image information found by calling 358 /// ObjectFile::GetDependentModules (FileSpecList&) on the main 359 /// executable and any modules on which it depends. Calling 360 /// Process::GetImages() will return the newly found images that 361 /// were obtained from all of the object files. 362 /// 363 /// @param[in] module_sp 364 /// A shared pointer reference to the module that will become 365 /// the main executable for this process. 366 /// 367 /// @param[in] get_dependent_files 368 /// If \b true then ask the object files to track down any 369 /// known dependent files. 370 /// 371 /// @see ObjectFile::GetDependentModules (FileSpecList&) 372 /// @see Process::GetImages() 373 //------------------------------------------------------------------ 374 void 375 SetExecutableModule (lldb::ModuleSP& module_sp, bool get_dependent_files); 376 377 //------------------------------------------------------------------ 378 /// Get accessor for the images for this process. 379 /// 380 /// Each process has a notion of a main executable that is the file 381 /// that will be executed or attached to. Executable files can have 382 /// dependent modules that are discovered from the object files, or 383 /// discovered at runtime as things are dynamically loaded. After 384 /// a main executable has been set, the images will contain a list 385 /// of all the files that the executable depends upon as far as the 386 /// object files know. These images will usually contain valid file 387 /// virtual addresses only. When the process is launched or attached 388 /// to, the DynamicLoader plug-in will discover where these images 389 /// were loaded in memory and will resolve the load virtual 390 /// addresses is each image, and also in images that are loaded by 391 /// code. 392 /// 393 /// @return 394 /// A list of Module objects in a module list. 395 //------------------------------------------------------------------ 396 ModuleList& 397 GetImages () 398 { 399 return m_images; 400 } 401 402 const ModuleList& 403 GetImages () const 404 { 405 return m_images; 406 } 407 408 ArchSpec & 409 GetArchitecture () 410 { 411 return m_arch; 412 } 413 414 const ArchSpec & 415 GetArchitecture () const 416 { 417 return m_arch; 418 } 419 420 //------------------------------------------------------------------ 421 /// Set the architecture for this target. 422 /// 423 /// If the current target has no Images read in, then this just sets the architecture, which will 424 /// be used to select the architecture of the ExecutableModule when that is set. 425 /// If the current target has an ExecutableModule, then calling SetArchitecture with a different 426 /// architecture from the currently selected one will reset the ExecutableModule to that slice 427 /// of the file backing the ExecutableModule. If the file backing the ExecutableModule does not 428 /// contain a fork of this architecture, then this code will return false, and the architecture 429 /// won't be changed. 430 /// If the input arch_spec is the same as the already set architecture, this is a no-op. 431 /// 432 /// @param[in] arch_spec 433 /// The new architecture. 434 /// 435 /// @return 436 /// \b true if the architecture was successfully set, \bfalse otherwise. 437 //------------------------------------------------------------------ 438 bool 439 SetArchitecture (const ArchSpec &arch_spec); 440 441 Debugger & 442 GetDebugger () 443 { 444 return m_debugger; 445 } 446 447 size_t 448 ReadMemoryFromFileCache (const Address& addr, 449 void *dst, 450 size_t dst_len, 451 Error &error); 452 453 // Reading memory through the target allows us to skip going to the process 454 // for reading memory if possible and it allows us to try and read from 455 // any constant sections in our object files on disk. If you always want 456 // live program memory, read straight from the process. If you possibly 457 // want to read from const sections in object files, read from the target. 458 // This version of ReadMemory will try and read memory from the process 459 // if the process is alive. The order is: 460 // 1 - if (prefer_file_cache == true) then read from object file cache 461 // 2 - if there is a valid process, try and read from its memory 462 // 3 - if (prefer_file_cache == false) then read from object file cache 463 size_t 464 ReadMemory (const Address& addr, 465 bool prefer_file_cache, 466 void *dst, 467 size_t dst_len, 468 Error &error); 469 470 size_t 471 ReadScalarIntegerFromMemory (const Address& addr, 472 bool prefer_file_cache, 473 uint32_t byte_size, 474 bool is_signed, 475 Scalar &scalar, 476 Error &error); 477 478 uint64_t 479 ReadUnsignedIntegerFromMemory (const Address& addr, 480 bool prefer_file_cache, 481 size_t integer_byte_size, 482 uint64_t fail_value, 483 Error &error); 484 485 bool 486 ReadPointerFromMemory (const Address& addr, 487 bool prefer_file_cache, 488 Error &error, 489 Address &pointer_addr); 490 491 SectionLoadList& 492 GetSectionLoadList() 493 { 494 return m_section_load_list; 495 } 496 497 const SectionLoadList& 498 GetSectionLoadList() const 499 { 500 return m_section_load_list; 501 } 502 503 504 //------------------------------------------------------------------ 505 /// Load a module in this target by at the section file addresses 506 /// with an optional constant slide applied to each section. 507 /// 508 /// This function will load all top level sections at their file 509 /// addresses and apply an optional constant slide amount to each 510 /// section. This can be used to easily load a module at the same 511 /// addresses that are contained in the object file (trust that 512 /// the addresses in an object file are the correct load addresses). 513 /// 514 /// @param[in] module 515 /// The module to load. 516 /// 517 /// @param[in] slide 518 /// A constant slide to add to each file address as each section 519 /// is being loaded. 520 /// 521 /// @return 522 /// \b true if loading the module at the specified address 523 /// causes a section to be loaded when it previously wasn't, or 524 /// if a section changes load address. Returns \b false if 525 /// the sections were all already loaded at these addresses. 526 //------------------------------------------------------------------ 527 bool 528 LoadModuleWithSlide (Module *module, lldb::addr_t slide); 529 530 static Target * 531 GetTargetFromContexts (const ExecutionContext *exe_ctx_ptr, 532 const SymbolContext *sc_ptr); 533 534 //------------------------------------------------------------------ 535 // lldb::ExecutionContextScope pure virtual functions 536 //------------------------------------------------------------------ 537 virtual Target * 538 CalculateTarget (); 539 540 virtual Process * 541 CalculateProcess (); 542 543 virtual Thread * 544 CalculateThread (); 545 546 virtual StackFrame * 547 CalculateStackFrame (); 548 549 virtual void 550 CalculateExecutionContext (ExecutionContext &exe_ctx); 551 552 PathMappingList & 553 GetImageSearchPathList (); 554 555 ClangASTContext * 556 GetScratchClangASTContext(); 557 558 const char * 559 GetExpressionPrefixContentsAsCString (); 560 561 // Since expressions results can persist beyond the lifetime of a process, 562 // and the const expression results are available after a process is gone, 563 // we provide a way for expressions to be evaluated from the Target itself. 564 // If an expression is going to be run, then it should have a frame filled 565 // in in th execution context. 566 ExecutionResults 567 EvaluateExpression (const char *expression, 568 StackFrame *frame, 569 bool unwind_on_error, 570 bool keep_in_memory, 571 lldb::DynamicValueType use_dynamic, 572 lldb::ValueObjectSP &result_valobj_sp); 573 574 ClangPersistentVariables & 575 GetPersistentVariables() 576 { 577 return m_persistent_variables; 578 } 579 580 //------------------------------------------------------------------ 581 // Target Stop Hooks 582 //------------------------------------------------------------------ 583 class StopHook : public UserID 584 { 585 public: 586 ~StopHook (); 587 588 StopHook (const StopHook &rhs); 589 590 StringList * 591 GetCommandPointer () 592 { 593 return &m_commands; 594 } 595 596 const StringList & 597 GetCommands() 598 { 599 return m_commands; 600 } 601 602 lldb::TargetSP & 603 GetTarget() 604 { 605 return m_target_sp; 606 } 607 608 void 609 SetCommands (StringList &in_commands) 610 { 611 m_commands = in_commands; 612 } 613 614 // Set the specifier. The stop hook will own the specifier, and is responsible for deleting it when we're done. 615 void 616 SetSpecifier (SymbolContextSpecifier *specifier) 617 { 618 m_specifier_sp.reset (specifier); 619 } 620 621 SymbolContextSpecifier * 622 GetSpecifier () 623 { 624 return m_specifier_sp.get(); 625 } 626 627 // Set the Thread Specifier. The stop hook will own the thread specifier, and is responsible for deleting it when we're done. 628 void 629 SetThreadSpecifier (ThreadSpec *specifier); 630 631 ThreadSpec * 632 GetThreadSpecifier() 633 { 634 return m_thread_spec_ap.get(); 635 } 636 637 bool 638 IsActive() 639 { 640 return m_active; 641 } 642 643 void 644 SetIsActive (bool is_active) 645 { 646 m_active = is_active; 647 } 648 649 void 650 GetDescription (Stream *s, lldb::DescriptionLevel level) const; 651 652 private: 653 lldb::TargetSP m_target_sp; 654 StringList m_commands; 655 lldb::SymbolContextSpecifierSP m_specifier_sp; 656 std::auto_ptr<ThreadSpec> m_thread_spec_ap; 657 bool m_active; 658 659 // Use AddStopHook to make a new empty stop hook. The GetCommandPointer and fill it with commands, 660 // and SetSpecifier to set the specifier shared pointer (can be null, that will match anything.) 661 StopHook (lldb::TargetSP target_sp, lldb::user_id_t uid); 662 friend class Target; 663 }; 664 typedef lldb::SharedPtr<StopHook>::Type StopHookSP; 665 666 // Add an empty stop hook to the Target's stop hook list, and returns a shared pointer to it in new_hook. 667 // Returns the id of the new hook. 668 lldb::user_id_t 669 AddStopHook (StopHookSP &new_hook); 670 671 void 672 RunStopHooks (); 673 674 size_t 675 GetStopHookSize(); 676 677 bool 678 SetSuppresStopHooks (bool suppress) 679 { 680 bool old_value = m_suppress_stop_hooks; 681 m_suppress_stop_hooks = suppress; 682 return old_value; 683 } 684 685 bool 686 GetSuppressStopHooks () 687 { 688 return m_suppress_stop_hooks; 689 } 690 691// StopHookSP & 692// GetStopHookByIndex (size_t index); 693// 694 bool 695 RemoveStopHookByID (lldb::user_id_t uid); 696 697 void 698 RemoveAllStopHooks (); 699 700 StopHookSP 701 GetStopHookByID (lldb::user_id_t uid); 702 703 bool 704 SetStopHookActiveStateByID (lldb::user_id_t uid, bool active_state); 705 706 void 707 SetAllStopHooksActiveState (bool active_state); 708 709 size_t GetNumStopHooks () const 710 { 711 return m_stop_hooks.size(); 712 } 713 714 StopHookSP 715 GetStopHookAtIndex (size_t index) 716 { 717 if (index >= GetNumStopHooks()) 718 return StopHookSP(); 719 StopHookCollection::iterator pos = m_stop_hooks.begin(); 720 721 while (index > 0) 722 { 723 pos++; 724 index--; 725 } 726 return (*pos).second; 727 } 728 729 lldb::PlatformSP 730 GetPlatform () 731 { 732 return m_platform_sp; 733 } 734 735 //------------------------------------------------------------------ 736 // Target::SettingsController 737 //------------------------------------------------------------------ 738 class SettingsController : public UserSettingsController 739 { 740 public: 741 SettingsController (); 742 743 virtual 744 ~SettingsController (); 745 746 bool 747 SetGlobalVariable (const ConstString &var_name, 748 const char *index_value, 749 const char *value, 750 const SettingEntry &entry, 751 const VarSetOperationType op, 752 Error&err); 753 754 bool 755 GetGlobalVariable (const ConstString &var_name, 756 StringList &value, 757 Error &err); 758 759 static SettingEntry global_settings_table[]; 760 static SettingEntry instance_settings_table[]; 761 762 ArchSpec & 763 GetArchitecture () 764 { 765 return m_default_architecture; 766 } 767 protected: 768 769 lldb::InstanceSettingsSP 770 CreateInstanceSettings (const char *instance_name); 771 772 private: 773 774 // Class-wide settings. 775 ArchSpec m_default_architecture; 776 777 DISALLOW_COPY_AND_ASSIGN (SettingsController); 778 }; 779 780 781protected: 782 friend class lldb::SBTarget; 783 784 //------------------------------------------------------------------ 785 // Member variables. 786 //------------------------------------------------------------------ 787 Debugger & m_debugger; 788 lldb::PlatformSP m_platform_sp; ///< The platform for this target. 789 Mutex m_mutex; ///< An API mutex that is used by the lldb::SB* classes make the SB interface thread safe 790 ArchSpec m_arch; 791 ModuleList m_images; ///< The list of images for this process (shared libraries and anything dynamically loaded). 792 SectionLoadList m_section_load_list; 793 BreakpointList m_breakpoint_list; 794 BreakpointList m_internal_breakpoint_list; 795 lldb::BreakpointSP m_last_created_breakpoint; 796 // We want to tightly control the process destruction process so 797 // we can correctly tear down everything that we need to, so the only 798 // class that knows about the process lifespan is this target class. 799 lldb::ProcessSP m_process_sp; 800 lldb::SearchFilterSP m_search_filter_sp; 801 PathMappingList m_image_search_paths; 802 std::auto_ptr<ClangASTContext> m_scratch_ast_context_ap; 803 ClangPersistentVariables m_persistent_variables; ///< These are the persistent variables associated with this process for the expression parser. 804 805 806 typedef std::map<lldb::user_id_t, StopHookSP> StopHookCollection; 807 StopHookCollection m_stop_hooks; 808 lldb::user_id_t m_stop_hook_next_id; 809 bool m_suppress_stop_hooks; 810 811 //------------------------------------------------------------------ 812 // Methods. 813 //------------------------------------------------------------------ 814 lldb::SearchFilterSP 815 GetSearchFilterForModule (const FileSpec *containingModule); 816 817 static void 818 ImageSearchPathsChanged (const PathMappingList &path_list, 819 void *baton); 820 821private: 822 DISALLOW_COPY_AND_ASSIGN (Target); 823}; 824 825} // namespace lldb_private 826 827#endif // liblldb_Target_h_ 828