14#include "llvm/ADT/ScopeExit.h"
15#include "llvm/Support/ScopedPrinter.h"
16#include "llvm/Support/Threading.h"
80using namespace std::chrono;
84#define ENABLE_MEMORY_CACHING
86#ifdef ENABLE_MEMORY_CACHING
87#define DISABLE_MEM_CACHE_DEFAULT false
89#define DISABLE_MEM_CACHE_DEFAULT true
93 :
public Cloneable<ProcessOptionValueProperties, OptionValueProperties> {
109 if (
this != instance_properties)
148 "Continue tracing the parent process and detach the child.",
153 "Trace the child process and detach the parent.",
157#define LLDB_PROPERTIES_process
158#include "TargetProperties.inc"
161#define LLDB_PROPERTIES_process
162#include "TargetPropertiesEnum.inc"
166#define LLDB_PROPERTIES_process_experimental
167#include "TargetProperties.inc"
170#define LLDB_PROPERTIES_process_experimental
171#include "TargetPropertiesEnum.inc"
175 :
public Cloneable<ProcessExperimentalOptionValueProperties,
176 OptionValueProperties> {
192 if (process ==
nullptr) {
194 m_collection_sp = std::make_shared<ProcessOptionValueProperties>(
"process");
197 "thread",
"Settings specific to threads.",
true,
203 ePropertyPythonOSPluginPath,
208 std::make_unique<ProcessExperimentalProperties>();
211 "Experimental settings - setting these won't produce "
212 "errors if the setting is not present.",
219 const uint32_t idx = ePropertyDisableMemCache;
220 return GetPropertyAtIndexAs<bool>(
221 idx, g_process_properties[idx].default_uint_value != 0);
225 const uint32_t idx = ePropertyMemCacheLineSize;
226 return GetPropertyAtIndexAs<uint64_t>(
227 idx, g_process_properties[idx].default_uint_value);
232 const uint32_t idx = ePropertyExtraStartCommand;
238 const uint32_t idx = ePropertyExtraStartCommand;
243 const uint32_t idx = ePropertyPythonOSPluginPath;
244 return GetPropertyAtIndexAs<FileSpec>(idx, {});
248 const uint32_t idx = ePropertyVirtualAddressableBits;
249 return GetPropertyAtIndexAs<uint64_t>(
250 idx, g_process_properties[idx].default_uint_value);
254 const uint32_t idx = ePropertyVirtualAddressableBits;
259 const uint32_t idx = ePropertyHighmemVirtualAddressableBits;
260 return GetPropertyAtIndexAs<uint64_t>(
261 idx, g_process_properties[idx].default_uint_value);
265 const uint32_t idx = ePropertyHighmemVirtualAddressableBits;
270 const uint32_t idx = ePropertyPythonOSPluginPath;
275 const uint32_t idx = ePropertyIgnoreBreakpointsInExpressions;
276 return GetPropertyAtIndexAs<bool>(
277 idx, g_process_properties[idx].default_uint_value != 0);
281 const uint32_t idx = ePropertyIgnoreBreakpointsInExpressions;
286 const uint32_t idx = ePropertyUnwindOnErrorInExpressions;
287 return GetPropertyAtIndexAs<bool>(
288 idx, g_process_properties[idx].default_uint_value != 0);
292 const uint32_t idx = ePropertyUnwindOnErrorInExpressions;
297 const uint32_t idx = ePropertyStopOnSharedLibraryEvents;
298 return GetPropertyAtIndexAs<bool>(
299 idx, g_process_properties[idx].default_uint_value != 0);
303 const uint32_t idx = ePropertyStopOnSharedLibraryEvents;
308 const uint32_t idx = ePropertyDisableLangRuntimeUnwindPlans;
309 return GetPropertyAtIndexAs<bool>(
310 idx, g_process_properties[idx].default_uint_value != 0);
314 const uint32_t idx = ePropertyDisableLangRuntimeUnwindPlans;
320 const uint32_t idx = ePropertyDetachKeepsStopped;
321 return GetPropertyAtIndexAs<bool>(
322 idx, g_process_properties[idx].default_uint_value != 0);
326 const uint32_t idx = ePropertyDetachKeepsStopped;
331 const uint32_t idx = ePropertyWarningOptimization;
332 return GetPropertyAtIndexAs<bool>(
333 idx, g_process_properties[idx].default_uint_value != 0);
337 const uint32_t idx = ePropertyWarningUnsupportedLanguage;
338 return GetPropertyAtIndexAs<bool>(
339 idx, g_process_properties[idx].default_uint_value != 0);
343 const uint32_t idx = ePropertyStopOnExec;
344 return GetPropertyAtIndexAs<bool>(
345 idx, g_process_properties[idx].default_uint_value != 0);
349 const uint32_t idx = ePropertyUtilityExpressionTimeout;
350 uint64_t value = GetPropertyAtIndexAs<uint64_t>(
351 idx, g_process_properties[idx].default_uint_value);
352 return std::chrono::seconds(value);
356 const uint32_t idx = ePropertyInterruptTimeout;
357 uint64_t value = GetPropertyAtIndexAs<uint64_t>(
358 idx, g_process_properties[idx].default_uint_value);
359 return std::chrono::seconds(value);
363 const uint32_t idx = ePropertySteppingRunsAllThreads;
364 return GetPropertyAtIndexAs<bool>(
365 idx, g_process_properties[idx].default_uint_value != 0);
369 const bool fail_value =
true;
373 exp_property->
GetValue()->GetAsProperties();
379 .value_or(fail_value);
386 exp_property->
GetValue()->GetAsProperties();
393 const uint32_t idx = ePropertyFollowForkMode;
394 return GetPropertyAtIndexAs<FollowForkMode>(
396 g_process_properties[idx].default_uint_value));
400 llvm::StringRef plugin_name,
404 static uint32_t g_process_unique_id = 0;
408 if (!plugin_name.empty()) {
411 if (create_callback) {
412 process_sp = create_callback(target_sp, listener_sp, crash_file_path,
415 if (process_sp->CanDebug(target_sp,
true)) {
416 process_sp->m_process_unique_id = ++g_process_unique_id;
422 for (uint32_t idx = 0;
426 process_sp = create_callback(target_sp, listener_sp, crash_file_path,
429 if (process_sp->CanDebug(target_sp,
false)) {
430 process_sp->m_process_unique_id = ++g_process_unique_id;
441 static constexpr llvm::StringLiteral class_name(
"lldb.process");
454 Broadcaster((target_sp->GetDebugger().GetBroadcasterManager()),
455 Process::GetStaticBroadcasterClass().str()),
458 m_private_state_broadcaster(nullptr,
459 "lldb.process.internal_state_broadcaster"),
460 m_private_state_control_broadcaster(
461 nullptr,
"lldb.process.internal_state_control_broadcaster"),
462 m_private_state_listener_sp(
463 Listener::MakeListener(
"lldb.process.internal_state_listener")),
464 m_mod_id(), m_process_unique_id(0), m_thread_index_id(0),
465 m_thread_id_to_index_id_map(), m_exit_status(-1),
466 m_thread_list_real(*this), m_thread_list(*this), m_thread_plans(*this),
467 m_extended_thread_list(*this), m_extended_thread_stop_id(0),
468 m_queue_list(this), m_queue_list_stop_id(0),
469 m_unix_signals_sp(unix_signals_sp), m_abi_sp(), m_process_input_reader(),
470 m_stdio_communication(
"process.stdio"), m_stdio_communication_mutex(),
471 m_stdin_forward(false), m_stdout_data(), m_stderr_data(),
472 m_profile_data_comm_mutex(), m_profile_data(), m_iohandler_sync(0),
473 m_memory_cache(*this), m_allocated_memory_cache(*this),
474 m_should_detach(false), m_next_event_action_up(), m_public_run_lock(),
475 m_private_run_lock(), m_currently_handling_do_on_removals(false),
476 m_resume_requested(false), m_finalizing(false), m_destructing(false),
477 m_clear_thread_plans_on_stop(false), m_force_next_event_delivery(false),
478 m_last_broadcast_state(
eStateInvalid), m_destroy_in_process(false),
479 m_can_interpret_function_calls(false), m_run_thread_plan_lock(),
480 m_can_jit(eCanJITDontKnow) {
484 LLDB_LOGF(log,
"%p Process::Process()",
static_cast<void *
>(
this));
522 uint64_t platform_cache_line_size =
523 target_sp->GetPlatform()->GetDefaultMemoryCacheLineSize();
524 if (!value_sp->OptionWasSet() && platform_cache_line_size != 0)
525 value_sp->SetValueAs(platform_cache_line_size);
536 LLDB_LOGF(log,
"%p Process::~Process()",
static_cast<void *
>(
this));
550 return *g_settings_ptr;
585 std::vector<Notifications> empty_notifications;
619 if (pos->baton == callbacks.
baton &&
630 std::vector<Notifications>::iterator notification_pos,
633 notification_pos != notification_end; ++notification_pos) {
634 if (notification_pos->process_state_changed)
635 notification_pos->process_state_changed(notification_pos->baton,
this,
654 std::chrono::seconds(0)) &&
674 "waited from m_iohandler_sync to change from {0}. New value is {1}.",
675 iohandler_id, *Result);
677 LLDB_LOG(log,
"timed out waiting for m_iohandler_sync to change from {0}.",
690 event_sp_ptr->reset();
698 LLDB_LOG(log,
"timeout = {0}", timeout);
703 "Process::%s returning without waiting for events; process "
704 "private and public states are already 'stopped'.",
708 if (hijack_listener_sp && use_run_lock)
716 if (event_sp_ptr && event_sp)
717 *event_sp_ptr = event_sp;
719 bool pop_process_io_handler = (hijack_listener_sp.get() !=
nullptr);
721 event_sp, stream, select_most_relevant, pop_process_io_handler);
730 if (hijack_listener_sp && use_run_lock)
739 if (hijack_listener_sp && use_run_lock)
753 bool &pop_process_io_handler) {
754 const bool handle_pop = pop_process_io_handler;
756 pop_process_io_handler =
false;
768 switch (event_state) {
776 stream->
Printf(
"Process %" PRIu64
" %s\n", process_sp->GetID(),
779 pop_process_io_handler =
true;
789 process_sp->GetStatus(*stream);
790 pop_process_io_handler =
true;
801 if (num_reasons > 0) {
804 if (num_reasons == 1) {
808 stream->
Printf(
"Process %" PRIu64
" stopped and restarted: %s\n",
810 reason ? reason :
"<UNKNOWN REASON>");
812 stream->
Printf(
"Process %" PRIu64
813 " stopped and restarted, reasons:\n",
814 process_sp->GetID());
816 for (
size_t i = 0; i < num_reasons; i++) {
820 stream->
Printf(
"\t%s\n", reason ? reason :
"<UNKNOWN REASON>");
830 ThreadList &thread_list = process_sp->GetThreadList();
831 std::lock_guard<std::recursive_mutex> guard(thread_list.
GetMutex());
836 bool prefer_curr_thread =
false;
837 if (curr_thread && curr_thread->IsValid()) {
838 curr_thread_stop_reason = curr_thread->GetStopReason();
839 switch (curr_thread_stop_reason) {
848 uint64_t signo = curr_thread->GetStopInfo()->GetValue();
849 if (process_sp->GetUnixSignals()->GetShouldStop(signo))
850 prefer_curr_thread =
true;
853 prefer_curr_thread =
true;
856 curr_thread_stop_info_sp = curr_thread->GetStopInfo();
859 if (!prefer_curr_thread) {
865 const size_t num_threads = thread_list.
GetSize();
867 for (i = 0; i < num_threads; ++i) {
869 StopReason thread_stop_reason = thread->GetStopReason();
870 switch (thread_stop_reason) {
879 uint64_t signo = thread->GetStopInfo()->GetValue();
880 if (process_sp->GetUnixSignals()->GetShouldStop(signo)) {
882 other_thread = thread;
898 other_thread = thread;
902 plan_thread = thread;
908 else if (other_thread)
911 if (curr_thread && curr_thread->IsValid())
912 thread = curr_thread;
926 Debugger &debugger = process_sp->GetTarget().GetDebugger();
928 &process_sp->GetTarget()) {
929 ThreadSP thread_sp = process_sp->GetThreadList().GetSelectedThread();
931 if (!thread_sp || !thread_sp->IsValid())
934 const bool only_threads_with_stop_reason =
true;
935 const uint32_t start_frame =
936 thread_sp->GetSelectedFrameIndex(select_most_relevant);
937 const uint32_t num_frames = 1;
938 const uint32_t num_frames_with_source = 1;
939 const bool stop_format =
true;
941 process_sp->GetStatus(*stream);
942 process_sp->GetThreadStatus(*stream, only_threads_with_stop_reason,
943 start_frame, num_frames,
944 num_frames_with_source,
946 if (curr_thread_stop_info_sp) {
949 curr_thread_stop_info_sp, &crashing_address);
955 valobj_sp->GetExpressionPath(*stream, format);
956 stream->
Printf(
" accessed 0x%" PRIx64
"\n", crashing_address);
961 process_sp->GetTarget().shared_from_this());
963 stream->
Printf(
"Target %d: (", target_idx);
965 stream->
Printf(
"Target <unknown index>: (");
967 stream->
Printf(
") stopped.\n");
972 pop_process_io_handler =
true;
977 if (handle_pop && pop_process_io_handler)
978 process_sp->PopProcessIOHandler();
997 LLDB_LOG(log,
"timeout = {0}, event_sp)...", timeout);
1004 if (listener_sp->GetEventForBroadcasterWithType(
1010 LLDB_LOG(log,
"got no event or was interrupted.");
1013 LLDB_LOG(log,
"timeout = {0}, event_sp) => {1}", timeout, state);
1020 LLDB_LOGF(log,
"Process::%s...", __FUNCTION__);
1027 LLDB_LOGF(log,
"Process::%s (event_ptr) => %s", __FUNCTION__,
1030 LLDB_LOGF(log,
"Process::%s no events found", __FUNCTION__);
1040 LLDB_LOG(log,
"timeout = {0}, event_sp)...", timeout);
1050 LLDB_LOG(log,
"timeout = {0}, event_sp) => {1}", timeout,
1057 bool control_only) {
1059 LLDB_LOG(log,
"timeout = {0}, event_sp)...", timeout);
1093 LLDB_LOG(log,
"(plugin = {0} status = {1} ({1:x8}), description=\"{2}\")",
1100 "(plugin = {0}) ignoring exit status because state was already set "
1107 if (!exit_string.empty())
1151 "Process::SetProcessExitStatus (pid=%" PRIu64
1152 ", exited=%i, signal=%i, exit_status=%i)\n",
1153 pid, exited, signo, exit_status);
1158 ProcessSP process_sp(target_sp->GetProcessSP());
1160 llvm::StringRef signal_str =
1161 process_sp->GetUnixSignals()->GetSignalAsStringRef(signo);
1162 process_sp->SetExitStatus(exit_status, signal_str);
1180 bool clear_unused_threads =
true;
1203 size_t num_old_threads = old_thread_list.
GetSize(
false);
1204 for (
size_t i = 0; i < num_old_threads; ++i)
1237 new_thread_list = real_thread_list;
1277 bool internal,
bool condense_trivial,
1278 bool skip_unreported_plans) {
1280 strm, tid, desc_level, internal, condense_trivial, skip_unreported_plans);
1283 bool internal,
bool condense_trivial,
1284 bool skip_unreported_plans) {
1286 skip_unreported_plans);
1319 uint32_t result = 0;
1320 std::map<uint64_t, uint32_t>::iterator iterator =
1326 result = iterator->second;
1341 if (new_state_is_stopped) {
1352 LLDB_LOGF(log,
"(plugin = %s, state = %s, restarted = %i)",
1363 "(plugin = %s, state = %s) -- unlocking run lock for detach",
1368 if ((old_state_is_stopped != new_state_is_stopped)) {
1369 if (new_state_is_stopped && !restarted) {
1370 LLDB_LOGF(log,
"(plugin = %s, state = %s) -- unlocking run lock",
1383 Status error(
"Resume request failed - process still running.");
1384 LLDB_LOGF(log,
"(plugin = %s) -- TrySetRunning failed, not resuming.",
1389 if (!
error.Success()) {
1398 LLDB_LOGF(log,
"Process::ResumeSynchronous -- locking run lock");
1400 Status error(
"Resume request failed - process still running.");
1401 LLDB_LOGF(log,
"Process::Resume: -- TrySetRunning failed, not resuming.");
1410 if (
error.Success()) {
1414 const bool must_be_alive =
1417 error.SetErrorStringWithFormat(
1418 "process not in stopped state after synchronous resume: %s",
1434 if (!hijacking_name.starts_with(
"lldb.internal"))
1462 bool state_changed =
false;
1471 state_changed = old_state != new_state;
1475 if (old_state_is_stopped != new_state_is_stopped) {
1476 if (new_state_is_stopped)
1482 if (state_changed) {
1506 LLDB_LOGF(log,
"(plugin = %s, state = %s, stop_id = %u",
1513 LLDB_LOGF(log,
"(plugin = %s, state = %s) state didn't change. Ignoring...",
1535 std::vector<LanguageRuntime *> language_runtimes;
1538 return language_runtimes;
1548 language_runtimes.emplace_back(runtime);
1551 return language_runtimes;
1561 LanguageRuntimeCollection::iterator pos;
1568 runtime = runtime_sp.get();
1570 runtime = pos->second.get();
1596 if (runtime->CouldHaveDynamicValue(in_value))
1626 if (
error.Success())
1636 if (bp_site_sp->IsEnabled())
1639 error.SetErrorStringWithFormat(
"invalid breakpoint site ID: %" PRIu64,
1650 if (!bp_site_sp->IsEnabled())
1653 error.SetErrorStringWithFormat(
"invalid breakpoint site ID: %" PRIu64,
1661 bool use_hardware) {
1664 bool show_error =
true;
1687 constituent->SetIsIndirect(
false);
1689 if (constituent->ShouldResolveIndirectFunctions()) {
1695 if (!
error.Success() && show_error) {
1697 "warning: failed to resolve indirect function at 0x%" PRIx64
1698 " for breakpoint %i.%i: %s\n",
1700 constituent->GetBreakpoint().GetID(), constituent->GetID(),
1701 error.AsCString() ?
error.AsCString() :
"unknown error");
1704 Address resolved_address(load_addr);
1706 constituent->SetIsIndirect(
true);
1708 load_addr = constituent->GetAddress().GetOpcodeLoadAddress(&
GetTarget());
1710 load_addr = constituent->GetAddress().GetOpcodeLoadAddress(&
GetTarget());
1721 bp_site_sp->AddConstituent(constituent);
1722 constituent->SetBreakpointSite(bp_site_sp);
1723 return bp_site_sp->GetID();
1729 if (
error.Success()) {
1730 constituent->SetBreakpointSite(bp_site_sp);
1733 if (show_error || use_hardware) {
1736 "warning: failed to set breakpoint site at 0x%" PRIx64
1737 " for breakpoint %i.%i: %s\n",
1738 load_addr, constituent->GetBreakpoint().GetID(),
1739 constituent->GetID(),
1740 error.AsCString() ?
error.AsCString() :
"unknown error");
1753 uint32_t num_constituents =
1754 bp_site_sp->RemoveConstituent(constituent_id, constituent_loc_id);
1755 if (num_constituents == 0) {
1764 uint8_t *buf)
const {
1765 size_t bytes_removed = 0;
1769 bp_sites_in_range)) {
1770 bp_sites_in_range.
ForEach([bp_addr, size,
1773 addr_t intersect_addr;
1774 size_t intersect_size;
1775 size_t opcode_offset;
1776 if (bp_site->IntersectsRange(bp_addr, size, &intersect_addr,
1777 &intersect_size, &opcode_offset)) {
1778 assert(bp_addr <= intersect_addr && intersect_addr < bp_addr + size);
1779 assert(bp_addr < intersect_addr + intersect_size &&
1780 intersect_addr + intersect_size <= bp_addr + size);
1781 assert(opcode_offset + intersect_size <= bp_site->GetByteSize());
1782 size_t buf_offset = intersect_addr - bp_addr;
1783 ::memcpy(buf + buf_offset,
1784 bp_site->GetSavedOpcodeBytes() + opcode_offset,
1790 return bytes_removed;
1796 return platform_sp->GetSoftwareBreakpointTrapOpcode(
GetTarget(), bp_site);
1802 assert(bp_site !=
nullptr);
1806 log,
"Process::EnableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64,
1807 bp_site->
GetID(), (uint64_t)bp_addr);
1811 "Process::EnableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64
1812 " -- already enabled",
1813 bp_site->
GetID(), (uint64_t)bp_addr);
1818 error.SetErrorString(
"BreakpointSite contains an invalid load address.");
1825 if (bp_opcode_size == 0) {
1826 error.SetErrorStringWithFormat(
"Process::GetSoftwareBreakpointTrapOpcode() "
1827 "returned zero, unable to get breakpoint "
1828 "trap for address 0x%" PRIx64,
1833 if (bp_opcode_bytes ==
nullptr) {
1834 error.SetErrorString(
1835 "BreakpointSite doesn't contain a valid breakpoint trap opcode.");
1841 error) == bp_opcode_size) {
1845 uint8_t verify_bp_opcode_bytes[64];
1846 if (
DoReadMemory(bp_addr, verify_bp_opcode_bytes, bp_opcode_size,
1847 error) == bp_opcode_size) {
1848 if (::memcmp(bp_opcode_bytes, verify_bp_opcode_bytes,
1849 bp_opcode_size) == 0) {
1853 "Process::EnableSoftwareBreakpoint (site_id = %d) "
1854 "addr = 0x%" PRIx64
" -- SUCCESS",
1855 bp_site->
GetID(), (uint64_t)bp_addr);
1857 error.SetErrorString(
1858 "failed to verify the breakpoint trap in memory.");
1860 error.SetErrorString(
1861 "Unable to read memory to verify breakpoint trap.");
1863 error.SetErrorString(
"Unable to write breakpoint trap to memory.");
1865 error.SetErrorString(
"Unable to read memory at breakpoint address.");
1867 if (log &&
error.Fail())
1870 "Process::EnableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64
1872 bp_site->
GetID(), (uint64_t)bp_addr,
error.AsCString());
1878 assert(bp_site !=
nullptr);
1883 "Process::DisableSoftwareBreakpoint (breakID = %" PRIu64
1884 ") addr = 0x%" PRIx64,
1885 breakID, (uint64_t)bp_addr);
1888 error.SetErrorString(
"Breakpoint site is a hardware breakpoint.");
1890 const size_t break_op_size = bp_site->
GetByteSize();
1892 if (break_op_size > 0) {
1894 uint8_t curr_break_op[8];
1895 assert(break_op_size <=
sizeof(curr_break_op));
1896 bool break_op_found =
false;
1901 bool verify =
false;
1903 if (::memcmp(curr_break_op, break_op, break_op_size) == 0) {
1904 break_op_found =
true;
1908 break_op_size,
error) == break_op_size) {
1911 error.SetErrorString(
1912 "Memory write failed when restoring original opcode.");
1914 error.SetErrorString(
1915 "Original breakpoint trap is no longer in memory.");
1922 uint8_t verify_opcode[8];
1923 assert(break_op_size <
sizeof(verify_opcode));
1929 break_op_size) == 0) {
1933 "Process::DisableSoftwareBreakpoint (site_id = %d) "
1934 "addr = 0x%" PRIx64
" -- SUCCESS",
1935 bp_site->
GetID(), (uint64_t)bp_addr);
1939 error.SetErrorString(
"Failed to restore original opcode.");
1942 error.SetErrorString(
"Failed to read memory to verify that "
1943 "breakpoint trap was restored.");
1946 error.SetErrorString(
1947 "Unable to read memory that should contain the breakpoint trap.");
1952 "Process::DisableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64
1953 " -- already disabled",
1954 bp_site->
GetID(), (uint64_t)bp_addr);
1960 "Process::DisableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64
1962 bp_site->
GetID(), (uint64_t)bp_addr,
error.AsCString());
1972 addr = abi_sp->FixAnyAddress(addr);
1976#if defined(VERIFY_MEMORY_READS)
1988 std::string verify_buf(size,
'\0');
1989 assert(verify_buf.size() == size);
1990 const size_t cache_bytes_read =
1993 const size_t verify_bytes_read =
1995 verify_buf.size(), verify_error);
1996 assert(cache_bytes_read == verify_bytes_read);
1997 assert(memcmp(buf, verify_buf.data(), verify_buf.size()) == 0);
1999 return cache_bytes_read;
2015 const uint8_t *buf,
size_t size,
2017 size_t max_matches) {
2019 assert(buf !=
nullptr);
2021 assert(alignment > 0);
2022 assert(max_matches > 0);
2025 assert(start_addr < end_addr);
2027 lldb::addr_t start = llvm::alignTo(start_addr, alignment);
2028 while (matches.size() < max_matches && (start + size) < end_addr) {
2033 if (found_addr % alignment) {
2036 start = llvm::alignTo(start + 1, alignment);
2040 matches.emplace_back(found_addr, size);
2041 start = found_addr + alignment;
2047 size_t alignment,
size_t max_matches,
2050 if (buf ==
nullptr) {
2051 error.SetErrorString(
"buffer is null");
2055 error.SetErrorString(
"buffer size is zero");
2058 if (ranges.empty()) {
2059 error.SetErrorString(
"empty ranges");
2062 if (alignment == 0) {
2063 error.SetErrorString(
"alignment must be greater than zero");
2066 if (max_matches == 0) {
2067 error.SetErrorString(
"max_matches must be greater than zero");
2071 int resolved_ranges = 0;
2073 for (
size_t i = 0; i < ranges.size(); ++i) {
2074 if (matches.size() >= max_matches)
2087 DoFindInMemory(start_addr, end_addr, buf, size, matches, alignment,
2091 if (resolved_ranges > 0)
2094 error.SetErrorString(
"unable to resolve any ranges");
2102 if (buf ==
nullptr) {
2103 error.SetErrorString(
"buffer is null");
2107 error.SetErrorString(
"buffer size is zero");
2111 error.SetErrorString(
"range is invalid");
2114 if (alignment == 0) {
2115 error.SetErrorString(
"alignment must be greater than zero");
2123 error.SetErrorString(
"range load address is invalid");
2129 DoFindInMemory(start_addr, end_addr, buf, size, matches, alignment, 1);
2130 if (matches.empty())
2134 return matches[0].GetBaseAddress().GetLoadAddress(&target);
2146 out_str.append(buf, length);
2149 if (length ==
sizeof(buf) - 1)
2150 curr_addr += length;
2154 return out_str.size();
2162 size_t total_cstr_len = 0;
2163 if (dst && dst_max_len) {
2164 result_error.
Clear();
2166 memset(dst, 0, dst_max_len);
2170 size_t bytes_left = dst_max_len - 1;
2171 char *curr_dst = dst;
2173 while (bytes_left > 0) {
2174 addr_t cache_line_bytes_left =
2175 cache_line_size - (curr_addr % cache_line_size);
2177 std::min<addr_t>(bytes_left, cache_line_bytes_left);
2178 size_t bytes_read =
ReadMemory(curr_addr, curr_dst, bytes_to_read,
error);
2180 if (bytes_read == 0) {
2181 result_error =
error;
2182 dst[total_cstr_len] =
'\0';
2185 const size_t len = strlen(curr_dst);
2187 total_cstr_len += len;
2189 if (len < bytes_to_read)
2192 curr_dst += bytes_read;
2193 curr_addr += bytes_read;
2194 bytes_left -= bytes_read;
2200 result_error.
Clear();
2202 return total_cstr_len;
2210 addr = abi_sp->FixAnyAddress(addr);
2212 if (buf ==
nullptr || size == 0)
2215 size_t bytes_read = 0;
2216 uint8_t *bytes = (uint8_t *)buf;
2218 while (bytes_read < size) {
2219 const size_t curr_size = size - bytes_read;
2220 const size_t curr_bytes_read =
2222 bytes_read += curr_bytes_read;
2223 if (curr_bytes_read == curr_size || curr_bytes_read == 0)
2235 size_t integer_byte_size,
2236 uint64_t fail_value,
2246 size_t integer_byte_size,
2268 if (addr_byte_size <= 4)
2269 scalar = (uint32_t)ptr_value;
2278 size_t bytes_written = 0;
2279 const uint8_t *bytes = (
const uint8_t *)buf;
2281 while (bytes_written < size) {
2282 const size_t curr_size = size - bytes_written;
2284 addr + bytes_written, bytes + bytes_written, curr_size,
error);
2285 bytes_written += curr_bytes_written;
2286 if (curr_bytes_written == curr_size || curr_bytes_written == 0)
2289 return bytes_written;
2295 addr = abi_sp->FixAnyAddress(addr);
2297#if defined(ENABLE_MEMORY_CACHING)
2301 if (buf ==
nullptr || size == 0)
2315 if (bp_sites_in_range.
IsEmpty())
2318 const uint8_t *ubuf = (
const uint8_t *)buf;
2319 uint64_t bytes_written = 0;
2321 bp_sites_in_range.
ForEach([
this, addr, size, &bytes_written, &ubuf,
2330 size_t intersect_size;
2331 size_t opcode_offset;
2333 addr, size, &intersect_addr, &intersect_size, &opcode_offset);
2336 assert(addr <= intersect_addr && intersect_addr < addr + size);
2337 assert(addr < intersect_addr + intersect_size &&
2338 intersect_addr + intersect_size <= addr + size);
2339 assert(opcode_offset + intersect_size <= bp->GetByteSize());
2342 const addr_t curr_addr = addr + bytes_written;
2343 if (intersect_addr > curr_addr) {
2346 size_t curr_size = intersect_addr - curr_addr;
2347 size_t curr_bytes_written =
2349 bytes_written += curr_bytes_written;
2350 if (curr_bytes_written != curr_size) {
2354 if (
error.Success())
2355 error.SetErrorToGenericError();
2362 bytes_written += intersect_size;
2366 if (bytes_written < size)
2369 size - bytes_written,
error);
2371 return bytes_written;
2378 if (byte_size > 0) {
2380 const size_t mem_size =
2385 error.SetErrorString(
"failed to get scalar as memory data");
2387 error.SetErrorString(
"invalid scalar value");
2393 bool is_signed,
Scalar &scalar,
2396 if (byte_size == 0) {
2397 error.SetErrorString(
"byte size is zero");
2398 }
else if (byte_size & (byte_size - 1)) {
2399 error.SetErrorStringWithFormat(
"byte size %u is not a power of 2",
2401 }
else if (byte_size <=
sizeof(uval)) {
2403 if (bytes_read == byte_size) {
2408 scalar = data.
GetMaxU32(&offset, byte_size);
2410 scalar = data.
GetMaxU64(&offset, byte_size);
2416 error.SetErrorStringWithFormat(
2417 "byte size of %u is too large for integer scalar type", byte_size);
2424 for (
const auto &
Entry : entries) {
2427 if (!
error.Success())
2433#define USE_ALLOCATE_MEMORY_CACHE 1
2437 error.SetErrorToGenericError();
2441#if defined(USE_ALLOCATE_MEMORY_CACHE)
2447 "Process::AllocateMemory(size=%" PRIu64
2448 ", permissions=%s) => 0x%16.16" PRIx64
2449 " (m_stop_id = %u m_memory_id = %u)",
2453 return allocated_addr;
2460 if (
error.Success()) {
2461 std::string buffer(size, 0);
2473 8, ePermissionsReadable | ePermissionsWritable | ePermissionsExecutable,
2479 "Process::%s pid %" PRIu64
2480 " allocation test passed, CanJIT () is true",
2481 __FUNCTION__,
GetID());
2485 "Process::%s pid %" PRIu64
2486 " allocation test failed, CanJIT () is false: %s",
2507#if defined(USE_ALLOCATE_MEMORY_CACHE)
2509 error.SetErrorStringWithFormat(
2510 "deallocation of memory at 0x%" PRIx64
" failed.", (uint64_t)ptr);
2517 "Process::DeallocateMemory(addr=0x%16.16" PRIx64
2518 ") => err = %s (m_stop_id = %u, m_memory_id = %u)",
2527 return *subclass_override;
2529 bool reported_after =
true;
2532 return reported_after;
2535 if (triple.isMIPS() || triple.isPPC64() || triple.isRISCV() ||
2536 triple.isAArch64() || triple.isArmMClass() || triple.isARM())
2537 reported_after =
false;
2539 return reported_after;
2544 size_t size_to_read) {
2548 "Process::ReadModuleFromMemory reading %s binary from memory",
2554 std::unique_ptr<Progress> progress_up;
2559 progress_up = std::make_unique<Progress>(
2562 ObjectFile *objfile = module_sp->GetMemoryObjectFile(
2563 shared_from_this(), header_addr,
error, size_to_read);
2571 uint32_t &permissions) {
2575 if (!
error.Success())
2588 error.SetErrorString(
"watchpoints are not supported");
2594 error.SetErrorString(
"watchpoints are not supported");
2633 LaunchPrivate(launch_info, state_after_launch, first_stop_event_sp);
2655 if (launch_info.
GetFlags().
Test(eLaunchFlagStopAtEntry))
2687 error.SetErrorString(
"executable module does not exist");
2713 std::string local_exec_file_path = exe_spec_to_use.
GetPath();
2714 return Status(
"file doesn't exist: '%s'", local_exec_file_path.c_str());
2717 const bool restarted =
false;
2726 error.SetErrorString(
"failed to acquire process run lock");
2732 const char *error_string =
error.AsCString();
2733 if (error_string ==
nullptr)
2734 error_string =
"launch failed";
2747 error.SetErrorString(
"failed to catch stop after launch");
2789 return Status(
"Unexpected process state after the launch: %s, expected %s, "
2798 if (
error.Success()) {
2833 LLDB_LOGF(log,
"Process::Halt() failed to stop, state is: %s",
2835 error.SetErrorString(
2836 "Did not get stopped event after loading the core file.");
2874 uint32_t exec_count)
2879 "Process::AttachCompletionHandler::%s process=%p, exec_count=%" PRIu32,
2880 __FUNCTION__,
static_cast<void *
>(process), exec_count);
2889 "Process::AttachCompletionHandler::%s called with state %s (%d)",
2894 return eEventActionSuccess;
2898 return eEventActionRetry;
2909 if (m_exec_count > 0) {
2913 "Process::AttachCompletionHandler::%s state %s: reduced "
2914 "remaining exec count to %" PRIu32
", requesting resume",
2918 return eEventActionRetry;
2921 "Process::AttachCompletionHandler::%s state %s: no more "
2922 "execs expected to start, continuing with attach",
2926 return eEventActionSuccess;
2937 return eEventActionExit;
2942 return eEventActionSuccess;
2951 return m_listener_sp;
2965 bool wait_for_launch) {
2986 sizeof(process_name))) {
2989 if (wait_for_launch) {
2991 if (
error.Success()) {
2994 const bool restarted =
false;
3000 error.SetErrorString(
"failed to acquire process run lock");
3006 if (
error.AsCString() ==
nullptr)
3007 error.SetErrorString(
"attach failed");
3026 platform_sp->FindProcesses(match_info, process_infos);
3027 const uint32_t num_matches = process_infos.size();
3028 if (num_matches == 1) {
3029 attach_pid = process_infos[0].GetProcessID();
3033 process_name,
sizeof(process_name));
3034 if (num_matches > 1) {
3037 for (
size_t i = 0; i < num_matches; i++) {
3038 process_infos[i].DumpAsTableRow(
3039 s, platform_sp->GetUserIDResolver(),
true,
false);
3041 error.SetErrorStringWithFormat(
3042 "more than one process named %s:\n%s", process_name,
3045 error.SetErrorStringWithFormat(
3046 "could not find a process named %s", process_name);
3049 error.SetErrorString(
3050 "invalid platform, can't find processes by name");
3055 error.SetErrorString(
"invalid process name");
3061 if (
error.Success()) {
3066 const bool restarted =
false;
3071 error.SetErrorString(
"failed to acquire process run lock");
3074 if (
error.Success()) {
3082 const char *error_string =
error.AsCString();
3083 if (error_string ==
nullptr)
3084 error_string =
"attach failed";
3095 LLDB_LOGF(log,
"Process::%s()", __FUNCTION__);
3104 "Process::{0} replacing process architecture with DidAttach() "
3105 "architecture: \"{1}\"",
3106 __FUNCTION__, process_arch.
GetTriple().getTriple());
3114 assert(platform_sp);
3118 if (target_arch.
IsValid() && !platform_sp->IsCompatibleArchitecture(
3119 target_arch, process_host_arch,
3123 target_arch, process_host_arch, &platform_arch);
3128 "switching platform to {0} and architecture to {1} based on "
3130 platform_sp->GetName(), platform_arch.
GetTriple().getTriple());
3132 }
else if (!process_arch.
IsValid()) {
3142 "Process::%s switching architecture to %s based on info "
3143 "the platform retrieved for pid %" PRIu64,
3144 __FUNCTION__, process_arch.
GetTriple().getTriple().c_str(),
3164 "after DynamicLoader::DidAttach(), target "
3165 "executable is {0} (using {1} plugin)",
3166 exe_module_sp ? exe_module_sp->GetFileSpec() :
FileSpec(),
3174 if (system_runtime) {
3179 "after SystemRuntime::DidAttach(), target "
3180 "executable is {0} (using {1} plugin)",
3181 exe_module_sp ? exe_module_sp->GetFileSpec() :
FileSpec(),
3199 if (module_sp && module_sp->IsExecutable()) {
3200 if (
GetTarget().GetExecutableModulePointer() != module_sp.get())
3201 new_executable_module_sp = module_sp;
3205 if (new_executable_module_sp) {
3212 "Process::%s after looping through modules, target executable is %s",
3214 exe_module_sp ? exe_module_sp->GetFileSpec().GetPath().c_str()
3231 if (
error.Success()) {
3258 "Process::PrivateResume() m_stop_id = %u, public state: %s "
3259 "private state: %s",
3269 if (
error.Success()) {
3280 error.SetErrorString(
3281 "Process::PrivateResume PreResumeActions failed, not resuming.");
3285 if (
error.Success()) {
3288 LLDB_LOGF(log,
"Process thinks the process has resumed.");
3290 LLDB_LOGF(log,
"Process::PrivateResume() DoResume failed.");
3300 "Process::PrivateResume() asked to simulate a start & stop.");
3306 LLDB_LOGF(log,
"Process::PrivateResume() got an error \"%s\".",
3307 error.AsCString(
"<unknown error>"));
3313 return Status(
"Process is not running.");
3342 halt_listener_sp,
nullptr,
3343 use_run_lock, select_most_relevant);
3357 const uint8_t *buf,
size_t size) {
3358 const size_t region_size = high - low;
3360 if (region_size < size)
3363 std::vector<size_t> bad_char_heuristic(256, size);
3366 for (
size_t idx = 0; idx < size - 1; idx++) {
3367 decltype(bad_char_heuristic)::size_type bcu_idx = buf[idx];
3368 bad_char_heuristic[bcu_idx] = size - idx - 1;
3370 for (
size_t s = 0; s <= (region_size - size);) {
3371 int64_t j = size - 1;
3372 while (j >= 0 && buf[j] == iterator[s + j])
3377 s += bad_char_heuristic[iterator[s + size - 1]];
3392 LLDB_LOGF(log,
"Process::%s() About to stop.", __FUNCTION__);
3402 &exit_event_sp,
true, listener_sp);
3412 LLDB_LOGF(log,
"Process::%s() Process exited while waiting to stop.",
3416 exit_event_sp.reset();
3419 LLDB_LOGF(log,
"Process::%s() failed to stop, state is: %s", __FUNCTION__,
3427 "Attempt to stop the target in order to detach timed out. "
3443 if (
error.Success()) {
3446 if (!
error.Success()) {
3449 }
else if (exit_event_sp) {
3462 if (
error.Success()) {
3473 if (exit_event_sp) {
3508 bool keep_stopped =
false;
3515 if (
error.Success()) {
3532 if (
error.Success()) {
3551 if (exit_event_sp) {
3571 if (
error.Success()) {
3573 if (
error.Success())
3580 assert(signals_sp &&
"null signals_sp");
3600 bool return_value =
true;
3618 return_value =
true;
3622 return_value =
false;
3634 return_value =
true;
3640 return_value =
false;
3653 return_value =
true;
3656 return_value =
false;
3675 "Process::ShouldBroadcastEvent (%p) stopped due to an "
3676 "interrupt, state: %s",
3681 return_value =
true;
3684 bool should_resume =
false;
3696 "Process::ShouldBroadcastEvent: should_resume: %i state: "
3697 "%s was_restarted: %i report_stop_vote: %d.",
3701 switch (report_stop_vote) {
3703 return_value =
true;
3707 return_value =
false;
3711 if (!was_restarted) {
3713 "Process::ShouldBroadcastEvent (%p) Restarting process "
3720 return_value =
true;
3743 "Process::ShouldBroadcastEvent (%p) => new state: %s, last "
3744 "broadcast state: %s - %s",
3747 return_value ?
"YES" :
"NO");
3748 return return_value;
3755 LLDB_LOGF(log,
"Process::%s()%s ", __FUNCTION__,
3756 already_running ?
" already running"
3757 :
" starting private state thread");
3759 if (!is_secondary_thread && already_running)
3764 char thread_name[1024];
3765 uint32_t max_len = llvm::get_max_thread_name_length();
3766 if (max_len > 0 && max_len <= 30) {
3769 if (already_running)
3770 snprintf(thread_name,
sizeof(thread_name),
"intern-state-OV");
3772 snprintf(thread_name,
sizeof(thread_name),
"intern-state");
3774 if (already_running)
3775 snprintf(thread_name,
sizeof(thread_name),
3776 "<lldb.process.internal-state-override(pid=%" PRIu64
")>",
3779 snprintf(thread_name,
sizeof(thread_name),
3780 "<lldb.process.internal-state(pid=%" PRIu64
")>",
GetID());
3783 llvm::Expected<HostThread> private_state_thread =
3786 [
this, is_secondary_thread] {
3790 if (!private_state_thread) {
3792 "failed to launch host thread: {0}");
3796 assert(private_state_thread->IsJoinable());
3817 "Went to stop the private state thread, but it was already invalid.");
3828 LLDB_LOGF(log,
"Process::%s (signal = %d)", __FUNCTION__, signal);
3837 LLDB_LOGF(log,
"Sending control event of type: %d.", signal);
3838 std::shared_ptr<EventDataReceipt> event_receipt_sp(
new EventDataReceipt());
3843 bool receipt_received =
false;
3845 while (!receipt_received) {
3850 if (!receipt_received) {
3867 "Private state thread already dead, no need to signal it to stop.");
3890 LLDB_LOGF(log,
"Ran next event action, result was %d.", action_result);
3892 switch (action_result) {
3918 if (should_broadcast) {
3922 "Process::%s (pid = %" PRIu64
3923 ") broadcasting new state %s (old state %s) to %s",
3926 is_hijacked ?
"hijacked" :
"public");
3933 if (!
GetTarget().GetDebugger().IsForwardingEvents() &&
3938 LLDB_LOGF(log,
"Process::%s updated m_iohandler_sync to %d",
3972 if (is_hijacked || !
GetTarget().GetDebugger().IsHandlingEvents())
3982 "Process::%s (pid = %" PRIu64
3983 ") suppressing state %s (old state %s): should_broadcast == false",
4005 bool control_only =
true;
4008 LLDB_LOGF(log,
"Process::%s (arg = %p, pid = %" PRIu64
") thread starting...",
4009 __FUNCTION__,
static_cast<void *
>(
this),
GetID());
4011 bool exit_now =
false;
4012 bool interrupt_requested =
false;
4018 "Process::%s (arg = %p, pid = %" PRIu64
4019 ") got a control event: %d",
4020 __FUNCTION__,
static_cast<void *
>(
this),
GetID(),
4021 event_sp->GetType());
4023 switch (event_sp->GetType()) {
4029 control_only =
true;
4033 control_only =
false;
4041 "Process::%s (arg = %p, pid = %" PRIu64
4042 ") woke up with an interrupt while attaching - "
4043 "forwarding interrupt.",
4044 __FUNCTION__,
static_cast<void *
>(
this),
GetID());
4055 "Process::%s (arg = %p, pid = %" PRIu64
4056 ") woke up with an interrupt - Halting.",
4057 __FUNCTION__,
static_cast<void *
>(
this),
GetID());
4059 if (
error.Fail() && log)
4061 "Process::%s (arg = %p, pid = %" PRIu64
4062 ") failed to halt the process: %s",
4063 __FUNCTION__,
static_cast<void *
>(
this),
GetID(),
4070 interrupt_requested =
true;
4079 "Process::%s ignoring interrupt as we have already stopped.",
4095 if (interrupt_requested) {
4100 interrupt_requested =
false;
4103 "Process::%s interrupt_requested, but a non-stopped "
4104 "state '%s' received.",
4115 "Process::%s (arg = %p, pid = %" PRIu64
4116 ") about to exit with internal state %s...",
4117 __FUNCTION__,
static_cast<void *
>(
this),
GetID(),
4125 LLDB_LOGF(log,
"Process::%s (arg = %p, pid = %" PRIu64
") thread exiting...",
4126 __FUNCTION__,
static_cast<void *
>(
this),
GetID());
4131 if (!is_secondary_thread)
4142 :
EventData(), m_process_wp(), m_state(state) {
4150 return "Process::ProcessEventData";
4158 bool &found_valid_stopinfo) {
4159 found_valid_stopinfo =
false;
4161 ProcessSP process_sp(m_process_wp.lock());
4165 ThreadList &curr_thread_list = process_sp->GetThreadList();
4166 uint32_t num_threads = curr_thread_list.
GetSize();
4178 std::vector<std::pair<ThreadSP, size_t>> not_suspended_threads;
4179 for (uint32_t idx = 0; idx < num_threads; ++idx) {
4187 not_suspended_threads.emplace_back(thread_sp, thread_sp->GetIndexID());
4195 bool still_should_stop =
false;
4203 for (
auto [thread_sp, thread_index] : not_suspended_threads) {
4204 if (curr_thread_list.
GetSize() != num_threads) {
4208 "Number of threads changed from %u to %u while processing event.",
4209 num_threads, curr_thread_list.
GetSize());
4213 if (thread_sp->GetIndexID() != thread_index) {
4216 "The thread {0} changed from {1} to {2} while processing event.",
4217 thread_sp.get(), thread_index, thread_sp->GetIndexID());
4221 StopInfoSP stop_info_sp = thread_sp->GetStopInfo();
4222 if (stop_info_sp && stop_info_sp->IsValid()) {
4223 found_valid_stopinfo =
true;
4224 bool this_thread_wants_to_stop;
4225 if (stop_info_sp->GetOverrideShouldStop()) {
4226 this_thread_wants_to_stop =
4227 stop_info_sp->GetOverriddenShouldStopValue();
4229 stop_info_sp->PerformAction(event_ptr);
4237 if (stop_info_sp->HasTargetRunSinceMe()) {
4242 this_thread_wants_to_stop = stop_info_sp->ShouldStop(event_ptr);
4245 if (!still_should_stop)
4246 still_should_stop = this_thread_wants_to_stop;
4250 return still_should_stop;
4261 return m_update_state == 1;
4269 ProcessSP process_sp(m_process_wp.lock());
4282 if (m_update_state != 1)
4285 process_sp->SetPublicState(
4292 process_sp->WillPublicStop();
4307 bool does_anybody_have_an_opinion =
false;
4308 bool still_should_stop = ShouldStop(event_ptr, does_anybody_have_an_opinion);
4310 if (GetRestarted()) {
4314 if (!still_should_stop && does_anybody_have_an_opinion) {
4319 process_sp->PrivateResume();
4322 !process_sp->StateChangedIsHijackedForSynchronousResume();
4330 if (process_sp->GetTarget().RunStopHooks())
4337 ProcessSP process_sp(m_process_wp.lock());
4340 s->
Printf(
" process = %p (pid = %" PRIu64
"), ",
4341 static_cast<void *
>(process_sp.get()), process_sp->GetID());
4370 if (data ==
nullptr)
4378 if (data ==
nullptr)
4388 if (data !=
nullptr)
4396 if (data !=
nullptr)
4407 if (data !=
nullptr)
4414 const char *reason) {
4417 if (data !=
nullptr)
4422 const Event *event_ptr) {
4424 if (data ==
nullptr)
4434 if (data !=
nullptr)
4477 auto event_data_sp =
4478 std::make_shared<ProcessEventData>(shared_from_this(),
GetState());
4479 return std::make_shared<Event>(event_type, event_data_sp);
4505 auto data_sp = std::make_shared<EventDataStructuredData>(
4506 shared_from_this(), object_sp, plugin_sp);
4514 return find_it->second;
4525 size_t bytes_available = one_profile_data.size();
4526 if (bytes_available > 0) {
4528 LLDB_LOGF(log,
"Process::GetProfileData (buf = %p, size = %" PRIu64
")",
4529 static_cast<void *
>(buf),
static_cast<uint64_t
>(buf_size));
4530 if (bytes_available > buf_size) {
4531 memcpy(buf, one_profile_data.c_str(), buf_size);
4532 one_profile_data.erase(0, buf_size);
4533 bytes_available = buf_size;
4535 memcpy(buf, one_profile_data.c_str(), bytes_available);
4539 return bytes_available;
4547 if (bytes_available > 0) {
4549 LLDB_LOGF(log,
"Process::GetSTDOUT (buf = %p, size = %" PRIu64
")",
4550 static_cast<void *
>(buf),
static_cast<uint64_t
>(buf_size));
4551 if (bytes_available > buf_size) {
4554 bytes_available = buf_size;
4560 return bytes_available;
4566 if (bytes_available > 0) {
4568 LLDB_LOGF(log,
"Process::GetSTDERR (buf = %p, size = %" PRIu64
")",
4569 static_cast<void *
>(buf),
static_cast<uint64_t
>(buf_size));
4570 if (bytes_available > buf_size) {
4573 bytes_available = buf_size;
4579 return bytes_available;
4585 process->
AppendSTDOUT(
static_cast<const char *
>(src), src_len);
4591 :
IOHandler(process->GetTarget().GetDebugger(),
4594 m_read_file(GetInputFD(),
File::eOpenOptionReadOnly, false),
4595 m_write_file(write_fd,
File::eOpenOptionWriteOnly, false) {
4596 m_pipe.CreateNew(
false);
4602 std::lock_guard<std::mutex> guard(m_mutex);
4603 SetIsDone(!running);
4604 m_is_running = running;
4610 if (!m_read_file.IsValid() || !m_write_file.IsValid() ||
4611 !m_pipe.CanRead() || !m_pipe.CanWrite()) {
4617 const int read_fd = m_read_file.GetDescriptor();
4622 llvm::consumeError(terminal.
SetEcho(
false));
4625 const int pipe_read_fd = m_pipe.GetReadFileDescriptor();
4629 std::lock_guard<std::mutex> guard(m_mutex);
4646 if (m_read_file.Read(&ch, n).Success() && n == 1) {
4647 if (m_write_file.Write(&ch, n).Fail() || n != 1)
4657 if (
error.Success()) {
4662 m_process->SendAsyncInterrupt();
4666 SetIsRunning(
false);
4671 std::lock_guard<std::mutex> guard(m_mutex);
4686 size_t bytes_written = 0;
4687 m_pipe.Write(&ch, 1, bytes_written);
4699 size_t bytes_written = 0;
4700 Status result = m_pipe.Write(&ch, 1, bytes_written);
4713 m_process->SendAsyncInterrupt();
4729 bool m_is_running =
false;
4735 std::make_unique<ConnectionFileDescriptor>(fd,
true));
4746 std::make_shared<IOHandlerProcessSTDIO>(
this, fd);
4762 if (io_handler_sp) {
4764 LLDB_LOGF(log,
"Process::%s pushing IO handler", __FUNCTION__);
4766 io_handler_sp->SetIsDone(
false);
4773 cancel_top_handler);
4799class RestorePlanState {
4802 : m_thread_plan_sp(thread_plan_sp) {
4803 if (m_thread_plan_sp) {
4804 m_private = m_thread_plan_sp->GetPrivate();
4805 m_is_controlling = m_thread_plan_sp->IsControllingPlan();
4806 m_okay_to_discard = m_thread_plan_sp->OkayToDiscard();
4810 ~RestorePlanState() { Clean(); }
4813 if (!m_already_reset && m_thread_plan_sp) {
4814 m_already_reset =
true;
4815 m_thread_plan_sp->SetPrivate(m_private);
4816 m_thread_plan_sp->SetIsControllingPlan(m_is_controlling);
4817 m_thread_plan_sp->SetOkayToDiscard(m_okay_to_discard);
4823 bool m_already_reset =
false;
4824 bool m_private =
false;
4825 bool m_is_controlling =
false;
4826 bool m_okay_to_discard =
false;
4832 const milliseconds default_one_thread_timeout(250);
4837 : default_one_thread_timeout;
4846 return std::min<microseconds>(default_one_thread_timeout,
4852 bool before_first_timeout) {
4858 if (before_first_timeout)
4862 return std::nullopt;
4867static std::optional<ExpressionResults>
4869 RestorePlanState &restorer,
const EventSP &event_sp,
4870 EventSP &event_to_broadcast_sp,
4872 bool handle_interrupts) {
4875 ThreadSP thread_sp = thread_plan_sp->GetTarget()
4878 .FindThreadByID(thread_id);
4881 "The thread on which we were running the "
4882 "expression: tid = {0}, exited while "
4883 "the expression was running.",
4889 if (plan == thread_plan_sp && plan->PlanSucceeded()) {
4890 LLDB_LOG(log,
"execution completed successfully");
4898 StopInfoSP stop_info_sp = thread_sp->GetStopInfo();
4900 stop_info_sp->ShouldNotify(event_sp.get())) {
4901 LLDB_LOG(log,
"stopped for breakpoint: {0}.", stop_info_sp->GetDescription());
4908 thread_plan_sp->SetPrivate(
false);
4909 event_to_broadcast_sp = event_sp;
4914 if (!handle_interrupts &&
4916 return std::nullopt;
4918 LLDB_LOG(log,
"thread plan did not successfully complete");
4920 event_to_broadcast_sp = event_sp;
4933 if (!thread_plan_sp) {
4939 if (!thread_plan_sp->ValidatePlan(
nullptr)) {
4942 "RunThreadPlan called with an invalid thread plan.");
4948 "RunThreadPlan called on wrong process.");
4953 if (thread ==
nullptr) {
4955 "RunThreadPlan called with invalid thread.");
4966 RestorePlanState thread_plan_restorer(thread_plan_sp);
4973 thread_plan_sp->SetPrivate(
false);
4979 thread_plan_sp->SetIsControllingPlan(
true);
4980 thread_plan_sp->SetOkayToDiscard(
false);
4990 "RunThreadPlan called while the private state was not stopped.");
4995 const uint32_t thread_idx_id = thread->
GetIndexID();
4998 if (!selected_frame_sp) {
5001 if (!selected_frame_sp) {
5002 diagnostic_manager.
Printf(
5004 "RunThreadPlan called without a selected frame on thread %d",
5015 "RunThreadPlan called with one thread "
5016 "timeout greater than total timeout");
5020 StackID ctx_frame_id = selected_frame_sp->GetStackID();
5028 uint32_t selected_tid;
5030 if (selected_thread_sp) {
5031 selected_tid = selected_thread_sp->GetIndexID();
5050 LLDB_LOGF(log,
"Running thread plan on private state thread, spinning up "
5051 "another state thread to handle the events.");
5074 thread_plan_sp,
false);
5107 "Process::RunThreadPlan(): Resuming thread %u - 0x%4.4" PRIx64
5108 " to run thread plan \"%s\".",
5109 thread_idx_id, expr_thread_id, s.
GetData());
5116 bool before_first_timeout =
true;
5118 bool do_resume =
true;
5119 bool handle_running_event =
true;
5122 uint32_t num_resumes = 0;
5128 before_first_timeout =
false;
5130 LLDB_LOGF(log,
"Stop others: %u, try all: %u, before_first: %u.\n",
5132 before_first_timeout);
5139 Event *other_events = listener_sp->PeekAtNextEvent();
5140 if (other_events !=
nullptr) {
5143 "RunThreadPlan called with pending events on the queue.");
5156#ifdef LLDB_RUN_THREAD_HALT_WITH_EVENT
5164 bool miss_first_event =
true;
5172 "Top of while loop: do_resume: %i handle_running_event: %i "
5173 "before_first_timeout: %i.",
5174 do_resume, handle_running_event, before_first_timeout);
5176 if (do_resume || handle_running_event) {
5183 if (!resume_error.
Success()) {
5184 diagnostic_manager.
Printf(
5186 "couldn't resume inferior the %d time: \"%s\".", num_resumes,
5197 "Process::RunThreadPlan(): didn't get any event after "
5198 "resume %" PRIu32
", exiting.",
5202 "didn't get any event after resume %" PRIu32
5213 bool restarted =
false;
5220 "Process::RunThreadPlan(): didn't get running event after "
5221 "resume %d, got %s instead (restarted: %i, do_resume: %i, "
5222 "handle_running_event: %i).",
5224 handle_running_event);
5231 const bool clear_thread_plans =
false;
5232 const bool use_run_lock =
false;
5233 Halt(clear_thread_plans, use_run_lock);
5236 diagnostic_manager.
Printf(
5238 "didn't get running event after initial resume, got %s instead.",
5245 log->
PutCString(
"Process::RunThreadPlan(): resuming succeeded.");
5253 log->
PutCString(
"Process::RunThreadPlan(): waiting for next event.");
5257 handle_running_event =
true;
5266 auto now = system_clock::now();
5268 "Process::RunThreadPlan(): about to wait - now is %s - "
5270 llvm::to_string(now).c_str(),
5271 llvm::to_string(now + *timeout).c_str());
5273 LLDB_LOGF(log,
"Process::RunThreadPlan(): about to wait forever.");
5277#ifdef LLDB_RUN_THREAD_HALT_WITH_EVENT
5279 if (miss_first_event) {
5280 std::this_thread::sleep_for(std::chrono::milliseconds(1));
5281 miss_first_event =
false;
5285 got_event = listener_sp->GetEvent(event_sp, timeout);
5289 bool keep_going =
false;
5291 const bool clear_thread_plans =
false;
5292 const bool use_run_lock =
false;
5293 Halt(clear_thread_plans, use_run_lock);
5296 "execution halted by user interrupt.");
5297 LLDB_LOGF(log,
"Process::RunThreadPlan(): Got interrupted by "
5298 "eBroadcastBitInterrupted, exiting.");
5304 "Process::RunThreadPlan(): in while loop, got event: %s.",
5307 switch (stop_state) {
5313 LLDB_LOGF(log,
"Process::RunThreadPlan(): Got a stop and "
5314 "restart, so we'll continue waiting.");
5317 handle_running_event =
true;
5319 const bool handle_interrupts =
true;
5321 expr_thread_id, thread_plan_sp, thread_plan_restorer,
5322 event_sp, event_to_broadcast_sp, options,
5335 handle_running_event =
false;
5340 "Process::RunThreadPlan(): execution stopped with "
5341 "unexpected state: %s.",
5345 event_to_broadcast_sp = event_sp;
5349 "execution stopped with unexpected state.");
5361 log->
PutCString(
"Process::RunThreadPlan(): got_event was true, but "
5362 "the event pointer was null. How odd...");
5374 if (before_first_timeout) {
5376 "Running function with one thread timeout timed out.");
5378 LLDB_LOG(log,
"Restarting function with all threads enabled and "
5379 "timeout: {0} timed out, abandoning execution.",
5382 LLDB_LOG(log,
"Running function with timeout: {0} timed out, "
5383 "abandoning execution.",
5396 bool back_to_top =
true;
5397 uint32_t try_halt_again = 0;
5398 bool do_halt =
true;
5399 const uint32_t num_retries = 5;
5400 while (try_halt_again < num_retries) {
5403 LLDB_LOGF(log,
"Process::RunThreadPlan(): Running Halt.");
5404 const bool clear_thread_plans =
false;
5405 const bool use_run_lock =
false;
5406 Halt(clear_thread_plans, use_run_lock);
5410 log->
PutCString(
"Process::RunThreadPlan(): Halt succeeded.");
5420 "Process::RunThreadPlan(): Stopped with event: %s",
5425 log->
PutCString(
" Event was the Halt interruption event.");
5432 log->
PutCString(
"Process::RunThreadPlan(): Went to halt "
5433 "but got a restarted event, there must be "
5434 "an un-restarted stopped event so try "
5436 "Exiting wait loop.");
5445 const bool handle_interrupts =
false;
5447 expr_thread_id, thread_plan_sp, thread_plan_restorer,
5448 event_sp, event_to_broadcast_sp, options,
5449 handle_interrupts)) {
5450 return_value = *result;
5451 back_to_top =
false;
5457 log->
PutCString(
"Process::RunThreadPlan(): try_all_threads "
5458 "was false, we stopped so now we're "
5461 back_to_top =
false;
5465 if (before_first_timeout) {
5468 before_first_timeout =
false;
5469 thread_plan_sp->SetStopOthers(
false);
5472 "Process::RunThreadPlan(): about to resume.");
5479 log->
PutCString(
"Process::RunThreadPlan(): running all "
5480 "threads timed out.");
5482 back_to_top =
false;
5488 log->
PutCString(
"Process::RunThreadPlan(): halt said it "
5489 "succeeded, but I got no event. "
5490 "I'm getting out of here passing Interrupted.");
5492 back_to_top =
false;
5501 if (!back_to_top || try_halt_again > num_retries)
5510 if (backup_private_state_thread.
IsJoinable()) {
5514 if (stopper_base_plan_sp) {
5525 return return_value;
5531 s.
PutCString(
"Thread state after unsuccessful completion: \n");
5545 thread_plan_sp->RestoreThreadState();
5556 log->
PutCString(
"Process::RunThreadPlan(): Stop event that "
5557 "interrupted us is NULL.");
5562 const char *event_explanation =
nullptr;
5566 event_explanation =
"<no event>";
5569 event_explanation =
"<user interrupt>";
5577 event_explanation =
"<no event data>";
5584 event_explanation =
"<no process>";
5590 uint32_t num_threads = thread_list.
GetSize();
5591 uint32_t thread_index;
5593 ts.
Printf(
"<%u threads> ", num_threads);
5595 for (thread_index = 0; thread_index < num_threads; ++thread_index) {
5607 if (register_context)
5608 ts.
Printf(
"[ip 0x%" PRIx64
"] ", register_context->
GetPC());
5610 ts.
Printf(
"[ip unknown] ");
5616 const char *stop_desc = stop_info_sp->GetDescription();
5623 event_explanation = ts.
GetData();
5627 if (event_explanation)
5629 "Process::RunThreadPlan(): execution interrupted: %s %s",
5630 s.
GetData(), event_explanation);
5632 LLDB_LOGF(log,
"Process::RunThreadPlan(): execution interrupted: %s",
5636 if (should_unwind) {
5638 "Process::RunThreadPlan: ExecutionInterrupted - "
5639 "discarding thread plans up to %p.",
5640 static_cast<void *
>(thread_plan_sp.get()));
5644 "Process::RunThreadPlan: ExecutionInterrupted - for "
5645 "plan: %p not discarding.",
5646 static_cast<void *
>(thread_plan_sp.get()));
5650 log->
PutCString(
"Process::RunThreadPlan(): execution set up error.");
5658 log->
PutCString(
"Process::RunThreadPlan(): thread plan is done");
5663 "Process::RunThreadPlan(): thread plan was discarded");
5668 "Process::RunThreadPlan(): thread plan stopped in mid course");
5671 log->
PutCString(
"Process::RunThreadPlan(): discarding thread plan "
5672 "'cause unwind_on_error is set.");
5690 if (
GetThreadList().SetSelectedThreadByIndexID(selected_tid) &&
5691 selected_stack_id.
IsValid()) {
5693 std::lock_guard<std::recursive_mutex> guard(
GetThreadList().GetMutex());
5699 old_frame_sp.get());
5706 if (event_to_broadcast_sp) {
5708 log->
PutCString(
"Process::RunThreadPlan(): rebroadcasting event.");
5712 return return_value;
5716 const char *result_name =
"<unknown>";
5720 result_name =
"eExpressionCompleted";
5723 result_name =
"eExpressionDiscarded";
5726 result_name =
"eExpressionInterrupted";
5729 result_name =
"eExpressionHitBreakpoint";
5732 result_name =
"eExpressionSetupError";
5735 result_name =
"eExpressionParseError";
5738 result_name =
"eExpressionResultUnavailable";
5741 result_name =
"eExpressionTimedOut";
5744 result_name =
"eExpressionStoppedForDebug";
5747 result_name =
"eExpressionThreadVanished";
5758 strm.
Printf(
"Process %" PRIu64
" exited with status = %i (0x%8.8x) %s\n",
5759 GetID(), exit_status, exit_status,
5760 exit_description ? exit_description :
"");
5763 strm.
Printf(
"Connected to remote target.\n");
5768 strm.
Printf(
"Process %" PRIu64
" is running.\n",
GetID());
5773 bool only_threads_with_stop_reason,
5774 uint32_t start_frame, uint32_t num_frames,
5775 uint32_t num_frames_with_source,
5777 size_t num_thread_infos_dumped = 0;
5784 uint32_t num_threads;
5785 std::vector<lldb::tid_t> thread_id_array;
5788 std::lock_guard<std::recursive_mutex> guard(
GetThreadList().GetMutex());
5790 num_threads = curr_thread_list.
GetSize();
5792 thread_id_array.resize(num_threads);
5793 for (idx = 0; idx < num_threads; ++idx)
5797 for (uint32_t i = 0; i < num_threads; i++) {
5800 if (only_threads_with_stop_reason) {
5801 StopInfoSP stop_info_sp = thread_sp->GetStopInfo();
5802 if (!stop_info_sp || !stop_info_sp->IsValid())
5805 thread_sp->GetStatus(strm, start_frame, num_frames,
5806 num_frames_with_source,
5808 ++num_thread_infos_dumped;
5811 LLDB_LOGF(log,
"Process::GetThreadStatus - thread 0x" PRIu64
5812 " vanished while running Thread::GetStatus.");
5815 return num_thread_infos_dumped;
5839 result = this_result;
5911 "Setting Process code address mask to {0:x}", code_address_mask);
5917 "Setting Process data address mask to {0:x}", data_address_mask);
5923 "Setting Process highmem code address mask to {0:x}",
5930 "Setting Process highmem data address mask to {0:x}",
5937 addr = abi_sp->FixCodeAddress(addr);
5943 addr = abi_sp->FixDataAddress(addr);
5949 addr = abi_sp->FixAnyAddress(addr);
5955 LLDB_LOGF(log,
"Process::%s()", __FUNCTION__);
5990 if (address ==
nullptr) {
5991 error.SetErrorString(
"Invalid address argument");
5998 std::map<addr_t, addr_t>::const_iterator iter =
6001 function_addr = (*iter).second;
6005 error.SetErrorStringWithFormat(
6006 "Unable to call resolver for indirect function %s",
6011 function_addr = abi_sp->FixCodeAddress(function_addr);
6013 std::pair<addr_t, addr_t>(addr, function_addr));
6016 return function_addr;
6032 runtime.second->ModulesDidLoad(module_list);
6038 runtime->ModulesDidLoad(module_list);
6049 pair.second->ModulesDidLoad(*
this, module_list);
6073 if (plugins[language])
6075 sc.
module_sp->ReportWarningUnsupportedLanguage(
6086 return platform_sp->GetProcessInfo(
GetID(), info);
6095 if (!memory_history) {
6099 threads = std::make_shared<ThreadCollection>(
6100 memory_history->GetHistoryThreads(addr));
6107 InstrumentationRuntimeCollection::iterator pos;
6112 return (*pos).second;
6117 module_spec.
Clear();
6144 Address retval = default_stop_addr;
6148 if (!default_stop_addr.
IsValid())
6151 const char *plugin_name =
nullptr;
6152 const char *flavor =
nullptr;
6155 if (disassembler_sp)
6156 insn_list = &disassembler_sp->GetInstructionList();
6158 if (insn_list ==
nullptr) {
6162 size_t insn_offset =
6169 insn_offset,
false ,
nullptr);
6174 if (branch_index > insn_offset) {
6175 Address next_branch_insn_address =
6177 if (next_branch_insn_address.
IsValid() &&
6179 retval = next_branch_insn_address;
6189 load_addr = abi->FixAnyAddress(load_addr);
6199 region_list.clear();
6205 region_list.clear();
6216 region_list.push_back(std::move(region_info));
6224 !(abi && (abi->FixAnyAddress(range_end) != range_end)));
6235 return Status(
"unimplemented");
6243 if (supported_type_names.
GetSize() == 0) {
6244 LLDB_LOG(log,
"no structured data types supported");
6249 std::set<llvm::StringRef> type_names;
6252 "the process supports the following async structured data types:");
6261 const llvm::StringRef type_name =
object->GetStringValue();
6262 if (type_name.empty())
6265 type_names.insert(type_name);
6275 for (uint32_t plugin_index = 0; !type_names.empty(); plugin_index++) {
6276 auto create_instance =
6279 if (!create_instance)
6291 std::vector<llvm::StringRef> names_to_remove;
6292 for (llvm::StringRef type_name : type_names) {
6293 if (plugin_sp->SupportsStructuredDataType(type_name)) {
6295 std::make_pair(type_name, plugin_sp));
6296 names_to_remove.push_back(type_name);
6297 LLDB_LOG(log,
"using plugin {0} for type name {1}",
6298 plugin_sp->GetPluginName(), type_name);
6303 for (llvm::StringRef type_name : names_to_remove)
6304 type_names.erase(type_name);
6321 llvm::StringRef type_name;
6333 find_it->second->HandleArrivalOfStructuredData(*
this, type_name, object_sp);
6345 llvm::function_ref<std::unique_ptr<UtilityFunction>()> factory) {
6346 if (platform !=
GetTarget().GetPlatform().get())
6355 return llvm::createStringError(llvm::inconvertibleErrorCode(),
6356 "Can't trace a non-live process.");
6357 return llvm::make_error<UnimplementedError>();
6362 bool trap_exceptions) {
6364 if (thread ==
nullptr || address ==
nullptr)
6376 auto type_system_or_err =
6378 if (!type_system_or_err) {
6379 llvm::consumeError(type_system_or_err.takeError());
6382 auto ts = *type_system_or_err;
6388 *thread, *address, void_ptr_type, llvm::ArrayRef<addr_t>(), options));
6400 call_plan_sp->GetReturnValueObject()->GetValueAsUnsigned(
6422 if (!arch || !tag_manager) {
6423 return llvm::createStringError(
6424 llvm::inconvertibleErrorCode(),
6425 "This architecture does not support memory tagging");
6429 return llvm::createStringError(llvm::inconvertibleErrorCode(),
6430 "Process does not support memory tagging");
6436llvm::Expected<std::vector<lldb::addr_t>>
6438 llvm::Expected<const MemoryTagManager *> tag_manager_or_err =
6440 if (!tag_manager_or_err)
6441 return tag_manager_or_err.takeError();
6444 llvm::Expected<std::vector<uint8_t>> tag_data =
6447 return tag_data.takeError();
6454 const std::vector<lldb::addr_t> &tags) {
6455 llvm::Expected<const MemoryTagManager *> tag_manager_or_err =
6457 if (!tag_manager_or_err)
6458 return Status(tag_manager_or_err.takeError());
6461 llvm::Expected<std::vector<uint8_t>> packed_tags =
6464 return Status(packed_tags.takeError());
6485 if (!dirty_page_list)
6491 llvm::AddressRange range(0, 0);
6492 for (
addr_t page_addr : *dirty_page_list) {
6493 if (range.empty()) {
6495 range = llvm::AddressRange(page_addr, page_addr + page_size);
6497 if (range.end() == page_addr) {
6499 range = llvm::AddressRange(range.start(), page_addr + page_size);
6503 ranges.push_back({range, lldb_permissions});
6504 range = llvm::AddressRange(page_addr, page_addr + page_size);
6510 ranges.push_back({range, lldb_permissions});
6537 const bool try_dirty_pages =
true;
6546 StackFrameSP frame_sp = thread_sp->GetStackFrameAtIndex(0);
6552 const addr_t sp = reg_ctx_sp->GetSP();
6553 const size_t red_zone = process.
GetABI()->GetRedZoneSize();
6556 const size_t stack_head = (
sp - red_zone);
6561 AddRegion(sp_region, try_dirty_pages, ranges);
6571 std::set<addr_t> &stack_ends) {
6574const bool try_dirty_pages =
false;
6575 for (
const auto ®ion : regions)
6576 if (stack_ends.count(region.GetRange().GetRangeEnd()) == 0)
6577 AddRegion(region, try_dirty_pages, ranges);
6589 bool have_dirty_page_info =
false;
6590 for (
const auto ®ion : regions) {
6591 if (stack_ends.count(region.GetRange().GetRangeEnd()) == 0 &&
6593 have_dirty_page_info =
true;
6596 if (!have_dirty_page_info) {
6599 const bool try_dirty_pages =
false;
6600 for (
const auto ®ion : regions)
6601 if (stack_ends.count(region.GetRange().GetRangeEnd()) == 0 &&
6603 AddRegion(region, try_dirty_pages, ranges);
6618 const bool try_dirty_pages =
true;
6622 for (
const auto ®ion : regions) {
6624 if (stack_ends.count(region.GetRange().GetRangeEnd()) == 0 &&
6626 AddRegion(region, try_dirty_pages, ranges);
6636 if (regions.empty())
6637 return Status(
"failed to get any valid memory regions from the process");
6639 return Status(
"callers must set the core_style to something other than "
6640 "eSaveCoreUnspecified");
6642 std::set<addr_t> stack_ends;
6645 switch (core_style) {
6666 return Status(
"no valid address ranges found for core style");
6675 if (low_memory_addr_bits == 0 && high_memory_addr_bits == 0)
6678 if (low_memory_addr_bits != 0) {
6685 if (high_memory_addr_bits != 0) {
static llvm::raw_ostream & error(Stream &strm)
#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 void SaveOffRegionsWithStackPointers(Process &process, const MemoryRegionInfos ®ions, Process::CoreFileMemoryRanges &ranges, std::set< addr_t > &stack_ends)
static std::optional< ExpressionResults > HandleStoppedEvent(lldb::tid_t thread_id, const ThreadPlanSP &thread_plan_sp, RestorePlanState &restorer, const EventSP &event_sp, EventSP &event_to_broadcast_sp, const EvaluateExpressionOptions &options, bool handle_interrupts)
static void GetCoreFileSaveRangesStackOnly(Process &process, const MemoryRegionInfos ®ions, Process::CoreFileMemoryRanges &ranges, std::set< addr_t > &stack_ends)
static constexpr OptionEnumValueElement g_follow_fork_mode_values[]
static void GetCoreFileSaveRangesFull(Process &process, const MemoryRegionInfos ®ions, Process::CoreFileMemoryRanges &ranges, std::set< addr_t > &stack_ends)
static void GetCoreFileSaveRangesDirtyOnly(Process &process, const MemoryRegionInfos ®ions, Process::CoreFileMemoryRanges &ranges, std::set< addr_t > &stack_ends)
static Timeout< std::micro > GetExpressionTimeout(const EvaluateExpressionOptions &options, bool before_first_timeout)
static microseconds GetOneThreadExpressionTimeout(const EvaluateExpressionOptions &options)
static Process::CoreFileMemoryRange CreateCoreFileMemoryRange(const MemoryRegionInfo ®ion)
static void AddRegion(const MemoryRegionInfo ®ion, bool try_dirty_pages, Process::CoreFileMemoryRanges &ranges)
static bool AddDirtyPages(const MemoryRegionInfo ®ion, Process::CoreFileMemoryRanges &ranges)
#define LLDB_SCOPED_TIMER()
void SetIsRunning(bool running)
~IOHandlerProcessSTDIO() override=default
bool Interrupt() override
IOHandlerProcessSTDIO(Process *process, int write_fd)
A windows-based implementation of Pipe, a class that abtracts unix style pipes.
ProcessExperimentalOptionValueProperties()
const lldb::addr_t m_base_addr
ProcessMemoryIterator(Process &process, lldb::addr_t base)
uint8_t operator[](lldb::addr_t offset)
const Property * GetPropertyAtIndex(size_t idx, const ExecutionContext *exe_ctx) const override
ProcessOptionValueProperties(llvm::StringRef name)
lldb_private::Status Select()
void FDSetRead(lldb::socket_t fd)
bool FDIsSetRead(lldb::socket_t fd) const
static lldb::ABISP FindPlugin(lldb::ProcessSP process_sp, const ArchSpec &arch)
A section + offset based address range class.
Address & GetBaseAddress()
Get accessor for the base address of the range.
bool ContainsFileAddress(const Address &so_addr) const
Check if a section offset address is contained in this range.
lldb::addr_t GetByteSize() const
Get accessor for the byte size of this range.
A section + offset based address class.
lldb::addr_t GetLoadAddress(Target *target) const
Get the load address.
lldb::addr_t GetOpcodeLoadAddress(Target *target, AddressClass addr_class=AddressClass::eInvalid) const
Get the load address as an opcode load address.
bool IsValid() const
Check if the object state is valid.
Symbol * CalculateSymbolContextSymbol() const
A class which holds the metadata from a remote stub/corefile note about how many bits are used for ad...
uint32_t GetHighmemAddressableBits() const
static lldb::addr_t AddressableBitToMask(uint32_t addressable_bits)
uint32_t GetLowmemAddressableBits() const
lldb::addr_t AllocateMemory(size_t byte_size, uint32_t permissions, Status &error)
void Clear(bool deallocate_memory)
bool DeallocateMemory(lldb::addr_t ptr)
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.
bool IsCompatibleMatch(const ArchSpec &rhs) const
Shorthand for IsMatch(rhs, CompatibleMatch).
bool IsExactMatch(const ArchSpec &rhs) const
Shorthand for IsMatch(rhs, ExactMatch).
lldb::ByteOrder GetByteOrder() const
Returns the byte order for the architecture specification.
virtual const MemoryTagManager * GetMemoryTagManager() const
A command line argument class.
Class that manages the actual breakpoint that will be inserted into the running program.
BreakpointSite::Type GetType() const
void SetType(BreakpointSite::Type type)
bool IntersectsRange(lldb::addr_t addr, size_t size, lldb::addr_t *intersect_addr, size_t *intersect_size, size_t *opcode_offset) const
Says whether addr and size size intersects with the address intersect_addr.
uint8_t * GetTrapOpcodeBytes()
Returns the Opcode Bytes for this breakpoint.
uint8_t * GetSavedOpcodeBytes()
Gets the original instruction bytes that were overwritten by the trap.
bool IsHardware() const override
bool IsEnabled() const
Tells whether the current breakpoint site is enabled or not.
void SetEnabled(bool enabled)
Sets whether the current breakpoint site is enabled or not.
An event broadcasting class.
lldb::ListenerSP GetPrimaryListener()
void RestoreBroadcaster()
Restore the state of the Broadcaster from a previous hijack attempt.
void SetEventName(uint32_t event_mask, const char *name)
Set the name for an event bit.
bool HijackBroadcaster(const lldb::ListenerSP &listener_sp, uint32_t event_mask=UINT32_MAX)
Provides a simple mechanism to temporarily redirect events from broadcaster.
void BroadcastEventIfUnique(lldb::EventSP &event_sp)
void SetPrimaryListener(lldb::ListenerSP listener_sp)
const char * GetHijackingListenerName()
void BroadcastEvent(lldb::EventSP &event_sp)
Broadcast an event which has no associated data.
bool IsHijackedForEvent(uint32_t event_mask)
void CheckInWithManager()
A class that implements CRTP-based "virtual constructor" idiom.
bool IsConnected() const
Check if the connection is valid.
Generic representation of a type in a programming language.
CompilerType GetBasicTypeFromAST(lldb::BasicType basic_type) const
Create related types using the current type's AST.
CompilerType GetPointerType() const
Return a new CompilerType that is a pointer to this type.
std::string GetString() const
Get the string value as a std::string.
const char * AsCString(const char *value_if_empty=nullptr) const
Get the string value as a C string.
A class to manage flag bits.
static lldb::TargetSP FindTargetWithProcessID(lldb::pid_t pid)
StreamFile & GetErrorStream()
TargetList & GetTargetList()
Get accessor for the target list.
bool IsTopIOHandler(const lldb::IOHandlerSP &reader_sp)
bool RemoveIOHandler(const lldb::IOHandlerSP &reader_sp)
Remove the given IO handler if it's currently active.
void RunIOHandlerAsync(const lldb::IOHandlerSP &reader_sp, bool cancel_top_handler=true)
Run the given IO handler and return immediately.
lldb::StreamSP GetAsyncErrorStream()
PlatformList & GetPlatformList()
lldb::ListenerSP GetListener()
size_t void PutString(lldb::Severity severity, llvm::StringRef str)
size_t Printf(lldb::Severity severity, const char *format,...) __attribute__((format(printf
static lldb::DisassemblerSP DisassembleRange(const ArchSpec &arch, const char *plugin_name, const char *flavor, Target &target, const AddressRange &disasm_range, bool force_live_memory=false)
Encapsulates dynamic check functions used by expressions.
A plug-in interface definition class for dynamic loaders.
virtual void DidAttach()=0
Called after attaching a process.
virtual void DidLaunch()=0
Called after launching a process.
static DynamicLoader * FindPlugin(Process *process, llvm::StringRef plugin_name)
Find a dynamic loader plugin for a given process.
void SetUnwindOnError(bool unwind=false)
bool GetStopOthers() const
bool DoesIgnoreBreakpoints() const
bool IsForUtilityExpr() const
bool GetTryAllThreads() const
void SetTrapExceptions(bool b)
void SetTryAllThreads(bool try_others=true)
void SetTimeout(const Timeout< std::micro > &timeout)
void SetStopOthers(bool stop_others=true)
bool DoesUnwindOnError() const
const Timeout< std::micro > & GetTimeout() const
void SetIgnoreBreakpoints(bool ignore=false)
const Timeout< std::micro > & GetOneThreadTimeout() const
virtual llvm::StringRef GetFlavor() const =0
"lldb/Target/ExecutionContext.h" A class that contains an execution context.
void SetFrameSP(const lldb::StackFrameSP &frame_sp)
Set accessor to set only the frame shared pointer.
void SetProcessPtr(Process *process)
Set accessor to set only the process shared pointer from a process pointer.
void SetThreadPtr(Thread *thread)
Set accessor to set only the thread shared pointer from a thread pointer.
void SetTargetPtr(Target *target)
Set accessor to set only the target shared pointer from a target pointer.
void SetFramePtr(StackFrame *frame)
Set accessor to set only the frame shared pointer from a frame pointer.
Process * GetProcessPtr() const
Returns a pointer to the process object.
Thread * GetThreadPtr() const
Returns a pointer to the thread object.
const ConstString & GetFilename() const
Filename 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.
static FileSystem & Instance()
An abstract base class for files.
bool Test(ValueType bit) const
Test a single flag bit.
bool GetIsOptimized()
Get whether compiler optimizations were enabled for this function.
Status Join(lldb::thread_result_t *result)
bool EqualsThread(lldb::thread_t thread) const
static lldb::thread_t GetCurrentThread()
Get the thread token (the one returned by ThreadCreate when the thread was created) for the calling t...
uint32_t GetIndexOfInstructionAtAddress(const Address &addr)
lldb::InstructionSP GetInstructionAtIndex(size_t idx) const
uint32_t GetIndexOfNextBranchInstruction(uint32_t start, bool ignore_calls, bool *found_calls) const
Get the index of the next branch instruction.
static void ModulesDidLoad(lldb_private::ModuleList &module_list, Process *process, InstrumentationRuntimeCollection &runtimes)
Class used by the Process to hold a list of its JITLoaders.
void ModulesDidLoad(ModuleList &module_list)
static void LoadPlugins(Process *process, lldb_private::JITLoaderList &list)
Find a JIT loader plugin for a given process.
virtual lldb::LanguageType GetLanguageType() const =0
static LanguageRuntime * FindPlugin(Process *process, lldb::LanguageType language)
virtual bool CouldHaveDynamicValue(ValueObject &in_value)=0
static lldb::LanguageType GetPrimaryLanguage(lldb::LanguageType language)
static std::set< lldb::LanguageType > GetSupportedLanguages()
static lldb::ListenerSP MakeListener(const char *name)
void PutCString(const char *cstr)
void PutString(llvm::StringRef str)
uint32_t GetMemoryCacheLineSize() const
bool RemoveInvalidRange(lldb::addr_t base_addr, lldb::addr_t byte_size)
void Flush(lldb::addr_t addr, size_t size)
void Clear(bool clear_invalid_ranges=false)
size_t Read(lldb::addr_t addr, void *dst, size_t dst_len, Status &error)
void AddInvalidRange(lldb::addr_t base_addr, lldb::addr_t byte_size)
static lldb::MemoryHistorySP FindPlugin(const lldb::ProcessSP process)
OptionalBool GetWritable() const
OptionalBool GetMapped() const
int GetPageSize() const
Get the target system's VM page size in bytes.
uint32_t GetLLDBPermissions() const
const std::optional< std::vector< lldb::addr_t > > & GetDirtyPageList() const
Get a vector of target VM pages that are dirty – that have been modified – within this memory region.
OptionalBool GetReadable() const
OptionalBool GetExecutable() const
virtual llvm::Expected< std::vector< lldb::addr_t > > UnpackTagsData(const std::vector< uint8_t > &tags, size_t granules=0) const =0
virtual lldb::addr_t GetGranuleSize() const =0
virtual llvm::Expected< std::vector< uint8_t > > PackTags(const std::vector< lldb::addr_t > &tags) const =0
virtual int32_t GetAllocationTagType() const =0
A collection class for Module objects.
A class that describes an executable image and its associated object and symbol files.
const FileSpec & GetFileSpec() const
Get const accessor for the module file specification.
A plug-in interface definition class for object file parsers.
A plug-in interface definition class for halted OS helpers.
virtual lldb::ThreadSP CreateThread(lldb::tid_t tid, lldb::addr_t context)
static OperatingSystem * FindPlugin(Process *process, const char *plugin_name)
Find a halted OS plugin for a given process.
virtual bool UpdateThreadList(ThreadList &old_thread_list, ThreadList &real_thread_list, ThreadList &new_thread_list)=0
auto GetPropertyAtIndexAs(size_t idx, const ExecutionContext *exe_ctx=nullptr) const
Property * ProtectedGetPropertyAtIndex(size_t idx)
bool SetPropertyAtIndex(size_t idx, T t, const ExecutionContext *exe_ctx=nullptr) const
static lldb::OptionValuePropertiesSP CreateLocalCopy(const Properties &global_properties)
virtual llvm::StringRef GetPluginName()=0
static ProcessCreateInstance GetProcessCreateCallbackAtIndex(uint32_t idx)
static ProcessCreateInstance GetProcessCreateCallbackForPluginName(llvm::StringRef name)
static StructuredDataPluginCreateInstance GetStructuredDataPluginCreateCallbackAtIndex(uint32_t idx)
static LanguageSet GetAllTypeSystemSupportedLanguagesForTypes()
void SetValue(T value, PredicateBroadcastType broadcast_type)
Value set accessor.
T GetValue() const
Value get accessor.
std::optional< T > WaitForValueNotEqualTo(T value, const Timeout< std::micro > &timeout=std::nullopt)
Wait for m_value to not be equal to value.
uint32_t GetResumeCount() const
lldb::ListenerSP GetListenerForProcess(Debugger &debugger)
bool GetWaitForLaunch() const
ProcessExperimentalProperties()
lldb::pid_t GetProcessID() const
FileSpec & GetExecutableFile()
bool IsScriptedProcess() const
ArchSpec & GetArchitecture()
void SetNameMatchType(NameMatch name_match_type)
ProcessInstanceInfo & GetProcessInfo()
static void DumpTableHeader(Stream &s, bool show_args, bool verbose)
void SetRunningUserExpression(bool on)
uint32_t GetMemoryID() const
void SetStopEventForLastNaturalStopID(lldb::EventSP event_sp)
uint32_t GetStopID() const
bool IsRunningUtilityFunction() const
bool IsLastResumeForUserExpression() const
void SetRunningUtilityFunction(bool on)
bool GetDetachKeepsStopped() const
bool GetSteppingRunsAllThreads() const
void SetStopOnSharedLibraryEvents(bool stop)
Args GetExtraStartupCommands() const
std::unique_ptr< ProcessExperimentalProperties > m_experimental_properties_up
FollowForkMode GetFollowForkMode() const
uint32_t GetVirtualAddressableBits() const
~ProcessProperties() override
void SetIgnoreBreakpointsInExpressions(bool ignore)
bool GetUnwindOnErrorInExpressions() const
std::chrono::seconds GetInterruptTimeout() const
bool GetDisableLangRuntimeUnwindPlans() const
void SetDetachKeepsStopped(bool keep_stopped)
void SetDisableLangRuntimeUnwindPlans(bool disable)
std::chrono::seconds GetUtilityExpressionTimeout() const
void SetVirtualAddressableBits(uint32_t bits)
bool GetStopOnSharedLibraryEvents() const
void SetHighmemVirtualAddressableBits(uint32_t bits)
void SetOSPluginReportsAllThreads(bool does_report)
bool GetWarningsOptimization() const
void SetUnwindOnErrorInExpressions(bool ignore)
bool GetDisableMemoryCache() const
FileSpec GetPythonOSPluginPath() const
bool GetStopOnExec() const
void SetPythonOSPluginPath(const FileSpec &file)
void SetExtraStartupCommands(const Args &args)
bool GetOSPluginReportsAllThreads() const
bool GetWarningsUnsupportedLanguage() const
uint32_t GetHighmemVirtualAddressableBits() const
bool GetIgnoreBreakpointsInExpressions() const
uint64_t GetMemoryCacheLineSize() const
ProcessProperties(lldb_private::Process *process)
A class used to prevent the process from starting while other threads are accessing its data,...
EventActionResult HandleBeingInterrupted() override
const char * GetExitString() override
EventActionResult PerformAction(lldb::EventSP &event_sp) override
AttachCompletionHandler(Process *process, uint32_t exec_count)
lldb::ProcessWP m_process_wp
static bool GetRestartedFromEvent(const Event *event_ptr)
virtual bool ShouldStop(Event *event_ptr, bool &found_valid_stopinfo)
void SetUpdateStateOnRemoval()
static void AddRestartedReason(Event *event_ptr, const char *reason)
void SetInterrupted(bool new_value)
lldb::ProcessSP GetProcessSP() const
void SetRestarted(bool new_value)
static void SetRestartedInEvent(Event *event_ptr, bool new_value)
static lldb::ProcessSP GetProcessFromEvent(const Event *event_ptr)
static void SetInterruptedInEvent(Event *event_ptr, bool new_value)
bool ForwardEventToPendingListeners(Event *event_ptr) override
This will be queried for a Broadcaster with a primary and some secondary listeners after the primary ...
llvm::StringRef GetFlavor() const override
~ProcessEventData() override
bool GetInterrupted() const
bool GetRestarted() const
size_t GetNumRestartedReasons()
static bool GetInterruptedFromEvent(const Event *event_ptr)
const char * GetRestartedReasonAtIndex(size_t idx)
static bool SetUpdateStateOnRemoval(Event *event_ptr)
static lldb::StateType GetStateFromEvent(const Event *event_ptr)
lldb::StateType GetState() const
static const Process::ProcessEventData * GetEventDataFromEvent(const Event *event_ptr)
static llvm::StringRef GetFlavorString()
void DoOnRemoval(Event *event_ptr) override
void Dump(Stream *s) const override
A plug-in interface definition class for debugging a process.
virtual Status EnableBreakpointSite(BreakpointSite *bp_site)
Status WillAttachToProcessWithName(const char *process_name, bool wait_for_launch)
Called before attaching to a process.
virtual llvm::Expected< TraceSupportedResponse > TraceSupported()
Get the processor tracing type supported for this process.
lldb::IOHandlerSP m_process_input_reader
friend class ProcessProperties
UtilityFunction * GetLoadImageUtilityFunction(Platform *platform, llvm::function_ref< std::unique_ptr< UtilityFunction >()> factory)
Get the cached UtilityFunction that assists in loading binary images into the process.
virtual Status DoSignal(int signal)
Sends a process a UNIX signal signal.
virtual Status WillResume()
Called before resuming to a process.
std::mutex m_process_input_reader_mutex
lldb::addr_t m_code_address_mask
Mask for code an data addresses.
StopPointSiteList< lldb_private::BreakpointSite > & GetBreakpointSiteList()
std::vector< lldb::addr_t > m_image_tokens
@ eBroadcastBitStructuredData
@ eBroadcastBitStateChanged
@ eBroadcastBitProfileData
bool PrivateStateThreadIsValid() const
virtual Status DoHalt(bool &caused_stop)
Halts a running process.
virtual void DidLaunch()
Called after launching a process.
virtual Status DisableSoftwareBreakpoint(BreakpointSite *bp_site)
lldb::pid_t GetID() const
Returns the pid of the process or LLDB_INVALID_PROCESS_ID if there is no known pid.
lldb::break_id_t CreateBreakpointSite(const lldb::BreakpointLocationSP &owner, bool use_hardware)
virtual Status WillSignal()
Called before sending a signal to a process.
void ResetImageToken(size_t token)
lldb::JITLoaderListUP m_jit_loaders_up
lldb::addr_t CallocateMemory(size_t size, uint32_t permissions, Status &error)
The public interface to allocating memory in the process, this also clears the allocated memory.
void SetNextEventAction(Process::NextEventAction *next_event_action)
Status Destroy(bool force_kill)
Kills the process and shuts down all threads that were spawned to track and monitor the process.
virtual Status WillDetach()
Called before detaching from a process.
virtual Status DoLaunch(Module *exe_module, ProcessLaunchInfo &launch_info)
Launch a new process.
StopPointSiteList< lldb_private::BreakpointSite > m_breakpoint_site_list
This is the list of breakpoint locations we intend to insert in the target.
void ControlPrivateStateThread(uint32_t signal)
ThreadList & GetThreadList()
void SetAddressableBitMasks(AddressableBits bit_masks)
void ClearPreResumeActions()
virtual DataExtractor GetAuxvData()
enum lldb_private::Process::@31 m_can_jit
Process(lldb::TargetSP target_sp, lldb::ListenerSP listener_sp)
Construct with a shared pointer to a target, and the Process listener.
lldb::ExpressionResults RunThreadPlan(ExecutionContext &exe_ctx, lldb::ThreadPlanSP &thread_plan_sp, const EvaluateExpressionOptions &options, DiagnosticManager &diagnostic_manager)
void PrintWarningUnsupportedLanguage(const SymbolContext &sc)
Print a user-visible warning about a function written in a language that this version of LLDB doesn't...
lldb::StateType GetPrivateState()
Status LaunchPrivate(ProcessLaunchInfo &launch_info, lldb::StateType &state, lldb::EventSP &event_sp)
std::vector< std::string > m_profile_data
bool m_can_interpret_function_calls
Status Resume()
Resumes all of a process's threads as configured using the Thread run control functions.
void PruneThreadPlans()
Prune ThreadPlanStacks for all unreported threads.
void SetUnixSignals(lldb::UnixSignalsSP &&signals_sp)
std::string m_stdout_data
Remember if stdin must be forwarded to remote debug server.
bool RemoveInvalidMemoryRange(const LoadRange ®ion)
uint32_t GetNextThreadIndexID(uint64_t thread_id)
Status PrivateResume()
The "private" side of resuming a process.
void SetDynamicCheckers(DynamicCheckerFunctions *dynamic_checkers)
void AddInvalidMemoryRegion(const LoadRange ®ion)
virtual void ModulesDidLoad(ModuleList &module_list)
InstrumentationRuntimeCollection m_instrumentation_runtimes
std::atomic< bool > m_destructing
virtual Status DoGetMemoryRegionInfo(lldb::addr_t load_addr, MemoryRegionInfo &range_info)
DoGetMemoryRegionInfo is called by GetMemoryRegionInfo after it has removed non address bits from loa...
int GetExitStatus()
Get the exit status for a process.
OperatingSystem * GetOperatingSystem()
Status WillAttachToProcessWithID(lldb::pid_t pid)
Called before attaching to a process.
virtual Status DoDetach(bool keep_stopped)
Detaches from a running or stopped process.
std::unique_ptr< UtilityFunction > m_dlopen_utility_func_up
void SetRunningUtilityFunction(bool on)
void DisableAllBreakpointSites()
int64_t ReadSignedIntegerFromMemory(lldb::addr_t load_addr, size_t byte_size, int64_t fail_value, Status &error)
Address AdvanceAddressToNextBranchInstruction(Address default_stop_addr, AddressRange range_bounds)
Find the next branch instruction to set a breakpoint on.
virtual bool GetLoadAddressPermissions(lldb::addr_t load_addr, uint32_t &permissions)
Attempt to get the attributes for a region of memory in the process.
static bool HandleProcessStateChangedEvent(const lldb::EventSP &event_sp, Stream *stream, SelectMostRelevant select_most_relevant, bool &pop_process_io_handler)
Centralize the code that handles and prints descriptions for process state changes.
virtual size_t GetAsyncProfileData(char *buf, size_t buf_size, Status &error)
Get any available profile data.
lldb::addr_t FixDataAddress(lldb::addr_t pc)
lldb::addr_t AllocateMemory(size_t size, uint32_t permissions, Status &error)
The public interface to allocating memory in the process.
std::unique_ptr< NextEventAction > m_next_event_action_up
void SetHighmemDataAddressMask(lldb::addr_t data_address_mask)
bool PruneThreadPlansForTID(lldb::tid_t tid)
Prune ThreadPlanStacks for unreported threads.
virtual void DidDetach()
Called after detaching from a process.
void PausePrivateStateThread()
HostThread m_private_state_thread
Thread ID for the thread that watches internal state events.
Status EnableBreakpointSiteByID(lldb::user_id_t break_id)
size_t ReadMemoryFromInferior(lldb::addr_t vm_addr, void *buf, size_t size, Status &error)
Read of memory from a process.
size_t ReadScalarIntegerFromMemory(lldb::addr_t addr, uint32_t byte_size, bool is_signed, Scalar &scalar, Status &error)
virtual Status Launch(ProcessLaunchInfo &launch_info)
Launch a new process.
std::mutex m_run_thread_plan_lock
static void SettingsInitialize()
void BroadcastStructuredData(const StructuredData::ObjectSP &object_sp, const lldb::StructuredDataPluginSP &plugin_sp)
Broadcasts the given structured data object from the given plugin.
void Flush()
Flush all data in the process.
bool m_clear_thread_plans_on_stop
virtual Status DoResume()
Resumes all of a process's threads as configured using the Thread run control functions.
ProcessRunLock m_public_run_lock
size_t ReadCStringFromMemory(lldb::addr_t vm_addr, char *cstr, size_t cstr_max_len, Status &error)
Read a NULL terminated C string from memory.
void ResumePrivateStateThread()
void SendAsyncInterrupt()
void MapSupportedStructuredDataPlugins(const StructuredData::Array &supported_type_names)
Loads any plugins associated with asynchronous structured data and maps the relevant supported type n...
bool GetEventsPrivate(lldb::EventSP &event_sp, const Timeout< std::micro > &timeout, bool control_only)
lldb::ABISP m_abi_sp
This is the current signal set for this process.
virtual void DidSignal()
Called after sending a signal to a process.
virtual SystemRuntime * GetSystemRuntime()
Get the system runtime plug-in for this process.
std::map< uint64_t, uint32_t > m_thread_id_to_index_id_map
bool DumpThreadPlansForTID(Stream &strm, lldb::tid_t tid, lldb::DescriptionLevel desc_level, bool internal, bool condense_trivial, bool skip_unreported_plans)
Dump the thread plans associated with thread with tid.
lldb::ListenerSP m_private_state_listener_sp
uint32_t m_extended_thread_stop_id
The natural stop id when extended_thread_list was last updated.
static constexpr llvm::StringRef ResumeSynchronousHijackListenerName
bool WritePointerToMemory(lldb::addr_t vm_addr, lldb::addr_t ptr_value, Status &error)
QueueList m_queue_list
The list of libdispatch queues at a given stop point.
void ClearPreResumeAction(PreResumeActionCallback callback, void *baton)
virtual Status WillDestroy()
lldb::ThreadSP CreateOSPluginThread(lldb::tid_t tid, lldb::addr_t context)
std::vector< PreResumeCallbackAndBaton > m_pre_resume_actions
void SetCanJIT(bool can_jit)
Sets whether executing JIT-compiled code in this process is possible.
lldb::StateType GetStateChangedEventsPrivate(lldb::EventSP &event_sp, const Timeout< std::micro > &timeout)
void LoadOperatingSystemPlugin(bool flush)
lldb::StructuredDataPluginSP GetStructuredDataPlugin(llvm::StringRef type_name) const
Returns the StructuredDataPlugin associated with a given type name, if there is one.
lldb::DynamicLoaderUP m_dyld_up
AddressRanges FindRangesInMemory(const uint8_t *buf, uint64_t size, const AddressRanges &ranges, size_t alignment, size_t max_matches, Status &error)
virtual bool GetModuleSpec(const FileSpec &module_file_spec, const ArchSpec &arch, ModuleSpec &module_spec)
Try to fetch the module specification for a module with the given file name and architecture.
virtual size_t DoWriteMemory(lldb::addr_t vm_addr, const void *buf, size_t size, Status &error)
Actually do the writing of memory to a process.
virtual Status WriteObjectFile(std::vector< ObjectFile::LoadableData > entries)
std::recursive_mutex m_stdio_communication_mutex
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.
StopPointSiteList< lldb_private::WatchpointResource > m_watchpoint_resource_list
Watchpoint resources currently in use.
Status DisableBreakpointSiteByID(lldb::user_id_t break_id)
llvm::Expected< const MemoryTagManager * > GetMemoryTagManager()
If this architecture and process supports memory tagging, return a tag manager that can be used to ma...
~Process() override
Destructor.
virtual Status DoWriteMemoryTags(lldb::addr_t addr, size_t len, int32_t type, const std::vector< uint8_t > &tags)
Does the final operation to write memory tags.
std::recursive_mutex m_profile_data_comm_mutex
lldb::InstrumentationRuntimeSP GetInstrumentationRuntime(lldb::InstrumentationRuntimeType type)
Status ResumeSynchronous(Stream *stream)
Resume a process, and wait for it to stop.
lldb::addr_t FixAnyAddress(lldb::addr_t pc)
Use this method when you do not know, or do not care what kind of address you are fixing.
lldb::thread_result_t RunPrivateStateThread(bool is_secondary_thread)
virtual Status DoWillLaunch(Module *module)
Called before launching to a process.
virtual Status ConnectRemote(llvm::StringRef remote_url)
Attach to a remote system via a URL.
void AppendSTDOUT(const char *s, size_t len)
llvm::StringMap< lldb::StructuredDataPluginSP > m_structured_data_plugin_map
virtual Status DisableBreakpointSite(BreakpointSite *bp_site)
size_t GetThreadStatus(Stream &ostrm, bool only_threads_with_stop_reason, uint32_t start_frame, uint32_t num_frames, uint32_t num_frames_with_source, bool stop_format)
void CalculateExecutionContext(ExecutionContext &exe_ctx) override
Reconstruct the object's execution context into sc.
virtual size_t ReadMemory(lldb::addr_t vm_addr, void *buf, size_t size, Status &error)
Read of memory from a process.
Event * PeekAtStateChangedEvents()
std::vector< Notifications > m_notifications
The list of notifications that this process can deliver.
bool HasAssignedIndexIDToThread(uint64_t sb_thread_id)
ThreadSafeValue< lldb::StateType > m_private_state
void StopPrivateStateThread()
size_t AddImageToken(lldb::addr_t image_ptr)
virtual void DoFindInMemory(lldb::addr_t start_addr, lldb::addr_t end_addr, const uint8_t *buf, size_t size, AddressRanges &matches, size_t alignment, size_t max_matches)
virtual bool DestroyRequiresHalt()
lldb::EventSP CreateEventFromProcessState(uint32_t event_type)
lldb::TargetSP CalculateTarget() override
void SetHighmemCodeAddressMask(lldb::addr_t code_address_mask)
lldb::ByteOrder GetByteOrder() const
Status Detach(bool keep_stopped)
Detaches from a running or stopped process.
void UpdateThreadListIfNeeded()
virtual llvm::Expected< std::vector< lldb::addr_t > > ReadMemoryTags(lldb::addr_t addr, size_t len)
Read memory tags for the range addr to addr+len.
virtual void DidResume()
Called after resuming a process.
virtual void DidExec()
Called after a process re-execs itself.
void SetCodeAddressMask(lldb::addr_t code_address_mask)
AllocatedMemoryCache m_allocated_memory_cache
virtual Status LoadCore()
@ eBroadcastInternalStateControlResume
@ eBroadcastInternalStateControlStop
@ eBroadcastInternalStateControlPause
std::mutex m_exit_status_mutex
Mutex so m_exit_status m_exit_string can be safely accessed from multiple threads.
Status Signal(int signal)
Sends a process a UNIX signal signal.
void SetDynamicLoader(lldb::DynamicLoaderUP dyld)
ThreadPlanStackMap m_thread_plans
This is the list of thread plans for threads in m_thread_list, as well as threads we knew existed,...
std::recursive_mutex m_thread_mutex
virtual Status ConfigureStructuredData(llvm::StringRef type_name, const StructuredData::ObjectSP &config_sp)
Configure asynchronous structured data feature.
virtual Status DoWillAttachToProcessWithName(const char *process_name, bool wait_for_launch)
Called before attaching to a process.
bool StartPrivateStateThread(bool is_secondary_thread=false)
void HandlePrivateEvent(lldb::EventSP &event_sp)
void BroadcastAsyncProfileData(const std::string &one_profile_data)
lldb::StateType GetState()
Get accessor for the current process state.
virtual Status DoWillAttachToProcessWithID(lldb::pid_t pid)
Called before attaching to a process.
ProcessRunLock & GetRunLock()
virtual Status DoLoadCore()
Predicate< uint32_t > m_iohandler_sync
LanguageRuntimeCollection m_language_runtimes
Should we detach if the process object goes away with an explicit call to Kill or Detach?
virtual Status GetMemoryRegions(lldb_private::MemoryRegionInfos ®ion_list)
Obtain all the mapped memory regions within this process.
size_t WriteMemoryPrivate(lldb::addr_t addr, const void *buf, size_t size, Status &error)
void GetStatus(Stream &ostrm)
void SetRunningUserExpression(bool on)
bool IsPossibleDynamicValue(ValueObject &in_value)
static bool SetProcessExitStatus(lldb::pid_t pid, bool exited, int signo, int status)
Static function that can be used with the host function Host::StartMonitoringChildProcess ().
void RemoveConstituentFromBreakpointSite(lldb::user_id_t site_id, lldb::user_id_t constituent_id, lldb::BreakpointSiteSP &bp_site_sp)
lldb::addr_t FindInMemory(lldb::addr_t low, lldb::addr_t high, const uint8_t *buf, size_t size)
Find a pattern within a memory region.
lldb::OperatingSystemUP m_os_up
uint32_t GetLastNaturalStopID() const
lldb::StateType WaitForProcessToStop(const Timeout< std::micro > &timeout, lldb::EventSP *event_sp_ptr=nullptr, bool wait_always=true, lldb::ListenerSP hijack_listener=lldb::ListenerSP(), Stream *stream=nullptr, bool use_run_lock=true, SelectMostRelevant select_most_relevant=DoNoSelectMostRelevantFrame)
lldb::UnixSignalsSP m_unix_signals_sp
bool StateChangedIsHijackedForSynchronousResume()
const char * GetExitDescription()
Get a textual description of what the process exited.
void SetPublicState(lldb::StateType new_state, bool restarted)
void SetDataAddressMask(lldb::addr_t data_address_mask)
virtual Status DoConnectRemote(llvm::StringRef remote_url)
Attach to a remote system via a URL.
bool() PreResumeActionCallback(void *)
uint64_t ReadUnsignedIntegerFromMemory(lldb::addr_t load_addr, size_t byte_size, uint64_t fail_value, Status &error)
Reads an unsigned integer of the specified byte size from process memory.
llvm::once_flag m_dlopen_utility_func_flag_once
virtual void UpdateQueueListIfNeeded()
virtual Status UpdateAutomaticSignalFiltering()
virtual lldb::addr_t GetImageInfoAddress()
Get the image information address for the current process.
std::map< lldb::addr_t, lldb::addr_t > m_resolved_indirect_addresses
This helps with the Public event coalescing in ShouldBroadcastEvent.
virtual Status DoAttachToProcessWithID(lldb::pid_t pid, const ProcessAttachInfo &attach_info)
Attach to an existing process using a process ID.
void SetCanRunCode(bool can_run_code)
Sets whether executing code in this process is possible.
Status ClearBreakpointSiteByID(lldb::user_id_t break_id)
virtual Status EnableSoftwareBreakpoint(BreakpointSite *bp_site)
void AppendSTDERR(const char *s, size_t len)
bool GetShouldDetach() const
static llvm::StringRef GetStaticBroadcasterClass()
Status CalculateCoreFileSaveRanges(lldb::SaveCoreStyle core_style, CoreFileMemoryRanges &ranges)
Helper function for Process::SaveCore(...) that calculates the address ranges that should be saved.
uint32_t m_thread_index_id
Each thread is created with a 1 based index that won't get re-used.
bool ProcessIOHandlerExists() const
bool RouteAsyncStructuredData(const StructuredData::ObjectSP object_sp)
Route the incoming structured data dictionary to the right plugin.
virtual void DidDestroy()
lldb::addr_t ReadPointerFromMemory(lldb::addr_t vm_addr, Status &error)
static const char * ExecutionResultAsCString(lldb::ExpressionResults result)
Broadcaster m_private_state_control_broadcaster
lldb::addr_t GetHighmemCodeAddressMask()
The highmem masks are for targets where we may have different masks for low memory versus high memory...
bool PushProcessIOHandler()
size_t RemoveBreakpointOpcodesFromBuffer(lldb::addr_t addr, size_t size, uint8_t *buf) const
Broadcaster m_private_state_broadcaster
virtual bool DetachRequiresHalt()
virtual bool IsAlive()
Check if a process is still alive.
bool m_destroy_in_process
ThreadList m_thread_list_real
The threads for this process as are known to the protocol we are debugging with.
ThreadSafeValue< lldb::StateType > m_public_state
lldb::addr_t m_data_address_mask
virtual ArchSpec GetSystemArchitecture()
Get the system architecture for this process.
Status DeallocateMemory(lldb::addr_t ptr)
The public interface to deallocating memory in the process.
virtual Status DisableWatchpoint(lldb::WatchpointSP wp_sp, bool notify=true)
void RegisterNotificationCallbacks(const Process::Notifications &callbacks)
Register for process and thread notifications.
virtual void DidAttach(ArchSpec &process_arch)
Called after attaching a process.
virtual lldb::addr_t ResolveIndirectFunction(const Address *address, Status &error)
Resolve dynamically loaded indirect functions.
lldb::StateType m_last_broadcast_state
LanguageRuntime * GetLanguageRuntime(lldb::LanguageType language)
ProcessModID m_mod_id
Tracks the state of the process over stops and other alterations.
void SetID(lldb::pid_t new_pid)
Sets the stored pid.
virtual JITLoaderList & GetJITLoaders()
uint32_t AssignIndexIDToThread(uint64_t thread_id)
virtual bool SetExitStatus(int exit_status, llvm::StringRef exit_string)
Set accessor for the process exit status (return code).
uint32_t m_queue_list_stop_id
The natural stop id when queue list was last fetched.
void PrintWarningOptimization(const SymbolContext &sc)
Print a user-visible warning about a module being built with optimization.
ProcessRunLock m_private_run_lock
virtual std::optional< bool > DoGetWatchpointReportedAfter()
Provide an override value in the subclass for lldb's CPU-based logic for whether watchpoint exception...
static ProcessProperties & GetGlobalProperties()
lldb::addr_t m_highmem_code_address_mask
lldb::addr_t GetImagePtrFromToken(size_t token) const
int m_exit_status
The exit status of the process, or -1 if not set.
std::vector< LanguageRuntime * > GetLanguageRuntimes()
MemoryCache m_memory_cache
static void STDIOReadThreadBytesReceived(void *baton, const void *src, size_t src_len)
virtual bool GetProcessInfo(ProcessInstanceInfo &info)
virtual void DidHalt()
Called after halting a process.
lldb::addr_t FixCodeAddress(lldb::addr_t pc)
Some targets might use bits in a code address to indicate a mode switch, ARM uses bit zero to signify...
lldb::StateType WaitForProcessStopPrivate(lldb::EventSP &event_sp, const Timeout< std::micro > &timeout)
void RestoreProcessEvents()
Restores the process event broadcasting to its normal state.
virtual bool SupportsMemoryTagging()
Check whether the process supports memory tagging.
void DumpThreadPlans(Stream &strm, lldb::DescriptionLevel desc_level, bool internal, bool condense_trivial, bool skip_unreported_plans)
Dump all the thread plans for this process.
uint32_t GetAddressByteSize() const
uint32_t GetStopID() const
void SetPrivateState(lldb::StateType state)
lldb::addr_t m_highmem_data_address_mask
virtual Status DoDestroy()=0
Status StopForDestroyOrDetach(lldb::EventSP &exit_event_sp)
bool GetWatchpointReportedAfter()
Whether lldb will be notified about watchpoints after the instruction has completed executing,...
lldb::StateType GetNextEvent(lldb::EventSP &event_sp)
virtual bool DoUpdateThreadList(ThreadList &old_thread_list, ThreadList &new_thread_list)=0
Update the thread list following process plug-in's specific logic.
virtual llvm::Expected< std::vector< uint8_t > > DoReadMemoryTags(lldb::addr_t addr, size_t len, int32_t type)
Does the final operation to read memory tags.
bool StateChangedIsExternallyHijacked()
bool RunPreResumeActions()
bool PopProcessIOHandler()
virtual size_t GetSTDERR(char *buf, size_t buf_size, Status &error)
Get any available STDERR.
size_t WriteMemory(lldb::addr_t vm_addr, const void *buf, size_t size, Status &error)
Write memory to a process.
virtual llvm::Expected< bool > SaveCore(llvm::StringRef outfile)
Save core dump into the specified file.
bool ProcessIOHandlerIsActive()
Status DestroyImpl(bool force_kill)
bool m_force_next_event_delivery
lldb::SystemRuntimeUP m_system_runtime_up
virtual Status WillHalt()
Called before halting to a process.
bool ShouldBroadcastEvent(Event *event_ptr)
This is the part of the event handling that for a process event.
virtual DynamicLoader * GetDynamicLoader()
Get the dynamic loader plug-in for this process.
std::string m_exit_string
A textual description of why a process exited.
lldb::DynamicCheckerFunctionsUP m_dynamic_checkers_up
The functions used by the expression parser to validate data that expressions use.
void SyncIOHandler(uint32_t iohandler_id, const Timeout< std::micro > &timeout)
Waits for the process state to be running within a given msec timeout.
void ForceNextEventDelivery()
ThreadPlanStack * FindThreadPlans(lldb::tid_t tid)
Find the thread plan stack associated with thread with tid.
std::vector< CoreFileMemoryRange > CoreFileMemoryRanges
void SetSTDIOFileDescriptor(int file_descriptor)
virtual Status Attach(ProcessAttachInfo &attach_info)
Attach to an existing process using the process attach info.
virtual void Finalize(bool destructing)
This object is about to be destroyed, do any necessary cleanup.
lldb::addr_t GetDataAddressMask()
void SynchronouslyNotifyStateChanged(lldb::StateType state)
bool CanJIT()
Determines whether executing JIT-compiled code in this process is possible.
virtual Status DoAttachToProcessWithName(const char *process_name, const ProcessAttachInfo &attach_info)
Attach to an existing process using a partial process name.
ThreadList m_thread_list
The threads for this process as the user will see them.
bool UpdateThreadList(ThreadList &old_thread_list, ThreadList &new_thread_list)
Update the thread list.
const lldb::UnixSignalsSP & GetUnixSignals()
Status WriteMemoryTags(lldb::addr_t addr, size_t len, const std::vector< lldb::addr_t > &tags)
Write memory tags for a range of memory.
virtual size_t DoReadMemory(lldb::addr_t vm_addr, void *buf, size_t size, Status &error)=0
Actually do the reading of memory from a process.
virtual bool IsLiveDebugSession() const
std::weak_ptr< Target > m_target_wp
The target that owns this process.
virtual void DoDidExec()
Subclasses of Process should implement this function if they need to do anything after a process exec...
virtual void RefreshStateAfterStop()=0
Currently called as part of ShouldStop.
lldb::addr_t GetCodeAddressMask()
Get the current address mask in the Process.
bool UnregisterNotificationCallbacks(const Process::Notifications &callbacks)
Unregister for process and thread notifications.
bool HijackProcessEvents(lldb::ListenerSP listener_sp)
If you need to ensure that you and only you will hear about some public event, then make a new listen...
virtual Status DoDeallocateMemory(lldb::addr_t ptr)
Actually deallocate memory in the process.
Status GetMemoryRegionInfo(lldb::addr_t load_addr, MemoryRegionInfo &range_info)
Locate the memory region that contains load_addr.
static void SettingsTerminate()
lldb::addr_t GetHighmemDataAddressMask()
ThreadList m_extended_thread_list
Constituent for extended threads that may be generated, cleared on natural stops.
bool CallVoidArgVoidPtrReturn(const Address *address, lldb::addr_t &returned_func, bool trap_exceptions=false)
bool CurrentThreadIsPrivateStateThread()
void AddPreResumeAction(PreResumeActionCallback callback, void *baton)
size_t GetSoftwareBreakpointTrapOpcode(BreakpointSite *bp_site)
Status Halt(bool clear_thread_plans=false, bool use_run_lock=true)
Halts a running process.
const lldb::ABISP & GetABI()
Status WillLaunch(Module *module)
Called before launching to a process.
lldb::ModuleSP ReadModuleFromMemory(const FileSpec &file_spec, lldb::addr_t header_addr, size_t size_to_read=512)
size_t WriteScalarToMemory(lldb::addr_t vm_addr, const Scalar &scalar, size_t size, Status &error)
Write all or part of a scalar value to memory.
virtual size_t GetSTDOUT(char *buf, size_t buf_size, Status &error)
Get any available STDOUT.
lldb::ThreadCollectionSP GetHistoryThreads(lldb::addr_t addr)
lldb::StateType GetStateChangedEvents(lldb::EventSP &event_sp, const Timeout< std::micro > &timeout, lldb::ListenerSP hijack_listener)
ThreadedCommunication m_stdio_communication
virtual lldb::addr_t DoAllocateMemory(size_t size, uint32_t permissions, Status &error)
Actually allocate memory in the process.
std::atomic< bool > m_finalizing
This is set at the beginning of Process::Finalize() to stop functions from looking up or creating thi...
std::recursive_mutex m_language_runtimes_mutex
std::string m_stderr_data
Target & GetTarget()
Get the target object pointer for this module.
virtual Status EnableWatchpoint(lldb::WatchpointSP wp_sp, bool notify=true)
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
uint32_t GetSize()
Get the number of libdispatch queues that are available.
void Clear()
Clear out the list of queues from the QueueList.
uint64_t GetPC(uint64_t fail_value=LLDB_INVALID_ADDRESS)
size_t GetByteSize() const
bool SignExtend(uint32_t bit_pos)
unsigned long long ULongLong(unsigned long long fail_value=0) const
size_t GetAsMemoryData(void *dst, size_t dst_len, lldb::ByteOrder dst_byte_order, Status &error) const
long long SLongLong(long long fail_value=0) const
This base class provides an interface to stack frames.
void CalculateExecutionContext(ExecutionContext &exe_ctx) override
Reconstruct the object's execution context into sc.
void Clear()
Clear the object state.
bool Fail() const
Test for error condition.
const char * AsCString(const char *default_error_str="unknown error") const
Get the error string associated with the current error.
void SetErrorString(llvm::StringRef err_str)
Set the current error string to err_str.
bool Success() const
Test for success condition.
static lldb::ValueObjectSP GetCrashingDereference(lldb::StopInfoSP &stop_info_sp, lldb::addr_t *crashing_address=nullptr)
StopPointSite::SiteID Add(const StopPointSiteSP &site_sp)
Add a site to the list.
void ForEach(std::function< void(StopPointSite *)> const &callback)
bool FindInRange(lldb::addr_t lower_bound, lldb::addr_t upper_bound, StopPointSiteList &bp_site_list) const
StopPointSiteSP FindByID(typename StopPointSite::SiteID site_id)
Returns a shared pointer to the site with id site_id.
bool Remove(typename StopPointSite::SiteID site_id)
Removes the site given by site_id from this list.
StopPointSiteSP FindByAddress(lldb::addr_t addr)
Returns a shared pointer to the site at address addr.
bool RemoveByAddress(lldb::addr_t addr)
Removes the site at address addr from this list.
lldb::break_id_t GetID() const
virtual lldb::addr_t GetLoadAddress() const
uint32_t GetByteSize() const
const char * GetData() const
llvm::StringRef GetString() const
A stream class that can stream formatted output to a file.
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.
bool ForEach(std::function< bool(Object *object)> const &foreach_callback) const
bool GetValueForKeyAsString(llvm::StringRef key, llvm::StringRef &result) const
Dictionary * GetAsDictionary()
std::shared_ptr< Object > ObjectSP
Defines a symbol context baton that can be handed other debug core functions.
lldb::LanguageType GetLanguage() const
Function * function
The Function for a given query.
lldb::ModuleSP module_sp
The Module for a given query.
lldb::addr_t GetLoadAddress(Target *target) const
ConstString GetName() const
Address GetAddress() const
A plug-in interface definition class for system runtimes.
virtual void DidAttach()
Called after attaching to a process.
void ModulesDidLoad(const ModuleList &module_list) override
Called when modules have been loaded in the process.
virtual void DidLaunch()
Called after launching a process.
static SystemRuntime * FindPlugin(Process *process)
Find a system runtime plugin for a given process.
uint32_t GetIndexOfTarget(lldb::TargetSP target_sp) const
lldb::TargetSP GetSelectedTarget()
bool SetPreferDynamicValue(lldb::DynamicValueType d)
bool GetUseFastStepping() const
lldb::DynamicValueType GetPreferDynamicValue() const
void SetFirstPrivateStopTime()
void SetFirstPublicStopTime()
Module * GetExecutableModulePointer()
void UpdateSignalsFromDummy(lldb::UnixSignalsSP signals_sp, lldb::StreamSP warning_stream_sp)
Updates the signals in signals_sp using the stored dummy signals.
void ClearModules(bool delete_locations)
Architecture * GetArchitecturePlugin() const
TargetStats & GetStatistics()
bool SetArchitecture(const ArchSpec &arch_spec, bool set_platform=false, bool merge=true)
Set the architecture for this target.
llvm::Expected< lldb::TypeSystemSP > GetScratchTypeSystemForLanguage(lldb::LanguageType language, bool create_on_demand=true)
lldb::ModuleSP GetExecutableModule()
Gets the module for the main executable.
void DidExec()
Called as the last function in Process::DidExec().
Status Install(ProcessLaunchInfo *launch_info)
lldb::PlatformSP GetPlatform()
const ArchSpec & GetArchitecture() const
void SetExecutableModule(lldb::ModuleSP &module_sp, LoadDependentFiles load_dependent_files=eLoadDependentsDefault)
Set the main executable module.
void SetPlatform(const lldb::PlatformSP &platform_sp)
A RAII-friendly terminal state saving/restoring class.
llvm::Error SetEcho(bool enabled)
llvm::Error SetCanonical(bool enabled)
virtual ThreadIterable Threads()
static llvm::Expected< HostThread > LaunchThread(llvm::StringRef name, std::function< lldb::thread_result_t()> thread_function, size_t min_stack_byte_size=0)
lldb::ThreadSP GetSelectedThread()
bool ShouldStop(Event *event_ptr)
Vote ShouldReportStop(Event *event_ptr)
uint32_t GetStopID() const
uint32_t GetSize(bool can_update=true)
bool SetSelectedThreadByID(lldb::tid_t tid, bool notify=false)
lldb::ThreadSP FindThreadByIndexID(uint32_t index_id, bool can_update=true)
Vote ShouldReportRun(Event *event_ptr)
void SetStopID(uint32_t stop_id)
lldb::ThreadSP GetThreadAtIndex(uint32_t idx, bool can_update=true)
std::recursive_mutex & GetMutex() const override
lldb::ThreadSP GetExpressionExecutionThread()
void DiscardThreadPlans()
void Update(ThreadList &rhs)
Precondition: both thread lists must be belong to the same process.
bool WillResume()
The thread list asks tells all the threads it is about to resume.
void SetShouldReportStop(Vote vote)
void ClearThreadCache()
Clear the Thread* cache that each ThreadPlan contains.
void DumpPlans(Stream &strm, lldb::DescriptionLevel desc_level, bool internal, bool ignore_boring, bool skip_unreported)
bool PrunePlansForTID(lldb::tid_t tid)
ThreadPlanStack * Find(lldb::tid_t tid)
void Update(ThreadList ¤t_threads, bool delete_missing, bool check_for_new=true)
bool DumpPlansForTID(Stream &strm, lldb::tid_t tid, lldb::DescriptionLevel desc_level, bool internal, bool ignore_boring, bool skip_unreported)
void SetValue(const T &value)
const T & GetValueNoLock() const
void SetValueNoLock(const T &value)
std::recursive_mutex & GetMutex()
bool IsThreadPlanDone(ThreadPlan *plan) const
Checks whether the given plan is in the completed plans for this stop.
virtual lldb::StackFrameSP GetStackFrameAtIndex(uint32_t idx)
Status QueueThreadPlan(lldb::ThreadPlanSP &plan_sp, bool abort_other_plans)
Queues a generic thread plan.
bool WasThreadPlanDiscarded(ThreadPlan *plan) const
Checks whether the given plan is in the discarded plans for this stop.
virtual lldb::RegisterContextSP GetRegisterContext()=0
static void SettingsInitialize()
virtual lldb::StopInfoSP GetPrivateStopInfo(bool calculate=true)
uint32_t GetIndexID() const
size_t GetStackFrameStatus(Stream &strm, uint32_t first_frame, uint32_t num_frames, bool show_frame_info, uint32_t num_frames_with_source)
lldb::StackFrameSP GetSelectedFrame(SelectMostRelevant select_most_relevant)
uint32_t SetSelectedFrame(lldb_private::StackFrame *frame, bool broadcast=false)
static void SettingsTerminate()
virtual lldb::StackFrameSP GetFrameWithStackID(const StackID &stack_id)
void DiscardThreadPlansUpToPlan(lldb::ThreadPlanSP &up_to_plan_sp)
Discards the plans queued on the plan stack of the current thread up to and including up_to_plan_sp.
static ThreadProperties & GetGlobalProperties()
void SetConnection(std::unique_ptr< Connection > connection) override
Sets the connection that it to be used by this class.
virtual bool StopReadThread(Status *error_ptr=nullptr)
Stops the read thread by cancelling it.
void SynchronizeWithReadThread()
Wait for the read thread to process all outstanding data.
lldb::ConnectionStatus Disconnect(Status *error_ptr=nullptr) override
Disconnect the communications connection if one is currently connected.
virtual bool StartReadThread(Status *error_ptr=nullptr)
Starts a read thread whose sole purpose it to read bytes from the current connection.
void SetReadThreadBytesReceivedCallback(ReadThreadBytesReceived callback, void *callback_baton)
RAII guard that should be acquired when an utility function is called within a given process.
"lldb/Expression/UtilityFunction.h" Encapsulates a bit of source code that provides a function that i...
@ eGetExpressionPathFormatHonorPointers
lldb::LanguageType GetObjectRuntimeLanguage()
#define LLDB_INVALID_BREAK_ID
#define LLDB_INVALID_ADDRESS_MASK
Address Mask Bits not used for addressing are set to 1 in the mask; all mask bits set is an invalid v...
#define LLDB_INVALID_THREAD_ID
#define UNUSED_IF_ASSERT_DISABLED(x)
#define LLDB_INVALID_IMAGE_TOKEN
#define LLDB_INVALID_ADDRESS
#define LLDB_INVALID_PROCESS_ID
@ DoNoSelectMostRelevantFrame
@ SelectMostRelevantFrame
A class that represents a running process on the host machine.
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
void RegisterVerboseTrapFrameRecognizer(Process &process)
bool StateIsStoppedState(lldb::StateType state, bool must_exist)
Check if a state represents a state where the process or thread is stopped.
void RegisterAssertFrameRecognizer(Process *process)
Registers the assert stack frame recognizer.
bool StateIsRunningState(lldb::StateType state)
Check if a state represents a state where the process or thread is running.
lldb::ProcessSP(* ProcessCreateInstance)(lldb::TargetSP target_sp, lldb::ListenerSP listener_sp, const FileSpec *crash_file_path, bool can_connect)
@ eBroadcastAlways
Always send a broadcast when the value is modified.
const char * StateAsCString(lldb::StateType state)
Converts a StateType to a C string.
std::vector< ProcessInstanceInfo > ProcessInstanceInfoList
const char * GetPermissionsAsCString(uint32_t permissions)
static uint32_t bits(const uint32_t val, const uint32_t msbit, const uint32_t lsbit)
std::shared_ptr< lldb_private::OptionValueProperties > OptionValuePropertiesSP
std::shared_ptr< lldb_private::ThreadPlan > ThreadPlanSP
std::shared_ptr< lldb_private::ABI > ABISP
std::shared_ptr< lldb_private::StackFrame > StackFrameSP
std::shared_ptr< lldb_private::BreakpointSite > BreakpointSiteSP
std::shared_ptr< lldb_private::BreakpointLocation > BreakpointLocationSP
DescriptionLevel
Description levels for "void GetDescription(Stream *, DescriptionLevel)" calls.
@ eDescriptionLevelVerbose
std::shared_ptr< lldb_private::IOHandler > IOHandlerSP
std::shared_ptr< lldb_private::Thread > ThreadSP
std::shared_ptr< lldb_private::ValueObject > ValueObjectSP
std::shared_ptr< lldb_private::UnixSignals > UnixSignalsSP
std::shared_ptr< lldb_private::Platform > PlatformSP
StateType
Process and Thread States.
@ eStateUnloaded
Process is object is valid, but not currently loaded.
@ eStateConnected
Process is connected to remote debug services, but not launched or attached to anything yet.
@ eStateDetached
Process has been detached and can't be examined.
@ eStateStopped
Process or thread is stopped and can be examined.
@ eStateSuspended
Process or thread is in a suspended state as far as the debugger is concerned while other processes o...
@ eStateRunning
Process or thread is running and can't be examined.
@ eStateLaunching
Process is in the process of launching.
@ eStateAttaching
Process is currently trying to attach.
@ eStateExited
Process has exited and can't be examined.
@ eStateStepping
Process or thread is in the process of stepping and can not be examined.
@ eStateCrashed
Process or thread has crashed and can be examined.
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::MemoryHistory > MemoryHistorySP
std::shared_ptr< lldb_private::Stream > StreamSP
ExpressionResults
The results of expression evaluation.
@ eExpressionHitBreakpoint
@ eExpressionStoppedForDebug
@ eExpressionResultUnavailable
@ eExpressionThreadVanished
std::shared_ptr< lldb_private::StructuredDataPlugin > StructuredDataPluginSP
std::shared_ptr< lldb_private::Process > ProcessSP
InstrumentationRuntimeType
std::shared_ptr< lldb_private::Disassembler > DisassemblerSP
std::shared_ptr< lldb_private::LanguageRuntime > LanguageRuntimeSP
std::shared_ptr< lldb_private::Event > EventSP
std::unique_ptr< lldb_private::DynamicLoader > DynamicLoaderUP
ByteOrder
Byte ordering definitions.
std::shared_ptr< lldb_private::Watchpoint > WatchpointSP
std::shared_ptr< lldb_private::Listener > ListenerSP
std::shared_ptr< lldb_private::StopInfo > StopInfoSP
StopReason
Thread stop reasons.
@ eStopReasonInstrumentation
@ eStopReasonPlanComplete
@ eStopReasonExec
Program was re-exec'ed.
@ eStopReasonProcessorTrace
@ eStopReasonThreadExiting
std::shared_ptr< lldb_private::Target > TargetSP
std::shared_ptr< lldb_private::RegisterContext > RegisterContextSP
std::shared_ptr< lldb_private::InstrumentationRuntime > InstrumentationRuntimeSP
std::shared_ptr< lldb_private::Module > ModuleSP
std::shared_ptr< lldb_private::OptionValue > OptionValueSP
std::shared_ptr< lldb_private::ThreadCollection > ThreadCollectionSP
A SmallBitVector that represents a set of source languages (lldb::LanguageType).
A notification structure that can be used by clients to listen for changes in a process's lifetime.
void(* process_state_changed)(void *baton, Process *process, lldb::StateType state)
void(* initialize)(void *baton, Process *process)
BaseType GetRangeBase() const
SizeType GetByteSize() const
void SetRangeBase(BaseType b)
Set the start value for the range, and keep the same size.
BaseType GetRangeEnd() const
void SetByteSize(SizeType s)
lldb::user_id_t GetID() const
Get accessor for the user ID.