67#include "llvm/ADT/ScopeExit.h"
68#include "llvm/ADT/SetVector.h"
82 m_plugin_up(
PluginManager::CreateArchitectureInstance(spec)) {}
119 static_cast<void *
>(
this));
122 "Target::Target created with architecture {0} ({1})",
124 target_arch.
GetTriple().getTriple().c_str());
132 LLDB_LOG(log,
"{0} Target::~Target()",
static_cast<void *
>(
this));
140 if (breakpoint_sp->IsInternal())
185 std::unique_lock<std::recursive_mutex> lock;
210 llvm::StringRef plugin_name,
217 listener_sp, crash_file, can_connect);
224 const char *repl_options,
bool can_create) {
232 language = *single_lang;
233 }
else if (repl_languages.
Empty()) {
235 "LLDB isn't configured with REPL support for any languages.");
239 "Multiple possible REPL languages. Please specify a language.");
244 REPLMap::iterator pos =
m_repl_map.find(language);
252 "Couldn't find an existing REPL for %s, and can't create a new one",
280 std::lock_guard<std::recursive_mutex> guard(
m_mutex);
287 const bool notify =
false;
310 return abi_sp->GetPluginName();
341 ModuleSP main_module_sp = GetExecutableModule();
343 shared_lib_filter.
Append(main_module_sp->GetFileSpec());
344 llvm::SetVector<std::string, std::vector<std::string>,
345 std::unordered_set<std::string>>
350 error.SetErrorString(
"Language not found\n");
354 if (!entryPointName.empty())
355 entryPointNamesSet.insert(entryPointName);
357 if (entryPointNamesSet.empty()) {
358 error.SetErrorString(
"No entry point name found\n");
363 nullptr, entryPointNamesSet.takeVector(),
364 eFunctionNameTypeFull,
371 error.SetErrorString(
"Breakpoint creation failed.\n");
374 bp_sp->SetOneShot(
true);
381 const std::unordered_set<std::string> &function_names,
385 containingModules, source_file_spec_list));
389 nullptr, std::move(source_regex), function_names,
390 !
static_cast<bool>(move_to_nearest_code)));
396 const FileSpec &file, uint32_t line_no,
399 LazyBool skip_prologue,
bool internal,
403 std::optional<llvm::StringRef> removed_prefix_opt =
405 if (!removed_prefix_opt)
406 remapped_file = file;
410 switch (inline_strategy) {
431 compile_unit_list.
Append(remapped_file);
444 !
static_cast<bool>(move_to_nearest_code));
449 nullptr, offset, skip_prologue, location_spec, removed_prefix_opt));
485 bool request_hardware) {
489 nullptr, file_addr, file_spec));
496 const FileSpecList *containingSourceFiles,
const char *func_name,
497 FunctionNameType func_name_type_mask,
LanguageType language,
502 containingModules, containingSourceFiles));
511 offset, skip_prologue));
520 const std::vector<std::string> &func_names,
521 FunctionNameType func_name_type_mask,
523 LazyBool skip_prologue,
bool internal,
bool hardware) {
525 size_t num_names = func_names.size();
528 containingModules, containingSourceFiles));
537 language, offset, skip_prologue));
546 const char *func_names[],
size_t num_names,
547 FunctionNameType func_name_type_mask,
549 LazyBool skip_prologue,
bool internal,
bool hardware) {
553 containingModules, containingSourceFiles));
565 nullptr, func_names, num_names, func_name_type_mask, language, offset,
567 resolver_sp->SetOffset(offset);
576 if (containingModule !=
nullptr) {
579 filter_sp = std::make_shared<SearchFilterByModule>(shared_from_this(),
584 std::make_shared<SearchFilterForUnconstrainedSearches>(
594 if (containingModules && containingModules->
GetSize() != 0) {
597 filter_sp = std::make_shared<SearchFilterByModuleList>(shared_from_this(),
602 std::make_shared<SearchFilterForUnconstrainedSearches>(
612 if (containingSourceFiles ==
nullptr || containingSourceFiles->
GetSize() == 0)
616 if (containingModules ==
nullptr) {
620 filter_sp = std::make_shared<SearchFilterByModuleListAndCU>(
621 shared_from_this(),
FileSpecList(), *containingSourceFiles);
623 filter_sp = std::make_shared<SearchFilterByModuleListAndCU>(
624 shared_from_this(), *containingModules, *containingSourceFiles);
633 bool internal,
bool hardware) {
635 containingModules, containingSourceFiles));
638 :
static_cast<bool>(skip_prologue);
640 nullptr, std::move(func_regex), requested_language, 0, skip));
647 bool catch_bp,
bool throw_bp,
bool internal,
650 *
this, language, catch_bp, throw_bp, internal);
651 if (exc_bkpt_sp && additional_args) {
653 if (precondition_sp && additional_args) {
655 *
error = precondition_sp->ConfigurePrecondition(*additional_args);
657 precondition_sp->ConfigurePrecondition(*additional_args);
664 const llvm::StringRef class_name,
const FileSpecList *containingModules,
665 const FileSpecList *containingSourceFiles,
bool internal,
672 containingSourceFiles && containingSourceFiles->
GetSize() > 0;
673 bool has_modules = containingModules && containingModules->
GetSize() > 0;
675 if (has_files && has_modules) {
677 containingSourceFiles);
678 }
else if (has_files) {
681 }
else if (has_modules) {
684 filter_sp = std::make_shared<SearchFilterForUnconstrainedSearches>(
695 bool internal,
bool request_hardware,
696 bool resolve_indirect_symbols) {
698 if (filter_sp && resolver_sp) {
700 bp_sp.reset(
new Breakpoint(*
this, filter_sp, resolver_sp, hardware,
701 resolve_indirect_symbols));
702 resolver_sp->SetBreakpoint(bp_sp);
720 LLDB_LOGF(log,
"Target::%s (internal = %s) => break_id = %s\n",
721 __FUNCTION__, bp_sp->IsInternal() ?
"yes" :
"no", s.
GetData());
724 bp_sp->ResolveBreakpoint();
738 error.SetErrorStringWithFormat(
"Could not find breakpoint %s", s.
GetData());
754 bp_sp->AddName(name);
759 std::make_pair(bp_name->GetName(), std::move(bp_name)));
765 if (!
error.Success())
770 return iter->second.get();
774 error.SetErrorStringWithFormat(
"Breakpoint name \"%s\" doesn't exist and "
775 "can_create is false.",
781 .insert(std::make_pair(name, std::make_unique<BreakpointName>(name)))
782 .first->second.get();
789 const char *name_cstr = name.
AsCString();
792 bp_sp->RemoveName(name_cstr);
810 llvm::Expected<std::vector<BreakpointSP>> expected_vector =
813 if (!expected_vector) {
815 llvm::toString(expected_vector.takeError()));
819 for (
auto bp_sp : *expected_vector)
826 names.push_back(bp_name_entry.first.AsCString());
836 std::optional<uint32_t> num_supported_hardware_watchpoints =
841 if (!num_supported_hardware_watchpoints)
844 if (num_supported_hardware_watchpoints == 0) {
845 error.SetErrorStringWithFormat(
846 "Target supports (%u) hardware watchpoint slots.\n",
847 *num_supported_hardware_watchpoints);
860 "Target::%s (addr = 0x%8.8" PRIx64
" size = %" PRIu64
862 __FUNCTION__, addr, (uint64_t)size, kind);
866 error.SetErrorString(
"process is not alive");
872 error.SetErrorString(
"cannot set a watchpoint with watch_size of 0");
874 error.SetErrorStringWithFormat(
"invalid watch address: %" PRIu64, addr);
879 error.SetErrorStringWithFormat(
"invalid watchpoint type: %d", kind);
889 const bool notify =
false;
894 addr = abi->FixDataAddress(addr);
908 std::unique_lock<std::recursive_mutex> lock;
912 size_t old_size = matched_sp->GetByteSize();
918 if (size == old_size && kind == old_type) {
920 wp_sp->SetEnabled(
false, notify);
929 wp_sp = std::make_shared<Watchpoint>(*
this, addr, size, type);
930 wp_sp->SetWatchpointType(kind, notify);
935 LLDB_LOGF(log,
"Target::%s (creation of watchpoint %s with id = %u)\n",
936 __FUNCTION__,
error.Success() ?
"succeeded" :
"failed",
951 LLDB_LOGF(log,
"Target::%s \n", __FUNCTION__);
960 LLDB_LOGF(log,
"Target::%s (internal_also = %s)\n", __FUNCTION__,
961 internal_also ?
"yes" :
"no");
972 LLDB_LOGF(log,
"Target::%s (internal_also = %s)\n", __FUNCTION__,
973 internal_also ?
"yes" :
"no");
982 LLDB_LOGF(log,
"Target::%s", __FUNCTION__);
989 LLDB_LOGF(log,
"Target::%s (internal_also = %s)\n", __FUNCTION__,
990 internal_also ?
"yes" :
"no");
999 LLDB_LOGF(log,
"Target::%s", __FUNCTION__);
1006 LLDB_LOGF(log,
"Target::%s (break_id = %i, internal = %s)\n", __FUNCTION__,
1026 LLDB_LOGF(log,
"Target::%s (break_id = %i, internal = %s)\n", __FUNCTION__,
1036 bp_sp->SetEnabled(
false);
1044 LLDB_LOGF(log,
"Target::%s (break_id = %i, internal = %s)\n", __FUNCTION__,
1055 bp_sp->SetEnabled(
true);
1071 error.SetErrorString(
"Invalid FileSpec.");
1075 std::string path(file.
GetPath());
1083 if (
error.Success()) {
1084 break_store_ptr = input_data_sp->
GetAsArray();
1085 if (!break_store_ptr) {
1086 error.SetErrorStringWithFormat(
1087 "Tried to append to invalid input file %s", path.c_str());
1093 if (!break_store_ptr) {
1094 break_store_sp = std::make_shared<StructuredData::Array>();
1095 break_store_ptr = break_store_sp.get();
1102 lldb::eFilePermissionsFileDefault);
1104 error.SetErrorStringWithFormat(
"Unable to open output file: %s.",
1109 std::unique_lock<std::recursive_mutex> lock;
1115 size_t num_breakpoints = breakpoints.
GetSize();
1116 for (
size_t i = 0; i < num_breakpoints; i++) {
1121 break_store_ptr->
AddItem(bkpt_save_sp);
1125 std::unordered_set<lldb::break_id_t> processed_bkpts;
1126 const size_t count = bp_ids.
GetSize();
1127 for (
size_t i = 0; i < count; ++i) {
1133 std::pair<std::unordered_set<lldb::break_id_t>::iterator,
bool>
1134 insert_result = processed_bkpts.insert(bp_id);
1135 if (!insert_result.second)
1142 if (!bkpt_save_sp) {
1143 error.SetErrorStringWithFormat(
"Unable to serialize breakpoint %d",
1147 break_store_ptr->
AddItem(bkpt_save_sp);
1152 break_store_ptr->
Dump(out_file,
false);
1159 std::vector<std::string> no_names;
1164 std::vector<std::string> &names,
1166 std::unique_lock<std::recursive_mutex> lock;
1172 if (!
error.Success()) {
1174 }
else if (!input_data_sp || !input_data_sp->IsValid()) {
1175 error.SetErrorStringWithFormat(
"Invalid JSON from input file: %s.",
1182 error.SetErrorStringWithFormat(
1183 "Invalid breakpoint data from input file: %s.", file.
GetPath().c_str());
1187 size_t num_bkpts = bkpt_array->
GetSize();
1188 size_t num_names = names.size();
1190 for (
size_t i = 0; i < num_bkpts; i++) {
1195 error.SetErrorStringWithFormat(
1196 "Invalid breakpoint data for element %zu from input file: %s.", i,
1207 shared_from_this(), bkpt_data_sp,
error);
1208 if (!
error.Success()) {
1209 error.SetErrorStringWithFormat(
1210 "Error restoring breakpoint %zu from %s: %s.", i,
1226 LLDB_LOGF(log,
"Target::%s\n", __FUNCTION__);
1255 LLDB_LOGF(log,
"Target::%s\n", __FUNCTION__);
1282 LLDB_LOGF(log,
"Target::%s\n", __FUNCTION__);
1308 LLDB_LOGF(log,
"Target::%s\n", __FUNCTION__);
1314 wp_sp->ResetHitCount();
1322 LLDB_LOGF(log,
"Target::%s\n", __FUNCTION__);
1328 wp_sp->ResetHistoricValues();
1337 LLDB_LOGF(log,
"Target::%s\n", __FUNCTION__);
1346 wp_sp->SetIgnoreCount(ignore_count);
1354 LLDB_LOGF(log,
"Target::%s (watch_id = %i)\n", __FUNCTION__, watch_id);
1373 LLDB_LOGF(log,
"Target::%s (watch_id = %i)\n", __FUNCTION__, watch_id);
1392 LLDB_LOGF(log,
"Target::%s (watch_id = %i)\n", __FUNCTION__, watch_id);
1407 uint32_t ignore_count) {
1409 LLDB_LOGF(log,
"Target::%s (watch_id = %i)\n", __FUNCTION__, watch_id);
1416 wp_sp->SetIgnoreCount(ignore_count);
1444 if (module_sp && !module_sp->LoadScriptingResourceInTarget(target,
error,
1446 if (
error.AsCString())
1448 "unable to load scripting data for module %s - error reported was "
1450 module_sp->GetFileSpec().GetFileNameStrippingExtension().GetCString(),
1453 if (feedback_stream.
GetSize())
1476 if (executable_sp) {
1479 executable_sp->GetFileSpec().GetPath().c_str());
1481 const bool notify =
true;
1488 m_arch = executable_sp->GetArchitecture();
1490 "Target::SetExecutableModule setting architecture to {0} ({1}) "
1491 "based on executable file",
1497 ObjectFile *executable_objfile = executable_sp->GetObjectFile();
1498 bool load_dependents =
true;
1499 switch (load_dependent_files) {
1501 load_dependents = executable_sp->IsExecutable();
1504 load_dependents =
true;
1507 load_dependents =
false;
1511 if (executable_objfile && load_dependents) {
1514 for (uint32_t i = 0; i < dependent_files.
GetSize(); i++) {
1516 FileSpec platform_dependent_file_spec;
1518 m_platform_sp->GetFileWithUUID(dependent_file_spec,
nullptr,
1519 platform_dependent_file_spec);
1521 platform_dependent_file_spec = dependent_file_spec;
1526 if (image_module_sp) {
1528 ObjectFile *objfile = image_module_sp->GetObjectFile();
1542 bool replace_local_arch =
true;
1543 bool compatible_local_arch =
false;
1552 if (!platform_sp || !platform_sp->IsCompatibleArchitecture(
1556 GetDebugger().GetPlatformList().GetOrCreate(other, {},
1560 other = platform_arch;
1566 if (!missing_local_arch) {
1571 compatible_local_arch =
true;
1574 replace_local_arch =
false;
1579 if (compatible_local_arch || missing_local_arch) {
1583 if (replace_local_arch)
1586 "Target::SetArchitecture merging compatible arch; arch "
1597 "Target::SetArchitecture changing architecture to %s (%s) from %s (%s)",
1599 arch_spec.
GetTriple().getTriple().c_str(),
1608 if (executable_sp) {
1610 "Target::SetArchitecture Trying to select executable file "
1611 "architecture %s (%s)",
1613 arch_spec.
GetTriple().getTriple().c_str());
1614 ModuleSpec module_spec(executable_sp->GetFileSpec(), other);
1617 &search_paths,
nullptr,
nullptr);
1619 if (!
error.Fail() && executable_sp) {
1635 "Target::MergeArchitecture target has arch %s, merging with "
1638 arch_spec.
GetTriple().getTriple().c_str());
1659 my_module_list.
Append(module_sp);
1669 my_module_list.
Append(module_sp);
1682 old_module_sp, new_module_sp);
1691 const size_t num_images = module_list.
GetSize();
1693 for (
size_t idx = 0; idx < num_images; ++idx) {
1703 std::make_shared<TargetEventData>(shared_from_this(), module_list);
1712 runtime->SymbolsDidLoad(module_list);
1719 std::make_shared<TargetEventData>(shared_from_this(), module_list);
1728 std::make_shared<TargetEventData>(shared_from_this(), module_list);
1742 const bool should_flush_type_systems =
1749 auto type = object_file->
GetType();
1759 if (should_flush_type_systems)
1765 const FileSpec &module_file_spec) {
1770 size_t num_modules = matchingModules.
GetSize();
1774 if (num_modules > 0) {
1775 for (
size_t i = 0; i < num_modules; i++) {
1790 return m_platform_sp->ModuleIsExcludedForUnconstrainedSearches(*
this,
1802 if (section_sp->IsEncrypted()) {
1803 error.SetErrorString(
"section is encrypted");
1806 ModuleSP module_sp(section_sp->GetModule());
1811 section_sp.get(), addr.
GetOffset(), dst, dst_len);
1815 error.SetErrorStringWithFormat(
"error reading data from section %s",
1816 section_sp->GetName().GetCString());
1818 error.SetErrorString(
"address isn't from a object file");
1820 error.SetErrorString(
"address isn't in a module");
1822 error.SetErrorString(
"address doesn't contain a section that points to a "
1823 "section in a object file");
1844 size_t bytes_read = 0;
1851 if (section_load_list.
IsEmpty()) {
1870 resolved_addr = fixed_addr;
1875 std::unique_ptr<uint8_t[]> file_cache_read_buffer;
1876 size_t file_cache_bytes_read = 0;
1882 auto permissions =
Flags(section_sp->GetPermissions());
1883 bool is_readonly = !permissions.Test(ePermissionsWritable) &&
1884 permissions.Test(ePermissionsReadable);
1886 file_cache_bytes_read =
1888 if (file_cache_bytes_read == dst_len)
1889 return file_cache_bytes_read;
1890 else if (file_cache_bytes_read > 0) {
1891 file_cache_read_buffer =
1892 std::make_unique<uint8_t[]>(file_cache_bytes_read);
1893 std::memcpy(file_cache_read_buffer.get(), dst, file_cache_bytes_read);
1905 if (addr_module_sp && addr_module_sp->GetFileSpec())
1906 error.SetErrorStringWithFormatv(
1907 "{0:F}[{1:x+}] can't be resolved, {0:F} is not currently loaded",
1910 error.SetErrorStringWithFormat(
"0x%" PRIx64
" can't be resolved",
1914 if (bytes_read != dst_len) {
1915 if (
error.Success()) {
1916 if (bytes_read == 0)
1917 error.SetErrorStringWithFormat(
1918 "read memory from 0x%" PRIx64
" failed", load_addr);
1920 error.SetErrorStringWithFormat(
1921 "only %" PRIu64
" of %" PRIu64
1922 " bytes were read from memory at 0x%" PRIx64,
1923 (uint64_t)bytes_read, (uint64_t)dst_len, load_addr);
1928 *load_addr_ptr = load_addr;
1934 if (file_cache_read_buffer && file_cache_bytes_read > 0) {
1937 std::memcpy(dst, file_cache_read_buffer.get(), file_cache_bytes_read);
1938 return file_cache_bytes_read;
1960 out_str.append(buf, length);
1963 if (length ==
sizeof(buf) - 1)
1964 curr_addr += length;
1969 return out_str.size();
1973 size_t dst_max_len,
Status &result_error,
1974 bool force_live_memory) {
1975 size_t total_cstr_len = 0;
1976 if (dst && dst_max_len) {
1977 result_error.
Clear();
1979 memset(dst, 0, dst_max_len);
1987 const size_t cache_line_size = 512;
1989 size_t bytes_left = dst_max_len - 1;
1990 char *curr_dst = dst;
1992 while (bytes_left > 0) {
1993 addr_t cache_line_bytes_left =
1994 cache_line_size - (curr_addr % cache_line_size);
1996 std::min<addr_t>(bytes_left, cache_line_bytes_left);
1997 size_t bytes_read =
ReadMemory(address, curr_dst, bytes_to_read,
error,
2000 if (bytes_read == 0) {
2001 result_error =
error;
2002 dst[total_cstr_len] =
'\0';
2005 const size_t len = strlen(curr_dst);
2007 total_cstr_len += len;
2009 if (len < bytes_to_read)
2012 curr_dst += bytes_read;
2013 curr_addr += bytes_read;
2014 bytes_left -= bytes_read;
2021 result_error.
Clear();
2023 return total_cstr_len;
2031 return cache_line_size - (load_addr % cache_line_size);
2041 size_t type_width,
bool force_live_memory) {
2042 if (!dst || !max_bytes || !type_width || max_bytes < type_width)
2045 size_t total_bytes_read = 0;
2049 memset(dst, 0, max_bytes);
2050 size_t bytes_left = max_bytes - type_width;
2052 const char terminator[4] = {
'\0',
'\0',
'\0',
'\0'};
2053 assert(
sizeof(terminator) >= type_width &&
"Attempting to validate a "
2054 "string with more than 4 bytes "
2058 char *curr_dst = dst;
2061 while (bytes_left > 0 &&
error.Success()) {
2065 ReadMemory(address, curr_dst, bytes_to_read,
error, force_live_memory);
2067 if (bytes_read == 0)
2072 size_t aligned_start = total_bytes_read - total_bytes_read % type_width;
2073 for (
size_t i = aligned_start;
2074 i + type_width <= total_bytes_read + bytes_read; i += type_width)
2075 if (::memcmp(&dst[i], terminator, type_width) == 0) {
2080 total_bytes_read += bytes_read;
2081 curr_dst += bytes_read;
2082 address.
Slide(bytes_read);
2083 bytes_left -= bytes_read;
2085 return total_bytes_read;
2089 bool is_signed,
Scalar &scalar,
2091 bool force_live_memory) {
2094 if (byte_size <=
sizeof(uval)) {
2097 if (bytes_read == byte_size) {
2102 scalar = data.
GetMaxU32(&offset, byte_size);
2104 scalar = data.
GetMaxU64(&offset, byte_size);
2111 error.SetErrorStringWithFormat(
2112 "byte size of %u is too large for integer scalar type", byte_size);
2118 size_t integer_byte_size,
2120 bool force_live_memory) {
2130 bool force_live_memory) {
2133 false, scalar,
error, force_live_memory)) {
2137 if (section_load_list.
IsEmpty()) {
2151 pointer_addr.
SetOffset(pointer_vm_addr);
2172 llvm::SmallVector<ModuleSP, 1>
2175 bool did_create_module =
false;
2185 module_spec, module_sp, symbol_file_spec, &did_create_module);
2216 &search_paths, &old_modules,
2217 &did_create_module);
2235 &old_modules, &did_create_module);
2243 module_spec,
m_process_sp.get(), module_sp, &search_paths,
2244 &old_modules, &did_create_module);
2246 error.SetErrorString(
"no platform is currently set");
2255 ObjectFile *objfile = module_sp->GetObjectFile();
2270 error_ptr->
SetErrorString(
"debug info files aren't valid target "
2271 "modules, please specify an executable");
2278 "modules, please specify an executable");
2283 "unsupported file type, please specify an executable");
2304 old_modules.push_back(found_module);
2311 if (symbol_file_spec)
2312 module_sp->SetSymbolFileFileSpec(symbol_file_spec);
2317 module_sp->PreloadSymbols();
2318 llvm::SmallVector<ModuleSP, 1> replaced_modules;
2319 for (
ModuleSP &old_module_sp : old_modules) {
2322 if (replaced_modules.empty())
2327 replaced_modules.push_back(std::move(old_module_sp));
2331 if (replaced_modules.size() > 1) {
2344 auto dump = [&message](
Module &dump_module) ->
void {
2345 UUID dump_uuid = dump_module.GetUUID();
2349 message <<
" (uuid ";
2352 dump_uuid.
Dump(message);
2354 message <<
"not specified";
2359 message <<
"New module ";
2362 << llvm::formatv(
" simultaneously replaced {0} old modules: ",
2363 replaced_modules.size());
2364 for (
ModuleSP &replaced_module_sp : replaced_modules)
2365 dump(*replaced_module_sp);
2371 if (replaced_modules.empty())
2374 for (
ModuleSP &old_module_sp : replaced_modules) {
2375 Module *old_module_ptr = old_module_sp.get();
2376 old_module_sp.reset();
2413llvm::Expected<lldb::TypeSystemSP>
2415 bool create_on_demand) {
2417 return llvm::make_error<llvm::StringError>(
"Invalid Target",
2418 llvm::inconvertibleErrorCode());
2430 if (languages_for_expressions.
Empty())
2431 return llvm::make_error<llvm::StringError>(
2432 "No expression support for any languages",
2433 llvm::inconvertibleErrorCode());
2444 uint32_t byte_size) {
2447 return provider->GetRegisterType(name, flags, byte_size);
2450std::vector<lldb::TypeSystemSP>
2458 std::vector<lldb::TypeSystemSP> scratch_type_systems;
2463 for (
auto bit : languages_for_expressions.
bitvector.set_bits()) {
2465 auto type_system_or_err =
2467 if (!type_system_or_err)
2470 "Language '{1}' has expression support but no scratch type "
2471 "system available: {0}",
2474 if (
auto ts = *type_system_or_err)
2475 scratch_type_systems.push_back(ts);
2478 std::sort(scratch_type_systems.begin(), scratch_type_systems.end());
2479 scratch_type_systems.erase(
2480 std::unique(scratch_type_systems.begin(), scratch_type_systems.end()),
2481 scratch_type_systems.end());
2482 return scratch_type_systems;
2489 if (
auto err = type_system_or_err.takeError()) {
2492 "Unable to get persistent expression state for language {1}: {0}",
2497 if (
auto ts = *type_system_or_err)
2498 return ts->GetPersistentExpressionState();
2501 "Unable to get persistent expression state for language {1}: {0}",
2512 if (
auto err = type_system_or_err.takeError()) {
2513 error.SetErrorStringWithFormat(
2514 "Could not find type system for language %s: %s",
2516 llvm::toString(std::move(err)).c_str());
2520 auto ts = *type_system_or_err;
2522 error.SetErrorStringWithFormat(
2523 "Type system for language %s is no longer live",
2528 auto *user_expr = ts->GetUserExpression(expr, prefix, language, desired_type,
2531 error.SetErrorStringWithFormat(
2532 "Could not create an expression for language %s",
2543 if (
auto err = type_system_or_err.takeError()) {
2544 error.SetErrorStringWithFormat(
2545 "Could not find type system for language %s: %s",
2547 llvm::toString(std::move(err)).c_str());
2550 auto ts = *type_system_or_err;
2552 error.SetErrorStringWithFormat(
2553 "Type system for language %s is no longer live",
2557 auto *persistent_fn = ts->GetFunctionCaller(return_type, function_address,
2558 arg_value_list, name);
2560 error.SetErrorStringWithFormat(
2561 "Could not create an expression for language %s",
2564 return persistent_fn;
2567llvm::Expected<std::unique_ptr<UtilityFunction>>
2572 if (!type_system_or_err)
2573 return type_system_or_err.takeError();
2574 auto ts = *type_system_or_err;
2576 return llvm::make_error<llvm::StringError>(
2577 llvm::StringRef(
"Type system for language ") +
2579 llvm::StringRef(
" is no longer live"),
2580 llvm::inconvertibleErrorCode());
2581 std::unique_ptr<UtilityFunction> utility_fn =
2582 ts->CreateUtilityFunction(std::move(expression), std::move(name));
2584 return llvm::make_error<llvm::StringError>(
2585 llvm::StringRef(
"Could not create an expression for language") +
2587 llvm::inconvertibleErrorCode());
2590 if (!utility_fn->Install(diagnostics, exe_ctx))
2591 return llvm::make_error<llvm::StringError>(diagnostics.
GetString(),
2592 llvm::inconvertibleErrorCode());
2594 return std::move(utility_fn);
2615 "setting target's default architecture to {0} ({1})",
2622 if (llvm::to_integer(label, n))
2623 return llvm::make_error<llvm::StringError>(
2624 "Cannot use integer as target label.", llvm::inconvertibleErrorCode());
2628 if (target_sp && target_sp->GetLabel() == label) {
2629 return llvm::make_error<llvm::StringError>(
2631 "Cannot use label '{0}' since it's set in target #{1}.", label,
2633 llvm::inconvertibleErrorCode());
2638 return llvm::Error::success();
2647 Target *target =
nullptr;
2648 if (sc_ptr !=
nullptr)
2650 if (target ==
nullptr && exe_ctx_ptr)
2660 result_valobj_sp.reset();
2666 return execution_results;
2672 auto on_exit = llvm::make_scope_exit([
this, old_suppress_value]() {
2690 if (expr[0] ==
'$') {
2691 auto type_system_or_err =
2693 if (
auto err = type_system_or_err.takeError()) {
2695 "Unable to get scratch type system");
2697 auto ts = *type_system_or_err;
2700 "Scratch type system is no longer live: {0}");
2703 ts->GetPersistentExpressionState()->GetVariable(expr);
2706 if (persistent_var_sp) {
2707 result_valobj_sp = persistent_var_sp->GetValueObject();
2713 result_valobj_sp,
error,
2714 fixed_expression, ctx_obj);
2716 if (
error.Fail() && !result_valobj_sp)
2718 exe_ctx.GetBestExecutionContextScope(),
error);
2725 return execution_results;
2731 [name, &variable_sp](
TypeSystemSP type_system) ->
bool {
2732 auto ts = type_system.get();
2736 ts->GetPersistentExpressionState()) {
2737 variable_sp = persistent_state->GetVariable(name);
2752 auto ts = type_system.get();
2757 ts->GetPersistentExpressionState()) {
2758 address = persistent_state->LookupSymbol(name);
2759 if (address != LLDB_INVALID_ADDRESS)
2771 const bool has_primary_executable = exe_module && exe_module->
GetObjectFile();
2772 if (has_primary_executable) {
2779 const size_t num_images = modules.
GetSize();
2780 for (
size_t idx = 0; idx < num_images; ++idx) {
2782 if (!module_sp || !module_sp->GetObjectFile())
2785 Address entry_addr = module_sp->GetObjectFile()->GetEntryPointAddress();
2791 if (!has_primary_executable)
2792 return llvm::make_error<llvm::StringError>(
2793 "No primary executable found and could not find entry point address in "
2794 "any executable module",
2795 llvm::inconvertibleErrorCode());
2797 return llvm::make_error<llvm::StringError>(
2798 "Could not find entry point address for primary executable module \"" +
2800 llvm::inconvertibleErrorCode());
2807 ? arch_plugin->GetCallableLoadAddress(load_addr, addr_class)
2814 return arch_plugin ? arch_plugin->GetOpcodeLoadAddress(load_addr, addr_class)
2820 return arch_plugin ? arch_plugin->GetBreakableLoadAddress(addr, *
this) : addr;
2841 return stop_hook_sp;
2853 return (num_removed != 0);
2861 StopHookCollection::iterator specified_hook_iter;
2864 found_hook = (*specified_hook_iter).second;
2869 bool active_state) {
2870 StopHookCollection::iterator specified_hook_iter;
2875 (*specified_hook_iter).second->SetIsActive(active_state);
2880 StopHookCollection::iterator pos, end =
m_stop_hooks.end();
2882 (*pos).second->SetIsActive(active_state);
2902 bool any_active_hooks =
false;
2904 if (hook.second->IsActive()) {
2905 any_active_hooks =
true;
2909 if (!any_active_hooks)
2918 uint32_t last_natural_stop =
m_process_sp->GetModIDRef().GetLastNaturalStopID();
2924 std::vector<ExecutionContext> exc_ctx_with_reasons;
2927 size_t num_threads = cur_threadlist.
GetSize();
2928 for (
size_t i = 0; i < num_threads; i++) {
2930 if (cur_thread_sp->ThreadStoppedForAReason()) {
2932 exc_ctx_with_reasons.emplace_back(
m_process_sp.get(), cur_thread_sp.get(),
2933 cur_frame_sp.get());
2938 size_t num_exe_ctx = exc_ctx_with_reasons.size();
2939 if (num_exe_ctx == 0)
2944 bool auto_continue =
false;
2945 bool hooks_ran =
false;
2947 bool print_thread_header = (num_exe_ctx != 1);
2948 bool should_stop =
false;
2949 bool somebody_restarted =
false;
2953 if (!cur_hook_sp->IsActive())
2956 bool any_thread_matched =
false;
2957 for (
auto exc_ctx : exc_ctx_with_reasons) {
2960 if (somebody_restarted)
2963 if (!cur_hook_sp->ExecutionContextPasses(exc_ctx))
2968 auto_continue |= cur_hook_sp->GetAutoContinue();
2973 if (print_hook_header && !any_thread_matched) {
2977 output_sp->
Printf(
"\n- Hook %" PRIu64
" (%s)\n", cur_hook_sp->GetID(),
2980 output_sp->Printf(
"\n- Hook %" PRIu64
"\n", cur_hook_sp->GetID());
2981 any_thread_matched =
true;
2984 if (print_thread_header)
2985 output_sp->Printf(
"-- Thread %d\n",
2986 exc_ctx.GetThreadPtr()->GetIndexID());
2989 cur_hook_sp->HandleStop(exc_ctx, output_sp);
2990 bool this_should_stop =
true;
2992 switch (this_result) {
2996 if (cur_hook_sp->GetAutoContinue())
2997 this_should_stop =
false;
2999 this_should_stop =
true;
3003 this_should_stop =
false;
3009 output_sp->Printf(
"\nAborting stop hooks, hook %" PRIu64
3010 " set the program running.\n"
3011 " Consider using '-G true' to make "
3012 "stop hooks auto-continue.\n",
3013 cur_hook_sp->GetID());
3014 somebody_restarted =
true;
3021 if (somebody_restarted)
3026 should_stop = this_should_stop;
3034 if (somebody_restarted)
3040 if ((hooks_ran && !should_stop) || auto_continue) {
3043 if (
error.Success()) {
3044 LLDB_LOG(log,
"Resuming from RunStopHooks");
3047 LLDB_LOG(log,
"Resuming from RunStopHooks failed: {0}",
error);
3060 return *g_settings_ptr;
3067 if (platform_sp->IsRemote()) {
3068 if (platform_sp->IsConnected()) {
3074 const size_t num_images = modules.
GetSize();
3075 for (
size_t idx = 0; idx < num_images; ++idx) {
3079 FileSpec local_file(module_sp->GetFileSpec());
3081 FileSpec remote_file(module_sp->GetRemoteInstallFileSpec());
3085 remote_file = platform_sp->GetRemoteWorkingDirectory();
3087 module_sp->GetFileSpec().GetFilename().GetCString());
3091 error = platform_sp->Install(local_file, remote_file);
3092 if (
error.Success()) {
3093 module_sp->SetPlatformFileSpec(remote_file);
3094 if (is_main_executable) {
3095 platform_sp->SetFilePermissions(remote_file, 0700);
3122 addr_t new_section_load_addr,
3123 bool warn_multiple) {
3124 const addr_t old_section_load_addr =
3127 if (old_section_load_addr != new_section_load_addr) {
3128 uint32_t stop_id = 0;
3131 stop_id = process_sp->GetStopID();
3135 stop_id, section_sp, new_section_load_addr, warn_multiple))
3142 size_t section_unload_count = 0;
3143 size_t num_modules = module_list.
GetSize();
3144 for (
size_t i = 0; i < num_modules; ++i) {
3145 section_unload_count +=
3148 return section_unload_count;
3152 uint32_t stop_id = 0;
3155 stop_id = process_sp->GetStopID();
3158 SectionList *sections = module_sp->GetSectionList();
3159 size_t section_unload_count = 0;
3162 for (uint32_t i = 0; i < num_sections; ++i) {
3167 return section_unload_count;
3171 uint32_t stop_id = 0;
3174 stop_id = process_sp->GetStopID();
3182 uint32_t stop_id = 0;
3185 stop_id = process_sp->GetStopID();
3210 LLDB_LOGF(log,
"Target::%s() called for %s", __FUNCTION__,
3222 state = process_sp->GetState();
3224 "Target::%s the process exists, and its current state is %s",
3227 LLDB_LOGF(log,
"Target::%s the process instance doesn't currently exist.",
3240 const bool synchronous_execution =
3248 if (launch_info.
GetFlags().
Test(eLaunchFlagLaunchInTTY)) {
3249 error.SetErrorString(
3250 "can't launch in tty when launching through a remote connection");
3270 LLDB_LOGF(log,
"Target::%s asking the platform to debug the process",
3284 "Target::%s the platform doesn't know how to debug a "
3285 "process, getting a process plugin to do this for us.",
3305 error.SetErrorString(
"failed to launch or debug process");
3307 if (!
error.Success())
3310 bool rebroadcast_first_stop =
3311 !synchronous_execution &&
3317 state =
m_process_sp->WaitForProcessToStop(std::nullopt, &first_stop_event_sp,
3318 rebroadcast_first_stop,
3322 if (rebroadcast_first_stop) {
3323 assert(first_stop_event_sp);
3330 if (launch_info.
GetFlags().
Test(eLaunchFlagStopAtEntry))
3332 if (synchronous_execution)
3339 if (!
error.Success()) {
3342 "process resume at entry point failed: %s",
error.AsCString());
3347 bool with_shell = !!launch_info.
GetShell();
3349 const char *exit_desc =
m_process_sp->GetExitDescription();
3351 if (exit_desc && exit_desc[0])
3352 desc =
" (" + std::string(exit_desc) +
')';
3354 error.SetErrorStringWithFormat(
3355 "process exited with status %i%s\n"
3356 "'r' and 'run' are aliases that default to launching through a "
3358 "Try launching without going through a shell by using "
3359 "'process launch'.",
3360 exit_status, desc.c_str());
3362 error.SetErrorStringWithFormat(
"process exited with status %i%s",
3363 exit_status, desc.c_str());
3366 error.SetErrorStringWithFormat(
"initial process state wasn't stopped: %s",
3379 return llvm::createStringError(llvm::inconvertibleErrorCode(),
3380 "A process is required for tracing");
3382 return llvm::createStringError(llvm::inconvertibleErrorCode(),
3383 "A trace already exists for the target");
3385 llvm::Expected<TraceSupportedResponse> trace_type =
3388 return llvm::createStringError(
3389 llvm::inconvertibleErrorCode(),
"Tracing is not supported. %s",
3390 llvm::toString(trace_type.takeError()).c_str());
3391 if (llvm::Expected<TraceSP> trace_sp =
3395 return llvm::createStringError(
3396 llvm::inconvertibleErrorCode(),
3397 "Couldn't create a Trace object for the process. %s",
3398 llvm::toString(trace_sp.takeError()).c_str());
3413 state = process_sp->GetState();
3416 return Status(
"process attach is in progress");
3417 return Status(
"a process is already being debugged");
3426 if (old_exec_module_sp)
3428 old_exec_module_sp->GetPlatformFileSpec().GetFilename());
3431 return Status(
"no process specified, create a target with a file, or "
3432 "specify the --pid or --name");
3436 const auto platform_sp =
3439 const bool async = attach_info.
GetAsync();
3457 plugin_name,
nullptr,
false);
3459 error.SetErrorStringWithFormatv(
3460 "failed to create process using plugin '{0}'",
3461 plugin_name.empty() ?
"<empty>" : plugin_name);
3465 if (hijack_listener_sp)
3466 process_sp->HijackProcessEvents(hijack_listener_sp);
3467 error = process_sp->Attach(attach_info);
3470 if (
error.Success() && process_sp) {
3472 process_sp->RestoreProcessEvents();
3475 state = process_sp->WaitForProcessToStop(
3478 process_sp->RestoreProcessEvents();
3481 const char *exit_desc = process_sp->GetExitDescription();
3483 error.SetErrorStringWithFormat(
"%s", exit_desc);
3485 error.SetErrorString(
3486 "process did not stop (no such process or permission problem?)");
3487 process_sp->Destroy(
false);
3500 const bool default_to_use_pty =
3504 "have platform={0}, platform_sp->IsHost()={1}, default_to_use_pty={2}",
3506 platform_sp ? (platform_sp->IsHost() ?
"true" :
"false") :
"n/a",
3507 default_to_use_pty);
3514 LLDB_LOG(log,
"at least one of stdin/stdout/stderr was not set, evaluating "
3515 "default handling");
3524 LLDB_LOG(log,
"eLaunchFlagDisableSTDIO set, adding suppression action "
3525 "for stdin, stdout and stderr");
3545 LLDB_LOG(log,
"target stdin='{0}', target stdout='{1}', stderr='{1}'",
3546 in_file_spec, out_file_spec, err_file_spec);
3550 LLDB_LOG(log,
"appended stdin open file action for {0}", in_file_spec);
3553 if (out_file_spec) {
3555 LLDB_LOG(log,
"appended stdout open file action for {0}",
3559 if (err_file_spec) {
3561 LLDB_LOG(log,
"appended stderr open file action for {0}",
3565 if (default_to_use_pty) {
3567 LLDB_LOG_ERROR(log, std::move(Err),
"SetUpPtyRedirection failed: {0}");
3584 elem.notify = notify;
3594 = signals_sp->GetSignalNumberFromName(elem.first().str().c_str());
3599 signals_sp->SetShouldSuppress(signo,
false);
3601 signals_sp->SetShouldSuppress(signo,
true);
3604 signals_sp->SetShouldNotify(signo,
true);
3606 signals_sp->SetShouldNotify(signo,
false);
3609 signals_sp->SetShouldStop(signo,
true);
3611 signals_sp->SetShouldStop(signo,
false);
3620 = signals_sp->GetSignalNumberFromName(elem.first().str().c_str());
3626 signals_sp->ResetSignal(signo, do_stop, do_notify, do_pass);
3637 warning_stream_sp->Printf(
"Target signal '%s' not found in process\n",
3638 elem.first().str().c_str());
3651 signals_sp = process_sp->GetUnixSignals();
3654 const char *signal_name = entry.c_str();
3668 strm.
Printf(
"NAME PASS STOP NOTIFY\n");
3669 strm.
Printf(
"=========== ======= ======= =======\n");
3671 auto str_for_lazy = [] (
LazyBool lazy) ->
const char * {
3677 llvm_unreachable(
"Fully covered switch above!");
3681 bool print_it =
false;
3682 for (
size_t idx = 0; idx < num_args; idx++) {
3689 strm.
Printf(
"%-11s ", elem.first().str().c_str());
3690 strm.
Printf(
"%s %s %s\n", str_for_lazy(elem.second.pass),
3691 str_for_lazy(elem.second.stop),
3692 str_for_lazy(elem.second.notify));
3699 :
UserID(uid), m_target_sp(target_sp), m_specifier_sp(),
3700 m_thread_spec_up() {}
3703 :
UserID(rhs.GetID()), m_target_sp(rhs.m_target_sp),
3704 m_specifier_sp(rhs.m_specifier_sp), m_thread_spec_up(),
3705 m_active(rhs.m_active), m_auto_continue(rhs.m_auto_continue) {
3711 m_specifier_sp.reset(specifier);
3715 m_thread_spec_up.reset(specifier);
3723 bool will_run =
true;
3725 will_run = GetSpecifier()->SymbolContextMatches(
3727 if (will_run && GetThreadSpecifier() !=
nullptr)
3729 GetThreadSpecifier()->ThreadPassesBasicTests(exc_ctx.
GetThreadRef());
3739 GetSubclassDescription(s, level);
3747 s.
Printf(
"Hook: %" PRIu64
"\n", GetID());
3749 s.
Indent(
"State: enabled\n");
3751 s.
Indent(
"State: disabled\n");
3753 if (m_auto_continue)
3754 s.
Indent(
"AutoContinue on\n");
3756 if (m_specifier_sp) {
3760 m_specifier_sp->GetDescription(&s, level);
3764 if (m_thread_spec_up) {
3767 m_thread_spec_up->GetDescription(&tmp, level);
3773 GetSubclassDescription(s, level);
3780 if (m_commands.GetSize() == 1)
3781 s.
PutCString(m_commands.GetStringAtIndex(0));
3784 s.
Indent(
"Commands: \n");
3786 uint32_t num_commands = m_commands.GetSize();
3787 for (uint32_t i = 0; i < num_commands; i++) {
3788 s.
Indent(m_commands.GetStringAtIndex(i));
3796 GetCommands().SplitIntoLines(
string);
3800 const std::vector<std::string> &strings) {
3801 for (
auto string : strings)
3802 GetCommands().AppendString(
string.c_str());
3808 assert(exc_ctx.
GetTargetPtr() &&
"Can't call PerformAction on a context "
3811 if (!m_commands.GetSize())
3812 return StopHookResult::KeepStopped;
3835 return StopHookResult::AlreadyContinued;
3836 return StopHookResult::KeepStopped;
3845 GetTarget()->GetDebugger().GetScriptInterpreter();
3846 if (!script_interp) {
3847 error.SetErrorString(
"No script interpreter installed.");
3851 m_class_name = class_name;
3852 m_extra_args.SetObjectSP(extra_args_sp);
3855 GetTarget(), m_class_name.c_str(), m_extra_args,
error);
3863 assert(exc_ctx.
GetTargetPtr() &&
"Can't call HandleStop on a context "
3867 GetTarget()->GetDebugger().GetScriptInterpreter();
3869 return StopHookResult::KeepStopped;
3872 m_implementation_sp, exc_ctx, output_sp);
3874 return should_stop ? StopHookResult::KeepStopped
3875 : StopHookResult::RequestContinue;
3885 s.
Printf(
"%s\n", m_class_name.c_str());
3890 if (!m_extra_args.IsValid())
3893 if (!object_sp || !object_sp->IsValid())
3897 if (!as_dict || !as_dict->
IsValid())
3900 uint32_t num_keys = as_dict->
GetSize();
3907 auto print_one_element = [&s](llvm::StringRef key,
3910 s.
Format(
"{0} : {1}\n", key, object->GetStringValue());
3914 as_dict->
ForEach(print_one_element);
3922 "no-dynamic-values",
3923 "Don't calculate the dynamic type of values",
3928 "Calculate the dynamic type of values "
3929 "even if you have to run the target.",
3934 "Calculate the dynamic type of values, but don't run the target.",
3946 "Never look for inline breakpoint locations (fastest). This setting "
3947 "should only be used if you know that no inlining occurs in your"
3953 "Only check for inline breakpoint locations when setting breakpoints "
3954 "in header files, but not when setting breakpoint in implementation "
3955 "source files (default).",
3960 "Always look for inline breakpoint locations when setting file and "
3961 "line breakpoints (slower but most accurate).",
3975 "Disassembler default (currently att).",
3980 "Intel disassembler flavor.",
3985 "AT&T disassembler flavor.",
3993 "Never import the 'std' C++ module in the expression parser.",
3998 "Retry evaluating expressions with an imported 'std' C++ module if they"
3999 " failed to parse without the module. This allows evaluating more "
4000 "complex expressions involving C++ standard library types."
4005 "Always import the 'std' C++ module. This allows evaluating more "
4006 "complex expressions involving C++ standard library types. This feature"
4016 "Automatically determine the most appropriate method for the "
4020 "Prefer using the realized classes struct."},
4022 "Prefer using the CopyRealizedClassList API."},
4024 "Prefer using the GetRealizedClassList API."},
4031 "C-style (0xffff).",
4036 "Asm-style (0ffffh).",
4044 "Load debug scripts inside symbol files",
4049 "Do not load debug scripts inside symbol files.",
4054 "Warn about debug scripts inside symbol files but do not load them.",
4062 "Load .lldbinit files from current directory",
4067 "Do not load .lldbinit files from current directory",
4072 "Warn about loading .lldbinit files from current directory",
4080 "Load minimal information when loading modules from memory. Currently "
4081 "this setting loads sections only.",
4086 "Load partial information when loading modules from memory. Currently "
4087 "this setting loads sections and function bounds.",
4092 "Load complete information when loading modules from memory. Currently "
4093 "this setting loads sections and all symbols.",
4097#define LLDB_PROPERTIES_target
4098#include "TargetProperties.inc"
4101#define LLDB_PROPERTIES_target
4102#include "TargetPropertiesEnum.inc"
4107 :
public Cloneable<TargetOptionValueProperties, OptionValueProperties> {
4118 Target *target = exe_ctx->GetTargetPtr();
4123 if (
this != target_properties)
4127 return ProtectedGetPropertyAtIndex(idx);
4132#define LLDB_PROPERTIES_target_experimental
4133#include "TargetProperties.inc"
4136#define LLDB_PROPERTIES_target_experimental
4137#include "TargetPropertiesEnum.inc"
4141 :
public Cloneable<TargetExperimentalOptionValueProperties,
4142 OptionValueProperties> {
4156 :
Properties(), m_launch_info(), m_target(target) {
4179 m_collection_sp->SetValueChangedCallback(ePropertyDetachOnError, [
this] {
4192 std::make_unique<TargetExperimentalProperties>();
4195 "Experimental settings - setting these won't produce "
4196 "errors if the setting is not present.",
4199 m_collection_sp = std::make_shared<TargetOptionValueProperties>(
"target");
4202 std::make_unique<TargetExperimentalProperties>();
4205 "Experimental settings - setting these won't produce "
4206 "errors if the setting is not present.",
4209 "process",
"Settings specific to processes.",
true,
4236 exp_property->
GetValue()->GetAsProperties();
4239 return std::nullopt;
4249 const uint32_t idx = ePropertyDefaultArch;
4250 return GetPropertyAtIndexAs<ArchSpec>(idx, {});
4254 const uint32_t idx = ePropertyDefaultArch;
4259 const uint32_t idx = ePropertyMoveToNearestCode;
4260 return GetPropertyAtIndexAs<bool>(
4261 idx, g_target_properties[idx].default_uint_value != 0);
4265 const uint32_t idx = ePropertyPreferDynamic;
4266 return GetPropertyAtIndexAs<lldb::DynamicValueType>(
4268 g_target_properties[idx].default_uint_value));
4272 const uint32_t idx = ePropertyPreferDynamic;
4278 "Interrupted checking preload symbols")) {
4281 const uint32_t idx = ePropertyPreloadSymbols;
4282 return GetPropertyAtIndexAs<bool>(
4283 idx, g_target_properties[idx].default_uint_value != 0);
4287 const uint32_t idx = ePropertyPreloadSymbols;
4292 const uint32_t idx = ePropertyDisableASLR;
4293 return GetPropertyAtIndexAs<bool>(
4294 idx, g_target_properties[idx].default_uint_value != 0);
4298 const uint32_t idx = ePropertyDisableASLR;
4303 const uint32_t idx = ePropertyInheritTCC;
4304 return GetPropertyAtIndexAs<bool>(
4305 idx, g_target_properties[idx].default_uint_value != 0);
4309 const uint32_t idx = ePropertyInheritTCC;
4314 const uint32_t idx = ePropertyDetachOnError;
4315 return GetPropertyAtIndexAs<bool>(
4316 idx, g_target_properties[idx].default_uint_value != 0);
4320 const uint32_t idx = ePropertyDetachOnError;
4325 const uint32_t idx = ePropertyDisableSTDIO;
4326 return GetPropertyAtIndexAs<bool>(
4327 idx, g_target_properties[idx].default_uint_value != 0);
4331 const uint32_t idx = ePropertyDisableSTDIO;
4336 const uint32_t idx = ePropertyDisassemblyFlavor;
4337 const char *return_value;
4340 GetPropertyAtIndexAs<x86DisassemblyFlavor>(
4342 g_target_properties[idx].default_uint_value));
4345 return return_value;
4349 const uint32_t idx = ePropertyInlineStrategy;
4350 return GetPropertyAtIndexAs<InlineStrategy>(
4352 static_cast<InlineStrategy>(g_target_properties[idx].default_uint_value));
4356 const uint32_t idx = ePropertyArg0;
4357 return GetPropertyAtIndexAs<llvm::StringRef>(
4358 idx, g_target_properties[idx].default_cstr_value);
4362 const uint32_t idx = ePropertyArg0;
4368 const uint32_t idx = ePropertyRunArgs;
4373 const uint32_t idx = ePropertyRunArgs;
4382 GetPropertyAtIndexAs<bool>(
4383 ePropertyInheritEnv,
4384 g_target_properties[ePropertyInheritEnv].default_uint_value != 0)) {
4386 Environment platform_env = platform_sp->GetEnvironment();
4387 for (
const auto &KV : platform_env)
4388 env[KV.first()] = KV.second;
4392 Args property_unset_env;
4394 property_unset_env);
4395 for (
const auto &var : property_unset_env)
4396 env.erase(var.ref());
4399 m_collection_sp->GetPropertyAtIndexAsArgs(ePropertyEnvVars, property_env);
4401 env[KV.first()] = KV.second;
4416 if (!GetPropertyAtIndexAs<bool>(
4417 ePropertyInheritEnv,
4418 g_target_properties[ePropertyInheritEnv].default_uint_value != 0))
4422 if (platform_sp ==
nullptr)
4425 Environment platform_environment = platform_sp->GetEnvironment();
4426 for (
const auto &KV : platform_environment)
4427 environment[KV.first()] = KV.second;
4429 Args property_unset_environment;
4431 property_unset_environment);
4432 for (
const auto &var : property_unset_environment)
4433 environment.erase(var.ref());
4439 Args property_environment;
4441 property_environment);
4443 for (
const auto &KV :
Environment(property_environment))
4444 environment[KV.first()] = KV.second;
4451 const uint32_t idx = ePropertyEnvVars;
4456 const uint32_t idx = ePropertySkipPrologue;
4457 return GetPropertyAtIndexAs<bool>(
4458 idx, g_target_properties[idx].default_uint_value != 0);
4462 const uint32_t idx = ePropertySourceMap;
4465 assert(option_value);
4470 const uint32_t idx = ePropertyAutoSourceMapRelative;
4471 return GetPropertyAtIndexAs<bool>(
4472 idx, g_target_properties[idx].default_uint_value != 0);
4476 const uint32_t idx = ePropertyExecutableSearchPaths;
4479 assert(option_value);
4484 const uint32_t idx = ePropertyExecutableSearchPaths;
4485 return GetPropertyAtIndexAs<FileSpecList>(idx, {});
4489 const uint32_t idx = ePropertyDebugFileSearchPaths;
4490 return GetPropertyAtIndexAs<FileSpecList>(idx, {});
4494 const uint32_t idx = ePropertyClangModuleSearchPaths;
4495 return GetPropertyAtIndexAs<FileSpecList>(idx, {});
4499 const uint32_t idx = ePropertyAutoImportClangModules;
4500 return GetPropertyAtIndexAs<bool>(
4501 idx, g_target_properties[idx].default_uint_value != 0);
4505 const uint32_t idx = ePropertyImportStdModule;
4506 return GetPropertyAtIndexAs<ImportStdModule>(
4508 g_target_properties[idx].default_uint_value));
4512 const uint32_t idx = ePropertyDynamicClassInfoHelper;
4513 return GetPropertyAtIndexAs<DynamicClassInfoHelper>(
4515 g_target_properties[idx].default_uint_value));
4519 const uint32_t idx = ePropertyAutoApplyFixIts;
4520 return GetPropertyAtIndexAs<bool>(
4521 idx, g_target_properties[idx].default_uint_value != 0);
4525 const uint32_t idx = ePropertyRetriesWithFixIts;
4526 return GetPropertyAtIndexAs<uint64_t>(
4527 idx, g_target_properties[idx].default_uint_value);
4531 const uint32_t idx = ePropertyNotifyAboutFixIts;
4532 return GetPropertyAtIndexAs<bool>(
4533 idx, g_target_properties[idx].default_uint_value != 0);
4537 const uint32_t idx = ePropertySaveObjectsDir;
4538 return GetPropertyAtIndexAs<FileSpec>(idx, {});
4547 bool exists = instance.
Exists(new_dir);
4548 bool is_directory = instance.
IsDirectory(new_dir);
4549 std::string path = new_dir.
GetPath(
true);
4550 bool writable = llvm::sys::fs::can_write(path);
4551 if (exists && is_directory && writable)
4559 llvm::raw_string_ostream os(buffer);
4560 os <<
"JIT object dir '" << path <<
"' ";
4562 os <<
"does not exist";
4563 else if (!is_directory)
4564 os <<
"is not a directory";
4566 os <<
"is not writable";
4568 std::optional<lldb::user_id_t> debugger_id;
4575 const uint32_t idx = ePropertyEnableSynthetic;
4576 return GetPropertyAtIndexAs<bool>(
4577 idx, g_target_properties[idx].default_uint_value != 0);
4581 const uint32_t idx = ePropertyShowHexVariableValuesWithLeadingZeroes;
4582 return GetPropertyAtIndexAs<bool>(
4583 idx, g_target_properties[idx].default_uint_value != 0);
4587 const uint32_t idx = ePropertyMaxZeroPaddingInFloatFormat;
4588 return GetPropertyAtIndexAs<uint64_t>(
4589 idx, g_target_properties[idx].default_uint_value);
4593 const uint32_t idx = ePropertyMaxChildrenCount;
4594 return GetPropertyAtIndexAs<int64_t>(
4595 idx, g_target_properties[idx].default_uint_value);
4598std::pair<uint32_t, bool>
4600 const uint32_t idx = ePropertyMaxChildrenDepth;
4601 auto *option_value =
4603 bool is_default = !option_value->OptionWasSet();
4604 return {option_value->GetCurrentValue(), is_default};
4608 const uint32_t idx = ePropertyMaxSummaryLength;
4609 return GetPropertyAtIndexAs<uint64_t>(
4610 idx, g_target_properties[idx].default_uint_value);
4614 const uint32_t idx = ePropertyMaxMemReadSize;
4615 return GetPropertyAtIndexAs<uint64_t>(
4616 idx, g_target_properties[idx].default_uint_value);
4620 const uint32_t idx = ePropertyInputPath;
4621 return GetPropertyAtIndexAs<FileSpec>(idx, {});
4625 const uint32_t idx = ePropertyInputPath;
4630 const uint32_t idx = ePropertyOutputPath;
4631 return GetPropertyAtIndexAs<FileSpec>(idx, {});
4635 const uint32_t idx = ePropertyOutputPath;
4640 const uint32_t idx = ePropertyErrorPath;
4641 return GetPropertyAtIndexAs<FileSpec>(idx, {});
4645 const uint32_t idx = ePropertyErrorPath;
4650 const uint32_t idx = ePropertyLanguage;
4651 return GetPropertyAtIndexAs<LanguageType>(idx, {});
4655 const uint32_t idx = ePropertyExprPrefix;
4661 return llvm::StringRef(
4662 reinterpret_cast<const char *
>(data_sp->GetBytes()),
4663 data_sp->GetByteSize());
4669 const uint32_t idx = ePropertyExprErrorLimit;
4670 return GetPropertyAtIndexAs<uint64_t>(
4671 idx, g_target_properties[idx].default_uint_value);
4675 const uint32_t idx = ePropertyExprAllocAddress;
4676 return GetPropertyAtIndexAs<uint64_t>(
4677 idx, g_target_properties[idx].default_uint_value);
4681 const uint32_t idx = ePropertyExprAllocSize;
4682 return GetPropertyAtIndexAs<uint64_t>(
4683 idx, g_target_properties[idx].default_uint_value);
4687 const uint32_t idx = ePropertyExprAllocAlign;
4688 return GetPropertyAtIndexAs<uint64_t>(
4689 idx, g_target_properties[idx].default_uint_value);
4693 const uint32_t idx = ePropertyBreakpointUseAvoidList;
4694 return GetPropertyAtIndexAs<bool>(
4695 idx, g_target_properties[idx].default_uint_value != 0);
4699 const uint32_t idx = ePropertyUseHexImmediates;
4700 return GetPropertyAtIndexAs<bool>(
4701 idx, g_target_properties[idx].default_uint_value != 0);
4705 const uint32_t idx = ePropertyUseFastStepping;
4706 return GetPropertyAtIndexAs<bool>(
4707 idx, g_target_properties[idx].default_uint_value != 0);
4711 const uint32_t idx = ePropertyDisplayExpressionsInCrashlogs;
4712 return GetPropertyAtIndexAs<bool>(
4713 idx, g_target_properties[idx].default_uint_value != 0);
4717 const uint32_t idx = ePropertyLoadScriptFromSymbolFile;
4718 return GetPropertyAtIndexAs<LoadScriptFromSymFile>(
4720 g_target_properties[idx].default_uint_value));
4724 const uint32_t idx = ePropertyLoadCWDlldbinitFile;
4725 return GetPropertyAtIndexAs<LoadCWDlldbinitFile>(
4727 g_target_properties[idx].default_uint_value));
4731 const uint32_t idx = ePropertyHexImmediateStyle;
4732 return GetPropertyAtIndexAs<Disassembler::HexImmediateStyle>(
4734 g_target_properties[idx].default_uint_value));
4738 const uint32_t idx = ePropertyMemoryModuleLoadLevel;
4739 return GetPropertyAtIndexAs<MemoryModuleLoadLevel>(
4741 g_target_properties[idx].default_uint_value));
4745 const uint32_t idx = ePropertyTrapHandlerNames;
4750 const uint32_t idx = ePropertyTrapHandlerNames;
4755 const uint32_t idx = ePropertyDisplayRuntimeSupportValues;
4756 return GetPropertyAtIndexAs<bool>(
4757 idx, g_target_properties[idx].default_uint_value != 0);
4761 const uint32_t idx = ePropertyDisplayRuntimeSupportValues;
4766 const uint32_t idx = ePropertyDisplayRecognizedArguments;
4767 return GetPropertyAtIndexAs<bool>(
4768 idx, g_target_properties[idx].default_uint_value != 0);
4772 const uint32_t idx = ePropertyDisplayRecognizedArguments;
4788 if (input_file_action) {
4793 if (output_file_action) {
4798 if (error_file_action) {
4804 launch_info.
GetFlags().
Test(lldb::eLaunchFlagInheritTCCFromParent));
4809 const uint32_t idx = ePropertyRequireHardwareBreakpoints;
4810 return GetPropertyAtIndexAs<bool>(
4811 idx, g_target_properties[idx].default_uint_value != 0);
4815 const uint32_t idx = ePropertyRequireHardwareBreakpoints;
4820 const uint32_t idx = ePropertyAutoInstallMainExecutable;
4821 return GetPropertyAtIndexAs<bool>(
4822 idx, g_target_properties[idx].default_uint_value != 0);
4883 const uint32_t idx = ePropertyDebugUtilityExpression;
4884 return GetPropertyAtIndexAs<bool>(
4885 idx, g_target_properties[idx].default_uint_value != 0);
4889 const uint32_t idx = ePropertyDebugUtilityExpression;
4896 :
EventData(), m_target_sp(target_sp), m_module_list() {}
4900 :
EventData(), m_target_sp(target_sp), m_module_list(module_list) {}
4905 return "Target::TargetEventData";
4909 for (
size_t i = 0; i < m_module_list.GetSize(); ++i) {
4912 m_module_list.GetModuleAtIndex(i)->GetDescription(
static llvm::raw_ostream & error(Stream &strm)
#define INTERRUPT_REQUESTED(debugger,...)
This handy define will keep you from having to generate a report for the interruption by hand.
#define LLDB_LOG(log,...)
The LLDB_LOG* macros defined below are the way to emit log messages.
#define LLDB_LOGF(log,...)
#define LLDB_LOG_ERROR(log, error,...)
static double elapsed(const StatsTimepoint &start, const StatsTimepoint &end)
static constexpr OptionEnumValueElement g_dynamic_class_info_helper_value_types[]
static bool CheckIfWatchpointsSupported(Target *target, Status &error)
static constexpr OptionEnumValueElement g_load_cwd_lldbinit_values[]
static void LoadScriptingResourceForModule(const ModuleSP &module_sp, Target *target)
static constexpr OptionEnumValueElement g_dynamic_value_types[]
static constexpr OptionEnumValueElement g_memory_module_load_level_values[]
static constexpr OptionEnumValueElement g_load_script_from_sym_file_values[]
static constexpr OptionEnumValueElement g_x86_dis_flavor_value_types[]
static constexpr OptionEnumValueElement g_hex_immediate_style_values[]
static constexpr OptionEnumValueElement g_inline_breakpoint_enums[]
static constexpr OptionEnumValueElement g_import_std_module_value_types[]
#define LLDB_SCOPED_TIMERF(...)
TargetExperimentalOptionValueProperties()
const Property * GetPropertyAtIndex(size_t idx, const ExecutionContext *exe_ctx=nullptr) const override
TargetOptionValueProperties(llvm::StringRef name)
static lldb::ABISP FindPlugin(lldb::ProcessSP process_sp, const ArchSpec &arch)
A section + offset based address class.
lldb::addr_t GetLoadAddress(Target *target) const
Get the load address.
bool SetLoadAddress(lldb::addr_t load_addr, Target *target, bool allow_section_end=false)
Set the address to represent load_addr.
lldb::SectionSP GetSection() const
Get const accessor for the section.
bool Slide(int64_t offset)
lldb::ModuleSP GetModule() const
Get accessor for the module for this address.
lldb::addr_t GetFileAddress() const
Get the file address.
lldb::addr_t GetOffset() const
Get the section relative offset value.
bool IsValid() const
Check if the object state is valid.
bool IsSectionOffset() const
Check if an address is section offset.
bool SetOffset(lldb::addr_t offset)
Set accessor for the offset.
An architecture specification class.
uint32_t GetAddressByteSize() const
Returns the size in bytes of an address of the current architecture.
bool IsValid() const
Tests if this ArchSpec is valid.
llvm::Triple & GetTriple()
Architecture triple accessor.
void MergeFrom(const ArchSpec &other)
Merges fields from another ArchSpec into this ArchSpec.
bool IsCompatibleMatch(const ArchSpec &rhs) const
Shorthand for IsMatch(rhs, CompatibleMatch).
lldb::ByteOrder GetByteOrder() const
Returns the byte order for the architecture specification.
const char * GetArchitectureName() const
Returns a static string representing the current architecture.
A command line argument class.
size_t GetArgumentCount() const
Gets the number of arguments left in this command object.
const char * GetArgumentAtIndex(size_t idx) const
Gets the NULL terminated C string argument pointer for the argument at index idx.
bool AddBreakpointID(BreakpointID bp_id)
BreakpointID GetBreakpointIDAtIndex(size_t index) const
lldb::break_id_t GetBreakpointID() const
static bool StringIsBreakpointName(llvm::StringRef str, Status &error)
Takes an input string and checks to see whether it is a breakpoint name.
General Outline: Allows adding and removing breakpoints and find by ID and index.
BreakpointIterable Breakpoints()
void RemoveInvalidLocations(const ArchSpec &arch)
Removes all invalid breakpoint locations.
lldb::BreakpointSP FindBreakpointByID(lldb::break_id_t breakID) const
Returns a shared pointer to the breakpoint with id breakID.
void GetListMutex(std::unique_lock< std::recursive_mutex > &lock)
Sets the passed in Locker to hold the Breakpoint List mutex.
lldb::break_id_t Add(lldb::BreakpointSP &bp_sp, bool notify)
Add the breakpoint bp_sp to the list.
void SetEnabledAllowed(bool enabled)
void ResetHitCounts()
Resets the hit count of all breakpoints.
size_t GetSize() const
Returns the number of elements in this breakpoint list.
void UpdateBreakpointsWhenModuleIsReplaced(lldb::ModuleSP old_module_sp, lldb::ModuleSP new_module_sp)
void RemoveAll(bool notify)
Removes all the breakpoints from this list.
void UpdateBreakpoints(ModuleList &module_list, bool load, bool delete_locations)
Tell all the breakpoints to update themselves due to a change in the modules in module_list.
void ClearAllBreakpointSites()
llvm::Expected< std::vector< lldb::BreakpointSP > > FindBreakpointsByName(const char *name)
Find all the breakpoints with a given name.
void Dump(Stream *s) const
Standard "Dump" method. At present it does nothing.
bool Remove(lldb::break_id_t breakID, bool notify)
Removes the breakpoint given by breakID from this list.
void RemoveAllowed(bool notify)
Removes all the breakpoints from this list - first checking the ePermDelete on the breakpoints.
lldb::BreakpointSP GetBreakpointAtIndex(size_t i) const
Returns a shared pointer to the breakpoint with index i.
void SetEnabledAll(bool enabled)
void MergeInto(const Permissions &incoming)
ConstString GetName() const
Permissions & GetPermissions()
BreakpointOptions & GetOptions()
void ConfigureBreakpoint(lldb::BreakpointSP bp_sp)
"lldb/Breakpoint/BreakpointOptions.h" Class that manages the options on a breakpoint or breakpoint lo...
void CopyOverSetOptions(const BreakpointOptions &rhs)
Copy over only the options set in the incoming BreakpointOptions.
"lldb/Breakpoint/BreakpointResolverAddress.h" This class sets breakpoints on a given Address.
"lldb/Breakpoint/BreakpointResolverFileLine.h" This class sets breakpoints by file and line.
"lldb/Breakpoint/BreakpointResolverFileRegex.h" This class sets breakpoints by file and line.
"lldb/Breakpoint/BreakpointResolverName.h" This class sets breakpoints on a given function name,...
"lldb/Breakpoint/BreakpointResolverScripted.h" This class sets breakpoints on a given Address.
General Outline: A breakpoint has four main parts, a filter, a resolver, the list of breakpoint locat...
virtual StructuredData::ObjectSP SerializeToStructuredData()
static lldb::BreakpointSP CreateFromStructuredData(lldb::TargetSP target_sp, StructuredData::ObjectSP &data_object_sp, Status &error)
static lldb::BreakpointSP CopyFromBreakpoint(lldb::TargetSP new_target, const Breakpoint &bp_to_copy_from)
static const char * GetSerializationKey()
static bool SerializedBreakpointMatchesNames(StructuredData::ObjectSP &bkpt_object_sp, std::vector< std::string > &names)
An event broadcasting class.
void SetEventName(uint32_t event_mask, const char *name)
Set the name for an event bit.
void BroadcastEvent(lldb::EventSP &event_sp)
Broadcast an event which has no associated data.
void CheckInWithManager()
A class that implements CRTP-based "virtual constructor" idiom.
void SetStopOnContinue(bool stop_on_continue)
void SetPrintErrors(bool print_errors)
void SetEchoCommands(bool echo_commands)
void SetAddToHistory(bool add_to_history)
void SetStopOnError(bool stop_on_error)
void SetPrintResults(bool print_results)
void HandleCommands(const StringList &commands, const ExecutionContext &context, const CommandInterpreterRunOptions &options, CommandReturnObject &result)
Execute a list of commands in sequence.
void SetInteractive(bool b)
void SetImmediateOutputStream(const lldb::StreamSP &stream_sp)
lldb::ReturnStatus GetStatus() const
Generic representation of a type in a programming language.
A uniqued constant string class.
const char * AsCString(const char *value_if_empty=nullptr) const
Get the string value as a C string.
bool IsEmpty() const
Test for empty string.
llvm::StringRef GetStringRef() const
Get the string value as a llvm::StringRef.
const char * GetCString() const
Get the string value as a C string.
A class to manage flag bits.
lldb::StreamSP GetAsyncOutputStream()
void SetAsyncExecution(bool async)
CommandInterpreter & GetCommandInterpreter()
StreamFile & GetErrorStream()
TargetList & GetTargetList()
Get accessor for the target list.
static void ReportError(std::string message, std::optional< lldb::user_id_t > debugger_id=std::nullopt, std::once_flag *once=nullptr)
Report error events.
PlatformList & GetPlatformList()
lldb::ListenerSP GetListener()
lldb::LanguageType GetREPLLanguage() const
std::string GetString(char separator='\n')
A class that measures elapsed time in an exception safe way.
static constexpr std::chrono::milliseconds default_timeout
virtual llvm::StringRef GetFlavor() const =0
"lldb/Target/ExecutionContextScope.h" Inherit from this if your object can reconstruct its execution ...
virtual void CalculateExecutionContext(ExecutionContext &exe_ctx)=0
Reconstruct the object's execution context into sc.
"lldb/Target/ExecutionContext.h" A class that contains an execution context.
void Clear()
Clear the object's state.
void SetTargetPtr(Target *target)
Set accessor to set only the target shared pointer from a target pointer.
StackFrame * GetFramePtr() const
Returns a pointer to the frame object.
Target * GetTargetPtr() const
Returns a pointer to the target object.
Thread & GetThreadRef() const
Returns a reference to the thread object.
llvm::StringRef GetPath() const
const FileSpec & GetFileSpecAtIndex(size_t idx) const
Get file at index.
void Append(const FileSpec &file)
Append a FileSpec object to the list.
size_t GetSize() const
Get the number of files in the file list.
void AppendPathComponent(llvm::StringRef component)
void SetDirectory(ConstString directory)
Directory string set accessor.
const ConstString & GetFilename() const
Filename string const get accessor.
const ConstString & GetDirectory() const
Directory string const get accessor.
size_t GetPath(char *path, size_t max_path_length, bool denormalize=true) const
Extract the full path to the file.
bool IsSourceImplementationFile() const
Returns true if the filespec represents an implementation source file (files with a "....
void SetFilename(ConstString filename)
Filename string set accessor.
bool Exists(const FileSpec &file_spec) const
Returns whether the given file exists.
bool IsDirectory(const FileSpec &file_spec) const
Returns whether the given path is a directory.
static FileSystem & Instance()
bool IsValid() const override
IsValid.
ValueType Clear(ValueType mask=~static_cast< ValueType >(0))
Clear one or more flags.
bool Test(ValueType bit) const
Test a single flag bit.
ValueType Set(ValueType mask)
Set one or more flags by logical OR'ing mask with the current flags.
Encapsulates a function that can be called.
static lldb::BreakpointSP CreateExceptionBreakpoint(Target &target, lldb::LanguageType language, bool catch_bp, bool throw_bp, bool is_internal=false)
static LanguageSet GetLanguagesSupportingREPLs()
static Language * FindPlugin(lldb::LanguageType language)
static const char * GetNameForLanguageType(lldb::LanguageType language)
static LanguageSet GetLanguagesSupportingTypeSystemsForExpressions()
virtual llvm::StringRef GetUserEntryPointName() const
static std::set< lldb::LanguageType > GetSupportedLanguages()
static lldb::ListenerSP MakeListener(const char *name)
lldb::ModuleSP GetModule() const
Get const accessor for the module pointer.
A collection class for Module objects.
bool ReplaceModule(const lldb::ModuleSP &old_module_sp, const lldb::ModuleSP &new_module_sp)
void ForEach(std::function< bool(const lldb::ModuleSP &module_sp)> const &callback) const
Applies 'callback' to each module in this ModuleList.
bool AnyOf(std::function< bool(lldb_private::Module &module)> const &callback) const
Returns true if 'callback' returns true for one of the modules in this ModuleList.
size_t GetIndexForModule(const Module *module) const
lldb::ModuleSP FindFirstModule(const ModuleSpec &module_spec) const
void Clear()
Clear the object's state.
void Dump(Stream *s) const
Dump the description of each module contained in this list.
static bool RemoveSharedModuleIfOrphaned(const Module *module_ptr)
bool AppendIfNeeded(const lldb::ModuleSP &new_module, bool notify=true)
Append a module to the module list, if it is not already there.
static Status GetSharedModule(const ModuleSpec &module_spec, lldb::ModuleSP &module_sp, const FileSpecList *module_search_paths_ptr, llvm::SmallVectorImpl< lldb::ModuleSP > *old_modules, bool *did_create_ptr, bool always_create=false)
void FindModules(const ModuleSpec &module_spec, ModuleList &matching_module_list) const
Finds the first module whose file specification matches file_spec.
bool Remove(const lldb::ModuleSP &module_sp, bool notify=true)
Remove a module from the module list.
lldb::ModuleSP GetModuleAtIndex(size_t idx) const
Get the module shared pointer for the module at index idx.
void Append(const lldb::ModuleSP &module_sp, bool notify=true)
Append a module to the module list.
bool ResolveFileAddress(lldb::addr_t vm_addr, Address &so_addr) const
size_t GetSize() const
Gets the size of the module list.
A class that describes an executable image and its associated object and symbol files.
virtual ObjectFile * GetObjectFile()
Get the object file representation for the current architecture.
bool FileHasChanged() const
const FileSpec & GetFileSpec() const
Get const accessor for the module file specification.
A plug-in interface definition class for object file parsers.
virtual uint32_t GetDependentModules(FileSpecList &file_list)=0
Extract the dependent modules from an object file.
virtual lldb_private::Address GetEntryPointAddress()
Returns the address of the Entry Point in this object file - if the object file doesn't have an entry...
@ eTypeExecutable
A normal executable.
@ eTypeDebugInfo
An object file that contains only debug information.
@ eTypeStubLibrary
A library that can be linked against but not used for execution.
@ eTypeObjectFile
An intermediate object file.
@ eTypeDynamicLinker
The platform's dynamic linker executable.
@ eTypeCoreFile
A core file that has a checkpoint of a program's execution state.
@ eTypeSharedLibrary
A shared library that can be used during execution.
virtual size_t ReadSectionData(Section *section, lldb::offset_t section_offset, void *dst, size_t dst_len)
void AppendCurrentValue(const FileSpec &value)
const lldb::DataBufferSP & GetFileContents()
PathMappingList & GetCurrentValue()
auto GetPropertyAtIndexAs(size_t idx, const ExecutionContext *exe_ctx=nullptr) const
Property * ProtectedGetPropertyAtIndex(size_t idx)
static lldb::OptionValuePropertiesSP CreateLocalCopy(const Properties &global_properties)
bool RemapPath(ConstString path, ConstString &new_path) const
std::optional< llvm::StringRef > ReverseRemapPath(const FileSpec &file, FileSpec &fixed) const
Perform reverse source path remap for input file.
static std::unique_ptr< Architecture > CreateArchitectureInstance(const ArchSpec &arch)
static lldb::RegisterTypeBuilderSP GetRegisterTypeBuilder(Target &target)
bool ProcessInfoSpecified() const
lldb::ListenerSP GetListenerForProcess(Debugger &debugger)
llvm::StringRef GetProcessPluginName() const
void SetHijackListener(const lldb::ListenerSP &listener_sp)
void SetExecutableFile(const FileSpec &exe_file, bool add_exe_file_as_first_arg)
lldb::ScriptedMetadataSP GetScriptedMetadata() const
lldb::ListenerSP GetHijackListener() const
void SetArg0(llvm::StringRef arg)
llvm::StringRef GetArg0() const
void SetScriptedMetadata(lldb::ScriptedMetadataSP metadata_sp)
FileSpec & GetExecutableFile()
lldb::ListenerSP GetListener() const
lldb::ListenerSP GetShadowListener() const
Environment & GetEnvironment()
bool IsScriptedProcess() const
ArchSpec & GetArchitecture()
llvm::StringRef GetProcessPluginName() const
const FileSpec & GetShell() const
llvm::Error SetUpPtyRedirection()
bool AppendOpenFileAction(int fd, const FileSpec &file_spec, bool read, bool write)
bool AppendSuppressFileAction(int fd, bool read, bool write)
const FileAction * GetFileActionForFD(int fd) const
void SetProcessPluginName(llvm::StringRef plugin)
static void SettingsInitialize()
static constexpr llvm::StringRef AttachSynchronousHijackListenerName
static lldb::ProcessSP FindPlugin(lldb::TargetSP target_sp, llvm::StringRef plugin_name, lldb::ListenerSP listener_sp, const FileSpec *crash_file_path, bool can_connect)
Find a Process plug-in that can debug module using the currently selected architecture.
static constexpr llvm::StringRef LaunchSynchronousHijackListenerName
static ProcessProperties & GetGlobalProperties()
static void SettingsTerminate()
lldb::OptionValuePropertiesSP m_collection_sp
static llvm::StringRef GetExperimentalSettingsName()
bool SetPropertyAtIndex(uint32_t idx, T t, const ExecutionContext *exe_ctx=nullptr) const
virtual lldb::OptionValuePropertiesSP GetValueProperties() const
const lldb::OptionValueSP & GetValue() const
static lldb::REPLSP Create(Status &Status, lldb::LanguageType language, Debugger *debugger, Target *target, const char *repl_options)
Get a REPL with an existing target (or, failing that, a debugger to use), and (optional) extra argume...
bool SignExtend(uint32_t bit_pos)
unsigned long long ULongLong(unsigned long long fail_value=0) const
virtual bool ScriptedStopHookHandleStop(StructuredData::GenericSP implementor_sp, ExecutionContext &exc_ctx, lldb::StreamSP stream_sp)
virtual StructuredData::GenericSP CreateScriptedStopHook(lldb::TargetSP target_sp, const char *class_name, const StructuredDataImpl &args_data, Status &error)
"lldb/Core/SearchFilter.h" This is a SearchFilter that searches through all modules.
size_t GetNumSections(uint32_t depth) const
lldb::SectionSP GetSectionAtIndex(size_t idx) const
bool ResolveLoadAddress(uint32_t stop_id, lldb::addr_t load_addr, Address &so_addr)
bool SetSectionLoadAddress(uint32_t stop_id, const lldb::SectionSP §ion_sp, lldb::addr_t load_addr, bool warn_multiple=false)
lldb::addr_t GetSectionLoadAddress(uint32_t stop_id, const lldb::SectionSP §ion_sp)
bool SetSectionUnloaded(uint32_t stop_id, const lldb::SectionSP §ion_sp, lldb::addr_t load_addr)
uint32_t GetLastStopID() const
bool ResolveLoadAddress(lldb::addr_t load_addr, Address &so_addr, bool allow_section_end=false) const
"lldb/Core/SourceLocationSpec.h" A source location specifier class.
Class that provides a registry of known stack frame recognizers.
const SymbolContext & GetSymbolContext(lldb::SymbolContextItem resolve_scope)
Provide a SymbolContext for this StackFrame's current pc value.
void Clear()
Clear the object state.
int SetErrorStringWithFormat(const char *format,...) __attribute__((format(printf
Set the current error string to a formatted error string.
bool Fail() const
Test for error condition.
void SetErrorString(llvm::StringRef err_str)
Set the current error string to err_str.
bool Success() const
Test for success condition.
const char * GetData() const
llvm::StringRef GetString() const
A stream class that can stream formatted output to a file.
void Format(const char *format, Args &&... args)
llvm::raw_ostream & AsRawOstream()
Returns a raw_ostream that forwards the data to this Stream object.
size_t Indent(llvm::StringRef s="")
Indent the current line in the stream.
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
size_t PutCString(llvm::StringRef cstr)
Output a C string to the stream.
void SetIndentLevel(unsigned level)
Set the current indentation level.
void IndentLess(unsigned amount=2)
Decrement the current indentation level.
void IndentMore(unsigned amount=2)
Increment the current indentation level.
unsigned GetIndentLevel() const
Get the current indentation level.
void AddItem(const ObjectSP &item)
ObjectSP GetItemAtIndex(size_t idx) const
ObjectSP GetValueForKey(llvm::StringRef key) const
void ForEach(std::function< bool(llvm::StringRef key, Object *object)> const &callback) const
Dictionary * GetAsDictionary()
virtual bool IsValid() const
void Dump(lldb_private::Stream &s, bool pretty_print=true) const
std::shared_ptr< Object > ObjectSP
std::shared_ptr< Array > ArraySP
static ObjectSP ParseJSONFromFile(const FileSpec &file, Status &error)
Defines a symbol context baton that can be handed other debug core functions.
lldb::TargetSP target_sp
The Target for a given query.
TargetExperimentalProperties()
lldb::TargetSP GetTargetAtIndex(uint32_t index) const
size_t GetNumTargets() const
uint32_t GetMaximumSizeOfStringSummary() const
FileSpecList GetDebugFileSearchPaths()
bool GetDisplayRecognizedArguments() const
ImportStdModule GetImportStdModule() const
bool GetDisableSTDIO() const
bool GetMoveToNearestCode() const
~TargetProperties() override
void AppendExecutableSearchPaths(const FileSpec &)
void SetInheritTCC(bool b)
bool GetEnableSyntheticValue() const
void UpdateLaunchInfoFromProperties()
ProcessLaunchInfo m_launch_info
uint64_t GetExprAllocAlign() const
MemoryModuleLoadLevel GetMemoryModuleLoadLevel() const
llvm::StringRef GetArg0() const
uint32_t GetMaximumMemReadSize() const
void SetRunArguments(const Args &args)
FileSpec GetStandardErrorPath() const
bool GetEnableNotifyAboutFixIts() const
bool SetPreferDynamicValue(lldb::DynamicValueType d)
void SetDisplayRecognizedArguments(bool b)
std::optional< bool > GetExperimentalPropertyValue(size_t prop_idx, ExecutionContext *exe_ctx=nullptr) const
bool GetDisableASLR() const
bool GetUseFastStepping() const
const ProcessLaunchInfo & GetProcessLaunchInfo() const
Environment ComputeEnvironment() const
void Arg0ValueChangedCallback()
bool GetUserSpecifiedTrapHandlerNames(Args &args) const
uint64_t GetExprErrorLimit() const
bool GetEnableAutoImportClangModules() const
bool GetDebugUtilityExpression() const
void CheckJITObjectsDir()
bool GetSkipPrologue() const
DynamicClassInfoHelper GetDynamicClassInfoHelper() const
FileSpec GetStandardOutputPath() const
void InputPathValueChangedCallback()
void SetDisplayRuntimeSupportValues(bool b)
uint32_t GetMaximumNumberOfChildrenToDisplay() const
void SetRequireHardwareBreakpoints(bool b)
void SetDisableSTDIO(bool b)
bool GetAutoInstallMainExecutable() const
uint64_t GetNumberOfRetriesWithFixits() const
uint64_t GetExprAllocSize() const
llvm::StringRef GetExpressionPrefixContents()
const char * GetDisassemblyFlavor() const
void SetPreloadSymbols(bool b)
FileSpec GetStandardInputPath() const
bool GetInheritTCC() const
void InheritTCCValueChangedCallback()
lldb::DynamicValueType GetPreferDynamicValue() const
void DisableSTDIOValueChangedCallback()
InlineStrategy GetInlineStrategy() const
Environment GetTargetEnvironment() const
bool GetDisplayRuntimeSupportValues() const
void SetDetachOnError(bool b)
void SetUserSpecifiedTrapHandlerNames(const Args &args)
bool GetUseHexImmediates() const
bool GetPreloadSymbols() const
uint32_t GetMaxZeroPaddingInFloatFormat() const
uint64_t GetExprAllocAddress() const
void DetachOnErrorValueChangedCallback()
LoadCWDlldbinitFile GetLoadCWDlldbinitFile() const
Environment GetInheritedEnvironment() const
void SetArg0(llvm::StringRef arg)
void EnvVarsValueChangedCallback()
bool GetInjectLocalVariables(ExecutionContext *exe_ctx) const
bool ShowHexVariableValuesWithLeadingZeroes() const
void OutputPathValueChangedCallback()
Environment GetEnvironment() const
void SetProcessLaunchInfo(const ProcessLaunchInfo &launch_info)
void RunArgsValueChangedCallback()
FileSpec GetSaveJITObjectsDir() const
void SetEnvironment(Environment env)
LoadScriptFromSymFile GetLoadScriptFromSymbolFile() const
void SetStandardErrorPath(llvm::StringRef path)
bool GetRunArguments(Args &args) const
bool GetBreakpointsConsultPlatformAvoidList()
FileSpecList GetExecutableSearchPaths()
void SetDisableASLR(bool b)
ArchSpec GetDefaultArchitecture() const
Disassembler::HexImmediateStyle GetHexImmediateStyle() const
std::unique_ptr< TargetExperimentalProperties > m_experimental_properties_up
FileSpecList GetClangModuleSearchPaths()
void SetStandardOutputPath(llvm::StringRef path)
void ErrorPathValueChangedCallback()
bool GetRequireHardwareBreakpoints() const
PathMappingList & GetSourcePathMap() const
bool GetAutoSourceMapRelative() const
void SetDefaultArchitecture(const ArchSpec &arch)
void SetStandardInputPath(llvm::StringRef path)
lldb::LanguageType GetLanguage() const
TargetProperties(Target *target)
bool GetDisplayExpressionsInCrashlogs() const
void DisableASLRValueChangedCallback()
bool GetEnableAutoApplyFixIts() const
void SetDebugUtilityExpression(bool debug)
std::pair< uint32_t, bool > GetMaximumDepthOfChildrenToDisplay() const
Get the max depth value, augmented with a bool to indicate whether the depth is the default.
bool GetDetachOnError() const
llvm::json::Value ToJSON(Target &target, const lldb_private::StatisticsOptions &options)
StatsDuration & GetCreateTime()
StatsSuccessFail & GetExpressionStats()
void SetLaunchOrAttachTime()
const ArchSpec & GetSpec() const
const Arch & operator=(const ArchSpec &spec)
Arch(const ArchSpec &spec)
void SetActionFromString(const std::string &strings)
void SetActionFromStrings(const std::vector< std::string > &strings)
StopHookResult HandleStop(ExecutionContext &exc_ctx, lldb::StreamSP output_sp) override
void GetSubclassDescription(Stream &s, lldb::DescriptionLevel level) const override
Status SetScriptCallback(std::string class_name, StructuredData::ObjectSP extra_args_sp)
StopHookResult HandleStop(ExecutionContext &exc_ctx, lldb::StreamSP output) override
void GetSubclassDescription(Stream &s, lldb::DescriptionLevel level) const override
void SetSpecifier(SymbolContextSpecifier *specifier)
std::unique_ptr< ThreadSpec > m_thread_spec_up
void SetThreadSpecifier(ThreadSpec *specifier)
StopHook(const StopHook &rhs)
bool ExecutionContextPasses(const ExecutionContext &exe_ctx)
void GetDescription(Stream &s, lldb::DescriptionLevel level) const
void Dump(Stream *s) const override
static llvm::StringRef GetFlavorString()
static ModuleList GetModuleListFromEvent(const Event *event_ptr)
~TargetEventData() override
static const TargetEventData * GetEventDataFromEvent(const Event *event_ptr)
TargetEventData(const lldb::TargetSP &target_sp)
lldb::TargetSP m_target_sp
static lldb::TargetSP GetTargetFromEvent(const Event *event_ptr)
void ModulesDidLoad(ModuleList &module_list)
lldb::ThreadSP CalculateThread() override
StopHookCollection m_stop_hooks
Module * GetExecutableModulePointer()
void Dump(Stream *s, lldb::DescriptionLevel description_level)
Dump a description of this object to a Stream.
bool m_suppress_stop_hooks
void DisableAllBreakpoints(bool internal_also=false)
lldb::WatchpointSP CreateWatchpoint(lldb::addr_t addr, size_t size, const CompilerType *type, uint32_t kind, Status &error)
void ApplyNameToBreakpoints(BreakpointName &bp_name)
StopHookSP CreateStopHook(StopHook::StopHookKind kind)
Add an empty stop hook to the Target's stop hook list, and returns a shared pointer to it in new_hook...
lldb::TraceSP GetTrace()
Get the Trace object containing processor trace information of this target.
PathMappingList & GetImageSearchPathList()
void FinalizeFileActions(ProcessLaunchInfo &info)
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.
lldb::addr_t GetOpcodeLoadAddress(lldb::addr_t load_addr, AddressClass addr_class=AddressClass::eInvalid) const
Get load_addr as an opcode for this target.
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)
static Target * GetTargetFromContexts(const ExecutionContext *exe_ctx_ptr, const SymbolContext *sc_ptr)
lldb::addr_t GetBreakableLoadAddress(lldb::addr_t addr)
void ClearDummySignals(Args &signal_names)
Clear the dummy signals in signal_names from the target, or all signals if signal_names is empty.
static void ImageSearchPathsChanged(const PathMappingList &path_list, void *baton)
llvm::Expected< lldb_private::Address > GetEntryPointAddress()
This method will return the address of the starting function for this binary, e.g.
bool IgnoreWatchpointByID(lldb::watch_id_t watch_id, uint32_t ignore_count)
lldb::BreakpointSP CreateFuncRegexBreakpoint(const FileSpecList *containingModules, const FileSpecList *containingSourceFiles, RegularExpression func_regexp, lldb::LanguageType requested_language, LazyBool skip_prologue, bool internal, bool request_hardware)
lldb::BreakpointSP GetBreakpointByID(lldb::break_id_t break_id)
std::shared_ptr< StopHook > StopHookSP
void SymbolsDidLoad(ModuleList &module_list)
bool ClearAllWatchpointHistoricValues()
void SetTrace(const lldb::TraceSP &trace_sp)
Set the Trace object containing processor trace information of this target.
BreakpointList & GetBreakpointList(bool internal=false)
CompilerType GetRegisterType(const std::string &name, const lldb_private::RegisterFlags &flags, uint32_t byte_size)
BreakpointNameList m_breakpoint_names
llvm::StringRef GetABIName() const
Returns the name of the target's ABI plugin.
SourceManager & GetSourceManager()
lldb::SearchFilterSP GetSearchFilterForModuleList(const FileSpecList *containingModuleList)
StopHookSP GetStopHookByID(lldb::user_id_t uid)
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...
lldb::ProcessSP m_process_sp
lldb::SearchFilterSP m_search_filter_sp
PersistentExpressionState * GetPersistentExpressionStateForLanguage(lldb::LanguageType language)
UserExpression * GetUserExpressionForLanguage(llvm::StringRef expr, llvm::StringRef prefix, lldb::LanguageType language, Expression::ResultType desired_type, const EvaluateExpressionOptions &options, ValueObject *ctx_obj, Status &error)
static ConstString & GetStaticBroadcasterClass()
void UpdateSignalsFromDummy(lldb::UnixSignalsSP signals_sp, lldb::StreamSP warning_stream_sp)
Updates the signals in signals_sp using the stored dummy signals.
bool m_is_dummy_target
Used to not run stop hooks for expressions.
static bool UpdateSignalFromDummy(lldb::UnixSignalsSP signals_sp, const DummySignalElement &element)
PathMappingList m_image_search_paths
bool ModuleIsExcludedForUnconstrainedSearches(const FileSpec &module_spec)
Return whether this FileSpec corresponds to a module that should be considered for general searches.
lldb::StackFrameSP CalculateStackFrame() override
SectionLoadList & GetSectionLoadList()
lldb::addr_t GetPersistentSymbol(ConstString name)
void PrimeFromDummyTarget(Target &target)
static void SettingsTerminate()
bool EnableWatchpointByID(lldb::watch_id_t watch_id)
bool ResolveFileAddress(lldb::addr_t load_addr, Address &so_addr)
bool ClearAllWatchpointHitCounts()
size_t ReadMemoryFromFileCache(const Address &addr, void *dst, size_t dst_len, Status &error)
void ClearAllLoadedSections()
std::vector< lldb::TypeSystemSP > GetScratchTypeSystems(bool create_on_demand=true)
size_t ReadScalarIntegerFromMemory(const Address &addr, uint32_t byte_size, bool is_signed, Scalar &scalar, Status &error, bool force_live_memory=false)
void AddNameToBreakpoint(BreakpointID &id, llvm::StringRef name, Status &error)
void DeleteCurrentProcess()
BreakpointList m_internal_breakpoint_list
void DisableAllowedBreakpoints()
bool SetSectionUnloaded(const lldb::SectionSP §ion_sp)
lldb::TargetSP CalculateTarget() override
const lldb::ProcessSP & GetProcessSP() const
void ClearModules(bool delete_locations)
bool RemoveBreakpointByID(lldb::break_id_t break_id)
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...
static bool ResetSignalFromDummy(lldb::UnixSignalsSP signals_sp, const DummySignalElement &element)
Architecture * GetArchitecturePlugin() const
llvm::json::Value ReportStatistics(const lldb_private::StatisticsOptions &options)
Get metrics associated with this target in JSON format.
FunctionCaller * GetFunctionCallerForLanguage(lldb::LanguageType language, const CompilerType &return_type, const Address &function_address, const ValueList &arg_value_list, const char *name, Status &error)
void EnableAllBreakpoints(bool internal_also=false)
Status Launch(ProcessLaunchInfo &launch_info, Stream *stream)
bool DisableBreakpointByID(lldb::break_id_t break_id)
lldb::BreakpointSP CreateBreakpointAtUserEntry(Status &error)
BreakpointName * FindBreakpointName(ConstString name, bool can_create, Status &error)
llvm::Expected< lldb::TraceSP > CreateTrace()
Create a Trace object for the current target using the using the default supported tracing technology...
lldb::TraceSP m_trace_sp
An optional lldb_private::Trace object containing processor trace information of this target.
bool RemoveAllWatchpoints(bool end_to_end=true)
bool ReadPointerFromMemory(const Address &addr, Status &error, Address &pointer_addr, bool force_live_memory=false)
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,...
WatchpointList m_watchpoint_list
@ eBroadcastBitModulesLoaded
@ eBroadcastBitSymbolsLoaded
@ eBroadcastBitModulesUnloaded
@ eBroadcastBitWatchpointChanged
@ eBroadcastBitBreakpointChanged
BreakpointList m_breakpoint_list
lldb::SourceManagerUP m_source_manager_up
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 RemoveWatchpointByID(lldb::watch_id_t watch_id)
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.
void DeleteBreakpointName(ConstString name)
void NotifyWillClearList(const ModuleList &module_list) override
bool SetArchitecture(const ArchSpec &arch_spec, bool set_platform=false, bool merge=true)
Set the architecture for this target.
void NotifyModuleAdded(const ModuleList &module_list, const lldb::ModuleSP &module_sp) override
Implementing of ModuleList::Notifier.
llvm::Expected< lldb::TypeSystemSP > GetScratchTypeSystemForLanguage(lldb::LanguageType language, bool create_on_demand=true)
void ConfigureBreakpointName(BreakpointName &bp_name, const BreakpointOptions &options, const BreakpointName::Permissions &permissions)
lldb::SearchFilterSP GetSearchFilterForModuleAndCUList(const FileSpecList *containingModules, const FileSpecList *containingSourceFiles)
lldb::ModuleSP GetExecutableModule()
Gets the module for the main executable.
bool SetStopHookActiveStateByID(lldb::user_id_t uid, bool active_state)
const lldb::ProcessSP & CreateProcess(lldb::ListenerSP listener_sp, llvm::StringRef plugin_name, const FileSpec *crash_file, bool can_connect)
void SetAllStopHooksActiveState(bool active_state)
lldb::ExpressionVariableSP GetPersistentVariable(ConstString name)
void NotifyModulesRemoved(lldb_private::ModuleList &module_list) override
size_t ReadCStringFromMemory(const Address &addr, std::string &out_str, Status &error, bool force_live_memory=false)
std::recursive_mutex m_mutex
An API mutex that is used by the lldb::SB* classes make the SB interface thread safe.
void ModulesDidUnload(ModuleList &module_list, bool delete_locations)
void CalculateExecutionContext(ExecutionContext &exe_ctx) override
Reconstruct the object's execution context into sc.
llvm::Expected< lldb::TraceSP > GetTraceOrCreate()
If a Trace object is present, this returns it, otherwise a new Trace is created with Trace::CreateTra...
void NotifyModuleUpdated(const ModuleList &module_list, const lldb::ModuleSP &old_module_sp, const lldb::ModuleSP &new_module_sp) override
Status SerializeBreakpointsToFile(const FileSpec &file, const BreakpointIDList &bp_ids, bool append)
void DidExec()
Called as the last function in Process::DidExec().
void SaveScriptedLaunchInfo(lldb_private::ProcessInfo &process_info)
lldb::user_id_t m_stop_hook_next_id
void RemoveAllStopHooks()
static FileSpecList GetDefaultExecutableSearchPaths()
lldb::BreakpointSP CreateExceptionBreakpoint(enum lldb::LanguageType language, bool catch_bp, bool throw_bp, bool internal, Args *additional_args=nullptr, Status *additional_args_error=nullptr)
lldb::SearchFilterSP GetSearchFilterForModule(const FileSpec *containingModule)
llvm::StringMapEntry< DummySignalValues > DummySignalElement
std::recursive_mutex & GetAPIMutex()
static FileSpecList GetDefaultDebugFileSearchPaths()
void EnableAllowedBreakpoints()
llvm::Error SetLabel(llvm::StringRef label)
Set a label for a target.
uint32_t m_latest_stop_hook_id
void RemoveAllowedBreakpoints()
bool DisableAllWatchpoints(bool end_to_end=true)
lldb::addr_t GetReasonableReadSize(const Address &addr)
Return a recommended size for memory reads at addr, optimizing for cache usage.
lldb::PlatformSP m_platform_sp
The platform for this target.
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.
static TargetProperties & GetGlobalProperties()
Status Install(ProcessLaunchInfo *launch_info)
lldb::PlatformSP GetPlatform()
void NotifyModuleRemoved(const ModuleList &module_list, const lldb::ModuleSP &module_sp) override
lldb::BreakpointSP CreateAddressInModuleBreakpoint(lldb::addr_t file_addr, bool internal, const FileSpec &file_spec, bool request_hardware)
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)
bool ResolveLoadAddress(lldb::addr_t load_addr, Address &so_addr, uint32_t stop_id=SectionLoadHistory::eStopIDNow)
void RemoveAllBreakpoints(bool internal_also=false)
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)
static ArchSpec GetDefaultArchitecture()
void ResetBreakpointHitCounts()
Resets the hit count of all breakpoints.
const ModuleList & GetImages() const
Get accessor for the images for this process.
const ArchSpec & GetArchitecture() const
WatchpointList & GetWatchpointList()
bool EnableBreakpointByID(lldb::break_id_t break_id)
uint64_t ReadUnsignedIntegerFromMemory(const Address &addr, size_t integer_byte_size, uint64_t fail_value, Status &error, bool force_live_memory=false)
bool IgnoreAllWatchpoints(uint32_t ignore_count)
void AddBreakpoint(lldb::BreakpointSP breakpoint_sp, bool internal)
TypeSystemMap m_scratch_type_system_map
void AddBreakpointName(std::unique_ptr< BreakpointName > bp_name)
SectionLoadHistory m_section_load_history
void GetBreakpointNames(std::vector< std::string > &names)
Target(Debugger &debugger, const ArchSpec &target_arch, const lldb::PlatformSP &platform_sp, bool is_dummy_target)
Construct with optional file and arch.
size_t UnloadModuleSections(const lldb::ModuleSP &module_sp)
bool m_valid
This records the last natural stop at which we ran a stop-hook.
bool DisableWatchpointByID(lldb::watch_id_t watch_id)
void AddDummySignal(llvm::StringRef name, LazyBool pass, LazyBool print, LazyBool stop)
Add a signal to the Target's list of stored signals/actions.
lldb::WatchpointSP m_last_created_watchpoint
Status CreateBreakpointsFromFile(const FileSpec &file, BreakpointIDList &new_bps)
void SetREPL(lldb::LanguageType language, lldb::REPLSP repl_sp)
void SetExecutableModule(lldb::ModuleSP &module_sp, LoadDependentFiles load_dependent_files=eLoadDependentsDefault)
Set the main executable module.
lldb::StackFrameRecognizerManagerUP m_frame_recognizer_manager_up
Stores the frame recognizers of this target.
lldb::REPLSP GetREPL(Status &err, lldb::LanguageType language, const char *repl_options, bool can_create)
ModuleList m_images
The list of images for this process (shared libraries and anything dynamically loaded).
lldb::ProcessSP CalculateProcess() override
void PrintDummySignals(Stream &strm, Args &signals)
Print all the signals set in this target.
void SetPlatform(const lldb::PlatformSP &platform_sp)
bool SetSectionLoadAddress(const lldb::SectionSP §ion, lldb::addr_t load_addr, bool warn_multiple=false)
Status Attach(ProcessAttachInfo &attach_info, Stream *stream)
static void SetDefaultArchitecture(const ArchSpec &arch)
lldb::BreakpointSP m_last_created_breakpoint
void RemoveNameFromBreakpoint(lldb::BreakpointSP &bp_sp, ConstString name)
bool RemoveStopHookByID(lldb::user_id_t uid)
static void SettingsInitialize()
bool EnableAllWatchpoints(bool end_to_end=true)
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...
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)
bool MergeArchitecture(const ArchSpec &arch_spec)
uint32_t GetSize(bool can_update=true)
lldb::ThreadSP GetThreadAtIndex(uint32_t idx, bool can_update=true)
static llvm::Expected< lldb::TraceSP > FindPluginForLiveProcess(llvm::StringRef plugin_name, Process &process)
Find a trace plug-in to trace a live process.
llvm::Expected< lldb::TypeSystemSP > GetTypeSystemForLanguage(lldb::LanguageType language, Module *module, bool can_create)
void ForEach(std::function< bool(lldb::TypeSystemSP)> const &callback)
void Dump(Stream &s) const
Encapsulates a one-time expression for use in lldb.
static lldb::ExpressionResults Evaluate(ExecutionContext &exe_ctx, const EvaluateExpressionOptions &options, llvm::StringRef expr_cstr, llvm::StringRef expr_prefix, lldb::ValueObjectSP &result_valobj_sp, Status &error, std::string *fixed_expression=nullptr, ValueObject *ctx_obj=nullptr)
Evaluate one expression in the scratch context of the target passed in the exe_ctx and return its res...
static lldb::ValueObjectSP Create(ExecutionContextScope *exe_scope, lldb::ByteOrder byte_order, uint32_t addr_byte_size, lldb::addr_t address=LLDB_INVALID_ADDRESS)
lldb::watch_id_t Add(const lldb::WatchpointSP &wp_sp, bool notify)
Add a Watchpoint to the list.
void SetEnabledAll(bool enabled)
lldb::WatchpointSP FindByID(lldb::watch_id_t watchID) const
Returns a shared pointer to the watchpoint with id watchID, const version.
void GetListMutex(std::unique_lock< std::recursive_mutex > &lock)
Sets the passed in Locker to hold the Watchpoint List mutex.
WatchpointIterable Watchpoints() const
void RemoveAll(bool notify)
bool Remove(lldb::watch_id_t watchID, bool notify)
Removes the watchpoint given by watchID from this list.
const lldb::WatchpointSP FindByAddress(lldb::addr_t addr) const
Returns a shared pointer to the watchpoint at address addr - const version.
#define LLDB_WATCH_TYPE_WRITE
#define LLDB_INVALID_BREAK_ID
#define LLDB_INVALID_SIGNAL_NUMBER
#define LLDB_INVALID_INDEX32
#define LLDB_WATCH_TYPE_IS_VALID(type)
#define LLDB_BREAK_ID_IS_INTERNAL(bid)
#define LLDB_WATCH_TYPE_MODIFY
#define LLDB_WATCH_TYPE_READ
#define LLDB_INVALID_ADDRESS
@ SelectMostRelevantFrame
A class that represents a running process on the host machine.
@ eMemoryModuleLoadLevelPartial
@ eMemoryModuleLoadLevelComplete
@ eMemoryModuleLoadLevelMinimal
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
@ eLoadScriptFromSymFileTrue
@ eLoadScriptFromSymFileFalse
@ eLoadScriptFromSymFileWarn
@ eDynamicClassInfoHelperCopyRealizedClassList
@ eDynamicClassInfoHelperGetRealizedClassList
@ eDynamicClassInfoHelperAuto
@ eDynamicClassInfoHelperRealizedClassesStruct
OptionEnumValues GetDynamicValueTypes()
@ eImportStdModuleFallback
const char * StateAsCString(lldb::StateType state)
Converts a StateType to a C string.
llvm::ArrayRef< OptionEnumValueElement > OptionEnumValues
@ eInlineBreakpointsNever
@ eInlineBreakpointsAlways
@ eInlineBreakpointsHeaders
std::shared_ptr< lldb_private::OptionValueProperties > OptionValuePropertiesSP
std::shared_ptr< lldb_private::Trace > TraceSP
std::shared_ptr< lldb_private::TypeSystem > TypeSystemSP
std::shared_ptr< lldb_private::ABI > ABISP
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.
@ eDescriptionLevelVerbose
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
StateType
Process and Thread States.
@ eStateConnected
Process is connected to remote debug services, but not launched or attached to anything yet.
@ eStateStopped
Process or thread is stopped and can be examined.
@ eStateAttaching
Process is currently trying to attach.
@ eStateExited
Process has exited and can't be examined.
std::shared_ptr< lldb_private::RegisterTypeBuilder > RegisterTypeBuilderSP
LanguageType
Programming language type.
@ eLanguageTypeMipsAssembler
Mips_Assembler.
@ eLanguageTypeUnknown
Unknown or invalid language value.
@ eLanguageTypeC
Non-standardized C, such as K&R.
std::shared_ptr< lldb_private::Stream > StreamSP
std::shared_ptr< lldb_private::Breakpoint > BreakpointSP
ExpressionResults
The results of expression evaluation.
std::shared_ptr< lldb_private::Process > ProcessSP
std::shared_ptr< lldb_private::BreakpointPrecondition > BreakpointPreconditionSP
std::shared_ptr< lldb_private::Event > EventSP
ReturnStatus
Command Return Status Types.
@ eReturnStatusSuccessContinuingResult
@ eReturnStatusSuccessContinuingNoResult
std::shared_ptr< lldb_private::Watchpoint > WatchpointSP
std::shared_ptr< lldb_private::Listener > ListenerSP
std::shared_ptr< lldb_private::DataBuffer > DataBufferSP
std::shared_ptr< lldb_private::Section > SectionSP
std::shared_ptr< lldb_private::Target > TargetSP
std::shared_ptr< lldb_private::Module > ModuleSP
std::shared_ptr< lldb_private::REPL > REPLSP
A SmallBitVector that represents a set of source languages (lldb::LanguageType).
llvm::SmallBitVector bitvector
std::optional< lldb::LanguageType > GetSingularLanguage()
If the set contains a single language only, return it.
const char * string_value
A mix in class that contains a generic user ID.
lldb::user_id_t GetID() const
Get accessor for the user ID.