Lines Matching defs:Process
1 //===-- Process.cpp ---------------------------------------------*- C++ -*-===//
51 #include "lldb/Target/Process.h"
90 // it is part of a new lldb_private::Process instance. It will copy all
102 Process *process = exe_ctx->GetProcessPtr();
123 ProcessProperties::ProcessProperties(lldb_private::Process *process)
137 Process::GetGlobalProperties().get());
278 case 'p': // Process plug-in name
412 ProcessSP Process::FindPlugin(lldb::TargetSP target_sp,
451 ConstString &Process::GetStaticBroadcasterClass() {
456 Process::Process(lldb::TargetSP target_sp, ListenerSP listener_sp)
457 : Process(target_sp, listener_sp,
459 // This constructor just delegates to the full Process constructor,
463 Process::Process(lldb::TargetSP target_sp, ListenerSP listener_sp,
467 Process::GetStaticBroadcasterClass().AsCString()),
497 LLDB_LOGF(log, "%p Process::Process()", static_cast<void *>(this));
543 Process::~Process() {
545 LLDB_LOGF(log, "%p Process::~Process()", static_cast<void *>(this));
554 const ProcessPropertiesSP &Process::GetGlobalProperties() {
562 void Process::Finalize() {
591 // We need to destroy the loader before the derived Process class gets
640 void Process::RegisterNotificationCallbacks(const Notifications &callbacks) {
646 bool Process::UnregisterNotificationCallbacks(const Notifications &callbacks) {
659 void Process::SynchronouslyNotifyStateChanged(StateType state) {
680 StateType Process::GetNextEvent(EventSP &event_sp) {
686 state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
691 void Process::SyncIOHandler(uint32_t iohandler_id,
712 StateType Process::WaitForProcessToStop(const Timeout<std::micro> &timeout,
733 "Process::%s returning without waiting for events; process "
750 Process::HandleProcessStateChangedEvent(event_sp, stream,
764 if (Process::ProcessEventData::GetRestartedFromEvent(event_sp.get()))
780 bool Process::HandleProcessStateChangedEvent(const EventSP &event_sp,
787 Process::ProcessEventData::GetProcessFromEvent(event_sp.get());
793 Process::ProcessEventData::GetStateFromEvent(event_sp.get());
805 stream->Printf("Process %" PRIu64 " %s\n", process_sp->GetID(),
826 if (Process::ProcessEventData::GetRestartedFromEvent(event_sp.get())) {
829 Process::ProcessEventData::GetNumRestartedReasons(event_sp.get());
835 Process::ProcessEventData::GetRestartedReasonAtIndex(
837 stream->Printf("Process %" PRIu64 " stopped and restarted: %s\n",
841 stream->Printf("Process %" PRIu64
847 Process::ProcessEventData::GetRestartedReasonAtIndex(
987 bool Process::HijackProcessEvents(ListenerSP listener_sp) {
995 void Process::RestoreProcessEvents() { RestoreBroadcaster(); }
997 StateType Process::GetStateChangedEvents(EventSP &event_sp,
1012 state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
1021 Event *Process::PeekAtStateChangedEvents() {
1024 LLDB_LOGF(log, "Process::%s...", __FUNCTION__);
1031 LLDB_LOGF(log, "Process::%s (event_ptr) => %s", __FUNCTION__,
1034 LLDB_LOGF(log, "Process::%s no events found", __FUNCTION__);
1041 Process::GetStateChangedEventsPrivate(EventSP &event_sp,
1052 state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
1059 bool Process::GetEventsPrivate(EventSP &event_sp,
1072 bool Process::IsRunning() const {
1076 int Process::GetExitStatus() {
1084 const char *Process::GetExitDescription() {
1092 bool Process::SetExitStatus(int status, const char *cstr) {
1099 log, "Process::SetExitStatus (status=%i (0x%8.8x), description=%s%s%s)",
1104 LLDB_LOGF(log, "Process::SetExitStatus () ignoring exit status because "
1127 bool Process::IsAlive() {
1146 // lldb_private::Process doesn't go away before we can deliver the signal.
1147 bool Process::SetProcessExitStatus(
1154 "Process::SetProcessExitStatus (pid=%" PRIu64
1175 void Process::UpdateThreadListIfNeeded() {
1198 // backed by actual threads from the lldb_private::Process subclass
1219 // created by each lldb_private::Process
1249 void Process::UpdateQueueListIfNeeded() {
1262 ThreadSP Process::CreateOSPluginThread(lldb::tid_t tid, lldb::addr_t context) {
1269 uint32_t Process::GetNextThreadIndexID(uint64_t thread_id) {
1273 bool Process::HasAssignedIndexIDToThread(uint64_t thread_id) {
1278 uint32_t Process::AssignIndexIDToThread(uint64_t thread_id) {
1292 StateType Process::GetState() {
1296 void Process::SetPublicState(StateType new_state, bool restarted) {
1299 LLDB_LOGF(log, "Process::SetPublicState (state = %s, restarted = %i)",
1310 "Process::SetPublicState (%s) -- unlocking run lock for detach",
1318 LLDB_LOGF(log, "Process::SetPublicState (%s) -- unlocking run lock",
1327 Status Process::Resume() {
1330 LLDB_LOGF(log, "Process::Resume -- locking run lock");
1333 LLDB_LOGF(log, "Process::Resume: -- TrySetRunning failed, not resuming.");
1344 static const char *g_resume_sync_name = "lldb.Process.ResumeSynchronous.hijack";
1346 Status Process::ResumeSynchronous(Stream *stream) {
1349 LLDB_LOGF(log, "Process::ResumeSynchronous -- locking run lock");
1352 LLDB_LOGF(log, "Process::Resume: -- TrySetRunning failed, not resuming.");
1381 bool Process::StateChangedIsExternallyHijacked() {
1391 bool Process::StateChangedIsHijackedForSynchronousResume() {
1401 StateType Process::GetPrivateState() { return m_private_state.GetValue(); }
1403 void Process::SetPrivateState(StateType new_state) {
1411 LLDB_LOGF(log, "Process::SetPrivateState (%s)", StateAsCString(new_state));
1450 LLDB_LOGF(log, "Process::SetPrivateState (%s) stop_id = %u",
1461 "Process::SetPrivateState (%s) state didn't change. Ignoring...",
1466 void Process::SetRunningUserExpression(bool on) {
1470 void Process::SetRunningUtilityFunction(bool on) {
1474 addr_t Process::GetImageInfoAddress() { return LLDB_INVALID_ADDRESS; }
1476 const lldb::ABISP &Process::GetABI() {
1482 std::vector<LanguageRuntime *> Process::GetLanguageRuntimes() {
1502 LanguageRuntime *Process::GetLanguageRuntime(lldb::LanguageType language) {
1530 bool Process::IsPossibleDynamicValue(ValueObject &in_value) {
1551 void Process::SetDynamicCheckers(DynamicCheckerFunctions *dynamic_checkers) {
1555 BreakpointSiteList &Process::GetBreakpointSiteList() {
1559 const BreakpointSiteList &Process::GetBreakpointSiteList() const {
1563 void Process::DisableAllBreakpointSites() {
1570 Status Process::ClearBreakpointSiteByID(lldb::user_id_t break_id) {
1579 Status Process::DisableBreakpointSiteByID(lldb::user_id_t break_id) {
1593 Status Process::EnableBreakpointSiteByID(lldb::user_id_t break_id) {
1607 Process::CreateBreakpointSite(const BreakpointLocationSP &owner,
1696 void Process::RemoveOwnerFromBreakpointSite(lldb::user_id_t owner_id,
1708 size_t Process::RemoveBreakpointOpcodesFromBuffer(addr_t bp_addr, size_t size,
1738 size_t Process::GetSoftwareBreakpointTrapOpcode(BreakpointSite *bp_site) {
1745 Status Process::EnableSoftwareBreakpoint(BreakpointSite *bp_site) {
1751 log, "Process::EnableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64,
1756 "Process::EnableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64
1766 // Ask the lldb::Process subclass to fill in the correct software breakpoint
1771 error.SetErrorStringWithFormat("Process::GetSoftwareBreakpointTrapOpcode() "
1798 "Process::EnableSoftwareBreakpoint (site_id = %d) "
1815 "Process::EnableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64
1821 Status Process::DisableSoftwareBreakpoint(BreakpointSite *bp_site) {
1828 "Process::DisableSoftwareBreakpoint (breakID = %" PRIu64
1878 "Process::DisableSoftwareBreakpoint (site_id = %d) "
1897 "Process::DisableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64
1905 "Process::DisableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64
1915 size_t Process::ReadMemory(addr_t addr, void *buf, size_t size, Status &error) {
1956 size_t Process::ReadCStringFromMemory(addr_t addr, std::string &out_str,
1976 size_t Process::ReadStringFromMemory(addr_t addr, char *dst, size_t max_bytes,
2029 size_t Process::ReadCStringFromMemory(addr_t addr, char *dst,
2075 size_t Process::ReadMemoryFromInferior(addr_t addr, void *buf, size_t size,
2099 uint64_t Process::ReadUnsignedIntegerFromMemory(lldb::addr_t vm_addr,
2110 int64_t Process::ReadSignedIntegerFromMemory(lldb::addr_t vm_addr,
2121 addr_t Process::ReadPointerFromMemory(lldb::addr_t vm_addr, Status &error) {
2129 bool Process::WritePointerToMemory(lldb::addr_t vm_addr, lldb::addr_t ptr_value,
2141 size_t Process::WriteMemoryPrivate(addr_t addr, const void *buf, size_t size,
2157 size_t Process::WriteMemory(addr_t addr, const void *buf, size_t size,
2233 size_t Process::WriteScalarToMemory(addr_t addr, const Scalar &scalar,
2251 size_t Process::ReadScalarIntegerFromMemory(addr_t addr, uint32_t byte_size,
2281 Status Process::WriteObjectFile(std::vector<ObjectFile::LoadableData> entries) {
2293 addr_t Process::AllocateMemory(size_t size, uint32_t permissions,
2306 "Process::AllocateMemory(size=%" PRIu64
2316 addr_t Process::CallocateMemory(size_t size, uint32_t permissions,
2326 bool Process::CanJIT() {
2338 "Process::%s pid %" PRIu64
2344 "Process::%s pid %" PRIu64
2355 void Process::SetCanJIT(bool can_jit) {
2359 void Process::SetCanRunCode(bool can_run_code) {
2364 Status Process::DeallocateMemory(addr_t ptr) {
2376 "Process::DeallocateMemory(addr=0x%16.16" PRIx64
2384 ModuleSP Process::ReadModuleFromMemory(const FileSpec &file_spec,
2390 "Process::ReadModuleFromMemory reading %s binary from memory",
2404 bool Process::GetLoadAddressPermissions(lldb::addr_t load_addr,
2429 Status Process::EnableWatchpoint(Watchpoint *watchpoint, bool notify) {
2435 Status Process::DisableWatchpoint(Watchpoint *watchpoint, bool notify) {
2442 Process::WaitForProcessStopPrivate(EventSP &event_sp,
2463 void Process::LoadOperatingSystemPlugin(bool flush) {
2471 Status Process::Launch(ProcessLaunchInfo &launch_info) {
2590 Status Process::LoadCore() {
2626 LLDB_LOGF(log, "Process::Halt() failed to stop, state is: %s",
2636 DynamicLoader *Process::GetDynamicLoader() {
2642 DataExtractor Process::GetAuxvData() { return DataExtractor(); }
2644 JITLoaderList &Process::GetJITLoaders() {
2652 SystemRuntime *Process::GetSystemRuntime() {
2658 Process::AttachCompletionHandler::AttachCompletionHandler(Process *process,
2664 "Process::AttachCompletionHandler::%s process=%p, exec_count=%" PRIu32,
2668 Process::NextEventAction::EventActionResult
2669 Process::AttachCompletionHandler::PerformAction(lldb::EventSP &event_sp) {
2674 "Process::AttachCompletionHandler::%s called with state %s (%d)",
2688 // lldb_private::Process subclasses must set the new process ID.
2698 "Process::AttachCompletionHandler::%s state %s: reduced "
2706 "Process::AttachCompletionHandler::%s state %s: no more "
2721 m_exit_string.assign("No valid Process");
2725 Process::NextEventAction::EventActionResult
2726 Process::AttachCompletionHandler::HandleBeingInterrupted() {
2730 const char *Process::AttachCompletionHandler::GetExitString() {
2741 Status Process::Attach(ProcessAttachInfo &attach_info) {
2781 SetNextEventAction(new Process::AttachCompletionHandler(
2844 SetNextEventAction(new Process::AttachCompletionHandler(
2862 void Process::CompleteAttach() {
2865 LLDB_LOGF(log, "Process::%s()", __FUNCTION__);
2877 "Process::%s replacing process architecture with DidAttach() "
2899 "Process::%s switching platform to %s and architecture "
2912 "Process::%s switching architecture to %s based on info "
2928 "Process::%s after DynamicLoader::DidAttach(), target "
2945 "Process::%s after SystemRuntime::DidAttach(), target "
2985 "Process::%s after looping through modules, target executable is %s",
2993 Status Process::ConnectRemote(Stream *strm, llvm::StringRef remote_url) {
3025 Status Process::PrivateResume() {
3029 "Process::PrivateResume() m_stop_id = %u, public state: %s "
3052 "Process::PrivateResume PreResumeActions failed, not resuming.");
3059 LLDB_LOGF(log, "Process thinks the process has resumed.");
3061 LLDB_LOGF(log, "Process::PrivateResume() DoResume failed.");
3071 "Process::PrivateResume() asked to simulate a start & stop.");
3077 LLDB_LOGF(log, "Process::PrivateResume() got an error \"%s\".",
3082 Status Process::Halt(bool clear_thread_plans, bool use_run_lock) {
3084 return Status("Process is not running.");
3122 Status Process::StopForDestroyOrDetach(lldb::EventSP &exit_event_sp) {
3131 LLDB_LOGF(log, "Process::%s() About to stop.", __FUNCTION__);
3134 Listener::MakeListener("lldb.Process.StopForDestroyOrDetach.hijack"));
3151 LLDB_LOGF(log, "Process::%s() Process exited while waiting to stop.",
3158 LLDB_LOGF(log, "Process::%s() failed to stop, state is: %s", __FUNCTION__,
3175 Status Process::Detach(bool keep_stopped) {
3227 Status Process::Destroy(bool force_kill) {
3298 Status Process::Signal(int signal) {
3308 void Process::SetUnixSignals(UnixSignalsSP &&signals_sp) {
3313 const lldb::UnixSignalsSP &Process::GetUnixSignals() {
3318 lldb::ByteOrder Process::GetByteOrder() const {
3322 uint32_t Process::GetAddressByteSize() const {
3326 bool Process::ShouldBroadcastEvent(Event *event_ptr) {
3328 Process::ProcessEventData::GetStateFromEvent(event_ptr);
3405 "Process::ShouldBroadcastEvent (%p) stopped due to an "
3426 "Process::ShouldBroadcastEvent: should_resume: %i state: "
3443 "Process::ShouldBroadcastEvent (%p) Restarting process "
3473 "Process::ShouldBroadcastEvent (%p) => new state: %s, last "
3481 bool Process::StartPrivateStateThread(bool is_secondary_thread) {
3485 LLDB_LOGF(log, "Process::%s()%s ", __FUNCTION__,
3517 ThreadLauncher::LaunchThread(thread_name, Process::PrivateStateThread,
3532 void Process::PausePrivateStateThread() {
3536 void Process::ResumePrivateStateThread() {
3540 void Process::StopPrivateStateThread() {
3551 void Process::ControlPrivateStateThread(uint32_t signal) {
3558 LLDB_LOGF(log, "Process::%s (signal = %d)", __FUNCTION__, signal);
3601 void Process::SendAsyncInterrupt() {
3603 m_private_state_broadcaster.BroadcastEvent(Process::eBroadcastBitInterrupt,
3606 BroadcastEvent(Process::eBroadcastBitInterrupt, nullptr);
3609 void Process::HandlePrivateEvent(EventSP &event_sp) {
3614 Process::ProcessEventData::GetStateFromEvent(event_sp.get());
3652 "Process::%s (pid = %" PRIu64
3658 Process::ProcessEventData::SetUpdateStateOnRemoval(event_sp.get());
3668 LLDB_LOGF(log, "Process::%s updated m_iohandler_sync to %d",
3672 if (!Process::ProcessEventData::GetRestartedFromEvent(event_sp.get())) {
3712 "Process::%s (pid = %" PRIu64
3720 Status Process::HaltPrivate() {
3734 thread_result_t Process::PrivateStateThread(void *arg) {
3742 thread_result_t Process::RunPrivateStateThread(bool is_secondary_thread) {
3746 LLDB_LOGF(log, "Process::%s (arg = %p, pid = %" PRIu64 ") thread starting...",
3756 "Process::%s (arg = %p, pid = %" PRIu64
3779 "Process::%s (arg = %p, pid = %" PRIu64
3786 "Process::%s (arg = %p, pid = %" PRIu64
3792 "Process::%s (arg = %p, pid = %" PRIu64
3803 // This can happen when someone (e.g. Process::Halt) sees that we are
3810 "Process::%s ignoring interrupt as we have already stopped.",
3817 Process::ProcessEventData::GetStateFromEvent(event_sp.get());
3834 "Process::%s interrupt_requested, but a non-stopped "
3846 "Process::%s (arg = %p, pid = %" PRIu64
3856 LLDB_LOGF(log, "Process::%s (arg = %p, pid = %" PRIu64 ") thread exiting...",
3867 // Process Event Data
3869 Process::ProcessEventData::ProcessEventData()
3873 Process::ProcessEventData::ProcessEventData(const ProcessSP &process_sp,
3881 Process::ProcessEventData::~ProcessEventData() = default;
3883 ConstString Process::ProcessEventData::GetFlavorString() {
3884 static ConstString g_flavor("Process::ProcessEventData");
3888 ConstString Process::ProcessEventData::GetFlavor() const {
3892 void Process::ProcessEventData::DoOnRemoval(Event *event_ptr) {
3910 m_state, Process::ProcessEventData::GetRestartedFromEvent(event_ptr));
4042 void Process::ProcessEventData::Dump(Stream *s) const {
4054 const Process::ProcessEventData *
4055 Process::ProcessEventData::GetEventDataFromEvent(const Event *event_ptr) {
4066 Process::ProcessEventData::GetProcessFromEvent(const Event *event_ptr) {
4074 StateType Process::ProcessEventData::GetStateFromEvent(const Event *event_ptr) {
4082 bool Process::ProcessEventData::GetRestartedFromEvent(const Event *event_ptr) {
4090 void Process::ProcessEventData::SetRestartedInEvent(Event *event_ptr,
4099 Process::ProcessEventData::GetNumRestartedReasons(const Event *event_ptr) {
4109 Process::ProcessEventData::GetRestartedReasonAtIndex(const Event *event_ptr,
4119 void Process::ProcessEventData::AddRestartedReason(Event *event_ptr,
4127 bool Process::ProcessEventData::GetInterruptedFromEvent(
4136 void Process::ProcessEventData::SetInterruptedInEvent(Event *event_ptr,
4144 bool Process::ProcessEventData::SetUpdateStateOnRemoval(Event *event_ptr) {
4154 lldb::TargetSP Process::CalculateTarget() { return m_target_wp.lock(); }
4156 void Process::CalculateExecutionContext(ExecutionContext &exe_ctx) {
4164 // Process::ListProcessesMatchingName (const char *name, StringList &matches,
4171 // Process::GetArchSpecForExistingProcess (lldb::pid_t pid)
4177 // Process::GetArchSpecForExistingProcess (const char *process_name)
4182 void Process::AppendSTDOUT(const char *s, size_t len) {
4189 void Process::AppendSTDERR(const char *s, size_t len) {
4196 void Process::BroadcastAsyncProfileData(const std::string &one_profile_data) {
4203 void Process::BroadcastStructuredData(const StructuredData::ObjectSP &object_sp,
4211 Process::GetStructuredDataPlugin(ConstString type_name) const {
4219 size_t Process::GetAsyncProfileData(char *buf, size_t buf_size, Status &error) {
4228 LLDB_LOGF(log, "Process::GetProfileData (buf = %p, size = %" PRIu64 ")",
4242 // Process STDIO
4244 size_t Process::GetSTDOUT(char *buf, size_t buf_size, Status &error) {
4249 LLDB_LOGF(log, "Process::GetSTDOUT (buf = %p, size = %" PRIu64 ")",
4263 size_t Process::GetSTDERR(char *buf, size_t buf_size, Status &error) {
4268 LLDB_LOGF(log, "Process::GetSTDERR (buf = %p, size = %" PRIu64 ")",
4282 void Process::STDIOReadThreadBytesReceived(void *baton, const void *src,
4284 Process *process = (Process *)baton;
4290 IOHandlerProcessSTDIO(Process *process, int write_fd)
4415 Process *m_process;
4423 void Process::SetSTDIOFileDescriptor(int fd) {
4445 bool Process::ProcessIOHandlerIsActive() {
4451 bool Process::PushProcessIOHandler() {
4455 LLDB_LOGF(log, "Process::%s pushing IO handler", __FUNCTION__);
4469 bool Process::PopProcessIOHandler() {
4477 void Process::SettingsInitialize() { Thread::SettingsInitialize(); }
4479 void Process::SettingsTerminate() { Thread::SettingsTerminate(); }
4589 Process::ProcessEventData::GetInterruptedFromEvent(event_sp.get()))
4599 Process::RunThreadPlan(ExecutionContext &exe_ctx,
4776 "Process::RunThreadPlan(): Resuming thread %u - 0x%4.4" PRIx64
4866 "Process::RunThreadPlan(): didn't get any event after "
4879 Process::ProcessEventData::GetStateFromEvent(event_sp.get());
4885 restarted = Process::ProcessEventData::GetRestartedFromEvent(
4889 "Process::RunThreadPlan(): didn't get running event after "
4914 log->PutCString("Process::RunThreadPlan(): resuming succeeded.");
4922 log->PutCString("Process::RunThreadPlan(): waiting for next event.");
4937 "Process::RunThreadPlan(): about to wait - now is %s - "
4942 LLDB_LOGF(log, "Process::RunThreadPlan(): about to wait forever.");
4966 LLDB_LOGF(log, "Process::RunThreadPlan(): Got interrupted by "
4971 Process::ProcessEventData::GetStateFromEvent(event_sp.get());
4973 "Process::RunThreadPlan(): in while loop, got event: %s.",
4985 "Process::RunThreadPlan(): execution completed "
4989 } else if (Process::ProcessEventData::GetRestartedFromEvent(
4994 LLDB_LOGF(log, "Process::RunThreadPlan(): Got a stop and "
5019 "Process::RunThreadPlan(): execution stopped with "
5040 log->PutCString("Process::RunThreadPlan(): got_event was true, but "
5082 LLDB_LOGF(log, "Process::RunThreadPlan(): Running Halt.");
5089 log->PutCString("Process::RunThreadPlan(): Halt succeeded.");
5096 Process::ProcessEventData::GetStateFromEvent(event_sp.get());
5099 "Process::RunThreadPlan(): Stopped with event: %s",
5102 Process::ProcessEventData::GetInterruptedFromEvent(
5108 if (Process::ProcessEventData::GetRestartedFromEvent(
5111 log->PutCString("Process::RunThreadPlan(): Went to halt "
5135 log->PutCString("Process::RunThreadPlan(): try_all_threads "
5150 "Process::RunThreadPlan(): about to resume.");
5157 log->PutCString("Process::RunThreadPlan(): running all "
5166 log->PutCString("Process::RunThreadPlan(): halt said it "
5227 log->PutCString("Process::RunThreadPlan(): Stop event that "
5243 const Process::ProcessEventData *event_data =
5244 Process::ProcessEventData::GetEventDataFromEvent(
5252 Process *process = event_data->GetProcessSP().get();
5300 "Process::RunThreadPlan(): execution interrupted: %s %s",
5303 LLDB_LOGF(log, "Process::RunThreadPlan(): execution interrupted: %s",
5309 "Process::RunThreadPlan: ExecutionInterrupted - "
5315 "Process::RunThreadPlan: ExecutionInterrupted - for "
5321 log->PutCString("Process::RunThreadPlan(): execution set up error.");
5329 log->PutCString("Process::RunThreadPlan(): thread plan is done");
5334 "Process::RunThreadPlan(): thread plan was discarded");
5339 "Process::RunThreadPlan(): thread plan stopped in mid course");
5342 log->PutCString("Process::RunThreadPlan(): discarding thread plan "
5379 log->PutCString("Process::RunThreadPlan(): rebroadcasting event.");
5386 const char *Process::ExecutionResultAsCString(ExpressionResults result) {
5421 void Process::GetStatus(Stream &strm) {
5427 strm.Printf("Process %" PRIu64 " exited with status = %i (0x%8.8x) %s\n",
5434 strm.Printf("Process %" PRIu64 " %s\n", GetID(), StateAsCString(state));
5437 strm.Printf("Process %" PRIu64 " is running.\n", GetID());
5441 size_t Process::GetThreadStatus(Stream &strm,
5480 LLDB_LOGF(log, "Process::GetThreadStatus - thread 0x" PRIu64
5487 void Process::AddInvalidMemoryRegion(const LoadRange ®ion) {
5491 bool Process::RemoveInvalidMemoryRange(const LoadRange ®ion) {
5496 void Process::AddPreResumeAction(PreResumeActionCallback callback,
5501 bool Process::RunPreResumeActions() {
5513 void Process::ClearPreResumeActions() { m_pre_resume_actions.clear(); }
5515 void Process::ClearPreResumeAction(PreResumeActionCallback callback, void *baton)
5525 ProcessRunLock &Process::GetRunLock() {
5532 bool Process::CurrentThreadIsPrivateStateThread()
5538 void Process::Flush() {
5546 void Process::DidExec() {
5548 LLDB_LOGF(log, "Process::%s()", __FUNCTION__);
5580 addr_t Process::ResolveIndirectFunction(const Address *address, Status &error) {
5608 void Process::ModulesDidLoad(ModuleList &module_list) {
5658 void Process::PrintWarning(uint64_t warning_type, const void *repeat_key,
5691 void Process::PrintWarningOptimization(const SymbolContext &sc) {
5695 PrintWarning(Process::Warnings::eWarningsOptimization, sc.module_sp.get(),
5702 bool Process::GetProcessInfo(ProcessInstanceInfo &info) {
5712 ThreadCollectionSP Process::GetHistoryThreads(lldb::addr_t addr) {
5729 Process::GetInstrumentationRuntime(lldb::InstrumentationRuntimeType type) {
5738 bool Process::GetModuleSpec(const FileSpec &module_file_spec,
5744 size_t Process::AddImageToken(lldb::addr_t image_ptr) {
5749 lldb::addr_t Process::GetImagePtrFromToken(size_t token) const {
5755 void Process::ResetImageToken(size_t token) {
5761 Process::AdvanceAddressToNextBranchInstruction(Address default_stop_addr,
5815 Process::GetMemoryRegions(lldb_private::MemoryRegionInfos ®ion_list) {
5841 Process::ConfigureStructuredData(ConstString type_name,
5843 // If you get this, the Process-derived class needs to implement a method to
5849 void Process::MapSupportedStructuredDataPlugins(
5855 LLDB_LOGF(log, "Process::%s(): no structured data types supported",
5864 "Process::%s(): the process supports the following async "
5914 "Process::%s(): using plugin %s for type name "
5927 bool Process::RouteAsyncStructuredData(
5956 Status Process::UpdateAutomaticSignalFiltering() {
5962 UtilityFunction *Process::GetLoadImageUtilityFunction(
5972 bool Process::CallVoidArgVoidPtrReturn(const Address *address,