//===-- Target.cpp --------------------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #include "lldb/Target/Target.h" #include "lldb/Breakpoint/BreakpointIDList.h" #include "lldb/Breakpoint/BreakpointPrecondition.h" #include "lldb/Breakpoint/BreakpointResolver.h" #include "lldb/Breakpoint/BreakpointResolverAddress.h" #include "lldb/Breakpoint/BreakpointResolverFileLine.h" #include "lldb/Breakpoint/BreakpointResolverFileRegex.h" #include "lldb/Breakpoint/BreakpointResolverName.h" #include "lldb/Breakpoint/BreakpointResolverScripted.h" #include "lldb/Breakpoint/Watchpoint.h" #include "lldb/Core/Debugger.h" #include "lldb/Core/Module.h" #include "lldb/Core/ModuleSpec.h" #include "lldb/Core/PluginManager.h" #include "lldb/Core/SearchFilter.h" #include "lldb/Core/Section.h" #include "lldb/Core/SourceManager.h" #include "lldb/Core/StructuredDataImpl.h" #include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObjectConstResult.h" #include "lldb/Expression/DiagnosticManager.h" #include "lldb/Expression/ExpressionVariable.h" #include "lldb/Expression/REPL.h" #include "lldb/Expression/UserExpression.h" #include "lldb/Expression/UtilityFunction.h" #include "lldb/Host/Host.h" #include "lldb/Host/PosixApi.h" #include "lldb/Host/StreamFile.h" #include "lldb/Interpreter/CommandInterpreter.h" #include "lldb/Interpreter/CommandReturnObject.h" #include "lldb/Interpreter/OptionGroupWatchpoint.h" #include "lldb/Interpreter/OptionValues.h" #include "lldb/Interpreter/Property.h" #include "lldb/Symbol/Function.h" #include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/Symbol.h" #include "lldb/Target/ABI.h" #include "lldb/Target/ExecutionContext.h" #include "lldb/Target/Language.h" #include "lldb/Target/LanguageRuntime.h" #include "lldb/Target/Process.h" #include "lldb/Target/RegisterTypeBuilder.h" #include "lldb/Target/SectionLoadList.h" #include "lldb/Target/StackFrame.h" #include "lldb/Target/StackFrameRecognizer.h" #include "lldb/Target/SystemRuntime.h" #include "lldb/Target/Thread.h" #include "lldb/Target/ThreadSpec.h" #include "lldb/Target/UnixSignals.h" #include "lldb/Utility/Event.h" #include "lldb/Utility/FileSpec.h" #include "lldb/Utility/LLDBAssert.h" #include "lldb/Utility/LLDBLog.h" #include "lldb/Utility/Log.h" #include "lldb/Utility/RealpathPrefixes.h" #include "lldb/Utility/State.h" #include "lldb/Utility/StreamString.h" #include "lldb/Utility/Timer.h" #include "llvm/ADT/ScopeExit.h" #include "llvm/ADT/SetVector.h" #include <memory> #include <mutex> #include <optional> #include <sstream> usingnamespacelldb; usingnamespacelldb_private; constexpr std::chrono::milliseconds EvaluateExpressionOptions::default_timeout; Target::Arch::Arch(const ArchSpec &spec) : … { … } const Target::Arch &Target::Arch::operator=(const ArchSpec &spec) { … } llvm::StringRef Target::GetStaticBroadcasterClass() { … } Target::Target(Debugger &debugger, const ArchSpec &target_arch, const lldb::PlatformSP &platform_sp, bool is_dummy_target) : … { … } Target::~Target() { … } void Target::PrimeFromDummyTarget(Target &target) { … } void Target::Dump(Stream *s, lldb::DescriptionLevel description_level) { … } void Target::CleanupProcess() { … } void Target::DeleteCurrentProcess() { … } const lldb::ProcessSP &Target::CreateProcess(ListenerSP listener_sp, llvm::StringRef plugin_name, const FileSpec *crash_file, bool can_connect) { … } const lldb::ProcessSP &Target::GetProcessSP() const { … } lldb::REPLSP Target::GetREPL(Status &err, lldb::LanguageType language, const char *repl_options, bool can_create) { … } void Target::SetREPL(lldb::LanguageType language, lldb::REPLSP repl_sp) { … } void Target::Destroy() { … } llvm::StringRef Target::GetABIName() const { … } BreakpointList &Target::GetBreakpointList(bool internal) { … } const BreakpointList &Target::GetBreakpointList(bool internal) const { … } BreakpointSP Target::GetBreakpointByID(break_id_t break_id) { … } lldb::BreakpointSP lldb_private::Target::CreateBreakpointAtUserEntry(Status &error) { … } BreakpointSP Target::CreateSourceRegexBreakpoint( const FileSpecList *containingModules, const FileSpecList *source_file_spec_list, const std::unordered_set<std::string> &function_names, RegularExpression source_regex, bool internal, bool hardware, LazyBool move_to_nearest_code) { … } BreakpointSP Target::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 hardware, LazyBool move_to_nearest_code) { … } BreakpointSP Target::CreateBreakpoint(lldb::addr_t addr, bool internal, bool hardware) { … } BreakpointSP Target::CreateBreakpoint(const Address &addr, bool internal, bool hardware) { … } lldb::BreakpointSP Target::CreateAddressInModuleBreakpoint(lldb::addr_t file_addr, bool internal, const FileSpec &file_spec, bool request_hardware) { … } BreakpointSP Target::CreateBreakpoint( const FileSpecList *containingModules, const FileSpecList *containingSourceFiles, const char *func_name, FunctionNameType func_name_type_mask, LanguageType language, lldb::addr_t offset, LazyBool skip_prologue, bool internal, bool hardware) { … } lldb::BreakpointSP Target::CreateBreakpoint(const FileSpecList *containingModules, const FileSpecList *containingSourceFiles, const std::vector<std::string> &func_names, FunctionNameType func_name_type_mask, LanguageType language, lldb::addr_t offset, LazyBool skip_prologue, bool internal, bool hardware) { … } BreakpointSP Target::CreateBreakpoint(const FileSpecList *containingModules, const FileSpecList *containingSourceFiles, const char *func_names[], size_t num_names, FunctionNameType func_name_type_mask, LanguageType language, lldb::addr_t offset, LazyBool skip_prologue, bool internal, bool hardware) { … } SearchFilterSP Target::GetSearchFilterForModule(const FileSpec *containingModule) { … } SearchFilterSP Target::GetSearchFilterForModuleList(const FileSpecList *containingModules) { … } SearchFilterSP Target::GetSearchFilterForModuleAndCUList( const FileSpecList *containingModules, const FileSpecList *containingSourceFiles) { … } BreakpointSP Target::CreateFuncRegexBreakpoint( const FileSpecList *containingModules, const FileSpecList *containingSourceFiles, RegularExpression func_regex, lldb::LanguageType requested_language, LazyBool skip_prologue, bool internal, bool hardware) { … } lldb::BreakpointSP Target::CreateExceptionBreakpoint(enum lldb::LanguageType language, bool catch_bp, bool throw_bp, bool internal, Args *additional_args, Status *error) { … } lldb::BreakpointSP Target::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) { … } BreakpointSP Target::CreateBreakpoint(SearchFilterSP &filter_sp, BreakpointResolverSP &resolver_sp, bool internal, bool request_hardware, bool resolve_indirect_symbols) { … } void Target::AddBreakpoint(lldb::BreakpointSP bp_sp, bool internal) { … } void Target::AddNameToBreakpoint(BreakpointID &id, llvm::StringRef name, Status &error) { … } void Target::AddNameToBreakpoint(BreakpointSP &bp_sp, llvm::StringRef name, Status &error) { … } void Target::AddBreakpointName(std::unique_ptr<BreakpointName> bp_name) { … } BreakpointName *Target::FindBreakpointName(ConstString name, bool can_create, Status &error) { … } void Target::DeleteBreakpointName(ConstString name) { … } void Target::RemoveNameFromBreakpoint(lldb::BreakpointSP &bp_sp, ConstString name) { … } void Target::ConfigureBreakpointName( BreakpointName &bp_name, const BreakpointOptions &new_options, const BreakpointName::Permissions &new_permissions) { … } void Target::ApplyNameToBreakpoints(BreakpointName &bp_name) { … } void Target::GetBreakpointNames(std::vector<std::string> &names) { … } bool Target::ProcessIsValid() { … } static bool CheckIfWatchpointsSupported(Target *target, Status &error) { … } // See also Watchpoint::SetWatchpointType(uint32_t type) and the // OptionGroupWatchpoint::WatchType enum type. WatchpointSP Target::CreateWatchpoint(lldb::addr_t addr, size_t size, const CompilerType *type, uint32_t kind, Status &error) { … } void Target::RemoveAllowedBreakpoints() { … } void Target::RemoveAllBreakpoints(bool internal_also) { … } void Target::DisableAllBreakpoints(bool internal_also) { … } void Target::DisableAllowedBreakpoints() { … } void Target::EnableAllBreakpoints(bool internal_also) { … } void Target::EnableAllowedBreakpoints() { … } bool Target::RemoveBreakpointByID(break_id_t break_id) { … } bool Target::DisableBreakpointByID(break_id_t break_id) { … } bool Target::EnableBreakpointByID(break_id_t break_id) { … } void Target::ResetBreakpointHitCounts() { … } Status Target::SerializeBreakpointsToFile(const FileSpec &file, const BreakpointIDList &bp_ids, bool append) { … } Status Target::CreateBreakpointsFromFile(const FileSpec &file, BreakpointIDList &new_bps) { … } Status Target::CreateBreakpointsFromFile(const FileSpec &file, std::vector<std::string> &names, BreakpointIDList &new_bps) { … } // The flag 'end_to_end', default to true, signifies that the operation is // performed end to end, for both the debugger and the debuggee. // Assumption: Caller holds the list mutex lock for m_watchpoint_list for end // to end operations. bool Target::RemoveAllWatchpoints(bool end_to_end) { … } // Assumption: Caller holds the list mutex lock for m_watchpoint_list for end // to end operations. bool Target::DisableAllWatchpoints(bool end_to_end) { … } // Assumption: Caller holds the list mutex lock for m_watchpoint_list for end // to end operations. bool Target::EnableAllWatchpoints(bool end_to_end) { … } // Assumption: Caller holds the list mutex lock for m_watchpoint_list. bool Target::ClearAllWatchpointHitCounts() { … } // Assumption: Caller holds the list mutex lock for m_watchpoint_list. bool Target::ClearAllWatchpointHistoricValues() { … } // Assumption: Caller holds the list mutex lock for m_watchpoint_list during // these operations. bool Target::IgnoreAllWatchpoints(uint32_t ignore_count) { … } // Assumption: Caller holds the list mutex lock for m_watchpoint_list. bool Target::DisableWatchpointByID(lldb::watch_id_t watch_id) { … } // Assumption: Caller holds the list mutex lock for m_watchpoint_list. bool Target::EnableWatchpointByID(lldb::watch_id_t watch_id) { … } // Assumption: Caller holds the list mutex lock for m_watchpoint_list. bool Target::RemoveWatchpointByID(lldb::watch_id_t watch_id) { … } // Assumption: Caller holds the list mutex lock for m_watchpoint_list. bool Target::IgnoreWatchpointByID(lldb::watch_id_t watch_id, uint32_t ignore_count) { … } ModuleSP Target::GetExecutableModule() { … } Module *Target::GetExecutableModulePointer() { … } static void LoadScriptingResourceForModule(const ModuleSP &module_sp, Target *target) { … } void Target::ClearModules(bool delete_locations) { … } void Target::DidExec() { … } void Target::SetExecutableModule(ModuleSP &executable_sp, LoadDependentFiles load_dependent_files) { … } bool Target::SetArchitecture(const ArchSpec &arch_spec, bool set_platform, bool merge) { … } bool Target::MergeArchitecture(const ArchSpec &arch_spec) { … } void Target::NotifyWillClearList(const ModuleList &module_list) { … } void Target::NotifyModuleAdded(const ModuleList &module_list, const ModuleSP &module_sp) { … } void Target::NotifyModuleRemoved(const ModuleList &module_list, const ModuleSP &module_sp) { … } void Target::NotifyModuleUpdated(const ModuleList &module_list, const ModuleSP &old_module_sp, const ModuleSP &new_module_sp) { … } void Target::NotifyModulesRemoved(lldb_private::ModuleList &module_list) { … } void Target::ModulesDidLoad(ModuleList &module_list) { … } void Target::SymbolsDidLoad(ModuleList &module_list) { … } void Target::ModulesDidUnload(ModuleList &module_list, bool delete_locations) { … } bool Target::ModuleIsExcludedForUnconstrainedSearches( const FileSpec &module_file_spec) { … } bool Target::ModuleIsExcludedForUnconstrainedSearches( const lldb::ModuleSP &module_sp) { … } size_t Target::ReadMemoryFromFileCache(const Address &addr, void *dst, size_t dst_len, Status &error) { … } size_t Target::ReadMemory(const Address &addr, void *dst, size_t dst_len, Status &error, bool force_live_memory, lldb::addr_t *load_addr_ptr) { … } size_t Target::ReadCStringFromMemory(const Address &addr, std::string &out_str, Status &error, bool force_live_memory) { … } size_t Target::ReadCStringFromMemory(const Address &addr, char *dst, size_t dst_max_len, Status &result_error, bool force_live_memory) { … } addr_t Target::GetReasonableReadSize(const Address &addr) { … } size_t Target::ReadStringFromMemory(const Address &addr, char *dst, size_t max_bytes, Status &error, size_t type_width, bool force_live_memory) { … } size_t Target::ReadScalarIntegerFromMemory(const Address &addr, uint32_t byte_size, bool is_signed, Scalar &scalar, Status &error, bool force_live_memory) { … } uint64_t Target::ReadUnsignedIntegerFromMemory(const Address &addr, size_t integer_byte_size, uint64_t fail_value, Status &error, bool force_live_memory) { … } bool Target::ReadPointerFromMemory(const Address &addr, Status &error, Address &pointer_addr, bool force_live_memory) { … } ModuleSP Target::GetOrCreateModule(const ModuleSpec &orig_module_spec, bool notify, Status *error_ptr) { … } TargetSP Target::CalculateTarget() { … } ProcessSP Target::CalculateProcess() { … } ThreadSP Target::CalculateThread() { … } StackFrameSP Target::CalculateStackFrame() { … } void Target::CalculateExecutionContext(ExecutionContext &exe_ctx) { … } PathMappingList &Target::GetImageSearchPathList() { … } void Target::ImageSearchPathsChanged(const PathMappingList &path_list, void *baton) { … } llvm::Expected<lldb::TypeSystemSP> Target::GetScratchTypeSystemForLanguage(lldb::LanguageType language, bool create_on_demand) { … } CompilerType Target::GetRegisterType(const std::string &name, const lldb_private::RegisterFlags &flags, uint32_t byte_size) { … } std::vector<lldb::TypeSystemSP> Target::GetScratchTypeSystems(bool create_on_demand) { … } PersistentExpressionState * Target::GetPersistentExpressionStateForLanguage(lldb::LanguageType language) { … } UserExpression *Target::GetUserExpressionForLanguage( llvm::StringRef expr, llvm::StringRef prefix, SourceLanguage language, Expression::ResultType desired_type, const EvaluateExpressionOptions &options, ValueObject *ctx_obj, Status &error) { … } FunctionCaller *Target::GetFunctionCallerForLanguage( lldb::LanguageType language, const CompilerType &return_type, const Address &function_address, const ValueList &arg_value_list, const char *name, Status &error) { … } llvm::Expected<std::unique_ptr<UtilityFunction>> Target::CreateUtilityFunction(std::string expression, std::string name, lldb::LanguageType language, ExecutionContext &exe_ctx) { … } void Target::SettingsInitialize() { … } void Target::SettingsTerminate() { … } FileSpecList Target::GetDefaultExecutableSearchPaths() { … } FileSpecList Target::GetDefaultDebugFileSearchPaths() { … } ArchSpec Target::GetDefaultArchitecture() { … } void Target::SetDefaultArchitecture(const ArchSpec &arch) { … } llvm::Error Target::SetLabel(llvm::StringRef label) { … } Target *Target::GetTargetFromContexts(const ExecutionContext *exe_ctx_ptr, const SymbolContext *sc_ptr) { … } ExpressionResults Target::EvaluateExpression( llvm::StringRef expr, ExecutionContextScope *exe_scope, lldb::ValueObjectSP &result_valobj_sp, const EvaluateExpressionOptions &options, std::string *fixed_expression, ValueObject *ctx_obj) { … } lldb::ExpressionVariableSP Target::GetPersistentVariable(ConstString name) { … } lldb::addr_t Target::GetPersistentSymbol(ConstString name) { … } llvm::Expected<lldb_private::Address> Target::GetEntryPointAddress() { … } lldb::addr_t Target::GetCallableLoadAddress(lldb::addr_t load_addr, AddressClass addr_class) const { … } lldb::addr_t Target::GetOpcodeLoadAddress(lldb::addr_t load_addr, AddressClass addr_class) const { … } lldb::addr_t Target::GetBreakableLoadAddress(lldb::addr_t addr) { … } SourceManager &Target::GetSourceManager() { … } Target::StopHookSP Target::CreateStopHook(StopHook::StopHookKind kind) { … } void Target::UndoCreateStopHook(lldb::user_id_t user_id) { … } bool Target::RemoveStopHookByID(lldb::user_id_t user_id) { … } void Target::RemoveAllStopHooks() { … } Target::StopHookSP Target::GetStopHookByID(lldb::user_id_t user_id) { … } bool Target::SetStopHookActiveStateByID(lldb::user_id_t user_id, bool active_state) { … } void Target::SetAllStopHooksActiveState(bool active_state) { … } bool Target::RunStopHooks() { … } TargetProperties &Target::GetGlobalProperties() { … } Status Target::Install(ProcessLaunchInfo *launch_info) { … } bool Target::ResolveLoadAddress(addr_t load_addr, Address &so_addr, uint32_t stop_id) { … } bool Target::ResolveFileAddress(lldb::addr_t file_addr, Address &resolved_addr) { … } bool Target::SetSectionLoadAddress(const SectionSP §ion_sp, addr_t new_section_load_addr, bool warn_multiple) { … } size_t Target::UnloadModuleSections(const ModuleList &module_list) { … } size_t Target::UnloadModuleSections(const lldb::ModuleSP &module_sp) { … } bool Target::SetSectionUnloaded(const lldb::SectionSP §ion_sp) { … } bool Target::SetSectionUnloaded(const lldb::SectionSP §ion_sp, addr_t load_addr) { … } void Target::ClearAllLoadedSections() { … } lldb_private::SummaryStatisticsSP Target::GetSummaryStatisticsSPForProviderName( lldb_private::TypeSummaryImpl &summary_provider) { … } SummaryStatisticsCache &Target::GetSummaryStatisticsCache() { … } void Target::SaveScriptedLaunchInfo(lldb_private::ProcessInfo &process_info) { … } Status Target::Launch(ProcessLaunchInfo &launch_info, Stream *stream) { … } void Target::SetTrace(const TraceSP &trace_sp) { … } TraceSP Target::GetTrace() { … } llvm::Expected<TraceSP> Target::CreateTrace() { … } llvm::Expected<TraceSP> Target::GetTraceOrCreate() { … } Status Target::Attach(ProcessAttachInfo &attach_info, Stream *stream) { … } void Target::FinalizeFileActions(ProcessLaunchInfo &info) { … } void Target::AddDummySignal(llvm::StringRef name, LazyBool pass, LazyBool notify, LazyBool stop) { … } bool Target::UpdateSignalFromDummy(UnixSignalsSP signals_sp, const DummySignalElement &elem) { … } bool Target::ResetSignalFromDummy(UnixSignalsSP signals_sp, const DummySignalElement &elem) { … } void Target::UpdateSignalsFromDummy(UnixSignalsSP signals_sp, StreamSP warning_stream_sp) { … } void Target::ClearDummySignals(Args &signal_names) { … } void Target::PrintDummySignals(Stream &strm, Args &signal_args) { … } // Target::StopHook Target::StopHook::StopHook(lldb::TargetSP target_sp, lldb::user_id_t uid) : … { … } Target::StopHook::StopHook(const StopHook &rhs) : … { … } void Target::StopHook::SetSpecifier(SymbolContextSpecifier *specifier) { … } void Target::StopHook::SetThreadSpecifier(ThreadSpec *specifier) { … } bool Target::StopHook::ExecutionContextPasses(const ExecutionContext &exc_ctx) { … } void Target::StopHook::GetDescription(Stream &s, lldb::DescriptionLevel level) const { … } void Target::StopHookCommandLine::GetSubclassDescription( Stream &s, lldb::DescriptionLevel level) const { … } // Target::StopHookCommandLine void Target::StopHookCommandLine::SetActionFromString(const std::string &string) { … } void Target::StopHookCommandLine::SetActionFromStrings( const std::vector<std::string> &strings) { … } Target::StopHook::StopHookResult Target::StopHookCommandLine::HandleStop(ExecutionContext &exc_ctx, StreamSP output_sp) { … } // Target::StopHookScripted Status Target::StopHookScripted::SetScriptCallback( std::string class_name, StructuredData::ObjectSP extra_args_sp) { … } Target::StopHook::StopHookResult Target::StopHookScripted::HandleStop(ExecutionContext &exc_ctx, StreamSP output_sp) { … } void Target::StopHookScripted::GetSubclassDescription( Stream &s, lldb::DescriptionLevel level) const { … } static constexpr OptionEnumValueElement g_dynamic_value_types[] = …; OptionEnumValues lldb_private::GetDynamicValueTypes() { … } static constexpr OptionEnumValueElement g_inline_breakpoint_enums[] = …; enum x86DisassemblyFlavor { … }; static constexpr OptionEnumValueElement g_x86_dis_flavor_value_types[] = …; static constexpr OptionEnumValueElement g_import_std_module_value_types[] = …; static constexpr OptionEnumValueElement g_dynamic_class_info_helper_value_types[] = …; static constexpr OptionEnumValueElement g_hex_immediate_style_values[] = …; static constexpr OptionEnumValueElement g_load_script_from_sym_file_values[] = …; static constexpr OptionEnumValueElement g_load_cwd_lldbinit_values[] = …; static constexpr OptionEnumValueElement g_memory_module_load_level_values[] = …; #define LLDB_PROPERTIES_target #include "TargetProperties.inc" enum { … }; class TargetOptionValueProperties : public Cloneable<TargetOptionValueProperties, OptionValueProperties> { … }; // TargetProperties #define LLDB_PROPERTIES_target_experimental #include "TargetProperties.inc" enum { … }; class TargetExperimentalOptionValueProperties : public Cloneable<TargetExperimentalOptionValueProperties, OptionValueProperties> { … }; TargetExperimentalProperties::TargetExperimentalProperties() : … { … } // TargetProperties TargetProperties::TargetProperties(Target *target) : … { … } TargetProperties::~TargetProperties() = default; void TargetProperties::UpdateLaunchInfoFromProperties() { … } std::optional<bool> TargetProperties::GetExperimentalPropertyValue( size_t prop_idx, ExecutionContext *exe_ctx) const { … } bool TargetProperties::GetInjectLocalVariables( ExecutionContext *exe_ctx) const { … } ArchSpec TargetProperties::GetDefaultArchitecture() const { … } void TargetProperties::SetDefaultArchitecture(const ArchSpec &arch) { … } bool TargetProperties::GetMoveToNearestCode() const { … } lldb::DynamicValueType TargetProperties::GetPreferDynamicValue() const { … } bool TargetProperties::SetPreferDynamicValue(lldb::DynamicValueType d) { … } bool TargetProperties::GetPreloadSymbols() const { … } void TargetProperties::SetPreloadSymbols(bool b) { … } bool TargetProperties::GetDisableASLR() const { … } void TargetProperties::SetDisableASLR(bool b) { … } bool TargetProperties::GetInheritTCC() const { … } void TargetProperties::SetInheritTCC(bool b) { … } bool TargetProperties::GetDetachOnError() const { … } void TargetProperties::SetDetachOnError(bool b) { … } bool TargetProperties::GetDisableSTDIO() const { … } void TargetProperties::SetDisableSTDIO(bool b) { … } const char *TargetProperties::GetDisassemblyFlavor() const { … } InlineStrategy TargetProperties::GetInlineStrategy() const { … } // Returning RealpathPrefixes, but the setting's type is FileSpecList. We do // this because we want the FileSpecList to normalize the file paths for us. RealpathPrefixes TargetProperties::GetSourceRealpathPrefixes() const { … } llvm::StringRef TargetProperties::GetArg0() const { … } void TargetProperties::SetArg0(llvm::StringRef arg) { … } bool TargetProperties::GetRunArguments(Args &args) const { … } void TargetProperties::SetRunArguments(const Args &args) { … } Environment TargetProperties::ComputeEnvironment() const { … } Environment TargetProperties::GetEnvironment() const { … } Environment TargetProperties::GetInheritedEnvironment() const { … } Environment TargetProperties::GetTargetEnvironment() const { … } void TargetProperties::SetEnvironment(Environment env) { … } bool TargetProperties::GetSkipPrologue() const { … } PathMappingList &TargetProperties::GetSourcePathMap() const { … } PathMappingList &TargetProperties::GetObjectPathMap() const { … } bool TargetProperties::GetAutoSourceMapRelative() const { … } void TargetProperties::AppendExecutableSearchPaths(const FileSpec &dir) { … } FileSpecList TargetProperties::GetExecutableSearchPaths() { … } FileSpecList TargetProperties::GetDebugFileSearchPaths() { … } FileSpecList TargetProperties::GetClangModuleSearchPaths() { … } bool TargetProperties::GetEnableAutoImportClangModules() const { … } ImportStdModule TargetProperties::GetImportStdModule() const { … } DynamicClassInfoHelper TargetProperties::GetDynamicClassInfoHelper() const { … } bool TargetProperties::GetEnableAutoApplyFixIts() const { … } uint64_t TargetProperties::GetNumberOfRetriesWithFixits() const { … } bool TargetProperties::GetEnableNotifyAboutFixIts() const { … } FileSpec TargetProperties::GetSaveJITObjectsDir() const { … } void TargetProperties::CheckJITObjectsDir() { … } bool TargetProperties::GetEnableSyntheticValue() const { … } bool TargetProperties::ShowHexVariableValuesWithLeadingZeroes() const { … } uint32_t TargetProperties::GetMaxZeroPaddingInFloatFormat() const { … } uint32_t TargetProperties::GetMaximumNumberOfChildrenToDisplay() const { … } std::pair<uint32_t, bool> TargetProperties::GetMaximumDepthOfChildrenToDisplay() const { … } uint32_t TargetProperties::GetMaximumSizeOfStringSummary() const { … } uint32_t TargetProperties::GetMaximumMemReadSize() const { … } FileSpec TargetProperties::GetStandardInputPath() const { … } void TargetProperties::SetStandardInputPath(llvm::StringRef path) { … } FileSpec TargetProperties::GetStandardOutputPath() const { … } void TargetProperties::SetStandardOutputPath(llvm::StringRef path) { … } FileSpec TargetProperties::GetStandardErrorPath() const { … } void TargetProperties::SetStandardErrorPath(llvm::StringRef path) { … } SourceLanguage TargetProperties::GetLanguage() const { … } llvm::StringRef TargetProperties::GetExpressionPrefixContents() { … } uint64_t TargetProperties::GetExprErrorLimit() const { … } uint64_t TargetProperties::GetExprAllocAddress() const { … } uint64_t TargetProperties::GetExprAllocSize() const { … } uint64_t TargetProperties::GetExprAllocAlign() const { … } bool TargetProperties::GetBreakpointsConsultPlatformAvoidList() { … } bool TargetProperties::GetUseHexImmediates() const { … } bool TargetProperties::GetUseFastStepping() const { … } bool TargetProperties::GetDisplayExpressionsInCrashlogs() const { … } LoadScriptFromSymFile TargetProperties::GetLoadScriptFromSymbolFile() const { … } LoadCWDlldbinitFile TargetProperties::GetLoadCWDlldbinitFile() const { … } Disassembler::HexImmediateStyle TargetProperties::GetHexImmediateStyle() const { … } MemoryModuleLoadLevel TargetProperties::GetMemoryModuleLoadLevel() const { … } bool TargetProperties::GetUserSpecifiedTrapHandlerNames(Args &args) const { … } void TargetProperties::SetUserSpecifiedTrapHandlerNames(const Args &args) { … } bool TargetProperties::GetDisplayRuntimeSupportValues() const { … } void TargetProperties::SetDisplayRuntimeSupportValues(bool b) { … } bool TargetProperties::GetDisplayRecognizedArguments() const { … } void TargetProperties::SetDisplayRecognizedArguments(bool b) { … } const ProcessLaunchInfo &TargetProperties::GetProcessLaunchInfo() const { … } void TargetProperties::SetProcessLaunchInfo( const ProcessLaunchInfo &launch_info) { … } bool TargetProperties::GetRequireHardwareBreakpoints() const { … } void TargetProperties::SetRequireHardwareBreakpoints(bool b) { … } bool TargetProperties::GetAutoInstallMainExecutable() const { … } void TargetProperties::Arg0ValueChangedCallback() { … } void TargetProperties::RunArgsValueChangedCallback() { … } void TargetProperties::EnvVarsValueChangedCallback() { … } void TargetProperties::InputPathValueChangedCallback() { … } void TargetProperties::OutputPathValueChangedCallback() { … } void TargetProperties::ErrorPathValueChangedCallback() { … } void TargetProperties::DetachOnErrorValueChangedCallback() { … } void TargetProperties::DisableASLRValueChangedCallback() { … } void TargetProperties::InheritTCCValueChangedCallback() { … } void TargetProperties::DisableSTDIOValueChangedCallback() { … } bool TargetProperties::GetDebugUtilityExpression() const { … } void TargetProperties::SetDebugUtilityExpression(bool debug) { … } // Target::TargetEventData Target::TargetEventData::TargetEventData(const lldb::TargetSP &target_sp) : … { … } Target::TargetEventData::TargetEventData(const lldb::TargetSP &target_sp, const ModuleList &module_list) : … { … } Target::TargetEventData::~TargetEventData() = default; llvm::StringRef Target::TargetEventData::GetFlavorString() { … } void Target::TargetEventData::Dump(Stream *s) const { … } const Target::TargetEventData * Target::TargetEventData::GetEventDataFromEvent(const Event *event_ptr) { … } TargetSP Target::TargetEventData::GetTargetFromEvent(const Event *event_ptr) { … } ModuleList Target::TargetEventData::GetModuleListFromEvent(const Event *event_ptr) { … } std::recursive_mutex &Target::GetAPIMutex() { … } /// Get metrics associated with this target in JSON format. llvm::json::Value Target::ReportStatistics(const lldb_private::StatisticsOptions &options) { … }
Codebase Browser
llvm