contrib/llvm/tools/lldb/include/lldb/Target/Target.h

   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 #include <list>
  16
  17 // Other libraries and framework includes
  18 // Project includes
  19 #include "lldb/lldb-public.h"
  20 #include "lldb/Breakpoint/BreakpointList.h"
  21 #include "lldb/Breakpoint/BreakpointLocationCollection.h"
  22 #include "lldb/Breakpoint/WatchpointList.h"
  23 #include "lldb/Core/ArchSpec.h"
  24 #include "lldb/Core/Broadcaster.h"
  25 #include "lldb/Core/Disassembler.h"
  26 #include "lldb/Core/Event.h"
  27 #include "lldb/Core/ModuleList.h"
  28 #include "lldb/Core/UserSettingsController.h"
  29 #include "lldb/Expression/ClangPersistentVariables.h"
  30 #include "lldb/Interpreter/Args.h"
  31 #include "lldb/Interpreter/OptionValueBoolean.h"
  32 #include "lldb/Interpreter/OptionValueEnumeration.h"
  33 #include "lldb/Interpreter/OptionValueFileSpec.h"
  34 #include "lldb/Symbol/SymbolContext.h"
  35 #include "lldb/Target/ABI.h"
  36 #include "lldb/Target/ExecutionContextScope.h"
  37 #include "lldb/Target/PathMappingList.h"
  38 #include "lldb/Target/SectionLoadHistory.h"
  39
  40 namespace lldb_private {
  41
  42 extern OptionEnumValueElement g_dynamic_value_types[];
  43
  44 typedef enum InlineStrategy
  45 {
  46     eInlineBreakpointsNever = 0,
  47     eInlineBreakpointsHeaders,
  48     eInlineBreakpointsAlways
  49 } InlineStrategy;
  50
  51 typedef enum LoadScriptFromSymFile
  52 {
  53     eLoadScriptFromSymFileTrue,
  54     eLoadScriptFromSymFileFalse,
  55     eLoadScriptFromSymFileWarn
  56 } LoadScriptFromSymFile;
  57
  58 //----------------------------------------------------------------------
  59 // TargetProperties
  60 //----------------------------------------------------------------------
  61 class TargetProperties : public Properties
  62 {
  63 public:
  64     TargetProperties(Target *target);
  65
  66     virtual
  67     ~TargetProperties();
  68
  69     ArchSpec
  70     GetDefaultArchitecture () const;
  71
  72     void
  73     SetDefaultArchitecture (const ArchSpec& arch);
  74
  75     lldb::DynamicValueType
  76     GetPreferDynamicValue() const;
  77
  78     bool
  79     GetDisableASLR () const;
  80
  81     void
  82     SetDisableASLR (bool b);
  83
  84     bool
  85     GetDisableSTDIO () const;
  86
  87     void
  88     SetDisableSTDIO (bool b);
  89
  90     const char *
  91     GetDisassemblyFlavor() const;
  92
  93 //    void
  94 //    SetDisassemblyFlavor(const char *flavor);
  95
  96     InlineStrategy
  97     GetInlineStrategy () const;
  98
  99     const char *
 100     GetArg0 () const;
 101
 102     void
 103     SetArg0 (const char *arg);
 104
 105     bool
 106     GetRunArguments (Args &args) const;
 107
 108     void
 109     SetRunArguments (const Args &args);
 110
 111     size_t
 112     GetEnvironmentAsArgs (Args &env) const;
 113
 114     bool
 115     GetSkipPrologue() const;
 116
 117     PathMappingList &
 118     GetSourcePathMap () const;
 119
 120     FileSpecList &
 121     GetExecutableSearchPaths ();
 122
 123     FileSpecList &
 124     GetDebugFileSearchPaths ();
 125
 126     bool
 127     GetEnableSyntheticValue () const;
 128
 129     uint32_t
 130     GetMaximumNumberOfChildrenToDisplay() const;
 131
 132     uint32_t
 133     GetMaximumSizeOfStringSummary() const;
 134
 135     uint32_t
 136     GetMaximumMemReadSize () const;
 137
 138     FileSpec
 139     GetStandardInputPath () const;
 140
 141     void
 142     SetStandardInputPath (const char *path);
 143
 144     FileSpec
 145     GetStandardOutputPath () const;
 146
 147     void
 148     SetStandardOutputPath (const char *path);
 149
 150     FileSpec
 151     GetStandardErrorPath () const;
 152
 153     void
 154     SetStandardErrorPath (const char *path);
 155
 156     bool
 157     GetBreakpointsConsultPlatformAvoidList ();
 158
 159     const char *
 160     GetExpressionPrefixContentsAsCString ();
 161
 162     bool
 163     GetUseHexImmediates() const;
 164
 165     bool
 166     GetUseFastStepping() const;
 167
 168     bool
 169     GetDisplayExpressionsInCrashlogs () const;
 170
 171     LoadScriptFromSymFile
 172     GetLoadScriptFromSymbolFile() const;
 173
 174     Disassembler::HexImmediateStyle
 175     GetHexImmediateStyle() const;
 176
 177     MemoryModuleLoadLevel
 178     GetMemoryModuleLoadLevel() const;
 179
 180     bool
 181     GetUserSpecifiedTrapHandlerNames (Args &args) const;
 182
 183     void
 184     SetUserSpecifiedTrapHandlerNames (const Args &args);
 185 };
 186
 187 typedef std::shared_ptr<TargetProperties> TargetPropertiesSP;
 188
 189 class EvaluateExpressionOptions
 190 {
 191 public:
 192     static const uint32_t default_timeout = 500000;
 193     EvaluateExpressionOptions() :
 194         m_execution_policy(eExecutionPolicyOnlyWhenNeeded),
 195         m_language (lldb::eLanguageTypeUnknown),
 196         m_coerce_to_id(false),
 197         m_unwind_on_error(true),
 198         m_ignore_breakpoints (false),
 199         m_keep_in_memory(false),
 200         m_try_others(true),
 201         m_stop_others(true),
 202         m_debug(false),
 203         m_trap_exceptions(true),
 204         m_use_dynamic(lldb::eNoDynamicValues),
 205         m_timeout_usec(default_timeout)
 206     {}
 207
 208     ExecutionPolicy
 209     GetExecutionPolicy () const
 210     {
 211         return m_execution_policy;
 212     }
 213
 214     void
 215     SetExecutionPolicy (ExecutionPolicy policy = eExecutionPolicyAlways)
 216     {
 217         m_execution_policy = policy;
 218     }
 219
 220     lldb::LanguageType
 221     GetLanguage() const
 222     {
 223         return m_language;
 224     }
 225
 226     void
 227     SetLanguage(lldb::LanguageType language)
 228     {
 229         m_language = language;
 230     }
 231
 232     bool
 233     DoesCoerceToId () const
 234     {
 235         return m_coerce_to_id;
 236     }
 237
 238     void
 239     SetCoerceToId (bool coerce = true)
 240     {
 241         m_coerce_to_id = coerce;
 242     }
 243
 244     bool
 245     DoesUnwindOnError () const
 246     {
 247         return m_unwind_on_error;
 248     }
 249
 250     void
 251     SetUnwindOnError (bool unwind = false)
 252     {
 253         m_unwind_on_error = unwind;
 254     }
 255
 256     bool
 257     DoesIgnoreBreakpoints () const
 258     {
 259         return m_ignore_breakpoints;
 260     }
 261
 262     void
 263     SetIgnoreBreakpoints (bool ignore = false)
 264     {
 265         m_ignore_breakpoints = ignore;
 266     }
 267
 268     bool
 269     DoesKeepInMemory () const
 270     {
 271         return m_keep_in_memory;
 272     }
 273
 274     void
 275     SetKeepInMemory (bool keep = true)
 276     {
 277         m_keep_in_memory = keep;
 278     }
 279
 280     lldb::DynamicValueType
 281     GetUseDynamic () const
 282     {
 283         return m_use_dynamic;
 284     }
 285
 286     void
 287     SetUseDynamic (lldb::DynamicValueType dynamic = lldb::eDynamicCanRunTarget)
 288     {
 289         m_use_dynamic = dynamic;
 290     }
 291
 292     uint32_t
 293     GetTimeoutUsec () const
 294     {
 295         return m_timeout_usec;
 296     }
 297
 298     void
 299     SetTimeoutUsec (uint32_t timeout = 0)
 300     {
 301         m_timeout_usec = timeout;
 302     }
 303
 304     bool
 305     GetTryAllThreads () const
 306     {
 307         return m_try_others;
 308     }
 309
 310     void
 311     SetTryAllThreads (bool try_others = true)
 312     {
 313         m_try_others = try_others;
 314     }
 315
 316     bool
 317     GetStopOthers () const
 318     {
 319         return m_stop_others;
 320     }
 321
 322     void
 323     SetStopOthers (bool stop_others = true)
 324     {
 325         m_stop_others = stop_others;
 326     }
 327
 328     bool
 329     GetDebug() const
 330     {
 331         return m_debug;
 332     }
 333
 334     void
 335     SetDebug(bool b)
 336     {
 337         m_debug = b;
 338     }
 339
 340     bool
 341     GetTrapExceptions() const
 342     {
 343         return m_trap_exceptions;
 344     }
 345
 346     void
 347     SetTrapExceptions (bool b)
 348     {
 349         m_trap_exceptions = b;
 350     }
 351
 352 private:
 353     ExecutionPolicy m_execution_policy;
 354     lldb::LanguageType m_language;
 355     bool m_coerce_to_id;
 356     bool m_unwind_on_error;
 357     bool m_ignore_breakpoints;
 358     bool m_keep_in_memory;
 359     bool m_try_others;
 360     bool m_stop_others;
 361     bool m_debug;
 362     bool m_trap_exceptions;
 363     lldb::DynamicValueType m_use_dynamic;
 364     uint32_t m_timeout_usec;
 365 };
 366
 367 //----------------------------------------------------------------------
 368 // Target
 369 //----------------------------------------------------------------------
 370 class Target :
 371     public std::enable_shared_from_this<Target>,
 372     public TargetProperties,
 373     public Broadcaster,
 374     public ExecutionContextScope,
 375     public ModuleList::Notifier
 376 {
 377 public:
 378     friend class TargetList;
 379
 380     //------------------------------------------------------------------
 381     /// Broadcaster event bits definitions.
 382     //------------------------------------------------------------------
 383     enum
 384     {
 385         eBroadcastBitBreakpointChanged  = (1 << 0),
 386         eBroadcastBitModulesLoaded      = (1 << 1),
 387         eBroadcastBitModulesUnloaded    = (1 << 2),
 388         eBroadcastBitWatchpointChanged  = (1 << 3),
 389         eBroadcastBitSymbolsLoaded      = (1 << 4)
 390     };
 391
 392     // These two functions fill out the Broadcaster interface:
 393
 394     static ConstString &GetStaticBroadcasterClass ();
 395
 396     virtual ConstString &GetBroadcasterClass() const
 397     {
 398         return GetStaticBroadcasterClass();
 399     }
 400
 401     // This event data class is for use by the TargetList to broadcast new target notifications.
 402     class TargetEventData : public EventData
 403     {
 404     public:
 405
 406         static const ConstString &
 407         GetFlavorString ();
 408
 409         virtual const ConstString &
 410         GetFlavor () const;
 411
 412         TargetEventData (const lldb::TargetSP &new_target_sp);
 413
 414         lldb::TargetSP &
 415         GetTarget()
 416         {
 417             return m_target_sp;
 418         }
 419
 420         virtual
 421         ~TargetEventData();
 422
 423         virtual void
 424         Dump (Stream *s) const;
 425
 426         static const lldb::TargetSP
 427         GetTargetFromEvent (const lldb::EventSP &event_sp);
 428
 429         static const TargetEventData *
 430         GetEventDataFromEvent (const Event *event_sp);
 431
 432     private:
 433         lldb::TargetSP m_target_sp;
 434
 435         DISALLOW_COPY_AND_ASSIGN (TargetEventData);
 436     };
 437
 438     static void
 439     SettingsInitialize ();
 440
 441     static void
 442     SettingsTerminate ();
 443
 444 //    static lldb::UserSettingsControllerSP &
 445 //    GetSettingsController ();
 446
 447     static FileSpecList
 448     GetDefaultExecutableSearchPaths ();
 449
 450     static FileSpecList
 451     GetDefaultDebugFileSearchPaths ();
 452
 453     static ArchSpec
 454     GetDefaultArchitecture ();
 455
 456     static void
 457     SetDefaultArchitecture (const ArchSpec &arch);
 458
 459 //    void
 460 //    UpdateInstanceName ();
 461
 462     lldb::ModuleSP
 463     GetSharedModule (const ModuleSpec &module_spec,
 464                      Error *error_ptr = NULL);
 465
 466     //----------------------------------------------------------------------
 467     // Settings accessors
 468     //----------------------------------------------------------------------
 469
 470     static const TargetPropertiesSP &
 471     GetGlobalProperties();
 472
 473
 474 private:
 475     //------------------------------------------------------------------
 476     /// Construct with optional file and arch.
 477     ///
 478     /// This member is private. Clients must use
 479     /// TargetList::CreateTarget(const FileSpec*, const ArchSpec*)
 480     /// so all targets can be tracked from the central target list.
 481     ///
 482     /// @see TargetList::CreateTarget(const FileSpec*, const ArchSpec*)
 483     //------------------------------------------------------------------
 484     Target (Debugger &debugger,
 485             const ArchSpec &target_arch,
 486             const lldb::PlatformSP &platform_sp);
 487
 488     // Helper function.
 489     bool
 490     ProcessIsValid ();
 491
 492 public:
 493     ~Target();
 494
 495     Mutex &
 496     GetAPIMutex ()
 497     {
 498         return m_mutex;
 499     }
 500
 501     void
 502     DeleteCurrentProcess ();
 503
 504     void
 505     CleanupProcess ();
 506     //------------------------------------------------------------------
 507     /// Dump a description of this object to a Stream.
 508     ///
 509     /// Dump a description of the contents of this object to the
 510     /// supplied stream \a s. The dumped content will be only what has
 511     /// been loaded or parsed up to this point at which this function
 512     /// is called, so this is a good way to see what has been parsed
 513     /// in a target.
 514     ///
 515     /// @param[in] s
 516     ///     The stream to which to dump the object descripton.
 517     //------------------------------------------------------------------
 518     void
 519     Dump (Stream *s, lldb::DescriptionLevel description_level);
 520
 521     const lldb::ProcessSP &
 522     CreateProcess (Listener &listener,
 523                    const char *plugin_name,
 524                    const FileSpec *crash_file);
 525
 526     const lldb::ProcessSP &
 527     GetProcessSP () const;
 528
 529     bool
 530     IsValid()
 531     {
 532         return m_valid;
 533     }
 534
 535     void
 536     Destroy();
 537
 538     Error
 539     Launch (Listener &listener,
 540             ProcessLaunchInfo &launch_info);
 541
 542     //------------------------------------------------------------------
 543     // This part handles the breakpoints.
 544     //------------------------------------------------------------------
 545
 546     BreakpointList &
 547     GetBreakpointList(bool internal = false);
 548
 549     const BreakpointList &
 550     GetBreakpointList(bool internal = false) const;
 551
 552     lldb::BreakpointSP
 553     GetLastCreatedBreakpoint ()
 554     {
 555         return m_last_created_breakpoint;
 556     }
 557
 558     lldb::BreakpointSP
 559     GetBreakpointByID (lldb::break_id_t break_id);
 560
 561     // Use this to create a file and line breakpoint to a given module or all module it is NULL
 562     lldb::BreakpointSP
 563     CreateBreakpoint (const FileSpecList *containingModules,
 564                       const FileSpec &file,
 565                       uint32_t line_no,
 566                       LazyBool check_inlines,
 567                       LazyBool skip_prologue,
 568                       bool internal,
 569                       bool request_hardware);
 570
 571     // Use this to create breakpoint that matches regex against the source lines in files given in source_file_list:
 572     lldb::BreakpointSP
 573     CreateSourceRegexBreakpoint (const FileSpecList *containingModules,
 574                                  const FileSpecList *source_file_list,
 575                                  RegularExpression &source_regex,
 576                                  bool internal,
 577                                  bool request_hardware);
 578
 579     // Use this to create a breakpoint from a load address
 580     lldb::BreakpointSP
 581     CreateBreakpoint (lldb::addr_t load_addr,
 582                       bool internal,
 583                       bool request_hardware);
 584
 585     // Use this to create Address breakpoints:
 586     lldb::BreakpointSP
 587     CreateBreakpoint (Address &addr,
 588                       bool internal,
 589                       bool request_hardware);
 590
 591     // Use this to create a function breakpoint by regexp in containingModule/containingSourceFiles, or all modules if it is NULL
 592     // When "skip_prologue is set to eLazyBoolCalculate, we use the current target
 593     // setting, else we use the values passed in
 594     lldb::BreakpointSP
 595     CreateFuncRegexBreakpoint (const FileSpecList *containingModules,
 596                                const FileSpecList *containingSourceFiles,
 597                                RegularExpression &func_regexp,
 598                                LazyBool skip_prologue,
 599                                bool internal,
 600                                bool request_hardware);
 601
 602     // Use this to create a function breakpoint by name in containingModule, or all modules if it is NULL
 603     // When "skip_prologue is set to eLazyBoolCalculate, we use the current target
 604     // setting, else we use the values passed in
 605     lldb::BreakpointSP
 606     CreateBreakpoint (const FileSpecList *containingModules,
 607                       const FileSpecList *containingSourceFiles,
 608                       const char *func_name,
 609                       uint32_t func_name_type_mask,
 610                       LazyBool skip_prologue,
 611                       bool internal,
 612                       bool request_hardware);
 613
 614     lldb::BreakpointSP
 615     CreateExceptionBreakpoint (enum lldb::LanguageType language, bool catch_bp, bool throw_bp, bool internal);
 616
 617     // This is the same as the func_name breakpoint except that you can specify a vector of names.  This is cheaper
 618     // than a regular expression breakpoint in the case where you just want to set a breakpoint on a set of names
 619     // you already know.
 620     lldb::BreakpointSP
 621     CreateBreakpoint (const FileSpecList *containingModules,
 622                       const FileSpecList *containingSourceFiles,
 623                       const char *func_names[],
 624                       size_t num_names,
 625                       uint32_t func_name_type_mask,
 626                       LazyBool skip_prologue,
 627                       bool internal,
 628                       bool request_hardware);
 629
 630     lldb::BreakpointSP
 631     CreateBreakpoint (const FileSpecList *containingModules,
 632                       const FileSpecList *containingSourceFiles,
 633                       const std::vector<std::string> &func_names,
 634                       uint32_t func_name_type_mask,
 635                       LazyBool skip_prologue,
 636                       bool internal,
 637                       bool request_hardware);
 638
 639
 640     // Use this to create a general breakpoint:
 641     lldb::BreakpointSP
 642     CreateBreakpoint (lldb::SearchFilterSP &filter_sp,
 643                       lldb::BreakpointResolverSP &resolver_sp,
 644                       bool internal,
 645                       bool request_hardware,
 646                       bool resolve_indirect_symbols);
 647
 648     // Use this to create a watchpoint:
 649     lldb::WatchpointSP
 650     CreateWatchpoint (lldb::addr_t addr,
 651                       size_t size,
 652                       const ClangASTType *type,
 653                       uint32_t kind,
 654                       Error &error);
 655
 656     lldb::WatchpointSP
 657     GetLastCreatedWatchpoint ()
 658     {
 659         return m_last_created_watchpoint;
 660     }
 661
 662     WatchpointList &
 663     GetWatchpointList()
 664     {
 665         return m_watchpoint_list;
 666     }
 667
 668     void
 669     RemoveAllBreakpoints (bool internal_also = false);
 670
 671     void
 672     DisableAllBreakpoints (bool internal_also = false);
 673
 674     void
 675     EnableAllBreakpoints (bool internal_also = false);
 676
 677     bool
 678     DisableBreakpointByID (lldb::break_id_t break_id);
 679
 680     bool
 681     EnableBreakpointByID (lldb::break_id_t break_id);
 682
 683     bool
 684     RemoveBreakpointByID (lldb::break_id_t break_id);
 685
 686     // The flag 'end_to_end', default to true, signifies that the operation is
 687     // performed end to end, for both the debugger and the debuggee.
 688
 689     bool
 690     RemoveAllWatchpoints (bool end_to_end = true);
 691
 692     bool
 693     DisableAllWatchpoints (bool end_to_end = true);
 694
 695     bool
 696     EnableAllWatchpoints (bool end_to_end = true);
 697
 698     bool
 699     ClearAllWatchpointHitCounts ();
 700
 701     bool
 702     IgnoreAllWatchpoints (uint32_t ignore_count);
 703
 704     bool
 705     DisableWatchpointByID (lldb::watch_id_t watch_id);
 706
 707     bool
 708     EnableWatchpointByID (lldb::watch_id_t watch_id);
 709
 710     bool
 711     RemoveWatchpointByID (lldb::watch_id_t watch_id);
 712
 713     bool
 714     IgnoreWatchpointByID (lldb::watch_id_t watch_id, uint32_t ignore_count);
 715
 716     //------------------------------------------------------------------
 717     /// Get \a load_addr as a callable code load address for this target
 718     ///
 719     /// Take \a load_addr and potentially add any address bits that are
 720     /// needed to make the address callable. For ARM this can set bit
 721     /// zero (if it already isn't) if \a load_addr is a thumb function.
 722     /// If \a addr_class is set to eAddressClassInvalid, then the address
 723     /// adjustment will always happen. If it is set to an address class
 724     /// that doesn't have code in it, LLDB_INVALID_ADDRESS will be
 725     /// returned.
 726     //------------------------------------------------------------------
 727     lldb::addr_t
 728     GetCallableLoadAddress (lldb::addr_t load_addr, lldb::AddressClass addr_class = lldb::eAddressClassInvalid) const;
 729
 730     //------------------------------------------------------------------
 731     /// Get \a load_addr as an opcode for this target.
 732     ///
 733     /// Take \a load_addr and potentially strip any address bits that are
 734     /// needed to make the address point to an opcode. For ARM this can
 735     /// clear bit zero (if it already isn't) if \a load_addr is a
 736     /// thumb function and load_addr is in code.
 737     /// If \a addr_class is set to eAddressClassInvalid, then the address
 738     /// adjustment will always happen. If it is set to an address class
 739     /// that doesn't have code in it, LLDB_INVALID_ADDRESS will be
 740     /// returned.
 741     //------------------------------------------------------------------
 742     lldb::addr_t
 743     GetOpcodeLoadAddress (lldb::addr_t load_addr, lldb::AddressClass addr_class = lldb::eAddressClassInvalid) const;
 744
 745 protected:
 746     //------------------------------------------------------------------
 747     /// Implementing of ModuleList::Notifier.
 748     //------------------------------------------------------------------
 749
 750     virtual void
 751     ModuleAdded (const ModuleList& module_list, const lldb::ModuleSP& module_sp);
 752
 753     virtual void
 754     ModuleRemoved (const ModuleList& module_list, const lldb::ModuleSP& module_sp);
 755
 756     virtual void
 757     ModuleUpdated (const ModuleList& module_list,
 758                    const lldb::ModuleSP& old_module_sp,
 759                    const lldb::ModuleSP& new_module_sp);
 760     virtual void
 761     WillClearList (const ModuleList& module_list);
 762
 763 public:
 764
 765     void
 766     ModulesDidLoad (ModuleList &module_list);
 767
 768     void
 769     ModulesDidUnload (ModuleList &module_list, bool delete_locations);
 770
 771     void
 772     SymbolsDidLoad (ModuleList &module_list);
 773
 774     void
 775     ClearModules(bool delete_locations);
 776
 777     //------------------------------------------------------------------
 778     /// Called as the last function in Process::DidExec().
 779     ///
 780     /// Process::DidExec() will clear a lot of state in the process,
 781     /// then try to reload a dynamic loader plugin to discover what
 782     /// binaries are currently available and then this function should
 783     /// be called to allow the target to do any cleanup after everything
 784     /// has been figured out. It can remove breakpoints that no longer
 785     /// make sense as the exec might have changed the target
 786     /// architecture, and unloaded some modules that might get deleted.
 787     //------------------------------------------------------------------
 788     void
 789     DidExec ();
 790
 791     //------------------------------------------------------------------
 792     /// Gets the module for the main executable.
 793     ///
 794     /// Each process has a notion of a main executable that is the file
 795     /// that will be executed or attached to. Executable files can have
 796     /// dependent modules that are discovered from the object files, or
 797     /// discovered at runtime as things are dynamically loaded.
 798     ///
 799     /// @return
 800     ///     The shared pointer to the executable module which can
 801     ///     contains a NULL Module object if no executable has been
 802     ///     set.
 803     ///
 804     /// @see DynamicLoader
 805     /// @see ObjectFile::GetDependentModules (FileSpecList&)
 806     /// @see Process::SetExecutableModule(lldb::ModuleSP&)
 807     //------------------------------------------------------------------
 808     lldb::ModuleSP
 809     GetExecutableModule ();
 810
 811     Module*
 812     GetExecutableModulePointer ();
 813
 814     //------------------------------------------------------------------
 815     /// Set the main executable module.
 816     ///
 817     /// Each process has a notion of a main executable that is the file
 818     /// that will be executed or attached to. Executable files can have
 819     /// dependent modules that are discovered from the object files, or
 820     /// discovered at runtime as things are dynamically loaded.
 821     ///
 822     /// Setting the executable causes any of the current dependant
 823     /// image information to be cleared and replaced with the static
 824     /// dependent image information found by calling
 825     /// ObjectFile::GetDependentModules (FileSpecList&) on the main
 826     /// executable and any modules on which it depends. Calling
 827     /// Process::GetImages() will return the newly found images that
 828     /// were obtained from all of the object files.
 829     ///
 830     /// @param[in] module_sp
 831     ///     A shared pointer reference to the module that will become
 832     ///     the main executable for this process.
 833     ///
 834     /// @param[in] get_dependent_files
 835     ///     If \b true then ask the object files to track down any
 836     ///     known dependent files.
 837     ///
 838     /// @see ObjectFile::GetDependentModules (FileSpecList&)
 839     /// @see Process::GetImages()
 840     //------------------------------------------------------------------
 841     void
 842     SetExecutableModule (lldb::ModuleSP& module_sp, bool get_dependent_files);
 843
 844     bool
 845     LoadScriptingResources (std::list<Error>& errors,
 846                             Stream* feedback_stream = NULL,
 847                             bool continue_on_error = true)
 848     {
 849         return m_images.LoadScriptingResourcesInTarget(this,errors,feedback_stream,continue_on_error);
 850     }
 851
 852     //------------------------------------------------------------------
 853     /// Get accessor for the images for this process.
 854     ///
 855     /// Each process has a notion of a main executable that is the file
 856     /// that will be executed or attached to. Executable files can have
 857     /// dependent modules that are discovered from the object files, or
 858     /// discovered at runtime as things are dynamically loaded. After
 859     /// a main executable has been set, the images will contain a list
 860     /// of all the files that the executable depends upon as far as the
 861     /// object files know. These images will usually contain valid file
 862     /// virtual addresses only. When the process is launched or attached
 863     /// to, the DynamicLoader plug-in will discover where these images
 864     /// were loaded in memory and will resolve the load virtual
 865     /// addresses is each image, and also in images that are loaded by
 866     /// code.
 867     ///
 868     /// @return
 869     ///     A list of Module objects in a module list.
 870     //------------------------------------------------------------------
 871     const ModuleList&
 872     GetImages () const
 873     {
 874         return m_images;
 875     }
 876
 877     ModuleList&
 878     GetImages ()
 879     {
 880         return m_images;
 881     }
 882
 883     //------------------------------------------------------------------
 884     /// Return whether this FileSpec corresponds to a module that should be considered for general searches.
 885     ///
 886     /// This API will be consulted by the SearchFilterForNonModuleSpecificSearches
 887     /// and any module that returns \b true will not be searched.  Note the
 888     /// SearchFilterForNonModuleSpecificSearches is the search filter that
 889     /// gets used in the CreateBreakpoint calls when no modules is provided.
 890     ///
 891     /// The target call at present just consults the Platform's call of the
 892     /// same name.
 893     ///
 894     /// @param[in] module_sp
 895     ///     A shared pointer reference to the module that checked.
 896     ///
 897     /// @return \b true if the module should be excluded, \b false otherwise.
 898     //------------------------------------------------------------------
 899     bool
 900     ModuleIsExcludedForNonModuleSpecificSearches (const FileSpec &module_spec);
 901
 902     //------------------------------------------------------------------
 903     /// Return whether this module should be considered for general searches.
 904     ///
 905     /// This API will be consulted by the SearchFilterForNonModuleSpecificSearches
 906     /// and any module that returns \b true will not be searched.  Note the
 907     /// SearchFilterForNonModuleSpecificSearches is the search filter that
 908     /// gets used in the CreateBreakpoint calls when no modules is provided.
 909     ///
 910     /// The target call at present just consults the Platform's call of the
 911     /// same name.
 912     ///
 913     /// FIXME: When we get time we should add a way for the user to set modules that they
 914     /// don't want searched, in addition to or instead of the platform ones.
 915     ///
 916     /// @param[in] module_sp
 917     ///     A shared pointer reference to the module that checked.
 918     ///
 919     /// @return \b true if the module should be excluded, \b false otherwise.
 920     //------------------------------------------------------------------
 921     bool
 922     ModuleIsExcludedForNonModuleSpecificSearches (const lldb::ModuleSP &module_sp);
 923
 924     ArchSpec &
 925     GetArchitecture ()
 926     {
 927         return m_arch;
 928     }
 929
 930     const ArchSpec &
 931     GetArchitecture () const
 932     {
 933         return m_arch;
 934     }
 935
 936     //------------------------------------------------------------------
 937     /// Set the architecture for this target.
 938     ///
 939     /// If the current target has no Images read in, then this just sets the architecture, which will
 940     /// be used to select the architecture of the ExecutableModule when that is set.
 941     /// If the current target has an ExecutableModule, then calling SetArchitecture with a different
 942     /// architecture from the currently selected one will reset the ExecutableModule to that slice
 943     /// of the file backing the ExecutableModule.  If the file backing the ExecutableModule does not
 944     /// contain a fork of this architecture, then this code will return false, and the architecture
 945     /// won't be changed.
 946     /// If the input arch_spec is the same as the already set architecture, this is a no-op.
 947     ///
 948     /// @param[in] arch_spec
 949     ///     The new architecture.
 950     ///
 951     /// @return
 952     ///     \b true if the architecture was successfully set, \bfalse otherwise.
 953     //------------------------------------------------------------------
 954     bool
 955     SetArchitecture (const ArchSpec &arch_spec);
 956
 957     Debugger &
 958     GetDebugger ()
 959     {
 960         return m_debugger;
 961     }
 962
 963     size_t
 964     ReadMemoryFromFileCache (const Address& addr,
 965                              void *dst,
 966                              size_t dst_len,
 967                              Error &error);
 968
 969     // Reading memory through the target allows us to skip going to the process
 970     // for reading memory if possible and it allows us to try and read from
 971     // any constant sections in our object files on disk. If you always want
 972     // live program memory, read straight from the process. If you possibly
 973     // want to read from const sections in object files, read from the target.
 974     // This version of ReadMemory will try and read memory from the process
 975     // if the process is alive. The order is:
 976     // 1 - if (prefer_file_cache == true) then read from object file cache
 977     // 2 - if there is a valid process, try and read from its memory
 978     // 3 - if (prefer_file_cache == false) then read from object file cache
 979     size_t
 980     ReadMemory (const Address& addr,
 981                 bool prefer_file_cache,
 982                 void *dst,
 983                 size_t dst_len,
 984                 Error &error,
 985                 lldb::addr_t *load_addr_ptr = NULL);
 986
 987     size_t
 988     ReadCStringFromMemory (const Address& addr, std::string &out_str, Error &error);
 989
 990     size_t
 991     ReadCStringFromMemory (const Address& addr, char *dst, size_t dst_max_len, Error &result_error);
 992
 993     size_t
 994     ReadScalarIntegerFromMemory (const Address& addr,
 995                                  bool prefer_file_cache,
 996                                  uint32_t byte_size,
 997                                  bool is_signed,
 998                                  Scalar &scalar,
 999                                  Error &error);
1000
1001     uint64_t
1002     ReadUnsignedIntegerFromMemory (const Address& addr,
1003                                    bool prefer_file_cache,
1004                                    size_t integer_byte_size,
1005                                    uint64_t fail_value,
1006                                    Error &error);
1007
1008     bool
1009     ReadPointerFromMemory (const Address& addr,
1010                            bool prefer_file_cache,
1011                            Error &error,
1012                            Address &pointer_addr);
1013
1014     SectionLoadList&
1015     GetSectionLoadList()
1016     {
1017         return m_section_load_history.GetCurrentSectionLoadList();
1018     }
1019
1020 //    const SectionLoadList&
1021 //    GetSectionLoadList() const
1022 //    {
1023 //        return const_cast<SectionLoadHistory *>(&m_section_load_history)->GetCurrentSectionLoadList();
1024 //    }
1025
1026     static Target *
1027     GetTargetFromContexts (const ExecutionContext *exe_ctx_ptr,
1028                            const SymbolContext *sc_ptr);
1029
1030     //------------------------------------------------------------------
1031     // lldb::ExecutionContextScope pure virtual functions
1032     //------------------------------------------------------------------
1033     virtual lldb::TargetSP
1034     CalculateTarget ();
1035
1036     virtual lldb::ProcessSP
1037     CalculateProcess ();
1038
1039     virtual lldb::ThreadSP
1040     CalculateThread ();
1041
1042     virtual lldb::StackFrameSP
1043     CalculateStackFrame ();
1044
1045     virtual void
1046     CalculateExecutionContext (ExecutionContext &exe_ctx);
1047
1048     PathMappingList &
1049     GetImageSearchPathList ();
1050
1051     ClangASTContext *
1052     GetScratchClangASTContext(bool create_on_demand=true);
1053
1054     ClangASTImporter *
1055     GetClangASTImporter();
1056
1057     //----------------------------------------------------------------------
1058     // Install any files through the platform that need be to installed
1059     // prior to launching or attaching.
1060     //----------------------------------------------------------------------
1061     Error
1062     Install(ProcessLaunchInfo *launch_info);
1063
1064
1065     bool
1066     ResolveLoadAddress (lldb::addr_t load_addr,
1067                         Address &so_addr,
1068                         uint32_t stop_id = SectionLoadHistory::eStopIDNow);
1069
1070     bool
1071     SetSectionLoadAddress (const lldb::SectionSP &section,
1072                            lldb::addr_t load_addr,
1073                            bool warn_multiple = false);
1074
1075     bool
1076     SetSectionUnloaded (const lldb::SectionSP &section_sp);
1077
1078     bool
1079     SetSectionUnloaded (const lldb::SectionSP &section_sp, lldb::addr_t load_addr);
1080
1081     void
1082     ClearAllLoadedSections ();
1083
1084     // Since expressions results can persist beyond the lifetime of a process,
1085     // and the const expression results are available after a process is gone,
1086     // we provide a way for expressions to be evaluated from the Target itself.
1087     // If an expression is going to be run, then it should have a frame filled
1088     // in in th execution context.
1089     ExecutionResults
1090     EvaluateExpression (const char *expression,
1091                         StackFrame *frame,
1092                         lldb::ValueObjectSP &result_valobj_sp,
1093                         const EvaluateExpressionOptions& options = EvaluateExpressionOptions());
1094
1095     ClangPersistentVariables &
1096     GetPersistentVariables()
1097     {
1098         return m_persistent_variables;
1099     }
1100
1101     //------------------------------------------------------------------
1102     // Target Stop Hooks
1103     //------------------------------------------------------------------
1104     class StopHook : public UserID
1105     {
1106     public:
1107         ~StopHook ();
1108
1109         StopHook (const StopHook &rhs);
1110
1111         StringList *
1112         GetCommandPointer ()
1113         {
1114             return &m_commands;
1115         }
1116
1117         const StringList &
1118         GetCommands()
1119         {
1120             return m_commands;
1121         }
1122
1123         lldb::TargetSP &
1124         GetTarget()
1125         {
1126             return m_target_sp;
1127         }
1128
1129         void
1130         SetCommands (StringList &in_commands)
1131         {
1132             m_commands = in_commands;
1133         }
1134
1135         // Set the specifier.  The stop hook will own the specifier, and is responsible for deleting it when we're done.
1136         void
1137         SetSpecifier (SymbolContextSpecifier *specifier)
1138         {
1139             m_specifier_sp.reset (specifier);
1140         }
1141
1142         SymbolContextSpecifier *
1143         GetSpecifier ()
1144         {
1145             return m_specifier_sp.get();
1146         }
1147
1148         // Set the Thread Specifier.  The stop hook will own the thread specifier, and is responsible for deleting it when we're done.
1149         void
1150         SetThreadSpecifier (ThreadSpec *specifier);
1151
1152         ThreadSpec *
1153         GetThreadSpecifier()
1154         {
1155             return m_thread_spec_ap.get();
1156         }
1157
1158         bool
1159         IsActive()
1160         {
1161             return m_active;
1162         }
1163
1164         void
1165         SetIsActive (bool is_active)
1166         {
1167             m_active = is_active;
1168         }
1169
1170         void
1171         GetDescription (Stream *s, lldb::DescriptionLevel level) const;
1172
1173     private:
1174         lldb::TargetSP m_target_sp;
1175         StringList   m_commands;
1176         lldb::SymbolContextSpecifierSP m_specifier_sp;
1177         std::unique_ptr<ThreadSpec> m_thread_spec_ap;
1178         bool m_active;
1179
1180         // Use CreateStopHook to make a new empty stop hook. The GetCommandPointer and fill it with commands,
1181         // and SetSpecifier to set the specifier shared pointer (can be null, that will match anything.)
1182         StopHook (lldb::TargetSP target_sp, lldb::user_id_t uid);
1183         friend class Target;
1184     };
1185     typedef std::shared_ptr<StopHook> StopHookSP;
1186
1187     // Add an empty stop hook to the Target's stop hook list, and returns a shared pointer to it in new_hook.
1188     // Returns the id of the new hook.
1189     StopHookSP
1190     CreateStopHook ();
1191
1192     void
1193     RunStopHooks ();
1194
1195     size_t
1196     GetStopHookSize();
1197
1198     bool
1199     SetSuppresStopHooks (bool suppress)
1200     {
1201         bool old_value = m_suppress_stop_hooks;
1202         m_suppress_stop_hooks = suppress;
1203         return old_value;
1204     }
1205
1206     bool
1207     GetSuppressStopHooks ()
1208     {
1209         return m_suppress_stop_hooks;
1210     }
1211
1212 //    StopHookSP &
1213 //    GetStopHookByIndex (size_t index);
1214 //
1215     bool
1216     RemoveStopHookByID (lldb::user_id_t uid);
1217
1218     void
1219     RemoveAllStopHooks ();
1220
1221     StopHookSP
1222     GetStopHookByID (lldb::user_id_t uid);
1223
1224     bool
1225     SetStopHookActiveStateByID (lldb::user_id_t uid, bool active_state);
1226
1227     void
1228     SetAllStopHooksActiveState (bool active_state);
1229
1230     size_t GetNumStopHooks () const
1231     {
1232         return m_stop_hooks.size();
1233     }
1234
1235     StopHookSP
1236     GetStopHookAtIndex (size_t index)
1237     {
1238         if (index >= GetNumStopHooks())
1239             return StopHookSP();
1240         StopHookCollection::iterator pos = m_stop_hooks.begin();
1241
1242         while (index > 0)
1243         {
1244             pos++;
1245             index--;
1246         }
1247         return (*pos).second;
1248     }
1249
1250     lldb::PlatformSP
1251     GetPlatform ()
1252     {
1253         return m_platform_sp;
1254     }
1255
1256     void
1257     SetPlatform (const lldb::PlatformSP &platform_sp)
1258     {
1259         m_platform_sp = platform_sp;
1260     }
1261
1262     SourceManager &
1263     GetSourceManager ();
1264
1265     //------------------------------------------------------------------
1266     // Methods.
1267     //------------------------------------------------------------------
1268     lldb::SearchFilterSP
1269     GetSearchFilterForModule (const FileSpec *containingModule);
1270
1271     lldb::SearchFilterSP
1272     GetSearchFilterForModuleList (const FileSpecList *containingModuleList);
1273
1274     lldb::SearchFilterSP
1275     GetSearchFilterForModuleAndCUList (const FileSpecList *containingModules, const FileSpecList *containingSourceFiles);
1276
1277 protected:
1278     //------------------------------------------------------------------
1279     // Member variables.
1280     //------------------------------------------------------------------
1281     Debugger &      m_debugger;
1282     lldb::PlatformSP m_platform_sp;     ///< The platform for this target.
1283     Mutex           m_mutex;            ///< An API mutex that is used by the lldb::SB* classes make the SB interface thread safe
1284     ArchSpec        m_arch;
1285     ModuleList      m_images;           ///< The list of images for this process (shared libraries and anything dynamically loaded).
1286     SectionLoadHistory m_section_load_history;
1287     BreakpointList  m_breakpoint_list;
1288     BreakpointList  m_internal_breakpoint_list;
1289     lldb::BreakpointSP m_last_created_breakpoint;
1290     WatchpointList  m_watchpoint_list;
1291     lldb::WatchpointSP m_last_created_watchpoint;
1292     // We want to tightly control the process destruction process so
1293     // we can correctly tear down everything that we need to, so the only
1294     // class that knows about the process lifespan is this target class.
1295     lldb::ProcessSP m_process_sp;
1296     lldb::SearchFilterSP  m_search_filter_sp;
1297     PathMappingList m_image_search_paths;
1298     std::unique_ptr<ClangASTContext> m_scratch_ast_context_ap;
1299     std::unique_ptr<ClangASTSource> m_scratch_ast_source_ap;
1300     std::unique_ptr<ClangASTImporter> m_ast_importer_ap;
1301     ClangPersistentVariables m_persistent_variables;      ///< These are the persistent variables associated with this process for the expression parser.
1302
1303     std::unique_ptr<SourceManager> m_source_manager_ap;
1304
1305     typedef std::map<lldb::user_id_t, StopHookSP> StopHookCollection;
1306     StopHookCollection      m_stop_hooks;
1307     lldb::user_id_t         m_stop_hook_next_id;
1308     bool                    m_valid;
1309     bool                    m_suppress_stop_hooks;
1310
1311     static void
1312     ImageSearchPathsChanged (const PathMappingList &path_list,
1313                              void *baton);
1314
1315 private:
1316     DISALLOW_COPY_AND_ASSIGN (Target);
1317 };
1318
1319 } // namespace lldb_private
1320
1321 #endif  // liblldb_Target_h_