Lines Matching refs:Process
1 //===-- Process.cpp -------------------------------------------------------===//
54 #include "lldb/Target/Process.h"
104 Process *process = exe_ctx->GetProcessPtr();
161 ProcessProperties::ProcessProperties(lldb_private::Process *process)
174 OptionValueProperties::CreateLocalCopy(Process::GetGlobalProperties());
372 ProcessSP Process::FindPlugin(lldb::TargetSP target_sp,
413 llvm::StringRef Process::GetStaticBroadcasterClass() {
418 Process::Process(lldb::TargetSP target_sp, ListenerSP listener_sp)
419 : Process(target_sp, listener_sp, UnixSignals::CreateForHost()) {
420 // This constructor just delegates to the full Process constructor,
424 Process::Process(lldb::TargetSP target_sp, ListenerSP listener_sp,
428 Process::GetStaticBroadcasterClass().str()),
459 LLDB_LOGF(log, "%p Process::Process()", static_cast<void *>(this));
479 // It always listens for all the event bits for Process:
509 Process::~Process() {
511 LLDB_LOGF(log, "%p Process::~Process()", static_cast<void *>(this));
520 ProcessProperties &Process::GetGlobalProperties() {
528 void Process::Finalize(bool destructing) {
544 // We need to destroy the loader before the derived Process class gets
585 void Process::RegisterNotificationCallbacks(const Notifications &callbacks) {
591 bool Process::UnregisterNotificationCallbacks(const Notifications &callbacks) {
604 void Process::SynchronouslyNotifyStateChanged(StateType state) {
625 StateType Process::GetNextEvent(EventSP &event_sp) {
631 state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
636 void Process::SyncIOHandler(uint32_t iohandler_id,
645 Log *log = GetLog(LLDBLog::Process);
657 StateType Process::WaitForProcessToStop(
672 Log *log = GetLog(LLDBLog::Process);
678 "Process::%s returning without waiting for events; process "
695 Process::HandleProcessStateChangedEvent(
709 if (Process::ProcessEventData::GetRestartedFromEvent(event_sp.get()))
725 bool Process::HandleProcessStateChangedEvent(
733 Process::ProcessEventData::GetProcessFromEvent(event_sp.get());
739 Process::ProcessEventData::GetStateFromEvent(event_sp.get());
751 stream->Printf("Process %" PRIu64 " %s\n", process_sp->GetID(),
772 if (Process::ProcessEventData::GetRestartedFromEvent(event_sp.get())) {
775 Process::ProcessEventData::GetNumRestartedReasons(event_sp.get());
781 Process::ProcessEventData::GetRestartedReasonAtIndex(
783 stream->Printf("Process %" PRIu64 " stopped and restarted: %s\n",
787 stream->Printf("Process %" PRIu64
793 Process::ProcessEventData::GetRestartedReasonAtIndex(
959 bool Process::HijackProcessEvents(ListenerSP listener_sp) {
967 void Process::RestoreProcessEvents() { RestoreBroadcaster(); }
969 StateType Process::GetStateChangedEvents(EventSP &event_sp,
972 Log *log = GetLog(LLDBLog::Process);
984 state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
993 Event *Process::PeekAtStateChangedEvents() {
994 Log *log = GetLog(LLDBLog::Process);
996 LLDB_LOGF(log, "Process::%s...", __FUNCTION__);
1003 LLDB_LOGF(log, "Process::%s (event_ptr) => %s", __FUNCTION__,
1006 LLDB_LOGF(log, "Process::%s no events found", __FUNCTION__);
1013 Process::GetStateChangedEventsPrivate(EventSP &event_sp,
1015 Log *log = GetLog(LLDBLog::Process);
1024 state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
1031 bool Process::GetEventsPrivate(EventSP &event_sp,
1034 Log *log = GetLog(LLDBLog::Process);
1044 bool Process::IsRunning() const {
1048 int Process::GetExitStatus() {
1056 const char *Process::GetExitDescription() {
1064 bool Process::SetExitStatus(int status, llvm::StringRef exit_string) {
1068 Log *log(GetLog(LLDBLog::State | LLDBLog::Process));
1100 bool Process::IsAlive() {
1119 // lldb_private::Process doesn't go away before we can deliver the signal.
1120 bool Process::SetProcessExitStatus(
1125 Log *log = GetLog(LLDBLog::Process);
1127 "Process::SetProcessExitStatus (pid=%" PRIu64
1146 bool Process::UpdateThreadList(ThreadList &old_thread_list,
1152 void Process::UpdateThreadListIfNeeded() {
1178 // backed by actual threads from the lldb_private::Process subclass
1203 // created by each lldb_private::Process
1239 ThreadPlanStack *Process::FindThreadPlans(lldb::tid_t tid) {
1243 bool Process::PruneThreadPlansForTID(lldb::tid_t tid) {
1247 void Process::PruneThreadPlans() {
1251 bool Process::DumpThreadPlansForTID(Stream &strm, lldb::tid_t tid,
1258 void Process::DumpThreadPlans(Stream &strm, lldb::DescriptionLevel desc_level,
1265 void Process::UpdateQueueListIfNeeded() {
1278 ThreadSP Process::CreateOSPluginThread(lldb::tid_t tid, lldb::addr_t context) {
1285 uint32_t Process::GetNextThreadIndexID(uint64_t thread_id) {
1289 bool Process::HasAssignedIndexIDToThread(uint64_t thread_id) {
1294 uint32_t Process::AssignIndexIDToThread(uint64_t thread_id) {
1303 StateType Process::GetState() {
1310 void Process::SetPublicState(StateType new_state, bool restarted) {
1322 Log *log(GetLog(LLDBLog::State | LLDBLog::Process));
1350 Status Process::Resume() {
1351 Log *log(GetLog(LLDBLog::State | LLDBLog::Process));
1367 Status Process::ResumeSynchronous(Stream *stream) {
1368 Log *log(GetLog(LLDBLog::State | LLDBLog::Process));
1369 LLDB_LOGF(log, "Process::ResumeSynchronous -- locking run lock");
1371 LLDB_LOGF(log, "Process::Resume: -- TrySetRunning failed, not resuming.");
1402 bool Process::StateChangedIsExternallyHijacked() {
1411 bool Process::StateChangedIsHijackedForSynchronousResume() {
1420 StateType Process::GetPrivateState() { return m_private_state.GetValue(); }
1422 void Process::SetPrivateState(StateType new_state) {
1426 // not be true for an in-the-middle-of-being-destructed Process, since the
1427 // event system relies on Process::shared_from_this, which may have already
1432 Log *log(GetLog(LLDBLog::State | LLDBLog::Process | LLDBLog::Unwind));
1489 void Process::SetRunningUserExpression(bool on) {
1493 void Process::SetRunningUtilityFunction(bool on) {
1497 addr_t Process::GetImageInfoAddress() { return LLDB_INVALID_ADDRESS; }
1499 const lldb::ABISP &Process::GetABI() {
1505 std::vector<LanguageRuntime *> Process::GetLanguageRuntimes() {
1525 LanguageRuntime *Process::GetLanguageRuntime(lldb::LanguageType language) {
1553 bool Process::IsPossibleDynamicValue(ValueObject &in_value) {
1574 void Process::SetDynamicCheckers(DynamicCheckerFunctions *dynamic_checkers) {
1578 StopPointSiteList<BreakpointSite> &Process::GetBreakpointSiteList() {
1583 Process::GetBreakpointSiteList() const {
1587 void Process::DisableAllBreakpointSites() {
1594 Status Process::ClearBreakpointSiteByID(lldb::user_id_t break_id) {
1603 Status Process::DisableBreakpointSiteByID(lldb::user_id_t break_id) {
1617 Status Process::EnableBreakpointSiteByID(lldb::user_id_t break_id) {
1631 Process::CreateBreakpointSite(const BreakpointLocationSP &constituent,
1721 void Process::RemoveConstituentFromBreakpointSite(
1734 size_t Process::RemoveBreakpointOpcodesFromBuffer(addr_t bp_addr, size_t size,
1764 size_t Process::GetSoftwareBreakpointTrapOpcode(BreakpointSite *bp_site) {
1771 Status Process::EnableSoftwareBreakpoint(BreakpointSite *bp_site) {
1777 log, "Process::EnableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64,
1782 "Process::EnableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64
1793 // Ask the lldb::Process subclass to fill in the correct software breakpoint
1799 "Process::GetSoftwareBreakpointTrapOpcode() "
1826 "Process::EnableSoftwareBreakpoint (site_id = %d) "
1845 "Process::EnableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64
1851 Status Process::DisableSoftwareBreakpoint(BreakpointSite *bp_site) {
1858 "Process::DisableSoftwareBreakpoint (breakID = %" PRIu64
1909 "Process::DisableSoftwareBreakpoint (site_id = %d) "
1930 "Process::DisableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64
1938 "Process::DisableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64
1948 size_t Process::ReadMemory(addr_t addr, void *buf, size_t size, Status &error) {
1992 void Process::DoFindInMemory(lldb::addr_t start_addr, lldb::addr_t end_addr,
2023 AddressRanges Process::FindRangesInMemory(const uint8_t *buf, uint64_t size,
2077 lldb::addr_t Process::FindInMemory(const uint8_t *buf, uint64_t size,
2115 size_t Process::ReadCStringFromMemory(addr_t addr, std::string &out_str,
2137 size_t Process::ReadCStringFromMemory(addr_t addr, char *dst,
2183 size_t Process::ReadMemoryFromInferior(addr_t addr, void *buf, size_t size,
2212 uint64_t Process::ReadUnsignedIntegerFromMemory(lldb::addr_t vm_addr,
2223 int64_t Process::ReadSignedIntegerFromMemory(lldb::addr_t vm_addr,
2234 addr_t Process::ReadPointerFromMemory(lldb::addr_t vm_addr, Status &error) {
2242 bool Process::WritePointerToMemory(lldb::addr_t vm_addr, lldb::addr_t ptr_value,
2254 size_t Process::WriteMemoryPrivate(addr_t addr, const void *buf, size_t size,
2270 size_t Process::WriteMemory(addr_t addr, const void *buf, size_t size,
2352 size_t Process::WriteScalarToMemory(addr_t addr, const Scalar &scalar,
2370 size_t Process::ReadScalarIntegerFromMemory(addr_t addr, uint32_t byte_size,
2400 Status Process::WriteObjectFile(std::vector<ObjectFile::LoadableData> entries) {
2412 addr_t Process::AllocateMemory(size_t size, uint32_t permissions,
2424 Log *log = GetLog(LLDBLog::Process);
2426 "Process::AllocateMemory(size=%" PRIu64
2436 addr_t Process::CallocateMemory(size_t size, uint32_t permissions,
2446 bool Process::CanJIT() {
2448 Log *log = GetLog(LLDBLog::Process);
2458 "Process::%s pid %" PRIu64
2464 "Process::%s pid %" PRIu64
2475 void Process::SetCanJIT(bool can_jit) {
2479 void Process::SetCanRunCode(bool can_run_code) {
2484 Status Process::DeallocateMemory(addr_t ptr) {
2494 Log *log = GetLog(LLDBLog::Process);
2496 "Process::DeallocateMemory(addr=0x%16.16" PRIx64
2504 bool Process::GetWatchpointReportedAfter() {
2522 ModuleSP Process::ReadModuleFromMemory(const FileSpec &file_spec,
2528 "Process::ReadModuleFromMemory reading %s binary from memory",
2550 bool Process::GetLoadAddressPermissions(lldb::addr_t load_addr,
2566 Status Process::EnableWatchpoint(WatchpointSP wp_sp, bool notify) {
2572 Status Process::DisableWatchpoint(WatchpointSP wp_sp, bool notify) {
2579 Process::WaitForProcessStopPrivate(EventSP &event_sp,
2600 void Process::LoadOperatingSystemPlugin(bool flush) {
2609 Status Process::Launch(ProcessLaunchInfo &launch_info) {
2641 Status Process::LaunchPrivate(ProcessLaunchInfo &launch_info, StateType &state,
2778 Status Process::LoadCore() {
2814 Log *log = GetLog(LLDBLog::Process);
2815 LLDB_LOGF(log, "Process::Halt() failed to stop, state is: %s",
2825 DynamicLoader *Process::GetDynamicLoader() {
2831 void Process::SetDynamicLoader(DynamicLoaderUP dyld_up) {
2835 DataExtractor Process::GetAuxvData() { return DataExtractor(); }
2837 llvm::Expected<bool> Process::SaveCore(llvm::StringRef outfile) {
2841 JITLoaderList &Process::GetJITLoaders() {
2849 SystemRuntime *Process::GetSystemRuntime() {
2855 Process::AttachCompletionHandler::AttachCompletionHandler(Process *process,
2858 Log *log = GetLog(LLDBLog::Process);
2861 "Process::AttachCompletionHandler::%s process=%p, exec_count=%" PRIu32,
2865 Process::NextEventAction::EventActionResult
2866 Process::AttachCompletionHandler::PerformAction(lldb::EventSP &event_sp) {
2867 Log *log = GetLog(LLDBLog::Process);
2871 "Process::AttachCompletionHandler::%s called with state %s (%d)",
2885 // lldb_private::Process subclasses must set the new process ID.
2895 "Process::AttachCompletionHandler::%s state %s: reduced "
2903 "Process::AttachCompletionHandler::%s state %s: no more "
2918 m_exit_string.assign("No valid Process");
2922 Process::NextEventAction::EventActionResult
2923 Process::AttachCompletionHandler::HandleBeingInterrupted() {
2927 const char *Process::AttachCompletionHandler::GetExitString() {
2938 Status Process::WillLaunch(Module *module) {
2942 Status Process::WillAttachToProcessWithID(lldb::pid_t pid) {
2946 Status Process::WillAttachToProcessWithName(const char *process_name,
2951 Status Process::Attach(ProcessAttachInfo &attach_info) {
2995 SetNextEventAction(new Process::AttachCompletionHandler(
3058 SetNextEventAction(new Process::AttachCompletionHandler(
3076 void Process::CompleteAttach() {
3077 Log *log(GetLog(LLDBLog::Process | LLDBLog::Target));
3078 LLDB_LOGF(log, "Process::%s()", __FUNCTION__);
3087 "Process::{0} replacing process architecture with DidAttach() "
3125 "Process::%s switching architecture to %s based on info "
3195 "Process::%s after looping through modules, target executable is %s",
3203 Status Process::ConnectRemote(llvm::StringRef remote_url) {
3238 Status Process::PrivateResume() {
3239 Log *log(GetLog(LLDBLog::Process | LLDBLog::Step));
3241 "Process::PrivateResume() m_stop_id = %u, public state: %s "
3268 "Process::PrivateResume PreResumeActions failed, not resuming.");
3275 LLDB_LOGF(log, "Process thinks the process has resumed.");
3277 LLDB_LOGF(log, "Process::PrivateResume() DoResume failed.");
3287 "Process::PrivateResume() asked to simulate a start & stop.");
3293 LLDB_LOGF(log, "Process::PrivateResume() got an error \"%s\".",
3298 Status Process::Halt(bool clear_thread_plans, bool use_run_lock) {
3300 return Status::FromErrorString("Process is not running.");
3344 lldb::addr_t Process::FindInMemory(lldb::addr_t low, lldb::addr_t high,
3400 Status Process::StopForDestroyOrDetach(lldb::EventSP &exit_event_sp) {
3408 Log *log = GetLog(LLDBLog::Process);
3409 LLDB_LOGF(log, "Process::%s() About to stop.", __FUNCTION__);
3412 Listener::MakeListener("lldb.Process.StopForDestroyOrDetach.hijack"));
3429 LLDB_LOGF(log, "Process::%s() Process exited while waiting to stop.",
3436 LLDB_LOGF(log, "Process::%s() failed to stop, state is: %s", __FUNCTION__,
3453 Status Process::Detach(bool keep_stopped) {
3505 Status Process::Destroy(bool force_kill) {
3506 // If we've already called Process::Finalize then there's nothing useful to
3513 Status Process::DestroyImpl(bool force_kill) {
3586 Status Process::Signal(int signal) {
3596 void Process::SetUnixSignals(UnixSignalsSP &&signals_sp) {
3601 const lldb::UnixSignalsSP &Process::GetUnixSignals() {
3606 lldb::ByteOrder Process::GetByteOrder() const {
3610 uint32_t Process::GetAddressByteSize() const {
3614 bool Process::ShouldBroadcastEvent(Event *event_ptr) {
3616 Process::ProcessEventData::GetStateFromEvent(event_ptr);
3618 Log *log(GetLog(LLDBLog::Events | LLDBLog::Process));
3692 "Process::ShouldBroadcastEvent (%p) stopped due to an "
3713 "Process::ShouldBroadcastEvent: should_resume: %i state: "
3730 "Process::ShouldBroadcastEvent (%p) Restarting process "
3760 "Process::ShouldBroadcastEvent (%p) => new state: %s, last "
3768 bool Process::StartPrivateStateThread(bool is_secondary_thread) {
3772 LLDB_LOGF(log, "Process::%s()%s ", __FUNCTION__,
3819 void Process::PausePrivateStateThread() {
3823 void Process::ResumePrivateStateThread() {
3827 void Process::StopPrivateStateThread() {
3831 Log *log = GetLog(LLDBLog::Process);
3838 void Process::ControlPrivateStateThread(uint32_t signal) {
3839 Log *log = GetLog(LLDBLog::Process);
3845 LLDB_LOGF(log, "Process::%s (signal = %d)", __FUNCTION__, signal);
3888 void Process::SendAsyncInterrupt(Thread *thread) {
3894 m_private_state_broadcaster.BroadcastEvent(Process::eBroadcastBitInterrupt,
3897 BroadcastEvent(Process::eBroadcastBitInterrupt, nullptr);
3900 void Process::HandlePrivateEvent(EventSP &event_sp) {
3901 Log *log = GetLog(LLDBLog::Process);
3905 Process::ProcessEventData::GetStateFromEvent(event_sp.get());
3943 "Process::%s (pid = %" PRIu64
3949 Process::ProcessEventData::SetUpdateStateOnRemoval(event_sp.get());
3959 LLDB_LOGF(log, "Process::%s updated m_iohandler_sync to %d",
3963 if (!Process::ProcessEventData::GetRestartedFromEvent(event_sp.get())) {
4003 "Process::%s (pid = %" PRIu64
4011 Status Process::HaltPrivate() {
4025 thread_result_t Process::RunPrivateStateThread(bool is_secondary_thread) {
4028 Log *log = GetLog(LLDBLog::Process);
4029 LLDB_LOGF(log, "Process::%s (arg = %p, pid = %" PRIu64 ") thread starting...",
4039 "Process::%s (arg = %p, pid = %" PRIu64
4062 "Process::%s (arg = %p, pid = %" PRIu64
4076 "Process::%s (arg = %p, pid = %" PRIu64
4082 "Process::%s (arg = %p, pid = %" PRIu64
4093 // This can happen when someone (e.g. Process::Halt) sees that we are
4100 "Process::%s ignoring interrupt as we have already stopped.",
4107 Process::ProcessEventData::GetStateFromEvent(event_sp.get());
4129 "Process::%s interrupt_requested, but a non-stopped "
4141 "Process::%s (arg = %p, pid = %" PRIu64
4151 LLDB_LOGF(log, "Process::%s (arg = %p, pid = %" PRIu64 ") thread exiting...",
4162 // Process Event Data
4164 Process::ProcessEventData::ProcessEventData() : EventData(), m_process_wp() {}
4166 Process::ProcessEventData::ProcessEventData(const ProcessSP &process_sp,
4173 Process::ProcessEventData::~ProcessEventData() = default;
4175 llvm::StringRef Process::ProcessEventData::GetFlavorString() {
4176 return "Process::ProcessEventData";
4179 llvm::StringRef Process::ProcessEventData::GetFlavor() const {
4183 bool Process::ProcessEventData::ShouldStop(Event *event_ptr,
4231 Log *log(GetLog(LLDBLog::Step | LLDBLog::Process));
4240 Log *log(GetLog(LLDBLog::Step | LLDBLog::Process));
4279 bool Process::ProcessEventData::ForwardEventToPendingListeners(
4282 if (event_ptr->GetType() != Process::eBroadcastBitStateChanged)
4290 void Process::ProcessEventData::DoOnRemoval(Event *event_ptr) {
4292 if (event_ptr->GetType() != Process::eBroadcastBitStateChanged)
4312 m_state, Process::ProcessEventData::GetRestartedFromEvent(event_ptr));
4362 void Process::ProcessEventData::Dump(Stream *s) const {
4374 const Process::ProcessEventData *
4375 Process::ProcessEventData::GetEventDataFromEvent(const Event *event_ptr) {
4386 Process::ProcessEventData::GetProcessFromEvent(const Event *event_ptr) {
4394 StateType Process::ProcessEventData::GetStateFromEvent(const Event *event_ptr) {
4402 bool Process::ProcessEventData::GetRestartedFromEvent(const Event *event_ptr) {
4410 void Process::ProcessEventData::SetRestartedInEvent(Event *event_ptr,
4419 Process::ProcessEventData::GetNumRestartedReasons(const Event *event_ptr) {
4429 Process::ProcessEventData::GetRestartedReasonAtIndex(const Event *event_ptr,
4439 void Process::ProcessEventData::AddRestartedReason(Event *event_ptr,
4447 bool Process::ProcessEventData::GetInterruptedFromEvent(
4456 void Process::ProcessEventData::SetInterruptedInEvent(Event *event_ptr,
4464 bool Process::ProcessEventData::SetUpdateStateOnRemoval(Event *event_ptr) {
4474 lldb::TargetSP Process::CalculateTarget() { return m_target_wp.lock(); }
4476 void Process::CalculateExecutionContext(ExecutionContext &exe_ctx) {
4484 // Process::ListProcessesMatchingName (const char *name, StringList &matches,
4491 // Process::GetArchSpecForExistingProcess (lldb::pid_t pid)
4497 // Process::GetArchSpecForExistingProcess (const char *process_name)
4502 EventSP Process::CreateEventFromProcessState(uint32_t event_type) {
4508 void Process::AppendSTDOUT(const char *s, size_t len) {
4515 void Process::AppendSTDERR(const char *s, size_t len) {
4522 void Process::BroadcastAsyncProfileData(const std::string &one_profile_data) {
4529 void Process::BroadcastStructuredData(const StructuredData::ObjectSP &object_sp,
4537 Process::GetStructuredDataPlugin(llvm::StringRef type_name) const {
4545 size_t Process::GetAsyncProfileData(char *buf, size_t buf_size, Status &error) {
4553 Log *log = GetLog(LLDBLog::Process);
4554 LLDB_LOGF(log, "Process::GetProfileData (buf = %p, size = %" PRIu64 ")",
4568 // Process STDIO
4570 size_t Process::GetSTDOUT(char *buf, size_t buf_size, Status &error) {
4574 Log *log = GetLog(LLDBLog::Process);
4575 LLDB_LOGF(log, "Process::GetSTDOUT (buf = %p, size = %" PRIu64 ")",
4589 size_t Process::GetSTDERR(char *buf, size_t buf_size, Status &error) {
4593 Log *log = GetLog(LLDBLog::Process);
4594 LLDB_LOGF(log, "Process::GetSTDERR (buf = %p, size = %" PRIu64 ")",
4608 void Process::STDIOReadThreadBytesReceived(void *baton, const void *src,
4610 Process *process = (Process *)baton;
4616 IOHandlerProcessSTDIO(Process *process, int write_fd)
4749 Process *m_process;
4758 void Process::SetSTDIOFileDescriptor(int fd) {
4777 bool Process::ProcessIOHandlerIsActive() {
4785 bool Process::PushProcessIOHandler() {
4789 Log *log = GetLog(LLDBLog::Process);
4790 LLDB_LOGF(log, "Process::%s pushing IO handler", __FUNCTION__);
4805 bool Process::PopProcessIOHandler() {
4814 void Process::SettingsInitialize() { Thread::SettingsInitialize(); }
4816 void Process::SettingsTerminate() { Thread::SettingsTerminate(); }
4899 Log *log = GetLog(LLDBLog::Step | LLDBLog::Process);
4941 Process::ProcessEventData::GetInterruptedFromEvent(event_sp.get()))
4951 Process::RunThreadPlan(ExecutionContext &exe_ctx,
5069 Log *log(GetLog(LLDBLog::Step | LLDBLog::Process));
5133 "Process::RunThreadPlan(): Resuming thread %u - 0x%4.4" PRIx64
5223 "Process::RunThreadPlan(): didn't get any event after "
5236 Process::ProcessEventData::GetStateFromEvent(event_sp.get());
5242 restarted = Process::ProcessEventData::GetRestartedFromEvent(
5246 "Process::RunThreadPlan(): didn't get running event after "
5271 log->PutCString("Process::RunThreadPlan(): resuming succeeded.");
5279 log->PutCString("Process::RunThreadPlan(): waiting for next event.");
5294 "Process::RunThreadPlan(): about to wait - now is %s - "
5299 LLDB_LOGF(log, "Process::RunThreadPlan(): about to wait forever.");
5323 LLDB_LOGF(log, "Process::RunThreadPlan(): Got interrupted by "
5328 Process::ProcessEventData::GetStateFromEvent(event_sp.get());
5330 "Process::RunThreadPlan(): in while loop, got event: %s.",
5335 if (Process::ProcessEventData::GetRestartedFromEvent(
5339 LLDB_LOGF(log, "Process::RunThreadPlan(): Got a stop and "
5366 "Process::RunThreadPlan(): execution stopped with "
5387 log->PutCString("Process::RunThreadPlan(): got_event was true, but "
5429 LLDB_LOGF(log, "Process::RunThreadPlan(): Running Halt.");
5436 log->PutCString("Process::RunThreadPlan(): Halt succeeded.");
5443 Process::ProcessEventData::GetStateFromEvent(event_sp.get());
5446 "Process::RunThreadPlan(): Stopped with event: %s",
5449 Process::ProcessEventData::GetInterruptedFromEvent(
5455 if (Process::ProcessEventData::GetRestartedFromEvent(
5458 log->PutCString("Process::RunThreadPlan(): Went to halt "
5483 log->PutCString("Process::RunThreadPlan(): try_all_threads "
5498 "Process::RunThreadPlan(): about to resume.");
5505 log->PutCString("Process::RunThreadPlan(): running all "
5514 log->PutCString("Process::RunThreadPlan(): halt said it "
5583 log->PutCString("Process::RunThreadPlan(): Stop event that "
5599 const Process::ProcessEventData *event_data =
5600 Process::ProcessEventData::GetEventDataFromEvent(
5608 Process *process = event_data->GetProcessSP().get();
5656 "Process::RunThreadPlan(): execution interrupted: %s %s",
5659 LLDB_LOGF(log, "Process::RunThreadPlan(): execution interrupted: %s",
5665 "Process::RunThreadPlan: ExecutionInterrupted - "
5671 "Process::RunThreadPlan: ExecutionInterrupted - for "
5677 log->PutCString("Process::RunThreadPlan(): execution set up error.");
5685 log->PutCString("Process::RunThreadPlan(): thread plan is done");
5690 "Process::RunThreadPlan(): thread plan was discarded");
5695 "Process::RunThreadPlan(): thread plan stopped in mid course");
5698 log->PutCString("Process::RunThreadPlan(): discarding thread plan "
5735 log->PutCString("Process::RunThreadPlan(): rebroadcasting event.");
5742 void Process::GetStatus(Stream &strm) {
5748 strm.Printf("Process %" PRIu64 " exited with status = %i (0x%8.8x) %s\n",
5755 strm.Printf("Process %" PRIu64 " %s\n", GetID(), StateAsCString(state));
5758 strm.Printf("Process %" PRIu64 " is running.\n", GetID());
5762 size_t Process::GetThreadStatus(Stream &strm,
5800 Log *log = GetLog(LLDBLog::Process);
5801 LLDB_LOGF(log, "Process::GetThreadStatus - thread 0x" PRIu64
5808 void Process::AddInvalidMemoryRegion(const LoadRange ®ion) {
5812 bool Process::RemoveInvalidMemoryRange(const LoadRange ®ion) {
5817 void Process::AddPreResumeAction(PreResumeActionCallback callback,
5822 bool Process::RunPreResumeActions() {
5834 void Process::ClearPreResumeActions() { m_pre_resume_actions.clear(); }
5836 void Process::ClearPreResumeAction(PreResumeActionCallback callback, void *baton)
5846 ProcessRunLock &Process::GetRunLock() {
5853 bool Process::CurrentThreadIsPrivateStateThread()
5859 void Process::Flush() {
5867 lldb::addr_t Process::GetCodeAddressMask() {
5874 lldb::addr_t Process::GetDataAddressMask() {
5881 lldb::addr_t Process::GetHighmemCodeAddressMask() {
5890 lldb::addr_t Process::GetHighmemDataAddressMask() {
5899 void Process::SetCodeAddressMask(lldb::addr_t code_address_mask) {
5900 LLDB_LOG(GetLog(LLDBLog::Process),
5901 "Setting Process code address mask to {0:x}", code_address_mask);
5905 void Process::SetDataAddressMask(lldb::addr_t data_address_mask) {
5906 LLDB_LOG(GetLog(LLDBLog::Process),
5907 "Setting Process data address mask to {0:x}", data_address_mask);
5911 void Process::SetHighmemCodeAddressMask(lldb::addr_t code_address_mask) {
5912 LLDB_LOG(GetLog(LLDBLog::Process),
5913 "Setting Process highmem code address mask to {0:x}",
5918 void Process::SetHighmemDataAddressMask(lldb::addr_t data_address_mask) {
5919 LLDB_LOG(GetLog(LLDBLog::Process),
5920 "Setting Process highmem data address mask to {0:x}",
5925 addr_t Process::FixCodeAddress(addr_t addr) {
5931 addr_t Process::FixDataAddress(addr_t addr) {
5937 addr_t Process::FixAnyAddress(addr_t addr) {
5943 void Process::DidExec() {
5944 Log *log = GetLog(LLDBLog::Process);
5945 LLDB_LOGF(log, "Process::%s()", __FUNCTION__);
5979 addr_t Process::ResolveIndirectFunction(const Address *address, Status &error) {
6009 void Process::ModulesDidLoad(ModuleList &module_list) {
6043 void Process::PrintWarningOptimization(const SymbolContext &sc) {
6051 void Process::PrintWarningUnsupportedLanguage(const SymbolContext &sc) {
6069 bool Process::GetProcessInfo(ProcessInstanceInfo &info) {
6079 lldb_private::UUID Process::FindModuleUUID(const llvm::StringRef path) {
6083 ThreadCollectionSP Process::GetHistoryThreads(lldb::addr_t addr) {
6100 Process::GetInstrumentationRuntime(lldb::InstrumentationRuntimeType type) {
6109 bool Process::GetModuleSpec(const FileSpec &module_file_spec,
6115 size_t Process::AddImageToken(lldb::addr_t image_ptr) {
6120 lldb::addr_t Process::GetImagePtrFromToken(size_t token) const {
6126 void Process::ResetImageToken(size_t token) {
6132 Process::AdvanceAddressToNextBranchInstruction(Address default_stop_addr,
6183 Status Process::GetMemoryRegionInfo(lldb::addr_t load_addr,
6195 Status Process::GetMemoryRegions(lldb_private::MemoryRegionInfos ®ion_list) {
6232 Process::ConfigureStructuredData(llvm::StringRef type_name,
6234 // If you get this, the Process-derived class needs to implement a method to
6240 void Process::MapSupportedStructuredDataPlugins(
6242 Log *log = GetLog(LLDBLog::Process);
6310 bool Process::RouteAsyncStructuredData(
6339 Status Process::UpdateAutomaticSignalFiltering() {
6345 UtilityFunction *Process::GetLoadImageUtilityFunction(
6355 llvm::Expected<TraceSupportedResponse> Process::TraceSupported() {
6362 bool Process::CallVoidArgVoidPtrReturn(const Address *address,
6420 llvm::Expected<const MemoryTagManager *> Process::GetMemoryTagManager() {
6432 "Process does not support memory tagging");
6439 Process::ReadMemoryTags(lldb::addr_t addr, size_t len) {
6455 Status Process::WriteMemoryTags(lldb::addr_t addr, size_t len,
6539 static void SaveDynamicLoaderSections(Process &process,
6562 static void SaveOffRegionsWithStackPointers(Process &process,
6606 static void GetCoreFileSaveRangesFull(Process &process,
6622 static void GetCoreFileSaveRangesDirtyOnly(Process &process,
6654 static void GetCoreFileSaveRangesStackOnly(Process &process,
6670 static void GetUserSpecifiedCoreFileSaveRanges(Process &process,
6688 Status Process::CalculateCoreFileSaveRanges(const SaveCoreOptions &options,
6746 Process::CalculateCoreFileThreadList(const SaveCoreOptions &core_options) {
6757 void Process::SetAddressableBitMasks(AddressableBits bit_masks) {