67#include "llvm/ADT/ScopeExit.h"
68#include "llvm/ADT/SetVector.h"
82 m_plugin_up(
PluginManager::CreateArchitectureInstance(spec)) {}
91 static constexpr llvm::StringLiteral class_name(
"lldb.target");
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::createStringError(
"Invalid Target");
2429 if (languages_for_expressions.
Empty())
2430 return llvm::createStringError(
2431 "No expression support for any languages");
2442 uint32_t byte_size) {
2445 return provider->GetRegisterType(name, flags, byte_size);
2448std::vector<lldb::TypeSystemSP>
2456 std::vector<lldb::TypeSystemSP> scratch_type_systems;
2461 for (
auto bit : languages_for_expressions.
bitvector.set_bits()) {
2463 auto type_system_or_err =
2465 if (!type_system_or_err)
2468 "Language '{1}' has expression support but no scratch type "
2469 "system available: {0}",
2472 if (
auto ts = *type_system_or_err)
2473 scratch_type_systems.push_back(ts);
2476 std::sort(scratch_type_systems.begin(), scratch_type_systems.end());
2477 scratch_type_systems.erase(
2478 std::unique(scratch_type_systems.begin(), scratch_type_systems.end()),
2479 scratch_type_systems.end());
2480 return scratch_type_systems;
2487 if (
auto err = type_system_or_err.takeError()) {
2490 "Unable to get persistent expression state for language {1}: {0}",
2495 if (
auto ts = *type_system_or_err)
2496 return ts->GetPersistentExpressionState();
2499 "Unable to get persistent expression state for language {1}: {0}",
2505 llvm::StringRef expr, llvm::StringRef prefix,
SourceLanguage language,
2509 auto type_system_or_err =
2511 if (
auto err = type_system_or_err.takeError()) {
2512 error.SetErrorStringWithFormat(
2513 "Could not find type system for language %s: %s",
2515 llvm::toString(std::move(err)).c_str());
2519 auto ts = *type_system_or_err;
2521 error.SetErrorStringWithFormat(
2522 "Type system for language %s is no longer live",
2527 auto *user_expr = ts->GetUserExpression(expr, prefix, language, desired_type,
2530 error.SetErrorStringWithFormat(
2531 "Could not create an expression for language %s",
2542 if (
auto err = type_system_or_err.takeError()) {
2543 error.SetErrorStringWithFormat(
2544 "Could not find type system for language %s: %s",
2546 llvm::toString(std::move(err)).c_str());
2549 auto ts = *type_system_or_err;
2551 error.SetErrorStringWithFormat(
2552 "Type system for language %s is no longer live",
2556 auto *persistent_fn = ts->GetFunctionCaller(return_type, function_address,
2557 arg_value_list, name);
2559 error.SetErrorStringWithFormat(
2560 "Could not create an expression for language %s",
2563 return persistent_fn;
2566llvm::Expected<std::unique_ptr<UtilityFunction>>
2571 if (!type_system_or_err)
2572 return type_system_or_err.takeError();
2573 auto ts = *type_system_or_err;
2575 return llvm::createStringError(
2576 llvm::StringRef(
"Type system for language ") +
2578 llvm::StringRef(
" is no longer live"));
2579 std::unique_ptr<UtilityFunction> utility_fn =
2580 ts->CreateUtilityFunction(std::move(expression), std::move(name));
2582 return llvm::createStringError(
2583 llvm::StringRef(
"Could not create an expression for language") +
2587 if (!utility_fn->Install(diagnostics, exe_ctx))
2588 return llvm::createStringError(diagnostics.
GetString());
2590 return std::move(utility_fn);
2611 "setting target's default architecture to {0} ({1})",
2618 if (llvm::to_integer(label, n))
2619 return llvm::createStringError(
"Cannot use integer as target label.");
2623 if (target_sp && target_sp->GetLabel() == label) {
2624 return llvm::make_error<llvm::StringError>(
2626 "Cannot use label '{0}' since it's set in target #{1}.", label,
2628 llvm::inconvertibleErrorCode());
2633 return llvm::Error::success();
2642 Target *target =
nullptr;
2643 if (sc_ptr !=
nullptr)
2645 if (target ==
nullptr && exe_ctx_ptr)
2655 result_valobj_sp.reset();
2661 return execution_results;
2667 auto on_exit = llvm::make_scope_exit([
this, old_suppress_value]() {
2685 if (expr[0] ==
'$') {
2686 auto type_system_or_err =
2688 if (
auto err = type_system_or_err.takeError()) {
2690 "Unable to get scratch type system");
2692 auto ts = *type_system_or_err;
2695 "Scratch type system is no longer live: {0}");
2698 ts->GetPersistentExpressionState()->GetVariable(expr);
2701 if (persistent_var_sp) {
2702 result_valobj_sp = persistent_var_sp->GetValueObject();
2708 result_valobj_sp,
error,
2709 fixed_expression, ctx_obj);
2711 if (
error.Fail() && !result_valobj_sp)
2713 exe_ctx.GetBestExecutionContextScope(),
error);
2720 return execution_results;
2726 [name, &variable_sp](
TypeSystemSP type_system) ->
bool {
2727 auto ts = type_system.get();
2731 ts->GetPersistentExpressionState()) {
2732 variable_sp = persistent_state->GetVariable(name);
2747 auto ts = type_system.get();
2752 ts->GetPersistentExpressionState()) {
2753 address = persistent_state->LookupSymbol(name);
2754 if (address != LLDB_INVALID_ADDRESS)
2766 const bool has_primary_executable = exe_module && exe_module->
GetObjectFile();
2767 if (has_primary_executable) {
2774 const size_t num_images = modules.
GetSize();
2775 for (
size_t idx = 0; idx < num_images; ++idx) {
2777 if (!module_sp || !module_sp->GetObjectFile())
2780 Address entry_addr = module_sp->GetObjectFile()->GetEntryPointAddress();
2786 if (!has_primary_executable)
2787 return llvm::createStringError(
2788 "No primary executable found and could not find entry point address in "
2789 "any executable module");
2791 return llvm::createStringError(
2792 "Could not find entry point address for primary executable module \"" +
2800 ? arch_plugin->GetCallableLoadAddress(load_addr, addr_class)
2807 return arch_plugin ? arch_plugin->GetOpcodeLoadAddress(load_addr, addr_class)
2813 return arch_plugin ? arch_plugin->GetBreakableLoadAddress(addr, *
this) : addr;
2834 return stop_hook_sp;
2846 return (num_removed != 0);
2854 StopHookCollection::iterator specified_hook_iter;
2857 found_hook = (*specified_hook_iter).second;
2862 bool active_state) {
2863 StopHookCollection::iterator specified_hook_iter;
2868 (*specified_hook_iter).second->SetIsActive(active_state);
2873 StopHookCollection::iterator pos, end =
m_stop_hooks.end();
2875 (*pos).second->SetIsActive(active_state);
2895 bool any_active_hooks =
false;
2897 if (hook.second->IsActive()) {
2898 any_active_hooks =
true;
2902 if (!any_active_hooks)
2911 uint32_t last_natural_stop =
m_process_sp->GetModIDRef().GetLastNaturalStopID();
2917 std::vector<ExecutionContext> exc_ctx_with_reasons;
2920 size_t num_threads = cur_threadlist.
GetSize();
2921 for (
size_t i = 0; i < num_threads; i++) {
2923 if (cur_thread_sp->ThreadStoppedForAReason()) {
2925 exc_ctx_with_reasons.emplace_back(
m_process_sp.get(), cur_thread_sp.get(),
2926 cur_frame_sp.get());
2931 size_t num_exe_ctx = exc_ctx_with_reasons.size();
2932 if (num_exe_ctx == 0)
2937 bool auto_continue =
false;
2938 bool hooks_ran =
false;
2940 bool print_thread_header = (num_exe_ctx != 1);
2941 bool should_stop =
false;
2942 bool somebody_restarted =
false;
2946 if (!cur_hook_sp->IsActive())
2949 bool any_thread_matched =
false;
2950 for (
auto exc_ctx : exc_ctx_with_reasons) {
2953 if (somebody_restarted)
2956 if (!cur_hook_sp->ExecutionContextPasses(exc_ctx))
2961 auto_continue |= cur_hook_sp->GetAutoContinue();
2966 if (print_hook_header && !any_thread_matched) {
2970 output_sp->
Printf(
"\n- Hook %" PRIu64
" (%s)\n", cur_hook_sp->GetID(),
2973 output_sp->Printf(
"\n- Hook %" PRIu64
"\n", cur_hook_sp->GetID());
2974 any_thread_matched =
true;
2977 if (print_thread_header)
2978 output_sp->Printf(
"-- Thread %d\n",
2979 exc_ctx.GetThreadPtr()->GetIndexID());
2982 cur_hook_sp->HandleStop(exc_ctx, output_sp);
2983 bool this_should_stop =
true;
2985 switch (this_result) {
2989 if (cur_hook_sp->GetAutoContinue())
2990 this_should_stop =
false;
2992 this_should_stop =
true;
2996 this_should_stop =
false;
3002 output_sp->Printf(
"\nAborting stop hooks, hook %" PRIu64
3003 " set the program running.\n"
3004 " Consider using '-G true' to make "
3005 "stop hooks auto-continue.\n",
3006 cur_hook_sp->GetID());
3007 somebody_restarted =
true;
3014 if (somebody_restarted)
3019 should_stop = this_should_stop;
3027 if (somebody_restarted)
3033 if ((hooks_ran && !should_stop) || auto_continue) {
3036 if (
error.Success()) {
3037 LLDB_LOG(log,
"Resuming from RunStopHooks");
3040 LLDB_LOG(log,
"Resuming from RunStopHooks failed: {0}",
error);
3053 return *g_settings_ptr;
3060 if (platform_sp->IsRemote()) {
3061 if (platform_sp->IsConnected()) {
3067 const size_t num_images = modules.
GetSize();
3068 for (
size_t idx = 0; idx < num_images; ++idx) {
3072 FileSpec local_file(module_sp->GetFileSpec());
3074 FileSpec remote_file(module_sp->GetRemoteInstallFileSpec());
3078 remote_file = platform_sp->GetRemoteWorkingDirectory();
3080 module_sp->GetFileSpec().GetFilename().GetCString());
3084 error = platform_sp->Install(local_file, remote_file);
3085 if (
error.Success()) {
3086 module_sp->SetPlatformFileSpec(remote_file);
3087 if (is_main_executable) {
3088 platform_sp->SetFilePermissions(remote_file, 0700);
3115 addr_t new_section_load_addr,
3116 bool warn_multiple) {
3117 const addr_t old_section_load_addr =
3120 if (old_section_load_addr != new_section_load_addr) {
3121 uint32_t stop_id = 0;
3124 stop_id = process_sp->GetStopID();
3128 stop_id, section_sp, new_section_load_addr, warn_multiple))
3135 size_t section_unload_count = 0;
3136 size_t num_modules = module_list.
GetSize();
3137 for (
size_t i = 0; i < num_modules; ++i) {
3138 section_unload_count +=
3141 return section_unload_count;
3145 uint32_t stop_id = 0;
3148 stop_id = process_sp->GetStopID();
3151 SectionList *sections = module_sp->GetSectionList();
3152 size_t section_unload_count = 0;
3155 for (uint32_t i = 0; i < num_sections; ++i) {
3160 return section_unload_count;
3164 uint32_t stop_id = 0;
3167 stop_id = process_sp->GetStopID();
3175 uint32_t stop_id = 0;
3178 stop_id = process_sp->GetStopID();
3203 LLDB_LOGF(log,
"Target::%s() called for %s", __FUNCTION__,
3215 state = process_sp->GetState();
3217 "Target::%s the process exists, and its current state is %s",
3220 LLDB_LOGF(log,
"Target::%s the process instance doesn't currently exist.",
3233 const bool synchronous_execution =
3241 if (launch_info.
GetFlags().
Test(eLaunchFlagLaunchInTTY)) {
3242 error.SetErrorString(
3243 "can't launch in tty when launching through a remote connection");
3263 LLDB_LOGF(log,
"Target::%s asking the platform to debug the process",
3277 "Target::%s the platform doesn't know how to debug a "
3278 "process, getting a process plugin to do this for us.",
3298 error.SetErrorString(
"failed to launch or debug process");
3300 if (!
error.Success())
3303 bool rebroadcast_first_stop =
3304 !synchronous_execution &&
3310 state =
m_process_sp->WaitForProcessToStop(std::nullopt, &first_stop_event_sp,
3311 rebroadcast_first_stop,
3315 if (rebroadcast_first_stop) {
3316 assert(first_stop_event_sp);
3323 if (launch_info.
GetFlags().
Test(eLaunchFlagStopAtEntry))
3325 if (synchronous_execution)
3332 if (!
error.Success()) {
3335 "process resume at entry point failed: %s",
error.AsCString());
3340 bool with_shell = !!launch_info.
GetShell();
3342 const char *exit_desc =
m_process_sp->GetExitDescription();
3344 if (exit_desc && exit_desc[0])
3345 desc =
" (" + std::string(exit_desc) +
')';
3347 error.SetErrorStringWithFormat(
3348 "process exited with status %i%s\n"
3349 "'r' and 'run' are aliases that default to launching through a "
3351 "Try launching without going through a shell by using "
3352 "'process launch'.",
3353 exit_status, desc.c_str());
3355 error.SetErrorStringWithFormat(
"process exited with status %i%s",
3356 exit_status, desc.c_str());
3359 error.SetErrorStringWithFormat(
"initial process state wasn't stopped: %s",
3372 return llvm::createStringError(llvm::inconvertibleErrorCode(),
3373 "A process is required for tracing");
3375 return llvm::createStringError(llvm::inconvertibleErrorCode(),
3376 "A trace already exists for the target");
3378 llvm::Expected<TraceSupportedResponse> trace_type =
3381 return llvm::createStringError(
3382 llvm::inconvertibleErrorCode(),
"Tracing is not supported. %s",
3383 llvm::toString(trace_type.takeError()).c_str());
3384 if (llvm::Expected<TraceSP> trace_sp =
3388 return llvm::createStringError(
3389 llvm::inconvertibleErrorCode(),
3390 "Couldn't create a Trace object for the process. %s",
3391 llvm::toString(trace_sp.takeError()).c_str());
3406 state = process_sp->GetState();
3409 return Status(
"process attach is in progress");
3410 return Status(
"a process is already being debugged");
3419 if (old_exec_module_sp)
3421 old_exec_module_sp->GetPlatformFileSpec().GetFilename());
3424 return Status(
"no process specified, create a target with a file, or "
3425 "specify the --pid or --name");
3429 const auto platform_sp =
3432 const bool async = attach_info.
GetAsync();
3450 plugin_name,
nullptr,
false);
3452 error.SetErrorStringWithFormatv(
3453 "failed to create process using plugin '{0}'",
3454 plugin_name.empty() ?
"<empty>" : plugin_name);
3458 if (hijack_listener_sp)
3459 process_sp->HijackProcessEvents(hijack_listener_sp);
3460 error = process_sp->Attach(attach_info);
3463 if (
error.Success() && process_sp) {
3465 process_sp->RestoreProcessEvents();
3468 state = process_sp->WaitForProcessToStop(
3471 process_sp->RestoreProcessEvents();
3474 const char *exit_desc = process_sp->GetExitDescription();
3476 error.SetErrorStringWithFormat(
"%s", exit_desc);
3478 error.SetErrorString(
3479 "process did not stop (no such process or permission problem?)");
3480 process_sp->Destroy(
false);
3493 const bool default_to_use_pty =
3497 "have platform={0}, platform_sp->IsHost()={1}, default_to_use_pty={2}",
3499 platform_sp ? (platform_sp->IsHost() ?
"true" :
"false") :
"n/a",
3500 default_to_use_pty);
3507 LLDB_LOG(log,
"at least one of stdin/stdout/stderr was not set, evaluating "
3508 "default handling");
3517 LLDB_LOG(log,
"eLaunchFlagDisableSTDIO set, adding suppression action "
3518 "for stdin, stdout and stderr");
3538 LLDB_LOG(log,
"target stdin='{0}', target stdout='{1}', stderr='{1}'",
3539 in_file_spec, out_file_spec, err_file_spec);
3543 LLDB_LOG(log,
"appended stdin open file action for {0}", in_file_spec);
3546 if (out_file_spec) {
3548 LLDB_LOG(log,
"appended stdout open file action for {0}",
3552 if (err_file_spec) {
3554 LLDB_LOG(log,
"appended stderr open file action for {0}",
3558 if (default_to_use_pty) {
3560 LLDB_LOG_ERROR(log, std::move(Err),
"SetUpPtyRedirection failed: {0}");
3577 elem.notify = notify;
3587 = signals_sp->GetSignalNumberFromName(elem.first().str().c_str());
3592 signals_sp->SetShouldSuppress(signo,
false);
3594 signals_sp->SetShouldSuppress(signo,
true);
3597 signals_sp->SetShouldNotify(signo,
true);
3599 signals_sp->SetShouldNotify(signo,
false);
3602 signals_sp->SetShouldStop(signo,
true);
3604 signals_sp->SetShouldStop(signo,
false);
3613 = signals_sp->GetSignalNumberFromName(elem.first().str().c_str());
3619 signals_sp->ResetSignal(signo, do_stop, do_notify, do_pass);
3630 warning_stream_sp->Printf(
"Target signal '%s' not found in process\n",
3631 elem.first().str().c_str());
3644 signals_sp = process_sp->GetUnixSignals();
3647 const char *signal_name = entry.c_str();
3661 strm.
Printf(
"NAME PASS STOP NOTIFY\n");
3662 strm.
Printf(
"=========== ======= ======= =======\n");
3664 auto str_for_lazy = [] (
LazyBool lazy) ->
const char * {
3670 llvm_unreachable(
"Fully covered switch above!");
3674 bool print_it =
false;
3675 for (
size_t idx = 0; idx < num_args; idx++) {
3682 strm.
Printf(
"%-11s ", elem.first().str().c_str());
3683 strm.
Printf(
"%s %s %s\n", str_for_lazy(elem.second.pass),
3684 str_for_lazy(elem.second.stop),
3685 str_for_lazy(elem.second.notify));
3692 :
UserID(uid), m_target_sp(target_sp), m_specifier_sp(),
3693 m_thread_spec_up() {}
3696 :
UserID(rhs.GetID()), m_target_sp(rhs.m_target_sp),
3697 m_specifier_sp(rhs.m_specifier_sp), m_thread_spec_up(),
3698 m_active(rhs.m_active), m_auto_continue(rhs.m_auto_continue) {
3704 m_specifier_sp.reset(specifier);
3708 m_thread_spec_up.reset(specifier);
3716 bool will_run =
true;
3718 will_run = GetSpecifier()->SymbolContextMatches(
3720 if (will_run && GetThreadSpecifier() !=
nullptr)
3722 GetThreadSpecifier()->ThreadPassesBasicTests(exc_ctx.
GetThreadRef());
3732 GetSubclassDescription(s, level);
3740 s.
Printf(
"Hook: %" PRIu64
"\n", GetID());
3742 s.
Indent(
"State: enabled\n");
3744 s.
Indent(
"State: disabled\n");
3746 if (m_auto_continue)
3747 s.
Indent(
"AutoContinue on\n");
3749 if (m_specifier_sp) {
3753 m_specifier_sp->GetDescription(&s, level);
3757 if (m_thread_spec_up) {
3760 m_thread_spec_up->GetDescription(&tmp, level);
3766 GetSubclassDescription(s, level);
3773 if (m_commands.GetSize() == 1)
3774 s.
PutCString(m_commands.GetStringAtIndex(0));
3777 s.
Indent(
"Commands: \n");
3779 uint32_t num_commands = m_commands.GetSize();
3780 for (uint32_t i = 0; i < num_commands; i++) {
3781 s.
Indent(m_commands.GetStringAtIndex(i));
3789 GetCommands().SplitIntoLines(
string);
3793 const std::vector<std::string> &strings) {
3794 for (
auto string : strings)
3795 GetCommands().AppendString(
string.c_str());
3801 assert(exc_ctx.
GetTargetPtr() &&
"Can't call PerformAction on a context "
3804 if (!m_commands.GetSize())
3805 return StopHookResult::KeepStopped;
3828 return StopHookResult::AlreadyContinued;
3829 return StopHookResult::KeepStopped;
3838 GetTarget()->GetDebugger().GetScriptInterpreter();
3839 if (!script_interp) {
3840 error.SetErrorString(
"No script interpreter installed.");
3844 m_class_name = class_name;
3845 m_extra_args.SetObjectSP(extra_args_sp);
3848 GetTarget(), m_class_name.c_str(), m_extra_args,
error);
3856 assert(exc_ctx.
GetTargetPtr() &&
"Can't call HandleStop on a context "
3860 GetTarget()->GetDebugger().GetScriptInterpreter();
3862 return StopHookResult::KeepStopped;
3865 m_implementation_sp, exc_ctx, output_sp);
3867 return should_stop ? StopHookResult::KeepStopped
3868 : StopHookResult::RequestContinue;
3878 s.
Printf(
"%s\n", m_class_name.c_str());
3883 if (!m_extra_args.IsValid())
3886 if (!object_sp || !object_sp->IsValid())
3890 if (!as_dict || !as_dict->
IsValid())
3893 uint32_t num_keys = as_dict->
GetSize();
3900 auto print_one_element = [&s](llvm::StringRef key,
3903 s.
Format(
"{0} : {1}\n", key, object->GetStringValue());
3907 as_dict->
ForEach(print_one_element);
3915 "no-dynamic-values",
3916 "Don't calculate the dynamic type of values",
3921 "Calculate the dynamic type of values "
3922 "even if you have to run the target.",
3927 "Calculate the dynamic type of values, but don't run the target.",
3939 "Never look for inline breakpoint locations (fastest). This setting "
3940 "should only be used if you know that no inlining occurs in your"
3946 "Only check for inline breakpoint locations when setting breakpoints "
3947 "in header files, but not when setting breakpoint in implementation "
3948 "source files (default).",
3953 "Always look for inline breakpoint locations when setting file and "
3954 "line breakpoints (slower but most accurate).",
3968 "Disassembler default (currently att).",
3973 "Intel disassembler flavor.",
3978 "AT&T disassembler flavor.",
3986 "Never import the 'std' C++ module in the expression parser.",
3991 "Retry evaluating expressions with an imported 'std' C++ module if they"
3992 " failed to parse without the module. This allows evaluating more "
3993 "complex expressions involving C++ standard library types."
3998 "Always import the 'std' C++ module. This allows evaluating more "
3999 "complex expressions involving C++ standard library types. This feature"
4009 "Automatically determine the most appropriate method for the "
4013 "Prefer using the realized classes struct."},
4015 "Prefer using the CopyRealizedClassList API."},
4017 "Prefer using the GetRealizedClassList API."},
4024 "C-style (0xffff).",
4029 "Asm-style (0ffffh).",
4037 "Load debug scripts inside symbol files",
4042 "Do not load debug scripts inside symbol files.",
4047 "Warn about debug scripts inside symbol files but do not load them.",
4055 "Load .lldbinit files from current directory",
4060 "Do not load .lldbinit files from current directory",
4065 "Warn about loading .lldbinit files from current directory",
4073 "Load minimal information when loading modules from memory. Currently "
4074 "this setting loads sections only.",
4079 "Load partial information when loading modules from memory. Currently "
4080 "this setting loads sections and function bounds.",
4085 "Load complete information when loading modules from memory. Currently "
4086 "this setting loads sections and all symbols.",
4090#define LLDB_PROPERTIES_target
4091#include "TargetProperties.inc"
4094#define LLDB_PROPERTIES_target
4095#include "TargetPropertiesEnum.inc"
4100 :
public Cloneable<TargetOptionValueProperties, OptionValueProperties> {
4111 Target *target = exe_ctx->GetTargetPtr();
4116 if (
this != target_properties)
4120 return ProtectedGetPropertyAtIndex(idx);
4125#define LLDB_PROPERTIES_target_experimental
4126#include "TargetProperties.inc"
4129#define LLDB_PROPERTIES_target_experimental
4130#include "TargetPropertiesEnum.inc"
4134 :
public Cloneable<TargetExperimentalOptionValueProperties,
4135 OptionValueProperties> {
4149 :
Properties(), m_launch_info(), m_target(target) {
4172 m_collection_sp->SetValueChangedCallback(ePropertyDetachOnError, [
this] {
4185 std::make_unique<TargetExperimentalProperties>();
4188 "Experimental settings - setting these won't produce "
4189 "errors if the setting is not present.",
4192 m_collection_sp = std::make_shared<TargetOptionValueProperties>(
"target");
4195 std::make_unique<TargetExperimentalProperties>();
4198 "Experimental settings - setting these won't produce "
4199 "errors if the setting is not present.",
4202 "process",
"Settings specific to processes.",
true,
4229 exp_property->
GetValue()->GetAsProperties();
4232 return std::nullopt;
4242 const uint32_t idx = ePropertyDefaultArch;
4243 return GetPropertyAtIndexAs<ArchSpec>(idx, {});
4247 const uint32_t idx = ePropertyDefaultArch;
4252 const uint32_t idx = ePropertyMoveToNearestCode;
4253 return GetPropertyAtIndexAs<bool>(
4254 idx, g_target_properties[idx].default_uint_value != 0);
4258 const uint32_t idx = ePropertyPreferDynamic;
4259 return GetPropertyAtIndexAs<lldb::DynamicValueType>(
4261 g_target_properties[idx].default_uint_value));
4265 const uint32_t idx = ePropertyPreferDynamic;
4271 "Interrupted checking preload symbols")) {
4274 const uint32_t idx = ePropertyPreloadSymbols;
4275 return GetPropertyAtIndexAs<bool>(
4276 idx, g_target_properties[idx].default_uint_value != 0);
4280 const uint32_t idx = ePropertyPreloadSymbols;
4285 const uint32_t idx = ePropertyDisableASLR;
4286 return GetPropertyAtIndexAs<bool>(
4287 idx, g_target_properties[idx].default_uint_value != 0);
4291 const uint32_t idx = ePropertyDisableASLR;
4296 const uint32_t idx = ePropertyInheritTCC;
4297 return GetPropertyAtIndexAs<bool>(
4298 idx, g_target_properties[idx].default_uint_value != 0);
4302 const uint32_t idx = ePropertyInheritTCC;
4307 const uint32_t idx = ePropertyDetachOnError;
4308 return GetPropertyAtIndexAs<bool>(
4309 idx, g_target_properties[idx].default_uint_value != 0);
4313 const uint32_t idx = ePropertyDetachOnError;
4318 const uint32_t idx = ePropertyDisableSTDIO;
4319 return GetPropertyAtIndexAs<bool>(
4320 idx, g_target_properties[idx].default_uint_value != 0);
4324 const uint32_t idx = ePropertyDisableSTDIO;
4329 const uint32_t idx = ePropertyDisassemblyFlavor;
4330 const char *return_value;
4333 GetPropertyAtIndexAs<x86DisassemblyFlavor>(
4335 g_target_properties[idx].default_uint_value));
4338 return return_value;
4342 const uint32_t idx = ePropertyInlineStrategy;
4343 return GetPropertyAtIndexAs<InlineStrategy>(
4345 static_cast<InlineStrategy>(g_target_properties[idx].default_uint_value));
4349 const uint32_t idx = ePropertyArg0;
4350 return GetPropertyAtIndexAs<llvm::StringRef>(
4351 idx, g_target_properties[idx].default_cstr_value);
4355 const uint32_t idx = ePropertyArg0;
4361 const uint32_t idx = ePropertyRunArgs;
4366 const uint32_t idx = ePropertyRunArgs;
4375 GetPropertyAtIndexAs<bool>(
4376 ePropertyInheritEnv,
4377 g_target_properties[ePropertyInheritEnv].default_uint_value != 0)) {
4379 Environment platform_env = platform_sp->GetEnvironment();
4380 for (
const auto &KV : platform_env)
4381 env[KV.first()] = KV.second;
4385 Args property_unset_env;
4387 property_unset_env);
4388 for (
const auto &var : property_unset_env)
4389 env.erase(var.ref());
4392 m_collection_sp->GetPropertyAtIndexAsArgs(ePropertyEnvVars, property_env);
4394 env[KV.first()] = KV.second;
4409 if (!GetPropertyAtIndexAs<bool>(
4410 ePropertyInheritEnv,
4411 g_target_properties[ePropertyInheritEnv].default_uint_value != 0))
4415 if (platform_sp ==
nullptr)
4418 Environment platform_environment = platform_sp->GetEnvironment();
4419 for (
const auto &KV : platform_environment)
4420 environment[KV.first()] = KV.second;
4422 Args property_unset_environment;
4424 property_unset_environment);
4425 for (
const auto &var : property_unset_environment)
4426 environment.erase(var.ref());
4432 Args property_environment;
4434 property_environment);
4436 for (
const auto &KV :
Environment(property_environment))
4437 environment[KV.first()] = KV.second;
4444 const uint32_t idx = ePropertyEnvVars;
4449 const uint32_t idx = ePropertySkipPrologue;
4450 return GetPropertyAtIndexAs<bool>(
4451 idx, g_target_properties[idx].default_uint_value != 0);
4455 const uint32_t idx = ePropertySourceMap;
4458 assert(option_value);
4463 const uint32_t idx = ePropertyAutoSourceMapRelative;
4464 return GetPropertyAtIndexAs<bool>(
4465 idx, g_target_properties[idx].default_uint_value != 0);
4469 const uint32_t idx = ePropertyExecutableSearchPaths;
4472 assert(option_value);
4477 const uint32_t idx = ePropertyExecutableSearchPaths;
4478 return GetPropertyAtIndexAs<FileSpecList>(idx, {});
4482 const uint32_t idx = ePropertyDebugFileSearchPaths;
4483 return GetPropertyAtIndexAs<FileSpecList>(idx, {});
4487 const uint32_t idx = ePropertyClangModuleSearchPaths;
4488 return GetPropertyAtIndexAs<FileSpecList>(idx, {});
4492 const uint32_t idx = ePropertyAutoImportClangModules;
4493 return GetPropertyAtIndexAs<bool>(
4494 idx, g_target_properties[idx].default_uint_value != 0);
4498 const uint32_t idx = ePropertyImportStdModule;
4499 return GetPropertyAtIndexAs<ImportStdModule>(
4501 g_target_properties[idx].default_uint_value));
4505 const uint32_t idx = ePropertyDynamicClassInfoHelper;
4506 return GetPropertyAtIndexAs<DynamicClassInfoHelper>(
4508 g_target_properties[idx].default_uint_value));
4512 const uint32_t idx = ePropertyAutoApplyFixIts;
4513 return GetPropertyAtIndexAs<bool>(
4514 idx, g_target_properties[idx].default_uint_value != 0);
4518 const uint32_t idx = ePropertyRetriesWithFixIts;
4519 return GetPropertyAtIndexAs<uint64_t>(
4520 idx, g_target_properties[idx].default_uint_value);
4524 const uint32_t idx = ePropertyNotifyAboutFixIts;
4525 return GetPropertyAtIndexAs<bool>(
4526 idx, g_target_properties[idx].default_uint_value != 0);
4530 const uint32_t idx = ePropertySaveObjectsDir;
4531 return GetPropertyAtIndexAs<FileSpec>(idx, {});
4540 bool exists = instance.
Exists(new_dir);
4541 bool is_directory = instance.
IsDirectory(new_dir);
4542 std::string path = new_dir.
GetPath(
true);
4543 bool writable = llvm::sys::fs::can_write(path);
4544 if (exists && is_directory && writable)
4552 llvm::raw_string_ostream os(buffer);
4553 os <<
"JIT object dir '" << path <<
"' ";
4555 os <<
"does not exist";
4556 else if (!is_directory)
4557 os <<
"is not a directory";
4559 os <<
"is not writable";
4561 std::optional<lldb::user_id_t> debugger_id;
4568 const uint32_t idx = ePropertyEnableSynthetic;
4569 return GetPropertyAtIndexAs<bool>(
4570 idx, g_target_properties[idx].default_uint_value != 0);
4574 const uint32_t idx = ePropertyShowHexVariableValuesWithLeadingZeroes;
4575 return GetPropertyAtIndexAs<bool>(
4576 idx, g_target_properties[idx].default_uint_value != 0);
4580 const uint32_t idx = ePropertyMaxZeroPaddingInFloatFormat;
4581 return GetPropertyAtIndexAs<uint64_t>(
4582 idx, g_target_properties[idx].default_uint_value);
4586 const uint32_t idx = ePropertyMaxChildrenCount;
4587 return GetPropertyAtIndexAs<int64_t>(
4588 idx, g_target_properties[idx].default_uint_value);
4591std::pair<uint32_t, bool>
4593 const uint32_t idx = ePropertyMaxChildrenDepth;
4594 auto *option_value =
4596 bool is_default = !option_value->OptionWasSet();
4597 return {option_value->GetCurrentValue(), is_default};
4601 const uint32_t idx = ePropertyMaxSummaryLength;
4602 return GetPropertyAtIndexAs<uint64_t>(
4603 idx, g_target_properties[idx].default_uint_value);
4607 const uint32_t idx = ePropertyMaxMemReadSize;
4608 return GetPropertyAtIndexAs<uint64_t>(
4609 idx, g_target_properties[idx].default_uint_value);
4613 const uint32_t idx = ePropertyInputPath;
4614 return GetPropertyAtIndexAs<FileSpec>(idx, {});
4618 const uint32_t idx = ePropertyInputPath;
4623 const uint32_t idx = ePropertyOutputPath;
4624 return GetPropertyAtIndexAs<FileSpec>(idx, {});
4628 const uint32_t idx = ePropertyOutputPath;
4633 const uint32_t idx = ePropertyErrorPath;
4634 return GetPropertyAtIndexAs<FileSpec>(idx, {});
4638 const uint32_t idx = ePropertyErrorPath;
4643 const uint32_t idx = ePropertyLanguage;
4644 return {GetPropertyAtIndexAs<LanguageType>(idx, {})};
4648 const uint32_t idx = ePropertyExprPrefix;
4654 return llvm::StringRef(
4655 reinterpret_cast<const char *
>(data_sp->GetBytes()),
4656 data_sp->GetByteSize());
4662 const uint32_t idx = ePropertyExprErrorLimit;
4663 return GetPropertyAtIndexAs<uint64_t>(
4664 idx, g_target_properties[idx].default_uint_value);
4668 const uint32_t idx = ePropertyExprAllocAddress;
4669 return GetPropertyAtIndexAs<uint64_t>(
4670 idx, g_target_properties[idx].default_uint_value);
4674 const uint32_t idx = ePropertyExprAllocSize;
4675 return GetPropertyAtIndexAs<uint64_t>(
4676 idx, g_target_properties[idx].default_uint_value);
4680 const uint32_t idx = ePropertyExprAllocAlign;
4681 return GetPropertyAtIndexAs<uint64_t>(
4682 idx, g_target_properties[idx].default_uint_value);
4686 const uint32_t idx = ePropertyBreakpointUseAvoidList;
4687 return GetPropertyAtIndexAs<bool>(
4688 idx, g_target_properties[idx].default_uint_value != 0);
4692 const uint32_t idx = ePropertyUseHexImmediates;
4693 return GetPropertyAtIndexAs<bool>(
4694 idx, g_target_properties[idx].default_uint_value != 0);
4698 const uint32_t idx = ePropertyUseFastStepping;
4699 return GetPropertyAtIndexAs<bool>(
4700 idx, g_target_properties[idx].default_uint_value != 0);
4704 const uint32_t idx = ePropertyDisplayExpressionsInCrashlogs;
4705 return GetPropertyAtIndexAs<bool>(
4706 idx, g_target_properties[idx].default_uint_value != 0);
4710 const uint32_t idx = ePropertyLoadScriptFromSymbolFile;
4711 return GetPropertyAtIndexAs<LoadScriptFromSymFile>(
4713 g_target_properties[idx].default_uint_value));
4717 const uint32_t idx = ePropertyLoadCWDlldbinitFile;
4718 return GetPropertyAtIndexAs<LoadCWDlldbinitFile>(
4720 g_target_properties[idx].default_uint_value));
4724 const uint32_t idx = ePropertyHexImmediateStyle;
4725 return GetPropertyAtIndexAs<Disassembler::HexImmediateStyle>(
4727 g_target_properties[idx].default_uint_value));
4731 const uint32_t idx = ePropertyMemoryModuleLoadLevel;
4732 return GetPropertyAtIndexAs<MemoryModuleLoadLevel>(
4734 g_target_properties[idx].default_uint_value));
4738 const uint32_t idx = ePropertyTrapHandlerNames;
4743 const uint32_t idx = ePropertyTrapHandlerNames;
4748 const uint32_t idx = ePropertyDisplayRuntimeSupportValues;
4749 return GetPropertyAtIndexAs<bool>(
4750 idx, g_target_properties[idx].default_uint_value != 0);
4754 const uint32_t idx = ePropertyDisplayRuntimeSupportValues;
4759 const uint32_t idx = ePropertyDisplayRecognizedArguments;
4760 return GetPropertyAtIndexAs<bool>(
4761 idx, g_target_properties[idx].default_uint_value != 0);
4765 const uint32_t idx = ePropertyDisplayRecognizedArguments;
4781 if (input_file_action) {
4786 if (output_file_action) {
4791 if (error_file_action) {
4797 launch_info.
GetFlags().
Test(lldb::eLaunchFlagInheritTCCFromParent));
4802 const uint32_t idx = ePropertyRequireHardwareBreakpoints;
4803 return GetPropertyAtIndexAs<bool>(
4804 idx, g_target_properties[idx].default_uint_value != 0);
4808 const uint32_t idx = ePropertyRequireHardwareBreakpoints;
4813 const uint32_t idx = ePropertyAutoInstallMainExecutable;
4814 return GetPropertyAtIndexAs<bool>(
4815 idx, g_target_properties[idx].default_uint_value != 0);
4876 const uint32_t idx = ePropertyDebugUtilityExpression;
4877 return GetPropertyAtIndexAs<bool>(
4878 idx, g_target_properties[idx].default_uint_value != 0);
4882 const uint32_t idx = ePropertyDebugUtilityExpression;
4889 :
EventData(), m_target_sp(target_sp), m_module_list() {}
4893 :
EventData(), m_target_sp(target_sp), m_module_list(module_list) {}
4898 return "Target::TargetEventData";
4902 for (
size_t i = 0; i < m_module_list.GetSize(); ++i) {
4905 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
SourceLanguage GetLanguage() 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)
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)
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
BreakpointList m_breakpoint_list
lldb::SourceManagerUP m_source_manager_up
virtual size_t ReadMemory(const Address &addr, void *dst, size_t dst_len, Status &error, bool force_live_memory=false, lldb::addr_t *load_addr_ptr=nullptr)
bool 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 llvm::StringRef GetStaticBroadcasterClass()
static FileSpecList GetDefaultDebugFileSearchPaths()
void EnableAllowedBreakpoints()
llvm::Error SetLabel(llvm::StringRef label)
Set a label for a target.
uint32_t m_latest_stop_hook_id
@ eBroadcastBitModulesLoaded
@ eBroadcastBitSymbolsLoaded
@ eBroadcastBitModulesUnloaded
@ eBroadcastBitWatchpointChanged
@ eBroadcastBitBreakpointChanged
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)
UserExpression * GetUserExpressionForLanguage(llvm::StringRef expr, llvm::StringRef prefix, SourceLanguage language, Expression::ResultType desired_type, const EvaluateExpressionOptions &options, ValueObject *ctx_obj, Status &error)
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 type-erased pair of llvm::dwarf::SourceLanguageName and version.
lldb::LanguageType AsLanguageType() const
llvm::StringRef GetDescription() const
A mix in class that contains a generic user ID.
lldb::user_id_t GetID() const
Get accessor for the user ID.