LLDB  mainline
Target.h
Go to the documentation of this file.
1 //===-- Target.h ------------------------------------------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #ifndef LLDB_TARGET_TARGET_H
10 #define LLDB_TARGET_TARGET_H
11 
12 #include <list>
13 #include <map>
14 #include <memory>
15 #include <string>
16 #include <vector>
17 
21 #include "lldb/Core/Architecture.h"
22 #include "lldb/Core/Disassembler.h"
23 #include "lldb/Core/ModuleList.h"
28 #include "lldb/Symbol/TypeSystem.h"
32 #include "lldb/Target/Statistics.h"
33 #include "lldb/Target/ThreadSpec.h"
34 #include "lldb/Utility/ArchSpec.h"
37 #include "lldb/Utility/Timeout.h"
38 #include "lldb/lldb-public.h"
39 
40 namespace lldb_private {
41 
42 OptionEnumValues GetDynamicValueTypes();
43 
48 };
49 
54 };
55 
60 };
61 
66 };
67 
73 };
74 
76 public:
78 };
79 
80 class TargetProperties : public Properties {
81 public:
82  TargetProperties(Target *target);
83 
84  ~TargetProperties() override;
85 
87 
88  void SetDefaultArchitecture(const ArchSpec &arch);
89 
90  bool GetMoveToNearestCode() const;
91 
93 
95 
96  bool GetPreloadSymbols() const;
97 
98  void SetPreloadSymbols(bool b);
99 
100  bool GetDisableASLR() const;
101 
102  void SetDisableASLR(bool b);
103 
104  bool GetInheritTCC() const;
105 
106  void SetInheritTCC(bool b);
107 
108  bool GetDetachOnError() const;
109 
110  void SetDetachOnError(bool b);
111 
112  bool GetDisableSTDIO() const;
113 
114  void SetDisableSTDIO(bool b);
115 
116  const char *GetDisassemblyFlavor() const;
117 
119 
120  llvm::StringRef GetArg0() const;
121 
122  void SetArg0(llvm::StringRef arg);
123 
124  bool GetRunArguments(Args &args) const;
125 
126  void SetRunArguments(const Args &args);
127 
128  // Get the whole environment including the platform inherited environment and
129  // the target specific environment, excluding the unset environment variables.
130  Environment GetEnvironment() const;
131  // Get the platform inherited environment, excluding the unset environment
132  // variables.
134  // Get the target specific environment only, without the platform inherited
135  // environment.
137  // Set the target specific environment.
138  void SetEnvironment(Environment env);
139 
140  bool GetSkipPrologue() const;
141 
143 
144  bool GetAutoSourceMapRelative() const;
145 
146  FileSpecList GetExecutableSearchPaths();
147 
149 
150  FileSpecList GetDebugFileSearchPaths();
151 
152  FileSpecList GetClangModuleSearchPaths();
153 
154  bool GetEnableAutoImportClangModules() const;
155 
157 
159 
160  bool GetEnableAutoApplyFixIts() const;
161 
162  uint64_t GetNumberOfRetriesWithFixits() const;
163 
164  bool GetEnableNotifyAboutFixIts() const;
165 
167 
168  bool GetEnableSyntheticValue() const;
169 
171 
173 
174  /// Get the max depth value, augmented with a bool to indicate whether the
175  /// depth is the default.
176  ///
177  /// When the user has customized the max depth, the bool will be false.
178  ///
179  /// \returns the max depth, and true if the max depth is the system default,
180  /// otherwise false.
181  std::pair<uint32_t, bool> GetMaximumDepthOfChildrenToDisplay() const;
182 
184 
186 
190 
191  void SetStandardInputPath(llvm::StringRef path);
192  void SetStandardOutputPath(llvm::StringRef path);
193  void SetStandardErrorPath(llvm::StringRef path);
194 
195  void SetStandardInputPath(const char *path) = delete;
196  void SetStandardOutputPath(const char *path) = delete;
197  void SetStandardErrorPath(const char *path) = delete;
198 
200 
202 
203  llvm::StringRef GetExpressionPrefixContents();
204 
205  uint64_t GetExprErrorLimit() const;
206 
207  bool GetUseHexImmediates() const;
208 
209  bool GetUseFastStepping() const;
210 
212 
214 
216 
218 
220 
221  bool GetUserSpecifiedTrapHandlerNames(Args &args) const;
222 
223  void SetUserSpecifiedTrapHandlerNames(const Args &args);
224 
225  bool GetDisplayRuntimeSupportValues() const;
226 
227  void SetDisplayRuntimeSupportValues(bool b);
228 
229  bool GetDisplayRecognizedArguments() const;
230 
231  void SetDisplayRecognizedArguments(bool b);
232 
234 
235  void SetProcessLaunchInfo(const ProcessLaunchInfo &launch_info);
236 
237  bool GetInjectLocalVariables(ExecutionContext *exe_ctx) const;
238 
239  void SetInjectLocalVariables(ExecutionContext *exe_ctx, bool b);
240 
241  void SetRequireHardwareBreakpoints(bool b);
242 
243  bool GetRequireHardwareBreakpoints() const;
244 
245  bool GetAutoInstallMainExecutable() const;
246 
248 
249  void SetDebugUtilityExpression(bool debug);
250 
251  bool GetDebugUtilityExpression() const;
252 
253 private:
254  // Callbacks for m_launch_info.
265 
266  // Settings checker for target.jit-save-objects-dir:
267  void CheckJITObjectsDir();
268 
270 
271  // Member variables.
273  std::unique_ptr<TargetExperimentalProperties> m_experimental_properties_up;
275 };
276 
278 public:
279 // MSVC has a bug here that reports C4268: 'const' static/global data
280 // initialized with compiler generated default constructor fills the object
281 // with zeros. Confirmed that MSVC is *not* zero-initializing, it's just a
282 // bogus warning.
283 #if defined(_MSC_VER)
284 #pragma warning(push)
285 #pragma warning(disable : 4268)
286 #endif
287  static constexpr std::chrono::milliseconds default_timeout{500};
288 #if defined(_MSC_VER)
289 #pragma warning(pop)
290 #endif
291 
294 
295  EvaluateExpressionOptions() = default;
296 
298 
300  m_execution_policy = policy;
301  }
302 
304 
305  void SetLanguage(lldb::LanguageType language) { m_language = language; }
306 
307  bool DoesCoerceToId() const { return m_coerce_to_id; }
308 
309  const char *GetPrefix() const {
310  return (m_prefix.empty() ? nullptr : m_prefix.c_str());
311  }
312 
313  void SetPrefix(const char *prefix) {
314  if (prefix && prefix[0])
315  m_prefix = prefix;
316  else
317  m_prefix.clear();
318  }
319 
320  void SetCoerceToId(bool coerce = true) { m_coerce_to_id = coerce; }
321 
322  bool DoesUnwindOnError() const { return m_unwind_on_error; }
323 
324  void SetUnwindOnError(bool unwind = false) { m_unwind_on_error = unwind; }
325 
327 
328  void SetIgnoreBreakpoints(bool ignore = false) {
329  m_ignore_breakpoints = ignore;
330  }
331 
332  bool DoesKeepInMemory() const { return m_keep_in_memory; }
333 
334  void SetKeepInMemory(bool keep = true) { m_keep_in_memory = keep; }
335 
337 
338  void
340  m_use_dynamic = dynamic;
341  }
342 
343  const Timeout<std::micro> &GetTimeout() const { return m_timeout; }
344 
345  void SetTimeout(const Timeout<std::micro> &timeout) { m_timeout = timeout; }
346 
348  return m_one_thread_timeout;
349  }
350 
352  m_one_thread_timeout = timeout;
353  }
354 
355  bool GetTryAllThreads() const { return m_try_others; }
356 
357  void SetTryAllThreads(bool try_others = true) { m_try_others = try_others; }
358 
359  bool GetStopOthers() const { return m_stop_others; }
360 
361  void SetStopOthers(bool stop_others = true) { m_stop_others = stop_others; }
362 
363  bool GetDebug() const { return m_debug; }
364 
365  void SetDebug(bool b) {
366  m_debug = b;
367  if (m_debug)
368  m_generate_debug_info = true;
369  }
370 
372 
374 
375  bool GetColorizeErrors() const { return m_ansi_color_errors; }
376 
378 
379  bool GetTrapExceptions() const { return m_trap_exceptions; }
380 
381  void SetTrapExceptions(bool b) { m_trap_exceptions = b; }
382 
383  bool GetREPLEnabled() const { return m_repl; }
384 
385  void SetREPLEnabled(bool b) { m_repl = b; }
386 
387  void SetCancelCallback(lldb::ExpressionCancelCallback callback, void *baton) {
388  m_cancel_callback_baton = baton;
389  m_cancel_callback = callback;
390  }
391 
393  return ((m_cancel_callback != nullptr)
395  : false);
396  }
397 
398  // Allows the expression contents to be remapped to point to the specified
399  // file and line using #line directives.
400  void SetPoundLine(const char *path, uint32_t line) const {
401  if (path && path[0]) {
402  m_pound_line_file = path;
403  m_pound_line_line = line;
404  } else {
405  m_pound_line_file.clear();
406  m_pound_line_line = 0;
407  }
408  }
409 
410  const char *GetPoundLineFilePath() const {
411  return (m_pound_line_file.empty() ? nullptr : m_pound_line_file.c_str());
412  }
413 
415 
417 
418  bool GetResultIsInternal() const { return m_result_is_internal; }
419 
421 
422  bool GetAutoApplyFixIts() const { return m_auto_apply_fixits; }
423 
424  void SetRetriesWithFixIts(uint64_t number_of_retries) {
425  m_retries_with_fixits = number_of_retries;
426  }
427 
428  uint64_t GetRetriesWithFixIts() const { return m_retries_with_fixits; }
429 
431 
433 
434 private:
438  bool m_coerce_to_id = false;
439  bool m_unwind_on_error = true;
440  bool m_ignore_breakpoints = false;
441  bool m_keep_in_memory = false;
442  bool m_try_others = true;
443  bool m_stop_others = true;
444  bool m_debug = false;
445  bool m_trap_exceptions = true;
446  bool m_repl = false;
447  bool m_generate_debug_info = false;
448  bool m_ansi_color_errors = false;
449  bool m_result_is_internal = false;
450  bool m_auto_apply_fixits = true;
451  uint64_t m_retries_with_fixits = 1;
452  /// True if the executed code should be treated as utility code that is only
453  /// used by LLDB internally.
455 
460  void *m_cancel_callback_baton = nullptr;
461  // If m_pound_line_file is not empty and m_pound_line_line is non-zero, use
462  // #line %u "%s" before the expression content to remap where the source
463  // originates
466 };
467 
468 // Target
469 class Target : public std::enable_shared_from_this<Target>,
470  public TargetProperties,
471  public Broadcaster,
472  public ExecutionContextScope,
473  public ModuleList::Notifier {
474 public:
475  friend class TargetList;
476  friend class Debugger;
477 
478  /// Broadcaster event bits definitions.
479  enum {
486  };
487 
488  // These two functions fill out the Broadcaster interface:
489 
491 
492  ConstString &GetBroadcasterClass() const override {
493  return GetStaticBroadcasterClass();
494  }
495 
496  // This event data class is for use by the TargetList to broadcast new target
497  // notifications.
498  class TargetEventData : public EventData {
499  public:
500  TargetEventData(const lldb::TargetSP &target_sp);
501 
502  TargetEventData(const lldb::TargetSP &target_sp,
503  const ModuleList &module_list);
504 
505  ~TargetEventData() override;
506 
507  static ConstString GetFlavorString();
508 
509  ConstString GetFlavor() const override {
511  }
512 
513  void Dump(Stream *s) const override;
514 
515  static const TargetEventData *GetEventDataFromEvent(const Event *event_ptr);
516 
517  static lldb::TargetSP GetTargetFromEvent(const Event *event_ptr);
518 
519  static ModuleList GetModuleListFromEvent(const Event *event_ptr);
520 
521  const lldb::TargetSP &GetTarget() const { return m_target_sp; }
522 
523  const ModuleList &GetModuleList() const { return m_module_list; }
524 
525  private:
526  lldb::TargetSP m_target_sp;
528 
529  TargetEventData(const TargetEventData &) = delete;
530  const TargetEventData &operator=(const TargetEventData &) = delete;
531  };
532 
533  ~Target() override;
534 
535  static void SettingsInitialize();
536 
537  static void SettingsTerminate();
538 
539  static FileSpecList GetDefaultExecutableSearchPaths();
540 
541  static FileSpecList GetDefaultDebugFileSearchPaths();
542 
544 
545  static void SetDefaultArchitecture(const ArchSpec &arch);
546 
547  bool IsDummyTarget() const { return m_is_dummy_target; }
548 
549  /// Find a binary on the system and return its Module,
550  /// or return an existing Module that is already in the Target.
551  ///
552  /// Given a ModuleSpec, find a binary satisifying that specification,
553  /// or identify a matching Module already present in the Target,
554  /// and return a shared pointer to it.
555  ///
556  /// \param[in] module_spec
557  /// The criteria that must be matched for the binary being loaded.
558  /// e.g. UUID, architecture, file path.
559  ///
560  /// \param[in] notify
561  /// If notify is true, and the Module is new to this Target,
562  /// Target::ModulesDidLoad will be called.
563  /// If notify is false, it is assumed that the caller is adding
564  /// multiple Modules and will call ModulesDidLoad with the
565  /// full list at the end.
566  /// ModulesDidLoad must be called when a Module/Modules have
567  /// been added to the target, one way or the other.
568  ///
569  /// \param[out] error_ptr
570  /// Optional argument, pointing to a Status object to fill in
571  /// with any results / messages while attempting to find/load
572  /// this binary. Many callers will be internal functions that
573  /// will handle / summarize the failures in a custom way and
574  /// don't use these messages.
575  ///
576  /// \return
577  /// An empty ModuleSP will be returned if no matching file
578  /// was found. If error_ptr was non-nullptr, an error message
579  /// will likely be provided.
580  lldb::ModuleSP GetOrCreateModule(const ModuleSpec &module_spec, bool notify,
581  Status *error_ptr = nullptr);
582 
583  // Settings accessors
584 
586 
587  std::recursive_mutex &GetAPIMutex();
588 
589  void DeleteCurrentProcess();
590 
591  void CleanupProcess();
592 
593  /// Dump a description of this object to a Stream.
594  ///
595  /// Dump a description of the contents of this object to the
596  /// supplied stream \a s. The dumped content will be only what has
597  /// been loaded or parsed up to this point at which this function
598  /// is called, so this is a good way to see what has been parsed
599  /// in a target.
600  ///
601  /// \param[in] s
602  /// The stream to which to dump the object description.
603  void Dump(Stream *s, lldb::DescriptionLevel description_level);
604 
605  // If listener_sp is null, the listener of the owning Debugger object will be
606  // used.
607  const lldb::ProcessSP &CreateProcess(lldb::ListenerSP listener_sp,
608  llvm::StringRef plugin_name,
609  const FileSpec *crash_file,
610  bool can_connect);
611 
612  const lldb::ProcessSP &GetProcessSP() const;
613 
614  bool IsValid() { return m_valid; }
615 
616  void Destroy();
617 
618  Status Launch(ProcessLaunchInfo &launch_info,
619  Stream *stream); // Optional stream to receive first stop info
620 
621  Status Attach(ProcessAttachInfo &attach_info,
622  Stream *stream); // Optional stream to receive first stop info
623 
624  // This part handles the breakpoints.
625 
626  BreakpointList &GetBreakpointList(bool internal = false);
627 
628  const BreakpointList &GetBreakpointList(bool internal = false) const;
629 
630  lldb::BreakpointSP GetLastCreatedBreakpoint() {
632  }
633 
634  lldb::BreakpointSP GetBreakpointByID(lldb::break_id_t break_id);
635 
636  // Use this to create a file and line breakpoint to a given module or all
637  // module it is nullptr
638  lldb::BreakpointSP CreateBreakpoint(const FileSpecList *containingModules,
639  const FileSpec &file, uint32_t line_no,
640  uint32_t column, lldb::addr_t offset,
641  LazyBool check_inlines,
642  LazyBool skip_prologue, bool internal,
643  bool request_hardware,
644  LazyBool move_to_nearest_code);
645 
646  // Use this to create breakpoint that matches regex against the source lines
647  // in files given in source_file_list: If function_names is non-empty, also
648  // filter by function after the matches are made.
649  lldb::BreakpointSP CreateSourceRegexBreakpoint(
650  const FileSpecList *containingModules,
651  const FileSpecList *source_file_list,
652  const std::unordered_set<std::string> &function_names,
653  RegularExpression source_regex, bool internal, bool request_hardware,
654  LazyBool move_to_nearest_code);
655 
656  // Use this to create a breakpoint from a load address
657  lldb::BreakpointSP CreateBreakpoint(lldb::addr_t load_addr, bool internal,
658  bool request_hardware);
659 
660  // Use this to create a breakpoint from a load address and a module file spec
661  lldb::BreakpointSP CreateAddressInModuleBreakpoint(lldb::addr_t file_addr,
662  bool internal,
663  const FileSpec *file_spec,
664  bool request_hardware);
665 
666  // Use this to create Address breakpoints:
667  lldb::BreakpointSP CreateBreakpoint(const Address &addr, bool internal,
668  bool request_hardware);
669 
670  // Use this to create a function breakpoint by regexp in
671  // containingModule/containingSourceFiles, or all modules if it is nullptr
672  // When "skip_prologue is set to eLazyBoolCalculate, we use the current
673  // target setting, else we use the values passed in
674  lldb::BreakpointSP CreateFuncRegexBreakpoint(
675  const FileSpecList *containingModules,
676  const FileSpecList *containingSourceFiles, RegularExpression func_regexp,
677  lldb::LanguageType requested_language, LazyBool skip_prologue,
678  bool internal, bool request_hardware);
679 
680  // Use this to create a function breakpoint by name in containingModule, or
681  // all modules if it is nullptr When "skip_prologue is set to
682  // eLazyBoolCalculate, we use the current target setting, else we use the
683  // values passed in. func_name_type_mask is or'ed values from the
684  // FunctionNameType enum.
685  lldb::BreakpointSP CreateBreakpoint(
686  const FileSpecList *containingModules,
687  const FileSpecList *containingSourceFiles, const char *func_name,
688  lldb::FunctionNameType func_name_type_mask, lldb::LanguageType language,
689  lldb::addr_t offset, LazyBool skip_prologue, bool internal,
690  bool request_hardware);
691 
692  lldb::BreakpointSP
693  CreateExceptionBreakpoint(enum lldb::LanguageType language, bool catch_bp,
694  bool throw_bp, bool internal,
695  Args *additional_args = nullptr,
696  Status *additional_args_error = nullptr);
697 
698  lldb::BreakpointSP CreateScriptedBreakpoint(
699  const llvm::StringRef class_name, const FileSpecList *containingModules,
700  const FileSpecList *containingSourceFiles, bool internal,
701  bool request_hardware, StructuredData::ObjectSP extra_args_sp,
702  Status *creation_error = nullptr);
703 
704  // This is the same as the func_name breakpoint except that you can specify a
705  // vector of names. This is cheaper than a regular expression breakpoint in
706  // the case where you just want to set a breakpoint on a set of names you
707  // already know. func_name_type_mask is or'ed values from the
708  // FunctionNameType enum.
709  lldb::BreakpointSP CreateBreakpoint(
710  const FileSpecList *containingModules,
711  const FileSpecList *containingSourceFiles, const char *func_names[],
712  size_t num_names, lldb::FunctionNameType func_name_type_mask,
713  lldb::LanguageType language, lldb::addr_t offset, LazyBool skip_prologue,
714  bool internal, bool request_hardware);
715 
716  lldb::BreakpointSP
717  CreateBreakpoint(const FileSpecList *containingModules,
718  const FileSpecList *containingSourceFiles,
719  const std::vector<std::string> &func_names,
720  lldb::FunctionNameType func_name_type_mask,
721  lldb::LanguageType language, lldb::addr_t m_offset,
722  LazyBool skip_prologue, bool internal,
723  bool request_hardware);
724 
725  // Use this to create a general breakpoint:
726  lldb::BreakpointSP CreateBreakpoint(lldb::SearchFilterSP &filter_sp,
727  lldb::BreakpointResolverSP &resolver_sp,
728  bool internal, bool request_hardware,
729  bool resolve_indirect_symbols);
730 
731  // Use this to create a watchpoint:
732  lldb::WatchpointSP CreateWatchpoint(lldb::addr_t addr, size_t size,
733  const CompilerType *type, uint32_t kind,
734  Status &error);
735 
736  lldb::WatchpointSP GetLastCreatedWatchpoint() {
738  }
739 
741 
742  // Manages breakpoint names:
743  void AddNameToBreakpoint(BreakpointID &id, const char *name, Status &error);
744 
745  void AddNameToBreakpoint(lldb::BreakpointSP &bp_sp, const char *name,
746  Status &error);
747 
748  void RemoveNameFromBreakpoint(lldb::BreakpointSP &bp_sp, ConstString name);
749 
750  BreakpointName *FindBreakpointName(ConstString name, bool can_create,
751  Status &error);
752 
754 
756  const BreakpointOptions &options,
757  const BreakpointName::Permissions &permissions);
758  void ApplyNameToBreakpoints(BreakpointName &bp_name);
759 
760  // This takes ownership of the name obj passed in.
761  void AddBreakpointName(BreakpointName *bp_name);
762 
763  void GetBreakpointNames(std::vector<std::string> &names);
764 
765  // This call removes ALL breakpoints regardless of permission.
766  void RemoveAllBreakpoints(bool internal_also = false);
767 
768  // This removes all the breakpoints, but obeys the ePermDelete on them.
770 
771  void DisableAllBreakpoints(bool internal_also = false);
772 
774 
775  void EnableAllBreakpoints(bool internal_also = false);
776 
778 
780 
781  bool EnableBreakpointByID(lldb::break_id_t break_id);
782 
783  bool RemoveBreakpointByID(lldb::break_id_t break_id);
784 
785  /// Resets the hit count of all breakpoints.
787 
788  // The flag 'end_to_end', default to true, signifies that the operation is
789  // performed end to end, for both the debugger and the debuggee.
790 
791  bool RemoveAllWatchpoints(bool end_to_end = true);
792 
793  bool DisableAllWatchpoints(bool end_to_end = true);
794 
795  bool EnableAllWatchpoints(bool end_to_end = true);
796 
798 
800 
801  bool IgnoreAllWatchpoints(uint32_t ignore_count);
802 
804 
805  bool EnableWatchpointByID(lldb::watch_id_t watch_id);
806 
807  bool RemoveWatchpointByID(lldb::watch_id_t watch_id);
808 
809  bool IgnoreWatchpointByID(lldb::watch_id_t watch_id, uint32_t ignore_count);
810 
812  const BreakpointIDList &bp_ids,
813  bool append);
814 
816  BreakpointIDList &new_bps);
817 
819  std::vector<std::string> &names,
820  BreakpointIDList &new_bps);
821 
822  /// Get \a load_addr as a callable code load address for this target
823  ///
824  /// Take \a load_addr and potentially add any address bits that are
825  /// needed to make the address callable. For ARM this can set bit
826  /// zero (if it already isn't) if \a load_addr is a thumb function.
827  /// If \a addr_class is set to AddressClass::eInvalid, then the address
828  /// adjustment will always happen. If it is set to an address class
829  /// that doesn't have code in it, LLDB_INVALID_ADDRESS will be
830  /// returned.
832  lldb::addr_t load_addr,
833  AddressClass addr_class = AddressClass::eInvalid) const;
834 
835  /// Get \a load_addr as an opcode for this target.
836  ///
837  /// Take \a load_addr and potentially strip any address bits that are
838  /// needed to make the address point to an opcode. For ARM this can
839  /// clear bit zero (if it already isn't) if \a load_addr is a
840  /// thumb function and load_addr is in code.
841  /// If \a addr_class is set to AddressClass::eInvalid, then the address
842  /// adjustment will always happen. If it is set to an address class
843  /// that doesn't have code in it, LLDB_INVALID_ADDRESS will be
844  /// returned.
847  AddressClass addr_class = AddressClass::eInvalid) const;
848 
849  // Get load_addr as breakable load address for this target. Take a addr and
850  // check if for any reason there is a better address than this to put a
851  // breakpoint on. If there is then return that address. For MIPS, if
852  // instruction at addr is a delay slot instruction then this method will find
853  // the address of its previous instruction and return that address.
855 
856  void ModulesDidLoad(ModuleList &module_list);
857 
858  void ModulesDidUnload(ModuleList &module_list, bool delete_locations);
859 
860  void SymbolsDidLoad(ModuleList &module_list);
861 
862  void ClearModules(bool delete_locations);
863 
864  /// Called as the last function in Process::DidExec().
865  ///
866  /// Process::DidExec() will clear a lot of state in the process,
867  /// then try to reload a dynamic loader plugin to discover what
868  /// binaries are currently available and then this function should
869  /// be called to allow the target to do any cleanup after everything
870  /// has been figured out. It can remove breakpoints that no longer
871  /// make sense as the exec might have changed the target
872  /// architecture, and unloaded some modules that might get deleted.
873  void DidExec();
874 
875  /// Gets the module for the main executable.
876  ///
877  /// Each process has a notion of a main executable that is the file
878  /// that will be executed or attached to. Executable files can have
879  /// dependent modules that are discovered from the object files, or
880  /// discovered at runtime as things are dynamically loaded.
881  ///
882  /// \return
883  /// The shared pointer to the executable module which can
884  /// contains a nullptr Module object if no executable has been
885  /// set.
886  ///
887  /// \see DynamicLoader
888  /// \see ObjectFile::GetDependentModules (FileSpecList&)
889  /// \see Process::SetExecutableModule(lldb::ModuleSP&)
890  lldb::ModuleSP GetExecutableModule();
891 
893 
894  /// Set the main executable module.
895  ///
896  /// Each process has a notion of a main executable that is the file
897  /// that will be executed or attached to. Executable files can have
898  /// dependent modules that are discovered from the object files, or
899  /// discovered at runtime as things are dynamically loaded.
900  ///
901  /// Setting the executable causes any of the current dependent
902  /// image information to be cleared and replaced with the static
903  /// dependent image information found by calling
904  /// ObjectFile::GetDependentModules (FileSpecList&) on the main
905  /// executable and any modules on which it depends. Calling
906  /// Process::GetImages() will return the newly found images that
907  /// were obtained from all of the object files.
908  ///
909  /// \param[in] module_sp
910  /// A shared pointer reference to the module that will become
911  /// the main executable for this process.
912  ///
913  /// \param[in] load_dependent_files
914  /// If \b true then ask the object files to track down any
915  /// known dependent files.
916  ///
917  /// \see ObjectFile::GetDependentModules (FileSpecList&)
918  /// \see Process::GetImages()
919  void SetExecutableModule(
920  lldb::ModuleSP &module_sp,
921  LoadDependentFiles load_dependent_files = eLoadDependentsDefault);
922 
923  bool LoadScriptingResources(std::list<Status> &errors,
924  Stream *feedback_stream = nullptr,
925  bool continue_on_error = true) {
927  this, errors, feedback_stream, continue_on_error);
928  }
929 
930  /// Get accessor for the images for this process.
931  ///
932  /// Each process has a notion of a main executable that is the file
933  /// that will be executed or attached to. Executable files can have
934  /// dependent modules that are discovered from the object files, or
935  /// discovered at runtime as things are dynamically loaded. After
936  /// a main executable has been set, the images will contain a list
937  /// of all the files that the executable depends upon as far as the
938  /// object files know. These images will usually contain valid file
939  /// virtual addresses only. When the process is launched or attached
940  /// to, the DynamicLoader plug-in will discover where these images
941  /// were loaded in memory and will resolve the load virtual
942  /// addresses is each image, and also in images that are loaded by
943  /// code.
944  ///
945  /// \return
946  /// A list of Module objects in a module list.
947  const ModuleList &GetImages() const { return m_images; }
948 
950 
951  /// Return whether this FileSpec corresponds to a module that should be
952  /// considered for general searches.
953  ///
954  /// This API will be consulted by the SearchFilterForUnconstrainedSearches
955  /// and any module that returns \b true will not be searched. Note the
956  /// SearchFilterForUnconstrainedSearches is the search filter that
957  /// gets used in the CreateBreakpoint calls when no modules is provided.
958  ///
959  /// The target call at present just consults the Platform's call of the
960  /// same name.
961  ///
962  /// \param[in] module_spec
963  /// Path to the module.
964  ///
965  /// \return \b true if the module should be excluded, \b false otherwise.
966  bool ModuleIsExcludedForUnconstrainedSearches(const FileSpec &module_spec);
967 
968  /// Return whether this module should be considered for general searches.
969  ///
970  /// This API will be consulted by the SearchFilterForUnconstrainedSearches
971  /// and any module that returns \b true will not be searched. Note the
972  /// SearchFilterForUnconstrainedSearches is the search filter that
973  /// gets used in the CreateBreakpoint calls when no modules is provided.
974  ///
975  /// The target call at present just consults the Platform's call of the
976  /// same name.
977  ///
978  /// FIXME: When we get time we should add a way for the user to set modules
979  /// that they
980  /// don't want searched, in addition to or instead of the platform ones.
981  ///
982  /// \param[in] module_sp
983  /// A shared pointer reference to the module that checked.
984  ///
985  /// \return \b true if the module should be excluded, \b false otherwise.
986  bool
987  ModuleIsExcludedForUnconstrainedSearches(const lldb::ModuleSP &module_sp);
988 
989  const ArchSpec &GetArchitecture() const { return m_arch.GetSpec(); }
990 
991  /// Returns the name of the target's ABI plugin.
992  llvm::StringRef GetABIName() const;
993 
994  /// Set the architecture for this target.
995  ///
996  /// If the current target has no Images read in, then this just sets the
997  /// architecture, which will be used to select the architecture of the
998  /// ExecutableModule when that is set. If the current target has an
999  /// ExecutableModule, then calling SetArchitecture with a different
1000  /// architecture from the currently selected one will reset the
1001  /// ExecutableModule to that slice of the file backing the ExecutableModule.
1002  /// If the file backing the ExecutableModule does not contain a fork of this
1003  /// architecture, then this code will return false, and the architecture
1004  /// won't be changed. If the input arch_spec is the same as the already set
1005  /// architecture, this is a no-op.
1006  ///
1007  /// \param[in] arch_spec
1008  /// The new architecture.
1009  ///
1010  /// \param[in] set_platform
1011  /// If \b true, then the platform will be adjusted if the currently
1012  /// selected platform is not compatible with the architecture being set.
1013  /// If \b false, then just the architecture will be set even if the
1014  /// currently selected platform isn't compatible (in case it might be
1015  /// manually set following this function call).
1016  ///
1017  /// \param[in] merged
1018  /// If true, arch_spec is merged with the current
1019  /// architecture. Otherwise it's replaced.
1020  ///
1021  /// \return
1022  /// \b true if the architecture was successfully set, \b false otherwise.
1023  bool SetArchitecture(const ArchSpec &arch_spec, bool set_platform = false,
1024  bool merge = true);
1025 
1026  bool MergeArchitecture(const ArchSpec &arch_spec);
1027 
1029 
1031 
1032  size_t ReadMemoryFromFileCache(const Address &addr, void *dst, size_t dst_len,
1033  Status &error);
1034 
1035  // Reading memory through the target allows us to skip going to the process
1036  // for reading memory if possible and it allows us to try and read from any
1037  // constant sections in our object files on disk. If you always want live
1038  // program memory, read straight from the process. If you possibly want to
1039  // read from const sections in object files, read from the target. This
1040  // version of ReadMemory will try and read memory from the process if the
1041  // process is alive. The order is:
1042  // 1 - if (force_live_memory == false) and the address falls in a read-only
1043  // section, then read from the file cache
1044  // 2 - if there is a process, then read from memory
1045  // 3 - if there is no process, then read from the file cache
1046  size_t ReadMemory(const Address &addr, void *dst, size_t dst_len,
1047  Status &error, bool force_live_memory = false,
1048  lldb::addr_t *load_addr_ptr = nullptr);
1049 
1050  size_t ReadCStringFromMemory(const Address &addr, std::string &out_str,
1051  Status &error, bool force_live_memory = false);
1052 
1053  size_t ReadCStringFromMemory(const Address &addr, char *dst,
1054  size_t dst_max_len, Status &result_error,
1055  bool force_live_memory = false);
1056 
1057  /// Read a NULL terminated string from memory
1058  ///
1059  /// This function will read a cache page at a time until a NULL string
1060  /// terminator is found. It will stop reading if an aligned sequence of NULL
1061  /// termination \a type_width bytes is not found before reading \a
1062  /// cstr_max_len bytes. The results are always guaranteed to be NULL
1063  /// terminated, and that no more than (max_bytes - type_width) bytes will be
1064  /// read.
1065  ///
1066  /// \param[in] addr
1067  /// The address to start the memory read.
1068  ///
1069  /// \param[in] dst
1070  /// A character buffer containing at least max_bytes.
1071  ///
1072  /// \param[in] max_bytes
1073  /// The maximum number of bytes to read.
1074  ///
1075  /// \param[in] error
1076  /// The error status of the read operation.
1077  ///
1078  /// \param[in] type_width
1079  /// The size of the null terminator (1 to 4 bytes per
1080  /// character). Defaults to 1.
1081  ///
1082  /// \return
1083  /// The error status or the number of bytes prior to the null terminator.
1084  size_t ReadStringFromMemory(const Address &addr, char *dst, size_t max_bytes,
1085  Status &error, size_t type_width,
1086  bool force_live_memory = true);
1087 
1088  size_t ReadScalarIntegerFromMemory(const Address &addr, uint32_t byte_size,
1089  bool is_signed, Scalar &scalar,
1090  Status &error,
1091  bool force_live_memory = false);
1092 
1093  uint64_t ReadUnsignedIntegerFromMemory(const Address &addr,
1094  size_t integer_byte_size,
1095  uint64_t fail_value, Status &error,
1096  bool force_live_memory = false);
1097 
1098  bool ReadPointerFromMemory(const Address &addr, Status &error,
1099  Address &pointer_addr,
1100  bool force_live_memory = false);
1101 
1104  }
1105 
1106  static Target *GetTargetFromContexts(const ExecutionContext *exe_ctx_ptr,
1107  const SymbolContext *sc_ptr);
1108 
1109  // lldb::ExecutionContextScope pure virtual functions
1110  lldb::TargetSP CalculateTarget() override;
1111 
1112  lldb::ProcessSP CalculateProcess() override;
1113 
1114  lldb::ThreadSP CalculateThread() override;
1115 
1116  lldb::StackFrameSP CalculateStackFrame() override;
1117 
1118  void CalculateExecutionContext(ExecutionContext &exe_ctx) override;
1119 
1121 
1122  llvm::Expected<TypeSystem &>
1124  bool create_on_demand = true);
1125 
1126  std::vector<TypeSystem *> GetScratchTypeSystems(bool create_on_demand = true);
1127 
1130 
1131  // Creates a UserExpression for the given language, the rest of the
1132  // parameters have the same meaning as for the UserExpression constructor.
1133  // Returns a new-ed object which the caller owns.
1134 
1135  UserExpression *
1136  GetUserExpressionForLanguage(llvm::StringRef expr, llvm::StringRef prefix,
1137  lldb::LanguageType language,
1138  Expression::ResultType desired_type,
1139  const EvaluateExpressionOptions &options,
1140  ValueObject *ctx_obj, Status &error);
1141 
1142  // Creates a FunctionCaller for the given language, the rest of the
1143  // parameters have the same meaning as for the FunctionCaller constructor.
1144  // Since a FunctionCaller can't be
1145  // IR Interpreted, it makes no sense to call this with an
1146  // ExecutionContextScope that lacks
1147  // a Process.
1148  // Returns a new-ed object which the caller owns.
1149 
1151  const CompilerType &return_type,
1152  const Address &function_address,
1153  const ValueList &arg_value_list,
1154  const char *name, Status &error);
1155 
1156  /// Creates and installs a UtilityFunction for the given language.
1157  llvm::Expected<std::unique_ptr<UtilityFunction>>
1159  lldb::LanguageType language, ExecutionContext &exe_ctx);
1160 
1161  // Install any files through the platform that need be to installed prior to
1162  // launching or attaching.
1163  Status Install(ProcessLaunchInfo *launch_info);
1164 
1165  bool ResolveFileAddress(lldb::addr_t load_addr, Address &so_addr);
1166 
1167  bool ResolveLoadAddress(lldb::addr_t load_addr, Address &so_addr,
1169 
1170  bool SetSectionLoadAddress(const lldb::SectionSP &section,
1171  lldb::addr_t load_addr,
1172  bool warn_multiple = false);
1173 
1174  size_t UnloadModuleSections(const lldb::ModuleSP &module_sp);
1175 
1176  size_t UnloadModuleSections(const ModuleList &module_list);
1177 
1178  bool SetSectionUnloaded(const lldb::SectionSP &section_sp);
1179 
1180  bool SetSectionUnloaded(const lldb::SectionSP &section_sp,
1181  lldb::addr_t load_addr);
1182 
1183  void ClearAllLoadedSections();
1184 
1185  /// Set the \a Trace object containing processor trace information of this
1186  /// target.
1187  ///
1188  /// \param[in] trace_sp
1189  /// The trace object.
1190  void SetTrace(const lldb::TraceSP &trace_sp);
1191 
1192  /// Get the \a Trace object containing processor trace information of this
1193  /// target.
1194  ///
1195  /// \return
1196  /// The trace object. It might be undefined.
1197  lldb::TraceSP GetTrace();
1198 
1199  /// Create a \a Trace object for the current target using the using the
1200  /// default supported tracing technology for this process.
1201  ///
1202  /// \return
1203  /// The new \a Trace or an \a llvm::Error if a \a Trace already exists or
1204  /// the trace couldn't be created.
1205  llvm::Expected<lldb::TraceSP> CreateTrace();
1206 
1207  /// If a \a Trace object is present, this returns it, otherwise a new Trace is
1208  /// created with \a Trace::CreateTrace.
1209  llvm::Expected<lldb::TraceSP> GetTraceOrCreate();
1210 
1211  // Since expressions results can persist beyond the lifetime of a process,
1212  // and the const expression results are available after a process is gone, we
1213  // provide a way for expressions to be evaluated from the Target itself. If
1214  // an expression is going to be run, then it should have a frame filled in in
1215  // the execution context.
1217  llvm::StringRef expression, ExecutionContextScope *exe_scope,
1218  lldb::ValueObjectSP &result_valobj_sp,
1220  std::string *fixed_expression = nullptr, ValueObject *ctx_obj = nullptr);
1221 
1222  lldb::ExpressionVariableSP GetPersistentVariable(ConstString name);
1223 
1225 
1226  /// This method will return the address of the starting function for
1227  /// this binary, e.g. main() or its equivalent. This can be used as
1228  /// an address of a function that is not called once a binary has
1229  /// started running - e.g. as a return address for inferior function
1230  /// calls that are unambiguous completion of the function call, not
1231  /// called during the course of the inferior function code running.
1232  ///
1233  /// If no entry point can be found, an invalid address is returned.
1234  ///
1235  /// \param [out] err
1236  /// This object will be set to failure if no entry address could
1237  /// be found, and may contain a helpful error message.
1238  //
1239  /// \return
1240  /// Returns the entry address for this program, or an error
1241  /// if none can be found.
1242  llvm::Expected<lldb_private::Address> GetEntryPointAddress();
1243 
1244  // Target Stop Hooks
1245  class StopHook : public UserID {
1246  public:
1247  StopHook(const StopHook &rhs);
1248  virtual ~StopHook() = default;
1249 
1251  enum class StopHookResult : uint32_t {
1252  KeepStopped = 0,
1255  };
1256 
1257  lldb::TargetSP &GetTarget() { return m_target_sp; }
1258 
1259  // Set the specifier. The stop hook will own the specifier, and is
1260  // responsible for deleting it when we're done.
1261  void SetSpecifier(SymbolContextSpecifier *specifier);
1262 
1264 
1265  bool ExecutionContextPasses(const ExecutionContext &exe_ctx);
1266 
1267  // Called on stop, this gets passed the ExecutionContext for each "stop
1268  // with a reason" thread. It should add to the stream whatever text it
1269  // wants to show the user, and return False to indicate it wants the target
1270  // not to stop.
1271  virtual StopHookResult HandleStop(ExecutionContext &exe_ctx,
1272  lldb::StreamSP output) = 0;
1273 
1274  // Set the Thread Specifier. The stop hook will own the thread specifier,
1275  // and is responsible for deleting it when we're done.
1276  void SetThreadSpecifier(ThreadSpec *specifier);
1277 
1279 
1280  bool IsActive() { return m_active; }
1281 
1282  void SetIsActive(bool is_active) { m_active = is_active; }
1283 
1284  void SetAutoContinue(bool auto_continue) {
1285  m_auto_continue = auto_continue;
1286  }
1287 
1288  bool GetAutoContinue() const { return m_auto_continue; }
1289 
1290  void GetDescription(Stream *s, lldb::DescriptionLevel level) const;
1291  virtual void GetSubclassDescription(Stream *s,
1292  lldb::DescriptionLevel level) const = 0;
1293 
1294  protected:
1295  lldb::TargetSP m_target_sp;
1296  lldb::SymbolContextSpecifierSP m_specifier_sp;
1297  std::unique_ptr<ThreadSpec> m_thread_spec_up;
1298  bool m_active = true;
1299  bool m_auto_continue = false;
1300 
1301  StopHook(lldb::TargetSP target_sp, lldb::user_id_t uid);
1302  };
1303 
1305  public:
1306  ~StopHookCommandLine() override = default;
1307 
1309  void SetActionFromString(const std::string &strings);
1310  void SetActionFromStrings(const std::vector<std::string> &strings);
1311 
1313  lldb::StreamSP output_sp) override;
1315  lldb::DescriptionLevel level) const override;
1316 
1317  private:
1319  // Use CreateStopHook to make a new empty stop hook. The GetCommandPointer
1320  // and fill it with commands, and SetSpecifier to set the specifier shared
1321  // pointer (can be null, that will match anything.)
1322  StopHookCommandLine(lldb::TargetSP target_sp, lldb::user_id_t uid)
1323  : StopHook(target_sp, uid) {}
1324  friend class Target;
1325  };
1326 
1327  class StopHookScripted : public StopHook {
1328  public:
1329  ~StopHookScripted() override = default;
1331  lldb::StreamSP output) override;
1332 
1334  StructuredData::ObjectSP extra_args_sp);
1335 
1337  lldb::DescriptionLevel level) const override;
1338 
1339  private:
1341  /// This holds the dictionary of keys & values that can be used to
1342  /// parametrize any given callback's behavior.
1344  /// This holds the python callback object.
1346 
1347  /// Use CreateStopHook to make a new empty stop hook. The GetCommandPointer
1348  /// and fill it with commands, and SetSpecifier to set the specifier shared
1349  /// pointer (can be null, that will match anything.)
1350  StopHookScripted(lldb::TargetSP target_sp, lldb::user_id_t uid)
1351  : StopHook(target_sp, uid) {}
1352  friend class Target;
1353  };
1354 
1355  typedef std::shared_ptr<StopHook> StopHookSP;
1356 
1357  /// Add an empty stop hook to the Target's stop hook list, and returns a
1358  /// shared pointer to it in new_hook. Returns the id of the new hook.
1360 
1361  /// If you tried to create a stop hook, and that failed, call this to
1362  /// remove the stop hook, as it will also reset the stop hook counter.
1364 
1365  // Runs the stop hooks that have been registered for this target.
1366  // Returns true if the stop hooks cause the target to resume.
1367  bool RunStopHooks();
1368 
1369  size_t GetStopHookSize();
1370 
1371  bool SetSuppresStopHooks(bool suppress) {
1372  bool old_value = m_suppress_stop_hooks;
1373  m_suppress_stop_hooks = suppress;
1374  return old_value;
1375  }
1376 
1378 
1380 
1381  void RemoveAllStopHooks();
1382 
1384 
1385  bool SetStopHookActiveStateByID(lldb::user_id_t uid, bool active_state);
1386 
1387  void SetAllStopHooksActiveState(bool active_state);
1388 
1389  size_t GetNumStopHooks() const { return m_stop_hooks.size(); }
1390 
1392  if (index >= GetNumStopHooks())
1393  return StopHookSP();
1394  StopHookCollection::iterator pos = m_stop_hooks.begin();
1395 
1396  while (index > 0) {
1397  pos++;
1398  index--;
1399  }
1400  return (*pos).second;
1401  }
1402 
1403  lldb::PlatformSP GetPlatform() { return m_platform_sp; }
1404 
1405  void SetPlatform(const lldb::PlatformSP &platform_sp) {
1406  m_platform_sp = platform_sp;
1407  }
1408 
1410 
1411  // Methods.
1412  lldb::SearchFilterSP
1413  GetSearchFilterForModule(const FileSpec *containingModule);
1414 
1415  lldb::SearchFilterSP
1416  GetSearchFilterForModuleList(const FileSpecList *containingModuleList);
1417 
1418  lldb::SearchFilterSP
1419  GetSearchFilterForModuleAndCUList(const FileSpecList *containingModules,
1420  const FileSpecList *containingSourceFiles);
1421 
1422  lldb::REPLSP GetREPL(Status &err, lldb::LanguageType language,
1423  const char *repl_options, bool can_create);
1424 
1425  void SetREPL(lldb::LanguageType language, lldb::REPLSP repl_sp);
1426 
1429  }
1430 
1431  /// Add a signal for the target. This will get copied over to the process
1432  /// if the signal exists on that target. Only the values with Yes and No are
1433  /// set, Calculate values will be ignored.
1434 protected:
1440  : pass(pass), notify(notify), stop(stop) {}
1441  DummySignalValues() = default;
1442  };
1443  using DummySignalElement = llvm::StringMapEntry<DummySignalValues>;
1444  static bool UpdateSignalFromDummy(lldb::UnixSignalsSP signals_sp,
1445  const DummySignalElement &element);
1446  static bool ResetSignalFromDummy(lldb::UnixSignalsSP signals_sp,
1447  const DummySignalElement &element);
1448 
1449 public:
1450  /// Add a signal to the Target's list of stored signals/actions. These
1451  /// values will get copied into any processes launched from
1452  /// this target.
1453  void AddDummySignal(llvm::StringRef name, LazyBool pass, LazyBool print,
1454  LazyBool stop);
1455  /// Updates the signals in signals_sp using the stored dummy signals.
1456  /// If warning_stream_sp is not null, if any stored signals are not found in
1457  /// the current process, a warning will be emitted here.
1458  void UpdateSignalsFromDummy(lldb::UnixSignalsSP signals_sp,
1459  lldb::StreamSP warning_stream_sp);
1460  /// Clear the dummy signals in signal_names from the target, or all signals
1461  /// if signal_names is empty. Also remove the behaviors they set from the
1462  /// process's signals if it exists.
1463  void ClearDummySignals(Args &signal_names);
1464  /// Print all the signals set in this target.
1465  void PrintDummySignals(Stream &strm, Args &signals);
1466 
1467 protected:
1468  /// Implementing of ModuleList::Notifier.
1469 
1470  void NotifyModuleAdded(const ModuleList &module_list,
1471  const lldb::ModuleSP &module_sp) override;
1472 
1473  void NotifyModuleRemoved(const ModuleList &module_list,
1474  const lldb::ModuleSP &module_sp) override;
1475 
1476  void NotifyModuleUpdated(const ModuleList &module_list,
1477  const lldb::ModuleSP &old_module_sp,
1478  const lldb::ModuleSP &new_module_sp) override;
1479 
1480  void NotifyWillClearList(const ModuleList &module_list) override;
1481 
1482  void NotifyModulesRemoved(lldb_private::ModuleList &module_list) override;
1483 
1484  class Arch {
1485  public:
1486  explicit Arch(const ArchSpec &spec);
1487  const Arch &operator=(const ArchSpec &spec);
1488 
1489  const ArchSpec &GetSpec() const { return m_spec; }
1490  Architecture *GetPlugin() const { return m_plugin_up.get(); }
1491 
1492  private:
1494  std::unique_ptr<Architecture> m_plugin_up;
1495  };
1496 
1497  // Member variables.
1499  lldb::PlatformSP m_platform_sp; ///< The platform for this target.
1500  std::recursive_mutex m_mutex; ///< An API mutex that is used by the lldb::SB*
1501  /// classes make the SB interface thread safe
1502  /// When the private state thread calls SB API's - usually because it is
1503  /// running OS plugin or Python ThreadPlan code - it should not block on the
1504  /// API mutex that is held by the code that kicked off the sequence of events
1505  /// that led us to run the code. We hand out this mutex instead when we
1506  /// detect that code is running on the private state thread.
1507  std::recursive_mutex m_private_mutex;
1509  ModuleList m_images; ///< The list of images for this process (shared
1510  /// libraries and anything dynamically loaded).
1514  using BreakpointNameList = std::map<ConstString, BreakpointName *>;
1516 
1517  lldb::BreakpointSP m_last_created_breakpoint;
1519  lldb::WatchpointSP m_last_created_watchpoint;
1520  // We want to tightly control the process destruction process so we can
1521  // correctly tear down everything that we need to, so the only class that
1522  // knows about the process lifespan is this target class.
1523  lldb::ProcessSP m_process_sp;
1524  lldb::SearchFilterSP m_search_filter_sp;
1527 
1528  typedef std::map<lldb::LanguageType, lldb::REPLSP> REPLMap;
1530 
1531  lldb::SourceManagerUP m_source_manager_up;
1532 
1533  typedef std::map<lldb::user_id_t, StopHookSP> StopHookCollection;
1536  uint32_t m_latest_stop_hook_id; /// This records the last natural stop at
1537  /// which we ran a stop-hook.
1538  bool m_valid;
1539  bool m_suppress_stop_hooks; /// Used to not run stop hooks for expressions
1542  /// An optional \a lldb_private::Trace object containing processor trace
1543  /// information of this target.
1544  lldb::TraceSP m_trace_sp;
1545  /// Stores the frame recognizers of this target.
1546  lldb::StackFrameRecognizerManagerUP m_frame_recognizer_manager_up;
1547  /// These are used to set the signal state when you don't have a process and
1548  /// more usefully in the Dummy target where you can't know exactly what
1549  /// signals you will have.
1550  llvm::StringMap<DummySignalValues> m_dummy_signals;
1551 
1552  static void ImageSearchPathsChanged(const PathMappingList &path_list,
1553  void *baton);
1554 
1555  // Utilities for `statistics` command.
1556 private:
1557  // Target metrics storage.
1559 
1560 public:
1561  /// Get metrics associated with this target in JSON format.
1562  ///
1563  /// Target metrics help measure timings and information that is contained in
1564  /// a target. These are designed to help measure performance of a debug
1565  /// session as well as represent the current state of the target, like
1566  /// information on the currently modules, currently set breakpoints and more.
1567  ///
1568  /// \return
1569  /// Returns a JSON value that contains all target metrics.
1570  llvm::json::Value ReportStatistics();
1571 
1573 
1574 private:
1575  /// Construct with optional file and arch.
1576  ///
1577  /// This member is private. Clients must use
1578  /// TargetList::CreateTarget(const FileSpec*, const ArchSpec*)
1579  /// so all targets can be tracked from the central target list.
1580  ///
1581  /// \see TargetList::CreateTarget(const FileSpec*, const ArchSpec*)
1582  Target(Debugger &debugger, const ArchSpec &target_arch,
1583  const lldb::PlatformSP &platform_sp, bool is_dummy_target);
1584 
1585  // Helper function.
1586  bool ProcessIsValid();
1587 
1588  // Copy breakpoints, stop hooks and so forth from the dummy target:
1589  void PrimeFromDummyTarget(Target &target);
1590 
1591  void AddBreakpoint(lldb::BreakpointSP breakpoint_sp, bool internal);
1592 
1594 
1595  /// Return a recommended size for memory reads at \a addr, optimizing for
1596  /// cache usage.
1598 
1599  Target(const Target &) = delete;
1600  const Target &operator=(const Target &) = delete;
1601 };
1602 
1603 } // namespace lldb_private
1604 
1605 #endif // LLDB_TARGET_TARGET_H
lldb_private::EvaluateExpressionOptions::DoesKeepInMemory
bool DoesKeepInMemory() const
Definition: Target.h:332
lldb_private::TargetProperties::GetStandardInputPath
FileSpec GetStandardInputPath() const
Definition: Target.cpp:4435
lldb_private::Target::PrimeFromDummyTarget
void PrimeFromDummyTarget(Target &target)
Definition: Target.cpp:131
lldb_private::Target::GetFrameRecognizerManager
StackFrameRecognizerManager & GetFrameRecognizerManager()
Definition: Target.h:1427
lldb_private::Target::TargetEventData::GetTarget
const lldb::TargetSP & GetTarget() const
Definition: Target.h:521
lldb_private::ModuleList::LoadScriptingResourcesInTarget
bool LoadScriptingResourcesInTarget(Target *target, std::list< Status > &errors, Stream *feedback_stream=nullptr, bool continue_on_error=true)
Definition: ModuleList.cpp:1037
lldb_private::TargetProperties::DisableSTDIOValueChangedCallback
void DisableSTDIOValueChangedCallback()
Definition: Target.cpp:4675
lldb_private::Target::ConfigureBreakpointName
void ConfigureBreakpointName(BreakpointName &bp_name, const BreakpointOptions &options, const BreakpointName::Permissions &permissions)
Definition: Target.cpp:755
lldb_private::TargetProperties::GetAutoSourceMapRelative
bool GetAutoSourceMapRelative() const
Definition: Target.cpp:4279
lldb_private::TargetProperties::GetDynamicClassInfoHelper
DynamicClassInfoHelper GetDynamicClassInfoHelper() const
Definition: Target.cpp:4333
lldb_private::EvaluateExpressionOptions::m_cancel_callback
lldb::ExpressionCancelCallback m_cancel_callback
Definition: Target.h:459
lldb_private::EvaluateExpressionOptions::GetColorizeErrors
bool GetColorizeErrors() const
Definition: Target.h:375
lldb_private::Target::DummySignalElement
llvm::StringMapEntry< DummySignalValues > DummySignalElement
Definition: Target.h:1443
BreakpointName.h
lldb_private::ExecutionContext
Definition: ExecutionContext.h:292
lldb_private::Target::StopHookCommandLine::StopHookCommandLine
StopHookCommandLine(lldb::TargetSP target_sp, lldb::user_id_t uid)
Definition: Target.h:1322
lldb_private::EvaluateExpressionOptions::GetTimeout
const Timeout< std::micro > & GetTimeout() const
Definition: Target.h:343
lldb-public.h
lldb_private::Target::Destroy
void Destroy()
Definition: Target.cpp:275
lldb_private::Target::StopHook::StopHook
StopHook(const StopHook &rhs)
Definition: Target.cpp:3503
lldb_private::TargetProperties::ComputeEnvironment
Environment ComputeEnvironment() const
Definition: Target.cpp:4186
lldb_private::MemoryModuleLoadLevel
MemoryModuleLoadLevel
Definition: lldb-private-enumerations.h:163
lldb_private::Target::NotifyWillClearList
void NotifyWillClearList(const ModuleList &module_list) override
Definition: Target.cpp:1598
lldb_private::BreakpointList
General Outline: Allows adding and removing breakpoints and find by ID and index.
Definition: BreakpointList.h:25
lldb_private::Architecture
Definition: Architecture.h:17
lldb_private::TargetProperties::GetDisplayExpressionsInCrashlogs
bool GetDisplayExpressionsInCrashlogs() const
Definition: Target.cpp:4513
lldb_private::ArchSpec
Definition: ArchSpec.h:32
lldb_private::Target::RemoveNameFromBreakpoint
void RemoveNameFromBreakpoint(lldb::BreakpointSP &bp_sp, ConstString name)
Definition: Target.cpp:750
lldb_private::RegularExpression
Definition: RegularExpression.h:18
lldb_private::Target::m_latest_stop_hook_id
uint32_t m_latest_stop_hook_id
Definition: Target.h:1536
lldb_private::Target::m_last_created_breakpoint
lldb::BreakpointSP m_last_created_breakpoint
Definition: Target.h:1517
lldb_private::TargetProperties::SetArg0
void SetArg0(llvm::StringRef arg)
Definition: Target.cpp:4169
lldb_private::TargetProperties::GetRequireHardwareBreakpoints
bool GetRequireHardwareBreakpoints() const
Definition: Target.cpp:4608
lldb_private::Target::DeleteBreakpointName
void DeleteBreakpointName(ConstString name)
Definition: Target.cpp:739
lldb_private::TargetProperties::GetInheritTCC
bool GetInheritTCC() const
Definition: Target.cpp:4113
lldb_private::TargetProperties::SetRequireHardwareBreakpoints
void SetRequireHardwareBreakpoints(bool b)
Definition: Target.cpp:4614
lldb_private::Event
Definition: Event.h:182
lldb_private::Target::GetEntryPointAddress
llvm::Expected< lldb_private::Address > GetEntryPointAddress()
This method will return the address of the starting function for this binary, e.g.
Definition: Target.cpp:2571
lldb_private::TargetProperties::GetTargetEnvironment
Environment GetTargetEnvironment() const
Definition: Target.cpp:4247
lldb_private::Target::ModuleIsExcludedForUnconstrainedSearches
bool ModuleIsExcludedForUnconstrainedSearches(const FileSpec &module_spec)
Return whether this FileSpec corresponds to a module that should be considered for general searches.
Definition: Target.cpp:1679
lldb_private::TargetProperties::OutputPathValueChangedCallback
void OutputPathValueChangedCallback()
Definition: Target.cpp:4644
lldb_private::Target::ClearModules
void ClearModules(bool delete_locations)
Definition: Target.cpp:1405
lldb_private::EvaluateExpressionOptions::SetTimeout
void SetTimeout(const Timeout< std::micro > &timeout)
Definition: Target.h:345
lldb_private::EvaluateExpressionOptions::SetREPLEnabled
void SetREPLEnabled(bool b)
Definition: Target.h:385
lldb_private::EvaluateExpressionOptions::SetLanguage
void SetLanguage(lldb::LanguageType language)
Definition: Target.h:305
lldb_private::Target::m_repl_map
REPLMap m_repl_map
Definition: Target.h:1529
lldb_private::Target::SymbolsDidLoad
void SymbolsDidLoad(ModuleList &module_list)
Definition: Target.cpp:1653
lldb_private::TargetProperties::GetExprErrorLimit
uint64_t GetExprErrorLimit() const
Definition: Target.cpp:4489
lldb_private::ExecutionPolicy
ExecutionPolicy
Expression execution policies.
Definition: lldb-private-enumerations.h:138
lldb_private::Target::StopHookCommandLine::HandleStop
StopHookResult HandleStop(ExecutionContext &exc_ctx, lldb::StreamSP output_sp) override
Definition: Target.cpp:3607
lldb_private::Target::StopHook::m_target_sp
lldb::TargetSP m_target_sp
Definition: Target.h:1295
lldb_private::Target::DummySignalValues::pass
LazyBool pass
Definition: Target.h:1436
lldb_private::Target::m_suppress_stop_hooks
bool m_suppress_stop_hooks
Definition: Target.h:1539
lldb_private::AddressClass
AddressClass
Definition: lldb-private-enumerations.h:48
lldb_private::Target::m_stats
TargetStats m_stats
Definition: Target.h:1558
lldb_private::Target::DisableBreakpointByID
bool DisableBreakpointByID(lldb::break_id_t break_id)
Definition: Target.cpp:971
lldb_private::StructuredData::GenericSP
std::shared_ptr< Generic > GenericSP
Definition: StructuredData.h:68
lldb::eNoDynamicValues
@ eNoDynamicValues
Definition: lldb-enumerations.h:495
lldb_private::Target::DummySignalValues
Add a signal for the target.
Definition: Target.h:1435
lldb_private::Target::StopHook::StopHookKind::ScriptBased
@ ScriptBased
lldb_private::Target::StopHookCommandLine::SetActionFromStrings
void SetActionFromStrings(const std::vector< std::string > &strings)
Definition: Target.cpp:3600
lldb_private::TargetProperties::SetStandardInputPath
void SetStandardInputPath(llvm::StringRef path)
Definition: Target.cpp:4440
lldb_private::TargetProperties::SetDisplayRuntimeSupportValues
void SetDisplayRuntimeSupportValues(bool b)
Definition: Target.cpp:4561
lldb_private::TargetProperties::SetDisplayRecognizedArguments
void SetDisplayRecognizedArguments(bool b)
Definition: Target.cpp:4571
lldb_private::Target::StopHook::m_thread_spec_up
std::unique_ptr< ThreadSpec > m_thread_spec_up
Definition: Target.h:1297
lldb_private::TargetProperties::GetPreloadSymbols
bool GetPreloadSymbols() const
Definition: Target.cpp:4091
lldb_private::Target::GetOrCreateModule
lldb::ModuleSP GetOrCreateModule(const ModuleSpec &module_spec, bool notify, Status *error_ptr=nullptr)
Find a binary on the system and return its Module, or return an existing Module that is already in th...
Definition: Target.cpp:2073
lldb::ExpressionCancelCallback
bool(* ExpressionCancelCallback)(ExpressionEvaluationPhase phase, void *baton)
Definition: lldb-types.h:74
lldb::ExpressionResults
ExpressionResults
The results of expression evaluation.
Definition: lldb-enumerations.h:270
lldb_private::Target::StopHook::SetAutoContinue
void SetAutoContinue(bool auto_continue)
Definition: Target.h:1284
lldb_private::Target::GetBreakpointNames
void GetBreakpointNames(std::vector< std::string > &names)
Definition: Target.cpp:777
lldb_private::Target::operator=
const Target & operator=(const Target &)=delete
ProcessLaunchInfo.h
lldb_private::Target::StopHook::m_auto_continue
bool m_auto_continue
Definition: Target.h:1299
lldb_private::UserID
Definition: UserID.h:31
lldb_private::Target::UnloadModuleSections
size_t UnloadModuleSections(const lldb::ModuleSP &module_sp)
Definition: Target.cpp:2955
lldb_private::LoadDependentFiles
LoadDependentFiles
Definition: lldb-private-enumerations.h:228
lldb_private::TargetProperties::GetMaximumSizeOfStringSummary
uint32_t GetMaximumSizeOfStringSummary() const
Definition: Target.cpp:4423
lldb_private::eImportStdModuleTrue
@ eImportStdModuleTrue
Definition: Target.h:65
lldb_private::Target::CalculateThread
lldb::ThreadSP CalculateThread() override
Definition: Target.cpp:2274
lldb_private::Scalar
Definition: Scalar.h:34
lldb_private::eImportStdModuleFallback
@ eImportStdModuleFallback
Definition: Target.h:64
lldb_private::EvaluateExpressionOptions::DoesCoerceToId
bool DoesCoerceToId() const
Definition: Target.h:307
lldb_private::Target::GetExecutableModulePointer
Module * GetExecutableModulePointer()
Definition: Target.cpp:1383
Architecture.h
lldb_private::TargetStats
A class that represents statistics for a since lldb_private::Target.
Definition: Statistics.h:130
lldb_private::Target::StopHook::HandleStop
virtual StopHookResult HandleStop(ExecutionContext &exe_ctx, lldb::StreamSP output)=0
lldb_private::TargetProperties::GetEnableSyntheticValue
bool GetEnableSyntheticValue() const
Definition: Target.cpp:4396
lldb_private::Target::CalculateProcess
lldb::ProcessSP CalculateProcess() override
Definition: Target.cpp:2272
lldb_private::Target::DisableAllBreakpoints
void DisableAllBreakpoints(bool internal_also=false)
Definition: Target.cpp:917
lldb_private::eLoadScriptFromSymFileFalse
@ eLoadScriptFromSymFileFalse
Definition: Target.h:52
lldb_private::Target::REPLMap
std::map< lldb::LanguageType, lldb::REPLSP > REPLMap
Definition: Target.h:1528
lldb_private::EventData
Definition: Event.h:36
lldb_private::Target::GetExecutableModule
lldb::ModuleSP GetExecutableModule()
Gets the module for the main executable.
Definition: Target.cpp:1369
lldb_private::EvaluateExpressionOptions::SetExecutionPolicy
void SetExecutionPolicy(ExecutionPolicy policy=eExecutionPolicyAlways)
Definition: Target.h:299
lldb_private::Target::BreakpointNameList
std::map< ConstString, BreakpointName * > BreakpointNameList
Definition: Target.h:1514
lldb_private::TargetProperties::GetMemoryModuleLoadLevel
MemoryModuleLoadLevel GetMemoryModuleLoadLevel() const
Definition: Target.cpp:4539
lldb_private::Target::ClearDummySignals
void ClearDummySignals(Args &signal_names)
Clear the dummy signals in signal_names from the target, or all signals if signal_names is empty.
Definition: Target.cpp:3443
lldb_private::EvaluateExpressionOptions::GetPrefix
const char * GetPrefix() const
Definition: Target.h:309
lldb_private::Target::AddBreakpoint
void AddBreakpoint(lldb::BreakpointSP breakpoint_sp, bool internal)
Definition: Target.cpp:664
lldb_private::EvaluateExpressionOptions::SetIsForUtilityExpr
void SetIsForUtilityExpr(bool b)
Definition: Target.h:432
lldb_private::TargetProperties::~TargetProperties
~TargetProperties() override
lldb_private::Target::ClearAllWatchpointHistoricValues
bool ClearAllWatchpointHistoricValues()
Definition: Target.cpp:1267
lldb_private::Target::StopHookCommandLine::m_commands
StringList m_commands
Definition: Target.h:1318
lldb_private::TargetProperties::SetDisableASLR
void SetDisableASLR(bool b)
Definition: Target.cpp:4108
lldb_private::Target::Arch::operator=
const Arch & operator=(const ArchSpec &spec)
Definition: Target.cpp:79
lldb_private::eDynamicClassInfoHelperRealizedClassesStruct
@ eDynamicClassInfoHelperRealizedClassesStruct
Definition: Target.h:70
lldb_private::EvaluateExpressionOptions::DoesIgnoreBreakpoints
bool DoesIgnoreBreakpoints() const
Definition: Target.h:326
lldb_private::EvaluateExpressionOptions::SetTrapExceptions
void SetTrapExceptions(bool b)
Definition: Target.h:381
lldb_private::EvaluateExpressionOptions
Definition: Target.h:277
lldb_private::TargetProperties::GetLoadScriptFromSymbolFile
LoadScriptFromSymFile GetLoadScriptFromSymbolFile() const
Definition: Target.cpp:4519
lldb_private::Target::m_valid
bool m_valid
This records the last natural stop at which we ran a stop-hook.
Definition: Target.h:1538
lldb_private::TargetProperties::m_experimental_properties_up
std::unique_ptr< TargetExperimentalProperties > m_experimental_properties_up
Definition: Target.h:273
lldb_private::TargetProperties::GetInjectLocalVariables
bool GetInjectLocalVariables(ExecutionContext *exe_ctx) const
Definition: Target.cpp:4034
lldb_private::EvaluateExpressionOptions::SetPoundLine
void SetPoundLine(const char *path, uint32_t line) const
Definition: Target.h:400
lldb::LanguageType
LanguageType
Programming language type.
Definition: lldb-enumerations.h:436
lldb_private::EvaluateExpressionOptions::m_repl
bool m_repl
Definition: Target.h:446
lldb_private::Target::StopHookScripted
Definition: Target.h:1327
lldb_private::TargetList
Definition: TargetList.h:21
lldb_private::Target::StopHook::GetAutoContinue
bool GetAutoContinue() const
Definition: Target.h:1288
lldb_private::eLoadDependentsDefault
@ eLoadDependentsDefault
Definition: lldb-private-enumerations.h:229
lldb_private::EvaluateExpressionOptions::SetCancelCallback
void SetCancelCallback(lldb::ExpressionCancelCallback callback, void *baton)
Definition: Target.h:387
lldb_private::Target::m_watchpoint_list
WatchpointList m_watchpoint_list
Definition: Target.h:1518
lldb_private::Target::StopHook::GetTarget
lldb::TargetSP & GetTarget()
Definition: Target.h:1257
lldb_private::Module
Definition: Module.h:85
lldb_private::Target::StopHookScripted::m_extra_args
StructuredDataImpl m_extra_args
This holds the dictionary of keys & values that can be used to parametrize any given callback's behav...
Definition: Target.h:1343
lldb_private::Target::GetScratchTypeSystemForLanguage
llvm::Expected< TypeSystem & > GetScratchTypeSystemForLanguage(lldb::LanguageType language, bool create_on_demand=true)
Definition: Target.cpp:2296
lldb_private::Target::GetReasonableReadSize
lldb::addr_t GetReasonableReadSize(const Address &addr)
Return a recommended size for memory reads at addr, optimizing for cache usage.
Definition: Target.cpp:1941
lldb_private::Target::GetImageSearchPathList
PathMappingList & GetImageSearchPathList()
Definition: Target.cpp:2283
lldb_private::Target::StopHookCommandLine::SetActionFromString
void SetActionFromString(const std::string &strings)
Definition: Target.cpp:3596
lldb_private::Target::TargetEventData::GetEventDataFromEvent
static const TargetEventData * GetEventDataFromEvent(const Event *event_ptr)
Definition: Target.cpp:4719
lldb_private::ValueList
Definition: Value.h:157
lldb_private::Target::m_platform_sp
lldb::PlatformSP m_platform_sp
The platform for this target.
Definition: Target.h:1499
lldb_private::BreakpointName
Definition: BreakpointName.h:30
lldb_private::Target::CreateExceptionBreakpoint
lldb::BreakpointSP CreateExceptionBreakpoint(enum lldb::LanguageType language, bool catch_bp, bool throw_bp, bool internal, Args *additional_args=nullptr, Status *additional_args_error=nullptr)
Definition: Target.cpp:602
Disassembler.h
lldb_private::eDynamicClassInfoHelperGetRealizedClassList
@ eDynamicClassInfoHelperGetRealizedClassList
Definition: Target.h:72
lldb_private::TargetProperties::SetDebugUtilityExpression
void SetDebugUtilityExpression(bool debug)
Definition: Target.cpp:4688
lldb_private::UserExpression
Definition: UserExpression.h:35
lldb_private::TargetProperties::InputPathValueChangedCallback
void InputPathValueChangedCallback()
Definition: Target.cpp:4639
lldb_private::Target::GetTargetFromContexts
static Target * GetTargetFromContexts(const ExecutionContext *exe_ctx_ptr, const SymbolContext *sc_ptr)
Definition: Target.cpp:2461
lldb_private::Target::m_scratch_type_system_map
TypeSystemMap m_scratch_type_system_map
Definition: Target.h:1526
lldb_private::eLoadScriptFromSymFileTrue
@ eLoadScriptFromSymFileTrue
Definition: Target.h:51
lldb_private::Target::ReadMemoryFromFileCache
size_t ReadMemoryFromFileCache(const Address &addr, void *dst, size_t dst_len, Status &error)
Definition: Target.cpp:1711
lldb_private::Target::DummySignalValues::notify
LazyBool notify
Definition: Target.h:1437
lldb_private::Stream
Definition: Stream.h:28
lldb_private::Target::GetWatchpointList
WatchpointList & GetWatchpointList()
Definition: Target.h:740
lldb_private::Args
Definition: Args.h:33
lldb_private::Target::CreateBreakpoint
lldb::BreakpointSP CreateBreakpoint(const FileSpecList *containingModules, const FileSpec &file, uint32_t line_no, uint32_t column, lldb::addr_t offset, LazyBool check_inlines, LazyBool skip_prologue, bool internal, bool request_hardware, LazyBool move_to_nearest_code)
Definition: Target.cpp:351
lldb::addr_t
uint64_t addr_t
Definition: lldb-types.h:83
lldb_private::EvaluateExpressionOptions::m_one_thread_timeout
Timeout< std::micro > m_one_thread_timeout
Definition: Target.h:458
lldb_private::EvaluateExpressionOptions::m_generate_debug_info
bool m_generate_debug_info
Definition: Target.h:447
lldb_private::StackFrameRecognizerManager
Class that provides a registry of known stack frame recognizers.
Definition: StackFrameRecognizer.h:101
lldb_private::LazyBool
LazyBool
Definition: lldb-private-enumerations.h:115
lldb_private::Target::GetBreakpointList
BreakpointList & GetBreakpointList(bool internal=false)
Definition: Target.cpp:309
lldb_private::eExecutionPolicyAlways
@ eExecutionPolicyAlways
Definition: lldb-private-enumerations.h:141
lldb_private::EvaluateExpressionOptions::GetAutoApplyFixIts
bool GetAutoApplyFixIts() const
Definition: Target.h:422
lldb_private::Target::SerializeBreakpointsToFile
Status SerializeBreakpointsToFile(const FileSpec &file, const BreakpointIDList &bp_ids, bool append)
Definition: Target.cpp:1012
lldb_private::Target::GetDebugger
Debugger & GetDebugger()
Definition: Target.h:1030
lldb_private::Target::FinalizeFileActions
void FinalizeFileActions(ProcessLaunchInfo &info)
Definition: Target.cpp:3295
lldb_private::Target::DidExec
void DidExec()
Called as the last function in Process::DidExec().
Definition: Target.cpp:1412
lldb_private::Target::m_source_manager_up
lldb::SourceManagerUP m_source_manager_up
Definition: Target.h:1531
lldb_private::EvaluateExpressionOptions::m_stop_others
bool m_stop_others
Definition: Target.h:443
lldb_private::Target::ResolveLoadAddress
bool ResolveLoadAddress(lldb::addr_t load_addr, Address &so_addr, uint32_t stop_id=SectionLoadHistory::eStopIDNow)
Definition: Target.cpp:2915
lldb_private::SymbolContext
Definition: SymbolContext.h:33
lldb_private::Target
Definition: Target.h:469
lldb_private::Target::StopHook::m_active
bool m_active
Definition: Target.h:1298
lldb_private::TargetProperties::GetMaximumNumberOfChildrenToDisplay
uint32_t GetMaximumNumberOfChildrenToDisplay() const
Definition: Target.cpp:4408
lldb_private::EvaluateExpressionOptions::SetRetriesWithFixIts
void SetRetriesWithFixIts(uint64_t number_of_retries)
Definition: Target.h:424
lldb_private::EvaluateExpressionOptions::GetREPLEnabled
bool GetREPLEnabled() const
Definition: Target.h:383
lldb_private::Target::GetFunctionCallerForLanguage
FunctionCaller * GetFunctionCallerForLanguage(lldb::LanguageType language, const CompilerType &return_type, const Address &function_address, const ValueList &arg_value_list, const char *name, Status &error)
Definition: Target.cpp:2390
lldb_private::TargetProperties::GetStandardErrorPath
FileSpec GetStandardErrorPath() const
Definition: Target.cpp:4455
lldb_private::Target::m_debugger
Debugger & m_debugger
Definition: Target.h:1498
lldb_private::Target::StopHookCommandLine::GetSubclassDescription
void GetSubclassDescription(Stream *s, lldb::DescriptionLevel level) const override
Definition: Target.cpp:3577
lldb_private::Target::CreateProcess
const lldb::ProcessSP & CreateProcess(lldb::ListenerSP listener_sp, llvm::StringRef plugin_name, const FileSpec *crash_file, bool can_connect)
Definition: Target.cpp:205
lldb_private::EvaluateExpressionOptions::SetResultIsInternal
void SetResultIsInternal(bool b)
Definition: Target.h:416
lldb_private::Target::GetImages
const ModuleList & GetImages() const
Get accessor for the images for this process.
Definition: Target.h:947
lldb_private::AddressClass::eInvalid
@ eInvalid
lldb_private::Target::m_private_mutex
std::recursive_mutex m_private_mutex
When the private state thread calls SB API's - usually because it is running OS plugin or Python Thre...
Definition: Target.h:1507
lldb_private::Target::StopHook::StopHookResult::RequestContinue
@ RequestContinue
lldb_private::Target::GetPersistentVariable
lldb::ExpressionVariableSP GetPersistentVariable(ConstString name)
Definition: Target.cpp:2539
lldb_private::TargetProperties::SetDisableSTDIO
void SetDisableSTDIO(bool b)
Definition: Target.cpp:4141
lldb_private::EvaluateExpressionOptions::default_timeout
static constexpr std::chrono::milliseconds default_timeout
Definition: Target.h:287
lldb_private::TargetProperties::CheckJITObjectsDir
void CheckJITObjectsDir()
Definition: Target.cpp:4363
lldb_private::EvaluateExpressionOptions::GetGenerateDebugInfo
bool GetGenerateDebugInfo() const
Definition: Target.h:371
Broadcaster.h
lldb_private::EvaluateExpressionOptions::EvaluateExpressionOptions
EvaluateExpressionOptions()=default
lldb_private::Target::StopHook::m_specifier_sp
lldb::SymbolContextSpecifierSP m_specifier_sp
Definition: Target.h:1296
lldb_private::eLoadScriptFromSymFileWarn
@ eLoadScriptFromSymFileWarn
Definition: Target.h:53
lldb_private::Target::TargetEventData::GetFlavorString
static ConstString GetFlavorString()
Definition: Target.cpp:4704
lldb_private::Expression::ResultType
ResultType
Definition: Expression.h:35
lldb_private::TargetProperties::GetDisableSTDIO
bool GetDisableSTDIO() const
Definition: Target.cpp:4135
lldb_private::Target::GetSuppressStopHooks
bool GetSuppressStopHooks()
Definition: Target.h:1377
lldb_private::Target::IgnoreWatchpointByID
bool IgnoreWatchpointByID(lldb::watch_id_t watch_id, uint32_t ignore_count)
Definition: Target.cpp:1353
lldb_private::EvaluateExpressionOptions::m_result_is_internal
bool m_result_is_internal
Definition: Target.h:449
lldb_private::Target::Arch::Arch
Arch(const ArchSpec &spec)
Definition: Target.cpp:75
lldb_private::Properties
Definition: UserSettingsController.h:33
lldb_private::Target::GetStopHookByID
StopHookSP GetStopHookByID(lldb::user_id_t uid)
Definition: Target.cpp:2662
lldb_private::Target::StopHook::GetSubclassDescription
virtual void GetSubclassDescription(Stream *s, lldb::DescriptionLevel level) const =0
lldb_private::Target::GetPlatform
lldb::PlatformSP GetPlatform()
Definition: Target.h:1403
lldb_private::Target::eBroadcastBitWatchpointChanged
@ eBroadcastBitWatchpointChanged
Definition: Target.h:483
lldb_private::EvaluateExpressionOptions::GetUseDynamic
lldb::DynamicValueType GetUseDynamic() const
Definition: Target.h:336
BreakpointList.h
lldb_private::Target::m_next_persistent_variable_index
unsigned m_next_persistent_variable_index
Definition: Target.h:1541
lldb_private::FileSpec
Definition: FileSpec.h:55
lldb_private::Target::GetLastCreatedBreakpoint
lldb::BreakpointSP GetLastCreatedBreakpoint()
Definition: Target.h:630
lldb_private::TargetProperties::SetPreferDynamicValue
bool SetPreferDynamicValue(lldb::DynamicValueType d)
Definition: Target.cpp:4086
error
static llvm::raw_ostream & error(Stream &strm)
Definition: CommandReturnObject.cpp:17
lldb_private::EvaluateExpressionOptions::m_execution_policy
ExecutionPolicy m_execution_policy
Definition: Target.h:435
lldb_private::Target::GetSearchFilterForModule
lldb::SearchFilterSP GetSearchFilterForModule(const FileSpec *containingModule)
Definition: Target.cpp:530
lldb_private::TargetProperties::DisableASLRValueChangedCallback
void DisableASLRValueChangedCallback()
Definition: Target.cpp:4661
lldb_private::TargetProperties::GetPreferDynamicValue
lldb::DynamicValueType GetPreferDynamicValue() const
Definition: Target.cpp:4079
lldb_private::TargetProperties::GetArg0
llvm::StringRef GetArg0() const
Definition: Target.cpp:4163
lldb_private::Target::PrintDummySignals
void PrintDummySignals(Stream &strm, Args &signals)
Print all the signals set in this target.
Definition: Target.cpp:3468
lldb_private::Target::GetStopHookAtIndex
StopHookSP GetStopHookAtIndex(size_t index)
Definition: Target.h:1391
lldb_private::TargetExperimentalProperties
Definition: Target.h:75
lldb_private::Target::ReadCStringFromMemory
size_t ReadCStringFromMemory(const Address &addr, std::string &out_str, Status &error, bool force_live_memory=false)
Definition: Target.cpp:1864
lldb_private::Target::ReadUnsignedIntegerFromMemory
uint64_t ReadUnsignedIntegerFromMemory(const Address &addr, size_t integer_byte_size, uint64_t fail_value, Status &error, bool force_live_memory=false)
Definition: Target.cpp:2032
lldb_private::TargetProperties::GetDisplayRecognizedArguments
bool GetDisplayRecognizedArguments() const
Definition: Target.cpp:4566
lldb_private::eInlineBreakpointsNever
@ eInlineBreakpointsNever
Definition: Target.h:45
lldb_private::eImportStdModuleFalse
@ eImportStdModuleFalse
Definition: Target.h:63
lldb_private::Target::AddDummySignal
void AddDummySignal(llvm::StringRef name, LazyBool pass, LazyBool print, LazyBool stop)
Add a signal to the Target's list of stored signals/actions.
Definition: Target.cpp:3374
ModuleList.h
LLDBAssert.h
lldb_private::TargetProperties
Definition: Target.h:80
lldb_private::Target::m_arch
Arch m_arch
Definition: Target.h:1508
lldb_private::Target::m_images
ModuleList m_images
The list of images for this process (shared libraries and anything dynamically loaded).
Definition: Target.h:1509
lldb_private::TargetProperties::GetSkipPrologue
bool GetSkipPrologue() const
Definition: Target.cpp:4264
lldb_private::Target::CreateSourceRegexBreakpoint
lldb::BreakpointSP CreateSourceRegexBreakpoint(const FileSpecList *containingModules, const FileSpecList *source_file_list, const std::unordered_set< std::string > &function_names, RegularExpression source_regex, bool internal, bool request_hardware, LazyBool move_to_nearest_code)
Definition: Target.cpp:334
lldb_private::ProcessLaunchInfo
Definition: ProcessLaunchInfo.h:31
lldb_private::ModuleList
Definition: ModuleList.h:82
lldb_private::TargetProperties::DetachOnErrorValueChangedCallback
void DetachOnErrorValueChangedCallback()
Definition: Target.cpp:4654
lldb_private::EvaluateExpressionOptions::default_execution_policy
static constexpr ExecutionPolicy default_execution_policy
Definition: Target.h:292
lldb_private::SymbolContextSpecifier
Definition: SymbolContext.h:328
lldb_private::Target::CreateBreakpointsFromFile
Status CreateBreakpointsFromFile(const FileSpec &file, BreakpointIDList &new_bps)
Definition: Target.cpp:1104
lldb_private::ExecutionContextScope
Definition: ExecutionContextScope.h:32
lldb_private::Target::RemoveAllStopHooks
void RemoveAllStopHooks()
Definition: Target.cpp:2660
lldb_private::Target::GetBroadcasterClass
ConstString & GetBroadcasterClass() const override
This needs to be filled in if you are going to register the broadcaster with the broadcaster manager ...
Definition: Target.h:492
lldb_private::Target::GetAPIMutex
std::recursive_mutex & GetAPIMutex()
Definition: Target.cpp:4746
lldb_private::TargetProperties::GetDetachOnError
bool GetDetachOnError() const
Definition: Target.cpp:4124
lldb_private::Target::DummySignalValues::DummySignalValues
DummySignalValues(LazyBool pass, LazyBool notify, LazyBool stop)
Definition: Target.h:1439
lldb_private::Target::GetLastCreatedWatchpoint
lldb::WatchpointSP GetLastCreatedWatchpoint()
Definition: Target.h:736
lldb_private::TargetProperties::SetRunArguments
void SetRunArguments(const Args &args)
Definition: Target.cpp:4180
lldb_private::Target::SetSectionLoadAddress
bool SetSectionLoadAddress(const lldb::SectionSP &section, lldb::addr_t load_addr, bool warn_multiple=false)
Definition: Target.cpp:2925
ThreadSpec.h
lldb_private::Target::EnableAllBreakpoints
void EnableAllBreakpoints(bool internal_also=false)
Definition: Target.cpp:934
lldb_private::TargetProperties::GetInlineStrategy
InlineStrategy GetInlineStrategy() const
Definition: Target.cpp:4157
lldb_private::TargetProperties::GetMaximumDepthOfChildrenToDisplay
std::pair< uint32_t, bool > GetMaximumDepthOfChildrenToDisplay() const
Get the max depth value, augmented with a bool to indicate whether the depth is the default.
Definition: Target.cpp:4415
lldb_private::Target::StopHook::GetThreadSpecifier
ThreadSpec * GetThreadSpecifier()
Definition: Target.h:1278
lldb_private::Target::Arch::GetPlugin
Architecture * GetPlugin() const
Definition: Target.h:1490
lldb_private::EvaluateExpressionOptions::m_cancel_callback_baton
void * m_cancel_callback_baton
Definition: Target.h:460
lldb_private::Target::eBroadcastBitSymbolsChanged
@ eBroadcastBitSymbolsChanged
Definition: Target.h:485
lldb_private::StructuredData::ObjectSP
std::shared_ptr< Object > ObjectSP
Definition: StructuredData.h:59
lldb_private::eDynamicClassInfoHelperAuto
@ eDynamicClassInfoHelperAuto
Definition: Target.h:69
lldb_private::Target::DummySignalValues::DummySignalValues
DummySignalValues()=default
lldb_private::Target::StopHookCommandLine
Definition: Target.h:1304
lldb_private::Target::m_image_search_paths
PathMappingList m_image_search_paths
Definition: Target.h:1525
lldb_private::TargetProperties::RunArgsValueChangedCallback
void RunArgsValueChangedCallback()
Definition: Target.cpp:4629
lldb_private::TargetProperties::UpdateLaunchInfoFromProperties
void UpdateLaunchInfoFromProperties()
Definition: Target.cpp:4021
lldb_private::Target::ClearAllLoadedSections
void ClearAllLoadedSections()
Definition: Target.cpp:2996
lldb_private::Target::EnableAllowedBreakpoints
void EnableAllowedBreakpoints()
Definition: Target.cpp:944
lldb_private::EvaluateExpressionOptions::m_try_others
bool m_try_others
Definition: Target.h:442
lldb_private::EvaluateExpressionOptions::m_retries_with_fixits
uint64_t m_retries_with_fixits
Definition: Target.h:451
lldb_private::TypeSystemMap
Definition: TypeSystem.h:514
lldb_private::Target::GetBreakableLoadAddress
lldb::addr_t GetBreakableLoadAddress(lldb::addr_t addr)
Definition: Target.cpp:2622
lldb_private::EvaluateExpressionOptions::m_coerce_to_id
bool m_coerce_to_id
Definition: Target.h:438
lldb_private::Target::ResolveFileAddress
bool ResolveFileAddress(lldb::addr_t load_addr, Address &so_addr)
Definition: Target.cpp:2920
lldb_private::TargetProperties::SetStandardOutputPath
void SetStandardOutputPath(llvm::StringRef path)
Definition: Target.cpp:4450
lldb_private::Target::CleanupProcess
void CleanupProcess()
Definition: Target.cpp:174
lldb_private::Target::StopHookScripted::~StopHookScripted
~StopHookScripted() override=default
lldb_private::TargetProperties::GetSaveJITObjectsDir
FileSpec GetSaveJITObjectsDir() const
Definition: Target.cpp:4358
lldb_private::Target::TargetEventData::~TargetEventData
~TargetEventData() override
lldb::break_id_t
int32_t break_id_t
Definition: lldb-types.h:88
lldb_private::Target::CreateUtilityFunction
llvm::Expected< std::unique_ptr< UtilityFunction > > CreateUtilityFunction(std::string expression, std::string name, lldb::LanguageType language, ExecutionContext &exe_ctx)
Creates and installs a UtilityFunction for the given language.
Definition: Target.cpp:2414
lldb_private::Target::SetSuppresStopHooks
bool SetSuppresStopHooks(bool suppress)
Definition: Target.h:1371
lldb_private::BreakpointName::Permissions
Definition: BreakpointName.h:32
lldb_private::Target::m_process_sp
lldb::ProcessSP m_process_sp
Definition: Target.h:1523
lldb_private::Target::RunStopHooks
bool RunStopHooks()
Definition: Target.cpp:2690
lldb_private::StringList
Definition: StringList.h:26
lldb_private::Target::DeleteCurrentProcess
void DeleteCurrentProcess()
Definition: Target.cpp:189
lldb_private::ConstString
Definition: ConstString.h:39
lldb_private::Target::StopHook::StopHookKind::CommandBased
@ CommandBased
lldb_private::Target::StopHook::StopHookResult::AlreadyContinued
@ AlreadyContinued
lldb_private::TargetProperties::SetStandardErrorPath
void SetStandardErrorPath(llvm::StringRef path)
Definition: Target.cpp:4460
lldb_private::Target::CreateAddressInModuleBreakpoint
lldb::BreakpointSP CreateAddressInModuleBreakpoint(lldb::addr_t file_addr, bool internal, const FileSpec *file_spec, bool request_hardware)
Definition: Target.cpp:439
lldb_private::BreakpointOptions
Definition: BreakpointOptions.h:27
lldb_private::Target::GetCallableLoadAddress
lldb::addr_t GetCallableLoadAddress(lldb::addr_t load_addr, AddressClass addr_class=AddressClass::eInvalid) const
Get load_addr as a callable code load address for this target.
Definition: Target.cpp:2607
lldb_private::Target::DisableAllWatchpoints
bool DisableAllWatchpoints(bool end_to_end=true)
Definition: Target.cpp:1200
lldb_private::Target::GetImages
ModuleList & GetImages()
Definition: Target.h:949
lldb_private::EvaluateExpressionOptions::SetColorizeErrors
void SetColorizeErrors(bool b)
Definition: Target.h:377
lldb_private::EvaluateExpressionOptions::m_ansi_color_errors
bool m_ansi_color_errors
Definition: Target.h:448
lldb_private::Target::m_is_dummy_target
bool m_is_dummy_target
Used to not run stop hooks for expressions.
Definition: Target.h:1540
lldb_private::Target::AddNameToBreakpoint
void AddNameToBreakpoint(BreakpointID &id, const char *name, Status &error)
Definition: Target.cpp:687
lldb_private::Target::NotifyModuleUpdated
void NotifyModuleUpdated(const ModuleList &module_list, const lldb::ModuleSP &old_module_sp, const lldb::ModuleSP &new_module_sp) override
Definition: Target.cpp:1620
lldb_private::Target::Dump
void Dump(Stream *s, lldb::DescriptionLevel description_level)
Dump a description of this object to a Stream.
Definition: Target.cpp:155
lldb_private::Target::GetABIName
llvm::StringRef GetABIName() const
Returns the name of the target's ABI plugin.
Definition: Target.cpp:298
lldb_private::EvaluateExpressionOptions::SetTryAllThreads
void SetTryAllThreads(bool try_others=true)
Definition: Target.h:357
lldb_private::EvaluateExpressionOptions::m_keep_in_memory
bool m_keep_in_memory
Definition: Target.h:441
lldb_private::StructuredDataImpl
Definition: StructuredDataImpl.h:26
lldb_private::TargetProperties::GetRunArguments
bool GetRunArguments(Args &args) const
Definition: Target.cpp:4175
lldb_private::Target::m_last_created_watchpoint
lldb::WatchpointSP m_last_created_watchpoint
Definition: Target.h:1519
lldb_private::Target::m_internal_breakpoint_list
BreakpointList m_internal_breakpoint_list
Definition: Target.h:1513
lldb_private::Target::StopHookSP
std::shared_ptr< StopHook > StopHookSP
Definition: Target.h:1355
lldb_private::Target::NotifyModuleAdded
void NotifyModuleAdded(const ModuleList &module_list, const lldb::ModuleSP &module_sp) override
Implementing of ModuleList::Notifier.
Definition: Target.cpp:1600
lldb_private::Target::ApplyNameToBreakpoints
void ApplyNameToBreakpoints(BreakpointName &bp_name)
Definition: Target.cpp:763
lldb::ExpressionEvaluationPhase
ExpressionEvaluationPhase
Expression Evaluation Stages.
Definition: lldb-enumerations.h:971
lldb_private::TargetProperties::Arg0ValueChangedCallback
void Arg0ValueChangedCallback()
Definition: Target.cpp:4625
lldb_private::Target::StopHook::StopHookResult::KeepStopped
@ KeepStopped
lldb_private::Target::StopHookCollection
std::map< lldb::user_id_t, StopHookSP > StopHookCollection
Definition: Target.h:1533
lldb_private::TargetProperties::GetMoveToNearestCode
bool GetMoveToNearestCode() const
Definition: Target.cpp:4073
lldb::DynamicValueType
DynamicValueType
Definition: lldb-enumerations.h:494
lldb_private::TargetProperties::GetExpressionPrefixContents
llvm::StringRef GetExpressionPrefixContents()
Definition: Target.cpp:4474
lldb_private::Debugger
Definition: Debugger.h:74
lldb_private::eLoadCWDlldbinitWarn
@ eLoadCWDlldbinitWarn
Definition: Target.h:59
lldb_private::SectionLoadList
Definition: SectionLoadList.h:22
lldb_private::TargetProperties::InheritTCCValueChangedCallback
void InheritTCCValueChangedCallback()
Definition: Target.cpp:4668
lldb_private::Target::DisableAllowedBreakpoints
void DisableAllowedBreakpoints()
Definition: Target.cpp:927
lldb_private::Target::CreateTrace
llvm::Expected< lldb::TraceSP > CreateTrace()
Create a Trace object for the current target using the using the default supported tracing technology...
Definition: Target.cpp:3181
lldb_private::Target::GetPersistentExpressionStateForLanguage
PersistentExpressionState * GetPersistentExpressionStateForLanguage(lldb::LanguageType language)
Definition: Target.cpp:2353
lldb_private::Target::ProcessIsValid
bool ProcessIsValid()
Definition: Target.cpp:785
string
string(SUBSTRING ${p} 10 -1 pStripped) if($
Definition: Plugins/CMakeLists.txt:40
lldb::watch_id_t
int32_t watch_id_t
Definition: lldb-types.h:89
lldb_private::eLoadCWDlldbinitTrue
@ eLoadCWDlldbinitTrue
Definition: Target.h:57
lldb_private::TargetProperties::EnvVarsValueChangedCallback
void EnvVarsValueChangedCallback()
Definition: Target.cpp:4635
lldb_private::EvaluateExpressionOptions::SetUnwindOnError
void SetUnwindOnError(bool unwind=false)
Definition: Target.h:324
lldb_private::EvaluateExpressionOptions::SetKeepInMemory
void SetKeepInMemory(bool keep=true)
Definition: Target.h:334
lldb_private::Target::CreateWatchpoint
lldb::WatchpointSP CreateWatchpoint(lldb::addr_t addr, size_t size, const CompilerType *type, uint32_t kind, Status &error)
Definition: Target.cpp:810
TypeSystem.h
lldb_private::Target::m_breakpoint_names
BreakpointNameList m_breakpoint_names
Definition: Target.h:1515
lldb_private::Target::SetTrace
void SetTrace(const lldb::TraceSP &trace_sp)
Set the Trace object containing processor trace information of this target.
Definition: Target.cpp:3177
lldb_private::EvaluateExpressionOptions::IsForUtilityExpr
bool IsForUtilityExpr() const
Definition: Target.h:430
lldb_private::TargetProperties::SetInjectLocalVariables
void SetInjectLocalVariables(ExecutionContext *exe_ctx, bool b)
Definition: Target.cpp:4047
lldb_private::Target::GetOpcodeLoadAddress
lldb::addr_t GetOpcodeLoadAddress(lldb::addr_t load_addr, AddressClass addr_class=AddressClass::eInvalid) const
Get load_addr as an opcode for this target.
Definition: Target.cpp:2615
lldb_private::Target::ReadStringFromMemory
size_t ReadStringFromMemory(const Address &addr, char *dst, size_t max_bytes, Status &error, size_t type_width, bool force_live_memory=true)
Read a NULL terminated string from memory.
Definition: Target.cpp:1954
lldb_private::TargetProperties::ErrorPathValueChangedCallback
void ErrorPathValueChangedCallback()
Definition: Target.cpp:4649
lldb_private::TargetProperties::GetDisplayRuntimeSupportValues
bool GetDisplayRuntimeSupportValues() const
Definition: Target.cpp:4556
lldb_private::ThreadSpec
Definition: ThreadSpec.h:33
lldb_private::TargetProperties::SetProcessLaunchInfo
void SetProcessLaunchInfo(const ProcessLaunchInfo &launch_info)
Definition: Target.cpp:4580
lldb_private::Target::m_mutex
std::recursive_mutex m_mutex
An API mutex that is used by the lldb::SB* classes make the SB interface thread safe.
Definition: Target.h:1500
lldb_private::EvaluateExpressionOptions::m_running_utility_expression
bool m_running_utility_expression
True if the executed code should be treated as utility code that is only used by LLDB internally.
Definition: Target.h:454
lldb_private::TargetProperties::GetEnableAutoApplyFixIts
bool GetEnableAutoApplyFixIts() const
Definition: Target.cpp:4340
lldb_private::SectionLoadHistory
Definition: SectionLoadHistory.h:19
lldb_private::ProcessAttachInfo
Definition: Process.h:113
lldb_private::Target::DummySignalValues::stop
LazyBool stop
Definition: Target.h:1438
lldb_private::Target::m_breakpoint_list
BreakpointList m_breakpoint_list
Definition: Target.h:1512
lldb_private::Target::SetExecutableModule
void SetExecutableModule(lldb::ModuleSP &module_sp, LoadDependentFiles load_dependent_files=eLoadDependentsDefault)
Set the main executable module.
Definition: Target.cpp:1418
lldb_private::Target::ResetSignalFromDummy
static bool ResetSignalFromDummy(lldb::UnixSignalsSP signals_sp, const DummySignalElement &element)
Definition: Target.cpp:3416
lldb_private::TargetProperties::GetProcessLaunchInfo
const ProcessLaunchInfo & GetProcessLaunchInfo() const
Definition: Target.cpp:4576
lldb_private::Target::TargetEventData::m_module_list
ModuleList m_module_list
Definition: Target.h:527
lldb_private::eDynamicClassInfoHelperCopyRealizedClassList
@ eDynamicClassInfoHelperCopyRealizedClassList
Definition: Target.h:71
lldb_private::TargetProperties::GetDebugFileSearchPaths
FileSpecList GetDebugFileSearchPaths()
Definition: Target.cpp:4303
lldb_private::Target::eBroadcastBitModulesUnloaded
@ eBroadcastBitModulesUnloaded
Definition: Target.h:482
lldb_private::EvaluateExpressionOptions::SetIgnoreBreakpoints
void SetIgnoreBreakpoints(bool ignore=false)
Definition: Target.h:328
lldb_private::TargetExperimentalProperties::TargetExperimentalProperties
TargetExperimentalProperties()
Definition: Target.cpp:3950
lldb_private::Target::GetStaticBroadcasterClass
static ConstString & GetStaticBroadcasterClass()
Definition: Target.cpp:85
lldb_private::Target::Attach
Status Attach(ProcessAttachInfo &attach_info, Stream *stream)
Definition: Target.cpp:3212
lldb_private::Target::SettingsTerminate
static void SettingsTerminate()
Definition: Target.cpp:2440
lldb_private::Target::GetProcessSP
const lldb::ProcessSP & GetProcessSP() const
Definition: Target.cpp:217
lldb_private::TargetProperties::GetDebugUtilityExpression
bool GetDebugUtilityExpression() const
Definition: Target.cpp:4682
lldb_private::Target::DisableWatchpointByID
bool DisableWatchpointByID(lldb::watch_id_t watch_id)
Definition: Target.cpp:1299
lldb_private::Target::Launch
Status Launch(ProcessLaunchInfo &launch_info, Stream *stream)
Definition: Target.cpp:2998
lldb_private::Target::GetTraceOrCreate
llvm::Expected< lldb::TraceSP > GetTraceOrCreate()
If a Trace object is present, this returns it, otherwise a new Trace is created with Trace::CreateTra...
Definition: Target.cpp:3206
lldb_private::Target::GetArchitecturePlugin
Architecture * GetArchitecturePlugin() const
Definition: Target.h:1028
lldb_private::Target::GetDefaultExecutableSearchPaths
static FileSpecList GetDefaultExecutableSearchPaths()
Definition: Target.cpp:2442
lldb_private::SectionLoadHistory::GetCurrentSectionLoadList
SectionLoadList & GetCurrentSectionLoadList()
Definition: SectionLoadHistory.cpp:95
lldb_private::Target::StopHook::SetSpecifier
void SetSpecifier(SymbolContextSpecifier *specifier)
Definition: Target.cpp:3511
lldb_private::ModuleSpec
Definition: ModuleSpec.h:27
lldb_private::Target::GetArchitecture
const ArchSpec & GetArchitecture() const
Definition: Target.h:989
lldb_private::Target::SetSectionUnloaded
bool SetSectionUnloaded(const lldb::SectionSP &section_sp)
Definition: Target.cpp:2974
lldb_private::EvaluateExpressionOptions::SetOneThreadTimeout
void SetOneThreadTimeout(const Timeout< std::micro > &timeout)
Definition: Target.h:351
lldb_private::Target::GetStopHookSize
size_t GetStopHookSize()
lldb_private::Status
Definition: Status.h:44
lldb_private::EvaluateExpressionOptions::m_trap_exceptions
bool m_trap_exceptions
Definition: Target.h:445
lldb_private::WatchpointList
Definition: WatchpointList.h:27
lldb_private::ValueObject
ValueObject:
Definition: ValueObject.h:105
lldb_private::TargetProperties::GetEnvironment
Environment GetEnvironment() const
Definition: Target.cpp:4215
lldb_private::EvaluateExpressionOptions::GetLanguage
lldb::LanguageType GetLanguage() const
Definition: Target.h:303
lldb_private::Target::CreateStopHook
StopHookSP CreateStopHook(StopHook::StopHookKind kind)
Add an empty stop hook to the Target's stop hook list, and returns a shared pointer to it in new_hook...
Definition: Target.cpp:2633
lldb_private::Timeout< std::micro >
lldb_private::TargetProperties::GetLoadCWDlldbinitFile
LoadCWDlldbinitFile GetLoadCWDlldbinitFile() const
Definition: Target.cpp:4526
lldb_private::Target::GetDefaultArchitecture
static ArchSpec GetDefaultArchitecture()
Definition: Target.cpp:2450
lldb_private::Target::ResetBreakpointHitCounts
void ResetBreakpointHitCounts()
Resets the hit count of all breakpoints.
Definition: Target.cpp:1008
lldb_private::Target::ReadMemory
size_t ReadMemory(const Address &addr, void *dst, size_t dst_len, Status &error, bool force_live_memory=false, lldb::addr_t *load_addr_ptr=nullptr)
Definition: Target.cpp:1743
lldb_private::Target::Install
Status Install(ProcessLaunchInfo *launch_info)
Definition: Target.cpp:2867
lldb_private::Target::IsValid
bool IsValid()
Definition: Target.h:614
lldb_private::Target::AddBreakpointName
void AddBreakpointName(BreakpointName *bp_name)
Definition: Target.cpp:713
lldb_private::EvaluateExpressionOptions::m_pound_line_line
uint32_t m_pound_line_line
Definition: Target.h:465
lldb_private::EvaluateExpressionOptions::m_use_dynamic
lldb::DynamicValueType m_use_dynamic
Definition: Target.h:456
lldb::eLanguageTypeUnknown
@ eLanguageTypeUnknown
Unknown or invalid language value.
Definition: lldb-enumerations.h:437
lldb_private::Target::eBroadcastBitBreakpointChanged
@ eBroadcastBitBreakpointChanged
Definition: Target.h:480
lldb_private::Target::UpdateSignalsFromDummy
void UpdateSignalsFromDummy(lldb::UnixSignalsSP signals_sp, lldb::StreamSP warning_stream_sp)
Updates the signals in signals_sp using the stored dummy signals.
Definition: Target.cpp:3431
lldb_private::TargetProperties::GetEnableAutoImportClangModules
bool GetEnableAutoImportClangModules() const
Definition: Target.cpp:4321
lldb_private::Target::SetREPL
void SetREPL(lldb::LanguageType language, lldb::REPLSP repl_sp)
Definition: Target.cpp:269
lldb_private::Target::GetREPL
lldb::REPLSP GetREPL(Status &err, lldb::LanguageType language, const char *repl_options, bool can_create)
Definition: Target.cpp:219
uint32_t
lldb_private::Target::ImageSearchPathsChanged
static void ImageSearchPathsChanged(const PathMappingList &path_list, void *baton)
Definition: Target.cpp:2287
lldb_private::Target::CalculateExecutionContext
void CalculateExecutionContext(ExecutionContext &exe_ctx) override
Reconstruct the object's execution context into sc.
Definition: Target.cpp:2278
lldb_private::EvaluateExpressionOptions::GetStopOthers
bool GetStopOthers() const
Definition: Target.h:359
lldb_private::Target::GetStatistics
TargetStats & GetStatistics()
Definition: Target.h:1572
lldb_private::EvaluateExpressionOptions::SetUseDynamic
void SetUseDynamic(lldb::DynamicValueType dynamic=lldb::eDynamicCanRunTarget)
Definition: Target.h:339
lldb_private::PathMappingList
Definition: PathMappingList.h:20
UserSettingsController.h
lldb_private::EvaluateExpressionOptions::SetCoerceToId
void SetCoerceToId(bool coerce=true)
Definition: Target.h:320
lldb_private::Target::RemoveAllBreakpoints
void RemoveAllBreakpoints(bool internal_also=false)
Definition: Target.cpp:905
lldb_private::TargetProperties::m_target
Target * m_target
Definition: Target.h:274
lldb_private::Address
Definition: Address.h:59
lldb_private::Target::GetPersistentSymbol
lldb::addr_t GetPersistentSymbol(ConstString name)
Definition: Target.cpp:2555
lldb_private::Target::ModulesDidLoad
void ModulesDidLoad(ModuleList &module_list)
Definition: Target.cpp:1636
lldb_private::eInlineBreakpointsAlways
@ eInlineBreakpointsAlways
Definition: Target.h:47
lldb_private::TargetProperties::AppendExecutableSearchPaths
void AppendExecutableSearchPaths(const FileSpec &)
Definition: Target.cpp:4285
lldb_private::Target::EvaluateExpression
lldb::ExpressionResults EvaluateExpression(llvm::StringRef expression, ExecutionContextScope *exe_scope, lldb::ValueObjectSP &result_valobj_sp, const EvaluateExpressionOptions &options=EvaluateExpressionOptions(), std::string *fixed_expression=nullptr, ValueObject *ctx_obj=nullptr)
Definition: Target.cpp:2475
lldb_private::SectionLoadHistory::eStopIDNow
@ eStopIDNow
Definition: SectionLoadHistory.h:24
lldb_private::Target::StopHook
Definition: Target.h:1245
lldb_private::EvaluateExpressionOptions::m_prefix
std::string m_prefix
Definition: Target.h:437
lldb_private::TargetProperties::GetImportStdModule
ImportStdModule GetImportStdModule() const
Definition: Target.cpp:4327
lldb_private::BreakpointID
Definition: BreakpointID.h:22
lldb_private::TargetProperties::GetHexImmediateStyle
Disassembler::HexImmediateStyle GetHexImmediateStyle() const
Definition: Target.cpp:4532
lldb_private::TargetProperties::m_launch_info
ProcessLaunchInfo m_launch_info
Definition: Target.h:272
lldb_private::EvaluateExpressionOptions::m_debug
bool m_debug
Definition: Target.h:444
lldb_private::Target::GetSearchFilterForModuleAndCUList
lldb::SearchFilterSP GetSearchFilterForModuleAndCUList(const FileSpecList *containingModules, const FileSpecList *containingSourceFiles)
Definition: Target.cpp:565
lldb_private::Target::m_stop_hooks
StopHookCollection m_stop_hooks
Definition: Target.h:1534
lldb_private::Disassembler::HexImmediateStyle
HexImmediateStyle
Definition: Disassembler.h:398
ExecutionContextScope.h
lldb_private::EvaluateExpressionOptions::m_language
lldb::LanguageType m_language
Definition: Target.h:436
lldb_private::Target::TargetEventData::operator=
const TargetEventData & operator=(const TargetEventData &)=delete
lldb_private::Target::StopHook::IsActive
bool IsActive()
Definition: Target.h:1280
lldb_private::Target::StopHookScripted::StopHookScripted
StopHookScripted(lldb::TargetSP target_sp, lldb::user_id_t uid)
Use CreateStopHook to make a new empty stop hook.
Definition: Target.h:1350
lldb_private::Target::GetSearchFilterForModuleList
lldb::SearchFilterSP GetSearchFilterForModuleList(const FileSpecList *containingModuleList)
Definition: Target.cpp:548
lldb_private::Target::TargetEventData::GetModuleList
const ModuleList & GetModuleList() const
Definition: Target.h:523
ArchSpec.h
lldb_private::Target::IsDummyTarget
bool IsDummyTarget() const
Definition: Target.h:547
lldb_private::Target::ClearAllWatchpointHitCounts
bool ClearAllWatchpointHitCounts()
Definition: Target.cpp:1253
lldb_private::TargetProperties::GetBreakpointsConsultPlatformAvoidList
bool GetBreakpointsConsultPlatformAvoidList()
Definition: Target.cpp:4495
lldb_private::Environment
Definition: Environment.h:18
lldb_private::EvaluateExpressionOptions::GetTryAllThreads
bool GetTryAllThreads() const
Definition: Target.h:355
Timeout.h
lldb_private::eLoadCWDlldbinitFalse
@ eLoadCWDlldbinitFalse
Definition: Target.h:58
lldb_private::EvaluateExpressionOptions::SetGenerateDebugInfo
void SetGenerateDebugInfo(bool b)
Definition: Target.h:373
lldb_private::Target::StopHookScripted::m_implementation_sp
StructuredData::GenericSP m_implementation_sp
This holds the python callback object.
Definition: Target.h:1345
lldb_private::Target::StopHook::ExecutionContextPasses
bool ExecutionContextPasses(const ExecutionContext &exe_ctx)
Definition: Target.cpp:3519
lldb_private::Target::m_stop_hook_next_id
lldb::user_id_t m_stop_hook_next_id
Definition: Target.h:1535
lldb_private::Target::GetScratchTypeSystems
std::vector< TypeSystem * > GetScratchTypeSystems(bool create_on_demand=true)
Definition: Target.cpp:2324
lldb_private::TargetProperties::GetUseFastStepping
bool GetUseFastStepping() const
Definition: Target.cpp:4507
lldb_private::EvaluateExpressionOptions::DoesUnwindOnError
bool DoesUnwindOnError() const
Definition: Target.h:322
lldb_private::Target::SetAllStopHooksActiveState
void SetAllStopHooksActiveState(bool active_state)
Definition: Target.cpp:2683
SectionLoadHistory.h
lldb_private::TargetProperties::GetUserSpecifiedTrapHandlerNames
bool GetUserSpecifiedTrapHandlerNames(Args &args) const
Definition: Target.cpp:4546
lldb_private::TargetProperties::GetStandardOutputPath
FileSpec GetStandardOutputPath() const
Definition: Target.cpp:4445
lldb_private::Target::StopHookScripted::HandleStop
StopHookResult HandleStop(ExecutionContext &exc_ctx, lldb::StreamSP output) override
Definition: Target.cpp:3662
lldb_private::Target::RemoveBreakpointByID
bool RemoveBreakpointByID(lldb::break_id_t break_id)
Definition: Target.cpp:951
lldb_private::Target::TargetEventData::Dump
void Dump(Stream *s) const override
Definition: Target.cpp:4709
lldb_private::Target::GetSectionLoadList
SectionLoadList & GetSectionLoadList()
Definition: Target.h:1102
lldb_private::Target::UndoCreateStopHook
void UndoCreateStopHook(lldb::user_id_t uid)
If you tried to create a stop hook, and that failed, call this to remove the stop hook,...
Definition: Target.cpp:2648
lldb_private::Target::Arch::m_plugin_up
std::unique_ptr< Architecture > m_plugin_up
Definition: Target.h:1494
lldb_private::eExecutionPolicyOnlyWhenNeeded
@ eExecutionPolicyOnlyWhenNeeded
Definition: lldb-private-enumerations.h:139
lldb_private::Target::m_dummy_signals
llvm::StringMap< DummySignalValues > m_dummy_signals
These are used to set the signal state when you don't have a process and more usefully in the Dummy t...
Definition: Target.h:1550
lldb_private::TargetProperties::GetUseHexImmediates
bool GetUseHexImmediates() const
Definition: Target.cpp:4501
lldb_private::TargetProperties::SetInheritTCC
void SetInheritTCC(bool b)
Definition: Target.cpp:4119
StructuredDataImpl.h
lldb_private::eInlineBreakpointsHeaders
@ eInlineBreakpointsHeaders
Definition: Target.h:46
lldb_private::CompilerType
Generic representation of a type in a programming language.
Definition: CompilerType.h:33
lldb_private::Target::StopHook::~StopHook
virtual ~StopHook()=default
lldb_private::EvaluateExpressionOptions::m_ignore_breakpoints
bool m_ignore_breakpoints
Definition: Target.h:440
Statistics.h
lldb_private::Target::GetUserExpressionForLanguage
UserExpression * GetUserExpressionForLanguage(llvm::StringRef expr, llvm::StringRef prefix, lldb::LanguageType language, Expression::ResultType desired_type, const EvaluateExpressionOptions &options, ValueObject *ctx_obj, Status &error)
Definition: Target.cpp:2366
lldb_private::Target::RemoveWatchpointByID
bool RemoveWatchpointByID(lldb::watch_id_t watch_id)
Definition: Target.cpp:1337
lldb_private::Target::StopHookCommandLine::~StopHookCommandLine
~StopHookCommandLine() override=default
lldb_private::Target::GetGlobalProperties
static TargetProperties & GetGlobalProperties()
Definition: Target.cpp:2859
lldb_private::TargetProperties::SetUserSpecifiedTrapHandlerNames
void SetUserSpecifiedTrapHandlerNames(const Args &args)
Definition: Target.cpp:4551
lldb_private::TargetProperties::GetNumberOfRetriesWithFixits
uint64_t GetNumberOfRetriesWithFixits() const
Definition: Target.cpp:4346
lldb::user_id_t
uint64_t user_id_t
Definition: lldb-types.h:84
lldb_private::PersistentExpressionState
Definition: ExpressionVariable.h:203
lldb_private::Target::TargetEventData::TargetEventData
TargetEventData(const lldb::TargetSP &target_sp)
Definition: Target.cpp:4695
lldb_private::Target::TargetEventData::GetFlavor
ConstString GetFlavor() const override
Definition: Target.h:509
lldb_private::Target::StopHook::StopHookResult
StopHookResult
Definition: Target.h:1251
lldb_private::Target::CalculateTarget
lldb::TargetSP CalculateTarget() override
Definition: Target.cpp:2270
lldb_private::EvaluateExpressionOptions::GetExecutionPolicy
ExecutionPolicy GetExecutionPolicy() const
Definition: Target.h:297
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
lldb_private::EvaluateExpressionOptions::GetTrapExceptions
bool GetTrapExceptions() const
Definition: Target.h:379
lldb_private::eLazyBoolCalculate
@ eLazyBoolCalculate
Definition: lldb-private-enumerations.h:115
lldb_private::TargetProperties::GetLanguage
lldb::LanguageType GetLanguage() const
Definition: Target.cpp:4465
lldb_private::Target::NotifyModuleRemoved
void NotifyModuleRemoved(const ModuleList &module_list, const lldb::ModuleSP &module_sp) override
Definition: Target.cpp:1610
lldb_private::TargetProperties::GetMaxZeroPaddingInFloatFormat
uint32_t GetMaxZeroPaddingInFloatFormat() const
Definition: Target.cpp:4402
lldb_private::EvaluateExpressionOptions::GetResultIsInternal
bool GetResultIsInternal() const
Definition: Target.h:418
lldb_private::Target::Arch::GetSpec
const ArchSpec & GetSpec() const
Definition: Target.h:1489
lldb_private::Target::ReadScalarIntegerFromMemory
size_t ReadScalarIntegerFromMemory(const Address &addr, uint32_t byte_size, bool is_signed, Scalar &scalar, Status &error, bool force_live_memory=false)
Definition: Target.cpp:2003
lldb_private::TargetProperties::GetMaximumMemReadSize
uint32_t GetMaximumMemReadSize() const
Definition: Target.cpp:4429
lldb::eDynamicCanRunTarget
@ eDynamicCanRunTarget
Definition: lldb-enumerations.h:496
lldb_private::TargetProperties::GetEnableNotifyAboutFixIts
bool GetEnableNotifyAboutFixIts() const
Definition: Target.cpp:4352
lldb_private::Target::StopHookCommandLine::GetCommands
StringList & GetCommands()
Definition: Target.h:1308
lldb_private::Target::Arch
Definition: Target.h:1484
lldb_private::Target::GetTrace
lldb::TraceSP GetTrace()
Get the Trace object containing processor trace information of this target.
Definition: Target.cpp:3179
lldb_private::Target::m_search_filter_sp
lldb::SearchFilterSP m_search_filter_sp
Definition: Target.h:1524
lldb_private::EvaluateExpressionOptions::InvokeCancelCallback
bool InvokeCancelCallback(lldb::ExpressionEvaluationPhase phase) const
Definition: Target.h:392
lldb_private::EvaluateExpressionOptions::SetDebug
void SetDebug(bool b)
Definition: Target.h:365
lldb_private::Target::LoadScriptingResources
bool LoadScriptingResources(std::list< Status > &errors, Stream *feedback_stream=nullptr, bool continue_on_error=true)
Definition: Target.h:923
lldb_private::Target::TargetEventData::m_target_sp
lldb::TargetSP m_target_sp
Definition: Target.h:526
lldb_private::Target::StopHook::GetSpecifier
SymbolContextSpecifier * GetSpecifier()
Definition: Target.h:1263
lldb_private::Target::TargetEventData::GetModuleListFromEvent
static ModuleList GetModuleListFromEvent(const Event *event_ptr)
Definition: Target.cpp:4738
lldb_private::Target::NotifyModulesRemoved
void NotifyModulesRemoved(lldb_private::ModuleList &module_list) override
Definition: Target.cpp:1632
lldb_private::Target::IgnoreAllWatchpoints
bool IgnoreAllWatchpoints(uint32_t ignore_count)
Definition: Target.cpp:1282
lldb_private::Target::~Target
~Target() override
Definition: Target.cpp:125
lldb_private::TargetProperties::GetSourcePathMap
PathMappingList & GetSourcePathMap() const
Definition: Target.cpp:4270
lldb_private::TargetProperties::SetDefaultArchitecture
void SetDefaultArchitecture(const ArchSpec &arch)
Definition: Target.cpp:4066
lldb_private::Target::StopHook::SetIsActive
void SetIsActive(bool is_active)
Definition: Target.h:1282
lldb_private::TargetProperties::GetDisableASLR
bool GetDisableASLR() const
Definition: Target.cpp:4102
lldb_private::Target::CreateScriptedBreakpoint
lldb::BreakpointSP CreateScriptedBreakpoint(const llvm::StringRef class_name, const FileSpecList *containingModules, const FileSpecList *containingSourceFiles, bool internal, bool request_hardware, StructuredData::ObjectSP extra_args_sp, Status *creation_error=nullptr)
Definition: Target.cpp:619
lldb_private::Target::GetDefaultDebugFileSearchPaths
static FileSpecList GetDefaultDebugFileSearchPaths()
Definition: Target.cpp:2446
lldb_private::Target::RemoveStopHookByID
bool RemoveStopHookByID(lldb::user_id_t uid)
Definition: Target.cpp:2655
lldb_private::EvaluateExpressionOptions::m_auto_apply_fixits
bool m_auto_apply_fixits
Definition: Target.h:450
lldb_private::EvaluateExpressionOptions::SetStopOthers
void SetStopOthers(bool stop_others=true)
Definition: Target.h:361
lldb_private::Target::GetBreakpointByID
lldb::BreakpointSP GetBreakpointByID(lldb::break_id_t break_id)
Definition: Target.cpp:323
lldb_private::Target::GetSourceManager
SourceManager & GetSourceManager()
Definition: Target.cpp:2627
lldb_private::Target::StopHook::GetDescription
void GetDescription(Stream *s, lldb::DescriptionLevel level) const
Definition: Target.cpp:3535
lldb_private::Target::ModulesDidUnload
void ModulesDidUnload(ModuleList &module_list, bool delete_locations)
Definition: Target.cpp:1668
lldb_private::Target::SetPlatform
void SetPlatform(const lldb::PlatformSP &platform_sp)
Definition: Target.h:1405
lldb_private::Target::EnableAllWatchpoints
bool EnableAllWatchpoints(bool end_to_end=true)
Definition: Target.cpp:1227
lldb_private::EvaluateExpressionOptions::m_timeout
Timeout< std::micro > m_timeout
Definition: Target.h:457
lldb_private::Target::SetDefaultArchitecture
static void SetDefaultArchitecture(const ArchSpec &arch)
Definition: Target.cpp:2454
lldb_private::TargetProperties::SetPreloadSymbols
void SetPreloadSymbols(bool b)
Definition: Target.cpp:4097
lldb_private::TargetProperties::TargetProperties
TargetProperties(Target *target)
Definition: Target.cpp:3957
lldb_private::Target::EnableBreakpointByID
bool EnableBreakpointByID(lldb::break_id_t break_id)
Definition: Target.cpp:989
lldb_private::Target::StopHookScripted::GetSubclassDescription
void GetSubclassDescription(Stream *s, lldb::DescriptionLevel level) const override
Definition: Target.cpp:3679
lldb_private::Target::TargetEventData
Definition: Target.h:498
Expression.h
lldb_private::EvaluateExpressionOptions::GetRetriesWithFixIts
uint64_t GetRetriesWithFixIts() const
Definition: Target.h:428
lldb_private::Target::CreateFuncRegexBreakpoint
lldb::BreakpointSP CreateFuncRegexBreakpoint(const FileSpecList *containingModules, const FileSpecList *containingSourceFiles, RegularExpression func_regexp, lldb::LanguageType requested_language, LazyBool skip_prologue, bool internal, bool request_hardware)
Definition: Target.cpp:585
lldb_private::GetDynamicValueTypes
OptionEnumValues GetDynamicValueTypes()
Definition: Target.cpp:3740
WatchpointList.h
lldb_private::Broadcaster
Definition: Broadcaster.h:242
lldb_private::LoadCWDlldbinitFile
LoadCWDlldbinitFile
Definition: Target.h:56
PathMappingList.h
lldb_private::ImportStdModule
ImportStdModule
Definition: Target.h:62
lldb_private::Target::eBroadcastBitSymbolsLoaded
@ eBroadcastBitSymbolsLoaded
Definition: Target.h:484
lldb_private::Target::StopHook::SetThreadSpecifier
void SetThreadSpecifier(ThreadSpec *specifier)
Definition: Target.cpp:3515
lldb_private::TargetProperties::GetDisassemblyFlavor
const char * GetDisassemblyFlavor() const
Definition: Target.cpp:4146
lldb_private::TargetProperties::GetDefaultArchitecture
ArchSpec GetDefaultArchitecture() const
Definition: Target.cpp:4058
lldb_private::Target::EnableWatchpointByID
bool EnableWatchpointByID(lldb::watch_id_t watch_id)
Definition: Target.cpp:1318
lldb_private::Target::SettingsInitialize
static void SettingsInitialize()
Definition: Target.cpp:2438
lldb_private::TargetProperties::GetClangModuleSearchPaths
FileSpecList GetClangModuleSearchPaths()
Definition: Target.cpp:4312
lldb_private::EvaluateExpressionOptions::SetPrefix
void SetPrefix(const char *prefix)
Definition: Target.h:313
lldb_private::Target::Target
Target(Debugger &debugger, const ArchSpec &target_arch, const lldb::PlatformSP &platform_sp, bool is_dummy_target)
Construct with optional file and arch.
Definition: Target.cpp:90
lldb_private::Target::StopHookScripted::SetScriptCallback
Status SetScriptCallback(std::string class_name, StructuredData::ObjectSP extra_args_sp)
Definition: Target.cpp:3641
lldb_private::Target::FindBreakpointName
BreakpointName * FindBreakpointName(ConstString name, bool can_create, Status &error)
Definition: Target.cpp:717
lldb_private::Target::eBroadcastBitModulesLoaded
@ eBroadcastBitModulesLoaded
Definition: Target.h:481
lldb_private::Target::m_frame_recognizer_manager_up
lldb::StackFrameRecognizerManagerUP m_frame_recognizer_manager_up
Stores the frame recognizers of this target.
Definition: Target.h:1546
lldb_private::TargetProperties::GetAutoInstallMainExecutable
bool GetAutoInstallMainExecutable() const
Definition: Target.cpp:4619
lldb_private::Target::StopHookScripted::m_class_name
std::string m_class_name
Definition: Target.h:1340
lldb_private::Target::ReportStatistics
llvm::json::Value ReportStatistics()
Get metrics associated with this target in JSON format.
Definition: Target.cpp:4754
lldb_private::EvaluateExpressionOptions::GetDebug
bool GetDebug() const
Definition: Target.h:363
lldb_private::Target::CalculateStackFrame
lldb::StackFrameSP CalculateStackFrame() override
Definition: Target.cpp:2276
lldb_private::Target::TargetEventData::GetTargetFromEvent
static lldb::TargetSP GetTargetFromEvent(const Event *event_ptr)
Definition: Target.cpp:4729
lldb_private::EvaluateExpressionOptions::GetPoundLineFilePath
const char * GetPoundLineFilePath() const
Definition: Target.h:410
lldb_private::Target::GetNumStopHooks
size_t GetNumStopHooks() const
Definition: Target.h:1389
lldb_private::BreakpointIDList
Definition: BreakpointIDList.h:25
lldb_private::EvaluateExpressionOptions::GetPoundLineLine
uint32_t GetPoundLineLine() const
Definition: Target.h:414
lldb_private::Target::m_section_load_history
SectionLoadHistory m_section_load_history
Definition: Target.h:1511
lldb_private::TargetProperties::GetInheritedEnvironment
Environment GetInheritedEnvironment() const
Definition: Target.cpp:4219
lldb_private::DynamicClassInfoHelper
DynamicClassInfoHelper
Definition: Target.h:68
lldb_private::TargetProperties::GetExecutableSearchPaths
FileSpecList GetExecutableSearchPaths()
Definition: Target.cpp:4294
lldb_private::TargetProperties::SetEnvironment
void SetEnvironment(Environment env)
Definition: Target.cpp:4258
lldb_private::TargetProperties::SetDetachOnError
void SetDetachOnError(bool b)
Definition: Target.cpp:4130
lldb_private::ModuleList::Notifier
Definition: ModuleList.h:84
lldb_private::Target::SetArchitecture
bool SetArchitecture(const ArchSpec &arch_spec, bool set_platform=false, bool merge=true)
Set the architecture for this target.
Definition: Target.cpp:1484
lldb::DescriptionLevel
DescriptionLevel
Description levels for "void GetDescription(Stream *, DescriptionLevel)" calls.
Definition: lldb-enumerations.h:207
lldb_private::Target::Arch::m_spec
ArchSpec m_spec
Definition: Target.h:1493
lldb_private::SourceManager
Definition: SourceManager.h:31
lldb_private::EvaluateExpressionOptions::GetOneThreadTimeout
const Timeout< std::micro > & GetOneThreadTimeout() const
Definition: Target.h:347
lldb_private::Target::RemoveAllWatchpoints
bool RemoveAllWatchpoints(bool end_to_end=true)
Definition: Target.cpp:1171
lldb_private::EvaluateExpressionOptions::m_pound_line_file
std::string m_pound_line_file
Definition: Target.h:464
lldb_private::EvaluateExpressionOptions::m_unwind_on_error
bool m_unwind_on_error
Definition: Target.h:439
lldb_private::InlineStrategy
InlineStrategy
Definition: Target.h:44
lldb_private::Target::RemoveAllowedBreakpoints
void RemoveAllowedBreakpoints()
Definition: Target.cpp:896
lldb_private::Target::StopHook::StopHookKind
StopHookKind
Definition: Target.h:1250
lldb_private::Target::UpdateSignalFromDummy
static bool UpdateSignalFromDummy(lldb::UnixSignalsSP signals_sp, const DummySignalElement &element)
Definition: Target.cpp:3389
lldb_private::Target::MergeArchitecture
bool MergeArchitecture(const ArchSpec &arch_spec)
Definition: Target.cpp:1573
lldb_private::FunctionCaller
Definition: FunctionCaller.h:56
lldb_private::LoadScriptFromSymFile
LoadScriptFromSymFile
Definition: Target.h:50
lldb_private::Target::SetStopHookActiveStateByID
bool SetStopHookActiveStateByID(lldb::user_id_t uid, bool active_state)
Definition: Target.cpp:2672
lldb_private::Target::m_trace_sp
lldb::TraceSP m_trace_sp
An optional lldb_private::Trace object containing processor trace information of this target.
Definition: Target.h:1544
lldb_private::EvaluateExpressionOptions::SetAutoApplyFixIts
void SetAutoApplyFixIts(bool b)
Definition: Target.h:420
lldb_private::Target::ReadPointerFromMemory
bool ReadPointerFromMemory(const Address &addr, Status &error, Address &pointer_addr, bool force_live_memory=false)
Definition: Target.cpp:2043