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/Address.h"
41#include "lldb/lldb-public.h"
42#include "llvm/ADT/StringRef.h"
43
44namespace lldb_private {
45
47
53
59
65
71
78
83
85public:
86 TargetProperties(Target *target);
87
89
91
92 void SetDefaultArchitecture(const ArchSpec &arch);
93
94 bool GetMoveToNearestCode() const;
95
97
99
100 bool GetPreloadSymbols() const;
101
102 void SetPreloadSymbols(bool b);
103
104 bool GetDisableASLR() const;
105
106 void SetDisableASLR(bool b);
107
108 bool GetInheritTCC() const;
109
110 void SetInheritTCC(bool b);
111
112 bool GetDetachOnError() const;
113
114 void SetDetachOnError(bool b);
115
116 bool GetDisableSTDIO() const;
117
118 void SetDisableSTDIO(bool b);
119
120 llvm::StringRef GetLaunchWorkingDirectory() const;
121
122 bool GetParallelModuleLoad() const;
123
124 const char *GetDisassemblyFlavor() const;
125
126 const char *GetDisassemblyCPU() const;
127
128 const char *GetDisassemblyFeatures() const;
129
131
133
134 llvm::StringRef GetArg0() const;
135
136 void SetArg0(llvm::StringRef arg);
137
138 bool GetRunArguments(Args &args) const;
139
140 void SetRunArguments(const Args &args);
141
142 // Get the whole environment including the platform inherited environment and
143 // the target specific environment, excluding the unset environment variables.
145 // Get the platform inherited environment, excluding the unset environment
146 // variables.
148 // Get the target specific environment only, without the platform inherited
149 // environment.
151 // Set the target specific environment.
152 void SetEnvironment(Environment env);
153
154 bool GetSkipPrologue() const;
155
157
159
160 bool GetAutoSourceMapRelative() const;
161
163
165
167
169
171
173
175
176 bool GetEnableAutoApplyFixIts() const;
177
178 uint64_t GetNumberOfRetriesWithFixits() const;
179
180 bool GetEnableNotifyAboutFixIts() const;
181
183
184 bool GetEnableSyntheticValue() const;
185
187
188 uint32_t GetMaxZeroPaddingInFloatFormat() const;
189
191
192 /// Get the max depth value, augmented with a bool to indicate whether the
193 /// depth is the default.
194 ///
195 /// When the user has customized the max depth, the bool will be false.
196 ///
197 /// \returns the max depth, and true if the max depth is the system default,
198 /// otherwise false.
199 std::pair<uint32_t, bool> GetMaximumDepthOfChildrenToDisplay() const;
200
201 uint32_t GetMaximumSizeOfStringSummary() const;
202
203 uint32_t GetMaximumMemReadSize() const;
204
208
209 void SetStandardInputPath(llvm::StringRef path);
210 void SetStandardOutputPath(llvm::StringRef path);
211 void SetStandardErrorPath(llvm::StringRef path);
212
213 void SetStandardInputPath(const char *path) = delete;
214 void SetStandardOutputPath(const char *path) = delete;
215 void SetStandardErrorPath(const char *path) = delete;
216
218
220
221 llvm::StringRef GetExpressionPrefixContents();
222
223 uint64_t GetExprErrorLimit() const;
224
225 uint64_t GetExprAllocAddress() const;
226
227 uint64_t GetExprAllocSize() const;
228
229 uint64_t GetExprAllocAlign() const;
230
231 bool GetUseHexImmediates() const;
232
233 bool GetUseFastStepping() const;
234
236
238
240
242
244
245 bool GetUserSpecifiedTrapHandlerNames(Args &args) const;
246
247 void SetUserSpecifiedTrapHandlerNames(const Args &args);
248
250
252
254
256
258
259 void SetProcessLaunchInfo(const ProcessLaunchInfo &launch_info);
260
261 bool GetInjectLocalVariables(ExecutionContext *exe_ctx) const;
262
263 bool GetUseDIL(ExecutionContext *exe_ctx) const;
264
265 void SetUseDIL(ExecutionContext *exe_ctx, bool b);
266
268
270
271 bool GetAutoInstallMainExecutable() const;
272
274
275 void SetDebugUtilityExpression(bool debug);
276
277 bool GetDebugUtilityExpression() const;
278
279private:
280 std::optional<bool>
281 GetExperimentalPropertyValue(size_t prop_idx,
282 ExecutionContext *exe_ctx = nullptr) const;
283
284 // Callbacks for m_launch_info.
295
296 // Settings checker for target.jit-save-objects-dir:
297 void CheckJITObjectsDir();
298
300
301 // Member variables.
303 std::unique_ptr<TargetExperimentalProperties> m_experimental_properties_up;
305};
306
308public:
309// MSVC has a bug here that reports C4268: 'const' static/global data
310// initialized with compiler generated default constructor fills the object
311// with zeros. Confirmed that MSVC is *not* zero-initializing, it's just a
312// bogus warning.
313#if defined(_MSC_VER)
314#pragma warning(push)
315#pragma warning(disable : 4268)
316#endif
317 static constexpr std::chrono::milliseconds default_timeout{500};
318#if defined(_MSC_VER)
319#pragma warning(pop)
320#endif
321
324
326
328
332
334
335 void SetLanguage(lldb::LanguageType language_type) {
336 m_language = SourceLanguage(language_type);
337 }
338
340 m_preferred_lookup_contexts = std::move(contexts);
341 }
342
346
347 /// Set the language using a pair of language code and version as
348 /// defined by the DWARF 6 specification.
349 /// WARNING: These codes may change until DWARF 6 is finalized.
350 void SetLanguage(uint16_t name, uint32_t version) {
351 m_language = SourceLanguage(name, version);
352 }
353
354 bool DoesCoerceToId() const { return m_coerce_to_id; }
355
356 const char *GetPrefix() const {
357 return (m_prefix.empty() ? nullptr : m_prefix.c_str());
358 }
359
360 void SetPrefix(const char *prefix) {
361 if (prefix && prefix[0])
362 m_prefix = prefix;
363 else
364 m_prefix.clear();
365 }
366
367 void SetCoerceToId(bool coerce = true) { m_coerce_to_id = coerce; }
368
369 bool DoesUnwindOnError() const { return m_unwind_on_error; }
370
371 void SetUnwindOnError(bool unwind = false) { m_unwind_on_error = unwind; }
372
374
375 void SetIgnoreBreakpoints(bool ignore = false) {
376 m_ignore_breakpoints = ignore;
377 }
378
379 bool DoesKeepInMemory() const { return m_keep_in_memory; }
380
381 void SetKeepInMemory(bool keep = true) { m_keep_in_memory = keep; }
382
384
385 void
389
390 const Timeout<std::micro> &GetTimeout() const { return m_timeout; }
391
392 void SetTimeout(const Timeout<std::micro> &timeout) { m_timeout = timeout; }
393
397
399 m_one_thread_timeout = timeout;
400 }
401
402 bool GetTryAllThreads() const { return m_try_others; }
403
404 void SetTryAllThreads(bool try_others = true) { m_try_others = try_others; }
405
406 bool GetStopOthers() const { return m_stop_others; }
407
408 void SetStopOthers(bool stop_others = true) { m_stop_others = stop_others; }
409
410 bool GetDebug() const { return m_debug; }
411
412 void SetDebug(bool b) {
413 m_debug = b;
414 if (m_debug)
416 }
417
419
421
422 bool GetColorizeErrors() const { return m_ansi_color_errors; }
423
425
426 bool GetTrapExceptions() const { return m_trap_exceptions; }
427
429
430 bool GetREPLEnabled() const { return m_repl; }
431
432 void SetREPLEnabled(bool b) { m_repl = b; }
433
436 m_cancel_callback = callback;
437 }
438
440 return ((m_cancel_callback != nullptr)
442 : false);
443 }
444
445 // Allows the expression contents to be remapped to point to the specified
446 // file and line using #line directives.
447 void SetPoundLine(const char *path, uint32_t line) const {
448 if (path && path[0]) {
449 m_pound_line_file = path;
450 m_pound_line_line = line;
451 } else {
452 m_pound_line_file.clear();
454 }
455 }
456
457 const char *GetPoundLineFilePath() const {
458 return (m_pound_line_file.empty() ? nullptr : m_pound_line_file.c_str());
459 }
460
461 uint32_t GetPoundLineLine() const { return m_pound_line_line; }
462
464
468
470
472
473 void SetRetriesWithFixIts(uint64_t number_of_retries) {
474 m_retries_with_fixits = number_of_retries;
475 }
476
477 uint64_t GetRetriesWithFixIts() const { return m_retries_with_fixits; }
478
480
482
483private:
486 std::string m_prefix;
487 bool m_coerce_to_id = false;
488 bool m_unwind_on_error = true;
490 bool m_keep_in_memory = false;
491 bool m_try_others = true;
492 bool m_stop_others = true;
493 bool m_debug = false;
494 bool m_trap_exceptions = true;
495 bool m_repl = false;
501 /// True if the executed code should be treated as utility code that is only
502 /// used by LLDB internally.
504
509 void *m_cancel_callback_baton = nullptr;
510 // If m_pound_line_file is not empty and m_pound_line_line is non-zero, use
511 // #line %u "%s" before the expression content to remap where the source
512 // originates
513 mutable std::string m_pound_line_file;
514 mutable uint32_t m_pound_line_line = 0;
515
516 /// During expression evaluation, any SymbolContext in this list will be
517 /// used for symbol/function lookup before any other context (except for
518 /// the module corresponding to the current frame).
520};
521
522// Target
523class Target : public std::enable_shared_from_this<Target>,
524 public TargetProperties,
525 public Broadcaster,
527 public ModuleList::Notifier {
528public:
529 friend class TargetList;
530 friend class Debugger;
531
532 /// Broadcaster event bits definitions.
533 enum {
540 };
541
542 // These two functions fill out the Broadcaster interface:
543
544 static llvm::StringRef GetStaticBroadcasterClass();
545
546 llvm::StringRef GetBroadcasterClass() const override {
548 }
549
550 // This event data class is for use by the TargetList to broadcast new target
551 // notifications.
552 class TargetEventData : public EventData {
553 public:
554 TargetEventData(const lldb::TargetSP &target_sp);
555
556 TargetEventData(const lldb::TargetSP &target_sp,
557 const ModuleList &module_list);
558
560
561 static llvm::StringRef GetFlavorString();
562
563 llvm::StringRef GetFlavor() const override {
565 }
566
567 void Dump(Stream *s) const override;
568
569 static const TargetEventData *GetEventDataFromEvent(const Event *event_ptr);
570
571 static lldb::TargetSP GetTargetFromEvent(const Event *event_ptr);
572
573 static ModuleList GetModuleListFromEvent(const Event *event_ptr);
574
575 const lldb::TargetSP &GetTarget() const { return m_target_sp; }
576
577 const ModuleList &GetModuleList() const { return m_module_list; }
578
579 private:
582
584 const TargetEventData &operator=(const TargetEventData &) = delete;
585 };
586
587 ~Target() override;
588
589 static void SettingsInitialize();
590
591 static void SettingsTerminate();
592
594
596
598
599 static void SetDefaultArchitecture(const ArchSpec &arch);
600
601 bool IsDummyTarget() const { return m_is_dummy_target; }
602
603 /// Get the globally unique ID for this target.
604 ///
605 /// This ID is unique across all debugger instances and all targets,
606 /// within the same lldb process. The ID is assigned
607 /// during target construction and remains constant for the target's lifetime.
608 /// The first target created (typically the dummy target) gets ID 1.
609 ///
610 /// \return
611 /// The globally unique ID for this target.
613
614 const std::string &GetLabel() const { return m_label; }
615
616 /// Set a label for a target.
617 ///
618 /// The label cannot be used by another target or be only integral.
619 ///
620 /// \return
621 /// The label for this target or an error if the label didn't match the
622 /// requirements.
623 llvm::Error SetLabel(llvm::StringRef label);
624
625 /// Find a binary on the system and return its Module,
626 /// or return an existing Module that is already in the Target.
627 ///
628 /// Given a ModuleSpec, find a binary satisifying that specification,
629 /// or identify a matching Module already present in the Target,
630 /// and return a shared pointer to it.
631 ///
632 /// \param[in] module_spec
633 /// The criteria that must be matched for the binary being loaded.
634 /// e.g. UUID, architecture, file path.
635 ///
636 /// \param[in] notify
637 /// If notify is true, and the Module is new to this Target,
638 /// Target::ModulesDidLoad will be called.
639 /// If notify is false, it is assumed that the caller is adding
640 /// multiple Modules and will call ModulesDidLoad with the
641 /// full list at the end.
642 /// ModulesDidLoad must be called when a Module/Modules have
643 /// been added to the target, one way or the other.
644 ///
645 /// \param[out] error_ptr
646 /// Optional argument, pointing to a Status object to fill in
647 /// with any results / messages while attempting to find/load
648 /// this binary. Many callers will be internal functions that
649 /// will handle / summarize the failures in a custom way and
650 /// don't use these messages.
651 ///
652 /// \return
653 /// An empty ModuleSP will be returned if no matching file
654 /// was found. If error_ptr was non-nullptr, an error message
655 /// will likely be provided.
656 lldb::ModuleSP GetOrCreateModule(const ModuleSpec &module_spec, bool notify,
657 Status *error_ptr = nullptr);
658
659 // Settings accessors
660
662
663 std::recursive_mutex &GetAPIMutex();
664
666
667 void CleanupProcess();
668
669 /// Dump a description of this object to a Stream.
670 ///
671 /// Dump a description of the contents of this object to the
672 /// supplied stream \a s. The dumped content will be only what has
673 /// been loaded or parsed up to this point at which this function
674 /// is called, so this is a good way to see what has been parsed
675 /// in a target.
676 ///
677 /// \param[in] s
678 /// The stream to which to dump the object description.
679 void Dump(Stream *s, lldb::DescriptionLevel description_level);
680
681 // If listener_sp is null, the listener of the owning Debugger object will be
682 // used.
684 llvm::StringRef plugin_name,
685 const FileSpec *crash_file,
686 bool can_connect);
687
688 const lldb::ProcessSP &GetProcessSP() const;
689
690 bool IsValid() { return m_valid; }
691
692 void Destroy();
693
694 Status Launch(ProcessLaunchInfo &launch_info,
695 Stream *stream); // Optional stream to receive first stop info
696
697 Status Attach(ProcessAttachInfo &attach_info,
698 Stream *stream); // Optional stream to receive first stop info
699
700 // This part handles the breakpoints.
701
702 BreakpointList &GetBreakpointList(bool internal = false);
703
704 const BreakpointList &GetBreakpointList(bool internal = false) const;
705
709
711
713
714 // Use this to create a file and line breakpoint to a given module or all
715 // module it is nullptr
716 lldb::BreakpointSP CreateBreakpoint(const FileSpecList *containingModules,
717 const FileSpec &file, uint32_t line_no,
718 uint32_t column, lldb::addr_t offset,
719 LazyBool check_inlines,
720 LazyBool skip_prologue, bool internal,
721 bool request_hardware,
722 LazyBool move_to_nearest_code);
723
724 // Use this to create breakpoint that matches regex against the source lines
725 // in files given in source_file_list: If function_names is non-empty, also
726 // filter by function after the matches are made.
728 const FileSpecList *containingModules,
729 const FileSpecList *source_file_list,
730 const std::unordered_set<std::string> &function_names,
731 RegularExpression source_regex, bool internal, bool request_hardware,
732 LazyBool move_to_nearest_code);
733
734 // Use this to create a breakpoint from a load address
735 lldb::BreakpointSP CreateBreakpoint(lldb::addr_t load_addr, bool internal,
736 bool request_hardware);
737
738 // Use this to create a breakpoint from a file address and a module file spec
740 bool internal,
741 const FileSpec &file_spec,
742 bool request_hardware);
743
744 // Use this to create Address breakpoints:
745 lldb::BreakpointSP CreateBreakpoint(const Address &addr, bool internal,
746 bool request_hardware);
747
748 // Use this to create a function breakpoint by regexp in
749 // containingModule/containingSourceFiles, or all modules if it is nullptr
750 // When "skip_prologue is set to eLazyBoolCalculate, we use the current
751 // target setting, else we use the values passed in
753 const FileSpecList *containingModules,
754 const FileSpecList *containingSourceFiles, RegularExpression func_regexp,
755 lldb::LanguageType requested_language, LazyBool skip_prologue,
756 bool internal, bool request_hardware);
757
758 // Use this to create a function breakpoint by name in containingModule, or
759 // all modules if it is nullptr When "skip_prologue is set to
760 // eLazyBoolCalculate, we use the current target setting, else we use the
761 // values passed in. func_name_type_mask is or'ed values from the
762 // FunctionNameType enum.
764 const FileSpecList *containingModules,
765 const FileSpecList *containingSourceFiles, const char *func_name,
766 lldb::FunctionNameType func_name_type_mask, lldb::LanguageType language,
767 lldb::addr_t offset, bool offset_is_insn_count, LazyBool skip_prologue,
768 bool internal, bool request_hardware);
769
771 CreateExceptionBreakpoint(enum lldb::LanguageType language, bool catch_bp,
772 bool throw_bp, bool internal,
773 Args *additional_args = nullptr,
774 Status *additional_args_error = nullptr);
775
777 const llvm::StringRef class_name, const FileSpecList *containingModules,
778 const FileSpecList *containingSourceFiles, bool internal,
779 bool request_hardware, StructuredData::ObjectSP extra_args_sp,
780 Status *creation_error = nullptr);
781
782 // This is the same as the func_name breakpoint except that you can specify a
783 // vector of names. This is cheaper than a regular expression breakpoint in
784 // the case where you just want to set a breakpoint on a set of names you
785 // already know. func_name_type_mask is or'ed values from the
786 // FunctionNameType enum.
788 const FileSpecList *containingModules,
789 const FileSpecList *containingSourceFiles, const char *func_names[],
790 size_t num_names, lldb::FunctionNameType func_name_type_mask,
791 lldb::LanguageType language, lldb::addr_t offset, LazyBool skip_prologue,
792 bool internal, bool request_hardware);
793
795 CreateBreakpoint(const FileSpecList *containingModules,
796 const FileSpecList *containingSourceFiles,
797 const std::vector<std::string> &func_names,
798 lldb::FunctionNameType func_name_type_mask,
799 lldb::LanguageType language, lldb::addr_t m_offset,
800 LazyBool skip_prologue, bool internal,
801 bool request_hardware);
802
803 // Use this to create a general breakpoint:
805 lldb::BreakpointResolverSP &resolver_sp,
806 bool internal, bool request_hardware,
807 bool resolve_indirect_symbols);
808
809 // Use this to create a watchpoint:
811 const CompilerType *type, uint32_t kind,
812 Status &error);
813
817
819
820 // Manages breakpoint names:
821 void AddNameToBreakpoint(BreakpointID &id, llvm::StringRef name,
822 Status &error);
823
824 void AddNameToBreakpoint(lldb::BreakpointSP &bp_sp, llvm::StringRef name,
825 Status &error);
826
828
829 BreakpointName *FindBreakpointName(ConstString name, bool can_create,
830 Status &error);
831
833
835 const BreakpointOptions &options,
836 const BreakpointName::Permissions &permissions);
838
839 void AddBreakpointName(std::unique_ptr<BreakpointName> bp_name);
840
841 void GetBreakpointNames(std::vector<std::string> &names);
842
843 // This call removes ALL breakpoints regardless of permission.
844 void RemoveAllBreakpoints(bool internal_also = false);
845
846 // This removes all the breakpoints, but obeys the ePermDelete on them.
848
849 void DisableAllBreakpoints(bool internal_also = false);
850
852
853 void EnableAllBreakpoints(bool internal_also = false);
854
856
858
860
862
863 /// Resets the hit count of all breakpoints.
865
866 // The flag 'end_to_end', default to true, signifies that the operation is
867 // performed end to end, for both the debugger and the debuggee.
868
869 bool RemoveAllWatchpoints(bool end_to_end = true);
870
871 bool DisableAllWatchpoints(bool end_to_end = true);
872
873 bool EnableAllWatchpoints(bool end_to_end = true);
874
876
878
879 bool IgnoreAllWatchpoints(uint32_t ignore_count);
880
882
884
886
887 bool IgnoreWatchpointByID(lldb::watch_id_t watch_id, uint32_t ignore_count);
888
890 const BreakpointIDList &bp_ids,
891 bool append);
892
894 BreakpointIDList &new_bps);
895
897 std::vector<std::string> &names,
898 BreakpointIDList &new_bps);
899
900 /// Get \a load_addr as a callable code load address for this target
901 ///
902 /// Take \a load_addr and potentially add any address bits that are
903 /// needed to make the address callable. For ARM this can set bit
904 /// zero (if it already isn't) if \a load_addr is a thumb function.
905 /// If \a addr_class is set to AddressClass::eInvalid, then the address
906 /// adjustment will always happen. If it is set to an address class
907 /// that doesn't have code in it, LLDB_INVALID_ADDRESS will be
908 /// returned.
910 lldb::addr_t load_addr,
911 AddressClass addr_class = AddressClass::eInvalid) const;
912
913 /// Get \a load_addr as an opcode for this target.
914 ///
915 /// Take \a load_addr and potentially strip any address bits that are
916 /// needed to make the address point to an opcode. For ARM this can
917 /// clear bit zero (if it already isn't) if \a load_addr is a
918 /// thumb function and load_addr is in code.
919 /// If \a addr_class is set to AddressClass::eInvalid, then the address
920 /// adjustment will always happen. If it is set to an address class
921 /// that doesn't have code in it, LLDB_INVALID_ADDRESS will be
922 /// returned.
925 AddressClass addr_class = AddressClass::eInvalid) const;
926
927 // Get load_addr as breakable load address for this target. Take a addr and
928 // check if for any reason there is a better address than this to put a
929 // breakpoint on. If there is then return that address. For MIPS, if
930 // instruction at addr is a delay slot instruction then this method will find
931 // the address of its previous instruction and return that address.
933
934 void ModulesDidLoad(ModuleList &module_list);
935
936 void ModulesDidUnload(ModuleList &module_list, bool delete_locations);
937
938 void SymbolsDidLoad(ModuleList &module_list);
939
940 void ClearModules(bool delete_locations);
941
942 /// Called as the last function in Process::DidExec().
943 ///
944 /// Process::DidExec() will clear a lot of state in the process,
945 /// then try to reload a dynamic loader plugin to discover what
946 /// binaries are currently available and then this function should
947 /// be called to allow the target to do any cleanup after everything
948 /// has been figured out. It can remove breakpoints that no longer
949 /// make sense as the exec might have changed the target
950 /// architecture, and unloaded some modules that might get deleted.
951 void DidExec();
952
953 /// Gets the module for the main executable.
954 ///
955 /// Each process has a notion of a main executable that is the file
956 /// that will be executed or attached to. Executable files can have
957 /// dependent modules that are discovered from the object files, or
958 /// discovered at runtime as things are dynamically loaded.
959 ///
960 /// \return
961 /// The shared pointer to the executable module which can
962 /// contains a nullptr Module object if no executable has been
963 /// set.
964 ///
965 /// \see DynamicLoader
966 /// \see ObjectFile::GetDependentModules (FileSpecList&)
967 /// \see Process::SetExecutableModule(lldb::ModuleSP&)
969
971
972 /// Set the main executable module.
973 ///
974 /// Each process has a notion of a main executable that is the file
975 /// that will be executed or attached to. Executable files can have
976 /// dependent modules that are discovered from the object files, or
977 /// discovered at runtime as things are dynamically loaded.
978 ///
979 /// Setting the executable causes any of the current dependent
980 /// image information to be cleared and replaced with the static
981 /// dependent image information found by calling
982 /// ObjectFile::GetDependentModules (FileSpecList&) on the main
983 /// executable and any modules on which it depends. Calling
984 /// Process::GetImages() will return the newly found images that
985 /// were obtained from all of the object files.
986 ///
987 /// \param[in] module_sp
988 /// A shared pointer reference to the module that will become
989 /// the main executable for this process.
990 ///
991 /// \param[in] load_dependent_files
992 /// If \b true then ask the object files to track down any
993 /// known dependent files.
994 ///
995 /// \see ObjectFile::GetDependentModules (FileSpecList&)
996 /// \see Process::GetImages()
998 lldb::ModuleSP &module_sp,
999 LoadDependentFiles load_dependent_files = eLoadDependentsDefault);
1000
1001 bool LoadScriptingResources(std::list<Status> &errors,
1002 Stream &feedback_stream,
1003 bool continue_on_error = true) {
1004 return m_images.LoadScriptingResourcesInTarget(
1005 this, errors, feedback_stream, continue_on_error);
1006 }
1007
1008 /// Get accessor for the images for this process.
1009 ///
1010 /// Each process has a notion of a main executable that is the file
1011 /// that will be executed or attached to. Executable files can have
1012 /// dependent modules that are discovered from the object files, or
1013 /// discovered at runtime as things are dynamically loaded. After
1014 /// a main executable has been set, the images will contain a list
1015 /// of all the files that the executable depends upon as far as the
1016 /// object files know. These images will usually contain valid file
1017 /// virtual addresses only. When the process is launched or attached
1018 /// to, the DynamicLoader plug-in will discover where these images
1019 /// were loaded in memory and will resolve the load virtual
1020 /// addresses is each image, and also in images that are loaded by
1021 /// code.
1022 ///
1023 /// \return
1024 /// A list of Module objects in a module list.
1025 const ModuleList &GetImages() const { return m_images; }
1026
1028
1029 /// Return whether this FileSpec corresponds to a module that should be
1030 /// considered for general searches.
1031 ///
1032 /// This API will be consulted by the SearchFilterForUnconstrainedSearches
1033 /// and any module that returns \b true will not be searched. Note the
1034 /// SearchFilterForUnconstrainedSearches is the search filter that
1035 /// gets used in the CreateBreakpoint calls when no modules is provided.
1036 ///
1037 /// The target call at present just consults the Platform's call of the
1038 /// same name.
1039 ///
1040 /// \param[in] module_spec
1041 /// Path to the module.
1042 ///
1043 /// \return \b true if the module should be excluded, \b false otherwise.
1044 bool ModuleIsExcludedForUnconstrainedSearches(const FileSpec &module_spec);
1045
1046 /// Return whether this module should be considered for general searches.
1047 ///
1048 /// This API will be consulted by the SearchFilterForUnconstrainedSearches
1049 /// and any module that returns \b true will not be searched. Note the
1050 /// SearchFilterForUnconstrainedSearches is the search filter that
1051 /// gets used in the CreateBreakpoint calls when no modules is provided.
1052 ///
1053 /// The target call at present just consults the Platform's call of the
1054 /// same name.
1055 ///
1056 /// FIXME: When we get time we should add a way for the user to set modules
1057 /// that they
1058 /// don't want searched, in addition to or instead of the platform ones.
1059 ///
1060 /// \param[in] module_sp
1061 /// A shared pointer reference to the module that checked.
1062 ///
1063 /// \return \b true if the module should be excluded, \b false otherwise.
1064 bool
1066
1067 const ArchSpec &GetArchitecture() const { return m_arch.GetSpec(); }
1068
1069 /// Returns the name of the target's ABI plugin.
1070 llvm::StringRef GetABIName() const;
1071
1072 /// Set the architecture for this target.
1073 ///
1074 /// If the current target has no Images read in, then this just sets the
1075 /// architecture, which will be used to select the architecture of the
1076 /// ExecutableModule when that is set. If the current target has an
1077 /// ExecutableModule, then calling SetArchitecture with a different
1078 /// architecture from the currently selected one will reset the
1079 /// ExecutableModule to that slice of the file backing the ExecutableModule.
1080 /// If the file backing the ExecutableModule does not contain a fork of this
1081 /// architecture, then this code will return false, and the architecture
1082 /// won't be changed. If the input arch_spec is the same as the already set
1083 /// architecture, this is a no-op.
1084 ///
1085 /// \param[in] arch_spec
1086 /// The new architecture.
1087 ///
1088 /// \param[in] set_platform
1089 /// If \b true, then the platform will be adjusted if the currently
1090 /// selected platform is not compatible with the architecture being set.
1091 /// If \b false, then just the architecture will be set even if the
1092 /// currently selected platform isn't compatible (in case it might be
1093 /// manually set following this function call).
1094 ///
1095 /// \param[in] merged
1096 /// If true, arch_spec is merged with the current
1097 /// architecture. Otherwise it's replaced.
1098 ///
1099 /// \return
1100 /// \b true if the architecture was successfully set, \b false otherwise.
1101 bool SetArchitecture(const ArchSpec &arch_spec, bool set_platform = false,
1102 bool merge = true);
1103
1104 bool MergeArchitecture(const ArchSpec &arch_spec);
1105
1106 Architecture *GetArchitecturePlugin() const { return m_arch.GetPlugin(); }
1107
1108 Debugger &GetDebugger() const { return m_debugger; }
1109
1110 size_t ReadMemoryFromFileCache(const Address &addr, void *dst, size_t dst_len,
1111 Status &error);
1112
1113 // Reading memory through the target allows us to skip going to the process
1114 // for reading memory if possible and it allows us to try and read from any
1115 // constant sections in our object files on disk. If you always want live
1116 // program memory, read straight from the process. If you possibly want to
1117 // read from const sections in object files, read from the target. This
1118 // version of ReadMemory will try and read memory from the process if the
1119 // process is alive. The order is:
1120 // 1 - if (force_live_memory == false) and the address falls in a read-only
1121 // section, then read from the file cache
1122 // 2 - if there is a process, then read from memory
1123 // 3 - if there is no process, then read from the file cache
1124 //
1125 // If did_read_live_memory is provided, will indicate if the read was from
1126 // live memory, or from file contents. A caller which needs to treat these two
1127 // sources differently should use this argument to disambiguate where the data
1128 // was read from.
1129 //
1130 // The method is virtual for mocking in the unit tests.
1131 virtual size_t ReadMemory(const Address &addr, void *dst, size_t dst_len,
1132 Status &error, bool force_live_memory = false,
1133 lldb::addr_t *load_addr_ptr = nullptr,
1134 bool *did_read_live_memory = nullptr);
1135
1136 size_t ReadCStringFromMemory(const Address &addr, std::string &out_str,
1137 Status &error, bool force_live_memory = false);
1138
1139 size_t ReadCStringFromMemory(const Address &addr, char *dst,
1140 size_t dst_max_len, Status &result_error,
1141 bool force_live_memory = false);
1142
1143 /// Read a NULL terminated string from memory
1144 ///
1145 /// This function will read a cache page at a time until a NULL string
1146 /// terminator is found. It will stop reading if an aligned sequence of NULL
1147 /// termination \a type_width bytes is not found before reading \a
1148 /// cstr_max_len bytes. The results are always guaranteed to be NULL
1149 /// terminated, and that no more than (max_bytes - type_width) bytes will be
1150 /// read.
1151 ///
1152 /// \param[in] addr
1153 /// The address to start the memory read.
1154 ///
1155 /// \param[in] dst
1156 /// A character buffer containing at least max_bytes.
1157 ///
1158 /// \param[in] max_bytes
1159 /// The maximum number of bytes to read.
1160 ///
1161 /// \param[in] error
1162 /// The error status of the read operation.
1163 ///
1164 /// \param[in] type_width
1165 /// The size of the null terminator (1 to 4 bytes per
1166 /// character). Defaults to 1.
1167 ///
1168 /// \return
1169 /// The error status or the number of bytes prior to the null terminator.
1170 size_t ReadStringFromMemory(const Address &addr, char *dst, size_t max_bytes,
1171 Status &error, size_t type_width,
1172 bool force_live_memory = true);
1173
1174 size_t ReadScalarIntegerFromMemory(const Address &addr, uint32_t byte_size,
1175 bool is_signed, Scalar &scalar,
1176 Status &error,
1177 bool force_live_memory = false);
1178
1179 int64_t ReadSignedIntegerFromMemory(const Address &addr,
1180 size_t integer_byte_size,
1181 int64_t fail_value, Status &error,
1182 bool force_live_memory = false);
1183
1184 uint64_t ReadUnsignedIntegerFromMemory(const Address &addr,
1185 size_t integer_byte_size,
1186 uint64_t fail_value, Status &error,
1187 bool force_live_memory = false);
1188
1189 bool ReadPointerFromMemory(const Address &addr, Status &error,
1190 Address &pointer_addr,
1191 bool force_live_memory = false);
1192
1193 bool HasLoadedSections();
1194
1196
1197 void ClearSectionLoadList();
1198
1199 void DumpSectionLoadList(Stream &s);
1200
1201 static Target *GetTargetFromContexts(const ExecutionContext *exe_ctx_ptr,
1202 const SymbolContext *sc_ptr);
1203
1204 // lldb::ExecutionContextScope pure virtual functions
1206
1208
1210
1212
1213 void CalculateExecutionContext(ExecutionContext &exe_ctx) override;
1214
1216
1217 llvm::Expected<lldb::TypeSystemSP>
1219 bool create_on_demand = true);
1220
1221 std::vector<lldb::TypeSystemSP>
1222 GetScratchTypeSystems(bool create_on_demand = true);
1223
1226
1227 // Creates a UserExpression for the given language, the rest of the
1228 // parameters have the same meaning as for the UserExpression constructor.
1229 // Returns a new-ed object which the caller owns.
1230
1232 GetUserExpressionForLanguage(llvm::StringRef expr, llvm::StringRef prefix,
1233 SourceLanguage language,
1234 Expression::ResultType desired_type,
1235 const EvaluateExpressionOptions &options,
1236 ValueObject *ctx_obj, Status &error);
1237
1238 // Creates a FunctionCaller for the given language, the rest of the
1239 // parameters have the same meaning as for the FunctionCaller constructor.
1240 // Since a FunctionCaller can't be
1241 // IR Interpreted, it makes no sense to call this with an
1242 // ExecutionContextScope that lacks
1243 // a Process.
1244 // Returns a new-ed object which the caller owns.
1245
1247 const CompilerType &return_type,
1248 const Address &function_address,
1249 const ValueList &arg_value_list,
1250 const char *name, Status &error);
1251
1252 /// Creates and installs a UtilityFunction for the given language.
1253 llvm::Expected<std::unique_ptr<UtilityFunction>>
1254 CreateUtilityFunction(std::string expression, std::string name,
1255 lldb::LanguageType language, ExecutionContext &exe_ctx);
1256
1257 // Install any files through the platform that need be to installed prior to
1258 // launching or attaching.
1259 Status Install(ProcessLaunchInfo *launch_info);
1260
1261 bool ResolveFileAddress(lldb::addr_t load_addr, Address &so_addr);
1262
1263 bool ResolveLoadAddress(lldb::addr_t load_addr, Address &so_addr,
1264 uint32_t stop_id = SectionLoadHistory::eStopIDNow,
1265 bool allow_section_end = false);
1266
1267 bool SetSectionLoadAddress(const lldb::SectionSP &section,
1268 lldb::addr_t load_addr,
1269 bool warn_multiple = false);
1270
1271 size_t UnloadModuleSections(const lldb::ModuleSP &module_sp);
1272
1273 size_t UnloadModuleSections(const ModuleList &module_list);
1274
1275 bool SetSectionUnloaded(const lldb::SectionSP &section_sp);
1276
1277 bool SetSectionUnloaded(const lldb::SectionSP &section_sp,
1278 lldb::addr_t load_addr);
1279
1281
1283 lldb_private::TypeSummaryImpl &summary_provider);
1285
1286 /// Set the \a Trace object containing processor trace information of this
1287 /// target.
1288 ///
1289 /// \param[in] trace_sp
1290 /// The trace object.
1291 void SetTrace(const lldb::TraceSP &trace_sp);
1292
1293 /// Get the \a Trace object containing processor trace information of this
1294 /// target.
1295 ///
1296 /// \return
1297 /// The trace object. It might be undefined.
1299
1300 /// Create a \a Trace object for the current target using the using the
1301 /// default supported tracing technology for this process.
1302 ///
1303 /// \return
1304 /// The new \a Trace or an \a llvm::Error if a \a Trace already exists or
1305 /// the trace couldn't be created.
1306 llvm::Expected<lldb::TraceSP> CreateTrace();
1307
1308 /// If a \a Trace object is present, this returns it, otherwise a new Trace is
1309 /// created with \a Trace::CreateTrace.
1310 llvm::Expected<lldb::TraceSP> GetTraceOrCreate();
1311
1312 // Since expressions results can persist beyond the lifetime of a process,
1313 // and the const expression results are available after a process is gone, we
1314 // provide a way for expressions to be evaluated from the Target itself. If
1315 // an expression is going to be run, then it should have a frame filled in in
1316 // the execution context.
1318 llvm::StringRef expression, ExecutionContextScope *exe_scope,
1319 lldb::ValueObjectSP &result_valobj_sp,
1321 std::string *fixed_expression = nullptr, ValueObject *ctx_obj = nullptr);
1322
1324
1326
1327 /// This method will return the address of the starting function for
1328 /// this binary, e.g. main() or its equivalent. This can be used as
1329 /// an address of a function that is not called once a binary has
1330 /// started running - e.g. as a return address for inferior function
1331 /// calls that are unambiguous completion of the function call, not
1332 /// called during the course of the inferior function code running.
1333 ///
1334 /// If no entry point can be found, an invalid address is returned.
1335 ///
1336 /// \param [out] err
1337 /// This object will be set to failure if no entry address could
1338 /// be found, and may contain a helpful error message.
1339 //
1340 /// \return
1341 /// Returns the entry address for this program, or an error
1342 /// if none can be found.
1343 llvm::Expected<lldb_private::Address> GetEntryPointAddress();
1344
1345 CompilerType GetRegisterType(const std::string &name,
1346 const lldb_private::RegisterFlags &flags,
1347 uint32_t byte_size);
1348
1349 llvm::Expected<lldb::DisassemblerSP>
1350 ReadInstructions(const Address &start_addr, uint32_t count,
1351 const char *flavor_string = nullptr);
1352
1353 // Target Stop Hooks
1354 class StopHook : public UserID {
1355 public:
1356 StopHook(const StopHook &rhs);
1357 virtual ~StopHook() = default;
1358
1359 enum class StopHookKind : uint32_t {
1363 };
1370
1372
1373 // Set the specifier. The stop hook will own the specifier, and is
1374 // responsible for deleting it when we're done.
1375 void SetSpecifier(SymbolContextSpecifier *specifier);
1376
1378
1379 bool ExecutionContextPasses(const ExecutionContext &exe_ctx);
1380
1381 // Called on stop, this gets passed the ExecutionContext for each "stop
1382 // with a reason" thread. It should add to the stream whatever text it
1383 // wants to show the user, and return False to indicate it wants the target
1384 // not to stop.
1386 lldb::StreamSP output) = 0;
1387
1388 // Set the Thread Specifier. The stop hook will own the thread specifier,
1389 // and is responsible for deleting it when we're done.
1390 void SetThreadSpecifier(ThreadSpec *specifier);
1391
1393
1394 bool IsActive() { return m_active; }
1395
1396 void SetIsActive(bool is_active) { m_active = is_active; }
1397
1398 void SetAutoContinue(bool auto_continue) {
1399 m_auto_continue = auto_continue;
1400 }
1401
1402 bool GetAutoContinue() const { return m_auto_continue; }
1403
1404 void SetRunAtInitialStop(bool at_initial_stop) {
1405 m_at_initial_stop = at_initial_stop;
1406 }
1407
1409
1410 void SetSuppressOutput(bool suppress_output) {
1411 m_suppress_output = suppress_output;
1412 }
1413
1414 bool GetSuppressOutput() const { return m_suppress_output; }
1415
1416 void GetDescription(Stream &s, lldb::DescriptionLevel level) const;
1418 lldb::DescriptionLevel level) const = 0;
1419
1420 protected:
1423 std::unique_ptr<ThreadSpec> m_thread_spec_up;
1424 bool m_active = true;
1425 bool m_auto_continue = false;
1427 bool m_suppress_output = false;
1428
1429 StopHook(lldb::TargetSP target_sp, lldb::user_id_t uid);
1430 };
1431
1433 public:
1434 ~StopHookCommandLine() override = default;
1435
1437 void SetActionFromString(const std::string &strings);
1438 void SetActionFromStrings(const std::vector<std::string> &strings);
1439
1441 lldb::StreamSP output_sp) override;
1443 lldb::DescriptionLevel level) const override;
1444
1445 private:
1447 // Use CreateStopHook to make a new empty stop hook. Use SetActionFromString
1448 // to fill it with commands, and SetSpecifier to set the specifier shared
1449 // pointer (can be null, that will match anything.)
1451 : StopHook(target_sp, uid) {}
1452 friend class Target;
1453 };
1454
1456 public:
1457 ~StopHookScripted() override = default;
1459 lldb::StreamSP output) override;
1460
1461 Status SetScriptCallback(std::string class_name,
1462 StructuredData::ObjectSP extra_args_sp);
1463
1465 lldb::DescriptionLevel level) const override;
1466
1467 private:
1468 std::string m_class_name;
1469 /// This holds the dictionary of keys & values that can be used to
1470 /// parametrize any given callback's behavior.
1473
1474 /// Use CreateStopHook to make a new empty stop hook. Use SetScriptCallback
1475 /// to set the script to execute, and SetSpecifier to set the specifier
1476 /// shared pointer (can be null, that will match anything.)
1478 : StopHook(target_sp, uid) {}
1479 friend class Target;
1480 };
1481
1482 class StopHookCoded : public StopHook {
1483 public:
1484 ~StopHookCoded() override = default;
1485
1487 lldb::StreamSP output);
1488
1489 void SetCallback(llvm::StringRef name, HandleStopCallback *callback) {
1490 m_name = name;
1491 m_callback = callback;
1492 }
1493
1495 lldb::StreamSP output) override {
1496 return m_callback(exc_ctx, output);
1497 }
1498
1500 lldb::DescriptionLevel level) const override {
1501 s.Indent();
1502 s.Printf("%s (built-in)\n", m_name.c_str());
1503 }
1504
1505 private:
1506 std::string m_name;
1508
1509 /// Use CreateStopHook to make a new empty stop hook. Use SetCallback to set
1510 /// the callback to execute, and SetSpecifier to set the specifier shared
1511 /// pointer (can be null, that will match anything.)
1513 : StopHook(target_sp, uid) {}
1514 friend class Target;
1515 };
1516
1518
1519 typedef std::shared_ptr<StopHook> StopHookSP;
1520
1521 /// Add an empty stop hook to the Target's stop hook list, and returns a
1522 /// shared pointer to the new hook.
1523 StopHookSP CreateStopHook(StopHook::StopHookKind kind, bool internal = false);
1524
1525 /// If you tried to create a stop hook, and that failed, call this to
1526 /// remove the stop hook, as it will also reset the stop hook counter.
1528
1529 // Runs the stop hooks that have been registered for this target.
1530 // Returns true if the stop hooks cause the target to resume.
1531 // Pass at_initial_stop if this is the stop where lldb gains
1532 // control over the process for the first time.
1533 bool RunStopHooks(bool at_initial_stop = false);
1534
1535 bool SetSuppresStopHooks(bool suppress) {
1536 bool old_value = m_suppress_stop_hooks;
1537 m_suppress_stop_hooks = suppress;
1538 return old_value;
1539 }
1540
1542
1544
1545 void RemoveAllStopHooks();
1546
1547 StopHookSP GetStopHookByID(lldb::user_id_t uid);
1548
1549 bool SetStopHookActiveStateByID(lldb::user_id_t uid, bool active_state);
1550
1551 void SetAllStopHooksActiveState(bool active_state);
1552
1553 const std::vector<StopHookSP> GetStopHooks(bool internal = false) const;
1554
1556
1557 void SetPlatform(const lldb::PlatformSP &platform_sp) {
1558 m_platform_sp = platform_sp;
1559 }
1560
1562
1563 // Methods.
1565 GetSearchFilterForModule(const FileSpec *containingModule);
1566
1568 GetSearchFilterForModuleList(const FileSpecList *containingModuleList);
1569
1571 GetSearchFilterForModuleAndCUList(const FileSpecList *containingModules,
1572 const FileSpecList *containingSourceFiles);
1573
1575 const char *repl_options, bool can_create);
1576
1577 void SetREPL(lldb::LanguageType language, lldb::REPLSP repl_sp);
1578
1582
1584
1585 /// Add a signal for the target. This will get copied over to the process
1586 /// if the signal exists on that target. Only the values with Yes and No are
1587 /// set, Calculate values will be ignored.
1588protected:
1597 using DummySignalElement = llvm::StringMapEntry<DummySignalValues>;
1598 static bool UpdateSignalFromDummy(lldb::UnixSignalsSP signals_sp,
1599 const DummySignalElement &element);
1600 static bool ResetSignalFromDummy(lldb::UnixSignalsSP signals_sp,
1601 const DummySignalElement &element);
1602
1603public:
1604 /// Add a signal to the Target's list of stored signals/actions. These
1605 /// values will get copied into any processes launched from
1606 /// this target.
1607 void AddDummySignal(llvm::StringRef name, LazyBool pass, LazyBool print,
1608 LazyBool stop);
1609 /// Updates the signals in signals_sp using the stored dummy signals.
1610 /// If warning_stream_sp is not null, if any stored signals are not found in
1611 /// the current process, a warning will be emitted here.
1613 lldb::StreamSP warning_stream_sp);
1614 /// Clear the dummy signals in signal_names from the target, or all signals
1615 /// if signal_names is empty. Also remove the behaviors they set from the
1616 /// process's signals if it exists.
1617 void ClearDummySignals(Args &signal_names);
1618 /// Print all the signals set in this target.
1619 void PrintDummySignals(Stream &strm, Args &signals);
1620
1621protected:
1622 /// Implementing of ModuleList::Notifier.
1623
1624 void NotifyModuleAdded(const ModuleList &module_list,
1625 const lldb::ModuleSP &module_sp) override;
1626
1627 void NotifyModuleRemoved(const ModuleList &module_list,
1628 const lldb::ModuleSP &module_sp) override;
1629
1630 void NotifyModuleUpdated(const ModuleList &module_list,
1631 const lldb::ModuleSP &old_module_sp,
1632 const lldb::ModuleSP &new_module_sp) override;
1633
1634 void NotifyWillClearList(const ModuleList &module_list) override;
1635
1636 void NotifyModulesRemoved(lldb_private::ModuleList &module_list) override;
1637
1638 class Arch {
1639 public:
1640 explicit Arch(const ArchSpec &spec);
1641 const Arch &operator=(const ArchSpec &spec);
1642
1643 const ArchSpec &GetSpec() const { return m_spec; }
1644 Architecture *GetPlugin() const { return m_plugin_up.get(); }
1645
1646 private:
1648 std::unique_ptr<Architecture> m_plugin_up;
1649 };
1650
1651 // Member variables.
1653 lldb::PlatformSP m_platform_sp; ///< The platform for this target.
1654 std::recursive_mutex m_mutex; ///< An API mutex that is used by the lldb::SB*
1655 /// classes make the SB interface thread safe
1656 /// When the private state thread calls SB API's - usually because it is
1657 /// running OS plugin or Python ThreadPlan code - it should not block on the
1658 /// API mutex that is held by the code that kicked off the sequence of events
1659 /// that led us to run the code. We hand out this mutex instead when we
1660 /// detect that code is running on the private state thread.
1661 std::recursive_mutex m_private_mutex;
1663 std::string m_label;
1664 ModuleList m_images; ///< The list of images for this process (shared
1665 /// libraries and anything dynamically loaded).
1671 std::map<ConstString, std::unique_ptr<BreakpointName>>;
1673
1677 // We want to tightly control the process destruction process so we can
1678 // correctly tear down everything that we need to, so the only class that
1679 // knows about the process lifespan is this target class.
1684
1685 typedef std::map<lldb::LanguageType, lldb::REPLSP> REPLMap;
1687
1689
1690 typedef std::map<lldb::user_id_t, StopHookSP> StopHookCollection;
1693 std::vector<StopHookSP> m_internal_stop_hooks;
1694 uint32_t m_latest_stop_hook_id; /// This records the last natural stop at
1695 /// which we ran a stop-hook.
1697 bool m_suppress_stop_hooks; /// Used to not run stop hooks for expressions
1701 LLDB_INVALID_GLOBALLY_UNIQUE_TARGET_ID; /// The globally unique ID
1702 /// assigned to this target
1703 /// An optional \a lldb_private::Trace object containing processor trace
1704 /// information of this target.
1706 /// Stores the frame recognizers of this target.
1708 /// These are used to set the signal state when you don't have a process and
1709 /// more usefully in the Dummy target where you can't know exactly what
1710 /// signals you will have.
1711 llvm::StringMap<DummySignalValues> m_dummy_signals;
1712
1713 static void ImageSearchPathsChanged(const PathMappingList &path_list,
1714 void *baton);
1715
1716 // Utilities for `statistics` command.
1717private:
1718 // Target metrics storage.
1720
1721public:
1722 /// Get metrics associated with this target in JSON format.
1723 ///
1724 /// Target metrics help measure timings and information that is contained in
1725 /// a target. These are designed to help measure performance of a debug
1726 /// session as well as represent the current state of the target, like
1727 /// information on the currently modules, currently set breakpoints and more.
1728 ///
1729 /// \return
1730 /// Returns a JSON value that contains all target metrics.
1731 llvm::json::Value
1733
1734 void ResetStatistics();
1735
1737
1738protected:
1739 /// Construct with optional file and arch.
1740 ///
1741 /// This member is private. Clients must use
1742 /// TargetList::CreateTarget(const FileSpec*, const ArchSpec*)
1743 /// so all targets can be tracked from the central target list.
1744 ///
1745 /// \see TargetList::CreateTarget(const FileSpec*, const ArchSpec*)
1746 Target(Debugger &debugger, const ArchSpec &target_arch,
1747 const lldb::PlatformSP &platform_sp, bool is_dummy_target);
1748
1749 // Helper function.
1750 bool ProcessIsValid();
1751
1752 // Copy breakpoints, stop hooks and so forth from the dummy target:
1753 void PrimeFromDummyTarget(Target &target);
1754
1755 void AddBreakpoint(lldb::BreakpointSP breakpoint_sp, bool internal);
1756
1758
1759 /// Return a recommended size for memory reads at \a addr, optimizing for
1760 /// cache usage.
1762
1763 Target(const Target &) = delete;
1764 const Target &operator=(const Target &) = delete;
1765
1767 return m_section_load_history.GetCurrentSectionLoadList();
1768 }
1769};
1770
1771} // namespace lldb_private
1772
1773#endif // LLDB_TARGET_TARGET_H
static llvm::raw_ostream & error(Stream &strm)
A section + offset based address class.
Definition Address.h:62
An architecture specification class.
Definition ArchSpec.h:31
A command line argument class.
Definition Args.h:33
General Outline: Allows adding and removing breakpoints and find by ID and index.
"lldb/Breakpoint/BreakpointOptions.h" Class that manages the options on a breakpoint or breakpoint lo...
Broadcaster(lldb::BroadcasterManagerSP manager_sp, std::string name)
Construct with a broadcaster with a name.
Generic representation of a type in a programming language.
A uniqued constant string class.
Definition ConstString.h:40
A class to manage flag bits.
Definition Debugger.h:80
void SetPreferredSymbolContexts(SymbolContextList contexts)
Definition Target.h:339
void SetOneThreadTimeout(const Timeout< std::micro > &timeout)
Definition Target.h:398
void SetUnwindOnError(bool unwind=false)
Definition Target.h:371
SourceLanguage GetLanguage() const
Definition Target.h:333
const char * GetPoundLineFilePath() const
Definition Target.h:457
lldb::DynamicValueType m_use_dynamic
Definition Target.h:505
void SetExecutionPolicy(ExecutionPolicy policy=eExecutionPolicyAlways)
Definition Target.h:329
Timeout< std::micro > m_one_thread_timeout
Definition Target.h:507
bool InvokeCancelCallback(lldb::ExpressionEvaluationPhase phase) const
Definition Target.h:439
lldb::DynamicValueType GetUseDynamic() const
Definition Target.h:383
void SetKeepInMemory(bool keep=true)
Definition Target.h:381
void SetCoerceToId(bool coerce=true)
Definition Target.h:367
void SetLanguage(lldb::LanguageType language_type)
Definition Target.h:335
ExecutionPolicy GetExecutionPolicy() const
Definition Target.h:327
Timeout< std::micro > m_timeout
Definition Target.h:506
void SetPrefix(const char *prefix)
Definition Target.h:360
void SetTryAllThreads(bool try_others=true)
Definition Target.h:404
void SetPoundLine(const char *path, uint32_t line) const
Definition Target.h:447
void SetRetriesWithFixIts(uint64_t number_of_retries)
Definition Target.h:473
SymbolContextList m_preferred_lookup_contexts
During expression evaluation, any SymbolContext in this list will be used for symbol/function lookup ...
Definition Target.h:519
void SetTimeout(const Timeout< std::micro > &timeout)
Definition Target.h:392
static constexpr ExecutionPolicy default_execution_policy
Definition Target.h:322
void SetStopOthers(bool stop_others=true)
Definition Target.h:408
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:503
void SetCancelCallback(lldb::ExpressionCancelCallback callback, void *baton)
Definition Target.h:434
const Timeout< std::micro > & GetTimeout() const
Definition Target.h:390
const SymbolContextList & GetPreferredSymbolContexts() const
Definition Target.h:343
void SetIgnoreBreakpoints(bool ignore=false)
Definition Target.h:375
void SetLanguage(uint16_t name, uint32_t version)
Set the language using a pair of language code and version as defined by the DWARF 6 specification.
Definition Target.h:350
void SetUseDynamic(lldb::DynamicValueType dynamic=lldb::eDynamicCanRunTarget)
Definition Target.h:386
lldb::ExpressionCancelCallback m_cancel_callback
Definition Target.h:508
static constexpr std::chrono::milliseconds default_timeout
Definition Target.h:317
const Timeout< std::micro > & GetOneThreadTimeout() const
Definition Target.h:394
"lldb/Target/ExecutionContextScope.h" Inherit from this if your object can reconstruct its execution ...
"lldb/Target/ExecutionContext.h" A class that contains an execution context.
A file collection class.
A file utility class.
Definition FileSpec.h:57
Encapsulates a function that can be called.
A collection class for Module objects.
Definition ModuleList.h:104
A class that describes an executable image and its associated object and symbol files.
Definition Module.h:90
Class that provides a registry of known stack frame recognizers.
An error handling class.
Definition Status.h:118
A stream class that can stream formatted output to a file.
Definition Stream.h:28
size_t Indent(llvm::StringRef s="")
Indent the current line in the stream.
Definition Stream.cpp:157
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition Stream.cpp:134
std::shared_ptr< Object > ObjectSP
A class that wraps a std::map of SummaryStatistics objects behind a mutex.
Definition Statistics.h:284
Defines a list of symbol context objects.
Defines a symbol context baton that can be handed other debug core functions.
uint32_t GetMaximumSizeOfStringSummary() const
Definition Target.cpp:4910
FileSpecList GetDebugFileSearchPaths()
Definition Target.cpp:4791
llvm::StringRef GetLaunchWorkingDirectory() const
Definition Target.cpp:4597
bool GetDisplayRecognizedArguments() const
Definition Target.cpp:5068
ImportStdModule GetImportStdModule() const
Definition Target.cpp:4807
void AppendExecutableSearchPaths(const FileSpec &)
Definition Target.cpp:4778
bool GetEnableSyntheticValue() const
Definition Target.cpp:4877
void SetStandardInputPath(const char *path)=delete
ProcessLaunchInfo m_launch_info
Definition Target.h:302
uint64_t GetExprAllocAlign() const
Definition Target.cpp:4989
MemoryModuleLoadLevel GetMemoryModuleLoadLevel() const
Definition Target.cpp:5040
llvm::StringRef GetArg0() const
Definition Target.cpp:4650
uint32_t GetMaximumMemReadSize() const
Definition Target.cpp:4916
void SetRunArguments(const Args &args)
Definition Target.cpp:4667
FileSpec GetStandardErrorPath() const
Definition Target.cpp:4942
bool GetEnableNotifyAboutFixIts() const
Definition Target.cpp:4833
bool SetPreferDynamicValue(lldb::DynamicValueType d)
Definition Target.cpp:4534
void SetDisplayRecognizedArguments(bool b)
Definition Target.cpp:5074
std::optional< bool > GetExperimentalPropertyValue(size_t prop_idx, ExecutionContext *exe_ctx=nullptr) const
Definition Target.cpp:4473
const ProcessLaunchInfo & GetProcessLaunchInfo() const
Definition Target.cpp:5079
Environment ComputeEnvironment() const
Definition Target.cpp:4673
void SetStandardOutputPath(const char *path)=delete
bool GetUserSpecifiedTrapHandlerNames(Args &args) const
Definition Target.cpp:5047
uint64_t GetExprErrorLimit() const
Definition Target.cpp:4971
bool GetEnableAutoImportClangModules() const
Definition Target.cpp:4801
bool GetDebugUtilityExpression() const
Definition Target.cpp:5185
DynamicClassInfoHelper GetDynamicClassInfoHelper() const
Definition Target.cpp:4814
FileSpec GetStandardOutputPath() const
Definition Target.cpp:4932
void SetDisplayRuntimeSupportValues(bool b)
Definition Target.cpp:5063
uint32_t GetMaximumNumberOfChildrenToDisplay() const
Definition Target.cpp:4895
void SetRequireHardwareBreakpoints(bool b)
Definition Target.cpp:5117
bool GetAutoInstallMainExecutable() const
Definition Target.cpp:5122
const char * GetDisassemblyFeatures() const
Definition Target.cpp:4629
RealpathPrefixes GetSourceRealpathPrefixes() const
Definition Target.cpp:4645
uint64_t GetNumberOfRetriesWithFixits() const
Definition Target.cpp:4827
uint64_t GetExprAllocSize() const
Definition Target.cpp:4983
llvm::StringRef GetExpressionPrefixContents()
Definition Target.cpp:4957
PathMappingList & GetObjectPathMap() const
Definition Target.cpp:4764
const char * GetDisassemblyFlavor() const
Definition Target.cpp:4609
FileSpec GetStandardInputPath() const
Definition Target.cpp:4922
lldb::DynamicValueType GetPreferDynamicValue() const
Definition Target.cpp:4527
InlineStrategy GetInlineStrategy() const
Definition Target.cpp:4636
Environment GetTargetEnvironment() const
Definition Target.cpp:4733
bool GetDisplayRuntimeSupportValues() const
Definition Target.cpp:5057
void SetUserSpecifiedTrapHandlerNames(const Args &args)
Definition Target.cpp:5052
uint32_t GetMaxZeroPaddingInFloatFormat() const
Definition Target.cpp:4889
uint64_t GetExprAllocAddress() const
Definition Target.cpp:4977
LoadCWDlldbinitFile GetLoadCWDlldbinitFile() const
Definition Target.cpp:5026
Environment GetInheritedEnvironment() const
Definition Target.cpp:4705
void SetArg0(llvm::StringRef arg)
Definition Target.cpp:4656
bool GetInjectLocalVariables(ExecutionContext *exe_ctx) const
Definition Target.cpp:4484
void SetStandardErrorPath(const char *path)=delete
bool ShowHexVariableValuesWithLeadingZeroes() const
Definition Target.cpp:4883
SourceLanguage GetLanguage() const
Definition Target.cpp:4952
Environment GetEnvironment() const
Definition Target.cpp:4701
void SetProcessLaunchInfo(const ProcessLaunchInfo &launch_info)
Definition Target.cpp:5083
FileSpec GetSaveJITObjectsDir() const
Definition Target.cpp:4839
void SetEnvironment(Environment env)
Definition Target.cpp:4744
LoadScriptFromSymFile GetLoadScriptFromSymbolFile() const
Definition Target.cpp:5019
const char * GetDisassemblyCPU() const
Definition Target.cpp:4622
void SetStandardErrorPath(llvm::StringRef path)
Definition Target.cpp:4947
bool GetRunArguments(Args &args) const
Definition Target.cpp:4662
FileSpecList GetExecutableSearchPaths()
Definition Target.cpp:4786
ArchSpec GetDefaultArchitecture() const
Definition Target.cpp:4511
Disassembler::HexImmediateStyle GetHexImmediateStyle() const
Definition Target.cpp:5033
void SetUseDIL(ExecutionContext *exe_ctx, bool b)
Definition Target.cpp:4502
std::unique_ptr< TargetExperimentalProperties > m_experimental_properties_up
Definition Target.h:303
FileSpecList GetClangModuleSearchPaths()
Definition Target.cpp:4796
void SetStandardOutputPath(llvm::StringRef path)
Definition Target.cpp:4937
bool GetRequireHardwareBreakpoints() const
Definition Target.cpp:5111
PathMappingList & GetSourcePathMap() const
Definition Target.cpp:4756
bool GetAutoSourceMapRelative() const
Definition Target.cpp:4772
bool GetUseDIL(ExecutionContext *exe_ctx) const
Definition Target.cpp:4490
void SetDefaultArchitecture(const ArchSpec &arch)
Definition Target.cpp:4516
void SetStandardInputPath(llvm::StringRef path)
Definition Target.cpp:4927
TargetProperties(Target *target)
Definition Target.cpp:4397
bool GetDisplayExpressionsInCrashlogs() const
Definition Target.cpp:5013
bool GetEnableAutoApplyFixIts() const
Definition Target.cpp:4821
void SetDebugUtilityExpression(bool debug)
Definition Target.cpp:5191
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:4902
A class that represents statistics for a since lldb_private::Target.
Definition Statistics.h:312
std::unique_ptr< Architecture > m_plugin_up
Definition Target.h:1648
const ArchSpec & GetSpec() const
Definition Target.h:1643
const Arch & operator=(const ArchSpec &spec)
Definition Target.cpp:164
Arch(const ArchSpec &spec)
Definition Target.cpp:160
Architecture * GetPlugin() const
Definition Target.h:1644
void GetSubclassDescription(Stream &s, lldb::DescriptionLevel level) const override
Definition Target.h:1499
HandleStopCallback * m_callback
Definition Target.h:1507
StopHookResult HandleStop(ExecutionContext &exc_ctx, lldb::StreamSP output) override
Definition Target.h:1494
StopHookCoded(lldb::TargetSP target_sp, lldb::user_id_t uid)
Use CreateStopHook to make a new empty stop hook.
Definition Target.h:1512
void SetCallback(llvm::StringRef name, HandleStopCallback *callback)
Definition Target.h:1489
StopHookResult(ExecutionContext &exc_ctx, lldb::StreamSP output) HandleStopCallback
Definition Target.h:1486
void SetActionFromString(const std::string &strings)
Definition Target.cpp:4016
StopHookCommandLine(lldb::TargetSP target_sp, lldb::user_id_t uid)
Definition Target.h:1450
void SetActionFromStrings(const std::vector< std::string > &strings)
Definition Target.cpp:4020
StopHookResult HandleStop(ExecutionContext &exc_ctx, lldb::StreamSP output_sp) override
Definition Target.cpp:4027
void GetSubclassDescription(Stream &s, lldb::DescriptionLevel level) const override
Definition Target.cpp:3997
Status SetScriptCallback(std::string class_name, StructuredData::ObjectSP extra_args_sp)
Definition Target.cpp:4061
StopHookResult HandleStop(ExecutionContext &exc_ctx, lldb::StreamSP output) override
Definition Target.cpp:4101
StopHookScripted(lldb::TargetSP target_sp, lldb::user_id_t uid)
Use CreateStopHook to make a new empty stop hook.
Definition Target.h:1477
void GetSubclassDescription(Stream &s, lldb::DescriptionLevel level) const override
Definition Target.cpp:4120
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:1471
lldb::ScriptedStopHookInterfaceSP m_interface_sp
Definition Target.h:1472
bool GetRunAtInitialStop() const
Definition Target.h:1408
SymbolContextSpecifier * GetSpecifier()
Definition Target.h:1377
void SetSpecifier(SymbolContextSpecifier *specifier)
Definition Target.cpp:3931
virtual StopHookResult HandleStop(ExecutionContext &exe_ctx, lldb::StreamSP output)=0
std::unique_ptr< ThreadSpec > m_thread_spec_up
Definition Target.h:1423
void SetIsActive(bool is_active)
Definition Target.h:1396
void SetSuppressOutput(bool suppress_output)
Definition Target.h:1410
void SetThreadSpecifier(ThreadSpec *specifier)
Definition Target.cpp:3935
ThreadSpec * GetThreadSpecifier()
Definition Target.h:1392
StopHook(const StopHook &rhs)
Definition Target.cpp:3923
bool ExecutionContextPasses(const ExecutionContext &exe_ctx)
Definition Target.cpp:3939
lldb::TargetSP & GetTarget()
Definition Target.h:1371
void SetRunAtInitialStop(bool at_initial_stop)
Definition Target.h:1404
lldb::SymbolContextSpecifierSP m_specifier_sp
Definition Target.h:1422
virtual void GetSubclassDescription(Stream &s, lldb::DescriptionLevel level) const =0
void GetDescription(Stream &s, lldb::DescriptionLevel level) const
Definition Target.cpp:3955
void SetAutoContinue(bool auto_continue)
Definition Target.h:1398
const ModuleList & GetModuleList() const
Definition Target.h:577
void Dump(Stream *s) const override
Definition Target.cpp:5211
static llvm::StringRef GetFlavorString()
Definition Target.cpp:5207
static ModuleList GetModuleListFromEvent(const Event *event_ptr)
Definition Target.cpp:5240
static const TargetEventData * GetEventDataFromEvent(const Event *event_ptr)
Definition Target.cpp:5221
llvm::StringRef GetFlavor() const override
Definition Target.h:563
const lldb::TargetSP & GetTarget() const
Definition Target.h:575
TargetEventData(const lldb::TargetSP &target_sp)
Definition Target.cpp:5198
TargetEventData(const TargetEventData &)=delete
const TargetEventData & operator=(const TargetEventData &)=delete
static lldb::TargetSP GetTargetFromEvent(const Event *event_ptr)
Definition Target.cpp:5231
void ModulesDidLoad(ModuleList &module_list)
Definition Target.cpp:1856
lldb::ThreadSP CalculateThread() override
Definition Target.cpp:2589
StopHookCollection m_stop_hooks
Definition Target.h:1691
Module * GetExecutableModulePointer()
Definition Target.cpp:1538
void Dump(Stream *s, lldb::DescriptionLevel description_level)
Dump a description of this object to a Stream.
Definition Target.cpp:241
void DisableAllBreakpoints(bool internal_also=false)
Definition Target.cpp:1070
lldb::WatchpointSP CreateWatchpoint(lldb::addr_t addr, size_t size, const CompilerType *type, uint32_t kind, Status &error)
Definition Target.cpp:952
void ApplyNameToBreakpoints(BreakpointName &bp_name)
Definition Target.cpp:906
lldb::TraceSP GetTrace()
Get the Trace object containing processor trace information of this target.
Definition Target.cpp:3590
PathMappingList & GetImageSearchPathList()
Definition Target.cpp:2598
void FinalizeFileActions(ProcessLaunchInfo &info)
Definition Target.cpp:3715
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:2988
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:2996
ModuleList & GetImages()
Definition Target.h:1027
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:758
static Target * GetTargetFromContexts(const ExecutionContext *exe_ctx_ptr, const SymbolContext *sc_ptr)
Definition Target.cpp:2833
lldb::addr_t GetBreakableLoadAddress(lldb::addr_t addr)
Definition Target.cpp:3003
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:3863
bool SetSuppresStopHooks(bool suppress)
Definition Target.h:1535
static void ImageSearchPathsChanged(const PathMappingList &path_list, void *baton)
Definition Target.cpp:2602
llvm::Expected< lldb_private::Address > GetEntryPointAddress()
This method will return the address of the starting function for this binary, e.g.
Definition Target.cpp:2954
bool IgnoreWatchpointByID(lldb::watch_id_t watch_id, uint32_t ignore_count)
Definition Target.cpp:1506
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:724
lldb::BreakpointSP GetBreakpointByID(lldb::break_id_t break_id)
Definition Target.cpp:419
std::shared_ptr< StopHook > StopHookSP
Definition Target.h:1519
llvm::StringRef GetBroadcasterClass() const override
This needs to be filled in if you are going to register the broadcaster with the broadcaster manager ...
Definition Target.h:546
void SymbolsDidLoad(ModuleList &module_list)
Definition Target.cpp:1876
bool ClearAllWatchpointHistoricValues()
Definition Target.cpp:1420
const std::vector< StopHookSP > GetStopHooks(bool internal=false) const
Definition Target.cpp:3116
void SetTrace(const lldb::TraceSP &trace_sp)
Set the Trace object containing processor trace information of this target.
Definition Target.cpp:3588
BreakpointList & GetBreakpointList(bool internal=false)
Definition Target.cpp:405
CompilerType GetRegisterType(const std::string &name, const lldb_private::RegisterFlags &flags, uint32_t byte_size)
Definition Target.cpp:2637
BreakpointNameList m_breakpoint_names
Definition Target.h:1672
lldb_private::SummaryStatisticsCache & GetSummaryStatisticsCache()
Definition Target.cpp:3405
lldb::addr_t GetSectionLoadAddress(const lldb::SectionSP &section_sp)
Definition Target.cpp:5265
llvm::StringRef GetABIName() const
Returns the name of the target's ABI plugin.
Definition Target.cpp:394
SourceManager & GetSourceManager()
Definition Target.cpp:3040
lldb::SearchFilterSP GetSearchFilterForModuleList(const FileSpecList *containingModuleList)
Definition Target.cpp:687
StopHookSP GetStopHookByID(lldb::user_id_t uid)
Definition Target.cpp:3082
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:1711
lldb::ProcessSP m_process_sp
Definition Target.h:1680
Debugger & GetDebugger() const
Definition Target.h:1108
lldb::SearchFilterSP m_search_filter_sp
Definition Target.h:1681
PersistentExpressionState * GetPersistentExpressionStateForLanguage(lldb::LanguageType language)
Definition Target.cpp:2680
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:3851
bool m_is_dummy_target
Used to not run stop hooks for expressions.
Definition Target.h:1698
static bool UpdateSignalFromDummy(lldb::UnixSignalsSP signals_sp, const DummySignalElement &element)
Definition Target.cpp:3809
PathMappingList m_image_search_paths
Definition Target.h:1682
bool ModuleIsExcludedForUnconstrainedSearches(const FileSpec &module_spec)
Return whether this FileSpec corresponds to a module that should be considered for general searches.
Definition Target.cpp:1932
lldb::StackFrameSP CalculateStackFrame() override
Definition Target.cpp:2591
SectionLoadList & GetSectionLoadList()
Definition Target.h:1766
lldb::addr_t GetPersistentSymbol(ConstString name)
Definition Target.cpp:2934
void PrimeFromDummyTarget(Target &target)
Definition Target.cpp:217
static void SettingsTerminate()
Definition Target.cpp:2792
bool EnableWatchpointByID(lldb::watch_id_t watch_id)
Definition Target.cpp:1471
bool ResolveFileAddress(lldb::addr_t load_addr, Address &so_addr)
Definition Target.cpp:3321
bool ClearAllWatchpointHitCounts()
Definition Target.cpp:1406
size_t ReadMemoryFromFileCache(const Address &addr, void *dst, size_t dst_len, Status &error)
Definition Target.cpp:1964
void ClearAllLoadedSections()
Definition Target.cpp:3397
std::vector< lldb::TypeSystemSP > GetScratchTypeSystems(bool create_on_demand=true)
Definition Target.cpp:2646
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:2263
void AddNameToBreakpoint(BreakpointID &id, llvm::StringRef name, Status &error)
Definition Target.cpp:826
bool LoadScriptingResources(std::list< Status > &errors, Stream &feedback_stream, bool continue_on_error=true)
Definition Target.h:1001
void DumpSectionLoadList(Stream &s)
Definition Target.cpp:5271
void DeleteCurrentProcess()
Definition Target.cpp:276
BreakpointList m_internal_breakpoint_list
Definition Target.h:1669
int64_t ReadSignedIntegerFromMemory(const Address &addr, size_t integer_byte_size, int64_t fail_value, Status &error, bool force_live_memory=false)
Definition Target.cpp:2292
void DisableAllowedBreakpoints()
Definition Target.cpp:1080
bool SetSectionUnloaded(const lldb::SectionSP &section_sp)
Definition Target.cpp:3375
lldb::TargetSP CalculateTarget() override
Definition Target.cpp:2585
const lldb::ProcessSP & GetProcessSP() const
Definition Target.cpp:310
void ClearModules(bool delete_locations)
Definition Target.cpp:1560
bool RemoveBreakpointByID(lldb::break_id_t break_id)
Definition Target.cpp:1104
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:2344
static bool ResetSignalFromDummy(lldb::UnixSignalsSP signals_sp, const DummySignalElement &element)
Definition Target.cpp:3836
Architecture * GetArchitecturePlugin() const
Definition Target.h:1106
llvm::json::Value ReportStatistics(const lldb_private::StatisticsOptions &options)
Get metrics associated with this target in JSON format.
Definition Target.cpp:5257
friend class TargetList
Definition Target.h:529
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:2733
TargetStats & GetStatistics()
Definition Target.h:1736
void EnableAllBreakpoints(bool internal_also=false)
Definition Target.cpp:1087
Status Launch(ProcessLaunchInfo &launch_info, Stream *stream)
Definition Target.cpp:3420
bool DisableBreakpointByID(lldb::break_id_t break_id)
Definition Target.cpp:1124
lldb::BreakpointSP CreateBreakpointAtUserEntry(Status &error)
Definition Target.cpp:431
BreakpointName * FindBreakpointName(ConstString name, bool can_create, Status &error)
Definition Target.cpp:858
std::map< lldb::user_id_t, StopHookSP > StopHookCollection
Definition Target.h:1690
llvm::Expected< lldb::TraceSP > CreateTrace()
Create a Trace object for the current target using the using the default supported tracing technology...
Definition Target.cpp:3592
lldb::TraceSP m_trace_sp
The globally unique ID assigned to this target.
Definition Target.h:1705
lldb::user_id_t GetGloballyUniqueID() const
Get the globally unique ID for this target.
Definition Target.h:612
bool RemoveAllWatchpoints(bool end_to_end=true)
Definition Target.cpp:1324
bool ReadPointerFromMemory(const Address &addr, Status &error, Address &pointer_addr, bool force_live_memory=false)
Definition Target.cpp:2314
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:3068
WatchpointList m_watchpoint_list
Definition Target.h:1675
BreakpointList m_breakpoint_list
Definition Target.h:1668
lldb::SourceManagerUP m_source_manager_up
Definition Target.h:1688
bool RemoveWatchpointByID(lldb::watch_id_t watch_id)
Definition Target.cpp:1490
bool ResolveLoadAddress(lldb::addr_t load_addr, Address &so_addr, uint32_t stop_id=SectionLoadHistory::eStopIDNow, bool allow_section_end=false)
Definition Target.cpp:3315
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:2214
void DeleteBreakpointName(ConstString name)
Definition Target.cpp:882
void NotifyWillClearList(const ModuleList &module_list) override
Definition Target.cpp:1818
bool SetArchitecture(const ArchSpec &arch_spec, bool set_platform=false, bool merge=true)
Set the architecture for this target.
Definition Target.cpp:1702
void NotifyModuleAdded(const ModuleList &module_list, const lldb::ModuleSP &module_sp) override
Implementing of ModuleList::Notifier.
Definition Target.cpp:1820
llvm::Expected< lldb::TypeSystemSP > GetScratchTypeSystemForLanguage(lldb::LanguageType language, bool create_on_demand=true)
Definition Target.cpp:2611
void ConfigureBreakpointName(BreakpointName &bp_name, const BreakpointOptions &options, const BreakpointName::Permissions &permissions)
Definition Target.cpp:898
lldb_private::SummaryStatisticsSP GetSummaryStatisticsSPForProviderName(lldb_private::TypeSummaryImpl &summary_provider)
Definition Target.cpp:3399
lldb::SearchFilterSP GetSearchFilterForModuleAndCUList(const FileSpecList *containingModules, const FileSpecList *containingSourceFiles)
Definition Target.cpp:704
lldb::ModuleSP GetExecutableModule()
Gets the module for the main executable.
Definition Target.cpp:1522
bool SetStopHookActiveStateByID(lldb::user_id_t uid, bool active_state)
Definition Target.cpp:3092
const lldb::ProcessSP & CreateProcess(lldb::ListenerSP listener_sp, llvm::StringRef plugin_name, const FileSpec *crash_file, bool can_connect)
Definition Target.cpp:298
void SetAllStopHooksActiveState(bool active_state)
Definition Target.cpp:3103
std::vector< StopHookSP > m_internal_stop_hooks
Definition Target.h:1693
lldb::ExpressionVariableSP GetPersistentVariable(ConstString name)
Definition Target.cpp:2915
void NotifyModulesRemoved(lldb_private::ModuleList &module_list) override
Definition Target.cpp:1852
StopHookSP CreateStopHook(StopHook::StopHookKind kind, bool internal=false)
Add an empty stop hook to the Target's stop hook list, and returns a shared pointer to the new hook.
Definition Target.cpp:3046
size_t ReadCStringFromMemory(const Address &addr, std::string &out_str, Status &error, bool force_live_memory=false)
Definition Target.cpp:2124
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:1654
lldb::user_id_t m_target_unique_id
Definition Target.h:1700
void ModulesDidUnload(ModuleList &module_list, bool delete_locations)
Definition Target.cpp:1892
void CalculateExecutionContext(ExecutionContext &exe_ctx) override
Reconstruct the object's execution context into sc.
Definition Target.cpp:2593
llvm::Expected< lldb::DisassemblerSP > ReadInstructions(const Address &start_addr, uint32_t count, const char *flavor_string=nullptr)
Definition Target.cpp:3009
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:3617
void NotifyModuleUpdated(const ModuleList &module_list, const lldb::ModuleSP &old_module_sp, const lldb::ModuleSP &new_module_sp) override
Definition Target.cpp:1840
SummaryStatisticsCache m_summary_statistics_cache
Definition Target.h:1666
Target(const Target &)=delete
void RegisterInternalStopHooks()
Status SerializeBreakpointsToFile(const FileSpec &file, const BreakpointIDList &bp_ids, bool append)
Definition Target.cpp:1165
void DidExec()
Called as the last function in Process::DidExec().
Definition Target.cpp:1567
void SaveScriptedLaunchInfo(lldb_private::ProcessInfo &process_info)
Definition Target.cpp:3409
bool GetSuppressStopHooks()
Definition Target.h:1541
std::string m_label
Definition Target.h:1663
lldb::user_id_t m_stop_hook_next_id
Definition Target.h:1692
static FileSpecList GetDefaultExecutableSearchPaths()
Definition Target.cpp:2794
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:741
lldb::SearchFilterSP GetSearchFilterForModule(const FileSpec *containingModule)
Definition Target.cpp:669
llvm::StringMapEntry< DummySignalValues > DummySignalElement
Definition Target.h:1597
std::recursive_mutex & GetAPIMutex()
Definition Target.cpp:5248
static llvm::StringRef GetStaticBroadcasterClass()
Definition Target.cpp:170
static FileSpecList GetDefaultDebugFileSearchPaths()
Definition Target.cpp:2798
void EnableAllowedBreakpoints()
Definition Target.cpp:1097
virtual 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, bool *did_read_live_memory=nullptr)
Definition Target.cpp:1998
llvm::Error SetLabel(llvm::StringRef label)
Set a label for a target.
Definition Target.cpp:2813
uint32_t m_latest_stop_hook_id
Definition Target.h:1694
StackFrameRecognizerManager & GetFrameRecognizerManager()
Definition Target.h:1579
void RemoveAllowedBreakpoints()
Definition Target.cpp:1049
bool DisableAllWatchpoints(bool end_to_end=true)
Definition Target.cpp:1353
bool RunStopHooks(bool at_initial_stop=false)
Definition Target.cpp:3127
void ClearSectionLoadList()
Definition Target.cpp:5269
const Target & operator=(const Target &)=delete
lldb::addr_t GetReasonableReadSize(const Address &addr)
Return a recommended size for memory reads at addr, optimizing for cache usage.
Definition Target.cpp:2201
lldb::PlatformSP m_platform_sp
The platform for this target.
Definition Target.h:1653
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:2763
static TargetProperties & GetGlobalProperties()
Definition Target.cpp:3279
Status Install(ProcessLaunchInfo *launch_info)
Definition Target.cpp:3287
lldb::PlatformSP GetPlatform()
Definition Target.h:1555
void NotifyModuleRemoved(const ModuleList &module_list, const lldb::ModuleSP &module_sp) override
Definition Target.cpp:1830
lldb::BreakpointSP CreateAddressInModuleBreakpoint(lldb::addr_t file_addr, bool internal, const FileSpec &file_spec, bool request_hardware)
Definition Target.cpp:575
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:486
void RemoveAllBreakpoints(bool internal_also=false)
Definition Target.cpp:1058
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:469
lldb::BreakpointSP CreateBreakpoint(const FileSpecList *containingModules, const FileSpecList *containingSourceFiles, const char *func_name, lldb::FunctionNameType func_name_type_mask, lldb::LanguageType language, lldb::addr_t offset, bool offset_is_insn_count, LazyBool skip_prologue, bool internal, bool request_hardware)
static ArchSpec GetDefaultArchitecture()
Definition Target.cpp:2802
void ResetBreakpointHitCounts()
Resets the hit count of all breakpoints.
Definition Target.cpp:1161
const ModuleList & GetImages() const
Get accessor for the images for this process.
Definition Target.h:1025
const ArchSpec & GetArchitecture() const
Definition Target.h:1067
WatchpointList & GetWatchpointList()
Definition Target.h:818
@ eBroadcastBitWatchpointChanged
Definition Target.h:537
@ eBroadcastBitBreakpointChanged
Definition Target.h:534
unsigned m_next_persistent_variable_index
Definition Target.h:1699
bool EnableBreakpointByID(lldb::break_id_t break_id)
Definition Target.cpp:1142
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:2303
TargetStats m_stats
Definition Target.h:1719
bool IgnoreAllWatchpoints(uint32_t ignore_count)
Definition Target.cpp:1435
void AddBreakpoint(lldb::BreakpointSP breakpoint_sp, bool internal)
Definition Target.cpp:803
TypeSystemMap m_scratch_type_system_map
Definition Target.h:1683
void AddBreakpointName(std::unique_ptr< BreakpointName > bp_name)
Definition Target.cpp:853
SectionLoadHistory m_section_load_history
Definition Target.h:1667
lldb::BreakpointSP CreateBreakpoint(const FileSpecList *containingModules, const FileSpecList *containingSourceFiles, const std::vector< std::string > &func_names, lldb::FunctionNameType func_name_type_mask, lldb::LanguageType language, lldb::addr_t m_offset, LazyBool skip_prologue, bool internal, bool request_hardware)
void GetBreakpointNames(std::vector< std::string > &names)
Definition Target.cpp:920
bool IsDummyTarget() const
Definition Target.h:601
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:175
size_t UnloadModuleSections(const lldb::ModuleSP &module_sp)
Definition Target.cpp:3356
const std::string & GetLabel() const
Definition Target.h:614
bool m_valid
This records the last natural stop at which we ran a stop-hook.
Definition Target.h:1696
bool DisableWatchpointByID(lldb::watch_id_t watch_id)
Definition Target.cpp:1452
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:3794
std::map< ConstString, std::unique_ptr< BreakpointName > > BreakpointNameList
Definition Target.h:1670
lldb::WatchpointSP m_last_created_watchpoint
Definition Target.h:1676
Status CreateBreakpointsFromFile(const FileSpec &file, BreakpointIDList &new_bps)
Definition Target.cpp:1257
Debugger & m_debugger
Definition Target.h:1652
void SetREPL(lldb::LanguageType language, lldb::REPLSP repl_sp)
Definition Target.cpp:363
lldb::BreakpointSP CreateBreakpoint(const FileSpecList *containingModules, const FileSpecList *containingSourceFiles, const char *func_names[], size_t num_names, lldb::FunctionNameType func_name_type_mask, lldb::LanguageType language, lldb::addr_t offset, LazyBool skip_prologue, bool internal, bool request_hardware)
void SetExecutableModule(lldb::ModuleSP &module_sp, LoadDependentFiles load_dependent_files=eLoadDependentsDefault)
Set the main executable module.
Definition Target.cpp:1573
lldb::StackFrameRecognizerManagerUP m_frame_recognizer_manager_up
Stores the frame recognizers of this target.
Definition Target.h:1707
lldb::REPLSP GetREPL(Status &err, lldb::LanguageType language, const char *repl_options, bool can_create)
Definition Target.cpp:312
UserExpression * GetUserExpressionForLanguage(llvm::StringRef expr, llvm::StringRef prefix, SourceLanguage language, Expression::ResultType desired_type, const EvaluateExpressionOptions &options, ValueObject *ctx_obj, Status &error)
Definition Target.cpp:2700
ModuleList m_images
The list of images for this process (shared libraries and anything dynamically loaded).
Definition Target.h:1664
lldb::ProcessSP CalculateProcess() override
Definition Target.cpp:2587
void PrintDummySignals(Stream &strm, Args &signals)
Print all the signals set in this target.
Definition Target.cpp:3888
void SetPlatform(const lldb::PlatformSP &platform_sp)
Definition Target.h:1557
bool SetSectionLoadAddress(const lldb::SectionSP &section, lldb::addr_t load_addr, bool warn_multiple=false)
Definition Target.cpp:3326
Status Attach(ProcessAttachInfo &attach_info, Stream *stream)
Definition Target.cpp:3623
std::map< lldb::LanguageType, lldb::REPLSP > REPLMap
Definition Target.h:1685
static void SetDefaultArchitecture(const ArchSpec &arch)
Definition Target.cpp:2806
lldb::BreakpointSP m_last_created_breakpoint
Definition Target.h:1674
lldb::WatchpointSP GetLastCreatedWatchpoint()
Definition Target.h:814
void RemoveNameFromBreakpoint(lldb::BreakpointSP &bp_sp, ConstString name)
Definition Target.cpp:893
bool RemoveStopHookByID(lldb::user_id_t uid)
Definition Target.cpp:3075
friend class Debugger
Definition Target.h:530
lldb::BreakpointSP GetLastCreatedBreakpoint()
Definition Target.h:706
static void SettingsInitialize()
Definition Target.cpp:2790
~Target() override
Definition Target.cpp:211
bool EnableAllWatchpoints(bool end_to_end=true)
Definition Target.cpp:1380
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:1661
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:2847
bool MergeArchitecture(const ArchSpec &arch_spec)
Definition Target.cpp:1793
Encapsulates a one-time expression for use in lldb.
This class is used by Watchpoint to manage a list of watchpoints,.
#define LLDB_INVALID_GLOBALLY_UNIQUE_TARGET_ID
A class that represents a running process on the host machine.
std::shared_ptr< SummaryStatistics > SummaryStatisticsSP
Definition Statistics.h:33
LoadScriptFromSymFile
Definition Target.h:54
@ eLoadScriptFromSymFileTrue
Definition Target.h:55
@ eLoadScriptFromSymFileFalse
Definition Target.h:56
@ eLoadScriptFromSymFileWarn
Definition Target.h:57
ExecutionPolicy
Expression execution policies.
DynamicClassInfoHelper
Definition Target.h:72
@ eDynamicClassInfoHelperCopyRealizedClassList
Definition Target.h:75
@ eDynamicClassInfoHelperGetRealizedClassList
Definition Target.h:76
@ eDynamicClassInfoHelperAuto
Definition Target.h:73
@ eDynamicClassInfoHelperRealizedClassesStruct
Definition Target.h:74
OptionEnumValues GetDynamicValueTypes()
Definition Target.cpp:4180
@ eImportStdModuleFalse
Definition Target.h:67
@ eImportStdModuleFallback
Definition Target.h:68
@ eImportStdModuleTrue
Definition Target.h:69
LoadCWDlldbinitFile
Definition Target.h:60
@ eLoadCWDlldbinitTrue
Definition Target.h:61
@ eLoadCWDlldbinitFalse
Definition Target.h:62
@ eLoadCWDlldbinitWarn
Definition Target.h:63
llvm::ArrayRef< OptionEnumValueElement > OptionEnumValues
@ eInlineBreakpointsNever
Definition Target.h:49
@ eInlineBreakpointsAlways
Definition Target.h:51
@ eInlineBreakpointsHeaders
Definition Target.h:50
ExpressionEvaluationPhase
Expression Evaluation Stages.
std::shared_ptr< lldb_private::Trace > TraceSP
std::shared_ptr< lldb_private::ScriptedStopHookInterface > ScriptedStopHookInterfaceSP
std::shared_ptr< lldb_private::StackFrame > StackFrameSP
std::shared_ptr< lldb_private::SearchFilter > SearchFilterSP
std::shared_ptr< lldb_private::BreakpointResolver > BreakpointResolverSP
DescriptionLevel
Description levels for "void GetDescription(Stream *, DescriptionLevel)" calls.
std::unique_ptr< lldb_private::StackFrameRecognizerManager > StackFrameRecognizerManagerUP
std::shared_ptr< lldb_private::Thread > ThreadSP
std::shared_ptr< lldb_private::ValueObject > ValueObjectSP
std::shared_ptr< lldb_private::ExpressionVariable > ExpressionVariableSP
std::shared_ptr< lldb_private::UnixSignals > UnixSignalsSP
std::shared_ptr< lldb_private::Platform > PlatformSP
LanguageType
Programming language type.
std::shared_ptr< lldb_private::Stream > StreamSP
std::shared_ptr< lldb_private::Breakpoint > BreakpointSP
ExpressionResults
The results of expression evaluation.
int32_t break_id_t
Definition lldb-types.h:86
std::unique_ptr< lldb_private::SourceManager > SourceManagerUP
std::shared_ptr< lldb_private::Process > ProcessSP
std::shared_ptr< lldb_private::SymbolContextSpecifier > SymbolContextSpecifierSP
std::shared_ptr< lldb_private::Watchpoint > WatchpointSP
std::shared_ptr< lldb_private::Listener > ListenerSP
int32_t watch_id_t
Definition lldb-types.h:87
uint64_t user_id_t
Definition lldb-types.h:82
std::shared_ptr< lldb_private::Section > SectionSP
uint64_t addr_t
Definition lldb-types.h:80
std::shared_ptr< lldb_private::Target > TargetSP
@ eDynamicCanRunTarget
bool(* ExpressionCancelCallback)(lldb::ExpressionEvaluationPhase phase, void *baton)
Definition lldb-types.h:75
std::shared_ptr< lldb_private::Module > ModuleSP
std::shared_ptr< lldb_private::REPL > REPLSP
A type-erased pair of llvm::dwarf::SourceLanguageName and version.
DummySignalValues(LazyBool pass, LazyBool notify, LazyBool stop)
Definition Target.h:1593
UserID(lldb::user_id_t uid=LLDB_INVALID_UID)
Construct with optional user ID.
Definition UserID.h:33