Lines Matching defs:Process
1 //===-- Process.cpp -------------------------------------------------------===//
54 #include "lldb/Target/Process.h"
104 Process *process = exe_ctx->GetProcessPtr();
119 ProcessMemoryIterator(Process &process, lldb::addr_t base)
139 Process &m_process;
188 ProcessProperties::ProcessProperties(lldb_private::Process *process)
201 OptionValueProperties::CreateLocalCopy(Process::GetGlobalProperties());
399 ProcessSP Process::FindPlugin(lldb::TargetSP target_sp,
440 llvm::StringRef Process::GetStaticBroadcasterClass() {
445 Process::Process(lldb::TargetSP target_sp, ListenerSP listener_sp)
446 : Process(target_sp, listener_sp, UnixSignals::CreateForHost()) {
447 // This constructor just delegates to the full Process constructor,
451 Process::Process(lldb::TargetSP target_sp, ListenerSP listener_sp,
455 Process::GetStaticBroadcasterClass().str()),
484 LLDB_LOGF(log, "%p Process::Process()", static_cast<void *>(this));
504 // It always listens for all the event bits for Process:
534 Process::~Process() {
536 LLDB_LOGF(log, "%p Process::~Process()", static_cast<void *>(this));
545 ProcessProperties &Process::GetGlobalProperties() {
553 void Process::Finalize(bool destructing) {
569 // We need to destroy the loader before the derived Process class gets
610 void Process::RegisterNotificationCallbacks(const Notifications &callbacks) {
616 bool Process::UnregisterNotificationCallbacks(const Notifications &callbacks) {
629 void Process::SynchronouslyNotifyStateChanged(StateType state) {
650 StateType Process::GetNextEvent(EventSP &event_sp) {
656 state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
661 void Process::SyncIOHandler(uint32_t iohandler_id,
670 Log *log = GetLog(LLDBLog::Process);
682 StateType Process::WaitForProcessToStop(
697 Log *log = GetLog(LLDBLog::Process);
703 "Process::%s returning without waiting for events; process "
720 Process::HandleProcessStateChangedEvent(
734 if (Process::ProcessEventData::GetRestartedFromEvent(event_sp.get()))
750 bool Process::HandleProcessStateChangedEvent(
758 Process::ProcessEventData::GetProcessFromEvent(event_sp.get());
764 Process::ProcessEventData::GetStateFromEvent(event_sp.get());
776 stream->Printf("Process %" PRIu64 " %s\n", process_sp->GetID(),
797 if (Process::ProcessEventData::GetRestartedFromEvent(event_sp.get())) {
800 Process::ProcessEventData::GetNumRestartedReasons(event_sp.get());
806 Process::ProcessEventData::GetRestartedReasonAtIndex(
808 stream->Printf("Process %" PRIu64 " stopped and restarted: %s\n",
812 stream->Printf("Process %" PRIu64
818 Process::ProcessEventData::GetRestartedReasonAtIndex(
983 bool Process::HijackProcessEvents(ListenerSP listener_sp) {
991 void Process::RestoreProcessEvents() { RestoreBroadcaster(); }
993 StateType Process::GetStateChangedEvents(EventSP &event_sp,
996 Log *log = GetLog(LLDBLog::Process);
1008 state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
1017 Event *Process::PeekAtStateChangedEvents() {
1018 Log *log = GetLog(LLDBLog::Process);
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__);
1037 Process::GetStateChangedEventsPrivate(EventSP &event_sp,
1039 Log *log = GetLog(LLDBLog::Process);
1048 state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
1055 bool Process::GetEventsPrivate(EventSP &event_sp,
1058 Log *log = GetLog(LLDBLog::Process);
1068 bool Process::IsRunning() const {
1072 int Process::GetExitStatus() {
1080 const char *Process::GetExitDescription() {
1088 bool Process::SetExitStatus(int status, llvm::StringRef exit_string) {
1092 Log *log(GetLog(LLDBLog::State | LLDBLog::Process));
1124 bool Process::IsAlive() {
1143 // lldb_private::Process doesn't go away before we can deliver the signal.
1144 bool Process::SetProcessExitStatus(
1149 Log *log = GetLog(LLDBLog::Process);
1151 "Process::SetProcessExitStatus (pid=%" PRIu64
1170 bool Process::UpdateThreadList(ThreadList &old_thread_list,
1176 void Process::UpdateThreadListIfNeeded() {
1202 // backed by actual threads from the lldb_private::Process subclass
1227 // created by each lldb_private::Process
1263 ThreadPlanStack *Process::FindThreadPlans(lldb::tid_t tid) {
1267 bool Process::PruneThreadPlansForTID(lldb::tid_t tid) {
1271 void Process::PruneThreadPlans() {
1275 bool Process::DumpThreadPlansForTID(Stream &strm, lldb::tid_t tid,
1282 void Process::DumpThreadPlans(Stream &strm, lldb::DescriptionLevel desc_level,
1289 void Process::UpdateQueueListIfNeeded() {
1302 ThreadSP Process::CreateOSPluginThread(lldb::tid_t tid, lldb::addr_t context) {
1309 uint32_t Process::GetNextThreadIndexID(uint64_t thread_id) {
1313 bool Process::HasAssignedIndexIDToThread(uint64_t thread_id) {
1318 uint32_t Process::AssignIndexIDToThread(uint64_t thread_id) {
1332 StateType Process::GetState() {
1339 void Process::SetPublicState(StateType new_state, bool restarted) {
1351 Log *log(GetLog(LLDBLog::State | LLDBLog::Process));
1379 Status Process::Resume() {
1380 Log *log(GetLog(LLDBLog::State | LLDBLog::Process));
1396 Status Process::ResumeSynchronous(Stream *stream) {
1397 Log *log(GetLog(LLDBLog::State | LLDBLog::Process));
1398 LLDB_LOGF(log, "Process::ResumeSynchronous -- locking run lock");
1401 LLDB_LOGF(log, "Process::Resume: -- TrySetRunning failed, not resuming.");
1431 bool Process::StateChangedIsExternallyHijacked() {
1440 bool Process::StateChangedIsHijackedForSynchronousResume() {
1449 StateType Process::GetPrivateState() { return m_private_state.GetValue(); }
1451 void Process::SetPrivateState(StateType new_state) {
1455 // not be true for an in-the-middle-of-being-destructed Process, since the
1456 // event system relies on Process::shared_from_this, which may have already
1461 Log *log(GetLog(LLDBLog::State | LLDBLog::Process | LLDBLog::Unwind));
1518 void Process::SetRunningUserExpression(bool on) {
1522 void Process::SetRunningUtilityFunction(bool on) {
1526 addr_t Process::GetImageInfoAddress() { return LLDB_INVALID_ADDRESS; }
1528 const lldb::ABISP &Process::GetABI() {
1534 std::vector<LanguageRuntime *> Process::GetLanguageRuntimes() {
1554 LanguageRuntime *Process::GetLanguageRuntime(lldb::LanguageType language) {
1582 bool Process::IsPossibleDynamicValue(ValueObject &in_value) {
1603 void Process::SetDynamicCheckers(DynamicCheckerFunctions *dynamic_checkers) {
1607 StopPointSiteList<BreakpointSite> &Process::GetBreakpointSiteList() {
1612 Process::GetBreakpointSiteList() const {
1616 void Process::DisableAllBreakpointSites() {
1623 Status Process::ClearBreakpointSiteByID(lldb::user_id_t break_id) {
1632 Status Process::DisableBreakpointSiteByID(lldb::user_id_t break_id) {
1646 Status Process::EnableBreakpointSiteByID(lldb::user_id_t break_id) {
1660 Process::CreateBreakpointSite(const BreakpointLocationSP &constituent,
1750 void Process::RemoveConstituentFromBreakpointSite(
1763 size_t Process::RemoveBreakpointOpcodesFromBuffer(addr_t bp_addr, size_t size,
1793 size_t Process::GetSoftwareBreakpointTrapOpcode(BreakpointSite *bp_site) {
1800 Status Process::EnableSoftwareBreakpoint(BreakpointSite *bp_site) {
1806 log, "Process::EnableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64,
1811 "Process::EnableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64
1821 // Ask the lldb::Process subclass to fill in the correct software breakpoint
1826 error.SetErrorStringWithFormat("Process::GetSoftwareBreakpointTrapOpcode() "
1853 "Process::EnableSoftwareBreakpoint (site_id = %d) "
1870 "Process::EnableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64
1876 Status Process::DisableSoftwareBreakpoint(BreakpointSite *bp_site) {
1883 "Process::DisableSoftwareBreakpoint (breakID = %" PRIu64
1933 "Process::DisableSoftwareBreakpoint (site_id = %d) "
1952 "Process::DisableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64
1960 "Process::DisableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64
1970 size_t Process::ReadMemory(addr_t addr, void *buf, size_t size, Status &error) {
2014 void Process::DoFindInMemory(lldb::addr_t start_addr, lldb::addr_t end_addr,
2045 AddressRanges Process::FindRangesInMemory(const uint8_t *buf, uint64_t size,
2099 lldb::addr_t Process::FindInMemory(const uint8_t *buf, uint64_t size,
2137 size_t Process::ReadCStringFromMemory(addr_t addr, std::string &out_str,
2159 size_t Process::ReadCStringFromMemory(addr_t addr, char *dst,
2205 size_t Process::ReadMemoryFromInferior(addr_t addr, void *buf, size_t size,
2234 uint64_t Process::ReadUnsignedIntegerFromMemory(lldb::addr_t vm_addr,
2245 int64_t Process::ReadSignedIntegerFromMemory(lldb::addr_t vm_addr,
2256 addr_t Process::ReadPointerFromMemory(lldb::addr_t vm_addr, Status &error) {
2264 bool Process::WritePointerToMemory(lldb::addr_t vm_addr, lldb::addr_t ptr_value,
2276 size_t Process::WriteMemoryPrivate(addr_t addr, const void *buf, size_t size,
2292 size_t Process::WriteMemory(addr_t addr, const void *buf, size_t size,
2374 size_t Process::WriteScalarToMemory(addr_t addr, const Scalar &scalar,
2392 size_t Process::ReadScalarIntegerFromMemory(addr_t addr, uint32_t byte_size,
2422 Status Process::WriteObjectFile(std::vector<ObjectFile::LoadableData> entries) {
2434 addr_t Process::AllocateMemory(size_t size, uint32_t permissions,
2445 Log *log = GetLog(LLDBLog::Process);
2447 "Process::AllocateMemory(size=%" PRIu64
2457 addr_t Process::CallocateMemory(size_t size, uint32_t permissions,
2467 bool Process::CanJIT() {
2469 Log *log = GetLog(LLDBLog::Process);
2479 "Process::%s pid %" PRIu64
2485 "Process::%s pid %" PRIu64
2496 void Process::SetCanJIT(bool can_jit) {
2500 void Process::SetCanRunCode(bool can_run_code) {
2505 Status Process::DeallocateMemory(addr_t ptr) {
2515 Log *log = GetLog(LLDBLog::Process);
2517 "Process::DeallocateMemory(addr=0x%16.16" PRIx64
2525 bool Process::GetWatchpointReportedAfter() {
2542 ModuleSP Process::ReadModuleFromMemory(const FileSpec &file_spec,
2548 "Process::ReadModuleFromMemory reading %s binary from memory",
2570 bool Process::GetLoadAddressPermissions(lldb::addr_t load_addr,
2586 Status Process::EnableWatchpoint(WatchpointSP wp_sp, bool notify) {
2592 Status Process::DisableWatchpoint(WatchpointSP wp_sp, bool notify) {
2599 Process::WaitForProcessStopPrivate(EventSP &event_sp,
2620 void Process::LoadOperatingSystemPlugin(bool flush) {
2629 Status Process::Launch(ProcessLaunchInfo &launch_info) {
2661 Status Process::LaunchPrivate(ProcessLaunchInfo &launch_info, StateType &state,
2796 Status Process::LoadCore() {
2832 Log *log = GetLog(LLDBLog::Process);
2833 LLDB_LOGF(log, "Process::Halt() failed to stop, state is: %s",
2843 DynamicLoader *Process::GetDynamicLoader() {
2849 void Process::SetDynamicLoader(DynamicLoaderUP dyld_up) {
2853 DataExtractor Process::GetAuxvData() { return DataExtractor(); }
2855 llvm::Expected<bool> Process::SaveCore(llvm::StringRef outfile) {
2859 JITLoaderList &Process::GetJITLoaders() {
2867 SystemRuntime *Process::GetSystemRuntime() {
2873 Process::AttachCompletionHandler::AttachCompletionHandler(Process *process,
2876 Log *log = GetLog(LLDBLog::Process);
2879 "Process::AttachCompletionHandler::%s process=%p, exec_count=%" PRIu32,
2883 Process::NextEventAction::EventActionResult
2884 Process::AttachCompletionHandler::PerformAction(lldb::EventSP &event_sp) {
2885 Log *log = GetLog(LLDBLog::Process);
2889 "Process::AttachCompletionHandler::%s called with state %s (%d)",
2903 // lldb_private::Process subclasses must set the new process ID.
2913 "Process::AttachCompletionHandler::%s state %s: reduced "
2921 "Process::AttachCompletionHandler::%s state %s: no more "
2936 m_exit_string.assign("No valid Process");
2940 Process::NextEventAction::EventActionResult
2941 Process::AttachCompletionHandler::HandleBeingInterrupted() {
2945 const char *Process::AttachCompletionHandler::GetExitString() {
2956 Status Process::WillLaunch(Module *module) {
2960 Status Process::WillAttachToProcessWithID(lldb::pid_t pid) {
2964 Status Process::WillAttachToProcessWithName(const char *process_name,
2969 Status Process::Attach(ProcessAttachInfo &attach_info) {
3012 SetNextEventAction(new Process::AttachCompletionHandler(
3075 SetNextEventAction(new Process::AttachCompletionHandler(
3093 void Process::CompleteAttach() {
3094 Log *log(GetLog(LLDBLog::Process | LLDBLog::Target));
3095 LLDB_LOGF(log, "Process::%s()", __FUNCTION__);
3104 "Process::{0} replacing process architecture with DidAttach() "
3142 "Process::%s switching architecture to %s based on info "
3212 "Process::%s after looping through modules, target executable is %s",
3220 Status Process::ConnectRemote(llvm::StringRef remote_url) {
3255 Status Process::PrivateResume() {
3256 Log *log(GetLog(LLDBLog::Process | LLDBLog::Step));
3258 "Process::PrivateResume() m_stop_id = %u, public state: %s "
3281 "Process::PrivateResume PreResumeActions failed, not resuming.");
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\".",
3311 Status Process::Halt(bool clear_thread_plans, bool use_run_lock) {
3313 return Status("Process is not running.");
3356 lldb::addr_t Process::FindInMemory(lldb::addr_t low, lldb::addr_t high,
3383 Status Process::StopForDestroyOrDetach(lldb::EventSP &exit_event_sp) {
3391 Log *log = GetLog(LLDBLog::Process);
3392 LLDB_LOGF(log, "Process::%s() About to stop.", __FUNCTION__);
3395 Listener::MakeListener("lldb.Process.StopForDestroyOrDetach.hijack"));
3412 LLDB_LOGF(log, "Process::%s() Process exited while waiting to stop.",
3419 LLDB_LOGF(log, "Process::%s() failed to stop, state is: %s", __FUNCTION__,
3436 Status Process::Detach(bool keep_stopped) {
3488 Status Process::Destroy(bool force_kill) {
3489 // If we've already called Process::Finalize then there's nothing useful to
3496 Status Process::DestroyImpl(bool force_kill) {
3569 Status Process::Signal(int signal) {
3579 void Process::SetUnixSignals(UnixSignalsSP &&signals_sp) {
3584 const lldb::UnixSignalsSP &Process::GetUnixSignals() {
3589 lldb::ByteOrder Process::GetByteOrder() const {
3593 uint32_t Process::GetAddressByteSize() const {
3597 bool Process::ShouldBroadcastEvent(Event *event_ptr) {
3599 Process::ProcessEventData::GetStateFromEvent(event_ptr);
3601 Log *log(GetLog(LLDBLog::Events | LLDBLog::Process));
3675 "Process::ShouldBroadcastEvent (%p) stopped due to an "
3696 "Process::ShouldBroadcastEvent: should_resume: %i state: "
3713 "Process::ShouldBroadcastEvent (%p) Restarting process "
3743 "Process::ShouldBroadcastEvent (%p) => new state: %s, last "
3751 bool Process::StartPrivateStateThread(bool is_secondary_thread) {
3755 LLDB_LOGF(log, "Process::%s()%s ", __FUNCTION__,
3802 void Process::PausePrivateStateThread() {
3806 void Process::ResumePrivateStateThread() {
3810 void Process::StopPrivateStateThread() {
3814 Log *log = GetLog(LLDBLog::Process);
3821 void Process::ControlPrivateStateThread(uint32_t signal) {
3822 Log *log = GetLog(LLDBLog::Process);
3828 LLDB_LOGF(log, "Process::%s (signal = %d)", __FUNCTION__, signal);
3871 void Process::SendAsyncInterrupt() {
3873 m_private_state_broadcaster.BroadcastEvent(Process::eBroadcastBitInterrupt,
3876 BroadcastEvent(Process::eBroadcastBitInterrupt, nullptr);
3879 void Process::HandlePrivateEvent(EventSP &event_sp) {
3880 Log *log = GetLog(LLDBLog::Process);
3884 Process::ProcessEventData::GetStateFromEvent(event_sp.get());
3922 "Process::%s (pid = %" PRIu64
3928 Process::ProcessEventData::SetUpdateStateOnRemoval(event_sp.get());
3938 LLDB_LOGF(log, "Process::%s updated m_iohandler_sync to %d",
3942 if (!Process::ProcessEventData::GetRestartedFromEvent(event_sp.get())) {
3982 "Process::%s (pid = %" PRIu64
3990 Status Process::HaltPrivate() {
4004 thread_result_t Process::RunPrivateStateThread(bool is_secondary_thread) {
4007 Log *log = GetLog(LLDBLog::Process);
4008 LLDB_LOGF(log, "Process::%s (arg = %p, pid = %" PRIu64 ") thread starting...",
4018 "Process::%s (arg = %p, pid = %" PRIu64
4041 "Process::%s (arg = %p, pid = %" PRIu64
4055 "Process::%s (arg = %p, pid = %" PRIu64
4061 "Process::%s (arg = %p, pid = %" PRIu64
4072 // This can happen when someone (e.g. Process::Halt) sees that we are
4079 "Process::%s ignoring interrupt as we have already stopped.",
4086 Process::ProcessEventData::GetStateFromEvent(event_sp.get());
4103 "Process::%s interrupt_requested, but a non-stopped "
4115 "Process::%s (arg = %p, pid = %" PRIu64
4125 LLDB_LOGF(log, "Process::%s (arg = %p, pid = %" PRIu64 ") thread exiting...",
4136 // Process Event Data
4138 Process::ProcessEventData::ProcessEventData() : EventData(), m_process_wp() {}
4140 Process::ProcessEventData::ProcessEventData(const ProcessSP &process_sp,
4147 Process::ProcessEventData::~ProcessEventData() = default;
4149 llvm::StringRef Process::ProcessEventData::GetFlavorString() {
4150 return "Process::ProcessEventData";
4153 llvm::StringRef Process::ProcessEventData::GetFlavor() const {
4157 bool Process::ProcessEventData::ShouldStop(Event *event_ptr,
4205 Log *log(GetLog(LLDBLog::Step | LLDBLog::Process));
4214 Log *log(GetLog(LLDBLog::Step | LLDBLog::Process));
4253 bool Process::ProcessEventData::ForwardEventToPendingListeners(
4256 if (event_ptr->GetType() != Process::eBroadcastBitStateChanged)
4264 void Process::ProcessEventData::DoOnRemoval(Event *event_ptr) {
4266 if (event_ptr->GetType() != Process::eBroadcastBitStateChanged)
4286 m_state, Process::ProcessEventData::GetRestartedFromEvent(event_ptr));
4336 void Process::ProcessEventData::Dump(Stream *s) const {
4348 const Process::ProcessEventData *
4349 Process::ProcessEventData::GetEventDataFromEvent(const Event *event_ptr) {
4360 Process::ProcessEventData::GetProcessFromEvent(const Event *event_ptr) {
4368 StateType Process::ProcessEventData::GetStateFromEvent(const Event *event_ptr) {
4376 bool Process::ProcessEventData::GetRestartedFromEvent(const Event *event_ptr) {
4384 void Process::ProcessEventData::SetRestartedInEvent(Event *event_ptr,
4393 Process::ProcessEventData::GetNumRestartedReasons(const Event *event_ptr) {
4403 Process::ProcessEventData::GetRestartedReasonAtIndex(const Event *event_ptr,
4413 void Process::ProcessEventData::AddRestartedReason(Event *event_ptr,
4421 bool Process::ProcessEventData::GetInterruptedFromEvent(
4430 void Process::ProcessEventData::SetInterruptedInEvent(Event *event_ptr,
4438 bool Process::ProcessEventData::SetUpdateStateOnRemoval(Event *event_ptr) {
4448 lldb::TargetSP Process::CalculateTarget() { return m_target_wp.lock(); }
4450 void Process::CalculateExecutionContext(ExecutionContext &exe_ctx) {
4458 // Process::ListProcessesMatchingName (const char *name, StringList &matches,
4465 // Process::GetArchSpecForExistingProcess (lldb::pid_t pid)
4471 // Process::GetArchSpecForExistingProcess (const char *process_name)
4476 EventSP Process::CreateEventFromProcessState(uint32_t event_type) {
4482 void Process::AppendSTDOUT(const char *s, size_t len) {
4489 void Process::AppendSTDERR(const char *s, size_t len) {
4496 void Process::BroadcastAsyncProfileData(const std::string &one_profile_data) {
4503 void Process::BroadcastStructuredData(const StructuredData::ObjectSP &object_sp,
4511 Process::GetStructuredDataPlugin(llvm::StringRef type_name) const {
4519 size_t Process::GetAsyncProfileData(char *buf, size_t buf_size, Status &error) {
4527 Log *log = GetLog(LLDBLog::Process);
4528 LLDB_LOGF(log, "Process::GetProfileData (buf = %p, size = %" PRIu64 ")",
4542 // Process STDIO
4544 size_t Process::GetSTDOUT(char *buf, size_t buf_size, Status &error) {
4548 Log *log = GetLog(LLDBLog::Process);
4549 LLDB_LOGF(log, "Process::GetSTDOUT (buf = %p, size = %" PRIu64 ")",
4563 size_t Process::GetSTDERR(char *buf, size_t buf_size, Status &error) {
4567 Log *log = GetLog(LLDBLog::Process);
4568 LLDB_LOGF(log, "Process::GetSTDERR (buf = %p, size = %" PRIu64 ")",
4582 void Process::STDIOReadThreadBytesReceived(void *baton, const void *src,
4584 Process *process = (Process *)baton;
4590 IOHandlerProcessSTDIO(Process *process, int write_fd)
4723 Process *m_process;
4732 void Process::SetSTDIOFileDescriptor(int fd) {
4751 bool Process::ProcessIOHandlerIsActive() {
4759 bool Process::PushProcessIOHandler() {
4763 Log *log = GetLog(LLDBLog::Process);
4764 LLDB_LOGF(log, "Process::%s pushing IO handler", __FUNCTION__);
4779 bool Process::PopProcessIOHandler() {
4788 void Process::SettingsInitialize() { Thread::SettingsInitialize(); }
4790 void Process::SettingsTerminate() { Thread::SettingsTerminate(); }
4873 Log *log = GetLog(LLDBLog::Step | LLDBLog::Process);
4915 Process::ProcessEventData::GetInterruptedFromEvent(event_sp.get()))
4925 Process::RunThreadPlan(ExecutionContext &exe_ctx,
5043 Log *log(GetLog(LLDBLog::Step | LLDBLog::Process));
5107 "Process::RunThreadPlan(): Resuming thread %u - 0x%4.4" PRIx64
5197 "Process::RunThreadPlan(): didn't get any event after "
5210 Process::ProcessEventData::GetStateFromEvent(event_sp.get());
5216 restarted = Process::ProcessEventData::GetRestartedFromEvent(
5220 "Process::RunThreadPlan(): didn't get running event after "
5245 log->PutCString("Process::RunThreadPlan(): resuming succeeded.");
5253 log->PutCString("Process::RunThreadPlan(): waiting for next event.");
5268 "Process::RunThreadPlan(): about to wait - now is %s - "
5273 LLDB_LOGF(log, "Process::RunThreadPlan(): about to wait forever.");
5297 LLDB_LOGF(log, "Process::RunThreadPlan(): Got interrupted by "
5302 Process::ProcessEventData::GetStateFromEvent(event_sp.get());
5304 "Process::RunThreadPlan(): in while loop, got event: %s.",
5309 if (Process::ProcessEventData::GetRestartedFromEvent(
5313 LLDB_LOGF(log, "Process::RunThreadPlan(): Got a stop and "
5340 "Process::RunThreadPlan(): execution stopped with "
5361 log->PutCString("Process::RunThreadPlan(): got_event was true, but "
5403 LLDB_LOGF(log, "Process::RunThreadPlan(): Running Halt.");
5410 log->PutCString("Process::RunThreadPlan(): Halt succeeded.");
5417 Process::ProcessEventData::GetStateFromEvent(event_sp.get());
5420 "Process::RunThreadPlan(): Stopped with event: %s",
5423 Process::ProcessEventData::GetInterruptedFromEvent(
5429 if (Process::ProcessEventData::GetRestartedFromEvent(
5432 log->PutCString("Process::RunThreadPlan(): Went to halt "
5457 log->PutCString("Process::RunThreadPlan(): try_all_threads "
5472 "Process::RunThreadPlan(): about to resume.");
5479 log->PutCString("Process::RunThreadPlan(): running all "
5488 log->PutCString("Process::RunThreadPlan(): halt said it "
5556 log->PutCString("Process::RunThreadPlan(): Stop event that "
5572 const Process::ProcessEventData *event_data =
5573 Process::ProcessEventData::GetEventDataFromEvent(
5581 Process *process = event_data->GetProcessSP().get();
5629 "Process::RunThreadPlan(): execution interrupted: %s %s",
5632 LLDB_LOGF(log, "Process::RunThreadPlan(): execution interrupted: %s",
5638 "Process::RunThreadPlan: ExecutionInterrupted - "
5644 "Process::RunThreadPlan: ExecutionInterrupted - for "
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 "
5708 log->PutCString("Process::RunThreadPlan(): rebroadcasting event.");
5715 const char *Process::ExecutionResultAsCString(ExpressionResults result) {
5752 void Process::GetStatus(Stream &strm) {
5758 strm.Printf("Process %" PRIu64 " exited with status = %i (0x%8.8x) %s\n",
5765 strm.Printf("Process %" PRIu64 " %s\n", GetID(), StateAsCString(state));
5768 strm.Printf("Process %" PRIu64 " is running.\n", GetID());
5772 size_t Process::GetThreadStatus(Stream &strm,
5810 Log *log = GetLog(LLDBLog::Process);
5811 LLDB_LOGF(log, "Process::GetThreadStatus - thread 0x" PRIu64
5818 void Process::AddInvalidMemoryRegion(const LoadRange ®ion) {
5822 bool Process::RemoveInvalidMemoryRange(const LoadRange ®ion) {
5827 void Process::AddPreResumeAction(PreResumeActionCallback callback,
5832 bool Process::RunPreResumeActions() {
5844 void Process::ClearPreResumeActions() { m_pre_resume_actions.clear(); }
5846 void Process::ClearPreResumeAction(PreResumeActionCallback callback, void *baton)
5856 ProcessRunLock &Process::GetRunLock() {
5863 bool Process::CurrentThreadIsPrivateStateThread()
5869 void Process::Flush() {
5877 lldb::addr_t Process::GetCodeAddressMask() {
5884 lldb::addr_t Process::GetDataAddressMask() {
5891 lldb::addr_t Process::GetHighmemCodeAddressMask() {
5900 lldb::addr_t Process::GetHighmemDataAddressMask() {
5909 void Process::SetCodeAddressMask(lldb::addr_t code_address_mask) {
5910 LLDB_LOG(GetLog(LLDBLog::Process),
5911 "Setting Process code address mask to {0:x}", code_address_mask);
5915 void Process::SetDataAddressMask(lldb::addr_t data_address_mask) {
5916 LLDB_LOG(GetLog(LLDBLog::Process),
5917 "Setting Process data address mask to {0:x}", data_address_mask);
5921 void Process::SetHighmemCodeAddressMask(lldb::addr_t code_address_mask) {
5922 LLDB_LOG(GetLog(LLDBLog::Process),
5923 "Setting Process highmem code address mask to {0:x}",
5928 void Process::SetHighmemDataAddressMask(lldb::addr_t data_address_mask) {
5929 LLDB_LOG(GetLog(LLDBLog::Process),
5930 "Setting Process highmem data address mask to {0:x}",
5935 addr_t Process::FixCodeAddress(addr_t addr) {
5941 addr_t Process::FixDataAddress(addr_t addr) {
5947 addr_t Process::FixAnyAddress(addr_t addr) {
5953 void Process::DidExec() {
5954 Log *log = GetLog(LLDBLog::Process);
5955 LLDB_LOGF(log, "Process::%s()", __FUNCTION__);
5989 addr_t Process::ResolveIndirectFunction(const Address *address, Status &error) {
6019 void Process::ModulesDidLoad(ModuleList &module_list) {
6053 void Process::PrintWarningOptimization(const SymbolContext &sc) {
6061 void Process::PrintWarningUnsupportedLanguage(const SymbolContext &sc) {
6079 bool Process::GetProcessInfo(ProcessInstanceInfo &info) {
6089 ThreadCollectionSP Process::GetHistoryThreads(lldb::addr_t addr) {
6106 Process::GetInstrumentationRuntime(lldb::InstrumentationRuntimeType type) {
6115 bool Process::GetModuleSpec(const FileSpec &module_file_spec,
6121 size_t Process::AddImageToken(lldb::addr_t image_ptr) {
6126 lldb::addr_t Process::GetImagePtrFromToken(size_t token) const {
6132 void Process::ResetImageToken(size_t token) {
6138 Process::AdvanceAddressToNextBranchInstruction(Address default_stop_addr,
6186 Status Process::GetMemoryRegionInfo(lldb::addr_t load_addr,
6193 Status Process::GetMemoryRegions(lldb_private::MemoryRegionInfos ®ion_list) {
6230 Process::ConfigureStructuredData(llvm::StringRef type_name,
6232 // If you get this, the Process-derived class needs to implement a method to
6238 void Process::MapSupportedStructuredDataPlugins(
6240 Log *log = GetLog(LLDBLog::Process);
6308 bool Process::RouteAsyncStructuredData(
6337 Status Process::UpdateAutomaticSignalFiltering() {
6343 UtilityFunction *Process::GetLoadImageUtilityFunction(
6353 llvm::Expected<TraceSupportedResponse> Process::TraceSupported() {
6360 bool Process::CallVoidArgVoidPtrReturn(const Address *address,
6418 llvm::Expected<const MemoryTagManager *> Process::GetMemoryTagManager() {
6430 "Process does not support memory tagging");
6437 Process::ReadMemoryTags(lldb::addr_t addr, size_t len) {
6453 Status Process::WriteMemoryTags(lldb::addr_t addr, size_t len,
6472 static Process::CoreFileMemoryRange
6483 Process::CoreFileMemoryRanges &ranges) {
6522 Process::CoreFileMemoryRanges &ranges) {
6535 Process &process, const MemoryRegionInfos ®ions,
6536 Process::CoreFileMemoryRanges &ranges, std::set<addr_t> &stack_ends) {
6568 static void GetCoreFileSaveRangesFull(Process &process,
6570 Process::CoreFileMemoryRanges &ranges,
6585 Process &process, const MemoryRegionInfos ®ions,
6586 Process::CoreFileMemoryRanges &ranges, std::set<addr_t> &stack_ends) {
6616 Process &process, const MemoryRegionInfos ®ions,
6617 Process::CoreFileMemoryRanges &ranges, std::set<addr_t> &stack_ends) {
6630 Status Process::CalculateCoreFileSaveRanges(lldb::SaveCoreStyle core_style,
6671 void Process::SetAddressableBitMasks(AddressableBits bit_masks) {