LLDB  mainline
Classes | Public Types | Public Member Functions | Static Public Member Functions | Protected Types | Protected Member Functions | Static Protected Member Functions | Protected Attributes | Private Member Functions | Static Private Member Functions | Friends | List of all members
lldb_private::Process Class Referenceabstract

#include "lldb/Target/Process.h"

Inheritance diagram for lldb_private::Process:
Inheritance graph
[legend]
Collaboration diagram for lldb_private::Process:
Collaboration graph
[legend]

Classes

class  AttachCompletionHandler
 
class  NextEventAction
 
struct  Notifications
 A notification structure that can be used by clients to listen for changes in a process's lifetime. More...
 
struct  PreResumeCallbackAndBaton
 
struct  PrivateStateThreadArgs
 
class  ProcessEventData
 
class  ProcessEventHijacker
 

Public Types

enum  {
  eBroadcastBitStateChanged = (1 << 0), eBroadcastBitInterrupt = (1 << 1), eBroadcastBitSTDOUT = (1 << 2), eBroadcastBitSTDERR = (1 << 3),
  eBroadcastBitProfileData = (1 << 4), eBroadcastBitStructuredData = (1 << 5)
}
 Broadcaster event bits definitions. More...
 
enum  { eBroadcastInternalStateControlStop = (1 << 0), eBroadcastInternalStateControlPause = (1 << 1), eBroadcastInternalStateControlResume = (1 << 2) }
 
enum  Warnings { eWarningsOptimization = 1, eWarningsUnsupportedLanguage = 2 }
 Process warning types. More...
 
typedef Range< lldb::addr_t, lldb::addr_tLoadRange
 
typedef ProcessRunLock::ProcessRunLocker StopLocker
 
typedef bool() PreResumeActionCallback(void *)
 

Public Member Functions

ConstStringGetBroadcasterClass () const override
 This needs to be filled in if you are going to register the broadcaster with the broadcaster manager and do broadcaster class matching. More...
 
 Process (lldb::TargetSP target_sp, lldb::ListenerSP listener_sp)
 Construct with a shared pointer to a target, and the Process listener. More...
 
 Process (lldb::TargetSP target_sp, lldb::ListenerSP listener_sp, const lldb::UnixSignalsSP &unix_signals_sp)
 Construct with a shared pointer to a target, the Process listener, and the appropriate UnixSignalsSP for the process. More...
 
 ~Process () override
 Destructor. More...
 
lldb::ByteOrder GetByteOrder () const
 
uint32_t GetAddressByteSize () const
 
lldb::pid_t GetID () const
 Returns the pid of the process or LLDB_INVALID_PROCESS_ID if there is no known pid. More...
 
void SetID (lldb::pid_t new_pid)
 Sets the stored pid. More...
 
uint32_t GetUniqueID () const
 
virtual bool CanDebug (lldb::TargetSP target, bool plugin_specified_by_name)=0
 Check if a plug-in instance can debug the file in module. More...
 
virtual void Finalize ()
 This object is about to be destroyed, do any necessary cleanup. More...
 
bool IsValid () const
 Return whether this object is valid (i.e. More...
 
virtual CommandObjectGetPluginCommandObject ()
 Return a multi-word command object that can be used to expose plug-in specific commands. More...
 
virtual Status Launch (ProcessLaunchInfo &launch_info)
 Launch a new process. More...
 
virtual Status LoadCore ()
 
virtual Status DoLoadCore ()
 
UtilityFunctionGetLoadImageUtilityFunction (Platform *platform, llvm::function_ref< std::unique_ptr< UtilityFunction >()> factory)
 Get the cached UtilityFunction that assists in loading binary images into the process. More...
 
virtual DynamicLoaderGetDynamicLoader ()
 Get the dynamic loader plug-in for this process. More...
 
virtual DataExtractor GetAuxvData ()
 
virtual llvm::Error LoadModules ()
 Sometimes processes know how to retrieve and load shared libraries. More...
 
virtual llvm::Expected< LoadedModuleInfoListGetLoadedModuleList ()
 Query remote GDBServer for a detailed loaded library list. More...
 
virtual llvm::Expected< bool > SaveCore (llvm::StringRef outfile)
 Save core dump into the specified file. More...
 
virtual SystemRuntimeGetSystemRuntime ()
 Get the system runtime plug-in for this process. More...
 
virtual Status Attach (ProcessAttachInfo &attach_info)
 Attach to an existing process using the process attach info. More...
 
virtual Status ConnectRemote (llvm::StringRef remote_url)
 Attach to a remote system via a URL. More...
 
bool GetShouldDetach () const
 
void SetShouldDetach (bool b)
 
const std::vector< lldb::addr_t > & GetImageTokens ()
 Get the image vector for the current process. More...
 
virtual lldb::addr_t GetImageInfoAddress ()
 Get the image information address for the current process. More...
 
virtual void WillPublicStop ()
 Called when the process is about to broadcast a public stop. More...
 
void RegisterNotificationCallbacks (const Process::Notifications &callbacks)
 Register for process and thread notifications. More...
 
bool UnregisterNotificationCallbacks (const Process::Notifications &callbacks)
 Unregister for process and thread notifications. More...
 
Status Resume ()
 Resumes all of a process's threads as configured using the Thread run control functions. More...
 
Status ResumeSynchronous (Stream *stream)
 
Status Halt (bool clear_thread_plans=false, bool use_run_lock=true)
 Halts a running process. More...
 
Status Detach (bool keep_stopped)
 Detaches from a running or stopped process. More...
 
Status Destroy (bool force_kill)
 Kills the process and shuts down all threads that were spawned to track and monitor the process. More...
 
Status Signal (int signal)
 Sends a process a UNIX signal signal. More...
 
void SetUnixSignals (lldb::UnixSignalsSP &&signals_sp)
 
const lldb::UnixSignalsSP & GetUnixSignals ()
 
virtual Status WillAttachToProcessWithID (lldb::pid_t pid)
 Called before attaching to a process. More...
 
virtual Status WillAttachToProcessWithName (const char *process_name, bool wait_for_launch)
 Called before attaching to a process. More...
 
virtual Status DoConnectRemote (llvm::StringRef remote_url)
 Attach to a remote system via a URL. More...
 
virtual Status DoAttachToProcessWithID (lldb::pid_t pid, const ProcessAttachInfo &attach_info)
 Attach to an existing process using a process ID. More...
 
virtual Status DoAttachToProcessWithName (const char *process_name, const ProcessAttachInfo &attach_info)
 Attach to an existing process using a partial process name. More...
 
virtual void DidAttach (ArchSpec &process_arch)
 Called after attaching a process. More...
 
virtual void DidExec ()
 Called after a process re-execs itself. More...
 
virtual void DoDidExec ()
 Subclasses of Process should implement this function if they need to do anything after a process exec's itself. More...
 
virtual void DidFork (lldb::pid_t child_pid, lldb::tid_t child_tid)
 Called after a reported fork. More...
 
virtual void DidVFork (lldb::pid_t child_pid, lldb::tid_t child_tid)
 Called after a reported vfork. More...
 
virtual void DidVForkDone ()
 Called after reported vfork completion. More...
 
virtual Status WillLaunch (Module *module)
 Called before launching to a process. More...
 
virtual Status DoLaunch (Module *exe_module, ProcessLaunchInfo &launch_info)
 Launch a new process. More...
 
virtual void DidLaunch ()
 Called after launching a process. More...
 
virtual Status WillResume ()
 Called before resuming to a process. More...
 
virtual Status DoResume ()
 Resumes all of a process's threads as configured using the Thread run control functions. More...
 
virtual void DidResume ()
 Called after resuming a process. More...
 
virtual Status WillHalt ()
 Called before halting to a process. More...
 
virtual Status DoHalt (bool &caused_stop)
 Halts a running process. More...
 
virtual void DidHalt ()
 Called after halting a process. More...
 
virtual Status WillDetach ()
 Called before detaching from a process. More...
 
virtual Status DoDetach (bool keep_stopped)
 Detaches from a running or stopped process. More...
 
virtual void DidDetach ()
 Called after detaching from a process. More...
 
virtual bool DetachRequiresHalt ()
 
virtual Status WillSignal ()
 Called before sending a signal to a process. More...
 
virtual Status DoSignal (int signal)
 Sends a process a UNIX signal signal. More...
 
virtual Status WillDestroy ()
 
virtual Status DoDestroy ()=0
 
virtual void DidDestroy ()
 
virtual bool DestroyRequiresHalt ()
 
virtual void DidSignal ()
 Called after sending a signal to a process. More...
 
virtual void RefreshStateAfterStop ()=0
 Currently called as part of ShouldStop. More...
 
virtual llvm::VersionTuple GetHostOSVersion ()
 Sometimes the connection to a process can detect the host OS version that the process is running on. More...
 
virtual llvm::VersionTuple GetHostMacCatalystVersion ()
 
TargetGetTarget ()
 Get the target object pointer for this module. More...
 
const TargetGetTarget () const
 Get the const target object pointer for this module. More...
 
void Flush ()
 Flush all data in the process. More...
 
lldb::StateType GetState ()
 Get accessor for the current process state. More...
 
lldb::ExpressionResults RunThreadPlan (ExecutionContext &exe_ctx, lldb::ThreadPlanSP &thread_plan_sp, const EvaluateExpressionOptions &options, DiagnosticManager &diagnostic_manager)
 
void GetStatus (Stream &ostrm)
 
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 SendAsyncInterrupt ()
 
virtual void ModulesDidLoad (ModuleList &module_list)
 
virtual lldb_private::StructuredData::ObjectSP GetLoadedDynamicLibrariesInfos (lldb::addr_t image_list_address, lldb::addr_t image_count)
 Retrieve the list of shared libraries that are loaded for this process This method is used on pre-macOS 10.12, pre-iOS 10, pre-tvOS 10, pre- watchOS 3 systems. More...
 
virtual lldb_private::StructuredData::ObjectSP GetLoadedDynamicLibrariesInfos ()
 
virtual lldb_private::StructuredData::ObjectSP GetLoadedDynamicLibrariesInfos (const std::vector< lldb::addr_t > &load_addresses)
 
virtual lldb_private::StructuredData::ObjectSP GetSharedCacheInfo ()
 
void PrintWarningOptimization (const SymbolContext &sc)
 Print a user-visible warning about a module being built with optimization. More...
 
void PrintWarningUnsupportedLanguage (const SymbolContext &sc)
 Print a user-visible warning about a function written in a language that this version of LLDB doesn't support. More...
 
virtual bool GetProcessInfo (ProcessInstanceInfo &info)
 
int GetExitStatus ()
 Get the exit status for a process. More...
 
const char * GetExitDescription ()
 Get a textual description of what the process exited. More...
 
virtual void DidExit ()
 
lldb::addr_t GetCodeAddressMask ()
 
lldb::addr_t GetDataAddressMask ()
 
void SetCodeAddressMask (lldb::addr_t code_address_mask)
 
void SetDataAddressMask (lldb::addr_t data_address_mask)
 
ProcessModID GetModID () const
 Get the Modification ID of the process. More...
 
const ProcessModIDGetModIDRef () const
 
uint32_t GetStopID () const
 
uint32_t GetResumeID () const
 
uint32_t GetLastUserExpressionResumeID () const
 
uint32_t GetLastNaturalStopID () const
 
lldb::EventSP GetStopEventForStopID (uint32_t stop_id) const
 
virtual bool SetExitStatus (int exit_status, const char *cstr)
 Set accessor for the process exit status (return code). More...
 
virtual bool IsAlive ()
 Check if a process is still alive. More...
 
virtual bool IsLiveDebugSession () const
 
virtual bool WarnBeforeDetach () const
 Before lldb detaches from a process, it warns the user that they are about to lose their debug session. More...
 
virtual size_t ReadMemory (lldb::addr_t vm_addr, void *buf, size_t size, Status &error)
 Read of memory from a process. More...
 
size_t ReadMemoryFromInferior (lldb::addr_t vm_addr, void *buf, size_t size, Status &error)
 Read of memory from a process. More...
 
size_t ReadStringFromMemory (lldb::addr_t vm_addr, char *str, size_t max_bytes, Status &error, size_t type_width=1)
 Read a NULL terminated string from memory. More...
 
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. More...
 
size_t ReadCStringFromMemory (lldb::addr_t vm_addr, std::string &out_str, Status &error)
 
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. More...
 
int64_t ReadSignedIntegerFromMemory (lldb::addr_t load_addr, size_t byte_size, int64_t fail_value, Status &error)
 
lldb::addr_t ReadPointerFromMemory (lldb::addr_t vm_addr, Status &error)
 
bool WritePointerToMemory (lldb::addr_t vm_addr, lldb::addr_t ptr_value, Status &error)
 
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. More...
 
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. More...
 
size_t ReadScalarIntegerFromMemory (lldb::addr_t addr, uint32_t byte_size, bool is_signed, Scalar &scalar, Status &error)
 
size_t WriteMemory (lldb::addr_t vm_addr, const void *buf, size_t size, Status &error)
 Write memory to a process. More...
 
virtual lldb::addr_t DoAllocateMemory (size_t size, uint32_t permissions, Status &error)
 Actually allocate memory in the process. More...
 
virtual Status WriteObjectFile (std::vector< ObjectFile::LoadableData > entries)
 
lldb::addr_t AllocateMemory (size_t size, uint32_t permissions, Status &error)
 The public interface to allocating memory in the process. More...
 
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. More...
 
llvm::Expected< const MemoryTagManager * > GetMemoryTagManager ()
 If this architecture and process supports memory tagging, return a tag manager that can be used to maniupulate those memory tags. More...
 
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. More...
 
Status WriteMemoryTags (lldb::addr_t addr, size_t len, const std::vector< lldb::addr_t > &tags)
 Write memory tags for a range of memory. More...
 
virtual lldb::addr_t ResolveIndirectFunction (const Address *address, Status &error)
 Resolve dynamically loaded indirect functions. More...
 
virtual Status GetMemoryRegionInfo (lldb::addr_t load_addr, MemoryRegionInfo &range_info)
 Locate the memory region that contains load_addr. More...
 
virtual Status GetMemoryRegions (lldb_private::MemoryRegionInfos &region_list)
 Obtain all the mapped memory regions within this process. More...
 
virtual Status GetWatchpointSupportInfo (uint32_t &num)
 
virtual Status GetWatchpointSupportInfo (uint32_t &num, bool &after)
 
lldb::ModuleSP ReadModuleFromMemory (const FileSpec &file_spec, lldb::addr_t header_addr, size_t size_to_read=512)
 
virtual bool GetLoadAddressPermissions (lldb::addr_t load_addr, uint32_t &permissions)
 Attempt to get the attributes for a region of memory in the process. More...
 
bool CanJIT ()
 Determines whether executing JIT-compiled code in this process is possible. More...
 
void SetCanJIT (bool can_jit)
 Sets whether executing JIT-compiled code in this process is possible. More...
 
bool CanInterpretFunctionCalls ()
 Determines whether executing function calls using the interpreter is possible for this process. More...
 
void SetCanInterpretFunctionCalls (bool can_interpret_function_calls)
 Sets whether executing function calls using the interpreter is possible for this process. More...
 
void SetCanRunCode (bool can_run_code)
 Sets whether executing code in this process is possible. More...
 
virtual Status DoDeallocateMemory (lldb::addr_t ptr)
 Actually deallocate memory in the process. More...
 
Status DeallocateMemory (lldb::addr_t ptr)
 The public interface to deallocating memory in the process. More...
 
virtual size_t GetSTDOUT (char *buf, size_t buf_size, Status &error)
 Get any available STDOUT. More...
 
virtual size_t GetSTDERR (char *buf, size_t buf_size, Status &error)
 Get any available STDERR. More...
 
virtual size_t PutSTDIN (const char *buf, size_t buf_size, Status &error)
 Puts data into this process's STDIN. More...
 
virtual size_t GetAsyncProfileData (char *buf, size_t buf_size, Status &error)
 Get any available profile data. More...
 
size_t GetSoftwareBreakpointTrapOpcode (BreakpointSite *bp_site)
 
virtual Status EnableBreakpointSite (BreakpointSite *bp_site)
 
virtual Status DisableBreakpointSite (BreakpointSite *bp_site)
 
virtual Status EnableSoftwareBreakpoint (BreakpointSite *bp_site)
 
virtual Status DisableSoftwareBreakpoint (BreakpointSite *bp_site)
 
BreakpointSiteListGetBreakpointSiteList ()
 
const BreakpointSiteListGetBreakpointSiteList () const
 
void DisableAllBreakpointSites ()
 
Status ClearBreakpointSiteByID (lldb::user_id_t break_id)
 
lldb::break_id_t CreateBreakpointSite (const lldb::BreakpointLocationSP &owner, bool use_hardware)
 
Status DisableBreakpointSiteByID (lldb::user_id_t break_id)
 
Status EnableBreakpointSiteByID (lldb::user_id_t break_id)
 
void RemoveOwnerFromBreakpointSite (lldb::user_id_t owner_id, lldb::user_id_t owner_loc_id, lldb::BreakpointSiteSP &bp_site_sp)
 
virtual Status EnableWatchpoint (Watchpoint *wp, bool notify=true)
 
virtual Status DisableWatchpoint (Watchpoint *wp, bool notify=true)
 
bool UpdateThreadList (ThreadList &old_thread_list, ThreadList &new_thread_list)
 Update the thread list. More...
 
void UpdateThreadListIfNeeded ()
 
ThreadListGetThreadList ()
 
ThreadListGetExtendedThreadList ()
 
ThreadList::ThreadIterable Threads ()
 
uint32_t GetNextThreadIndexID (uint64_t thread_id)
 
lldb::ThreadSP CreateOSPluginThread (lldb::tid_t tid, lldb::addr_t context)
 
bool HasAssignedIndexIDToThread (uint64_t sb_thread_id)
 
uint32_t AssignIndexIDToThread (uint64_t thread_id)
 
void UpdateQueueListIfNeeded ()
 
QueueListGetQueueList ()
 
QueueList::QueueIterable Queues ()
 
lldb::StateType GetNextEvent (lldb::EventSP &event_sp)
 
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)
 
uint32_t GetIOHandlerID () const
 
void SyncIOHandler (uint32_t iohandler_id, const Timeout< std::micro > &timeout)
 Waits for the process state to be running within a given msec timeout. More...
 
lldb::StateType GetStateChangedEvents (lldb::EventSP &event_sp, const Timeout< std::micro > &timeout, lldb::ListenerSP hijack_listener)
 
EventPeekAtStateChangedEvents ()
 
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 listener, set to listen to process events, and then call this with that listener. More...
 
void RestoreProcessEvents ()
 Restores the process event broadcasting to its normal state. More...
 
bool StateChangedIsHijackedForSynchronousResume ()
 
bool StateChangedIsExternallyHijacked ()
 
const lldb::ABISP & GetABI ()
 
OperatingSystemGetOperatingSystem ()
 
std::vector< LanguageRuntime * > GetLanguageRuntimes ()
 
LanguageRuntimeGetLanguageRuntime (lldb::LanguageType language)
 
bool IsPossibleDynamicValue (ValueObject &in_value)
 
bool IsRunning () const
 
DynamicCheckerFunctionsGetDynamicCheckers ()
 
void SetDynamicCheckers (DynamicCheckerFunctions *dynamic_checkers)
 
bool PruneThreadPlansForTID (lldb::tid_t tid)
 Prune ThreadPlanStacks for unreported threads. More...
 
void PruneThreadPlans ()
 Prune ThreadPlanStacks for all unreported threads. More...
 
ThreadPlanStackFindThreadPlans (lldb::tid_t tid)
 Find the thread plan stack associated with thread with tid. More...
 
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. More...
 
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. More...
 
virtual bool StartNoticingNewThreads ()
 Call this to set the lldb in the mode where it breaks on new thread creations, and then auto-restarts. More...
 
virtual bool StopNoticingNewThreads ()
 Call this to turn off the stop & notice new threads mode. More...
 
void SetRunningUserExpression (bool on)
 
void SetRunningUtilityFunction (bool on)
 
lldb::TargetSP CalculateTarget () override
 
lldb::ProcessSP CalculateProcess () override
 
lldb::ThreadSP CalculateThread () override
 
lldb::StackFrameSP CalculateStackFrame () override
 
void CalculateExecutionContext (ExecutionContext &exe_ctx) override
 Reconstruct the object's execution context into sc. More...
 
void SetSTDIOFileDescriptor (int file_descriptor)
 
void AddInvalidMemoryRegion (const LoadRange &region)
 
bool RemoveInvalidMemoryRange (const LoadRange &region)
 
void AddPreResumeAction (PreResumeActionCallback callback, void *baton)
 
bool RunPreResumeActions ()
 
void ClearPreResumeActions ()
 
void ClearPreResumeAction (PreResumeActionCallback callback, void *baton)
 
ProcessRunLockGetRunLock ()
 
bool CurrentThreadIsPrivateStateThread ()
 
virtual Status SendEventData (const char *data)
 
lldb::ThreadCollectionSP GetHistoryThreads (lldb::addr_t addr)
 
lldb::InstrumentationRuntimeSP GetInstrumentationRuntime (lldb::InstrumentationRuntimeType type)
 
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. More...
 
virtual void PrefetchModuleSpecs (llvm::ArrayRef< FileSpec > module_file_specs, const llvm::Triple &triple)
 
virtual Status GetFileLoadAddress (const FileSpec &file, bool &is_loaded, lldb::addr_t &load_addr)
 Try to find the load address of a file. More...
 
size_t AddImageToken (lldb::addr_t image_ptr)
 
lldb::addr_t GetImagePtrFromToken (size_t token) const
 
void ResetImageToken (size_t token)
 
Address AdvanceAddressToNextBranchInstruction (Address default_stop_addr, AddressRange range_bounds)
 Find the next branch instruction to set a breakpoint on. More...
 
virtual Status ConfigureStructuredData (ConstString type_name, const StructuredData::ObjectSP &config_sp)
 Configure asynchronous structured data feature. More...
 
void BroadcastStructuredData (const StructuredData::ObjectSP &object_sp, const lldb::StructuredDataPluginSP &plugin_sp)
 Broadcasts the given structured data object from the given plugin. More...
 
lldb::StructuredDataPluginSP GetStructuredDataPlugin (ConstString type_name) const
 Returns the StructuredDataPlugin associated with a given type name, if there is one. More...
 
- Public Member Functions inherited from lldb_private::ProcessProperties
 ProcessProperties (lldb_private::Process *process)
 
 ~ProcessProperties () override
 
bool GetDisableMemoryCache () const
 
uint64_t GetMemoryCacheLineSize () const
 
Args GetExtraStartupCommands () const
 
void SetExtraStartupCommands (const Args &args)
 
FileSpec GetPythonOSPluginPath () const
 
uint32_t GetVirtualAddressableBits () const
 
void SetVirtualAddressableBits (uint32_t bits)
 
void SetPythonOSPluginPath (const FileSpec &file)
 
bool GetIgnoreBreakpointsInExpressions () const
 
void SetIgnoreBreakpointsInExpressions (bool ignore)
 
bool GetUnwindOnErrorInExpressions () const
 
void SetUnwindOnErrorInExpressions (bool ignore)
 
bool GetStopOnSharedLibraryEvents () const
 
void SetStopOnSharedLibraryEvents (bool stop)
 
bool GetDisableLangRuntimeUnwindPlans () const
 
void SetDisableLangRuntimeUnwindPlans (bool disable)
 
bool GetDetachKeepsStopped () const
 
void SetDetachKeepsStopped (bool keep_stopped)
 
bool GetWarningsOptimization () const
 
bool GetWarningsUnsupportedLanguage () const
 
bool GetStopOnExec () const
 
std::chrono::seconds GetUtilityExpressionTimeout () const
 
std::chrono::seconds GetInterruptTimeout () const
 
bool GetOSPluginReportsAllThreads () const
 
void SetOSPluginReportsAllThreads (bool does_report)
 
bool GetSteppingRunsAllThreads () const
 
FollowForkMode GetFollowForkMode () const
 
- Public Member Functions inherited from lldb_private::Properties
 Properties ()=default
 
 Properties (const lldb::OptionValuePropertiesSP &collection_sp)
 
virtual ~Properties ()=default
 
virtual lldb::OptionValuePropertiesSP GetValueProperties () const
 
virtual lldb::OptionValueSP GetPropertyValue (const ExecutionContext *exe_ctx, llvm::StringRef property_path, bool will_modify, Status &error) const
 
virtual Status SetPropertyValue (const ExecutionContext *exe_ctx, VarSetOperationType op, llvm::StringRef property_path, llvm::StringRef value)
 
virtual Status DumpPropertyValue (const ExecutionContext *exe_ctx, Stream &strm, llvm::StringRef property_path, uint32_t dump_mask)
 
virtual void DumpAllPropertyValues (const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask)
 
virtual void DumpAllDescriptions (CommandInterpreter &interpreter, Stream &strm) const
 
size_t Apropos (llvm::StringRef keyword, std::vector< const Property * > &matching_properties) const
 
lldb::OptionValuePropertiesSP GetSubProperty (const ExecutionContext *exe_ctx, ConstString name)
 
- Public Member Functions inherited from lldb_private::Broadcaster
 Broadcaster (lldb::BroadcasterManagerSP manager_sp, const char *name)
 Construct with a broadcaster with a name. More...
 
virtual ~Broadcaster ()
 Destructor. More...
 
void CheckInWithManager ()
 
void BroadcastEvent (lldb::EventSP &event_sp)
 Broadcast an event which has no associated data. More...
 
void BroadcastEventIfUnique (lldb::EventSP &event_sp)
 
void BroadcastEvent (uint32_t event_type, const lldb::EventDataSP &event_data_sp)
 
void BroadcastEvent (uint32_t event_type, EventData *event_data=nullptr)
 
void BroadcastEventIfUnique (uint32_t event_type, EventData *event_data=nullptr)
 
void Clear ()
 
virtual void AddInitialEventsToListener (const lldb::ListenerSP &listener_sp, uint32_t requested_events)
 
uint32_t AddListener (const lldb::ListenerSP &listener_sp, uint32_t event_mask)
 Listen for any events specified by event_mask. More...
 
ConstString GetBroadcasterName ()
 Get the NULL terminated C string name of this Broadcaster object. More...
 
bool GetEventNames (Stream &s, const uint32_t event_mask, bool prefix_with_broadcaster_name) const
 Get the event name(s) for one or more event bits. More...
 
void SetEventName (uint32_t event_mask, const char *name)
 Set the name for an event bit. More...
 
const char * GetEventName (uint32_t event_mask) const
 
bool EventTypeHasListeners (uint32_t event_type)
 
bool RemoveListener (const lldb::ListenerSP &listener_sp, uint32_t event_mask=UINT32_MAX)
 Removes a Listener from this broadcasters list and frees the event bits specified by event_mask that were previously acquired by listener (assuming listener was listening to this object) for other listener objects to use. More...
 
bool HijackBroadcaster (const lldb::ListenerSP &listener_sp, uint32_t event_mask=UINT32_MAX)
 Provides a simple mechanism to temporarily redirect events from broadcaster. More...
 
bool IsHijackedForEvent (uint32_t event_mask)
 
void RestoreBroadcaster ()
 Restore the state of the Broadcaster from a previous hijack attempt. More...
 
lldb::BroadcasterManagerSP GetManager ()
 
- Public Member Functions inherited from lldb_private::ExecutionContextScope
virtual ~ExecutionContextScope ()=default
 
- Public Member Functions inherited from lldb_private::PluginInterface
 PluginInterface ()=default
 
virtual ~PluginInterface ()=default
 
virtual ConstString GetPluginName ()=0
 
 PluginInterface (const PluginInterface &)=delete
 
PluginInterfaceoperator= (const PluginInterface &)=delete
 

Static Public Member Functions

static ConstStringGetStaticBroadcasterClass ()
 
static void SettingsInitialize ()
 
static void SettingsTerminate ()
 
static const ProcessPropertiesSPGetGlobalProperties ()
 
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. More...
 
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 (). More...
 
static const char * ExecutionResultAsCString (lldb::ExpressionResults result)
 
static bool HandleProcessStateChangedEvent (const lldb::EventSP &event_sp, Stream *stream, bool &pop_process_io_handler)
 Centralize the code that handles and prints descriptions for process state changes. More...
 
- Static Public Member Functions inherited from lldb_private::Properties
static const char * GetExperimentalSettingsName ()
 
static bool IsSettingExperimental (llvm::StringRef setting)
 

Protected Types

enum  { eCanJITDontKnow = 0, eCanJITYes, eCanJITNo }
 
typedef std::map< lldb::LanguageType, lldb::LanguageRuntimeSP > LanguageRuntimeCollection
 
typedef std::unordered_set< const void * > WarningsPointerSet
 
typedef std::map< uint64_t, WarningsPointerSetWarningsCollection
 
using StructuredDataPluginMap = std::map< ConstString, lldb::StructuredDataPluginSP >
 
- Protected Types inherited from lldb_private::Broadcaster
typedef std::shared_ptr< BroadcasterImplBroadcasterImplSP
 
typedef std::weak_ptr< BroadcasterImplBroadcasterImplWP
 

Protected Member Functions

virtual JITLoaderListGetJITLoaders ()
 
virtual llvm::Expected< TraceSupportedResponseTraceSupported ()
 Get the processor tracing type supported for this process. More...
 
virtual llvm::Error TraceStart (const llvm::json::Value &request)
 Start tracing a process or its threads. More...
 
virtual llvm::Error TraceStop (const TraceStopRequest &request)
 Stop tracing a live process or its threads. More...
 
virtual llvm::Expected< std::stringTraceGetState (llvm::StringRef type)
 Get the current tracing state of the process and its threads. More...
 
virtual llvm::Expected< std::vector< uint8_t > > TraceGetBinaryData (const TraceGetBinaryDataRequest &request)
 Get binary data given a trace technology and a data identifier. More...
 
bool CallVoidArgVoidPtrReturn (const Address *address, lldb::addr_t &returned_func, bool trap_exceptions=false)
 
virtual bool DoUpdateThreadList (ThreadList &old_thread_list, ThreadList &new_thread_list)=0
 Update the thread list following process plug-in's specific logic. More...
 
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. More...
 
lldb::StateType GetPrivateState ()
 
Status PrivateResume ()
 The "private" side of resuming a process. More...
 
void CompleteAttach ()
 
void PrintWarning (uint64_t warning_type, const void *repeat_key, const char *fmt,...) __attribute__((format(printf
 Print a user-visible warning one time per Process. More...
 
void SetNextEventAction (Process::NextEventAction *next_event_action)
 
bool PrivateStateThreadIsValid () const
 
void ForceNextEventDelivery ()
 
void MapSupportedStructuredDataPlugins (const StructuredData::Array &supported_type_names)
 Loads any plugins associated with asynchronous structured data and maps the relevant supported type name to the plugin. More...
 
bool RouteAsyncStructuredData (const StructuredData::ObjectSP object_sp)
 Route the incoming structured data dictionary to the right plugin. More...
 
virtual bool SupportsMemoryTagging ()
 Check whether the process supports memory tagging. More...
 
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. More...
 
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. More...
 
size_t RemoveBreakpointOpcodesFromBuffer (lldb::addr_t addr, size_t size, uint8_t *buf) const
 
void SynchronouslyNotifyStateChanged (lldb::StateType state)
 
void SetPublicState (lldb::StateType new_state, bool restarted)
 
void SetPrivateState (lldb::StateType state)
 
bool StartPrivateStateThread (bool is_secondary_thread=false)
 
void StopPrivateStateThread ()
 
void PausePrivateStateThread ()
 
void ResumePrivateStateThread ()
 
void HandlePrivateEvent (lldb::EventSP &event_sp)
 
Status HaltPrivate ()
 
lldb::StateType WaitForProcessStopPrivate (lldb::EventSP &event_sp, const Timeout< std::micro > &timeout)
 
bool GetEventsPrivate (lldb::EventSP &event_sp, const Timeout< std::micro > &timeout, bool control_only)
 
lldb::StateType GetStateChangedEventsPrivate (lldb::EventSP &event_sp, const Timeout< std::micro > &timeout)
 
size_t WriteMemoryPrivate (lldb::addr_t addr, const void *buf, size_t size, Status &error)
 
void AppendSTDOUT (const char *s, size_t len)
 
void AppendSTDERR (const char *s, size_t len)
 
void BroadcastAsyncProfileData (const std::string &one_profile_data)
 
bool PushProcessIOHandler ()
 
bool PopProcessIOHandler ()
 
bool ProcessIOHandlerIsActive ()
 
bool ProcessIOHandlerExists () const
 
Status StopForDestroyOrDetach (lldb::EventSP &exit_event_sp)
 
virtual Status UpdateAutomaticSignalFiltering ()
 
void LoadOperatingSystemPlugin (bool flush)
 
- Protected Member Functions inherited from lldb_private::Broadcaster
BroadcasterImplSP GetBroadcasterImpl ()
 
const char * GetHijackingListenerName ()
 

Static Protected Member Functions

static void STDIOReadThreadBytesReceived (void *baton, const void *src, size_t src_len)
 

Protected Attributes

std::weak_ptr< Targetm_target_wp
 The target that owns this process. More...
 
lldb::pid_t m_pid = LLDB_INVALID_PROCESS_ID
 
ThreadSafeValue< lldb::StateTypem_public_state
 
ThreadSafeValue< lldb::StateTypem_private_state
 
Broadcaster m_private_state_broadcaster
 
Broadcaster m_private_state_control_broadcaster
 
lldb::ListenerSP m_private_state_listener_sp
 
HostThread m_private_state_thread
 Thread ID for the thread that watches internal state events. More...
 
ProcessModID m_mod_id
 Tracks the state of the process over stops and other alterations. More...
 
uint32_t m_process_unique_id
 Each lldb_private::Process class that is created gets a unique integer ID that increments with each new instance. More...
 
uint32_t m_thread_index_id
 Each thread is created with a 1 based index that won't get re-used. More...
 
std::map< uint64_t, uint32_tm_thread_id_to_index_id_map
 
int m_exit_status
 The exit status of the process, or -1 if not set. More...
 
std::string m_exit_string
 A textual description of why a process exited. More...
 
std::mutex m_exit_status_mutex
 Mutex so m_exit_status m_exit_string can be safely accessed from multiple threads. More...
 
std::recursive_mutex m_thread_mutex
 
ThreadList m_thread_list_real
 The threads for this process as are known to the protocol we are debugging with. More...
 
ThreadList m_thread_list
 The threads for this process as the user will see them. More...
 
ThreadPlanStackMap m_thread_plans
 This is the list of thread plans for threads in m_thread_list, as well as threads we knew existed, but haven't determined that they have died yet. More...
 
ThreadList m_extended_thread_list
 Owner for extended threads that may be generated, cleared on natural stops. More...
 
uint32_t m_extended_thread_stop_id
 The natural stop id when extended_thread_list was last updated. More...
 
QueueList m_queue_list
 The list of libdispatch queues at a given stop point. More...
 
uint32_t m_queue_list_stop_id
 The natural stop id when queue list was last fetched. More...
 
std::vector< Notificationsm_notifications
 The list of notifications that this process can deliver. More...
 
std::vector< lldb::addr_tm_image_tokens
 
lldb::ListenerSP m_listener_sp
 Shared pointer to the listener used for public events. More...
 
BreakpointSiteList m_breakpoint_site_list
 This is the list of breakpoint locations we intend to insert in the target. More...
 
lldb::DynamicLoaderUP m_dyld_up
 
lldb::JITLoaderListUP m_jit_loaders_up
 
lldb::DynamicCheckerFunctionsUP m_dynamic_checkers_up
 The functions used by the expression parser to validate data that expressions use. More...
 
lldb::OperatingSystemUP m_os_up
 
lldb::SystemRuntimeUP m_system_runtime_up
 
lldb::UnixSignalsSP m_unix_signals_sp
 
lldb::ABISP m_abi_sp
 This is the current signal set for this process. More...
 
lldb::IOHandlerSP m_process_input_reader
 
Communication m_stdio_communication
 
std::recursive_mutex m_stdio_communication_mutex
 
bool m_stdin_forward
 
std::string m_stdout_data
 Remember if stdin must be forwarded to remote debug server. More...
 
std::string m_stderr_data
 
std::recursive_mutex m_profile_data_comm_mutex
 
std::vector< std::stringm_profile_data
 
Predicate< uint32_tm_iohandler_sync
 
MemoryCache m_memory_cache
 
AllocatedMemoryCache m_allocated_memory_cache
 
bool m_should_detach
 
LanguageRuntimeCollection m_language_runtimes
 Should we detach if the process object goes away with an explicit call to Kill or Detach? More...
 
std::recursive_mutex m_language_runtimes_mutex
 
InstrumentationRuntimeCollection m_instrumentation_runtimes
 
std::unique_ptr< NextEventActionm_next_event_action_up
 
std::vector< PreResumeCallbackAndBatonm_pre_resume_actions
 
ProcessRunLock m_public_run_lock
 
ProcessRunLock m_private_run_lock
 
bool m_currently_handling_do_on_removals
 
bool m_resume_requested
 
std::atomic< bool > m_finalizing
 This is set at the beginning of Process::Finalize() to stop functions from looking up or creating things during or after a finalize call. More...
 
bool m_clear_thread_plans_on_stop
 
bool m_force_next_event_delivery
 
lldb::StateType m_last_broadcast_state
 
std::map< lldb::addr_t, lldb::addr_tm_resolved_indirect_addresses
 This helps with the Public event coalescing in ShouldBroadcastEvent. More...
 
bool m_destroy_in_process
 
bool m_can_interpret_function_calls
 
WarningsCollection m_warnings_issued
 
std::mutex m_run_thread_plan_lock
 
StructuredDataPluginMap m_structured_data_plugin_map
 
enum lldb_private::Process:: { ... }  m_can_jit
 
std::unique_ptr< UtilityFunctionm_dlopen_utility_func_up
 
llvm::once_flag m_dlopen_utility_func_flag_once
 
lldb::addr_t m_code_address_mask = 0
 Mask for code an data addresses. More...
 
lldb::addr_t m_data_address_mask = 0
 
- Protected Attributes inherited from lldb_private::ProcessProperties
Processm_process
 
std::unique_ptr< ProcessExperimentalPropertiesm_experimental_properties_up
 
- Protected Attributes inherited from lldb_private::Properties
lldb::OptionValuePropertiesSP m_collection_sp
 

Private Member Functions

lldb::thread_result_t RunPrivateStateThread (bool is_secondary_thread)
 
Status DestroyImpl (bool force_kill)
 
bool ShouldBroadcastEvent (Event *event_ptr)
 This is the part of the event handling that for a process event. More...
 
void ControlPrivateStateThread (uint32_t signal)
 
 Process (const Process &)=delete
 
const Processoperator= (const Process &)=delete
 

Static Private Member Functions

static lldb::thread_result_t PrivateStateThread (void *arg)
 

Friends

class FunctionCaller
 
class Debugger
 
class DynamicLoader
 
class ProcessEventData
 
class StopInfo
 
class Target
 
class ThreadList
 
class ProcessEventHijacker
 
class ProcessProperties
 
class Trace
 

Detailed Description

A plug-in interface definition class for debugging a process.

Definition at line 342 of file Process.h.

Member Typedef Documentation

◆ LanguageRuntimeCollection

typedef std::map<lldb::LanguageType, lldb::LanguageRuntimeSP> lldb_private::Process::LanguageRuntimeCollection
protected

Definition at line 2849 of file Process.h.

◆ LoadRange

Definition at line 375 of file Process.h.

◆ PreResumeActionCallback

typedef bool() lldb_private::Process::PreResumeActionCallback(void *)

Definition at line 2389 of file Process.h.

◆ StopLocker

Definition at line 382 of file Process.h.

◆ StructuredDataPluginMap

using lldb_private::Process::StructuredDataPluginMap = std::map<ConstString, lldb::StructuredDataPluginSP>
protected

Definition at line 2865 of file Process.h.

◆ WarningsCollection

typedef std::map<uint64_t, WarningsPointerSet> lldb_private::Process::WarningsCollection
protected

Definition at line 2851 of file Process.h.

◆ WarningsPointerSet

typedef std::unordered_set<const void *> lldb_private::Process::WarningsPointerSet
protected

Definition at line 2850 of file Process.h.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum

Broadcaster event bits definitions.

Enumerator
eBroadcastBitStateChanged 
eBroadcastBitInterrupt 
eBroadcastBitSTDOUT 
eBroadcastBitSTDERR 
eBroadcastBitProfileData 
eBroadcastBitStructuredData 

Definition at line 357 of file Process.h.

◆ anonymous enum

anonymous enum
Enumerator
eBroadcastInternalStateControlStop 
eBroadcastInternalStateControlPause 
eBroadcastInternalStateControlResume 

Definition at line 366 of file Process.h.

◆ anonymous enum

anonymous enum
protected
Enumerator
eCanJITDontKnow 
eCanJITYes 
eCanJITNo 

Definition at line 2989 of file Process.h.

◆ Warnings

Process warning types.

Enumerator
eWarningsOptimization 
eWarningsUnsupportedLanguage 

Definition at line 373 of file Process.h.

Constructor & Destructor Documentation

◆ Process() [1/3]

lldb_private::Process::Process ( lldb::TargetSP  target_sp,
lldb::ListenerSP  listener_sp 
)

Construct with a shared pointer to a target, and the Process listener.

Uses the Host UnixSignalsSP by default.

◆ Process() [2/3]

lldb_private::Process::Process ( lldb::TargetSP  target_sp,
lldb::ListenerSP  listener_sp,
const lldb::UnixSignalsSP &  unix_signals_sp 
)

Construct with a shared pointer to a target, the Process listener, and the appropriate UnixSignalsSP for the process.

◆ ~Process()

Process::~Process ( )
override

Destructor.

The destructor is virtual since this class is designed to be inherited from by the plug-in instance.

Definition at line 492 of file Process.cpp.

References lldb_private::ThreadList::Clear(), lldb_private::GetLogIfAllCategoriesSet(), LIBLLDB_LOG_OBJECT, LLDB_LOGF, m_thread_list, and StopPrivateStateThread().

◆ Process() [3/3]

lldb_private::Process::Process ( const Process )
privatedelete

Member Function Documentation

◆ AddImageToken()

size_t Process::AddImageToken ( lldb::addr_t  image_ptr)

Definition at line 5825 of file Process.cpp.

References m_image_tokens.

Referenced by PlatformPOSIX::DoLoadImage().

◆ AddInvalidMemoryRegion()

void Process::AddInvalidMemoryRegion ( const LoadRange region)

◆ AddPreResumeAction()

void Process::AddPreResumeAction ( PreResumeActionCallback  callback,
void *  baton 
)

◆ AdvanceAddressToNextBranchInstruction()

Address Process::AdvanceAddressToNextBranchInstruction ( Address  default_stop_addr,
AddressRange  range_bounds 
)

Find the next branch instruction to set a breakpoint on.

When instruction stepping through a source line, instead of stepping through each instruction, we can put a breakpoint on the next branch instruction (within the range of instructions we are stepping through) and continue the process to there, yielding significant performance benefits over instruction stepping.

Parameters
[in]default_stop_addrThe address of the instruction where lldb would put a breakpoint normally.
[in]range_boundsThe range which the breakpoint must be contained within. Typically a source line.
Returns
The address of the next branch instruction, or the end of the range provided in range_bounds. If there are any problems with the disassembly or getting the instructions, the original default_stop_addr will be returned.

Definition at line 5842 of file Process.cpp.

References lldb_private::AddressRange::ContainsFileAddress(), lldb_private::Disassembler::DisassembleRange(), lldb_private::Target::GetArchitecture(), lldb_private::InstructionList::GetIndexOfInstructionAtAddress(), lldb_private::InstructionList::GetIndexOfNextBranchInstruction(), lldb_private::InstructionList::GetInstructionAtIndex(), GetTarget(), lldb_private::TargetProperties::GetUseFastStepping(), lldb_private::Address::IsValid(), and UINT32_MAX.

Referenced by lldb_private::ThreadPlanStepOut::ThreadPlanStepOut().

◆ AllocateMemory()

addr_t Process::AllocateMemory ( size_t  size,
uint32_t  permissions,
Status error 
)

The public interface to allocating memory in the process.

This function will allocate memory in the process's address space. This can't rely on the generic function calling mechanism, since that requires this function.

Parameters
[in]sizeThe size of the allocation requested.
[in]permissionsOr together any of the lldb::Permissions bits. The permissions on a given memory allocation can't be changed after allocation. Note that a block that isn't set writable can still be written on from lldb, just not by the process itself.
[in,out]errorAn error object to fill in if things go wrong.
Returns
The address of the allocated buffer in the process, or LLDB_INVALID_ADDRESS if the allocation failed.

Definition at line 2297 of file Process.cpp.

References lldb_private::AllocatedMemoryCache::AllocateMemory(), DoAllocateMemory(), error(), lldb::eStateStopped, lldb_private::GetLogIfAllCategoriesSet(), lldb_private::ProcessModID::GetMemoryID(), lldb_private::GetPermissionsAsCString(), GetPrivateState(), lldb_private::ProcessModID::GetStopID(), LIBLLDB_LOG_PROCESS, LLDB_INVALID_ADDRESS, LLDB_LOGF, m_allocated_memory_cache, and m_mod_id.

Referenced by CallocateMemory(), CanJIT(), PlatformPOSIX::DoLoadImage(), lldb_private::AppleObjCRuntimeV2::DynamicClassInfoExtractor::UpdateISAToDescriptorMap(), lldb_private::AppleObjCRuntimeV2::SharedCacheClassInfoExtractor::UpdateISAToDescriptorMap(), and lldb_private::FunctionCaller::WriteFunctionArguments().

◆ AppendSTDERR()

void Process::AppendSTDERR ( const char *  s,
size_t  len 
)
protected

◆ AppendSTDOUT()

void Process::AppendSTDOUT ( const char *  s,
size_t  len 
)
protected

◆ AssignIndexIDToThread()

uint32_t Process::AssignIndexIDToThread ( uint64_t  thread_id)

◆ Attach()

Status Process::Attach ( ProcessAttachInfo attach_info)
virtual

Attach to an existing process using the process attach info.

This function is not meant to be overridden by Process subclasses. It will first call WillAttach (lldb::pid_t) or WillAttach (const char *), and if that returns true, DoAttach (lldb::pid_t) or DoAttach (const char *) will be called to actually do the attach. If DoAttach returns true, then Process::DidAttach() will be called.

Parameters
[in]attach_infoThe process attach info.
Returns
Returns pid if attaching was successful, or LLDB_INVALID_PROCESS_ID if attaching fails.

Definition at line 2754 of file Process.cpp.

References DoAttachToProcessWithID(), DoAttachToProcessWithName(), lldb_private::ProcessInstanceInfo::DumpTableHeader(), lldb_private::Equals, error(), lldb::eStateAttaching, lldb_private::StreamString::GetData(), lldb_private::ProcessInfo::GetExecutableFile(), GetID(), lldb_private::FileSpec::GetPath(), lldb_private::ProcessInfo::GetProcessID(), lldb_private::ProcessInstanceInfoMatch::GetProcessInfo(), lldb_private::ProcessAttachInfo::GetResumeCount(), GetTarget(), lldb_private::ProcessAttachInfo::GetWaitForLaunch(), LLDB_INVALID_PROCESS_ID, m_abi_sp, m_dyld_up, m_jit_loaders_up, m_os_up, m_process_input_reader, m_public_run_lock, m_should_detach, m_system_runtime_up, PATH_MAX, SetExitStatus(), SetID(), lldb_private::ProcessInstanceInfoMatch::SetNameMatchType(), SetNextEventAction(), SetPublicState(), StartPrivateStateThread(), lldb_private::ProcessRunLock::TrySetRunning(), WillAttachToProcessWithID(), and WillAttachToProcessWithName().

◆ BroadcastAsyncProfileData()

void Process::BroadcastAsyncProfileData ( const std::string one_profile_data)
protected

◆ BroadcastStructuredData()

void Process::BroadcastStructuredData ( const StructuredData::ObjectSP object_sp,
const lldb::StructuredDataPluginSP &  plugin_sp 
)

Broadcasts the given structured data object from the given plugin.

StructuredDataPlugin instances can use this to optionally broadcast any of their data if they want to make it available for clients. The data will come in on the structured data event bit (eBroadcastBitStructuredData).

Parameters
[in]object_spThe structured data object to broadcast.
[in]plugin_spThe plugin that will be reported in the event's plugin parameter.

Definition at line 4245 of file Process.cpp.

References lldb_private::Broadcaster::BroadcastEvent(), and eBroadcastBitStructuredData.

Referenced by lldb_private::StructuredDataDarwinLog::HandleArrivalOfStructuredData().

◆ CalculateExecutionContext()

void Process::CalculateExecutionContext ( ExecutionContext exe_ctx)
overridevirtual

Reconstruct the object's execution context into sc.

The object should fill in as much of the ExecutionContextScope as it can so function calls that require a execution context can be made for the given object.

Parameters
[out]exe_ctxA reference to an execution context object that gets filled in.

Implements lldb_private::ExecutionContextScope.

Definition at line 4198 of file Process.cpp.

References GetTarget(), lldb_private::ExecutionContext::SetFramePtr(), lldb_private::ExecutionContext::SetProcessPtr(), lldb_private::ExecutionContext::SetTargetPtr(), and lldb_private::ExecutionContext::SetThreadPtr().

◆ CalculateProcess()

lldb::ProcessSP lldb_private::Process::CalculateProcess ( )
inlineoverridevirtual

Implements lldb_private::ExecutionContextScope.

Definition at line 2360 of file Process.h.

◆ CalculateStackFrame()

lldb::StackFrameSP lldb_private::Process::CalculateStackFrame ( )
inlineoverridevirtual

Implements lldb_private::ExecutionContextScope.

Definition at line 2364 of file Process.h.

◆ CalculateTarget()

lldb::TargetSP Process::CalculateTarget ( )
overridevirtual

◆ CalculateThread()

lldb::ThreadSP lldb_private::Process::CalculateThread ( )
inlineoverridevirtual

Implements lldb_private::ExecutionContextScope.

Definition at line 2362 of file Process.h.

◆ CallocateMemory()

addr_t Process::CallocateMemory ( size_t  size,
uint32_t  permissions,
Status error 
)

The public interface to allocating memory in the process, this also clears the allocated memory.

This function will allocate memory in the process's address space. This can't rely on the generic function calling mechanism, since that requires this function.

Parameters
[in]sizeThe size of the allocation requested.
[in]permissionsOr together any of the lldb::Permissions bits. The permissions on a given memory allocation can't be changed after allocation. Note that a block that isn't set writable can still be written on from lldb, just not by the process itself.
[in,out]errorAn error object to fill in if things go wrong.
Returns
The address of the allocated buffer in the process, or LLDB_INVALID_ADDRESS if the allocation failed.

Definition at line 2320 of file Process.cpp.

References AllocateMemory(), error(), string(), and WriteMemory().

Referenced by PlatformPOSIX::DoLoadImage().

◆ CallVoidArgVoidPtrReturn()

bool Process::CallVoidArgVoidPtrReturn ( const Address address,
lldb::addr_t returned_func,
bool  trap_exceptions = false 
)
protected

◆ CanDebug()

virtual bool lldb_private::Process::CanDebug ( lldb::TargetSP  target,
bool  plugin_specified_by_name 
)
pure virtual

Check if a plug-in instance can debug the file in module.

Each plug-in is given a chance to say whether it can debug the file in module. If the Process plug-in instance can debug a file on the current system, it should return true.

Returns
Returns true if this Process plug-in instance can debug the executable, false otherwise.

Implemented in lldb_private::process_gdb_remote::ProcessGDBRemote, lldb_private::ProcessWindows, lldb_private::ScriptedProcess, ProcessElfCore, ProcessKDP, lldb_private::minidump::ProcessMinidump, ProcessMachCore, and lldb_private::ProcessTrace.

◆ CanInterpretFunctionCalls()

bool lldb_private::Process::CanInterpretFunctionCalls ( )
inline

Determines whether executing function calls using the interpreter is possible for this process.

Returns
True if possible; false otherwise.

Definition at line 1898 of file Process.h.

References m_can_interpret_function_calls.

Referenced by lldb_private::ClangExpressionParser::PrepareForExecution().

◆ CanJIT()

bool Process::CanJIT ( )

Determines whether executing JIT-compiled code in this process is possible.

Returns
True if execution of JIT code is possible; false otherwise.

Definition at line 2330 of file Process.cpp.

References AllocateMemory(), lldb_private::Status::AsCString(), DeallocateMemory(), eCanJITDontKnow, eCanJITNo, eCanJITYes, GetID(), lldb_private::GetLogIfAllCategoriesSet(), LIBLLDB_LOG_PROCESS, LLDB_LOGF, m_can_jit, and lldb_private::Status::Success().

Referenced by lldb_private::UserExpression::Evaluate().

◆ ClearBreakpointSiteByID()

Status Process::ClearBreakpointSiteByID ( lldb::user_id_t  break_id)

◆ ClearPreResumeAction()

void Process::ClearPreResumeAction ( PreResumeActionCallback  callback,
void *  baton 
)

Definition at line 5571 of file Process.cpp.

References m_pre_resume_actions.

◆ ClearPreResumeActions()

void Process::ClearPreResumeActions ( )

Definition at line 5569 of file Process.cpp.

References m_pre_resume_actions.

◆ CompleteAttach()

void Process::CompleteAttach ( )
protected

◆ ConfigureStructuredData()

Status Process::ConfigureStructuredData ( ConstString  type_name,
const StructuredData::ObjectSP config_sp 
)
virtual

Configure asynchronous structured data feature.

Each Process type that supports using an asynchronous StructuredData feature should implement this to enable/disable/configure the feature. The default implementation here will always return an error indiciating the feature is unsupported.

StructuredDataPlugin implementations will call this to configure a feature that has been reported as being supported.

Parameters
[in]type_nameThe StructuredData type name as previously discovered by the Process-derived instance.
[in]config_spConfiguration data for the feature being enabled. This config data, which may be null, will be passed along to the feature to process. The feature will dictate whether this is a dictionary, an array or some other object. If the feature needs to be set up properly before it can be enabled, then the config should also take an enable/disable flag.
Returns
Returns the result of attempting to configure the feature.

Reimplemented in lldb_private::process_gdb_remote::ProcessGDBRemote.

Definition at line 5917 of file Process.cpp.

◆ ConnectRemote()

Status Process::ConnectRemote ( llvm::StringRef  remote_url)
virtual

Attach to a remote system via a URL.

Parameters
[in]remote_urlThe URL format that we are connecting to.
Returns
Returns an error object.

Definition at line 3003 of file Process.cpp.

References CompleteAttach(), DoConnectRemote(), error(), lldb::eStateCrashed, lldb::eStateStopped, GetID(), HandlePrivateEvent(), LLDB_INVALID_PROCESS_ID, m_abi_sp, m_process_input_reader, PrivateStateThreadIsValid(), ResumePrivateStateThread(), StartPrivateStateThread(), and WaitForProcessStopPrivate().

◆ ControlPrivateStateThread()

void Process::ControlPrivateStateThread ( uint32_t  signal)
private

◆ CreateBreakpointSite()

lldb::break_id_t Process::CreateBreakpointSite ( const lldb::BreakpointLocationSP &  owner,
bool  use_hardware 
)

◆ CreateOSPluginThread()

ThreadSP Process::CreateOSPluginThread ( lldb::tid_t  tid,
lldb::addr_t  context 
)

◆ CurrentThreadIsPrivateStateThread()

bool Process::CurrentThreadIsPrivateStateThread ( )

◆ DeallocateMemory()

Status Process::DeallocateMemory ( lldb::addr_t  ptr)

◆ Destroy()

Status Process::Destroy ( bool  force_kill)

Kills the process and shuts down all threads that were spawned to track and monitor the process.

This function is not meant to be overridden by Process subclasses.

Parameters
[in]force_killWhether lldb should force a kill (instead of a detach) from the inferior process. Normally if lldb launched a binary and Destory is called, lldb kills it. If lldb attached to a running process and Destory is called, lldb detaches. If this behavior needs to be over-ridden, this is the bool that can be used.
Returns
Returns an error object.

Definition at line 3238 of file Process.cpp.

References DestroyImpl(), and m_finalizing.

Referenced by lldb_private::process_gdb_remote::ProcessGDBRemote::DoDestroy(), CommandObjectProcessKill::DoExecute(), Halt(), Launch(), and CommandObjectProcessLaunchOrAttach::StopProcessIfNecessary().

◆ DestroyImpl()

Status Process::DestroyImpl ( bool  force_kill)
private

◆ DestroyRequiresHalt()

virtual bool lldb_private::Process::DestroyRequiresHalt ( )
inlinevirtual

Reimplemented in lldb_private::ProcessWindows.

Definition at line 1173 of file Process.h.

Referenced by DestroyImpl().

◆ Detach()

Status Process::Detach ( bool  keep_stopped)

Detaches from a running or stopped process.

This function is not meant to be overridden by Process subclasses.

Parameters
[in]keep_stoppedIf true, don't resume the process on detach.
Returns
Returns an error object.

Definition at line 3186 of file Process.cpp.

References lldb_private::Broadcaster::BroadcastEvent(), DetachRequiresHalt(), DidDetach(), DisableAllBreakpointSites(), lldb_private::ThreadList::DiscardThreadPlans(), DoDetach(), error(), m_destroy_in_process, m_public_run_lock, m_thread_list, lldb_private::ProcessRunLock::SetStopped(), StopForDestroyOrDetach(), StopPrivateStateThread(), and WillDetach().

Referenced by DestroyImpl(), CommandObjectProcessDetach::DoExecute(), and CommandObjectProcessLaunchOrAttach::StopProcessIfNecessary().

◆ DetachRequiresHalt()

virtual bool lldb_private::Process::DetachRequiresHalt ( )
inlinevirtual

Reimplemented in lldb_private::process_gdb_remote::ProcessGDBRemote.

Definition at line 1142 of file Process.h.

Referenced by Detach().

◆ DidAttach()

virtual void lldb_private::Process::DidAttach ( ArchSpec process_arch)
inlinevirtual

Called after attaching a process.

Parameters
[in]process_archIf you can figure out the process architecture after attach, fill it in here.

Allow Process plug-ins to execute some code after attaching to a process.

Reimplemented in ProcessKDP, lldb_private::ProcessWindows, lldb_private::process_gdb_remote::ProcessGDBRemote, and lldb_private::ProcessTrace.

Definition at line 981 of file Process.h.

References lldb_private::ArchSpec::Clear().

Referenced by CompleteAttach(), and lldb_private::ProcessTrace::DidAttach().

◆ DidDestroy()

virtual void lldb_private::Process::DidDestroy ( )
inlinevirtual

Definition at line 1171 of file Process.h.

Referenced by DestroyImpl().

◆ DidDetach()

virtual void lldb_private::Process::DidDetach ( )
inlinevirtual

Called after detaching from a process.

Allow Process plug-ins to execute some code after detaching from a process.

Definition at line 1140 of file Process.h.

Referenced by Detach().

◆ DidExec()

void Process::DidExec ( )
virtual

◆ DidExit()

virtual void lldb_private::Process::DidExit ( )
inlinevirtual

Reimplemented in lldb_private::process_gdb_remote::ProcessGDBRemote.

Definition at line 1352 of file Process.h.

Referenced by SetExitStatus().

◆ DidFork()

virtual void lldb_private::Process::DidFork ( lldb::pid_t  child_pid,
lldb::tid_t  child_tid 
)
inlinevirtual

Called after a reported fork.

Reimplemented in lldb_private::process_gdb_remote::ProcessGDBRemote.

Definition at line 996 of file Process.h.

◆ DidHalt()

virtual void lldb_private::Process::DidHalt ( )
inlinevirtual

Called after halting a process.

Allow Process plug-ins to execute some code after halting a process.

Definition at line 1112 of file Process.h.

Referenced by HaltPrivate().

◆ DidLaunch()

virtual void lldb_private::Process::DidLaunch ( )
inlinevirtual

Called after launching a process.

Allow Process plug-ins to execute some code after launching a process.

Reimplemented in lldb_private::process_gdb_remote::ProcessGDBRemote, lldb_private::ScriptedProcess, and lldb_private::ProcessWindows.

Definition at line 1040 of file Process.h.

Referenced by Launch().

◆ DidResume()

virtual void lldb_private::Process::DidResume ( )
inlinevirtual

Called after resuming a process.

Allow Process plug-ins to execute some code after resuming a process.

Definition at line 1076 of file Process.h.

Referenced by PrivateResume().

◆ DidSignal()

virtual void lldb_private::Process::DidSignal ( )
inlinevirtual

Called after sending a signal to a process.

Allow Process plug-ins to execute some code after sending a signal to a process.

Definition at line 1179 of file Process.h.

Referenced by Signal().

◆ DidVFork()

virtual void lldb_private::Process::DidVFork ( lldb::pid_t  child_pid,
lldb::tid_t  child_tid 
)
inlinevirtual

Called after a reported vfork.

Reimplemented in lldb_private::process_gdb_remote::ProcessGDBRemote.

Definition at line 999 of file Process.h.

◆ DidVForkDone()

virtual void lldb_private::Process::DidVForkDone ( )
inlinevirtual

Called after reported vfork completion.

Reimplemented in lldb_private::process_gdb_remote::ProcessGDBRemote.

Definition at line 1002 of file Process.h.

◆ DisableAllBreakpointSites()

void Process::DisableAllBreakpointSites ( )

◆ DisableBreakpointSite()

virtual Status lldb_private::Process::DisableBreakpointSite ( BreakpointSite bp_site)
inlinevirtual

◆ DisableBreakpointSiteByID()

Status Process::DisableBreakpointSiteByID ( lldb::user_id_t  break_id)

◆ DisableSoftwareBreakpoint()

Status Process::DisableSoftwareBreakpoint ( BreakpointSite bp_site)
virtual

◆ DisableWatchpoint()

Status Process::DisableWatchpoint ( Watchpoint wp,
bool  notify = true 
)
virtual

◆ DoAllocateMemory()

virtual lldb::addr_t lldb_private::Process::DoAllocateMemory ( size_t  size,
uint32_t  permissions,
Status error 
)
inlinevirtual

Actually allocate memory in the process.

This function will allocate memory in the process's address space. This can't rely on the generic function calling mechanism, since that requires this function.

Parameters
[in]sizeThe size of the allocation requested.
Returns
The address of the allocated buffer in the process, or LLDB_INVALID_ADDRESS if the allocation failed.

Reimplemented in lldb_private::process_gdb_remote::ProcessGDBRemote, lldb_private::ProcessWindows, and ProcessKDP.

Definition at line 1672 of file Process.h.

References error(), lldb_private::PluginInterface::GetPluginName(), and LLDB_INVALID_ADDRESS.

Referenced by AllocateMemory(), and lldb_private::AllocatedMemoryCache::AllocatePage().

◆ DoAttachToProcessWithID()

virtual Status lldb_private::Process::DoAttachToProcessWithID ( lldb::pid_t  pid,
const ProcessAttachInfo attach_info 
)
inlinevirtual

Attach to an existing process using a process ID.

Parameters
[in]pidThe process ID that we should attempt to attach to.
[in]attach_infoInformation on how to do the attach. For example, GetUserID() will return the uid to attach as.
Returns
Returns a successful Status attaching was successful, or an appropriate (possibly platform-specific) error code if attaching fails. hanming : need flag

Reimplemented in lldb_private::process_gdb_remote::ProcessGDBRemote, ProcessKDP, and lldb_private::ProcessWindows.

Definition at line 943 of file Process.h.

References error(), and lldb_private::PluginInterface::GetPluginName().

Referenced by Attach().

◆ DoAttachToProcessWithName()

virtual Status lldb_private::Process::DoAttachToProcessWithName ( const char *  process_name,
const ProcessAttachInfo attach_info 
)
inlinevirtual

Attach to an existing process using a partial process name.

Parameters
[in]process_nameThe name of the process to attach to.
[in]attach_infoInformation on how to do the attach. For example, GetUserID() will return the uid to attach as.
Returns
Returns a successful Status attaching was successful, or an appropriate (possibly platform-specific) error code if attaching fails.

Reimplemented in lldb_private::process_gdb_remote::ProcessGDBRemote, and ProcessKDP.

Definition at line 966 of file Process.h.

References error().

Referenced by Attach().

◆ DoConnectRemote()

virtual Status lldb_private::Process::DoConnectRemote ( llvm::StringRef  remote_url)
inlinevirtual

Attach to a remote system via a URL.

Parameters
[in]remote_urlThe URL format that we are connecting to.
Returns
Returns an error object.

Reimplemented in lldb_private::process_gdb_remote::ProcessGDBRemote, and ProcessKDP.

Definition at line 923 of file Process.h.

References error().

Referenced by ConnectRemote().

◆ DoDeallocateMemory()

virtual Status lldb_private::Process::DoDeallocateMemory ( lldb::addr_t  ptr)
inlinevirtual

Actually deallocate memory in the process.

This function will deallocate memory in the process's address space that was allocated with AllocateMemory.

Parameters
[in]ptrA return value from AllocateMemory, pointing to the memory you want to deallocate.
Returns
\btrue if the memory was deallocated, \bfalse otherwise.

Reimplemented in lldb_private::process_gdb_remote::ProcessGDBRemote, ProcessKDP, and lldb_private::ProcessWindows.

Definition at line 1927 of file Process.h.

References error(), and lldb_private::PluginInterface::GetPluginName().

Referenced by lldb_private::AllocatedMemoryCache::Clear(), and DeallocateMemory().

◆ DoDestroy()

virtual Status lldb_private::Process::DoDestroy ( )
pure virtual

◆ DoDetach()

virtual Status lldb_private::Process::DoDetach ( bool  keep_stopped)
inlinevirtual

Detaches from a running or stopped process.

Returns
Returns true if the process successfully detaches, false otherwise.

Reimplemented in lldb_private::process_gdb_remote::ProcessGDBRemote, ProcessKDP, and lldb_private::ProcessWindows.

Definition at line 1128 of file Process.h.

References error(), and lldb_private::PluginInterface::GetPluginName().

Referenced by Detach().

◆ DoDidExec()

virtual void lldb_private::Process::DoDidExec ( )
inlinevirtual

Subclasses of Process should implement this function if they need to do anything after a process exec's itself.

Definition at line 993 of file Process.h.

Referenced by DidExec().

◆ DoHalt()

virtual Status lldb_private::Process::DoHalt ( bool &  caused_stop)
inlinevirtual

Halts a running process.

DoHalt must produce one and only one stop StateChanged event if it actually stops the process. If the stop happens through some natural event (for instance a SIGSTOP), then forwarding that event will do. Otherwise, you must generate the event manually. This function is called from the context of the private state thread.

Parameters
[out]caused_stopIf true, then this Halt caused the stop, otherwise, the process was already stopped.
Returns
Returns true if the process successfully halts, false otherwise.

Reimplemented in lldb_private::process_gdb_remote::ProcessGDBRemote, ProcessKDP, and lldb_private::ProcessWindows.

Definition at line 1101 of file Process.h.

References error(), and lldb_private::PluginInterface::GetPluginName().

Referenced by HaltPrivate().

◆ DoLaunch()

virtual Status lldb_private::Process::DoLaunch ( Module exe_module,
ProcessLaunchInfo launch_info 
)
inlinevirtual

Launch a new process.

Launch a new process by spawning a new process using exe_module's file as the file to launch. Launch details are provided in launch_info.

Parameters
[in]exe_moduleThe module from which to extract the file specification and launch.
[in]launch_infoDetails (e.g. arguments, stdio redirection, etc.) for the requested launch.
Returns
An Status instance indicating success or failure of the operation.

Reimplemented in lldb_private::process_gdb_remote::ProcessGDBRemote, lldb_private::ScriptedProcess, lldb_private::ProcessWindows, and ProcessKDP.

Definition at line 1029 of file Process.h.

References error(), and lldb_private::PluginInterface::GetPluginName().

Referenced by Launch().

◆ DoLoadCore()

virtual Status lldb_private::Process::DoLoadCore ( )
inlinevirtual

◆ DoReadMemory()

virtual size_t lldb_private::Process::DoReadMemory ( lldb::addr_t  vm_addr,
void *  buf,
size_t  size,
Status error 
)
protectedpure virtual

Actually do the reading of memory from a process.

Subclasses must override this function and can return fewer bytes than requested when memory requests are too large. This class will break up the memory requests and keep advancing the arguments along as needed.

Parameters
[in]vm_addrA virtual load address that indicates where to start reading memory from.
[in]sizeThe number of bytes to read.
[out]bufA byte buffer that is at least size bytes long that will receive the memory bytes.
[out]errorAn error that indicates the success or failure of this operation. If error indicates success (error.Success()), then the value returned can be trusted, otherwise zero will be returned.
Returns
The number of bytes that were actually read into buf. Zero is returned in the case of an error.

Implemented in lldb_private::ProcessWindows, lldb_private::process_gdb_remote::ProcessGDBRemote, lldb_private::ScriptedProcess, lldb_private::minidump::ProcessMinidump, lldb_private::ProcessTrace, ProcessKDP, ProcessElfCore, and ProcessMachCore.

Referenced by DisableSoftwareBreakpoint(), EnableSoftwareBreakpoint(), and ReadMemoryFromInferior().

◆ DoReadMemoryTags()

virtual llvm::Expected<std::vector<uint8_t> > lldb_private::Process::DoReadMemoryTags ( lldb::addr_t  addr,
size_t  len,
int32_t  type 
)
inlineprotectedvirtual

Does the final operation to read memory tags.

E.g. sending a GDB packet. It assumes that ReadMemoryTags has checked that memory tagging is enabled and has expanded the memory range as needed.

Parameters
[in]addrStart of address range to read memory tags for.
[in]lenLength of the memory range to read tags for (in bytes).
[in]typeType of tags to read (get this from a MemoryTagManager)
Returns
The packed tag data received from the remote or an error if the read failed.

Reimplemented in lldb_private::process_gdb_remote::ProcessGDBRemote.

Definition at line 2817 of file Process.h.

References lldb_private::PluginInterface::GetPluginName().

Referenced by ReadMemoryTags().

◆ DoResume()

virtual Status lldb_private::Process::DoResume ( )
inlinevirtual

Resumes all of a process's threads as configured using the Thread run control functions.

Threads for a process should be updated with one of the run control actions (resume, step, or suspend) that they should take when the process is resumed. If no run control action is given to a thread it will be resumed by default.

Returns
Returns true if the process successfully resumes using the thread run control actions, false otherwise.
See also
Thread:Resume()
Thread:Step()
Thread:Suspend()

Reimplemented in lldb_private::process_gdb_remote::ProcessGDBRemote, ProcessKDP, lldb_private::ScriptedProcess, and lldb_private::ProcessWindows.

Definition at line 1065 of file Process.h.

References error(), and lldb_private::PluginInterface::GetPluginName().

Referenced by PrivateResume().

◆ DoSignal()

virtual Status lldb_private::Process::DoSignal ( int  signal)
inlinevirtual

Sends a process a UNIX signal signal.

Returns
Returns an error object.

Reimplemented in lldb_private::process_gdb_remote::ProcessGDBRemote, and ProcessKDP.

Definition at line 1159 of file Process.h.

References error(), and lldb_private::PluginInterface::GetPluginName().

Referenced by Signal().

◆ DoUpdateThreadList()

virtual bool lldb_private::Process::DoUpdateThreadList ( ThreadList old_thread_list,
ThreadList new_thread_list 
)
protectedpure virtual

Update the thread list following process plug-in's specific logic.

This method should only be invoked by UpdateThreadList.

Returns
true if the new thread list could be generated, false otherwise.

Implemented in lldb_private::process_gdb_remote::ProcessGDBRemote, lldb_private::ScriptedProcess, lldb_private::minidump::ProcessMinidump, lldb_private::ProcessTrace, lldb_private::ProcessWindows, ProcessKDP, ProcessElfCore, and ProcessMachCore.

Referenced by UpdateThreadList().

◆ DoWriteMemory()

virtual size_t lldb_private::Process::DoWriteMemory ( lldb::addr_t  vm_addr,
const void *  buf,
size_t  size,
Status error 
)
inlinevirtual

Actually do the writing of memory to a process.

Parameters
[in]vm_addrA virtual load address that indicates where to start writing memory to.
[in]bufA byte buffer that is at least size bytes long that contains the data to write.
[in]sizeThe number of bytes to write.
[out]errorAn error value in case the memory write fails.
Returns
The number of bytes that were actually written.

Reimplemented in lldb_private::ProcessWindows, lldb_private::process_gdb_remote::ProcessGDBRemote, and ProcessKDP.

Definition at line 1588 of file Process.h.

References error(), and lldb_private::PluginInterface::GetPluginName().

Referenced by DisableSoftwareBreakpoint(), EnableSoftwareBreakpoint(), and WriteMemoryPrivate().

◆ DoWriteMemoryTags()

virtual Status lldb_private::Process::DoWriteMemoryTags ( lldb::addr_t  addr,
size_t  len,
int32_t  type,
const std::vector< uint8_t > &  tags 
)
inlineprotectedvirtual

Does the final operation to write memory tags.

E.g. sending a GDB packet. It assumes that WriteMemoryTags has checked that memory tagging is enabled and has packed the tag data.

Parameters
[in]addrStart of address range to write memory tags for.
[in]lenLength of the memory range to write tags for (in bytes).
[in]typeType of tags to read (get this from a MemoryTagManager)
[in]tagsPacked tags to be written.
Returns
Status telling you whether the write succeeded.

Reimplemented in lldb_private::process_gdb_remote::ProcessGDBRemote.

Definition at line 2841 of file Process.h.

References lldb_private::PluginInterface::GetPluginName().

Referenced by WriteMemoryTags().

◆ DumpThreadPlans()

void Process::DumpThreadPlans ( Stream strm,
lldb::DescriptionLevel  desc_level,
bool  internal,
bool  condense_trivial,
bool  skip_unreported_plans 
)

Dump all the thread plans for this process.

Parameters
[in,out]strmThe stream to which to dump the output
[in]desc_levelHow much detail to dump
[in]internalIf true dump all plans, if false only user initiated plans
[in]condense_trivialIf true, only dump a header if the plan stack is just the base plan.
[in]skip_unreported_plansIf true, skip printing all thread plan stacks that don't currently have a backing lldb_private::Thread *.

Definition at line 1245 of file Process.cpp.

References lldb_private::ThreadPlanStackMap::DumpPlans(), and m_thread_plans.

◆ DumpThreadPlansForTID()

bool Process::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.

Parameters
[in,out]strmThe stream to which to dump the output
[in]tidThe tid whose Plan Stack we are dumping
[in]desc_levelHow much detail to dump
[in]internalIf true dump all plans, if false only user initiated plans
[in]condense_trivialIf true, only dump a header if the plan stack is just the base plan.
[in]skip_unreported_plansIf true, only dump a plan if it is currently backed by an lldb_private::Thread *.
Returns
Returns true if TID was found, false otherwise

Definition at line 1238 of file Process.cpp.

References lldb_private::ThreadPlanStackMap::DumpPlansForTID(), and m_thread_plans.

Referenced by CommandObjectThreadPlanList::DoExecute(), and CommandObjectThreadPlanList::HandleOneThread().

◆ EnableBreakpointSite()

virtual Status lldb_private::Process::EnableBreakpointSite ( BreakpointSite bp_site)
inlinevirtual

◆ EnableBreakpointSiteByID()

Status Process::EnableBreakpointSiteByID ( lldb::user_id_t  break_id)

◆ EnableSoftwareBreakpoint()

Status Process::EnableSoftwareBreakpoint ( BreakpointSite bp_site)
virtual

◆ EnableWatchpoint()

Status Process::EnableWatchpoint ( Watchpoint wp,
bool  notify = true 
)
virtual

◆ ExecutionResultAsCString()

const char * Process::ExecutionResultAsCString ( lldb::ExpressionResults  result)
static

◆ Finalize()

void Process::Finalize ( )
virtual

◆ FindPlugin()

ProcessSP Process::FindPlugin ( lldb::TargetSP  target_sp,
llvm::StringRef  plugin_name,
lldb::ListenerSP  listener_sp,
const FileSpec crash_file_path,
bool  can_connect 
)
static

Find a Process plug-in that can debug module using the currently selected architecture.

Scans all loaded plug-in interfaces that implement versions of the Process plug-in interface and returns the first instance that can debug the file.

See also
Process::CanDebug ()

Definition at line 356 of file Process.cpp.

References lldb_private::PluginManager::GetProcessCreateCallbackAtIndex(), and lldb_private::PluginManager::GetProcessCreateCallbackForPluginName().

Referenced by lldb_private::Target::CreateProcess().

◆ FindThreadPlans()

ThreadPlanStack * Process::FindThreadPlans ( lldb::tid_t  tid)

Find the thread plan stack associated with thread with tid.

Parameters
[in]tidThe tid whose Plan Stack we are seeking.
Returns
Returns a ThreadPlan if the TID is found or nullptr if not.

Definition at line 1226 of file Process.cpp.

References lldb_private::ThreadPlanStackMap::Find(), and m_thread_plans.

◆ Flush()

void Process::Flush ( )

Flush all data in the process.

Flush the memory caches, all threads, and any other cached data in the process.

This function can be called after a world changing event like adding a new symbol file, or after the process makes a large context switch (from boot ROM to booted into an OS).

Definition at line 5594 of file Process.cpp.

References lldb_private::QueueList::Clear(), lldb_private::ThreadList::Flush(), m_extended_thread_list, m_extended_thread_stop_id, m_queue_list, m_queue_list_stop_id, and m_thread_list.

Referenced by DidExec(), CommandObjectTargetModulesLoad::DoExecute(), CommandObjectTargetSymbolsAdd::DoExecute(), LoadOperatingSystemPlugin(), and lldb_private::ProcessProperties::SetDisableLangRuntimeUnwindPlans().

◆ ForceNextEventDelivery()

void lldb_private::Process::ForceNextEventDelivery ( )
inlineprotected

Definition at line 2748 of file Process.h.

References m_force_next_event_delivery.

Referenced by RunThreadPlan().

◆ GetABI()

const lldb::ABISP & Process::GetABI ( )

◆ GetAddressByteSize()

uint32_t Process::GetAddressByteSize ( ) const

Definition at line 3340 of file Process.cpp.

References lldb_private::ArchSpec::GetAddressByteSize(), lldb_private::Target::GetArchitecture(), and GetTarget().

Referenced by lldb_private::formatters::Foundation1437::__NSArrayMSize(), lldb_private::formatters::Foundation1437::__NSArrayMSize_Impl(), lldb_private::formatters::Foundation1437::__NSDictionaryMSize(), lldb_private::formatters::Foundation1437::__NSDictionaryMSize_Impl(), lldb_private::formatters::Foundation1437::__NSSetMSize(), lldb_private::formatters::Foundation1437::__NSSetMSize_Impl(), CallVoidArgVoidPtrReturn(), SystemRuntimeMacOSX::CompleteQueueItem(), CommandObjectProcessMinidumpDump::DoExecute(), CommandObjectMemoryFind::DoExecute(), PlatformPOSIX::DoLoadImage(), CommandObjectRegisterRead::DumpRegister(), lldb_private::AppleObjCRuntimeV2::NonPointerISACache::EvaluateNonPointerISA(), ExtractRuntimeGlobalSymbol(), lldb_private::CPPLanguageRuntime::FindLibCppStdFunctionCallableInfo(), ABISysV_arm::GetArgumentValues(), ABIMacOSX_arm::GetArgumentValues(), ABISysV_arm64::GetArgumentValues(), ABIMacOSX_arm64::GetArgumentValues(), ProcessElfCore::GetAuxvData(), lldb_private::process_gdb_remote::ProcessGDBRemote::GetAuxvData(), lldb_private::AppleObjCRuntime::GetBacktraceThreadFromException(), GetClassDataMask(), lldb_private::AppleObjCRuntimeV2::TaggedPointerVendorRuntimeAssisted::GetClassDescriptor(), lldb_private::AppleObjCRuntimeV2::TaggedPointerVendorExtended::GetClassDescriptor(), lldb_private::ItaniumABILanguageRuntime::GetDynamicTypeAndAddress(), SystemRuntimeMacOSX::GetExtendedBacktraceFromItemRef(), SystemRuntimeMacOSX::GetExtendedBacktraceThread(), lldb_private::formatters::InferiorSizedWord::GetMaximum(), SystemRuntimeMacOSX::GetPendingItemRefsForQueue(), ABIMacOSX_arm64::GetReturnValueObjectImpl(), ABISysV_arm64::GetReturnValueObjectImpl(), DynamicLoaderMacOSXDYLD::GetSharedCacheInformation(), lldb_private::ClassDescriptorV2::method_t::GetSize(), lldb_private::ClassDescriptorV2::ivar_t::GetSize(), lldb_private::AppleObjCTrampolineHandler::GetStepThroughDispatchPlan(), lldb_private::ClangExpressionDeclMap::GetTargetInfo(), lldb_private::DynamicLoaderDarwin::GetThreadLocalData(), lldb_private::InferiorCallMmap(), LoadValueFromConsecutiveGPRRegisters(), lldb_private::ThreadPlanAssemblyTracer::Log(), RemoteNXMapTable::ParseHeader(), SystemRuntimeMacOSX::PopulateQueuesUsingLibBTR(), lldb_private::ProcessStructReader::ProcessStructReader(), lldb_private::ClassDescriptorV2::objc_class_t::Read(), lldb_private::ClassDescriptorV2::class_ro_t::Read(), lldb_private::ClassDescriptorV2::class_rw_t::Read(), lldb_private::ClassDescriptorV2::method_list_t::Read(), lldb_private::ClassDescriptorV2::method_t::Read(), lldb_private::ClassDescriptorV2::ivar_list_t::Read(), lldb_private::ClassDescriptorV2::ivar_t::Read(), lldb_private::RegisterContextUnwind::ReadFrameAddress(), SystemRuntimeMacOSX::ReadLibdispatchOffsets(), SystemRuntimeMacOSX::ReadLibpthreadOffsets(), HexagonDYLDRendezvous::ReadPointer(), DYLDRendezvous::ReadPointer(), ReadPointerFromMemory(), ReadScalarIntegerFromMemory(), ReadVBaseOffsetFromVTable(), HexagonDYLDRendezvous::Resolve(), DYLDRendezvous::Resolve(), DYLDRendezvous::ResolveRendezvousAddress(), lldb_private::RegisterContextUnwind::SavedLocationForRegister(), DynamicLoaderDarwinKernel::SearchForKernelWithDebugHints(), NSIndexPathSyntheticFrontEnd::Impl::InlinedIndexes::SetIndexes(), lldb_private::AppleObjCRuntimeV2::DynamicClassInfoExtractor::UpdateISAToDescriptorMap(), lldb_private::AppleObjCRuntimeV2::SharedCacheClassInfoExtractor::UpdateISAToDescriptorMap(), lldb_private::AppleObjCRuntimeV1::UpdateISAToDescriptorMapIfNeeded(), lldb_private::ValueObjectRegister::UpdateValue(), lldb_private::FunctionCaller::WriteFunctionArguments(), and WritePointerToMemory().

◆ GetAsyncProfileData()

size_t Process::GetAsyncProfileData ( char *  buf,
size_t  buf_size,
Status error 
)
virtual

Get any available profile data.

Parameters
[out]bufA buffer that will receive any profile data bytes that are currently available.
[out]buf_sizeThe size in bytes for the buffer buf.
Returns
The number of bytes written into buf. If this value is equal to buf_size, another call to this function should be made to retrieve more profile data.

Definition at line 4261 of file Process.cpp.

References lldb_private::GetLogIfAllCategoriesSet(), LIBLLDB_LOG_PROCESS, LLDB_LOGF, m_profile_data, m_profile_data_comm_mutex, and string().

◆ GetAuxvData()

DataExtractor Process::GetAuxvData ( )
virtual

◆ GetBreakpointSiteList() [1/2]

const BreakpointSiteList & Process::GetBreakpointSiteList ( )

◆ GetBreakpointSiteList() [2/2]

const BreakpointSiteList& lldb_private::Process::GetBreakpointSiteList ( ) const

◆ GetBroadcasterClass()

ConstString& lldb_private::Process::GetBroadcasterClass ( ) const
inlineoverridevirtual

This needs to be filled in if you are going to register the broadcaster with the broadcaster manager and do broadcaster class matching.

FIXME: Probably should make a ManagedBroadcaster subclass with all the bits needed to work with the BroadcasterManager, so that it is clearer how to add one.

Reimplemented from lldb_private::Broadcaster.

Definition at line 388 of file Process.h.

References GetStaticBroadcasterClass().

◆ GetByteOrder()

lldb::ByteOrder Process::GetByteOrder ( ) const

Definition at line 3336 of file Process.cpp.

References lldb_private::Target::GetArchitecture(), lldb_private::ArchSpec::GetByteOrder(), and GetTarget().

Referenced by SystemRuntimeMacOSX::CompleteQueueItem(), lldb_private::IRExecutionUnit::DisassembleFunction(), CommandObjectMemoryFind::DoExecute(), lldb_private::ScriptedProcess::DoReadMemory(), lldb_private::TypeSystemClang::DumpSummary(), lldb_private::DWARFExpression::Evaluate(), lldb_private::AppleObjCRuntimeV2::NonPointerISACache::EvaluateNonPointerISA(), ProcessElfCore::GetAuxvData(), lldb_private::process_gdb_remote::ProcessGDBRemote::GetAuxvData(), lldb_private::RegisterContext::GetByteOrder(), SystemRuntimeMacOSX::GetExtendedBacktraceFromItemRef(), SystemRuntimeMacOSX::GetExtendedBacktraceThread(), SystemRuntimeMacOSX::GetPendingItemRefsForQueue(), ABIMacOSX_arm64::GetReturnValueObjectImpl(), ABISysV_arm64::GetReturnValueObjectImpl(), lldb_private::ClangExpressionDeclMap::GetTargetInfo(), lldb_private::DynamicLoaderDarwin::GetThreadLocalData(), LoadValueFromConsecutiveGPRRegisters(), lldb_private::ThreadPlanAssemblyTracer::Log(), SystemRuntimeMacOSX::PopulateQueuesUsingLibBTR(), lldb_private::ProcessStructReader::ProcessStructReader(), lldb_private::ClassDescriptorV2::objc_class_t::Read(), lldb_private::ClassDescriptorV2::class_ro_t::Read(), lldb_private::ClassDescriptorV2::class_rw_t::Read(), lldb_private::ClassDescriptorV2::method_list_t::Read(), lldb_private::ClassDescriptorV2::method_t::Read(), lldb_private::ClassDescriptorV2::ivar_list_t::Read(), lldb_private::ClassDescriptorV2::ivar_t::Read(), lldb_private::RegisterContextUnwind::ReadFrameAddress(), SystemRuntimeMacOSX::ReadLibdispatchOffsets(), SystemRuntimeMacOSX::ReadLibpthreadOffsets(), ReadScalarIntegerFromMemory(), lldb_private::RegisterContextUnwind::SavedLocationForRegister(), DynamicLoaderDarwinKernel::SearchForKernelWithDebugHints(), lldb_private::process_gdb_remote::ProcessGDBRemote::SetThreadPc(), lldb_private::AppleObjCRuntimeV2::DynamicClassInfoExtractor::UpdateISAToDescriptorMap(), lldb_private::AppleObjCRuntimeV2::SharedCacheClassInfoExtractor::UpdateISAToDescriptorMap(), lldb_private::AppleObjCRuntimeV1::UpdateISAToDescriptorMapIfNeeded(), and WriteScalarToMemory().

◆ GetCodeAddressMask()

lldb::addr_t Process::GetCodeAddressMask ( )

◆ GetDataAddressMask()

lldb::addr_t Process::GetDataAddressMask ( )

◆ GetDynamicCheckers()

DynamicCheckerFunctions* lldb_private::Process::GetDynamicCheckers ( )
inline

◆ GetDynamicLoader()

DynamicLoader * Process::GetDynamicLoader ( )
virtual

Get the dynamic loader plug-in for this process.

The default action is to let the DynamicLoader plug-ins check the main executable and the DynamicLoader will select itself automatically. Subclasses can override this if inspecting the executable is not desired, or if Process subclasses can only use a specific DynamicLoader plug-in.

Reimplemented in lldb_private::process_gdb_remote::ProcessGDBRemote, lldb_private::ProcessWindows, ProcessKDP, lldb_private::ScriptedProcess, ProcessElfCore, lldb_private::minidump::ProcessMinidump, ProcessMachCore, and lldb_private::ProcessTrace.

Definition at line 2645 of file Process.cpp.

References lldb_private::DynamicLoader::FindPlugin(), and m_dyld_up.

Referenced by CompleteAttach(), PlatformPOSIX::EvaluateLibdlExpression(), lldb_private::RegisterContextUnwind::GetFullUnwindPlanForFrame(), ObjectFileMachO::GetProcessSharedCacheUUID(), Launch(), and LoadCore().

◆ GetEventsPrivate()

bool Process::GetEventsPrivate ( lldb::EventSP &  event_sp,
const Timeout< std::micro > &  timeout,
bool  control_only 
)
protected

◆ GetExitDescription()

const char * Process::GetExitDescription ( )

Get a textual description of what the process exited.

Returns
The textual description of why the process exited, or nullptr if there is no description available.

Definition at line 1042 of file Process.cpp.

References lldb::eStateExited, lldb_private::ThreadSafeValue< T >::GetValue(), m_exit_status_mutex, m_exit_string, and m_public_state.

Referenced by GetStatus().

◆ GetExitStatus()

int Process::GetExitStatus ( )

Get the exit status for a process.

Returns
The process's return code, or -1 if the current process state is not eStateExited.

Definition at line 1034 of file Process.cpp.

References lldb::eStateExited, lldb_private::ThreadSafeValue< T >::GetValue(), m_exit_status, m_exit_status_mutex, and m_public_state.

Referenced by GetStatus().

◆ GetExtendedThreadList()

ThreadList& lldb_private::Process::GetExtendedThreadList ( )
inline

◆ GetFileLoadAddress()

virtual Status lldb_private::Process::GetFileLoadAddress ( const FileSpec file,
bool &  is_loaded,
lldb::addr_t load_addr 
)
inlinevirtual

Try to find the load address of a file.

The load address is defined as the address of the first memory region what contains data mapped from the specified file.

Parameters
[in]fileThe name of the file whose load address we are looking for
[out]is_loadedTrue if the file is loaded into the memory and false otherwise.
[out]load_addrThe load address of the file if it is loaded into the processes address space, LLDB_INVALID_ADDRESS otherwise.

Reimplemented in lldb_private::process_gdb_remote::ProcessGDBRemote.

Definition at line 2451 of file Process.h.

Referenced by lldb_private::DynamicLoader::LoadModuleAtAddress(), and DYLDRendezvous::UpdateBaseAddrIfNecessary().

◆ GetGlobalProperties()

const ProcessPropertiesSP & Process::GetGlobalProperties ( )
static

◆ GetHistoryThreads()

ThreadCollectionSP Process::GetHistoryThreads ( lldb::addr_t  addr)

Definition at line 5793 of file Process.cpp.

References lldb_private::MemoryHistory::FindPlugin().

◆ GetHostMacCatalystVersion()

virtual llvm::VersionTuple lldb_private::Process::GetHostMacCatalystVersion ( )
inlinevirtual
Returns
the macCatalyst version of the host OS.

Reimplemented in lldb_private::process_gdb_remote::ProcessGDBRemote.

Definition at line 1207 of file Process.h.

◆ GetHostOSVersion()

virtual llvm::VersionTuple lldb_private::Process::GetHostOSVersion ( )
inlinevirtual

Sometimes the connection to a process can detect the host OS version that the process is running on.

The current platform should be checked first in case the platform is connected, but clients can fall back onto this function if the platform fails to identify the host OS version. The platform should be checked first in case you are running a simulator platform that might itself be running natively, but have different heuristics for figuring out which OS is is emulating.

Returns
Returns the version tuple of the host OS. In case of failure an empty VersionTuple is returner.

Reimplemented in lldb_private::process_gdb_remote::ProcessGDBRemote.

Definition at line 1204 of file Process.h.

Referenced by lldb_private::Platform::GetOSVersion(), and lldb_private::DynamicLoaderDarwin::UseDYLDSPI().

◆ GetID()

lldb::pid_t lldb_private::Process::GetID ( ) const
inline

Returns the pid of the process or LLDB_INVALID_PROCESS_ID if there is no known pid.

Definition at line 542 of file Process.h.

References m_pid.

Referenced by ProcessKDP::AsyncThread(), lldb_private::process_gdb_remote::ProcessGDBRemote::AsyncThread(), Attach(), lldb_private::TraceSessionSaver::BuildProcessesSection(), CanJIT(), CompleteAttach(), ConnectRemote(), DynamicLoaderPOSIXDYLD::DidAttach(), ProcessKDP::DidAttach(), lldb_private::process_gdb_remote::ProcessGDBRemote::DoConnectRemote(), lldb_private::process_gdb_remote::ProcessGDBRemote::DoDestroy(), lldb_private::ProcessWindows::DoDetach(), CommandObjectProcessContinue::DoExecute(), CommandObjectThreadContinue::DoExecute(), CommandObjectProcessConnect::DoExecute(), CommandObjectThreadUntil::DoExecute(), lldb_private::process_gdb_remote::ProcessGDBRemote::DoLaunch(), ProcessKDP::DoUpdateThreadList(), lldb_private::process_gdb_remote::ProcessGDBRemote::DoUpdateThreadList(), DynamicLoaderPOSIXDYLD::EntryBreakpointHit(), lldb_private::FormatEntity::Format(), PlatformDarwin::GetOSVersion(), lldb_private::ProcessTrace::GetProcessInfo(), lldb_private::minidump::ProcessMinidump::GetProcessInfo(), lldb_private::ScriptedProcess::GetProcessInfo(), ProcessElfCore::GetProcessInfo(), GetProcessInfo(), GetStatus(), HandlePrivateEvent(), lldb_private::process_gdb_remote::ProcessGDBRemote::HandleStopReply(), Launch(), lldb_private::ProcessWindows::OnExitProcess(), lldb_private::Process::AttachCompletionHandler::PerformAction(), DynamicLoaderPOSIXDYLD::ProbeEntry(), DynamicLoaderPOSIXDYLD::RendezvousBreakpointHit(), DynamicLoaderPOSIXDYLD::ResolveExecutableModule(), RunPrivateStateThread(), DynamicLoaderPOSIXDYLD::SetRendezvousBreakpoint(), lldb_private::process_gdb_remote::ProcessGDBRemote::SetThreadStopInfo(), StartPrivateStateThread(), and lldb_private::process_gdb_remote::ThreadGDBRemote::ThreadGDBRemote().

◆ GetImageInfoAddress()

addr_t Process::GetImageInfoAddress ( )
virtual

Get the image information address for the current process.

Some runtimes have system functions that can help dynamic loaders locate the dynamic loader information needed to observe shared libraries being loaded or unloaded. This function is in the Process interface (as opposed to the DynamicLoader interface) to ensure that remote debugging can take advantage of this functionality.

Returns
The address of the dynamic loader information, or LLDB_INVALID_ADDRESS if this is not supported by this interface.

Reimplemented in lldb_private::process_gdb_remote::ProcessGDBRemote, ProcessElfCore, lldb_private::ProcessWindows, ProcessKDP, and ProcessMachCore.

Definition at line 1473 of file Process.cpp.

References LLDB_INVALID_ADDRESS.

Referenced by DynamicLoaderMacOS::DoInitialImageFetch(), DynamicLoaderMacOSXDYLD::DoInitialImageFetch(), DynamicLoaderMacOSXDYLD::GetSharedCacheInformation(), DynamicLoaderMacOS::ProcessDidExec(), DynamicLoaderMacOSXDYLD::ProcessDidExec(), ResolveRendezvousAddress(), DYLDRendezvous::ResolveRendezvousAddress(), and DynamicLoaderDarwinKernel::SearchForDarwinKernel().

◆ GetImagePtrFromToken()

lldb::addr_t Process::GetImagePtrFromToken ( size_t  token) const

Definition at line 5830 of file Process.cpp.

References LLDB_INVALID_ADDRESS, and m_image_tokens.

Referenced by PlatformPOSIX::UnloadImage().

◆ GetImageTokens()

const std::vector<lldb::addr_t>& lldb_private::Process::GetImageTokens ( )
inline

Get the image vector for the current process.

Returns
The constant reference to the member m_image_tokens.

Definition at line 744 of file Process.h.

References m_image_tokens.

Referenced by CommandObjectProcessUnload::HandleArgumentCompletion().

◆ GetInstrumentationRuntime()

InstrumentationRuntimeSP Process::GetInstrumentationRuntime ( lldb::InstrumentationRuntimeType  type)

Definition at line 5810 of file Process.cpp.

References m_instrumentation_runtimes.

◆ GetIOHandlerID()

uint32_t lldb_private::Process::GetIOHandlerID ( ) const
inline

◆ GetJITLoaders()

JITLoaderList & Process::GetJITLoaders ( )
protectedvirtual

◆ GetLanguageRuntime()

LanguageRuntime * Process::GetLanguageRuntime ( lldb::LanguageType  language)

◆ GetLanguageRuntimes()

std::vector< LanguageRuntime * > Process::GetLanguageRuntimes ( )

◆ GetLastNaturalStopID()

uint32_t lldb_private::Process::GetLastNaturalStopID ( ) const
inline

◆ GetLastUserExpressionResumeID()

uint32_t lldb_private::Process::GetLastUserExpressionResumeID ( ) const
inline

◆ GetLoadAddressPermissions()

bool Process::GetLoadAddressPermissions ( lldb::addr_t  load_addr,
uint32_t permissions 
)
virtual

Attempt to get the attributes for a region of memory in the process.

It may be possible for the remote debug server to inspect attributes for a region of memory in the process, such as whether there is a valid page of memory at a given address or whether that page is readable/writable/executable by the process.

Parameters
[in]load_addrThe address of interest in the process.
[out]permissionsIf this call returns successfully, this bitmask will have its Permissions bits set to indicate whether the region is readable/writable/executable. If this call fails, the bitmask values are undefined.
Returns
Returns true if it was able to determine the attributes of the memory region. False if not.

Definition at line 2408 of file Process.cpp.

References lldb_private::MemoryRegionInfo::eDontKnow, error(), lldb_private::MemoryRegionInfo::eYes, lldb_private::MemoryRegionInfo::GetExecutable(), GetMemoryRegionInfo(), lldb_private::MemoryRegionInfo::GetReadable(), and lldb_private::MemoryRegionInfo::GetWritable().

Referenced by lldb_private::RegisterContextUnwind::GetFullUnwindPlanForFrame(), lldb_private::RegisterContextUnwind::InitializeNonZerothFrame(), lldb_private::RegisterContextUnwind::ReadFrameAddress(), and lldb_private::ThreadPlanStepOut::ThreadPlanStepOut().

◆ GetLoadedDynamicLibrariesInfos() [1/3]

virtual lldb_private::StructuredData::ObjectSP lldb_private::Process::GetLoadedDynamicLibrariesInfos ( )
inlinevirtual

Reimplemented in lldb_private::process_gdb_remote::ProcessGDBRemote.

Definition at line 1298 of file Process.h.

◆ GetLoadedDynamicLibrariesInfos() [2/3]

virtual lldb_private::StructuredData::ObjectSP lldb_private::Process::GetLoadedDynamicLibrariesInfos ( const std::vector< lldb::addr_t > &  load_addresses)
inlinevirtual

Reimplemented in lldb_private::process_gdb_remote::ProcessGDBRemote.

Definition at line 1304 of file Process.h.

◆ GetLoadedDynamicLibrariesInfos() [3/3]

virtual lldb_private::StructuredData::ObjectSP lldb_private::Process::GetLoadedDynamicLibrariesInfos ( lldb::addr_t  image_list_address,
lldb::addr_t  image_count 
)
inlinevirtual

Retrieve the list of shared libraries that are loaded for this process This method is used on pre-macOS 10.12, pre-iOS 10, pre-tvOS 10, pre- watchOS 3 systems.

The following two methods are for newer versions of those OSes.

For certain platforms, the time it takes for the DynamicLoader plugin to read all of the shared libraries out of memory over a slow communication channel may be too long. In that instance, the gdb-remote stub may be able to retrieve the necessary information about the solibs out of memory and return a concise summary sufficient for the DynamicLoader plugin.

Parameters
[in]image_list_addressThe address where the table of shared libraries is stored in memory, if that is appropriate for this platform. Else this may be passed as LLDB_INVALID_ADDRESS.
[in]image_countThe number of shared libraries that are present in this process, if that is appropriate for this platofrm Else this may be passed as LLDB_INVALID_ADDRESS.
Returns
A StructuredDataSP object which, if non-empty, will contain the information the DynamicLoader needs to get the initial scan of solibs resolved.

Reimplemented in lldb_private::process_gdb_remote::ProcessGDBRemote.

Definition at line 1290 of file Process.h.

Referenced by DynamicLoaderMacOS::AddBinaries(), DynamicLoaderMacOSXDYLD::AddModulesUsingImageInfosAddress(), and DynamicLoaderMacOS::DoInitialImageFetch().

◆ GetLoadedModuleList()

virtual llvm::Expected<LoadedModuleInfoList> lldb_private::Process::GetLoadedModuleList ( )
inlinevirtual

Query remote GDBServer for a detailed loaded library list.

Returns
The list of modules currently loaded by the process, or an error.

Reimplemented in lldb_private::process_gdb_remote::ProcessGDBRemote.

Definition at line 685 of file Process.h.

Referenced by DYLDRendezvous::UpdateSOEntriesFromRemote().

◆ GetLoadImageUtilityFunction()

UtilityFunction * Process::GetLoadImageUtilityFunction ( Platform platform,
llvm::function_ref< std::unique_ptr< UtilityFunction >()>  factory 
)

Get the cached UtilityFunction that assists in loading binary images into the process.

Parameters
[in]platformThe platform fetching the UtilityFunction.
[in]factoryA function that will be called only once per-process in a thread-safe way to create the UtilityFunction if it has not been initialized yet.
Returns
The cached utility function or null if the platform is not the same as the target's platform.

Definition at line 6038 of file Process.cpp.

References GetTarget(), m_dlopen_utility_func_flag_once, and m_dlopen_utility_func_up.

Referenced by PlatformPOSIX::DoLoadImage().

◆ GetMemoryRegionInfo()

virtual Status lldb_private::Process::GetMemoryRegionInfo ( lldb::addr_t  load_addr,
MemoryRegionInfo range_info 
)
inlinevirtual

Locate the memory region that contains load_addr.

If load_addr is within the address space the process has mapped range_info will be filled in with the start and end of that range as well as the permissions for that range and range_info.GetMapped will return true.

If load_addr is outside any mapped region then range_info will have its start address set to load_addr and the end of the range will indicate the start of the next mapped range or be set to LLDB_INVALID_ADDRESS if there are no valid mapped ranges between load_addr and the end of the process address space.

GetMemoryRegionInfo will only return an error if it is unimplemented for the current process.

Parameters
[in]load_addrThe load address to query the range_info for.
[out]range_infoAn range_info value containing the details of the range.
Returns
An error value.

Reimplemented in lldb_private::ProcessWindows, lldb_private::process_gdb_remote::ProcessGDBRemote, lldb_private::ScriptedProcess, lldb_private::minidump::ProcessMinidump, ProcessElfCore, and ProcessMachCore.

Definition at line 1821 of file Process.h.

References error().

Referenced by GetLoadAddressPermissions(), GetMemoryRegions(), DynamicLoaderPOSIXDYLD::LoadInterpreterModule(), lldb_private::DynamicLoader::LoadModuleAtAddress(), DynamicLoaderPOSIXDYLD::LoadVDSO(), and DYLDRendezvous::UpdateFileSpecIfNecessary().

◆ GetMemoryRegions()

Status Process::GetMemoryRegions ( lldb_private::MemoryRegionInfos region_list)
virtual

Obtain all the mapped memory regions within this process.

Parameters
[out]region_listA vector to contain MemoryRegionInfo objects for all mapped ranges.
Returns
An error value.

Reimplemented in lldb_private::ScriptedProcess, and lldb_private::minidump::ProcessMinidump.

Definition at line 5891 of file Process.cpp.

References error(), lldb_private::MemoryRegionInfo::eYes, lldb_private::MemoryRegionInfo::GetMapped(), GetMemoryRegionInfo(), lldb_private::MemoryRegionInfo::GetRange(), lldb_private::Range< B, S >::GetRangeEnd(), and LLDB_INVALID_ADDRESS.

Referenced by CommandObjectMemoryTagRead::DoExecute(), and CommandObjectMemoryTagWrite::DoExecute().

◆ GetMemoryTagManager()

llvm::Expected< const MemoryTagManager * > Process::GetMemoryTagManager ( )

If this architecture and process supports memory tagging, return a tag manager that can be used to maniupulate those memory tags.

Returns
Either a valid pointer to a tag manager or an error describing why one could not be provided.

Definition at line 6110 of file Process.cpp.

References lldb_private::Target::GetArchitecturePlugin(), lldb_private::Architecture::GetMemoryTagManager(), lldb_private::PluginInterface::GetPluginName(), GetTarget(), and SupportsMemoryTagging().

Referenced by CommandObjectMemoryTagRead::DoExecute(), CommandObjectMemoryTagWrite::DoExecute(), ReadMemoryTags(), and WriteMemoryTags().

◆ GetModID()

ProcessModID lldb_private::Process::GetModID ( ) const
inline

Get the Modification ID of the process.

Returns
The modification ID of the process.

Definition at line 1369 of file Process.h.

References m_mod_id.

Referenced by lldb_private::ValueObject::EvaluationPoint::SyncWithProcessState().

◆ GetModIDRef()

const ProcessModID& lldb_private::Process::GetModIDRef ( ) const
inline

Definition at line 1371 of file Process.h.

References m_mod_id.

Referenced by lldb_private::StopInfoBreakpoint::PerformAction().

◆ GetModuleSpec()

bool Process::GetModuleSpec ( const FileSpec module_file_spec,
const ArchSpec arch,
ModuleSpec module_spec 
)
virtual

Try to fetch the module specification for a module with the given file name and architecture.

Process sub-classes have to override this method if they support platforms where the Platform object can't get the module spec for all module.

Parameters
[in]module_file_specThe file name of the module to get specification for.
[in]archThe architecture of the module to get specification for.
[out]module_specThe fetched module specification if the return value is true, unchanged otherwise.
Returns
Returns true if the module spec fetched successfully, false otherwise.

Reimplemented in lldb_private::process_gdb_remote::ProcessGDBRemote.

Definition at line 5819 of file Process.cpp.

References lldb_private::ModuleSpec::Clear().

Referenced by lldb_private::Platform::GetRemoteSharedModule().

◆ GetNextEvent()

StateType Process::GetNextEvent ( lldb::EventSP &  event_sp)

◆ GetNextThreadIndexID()

uint32_t Process::GetNextThreadIndexID ( uint64_t  thread_id)

Definition at line 1272 of file Process.cpp.

References AssignIndexIDToThread().

◆ GetOperatingSystem()

OperatingSystem* lldb_private::Process::GetOperatingSystem ( )
inline

Definition at line 2250 of file Process.h.

References m_os_up.

Referenced by CreateOSPluginThread(), and UpdateThreadListIfNeeded().

◆ GetPluginCommandObject()

virtual CommandObject* lldb_private::Process::GetPluginCommandObject ( )
inlinevirtual

Return a multi-word command object that can be used to expose plug-in specific commands.

This object will be used to resolve plug-in commands and can be triggered by a call to:

(lldb) process command <args>
Returns
A CommandObject which can be one of the concrete subclasses of CommandObject like CommandObjectRaw, CommandObjectParsed, or CommandObjectMultiword.

Reimplemented in lldb_private::process_gdb_remote::ProcessGDBRemote, ProcessKDP, and lldb_private::minidump::ProcessMinidump.

Definition at line 588 of file Process.h.

Referenced by CommandObjectProcessPlugin::GetProxyCommandObject().

◆ GetPrivateState()

StateType Process::GetPrivateState ( )
protected

◆ GetProcessInfo()

bool Process::GetProcessInfo ( ProcessInstanceInfo info)
virtual

◆ GetQueueList()

QueueList& lldb_private::Process::GetQueueList ( )
inline

Definition at line 2142 of file Process.h.

References m_queue_list, and UpdateQueueListIfNeeded().

◆ GetResumeID()

uint32_t lldb_private::Process::GetResumeID ( ) const
inline

Definition at line 1375 of file Process.h.

References lldb_private::ProcessModID::GetResumeID(), and m_mod_id.

◆ GetRunLock()

ProcessRunLock & Process::GetRunLock ( )

Definition at line 5581 of file Process.cpp.

References lldb_private::HostThread::EqualsThread(), lldb_private::Host::GetCurrentThread(), m_private_run_lock, m_private_state_thread, and m_public_run_lock.

Referenced by lldb::SBFrame::Disassemble(), lldb::SBFrame::EvaluateExpression(), lldb::SBFrame::FindRegister(), lldb::SBFrame::FindValue(), lldb::SBFrame::FindVariable(), lldb::SBFrame::GetBlock(), lldb::SBFrame::GetCompileUnit(), lldb::SBFrame::GetDescription(), lldb::SBFrame::GetDisplayFunctionName(), lldb::SBThread::GetExtendedBacktraceThread(), lldb::SBFrame::GetFP(), lldb::SBThread::GetFrameAtIndex(), lldb::SBFrame::GetFrameBlock(), lldb::SBFrame::GetFunction(), lldb::SBThread::GetInfoItemByPathAsString(), lldb::SBFrame::GetLineEntry(), lldb::SBFrame::GetModule(), lldb::SBThread::GetName(), lldb::SBThread::GetNumFrames(), lldb::SBFrame::GetPC(), lldb::SBFrame::GetPCAddress(), lldb::SBThread::GetQueue(), lldb::SBThread::GetQueueID(), lldb::SBThread::GetQueueName(), lldb::SBFrame::GetRegisters(), lldb::SBThread::GetSelectedFrame(), lldb::SBFrame::GetSP(), lldb::SBThread::GetStopDescription(), lldb::SBThread::GetStopReason(), lldb::SBThread::GetStopReasonDataAtIndex(), lldb::SBThread::GetStopReasonDataCount(), lldb::SBThread::GetStopReturnValue(), lldb::SBFrame::GetSymbol(), lldb::SBFrame::GetSymbolContext(), lldb::SBFrame::GetValueForVariablePath(), lldb::SBFrame::GetVariables(), lldb::SBFrame::GuessLanguage(), lldb::SBFrame::operator bool(), lldb::SBThread::operator bool(), lldb::SBThread::Resume(), lldb::SBFrame::SetPC(), lldb::SBThread::SetSelectedFrame(), and lldb::SBThread::Suspend().

◆ GetSharedCacheInfo()

virtual lldb_private::StructuredData::ObjectSP lldb_private::Process::GetSharedCacheInfo ( )
inlinevirtual

◆ GetShouldDetach()

bool lldb_private::Process::GetShouldDetach ( ) const
inline

◆ GetSoftwareBreakpointTrapOpcode()

size_t Process::GetSoftwareBreakpointTrapOpcode ( BreakpointSite bp_site)

◆ GetState()

StateType Process::GetState ( )

◆ GetStateChangedEvents()

StateType Process::GetStateChangedEvents ( lldb::EventSP &  event_sp,
const Timeout< std::micro > &  timeout,
lldb::ListenerSP  hijack_listener 
)

◆ GetStateChangedEventsPrivate()

StateType Process::GetStateChangedEventsPrivate ( lldb::EventSP &  event_sp,
const Timeout< std::micro > &  timeout 
)
protected

◆ GetStaticBroadcasterClass()

ConstString & Process::GetStaticBroadcasterClass ( )
static

◆ GetStatus()

void Process::GetStatus ( Stream ostrm)

◆ GetSTDERR()

size_t Process::GetSTDERR ( char *  buf,
size_t  buf_size,
Status error 
)
virtual

Get any available STDERR.

Calling this method is a valid operation only if all of the following conditions are true: 1) The process was launched, and not attached to. 2) The process was not launched with eLaunchFlagDisableSTDIO. 3) The process was launched without supplying a valid file path for STDERR.

Note that the implementation will probably need to start a read thread in the background to make sure that the pipe is drained and the STDERR buffered appropriately, to prevent the process from deadlocking trying to write to a full buffer.

Events will be queued indicating that there is STDERR available that can be retrieved using this function.

Parameters
[in]bufA buffer that will receive any STDERR bytes that are currently available.
[out]buf_sizeThe size in bytes for the buffer buf.
Returns
The number of bytes written into buf. If this value is equal to buf_size, another call to this function should be made to retrieve more STDERR data.

Reimplemented in lldb_private::ProcessWindows.

Definition at line 4305 of file Process.cpp.

References lldb_private::GetLogIfAllCategoriesSet(), LIBLLDB_LOG_PROCESS, LLDB_LOGF, m_stderr_data, and m_stdio_communication_mutex.

Referenced by lldb_private::Debugger::FlushProcessOutput().

◆ GetSTDOUT()

size_t Process::GetSTDOUT ( char *  buf,
size_t  buf_size,
Status error 
)
virtual

Get any available STDOUT.

Calling this method is a valid operation only if all of the following conditions are true: 1) The process was launched, and not attached to. 2) The process was not launched with eLaunchFlagDisableSTDIO. 3) The process was launched without supplying a valid file path for STDOUT.

Note that the implementation will probably need to start a read thread in the background to make sure that the pipe is drained and the STDOUT buffered appropriately, to prevent the process from deadlocking trying to write to a full buffer.

Events will be queued indicating that there is STDOUT available that can be retrieved using this function.

Parameters
[out]bufA buffer that will receive any STDOUT bytes that are currently available.
[in]buf_sizeThe size in bytes for the buffer buf.
Returns
The number of bytes written into buf. If this value is equal to buf_size, another call to this function should be made to retrieve more STDOUT data.

Reimplemented in lldb_private::ProcessWindows.

Definition at line 4286 of file Process.cpp.

References lldb_private::GetLogIfAllCategoriesSet(), LIBLLDB_LOG_PROCESS, LLDB_LOGF, m_stdio_communication_mutex, and m_stdout_data.

Referenced by lldb_private::Debugger::FlushProcessOutput().

◆ GetStopEventForStopID()

lldb::EventSP lldb_private::Process::GetStopEventForStopID ( uint32_t  stop_id) const
inline

Definition at line 1385 of file Process.h.

References lldb_private::ProcessModID::GetStopEventForStopID(), and m_mod_id.

◆ GetStopID()

uint32_t lldb_private::Process::GetStopID ( ) const
inline

◆ GetStructuredDataPlugin()

StructuredDataPluginSP Process::GetStructuredDataPlugin ( ConstString  type_name) const

Returns the StructuredDataPlugin associated with a given type name, if there is one.

There will only be a plugin for a given StructuredDataType if the debugged process monitor claims that the feature is supported. This is one way to tell whether a feature is available.

Returns
The plugin if one is available for the specified feature; otherwise, returns an empty shared pointer.

Definition at line 4253 of file Process.cpp.

References m_structured_data_plugin_map.

◆ GetSystemRuntime()

SystemRuntime * Process::GetSystemRuntime ( )
virtual

◆ GetTarget() [1/2]

Target& lldb_private::Process::GetTarget ( )
inline

Get the target object pointer for this module.

Returns
A Target object pointer to the target that owns this module.

Definition at line 1214 of file Process.h.

References m_target_wp.

Referenced by lldb_private::StructuredDataDarwinLog::AddInitCompletionHook(), lldb_private::DynamicLoaderDarwin::AddModulesUsingImageInfos(), AdvanceAddressToNextBranchInstruction(), lldb_private::AppleObjCRuntime::AppleObjCRuntime(), lldb_private::AppleObjCTypeEncodingParser::AppleObjCTypeEncodingParser(), lldb_private::process_gdb_remote::ProcessGDBRemote::AsyncThread(), Attach(), lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::AvoidGPackets(), SystemRuntimeMacOSX::BacktraceRecordingHeadersInitialized(), lldb_private::process_gdb_remote::ProcessGDBRemote::BuildDynamicRegisterInfo(), lldb_private::minidump::ProcessMinidump::BuildMemoryRegions(), lldb_private::TraceSessionSaver::BuildModulesSection(), lldb_private::TraceSessionSaver::BuildProcessesSection(), CalculateExecutionContext(), lldb_private::AppleObjCRuntime::CalculateHasNewLiteralsAndIndexing(), CallVoidArgVoidPtrReturn(), DynamicLoaderMacOS::CanLoadImage(), DynamicLoaderDarwinKernel::CheckForKernelImageAtAddress(), lldb_private::ThreadPlanStepThrough::ClearBackstopBreakpoint(), DynamicLoaderMacOS::ClearNotificationBreakpoint(), DynamicLoaderMacOSXDYLD::ClearNotificationBreakpoint(), CompleteAttach(), DynamicLoaderPOSIXDYLD::ComputeLoadOffset(), lldb_private::process_gdb_remote::ProcessGDBRemote::ConnectToDebugserver(), CreateBreakpointSite(), lldb_private::AppleObjCRuntime::CreateExceptionSearchFilter(), lldb_private::LanguageRuntime::CreateExceptionSearchFilter(), lldb_private::wasm::DynamicLoaderWasmDYLD::CreateInstance(), lldb_private::DynamicLoaderWindowsDYLD::CreateInstance(), JITLoaderGDB::CreateInstance(), DynamicLoaderHexagonDYLD::CreateInstance(), DynamicLoaderPOSIXDYLD::CreateInstance(), DynamicLoaderDarwinKernel::CreateInstance(), DynamicLoaderMacOS::CreateInstance(), lldb_private::StructuredDataDarwinLog::CreateInstance(), lldb_private::trace_intel_pt::TraceIntelPT::CreateInstanceForLiveProcess(), DynamicLoaderHexagonDYLD::DidAttach(), JITLoaderGDB::DidAttach(), DynamicLoaderPOSIXDYLD::DidAttach(), DidExec(), lldb_private::process_gdb_remote::ProcessGDBRemote::DidForkSwitchHardwareTraps(), JITLoaderGDB::DidLaunch(), DynamicLoaderPOSIXDYLD::DidLaunch(), lldb_private::process_gdb_remote::ProcessGDBRemote::DidLaunchOrAttach(), DynamicLoaderMacOS::DoClear(), DynamicLoaderMacOSXDYLD::DoClear(), ProcessKDP::DoConnectRemote(), lldb_private::process_gdb_remote::ProcessGDBRemote::DoConnectRemote(), lldb_private::process_gdb_remote::ProcessGDBRemote::DoDestroy(), DoesProcessHaveSharedCache(), CommandObjectProcessLoad::DoExecute(), CommandObjectProcessUnload::DoExecute(), CommandObjectMemoryFind::DoExecute(), CommandObjectMemoryWrite::DoExecute(), CommandObjectProcessStatus::DoExecute(), DynamicLoaderMacOSXDYLD::DoInitialImageFetch(), lldb_private::process_gdb_remote::ProcessGDBRemote::DoLaunch(), ProcessMachCore::DoLoadCore(), lldb_private::minidump::ProcessMinidump::DoLoadCore(), ProcessElfCore::DoLoadCore(), lldb_private::ScriptedProcess::DoLoadCore(), PlatformPOSIX::DoLoadImage(), lldb_private::ProcessTrace::DoReadMemory(), lldb_private::process_gdb_remote::ProcessGDBRemote::DoResume(), lldb_private::ThreadPlanStepOverRange::DoWillResume(), DynamicLoaderDarwinKernel::DynamicLoaderDarwinKernel(), DynamicLoaderPOSIXDYLD::EntryBreakpointHit(), lldb_private::process_gdb_remote::ProcessGDBRemote::EstablishConnectionIfNeeded(), lldb_private::ExecutionContext::ExecutionContext(), PlatformDarwin::ExtractCrashInfoAnnotations(), ExtractRuntimeGlobalSymbol(), lldb_private::CPPLanguageRuntime::FindLibCppStdFunctionCallableInfo(), HexagonDYLDRendezvous::FindMetadata(), DYLDRendezvous::FindMetadata(), lldb_private::DynamicLoaderDarwin::FindTargetModuleForImageInfo(), lldb_private::FormatEntity::Format(), GetABI(), GetAddressByteSize(), lldb_private::ProcessTrace::GetArchitecture(), lldb_private::ScriptedProcess::GetArchitecture(), ProcessElfCore::GetArchitecture(), lldb_private::AppleObjCRuntimeV2::GetByteOffsetForIvar(), GetByteOrder(), lldb_private::AppleObjCRuntimeV2::GetCFBooleanValuesIfNeeded(), lldb_private::ThreadPlanAssemblyTracer::GetDisassembler(), DynamicLoaderMacOS::GetDyldLockVariableAddressFromModule(), lldb_private::ItaniumABILanguageRuntime::GetDynamicTypeAndAddress(), DynamicLoaderHexagonDYLD::GetEntryPoint(), DynamicLoaderPOSIXDYLD::GetEntryPoint(), lldb_private::AppleObjCRuntime::GetFoundationVersion(), lldb_private::RegisterContextUnwind::GetFullUnwindPlanForFrame(), lldb_private::process_gdb_remote::ProcessGDBRemote::GetGDBServerRegisterInfoXMLAndProcess(), lldb_private::ProcessWindows::GetImageInfoAddress(), ProcessElfCore::GetImageInfoAddress(), lldb_private::AppleObjCRuntimeV1::GetISAHashTablePointer(), lldb_private::AppleObjCRuntimeV2::GetISAHashTablePointer(), lldb_private::platform_android::PlatformAndroid::GetLibdlFunctionDeclarations(), GetLoadImageUtilityFunction(), GetMemoryTagManager(), lldb_private::AppleObjCRuntime::GetObjCModule(), lldb_private::AppleObjCRuntime::GetObjCVersion(), lldb_private::minidump::ProcessMinidump::GetOrCreateModule(), lldb_private::minidump::ProcessMinidump::GetPluginCommandObject(), ProcessKDP::GetPluginCommandObject(), lldb_private::process_gdb_remote::ProcessGDBRemote::GetPluginCommandObject(), lldb_private::AppleObjCRuntime::GetPrintForDebuggerAddr(), lldb_private::ProcessTrace::GetProcessInfo(), lldb_private::minidump::ProcessMinidump::GetProcessInfo(), lldb_private::ScriptedProcess::GetProcessInfo(), ProcessElfCore::GetProcessInfo(), GetProcessInfo(), lldb_private::DynamicLoaderDarwin::GetPThreadLibraryModule(), lldb_private::ThreadPlanPython::GetScriptInterpreter(), lldb_private::AppleObjCRuntimeV2::GetSharedCacheReadOnlyAddress(), GetSoftwareBreakpointTrapOpcode(), JITLoaderGDB::GetSymbolAddress(), lldb_private::AppleObjCRuntimeV2::GetTaggedPointerObfuscator(), lldb_private::ThreadPlan::GetTarget(), DynamicLoaderHexagonDYLD::GetTargetExecutable(), lldb_private::DynamicLoader::GetTargetExecutable(), lldb_private::Runtime::GetTargetRef(), lldb_private::DynamicLoaderDarwin::GetThreadLocalData(), lldb_private::Value::GetValueAsData(), lldb_private::process_gdb_remote::ProcessGDBRemote::GetWatchpointSupportInfo(), lldb_private::StructuredDataDarwinLog::HandleArrivalOfStructuredData(), HandlePrivateEvent(), HexagonDYLDRendezvous::HexagonDYLDRendezvous(), lldb_private::InferiorCallMmap(), lldb_private::InferiorCallMunmap(), DynamicLoaderMacOSXDYLD::InitializeFromAllImageInfos(), lldb_private::RegisterContextUnwind::InitializeNonZerothFrame(), lldb_private::RegisterContextUnwind::InitializeZerothFrame(), lldb_private::RegisterContextUnwind::IsTrapHandlerSymbol(), Launch(), lldb_private::process_gdb_remote::ProcessGDBRemote::LaunchAndConnectToDebugserver(), DynamicLoaderHexagonDYLD::LoadAllCurrentModules(), DynamicLoaderPOSIXDYLD::LoadAllCurrentModules(), DynamicLoaderStatic::LoadAllImagesAtFileAddresses(), ObjectFileMachO::LoadCoreFileImages(), DynamicLoaderDarwinKernel::KextImageInfo::LoadImageAtFileAddress(), DynamicLoaderDarwinKernel::KextImageInfo::LoadImageUsingMemoryModule(), DynamicLoaderPOSIXDYLD::LoadInterpreterModule(), DynamicLoaderDarwinKernel::LoadKernelModuleIfNeeded(), lldb_private::DynamicLoader::LoadModuleAtAddress(), lldb_private::process_gdb_remote::ProcessGDBRemote::LoadModules(), DynamicLoaderPOSIXDYLD::LoadVDSO(), lldb_private::ThreadPlanAssemblyTracer::Log(), lldb_private::ObjCLanguageRuntime::LookupInCompleteClassCache(), PlatformPOSIX::MakeLoadImageUtilityFunction(), lldb_private::process_gdb_remote::ProcessGDBRemote::MaybeLoadExecutableModule(), DynamicLoaderMacOS::NotifyBreakpointHit(), DynamicLoaderMacOSXDYLD::NotifyBreakpointHit(), lldb_private::ProcessWindows::OnDebuggerConnected(), DynamicLoaderDarwinKernel::ParseKextSummaries(), lldb_private::process_gdb_remote::ProcessGDBRemote::ParsePythonTargetDefinition(), lldb_private::StopInfoBreakpoint::PerformAction(), PopProcessIOHandler(), SystemRuntimeMacOSX::PopulatePendingItemsForQueue(), PrintWarning(), lldb_private::DynamicLoaderDarwin::PrivateInitialize(), DynamicLoaderPOSIXDYLD::ProbeEntry(), ProcessIOHandlerIsActive(), lldb_private::RegisterContextUnwind::PropagateTrapHandlerFlagFromUnwindPlan(), PushProcessIOHandler(), DynamicLoaderMacOSXDYLD::ReadAllImageInfosStructure(), DynamicLoaderMacOSXDYLD::ReadDYLDInfoFromMemoryAndSetNotificationCallback(), JITLoaderGDB::ReadJITDescriptor(), JITLoaderGDB::ReadJITDescriptorImpl(), DynamicLoaderDarwinKernel::ReadKextSummaries(), DynamicLoaderDarwinKernel::ReadKextSummaryHeader(), SystemRuntimeMacOSX::ReadLibdispatchOffsetsAddress(), SystemRuntimeMacOSX::ReadLibdispatchTSDIndexes(), SystemRuntimeMacOSX::ReadLibdispatchTSDIndexesAddress(), SystemRuntimeMacOSX::ReadLibpthreadOffsetsAddress(), DynamicLoaderDarwinKernel::KextImageInfo::ReadMemoryModule(), lldb_private::minidump::ProcessMinidump::ReadModuleList(), DYLDRendezvous::ReadSOEntryFromMemory(), DynamicLoaderHexagonDYLD::RefreshModules(), DynamicLoaderPOSIXDYLD::RefreshModules(), lldb_private::ProcessWindows::RefreshStateAfterStop(), lldb_private::AppleObjCTrampolineHandler::AppleObjCVTables::RefreshTrampolines(), lldb_private::RegisterAssertFrameRecognizer(), RegisterObjCExceptionRecognizer(), DynamicLoaderMacOSXDYLD::RemoveModulesUsingImageInfosAddress(), lldb_private::RenderScriptRuntime::RenderScriptRuntime(), DynamicLoaderPOSIXDYLD::ResolveExecutableModule(), ResolveIndirectFunction(), DYLDRendezvous::ResolveRendezvousAddress(), lldb::SBThread::ResumeNewPlan(), lldb_private::process_gdb_remote::ProcessGDBRemote::SaveCore(), DynamicLoaderDarwinKernel::SearchForKernelAtSameLoadAddr(), DynamicLoaderDarwinKernel::SearchForKernelNearPC(), DynamicLoaderDarwinKernel::SearchForKernelViaExhaustiveSearch(), lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::ServeSymbolLookups(), lldb_private::AppleObjCRuntime::SetExceptionBreakpoints(), JITLoaderGDB::SetJITBreakpoint(), lldb_private::process_gdb_remote::ProcessGDBRemote::SetLastStopPacket(), lldb_private::ThreadPlanStepRange::SetNextBranchBreakpoint(), DynamicLoaderMacOS::SetNotificationBreakpoint(), DynamicLoaderMacOSXDYLD::SetNotificationBreakpoint(), DynamicLoaderDarwinKernel::SetNotificationBreakpointIfNeeded(), DynamicLoaderHexagonDYLD::SetRendezvousBreakpoint(), DynamicLoaderPOSIXDYLD::SetRendezvousBreakpoint(), lldb_private::process_gdb_remote::ProcessGDBRemote::SetThreadStopInfo(), DYLDRendezvous::SOEntryIsMainExecutable(), lldb_private::process_gdb_remote::ProcessGDBRemote::StartNoticingNewThreads(), lldb_private::ThreadPlanStepOut::ThreadPlanStepOut(), lldb_private::ThreadPlanStepThrough::ThreadPlanStepThrough(), lldb_private::DynamicLoaderDarwin::UnloadAllImages(), lldb_private::DynamicLoaderDarwin::UnloadImages(), lldb_private::DynamicLoaderDarwin::UnloadModuleSections(), DynamicLoaderHexagonDYLD::UnloadSections(), lldb_private::DynamicLoader::UnloadSectionsCommon(), DYLDRendezvous::UpdateBaseAddrIfNecessary(), lldb_private::DynamicLoaderDarwin::UpdateDYLDImageInfoFromNewImageInfo(), DYLDRendezvous::UpdateExecutablePath(), DynamicLoaderMacOSXDYLD::UpdateImageInfosHeaderAndLoadCommands(), lldb_private::DynamicLoaderDarwin::UpdateImageLoadAddress(), lldb_private::AppleObjCRuntimeV2::DynamicClassInfoExtractor::UpdateISAToDescriptorMap(), lldb_private::AppleObjCRuntimeV2::SharedCacheClassInfoExtractor::UpdateISAToDescriptorMap(), DynamicLoaderHexagonDYLD::UpdateLoadedSections(), lldb_private::DynamicLoader::UpdateLoadedSectionsCommon(), lldb_private::DynamicLoaderDarwin::UpdateSpecialBinariesFromNewImageInfos(), UpdateThreadListIfNeeded(), lldb_private::DynamicLoaderDarwin::UseDYLDSPI(), lldb_private::FunctionCaller::WriteFunctionWrapper(), lldb_private::process_gdb_remote::GDBRemoteRegisterContext::WriteRegisterBytes(), DynamicLoaderHexagonDYLD::~DynamicLoaderHexagonDYLD(), DynamicLoaderMacOS::~DynamicLoaderMacOS(), DynamicLoaderMacOSXDYLD::~DynamicLoaderMacOSXDYLD(), DynamicLoaderPOSIXDYLD::~DynamicLoaderPOSIXDYLD(), and JITLoaderGDB::~JITLoaderGDB().

◆ GetTarget() [2/2]

const Target& lldb_private::Process::GetTarget ( ) const
inline

Get the const target object pointer for this module.

Returns
A const Target object pointer to the target that owns this module.

Definition at line 1221 of file Process.h.

References m_target_wp.

◆ GetThreadList()

ThreadList& lldb_private::Process::GetThreadList ( )
inline

Definition at line 2116 of file Process.h.

References m_thread_list.

Referenced by lldb_private::CommandObjectIterateOverThreads::BucketThread(), CallVoidArgVoidPtrReturn(), SystemRuntimeMacOSX::CompleteQueueItem(), ProcessKDP::DoConnectRemote(), lldb_private::process_gdb_remote::ProcessGDBRemote::DoConnectRemote(), lldb_private::process_gdb_remote::ProcessGDBRemote::DoDestroy(), lldb_private::ctf::CommandObjectThreadTraceExportCTF::DoExecute(), lldb_private::CommandObjectIterateOverThreads::DoExecute(), lldb_private::CommandObjectMultipleThreads::DoExecute(), CommandObjectThreadStepWithTypeAndScope::DoExecute(), CommandObjectProcessContinue::DoExecute(), CommandObjectThreadContinue::DoExecute(), CommandObjectThreadUntil::DoExecute(), CommandObjectThreadSelect::DoExecute(), CommandObjectThreadPlanPrune::DoExecute(), CommandObjectTargetModulesShowUnwind::DoExecute(), lldb_private::ScriptedProcess::DoLaunch(), PlatformPOSIX::DoLoadImage(), lldb_private::trace_intel_pt::TraceIntelPT::DoRefreshLiveProcessState(), lldb_private::process_gdb_remote::ProcessGDBRemote::DoResume(), PlatformPOSIX::EvaluateLibdlExpression(), lldb_private::CommandObject::GetDefaultThread(), SystemRuntimeMacOSX::GetExtendedBacktraceFromItemRef(), SystemRuntimeMacOSX::GetExtendedBacktraceThread(), lldb_private::AppleObjCRuntime::GetObjectDescription(), SystemRuntimeMacOSX::GetPendingItemRefsForQueue(), lldb_private::Thread::GetStatus(), lldb_private::ThreadPlanTracer::GetThread(), lldb_private::ThreadPlan::GetThread(), GetThreadStatus(), lldb_private::InferiorCallMmap(), lldb_private::InferiorCallMunmap(), lldb_private::Process::AttachCompletionHandler::PerformAction(), SystemRuntimeMacOSX::PopulateQueueList(), DynamicLoaderMacOS::ProcessDidExec(), DynamicLoaderMacOSXDYLD::ProcessDidExec(), PruneThreadPlans(), lldb::SBThread::ResumeNewPlan(), RunThreadPlan(), DynamicLoaderDarwinKernel::SearchForKernelNearPC(), lldb_private::Thread::StepIn(), lldb_private::Thread::StepOut(), lldb_private::Thread::StepOver(), lldb_private::CommandCompletions::ThreadIndexes(), lldb_private::AppleObjCRuntimeV2::DynamicClassInfoExtractor::UpdateISAToDescriptorMap(), and lldb_private::AppleObjCRuntimeV2::SharedCacheClassInfoExtractor::UpdateISAToDescriptorMap().

◆ GetThreadStatus()

size_t Process::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 
)

◆ GetUniqueID()

uint32_t lldb_private::Process::GetUniqueID ( ) const
inline

◆ GetUnixSignals()

const lldb::UnixSignalsSP & Process::GetUnixSignals ( )

◆ GetWatchpointSupportInfo() [1/2]

virtual Status lldb_private::Process::GetWatchpointSupportInfo ( uint32_t num)
inlinevirtual

Reimplemented in lldb_private::process_gdb_remote::ProcessGDBRemote, and lldb_private::ProcessWindows.

Definition at line 1839 of file Process.h.

References error().

◆ GetWatchpointSupportInfo() [2/2]

virtual Status lldb_private::Process::GetWatchpointSupportInfo ( uint32_t num,
bool &  after 
)
inlinevirtual

Reimplemented in lldb_private::process_gdb_remote::ProcessGDBRemote, and lldb_private::ProcessWindows.

Definition at line 1846 of file Process.h.

References error().

◆ Halt()

Status Process::Halt ( bool  clear_thread_plans = false,
bool  use_run_lock = true 
)

Halts a running process.

This function is not meant to be overridden by Process subclasses. If the process is successfully halted, a eStateStopped process event with GetInterrupted will be broadcast. If false, we will halt the process with no events generated by the halt.

Parameters
[in]clear_thread_plansIf true, when the process stops, clear all thread plans.
[in]use_run_lockWhether to release the run lock after the stop.
Returns
Returns an error object. If the error is empty, the process is halted. otherwise the halt has failed.

Definition at line 3092 of file Process.cpp.

References lldb_private::Broadcaster::BroadcastEvent(), Destroy(), lldb::eStateAttaching, lldb::eStateInvalid, lldb_private::ProcessProperties::GetInterruptTimeout(), GetState(), lldb_private::ThreadSafeValue< T >::GetValue(), HijackProcessEvents(), m_clear_thread_plans_on_stop, m_public_state, lldb_private::Listener::MakeListener(), RestoreProcessEvents(), SendAsyncInterrupt(), SetExitStatus(), SIGKILL, lldb_private::StateAsCString(), lldb_private::StateIsRunningState(), and WaitForProcessToStop().

Referenced by CommandObjectProcessInterrupt::DoExecute(), and RunThreadPlan().

◆ HaltPrivate()

Status Process::HaltPrivate ( )
protected

Definition at line 3738 of file Process.cpp.

References DidHalt(), DoHalt(), error(), and WillHalt().

Referenced by RunPrivateStateThread().

◆ HandlePrivateEvent()

void Process::HandlePrivateEvent ( lldb::EventSP &  event_sp)
protected

◆ HandleProcessStateChangedEvent()

bool Process::HandleProcessStateChangedEvent ( const lldb::EventSP &  event_sp,
Stream stream,
bool &  pop_process_io_handler 
)
static

Centralize the code that handles and prints descriptions for process state changes.

Parameters
[in]event_spThe process state changed event
[in]streamThe output stream to get the state change description
[in,out]pop_process_io_handlerIf this value comes in set to true, then pop the Process IOHandler if needed. Else this variable will be set to true or false to indicate if the process needs to have its process IOHandler popped.
Returns
true if the event describes a process state changed event, false otherwise.

Definition at line 714 of file Process.cpp.

References lldb::eDescriptionLevelBrief, lldb::eStateAttaching, lldb::eStateConnected, lldb::eStateCrashed, lldb::eStateDetached, lldb::eStateExited, lldb::eStateInvalid, lldb::eStateLaunching, lldb::eStateRunning, lldb::eStateStepping, lldb::eStateStopped, lldb::eStateSuspended, lldb::eStateUnloaded, lldb::eStopReasonBreakpoint, lldb::eStopReasonException, lldb::eStopReasonExec, lldb::eStopReasonFork, lldb::eStopReasonInstrumentation, lldb::eStopReasonInvalid, lldb::eStopReasonNone, lldb::eStopReasonPlanComplete, lldb::eStopReasonProcessorTrace, lldb::eStopReasonSignal, lldb::eStopReasonThreadExiting, lldb::eStopReasonTrace, lldb::eStopReasonVFork, lldb::eStopReasonVForkDone, lldb::eStopReasonWatchpoint, lldb_private::StopInfo::GetCrashingDereference(), lldb_private::TargetList::GetIndexOfTarget(), lldb_private::ThreadList::GetMutex(), lldb_private::Process::ProcessEventData::GetNumRestartedReasons(), lldb_private::Process::ProcessEventData::GetProcessFromEvent(), lldb_private::Process::ProcessEventData::GetRestartedFromEvent(), lldb_private::Process::ProcessEventData::GetRestartedReasonAtIndex(), lldb_private::TargetList::GetSelectedTarget(), lldb_private::ThreadList::GetSelectedThread(), lldb_private::ThreadList::GetSize(), lldb_private::Process::ProcessEventData::GetStateFromEvent(), lldb_private::Debugger::GetTargetList(), lldb_private::ThreadList::GetThreadAtIndex(), lldb_private::Stream::Printf(), lldb_private::Stream::PutCString(), lldb_private::ThreadList::SetSelectedThreadByID(), lldb_private::StateAsCString(), and UINT32_MAX.

Referenced by lldb_private::Platform::DoConnectProcess(), lldb_private::Debugger::HandleProcessEvent(), and WaitForProcessToStop().

◆ HasAssignedIndexIDToThread()

bool Process::HasAssignedIndexIDToThread ( uint64_t  sb_thread_id)

◆ HijackProcessEvents()

bool Process::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 listener, set to listen to process events, and then call this with that listener.

Then you will have to wait on that listener explicitly for events (rather than using the GetNextEvent & WaitFor* calls above. Be sure to call RestoreProcessEvents when you are done.

Parameters
[in]listener_spThis is the new listener to whom all process events will be delivered.
Returns
Returns true if the new listener could be installed, false otherwise.

Definition at line 945 of file Process.cpp.

References eBroadcastBitInterrupt, eBroadcastBitStateChanged, and lldb_private::Broadcaster::HijackBroadcaster().

Referenced by lldb_private::ProcessTrace::DidAttach(), Halt(), Launch(), LoadCore(), lldb_private::Process::ProcessEventHijacker::ProcessEventHijacker(), ResumeSynchronous(), and StopForDestroyOrDetach().

◆ IsAlive()

bool Process::IsAlive ( )
virtual

◆ IsLiveDebugSession()

virtual bool lldb_private::Process::IsLiveDebugSession ( ) const
inlinevirtual

Reimplemented in lldb_private::PostMortemProcess.

Definition at line 1411 of file Process.h.

Referenced by lldb_private::Trace::FindPluginForLiveProcess(), and TraceSupported().

◆ IsPossibleDynamicValue()

bool Process::IsPossibleDynamicValue ( ValueObject in_value)

◆ IsRunning()

bool Process::IsRunning ( ) const

◆ IsValid()

bool lldb_private::Process::IsValid ( ) const
inline

Return whether this object is valid (i.e.

has not been finalized.)

Returns
Returns true if this Process has not been finalized and false otherwise.

Definition at line 574 of file Process.h.

References m_finalizing.

Referenced by lldb_private::process_gdb_remote::ProcessGDBRemote::DoConnectRemote(), and ProcessMachCore::DoLoadCore().

◆ Launch()

Status Process::Launch ( ProcessLaunchInfo launch_info)
virtual

Launch a new process.

Launch a new process by spawning a new process using the target object's executable module's file as the file to launch.

This function is not meant to be overridden by Process subclasses. It will first call Process::WillLaunch (Module *) and if that returns true, Process::DoLaunch (Module*, char const *[],char const *[],const char *,const char *, const char *) will be called to actually do the launching. If DoLaunch returns true, then Process::DidLaunch() will be called.

Parameters
[in]launch_infoDetails regarding the environment, STDIN/STDOUT/STDERR redirection, working path, etc. related to the requested launch.
Returns
An error object. Call GetID() to get the process ID if the error object is success.

Definition at line 2475 of file Process.cpp.

References Destroy(), lldb_private::JITLoaderList::DidLaunch(), lldb_private::SystemRuntime::DidLaunch(), lldb_private::DynamicLoader::DidLaunch(), DidLaunch(), DoLaunch(), error(), lldb::eStateCrashed, lldb::eStateExited, lldb::eStateInvalid, lldb::eStateLaunching, lldb::eStateStopped, GetDynamicLoader(), lldb_private::Target::GetExecutableModulePointer(), lldb_private::Module::GetFileSpec(), lldb_private::ProcessLaunchInfo::GetFlags(), GetID(), GetJITLoaders(), lldb_private::FileSpec::GetPath(), lldb_private::Module::GetPlatformFileSpec(), GetSystemRuntime(), GetTarget(), HandlePrivateEvent(), HijackProcessEvents(), lldb_private::Target::Install(), lldb_private::FileSystem::Instance(), LLDB_INVALID_PROCESS_ID, LoadOperatingSystemPlugin(), m_abi_sp, m_dyld_up, m_jit_loaders_up, m_os_up, m_process_input_reader, m_public_run_lock, m_should_detach, m_system_runtime_up, lldb_private::Listener::MakeListener(), PATH_MAX, PausePrivateStateThread(), PrivateStateThreadIsValid(), RestoreProcessEvents(), ResumePrivateStateThread(), SetExitStatus(), SetID(), SetPublicState(), StartPrivateStateThread(), lldb_private::Flags::Test(), lldb_private::ProcessRunLock::TrySetRunning(), UpdateAutomaticSignalFiltering(), WaitForProcessStopPrivate(), and WillLaunch().

◆ LoadCore()

Status Process::LoadCore ( )
virtual

◆ LoadModules()

virtual llvm::Error lldb_private::Process::LoadModules ( )
inlinevirtual

Sometimes processes know how to retrieve and load shared libraries.

This is normally done by DynamicLoader plug-ins, but sometimes the connection to the process allows retrieving this information. The dynamic loader plug-ins can use this function if they can't determine the current shared library load state.

Returns
A status object indicating if the operation was sucessful or not.

Reimplemented in lldb_private::process_gdb_remote::ProcessGDBRemote.

Definition at line 677 of file Process.h.

Referenced by DynamicLoaderPOSIXDYLD::DidAttach().

◆ LoadOperatingSystemPlugin()

void Process::LoadOperatingSystemPlugin ( bool  flush)
protected

◆ MapSupportedStructuredDataPlugins()

void Process::MapSupportedStructuredDataPlugins ( const StructuredData::Array supported_type_names)
protected

Loads any plugins associated with asynchronous structured data and maps the relevant supported type name to the plugin.

Processes can receive asynchronous structured data from the process monitor. This method will load and map any structured data plugins that support the given set of supported type names. Later, if any of these features are enabled, the process monitor is free to generate asynchronous structured data. The data must come in as a single StructuredData::Dictionary. That dictionary must have a string field named 'type', with a value that equals the relevant type name string (one of the values in supported_type_names).

Parameters
[in]supported_type_namesAn array of zero or more type names. Each must be unique. For each entry in the list, a StructuredDataPlugin will be searched for that supports the structured data type name.

Definition at line 5925 of file Process.cpp.

References lldb_private::StructuredData::Array::ForEach(), lldb_private::GetLogIfAnyCategoriesSet(), lldb_private::StructuredData::Array::GetSize(), lldb_private::PluginManager::GetStructuredDataPluginCreateCallbackAtIndex(), LIBLLDB_LOG_PROCESS, LLDB_LOG, LLDB_LOGF, and m_structured_data_plugin_map.

Referenced by lldb_private::process_gdb_remote::ProcessGDBRemote::DidLaunchOrAttach().

◆ ModulesDidLoad()

void Process::ModulesDidLoad ( ModuleList module_list)
virtual

◆ operator=()

const Process& lldb_private::Process::operator= ( const Process )
privatedelete

◆ PausePrivateStateThread()

void Process::PausePrivateStateThread ( )
protected

Definition at line 3550 of file Process.cpp.

References ControlPrivateStateThread(), and eBroadcastInternalStateControlPause.

Referenced by Launch().

◆ PeekAtStateChangedEvents()

Event * Process::PeekAtStateChangedEvents ( )

◆ PopProcessIOHandler()

bool Process::PopProcessIOHandler ( )
protected

◆ PrefetchModuleSpecs()

virtual void lldb_private::Process::PrefetchModuleSpecs ( llvm::ArrayRef< FileSpec module_file_specs,
const llvm::Triple &  triple 
)
inlinevirtual

◆ PrintWarning()

void Process::PrintWarning ( uint64_t  warning_type,
const void *  repeat_key,
const char *  fmt,
  ... 
)
protected

Print a user-visible warning one time per Process.

A facility for printing a warning to the user once per repeat_key.

warning_type is from the Process::Warnings enums. repeat_key is a pointer value that will be used to ensure that the warning message is not printed multiple times. For instance, with a warning about a function being optimized, you can pass the CompileUnit pointer to have the warning issued for only the first function in a CU, or the Function pointer to have it issued once for every function, or a Module pointer to have it issued once per Module.

Classes outside Process should call a specific PrintWarning method so that the warning strings are all centralized in Process, instead of calling PrintWarning() directly.

Parameters
[in]warning_typeOne of the types defined in Process::Warnings.
[in]repeat_keyA pointer value used to ensure that the warning is only printed once. May be nullptr, indicating that the warning is printed unconditionally every time.
[in]fmtprintf style format string

Definition at line 5720 of file Process.cpp.

References lldb_private::Debugger::GetAsyncOutputStream(), lldb_private::Target::GetDebugger(), GetTarget(), and m_warnings_issued.

Referenced by PrintWarningOptimization(), and PrintWarningUnsupportedLanguage().

◆ PrintWarningOptimization()

void Process::PrintWarningOptimization ( const SymbolContext sc)

Print a user-visible warning about a module being built with optimization.

Prints a async warning message to the user one time per Module where a function is found that was compiled with optimization, per Process.

Parameters
[in]scA SymbolContext with eSymbolContextFunction and eSymbolContextModule pre-computed.

Definition at line 5750 of file Process.cpp.

References lldb_private::SymbolContext::function, lldb_private::Function::GetIsOptimized(), lldb_private::ProcessProperties::GetWarningsOptimization(), lldb_private::SymbolContext::module_sp, and PrintWarning().

◆ PrintWarningUnsupportedLanguage()

void Process::PrintWarningUnsupportedLanguage ( const SymbolContext sc)

◆ PrivateResume()

Status Process::PrivateResume ( )
protected

◆ PrivateStateThread()

thread_result_t Process::PrivateStateThread ( void *  arg)
staticprivate

Definition at line 3752 of file Process.cpp.

Referenced by StartPrivateStateThread().

◆ PrivateStateThreadIsValid()

bool lldb_private::Process::PrivateStateThreadIsValid ( ) const
inlineprotected

◆ ProcessIOHandlerExists()

bool lldb_private::Process::ProcessIOHandlerExists ( ) const
inlineprotected

Definition at line 3066 of file Process.h.

References m_process_input_reader.

◆ ProcessIOHandlerIsActive()

bool Process::ProcessIOHandlerIsActive ( )
protected

◆ PruneThreadPlans()

void Process::PruneThreadPlans ( )

Prune ThreadPlanStacks for all unreported threads.

Definition at line 1234 of file Process.cpp.

References GetThreadList(), m_thread_plans, and lldb_private::ThreadPlanStackMap::Update().

Referenced by CommandObjectThreadPlanPrune::DoExecute().

◆ PruneThreadPlansForTID()

bool Process::PruneThreadPlansForTID ( lldb::tid_t  tid)

Prune ThreadPlanStacks for unreported threads.

Parameters
[in]tidThe tid whose Plan Stack we are seeking to prune.
Returns
true if the TID is found or false if not.

Definition at line 1230 of file Process.cpp.

References m_thread_plans, and lldb_private::ThreadPlanStackMap::PrunePlansForTID().

Referenced by CommandObjectThreadPlanPrune::DoExecute().

◆ PushProcessIOHandler()

bool Process::PushProcessIOHandler ( )
protected

◆ PutSTDIN()

virtual size_t lldb_private::Process::PutSTDIN ( const char *  buf,
size_t  buf_size,
Status error 
)
inlinevirtual

Puts data into this process's STDIN.

Calling this method is a valid operation only if all of the following conditions are true: 1) The process was launched, and not attached to. 2) The process was not launched with eLaunchFlagDisableSTDIO. 3) The process was launched without supplying a valid file path for STDIN.

Parameters
[in]bufA buffer that contains the data to write to the process's STDIN.
[in]buf_sizeThe size in bytes for the buffer buf.
Returns
The number of bytes written into buf. If this value is less than buf_size, another call to this function should be made to write the rest of the data.

Reimplemented in lldb_private::process_gdb_remote::ProcessGDBRemote, and lldb_private::ProcessWindows.

Definition at line 2024 of file Process.h.

References error().

◆ Queues()

QueueList::QueueIterable lldb_private::Process::Queues ( )
inline

◆ ReadCStringFromMemory() [1/2]

size_t Process::ReadCStringFromMemory ( lldb::addr_t  vm_addr,
char *  cstr,
size_t  cstr_max_len,
Status error 
)

Read a NULL terminated C string from memory.

This function will read a cache page at a time until the NULL C string terminator is found. It will stop reading if the NULL termination byte isn't found before reading cstr_max_len bytes, and the results are always guaranteed to be NULL terminated (at most cstr_max_len - 1 bytes will be read).

Definition at line 2028 of file Process.cpp.

References lldb_private::Status::Clear(), error(), lldb_private::MemoryCache::GetMemoryCacheLineSize(), m_memory_cache, ReadMemory(), and lldb_private::Status::SetErrorString().

Referenced by lldb_private::RenderScriptRuntime::CaptureScriptInit(), PlatformPOSIX::DoLoadImage(), PlatformDarwin::ExtractCrashInfoAnnotations(), lldb_private::AppleObjCRuntime::GetObjectDescription(), SystemRuntimeMacOSX::GetQueueNameFromThreadQAddress(), lldb_private::ClassDescriptorV2::class_ro_t::Read(), lldb_private::ClassDescriptorV2::method_t::Read(), lldb_private::ClassDescriptorV2::ivar_t::Read(), ReadCStringFromMemory(), DynamicLoaderMacOSXDYLD::ReadImageInfos(), and DYLDRendezvous::ReadStringFromMemory().

◆ ReadCStringFromMemory() [2/2]

size_t Process::ReadCStringFromMemory ( lldb::addr_t  vm_addr,
std::string out_str,
Status error 
)

Definition at line 1955 of file Process.cpp.

References error(), and ReadCStringFromMemory().

◆ ReadMemory()

size_t Process::ReadMemory ( lldb::addr_t  vm_addr,
void *  buf,
size_t  size,
Status error 
)
virtual

Read of memory from a process.

This function will read memory from the current process's address space and remove any traps that may have been inserted into the memory.

This function is not meant to be overridden by Process subclasses, the subclasses should implement Process::DoReadMemory (lldb::addr_t, size_t, void *).

Parameters
[in]vm_addrA virtual load address that indicates where to start reading memory from.
[out]bufA byte buffer that is at least size bytes long that will receive the memory bytes.
[in]sizeThe number of bytes to read.
[out]errorAn error that indicates the success or failure of this operation. If error indicates success (error.Success()), then the value returned can be trusted, otherwise zero will be returned.
Returns
The number of bytes that were actually read into buf. If the returned number is greater than zero, yet less than size, then this function will get called again with vm_addr, buf, and size updated appropriately. Zero is returned in the case of an error.

Reimplemented in lldb_private::minidump::ProcessMinidump, lldb_private::ProcessTrace, ProcessElfCore, and ProcessMachCore.

Definition at line 1914 of file Process.cpp.

References error(), lldb_private::ProcessProperties::GetDisableMemoryCache(), m_memory_cache, lldb_private::MemoryCache::Read(), ReadMemoryFromInferior(), string(), and lldb_private::Status::Success().

Referenced by lldb_private::formatters::Foundation1437::__NSArrayMSize_Impl(), lldb_private::formatters::Foundation1437::__NSDictionaryMSize_Impl(), lldb_private::formatters::Foundation1437::__NSSetMSize_Impl(), SystemRuntimeMacOSX::CompleteQueueItem(), lldb_private::IRExecutionUnit::DisassembleFunction(), CommandObjectMemoryFind::DoExecute(), DynamicLoaderMacOSXDYLD::DoInitialImageFetch(), lldb_private::TypeSystemClang::DumpSummary(), lldb_private::DWARFExpression::Evaluate(), lldb_private::AppleObjCRuntimeV2::NonPointerISACache::EvaluateNonPointerISA(), SystemRuntimeMacOSX::GetExtendedBacktraceFromItemRef(), SystemRuntimeMacOSX::GetExtendedBacktraceThread(), SystemRuntimeMacOSX::GetPendingItemRefsForQueue(), lldb_private::ValueObject::GetPointeeData(), SystemRuntimeMacOSX::GetQueueNameFromThreadQAddress(), DynamicLoaderMacOSXDYLD::GetSharedCacheInformation(), lldb_private::Value::GetValueAsData(), LoadValueFromConsecutiveGPRRegisters(), lldb_private::ThreadPlanAssemblyTracer::Log(), SystemRuntimeMacOSX::PopulateQueuesUsingLibBTR(), lldb_private::ClassDescriptorV2::objc_class_t::Read(), lldb_private::ClassDescriptorV2::class_ro_t::Read(), lldb_private::ClassDescriptorV2::class_rw_t::Read(), lldb_private::ClassDescriptorV2::method_list_t::Read(), lldb_private::ClassDescriptorV2::method_t::Read(), lldb_private::ClassDescriptorV2::ivar_list_t::Read(), lldb_private::ClassDescriptorV2::ivar_t::Read(), DynamicLoaderMacOSXDYLD::ReadAllImageInfosStructure(), ReadCStringFromMemory(), lldb_private::Type::ReadFromMemory(), DynamicLoaderMacOSXDYLD::ReadImageInfos(), JITLoaderGDB::ReadJITDescriptorImpl(), SystemRuntimeMacOSX::ReadLibdispatchOffsets(), SystemRuntimeMacOSX::ReadLibpthreadOffsets(), DynamicLoaderMacOSXDYLD::ReadMachHeader(), DynamicLoaderDarwinKernel::ReadMachHeader(), ReadProcessMemory(), ReadScalarIntegerFromMemory(), HexagonDYLDRendezvous::ReadStringFromMemory(), ReadStringFromMemory(), lldb_private::AppleObjCRuntimeV2::DynamicClassInfoExtractor::UpdateISAToDescriptorMap(), lldb_private::AppleObjCRuntimeV2::SharedCacheClassInfoExtractor::UpdateISAToDescriptorMap(), and lldb_private::AppleObjCRuntimeV1::UpdateISAToDescriptorMapIfNeeded().

◆ ReadMemoryFromInferior()

size_t Process::ReadMemoryFromInferior ( lldb::addr_t  vm_addr,
void *  buf,
size_t  size,
Status error 
)

Read of memory from a process.

This function has the same semantics of ReadMemory except that it bypasses caching.

Parameters
[in]vm_addrA virtual load address that indicates where to start reading memory from.
[out]bufA byte buffer that is at least size bytes long that will receive the memory bytes.
[in]sizeThe number of bytes to read.
[out]errorAn error that indicates the success or failure of this operation. If error indicates success (error.Success()), then the value returned can be trusted, otherwise zero will be returned.
Returns
The number of bytes that were actually read into buf. If the returned number is greater than zero, yet less than size, then this function will get called again with vm_addr, buf, and size updated appropriately. Zero is returned in the case of an error.

Definition at line 2074 of file Process.cpp.

References DoReadMemory(), error(), LLDB_SCOPED_TIMER, and RemoveBreakpointOpcodesFromBuffer().

Referenced by PlatformDarwin::ExtractCrashInfoAnnotations(), lldb_private::ProcessStructReader::ProcessStructReader(), lldb_private::MemoryCache::Read(), ReadMemory(), and DynamicLoaderDarwinKernel::SearchForKernelWithDebugHints().

◆ ReadMemoryTags()

llvm::Expected< std::vector< lldb::addr_t > > Process::ReadMemoryTags ( lldb::addr_t  addr,
size_t  len 
)

Read memory tags for the range addr to addr+len.

It is assumed that this range has already been granule aligned. (see MemoryTagManager::MakeTaggedRange)

This calls DoReadMemoryTags to do the target specific operations.

Parameters
[in]addrStart of memory range to read tags for.
[in]lenLength of memory range to read tags for (in bytes).
Returns
If this architecture or process does not support memory tagging, an error saying so. If it does, either the memory tags or an error describing a failure to read or unpack them.

Definition at line 6130 of file Process.cpp.

References DoReadMemoryTags(), lldb_private::MemoryTagManager::GetAllocationTagType(), lldb_private::MemoryTagManager::GetGranuleSize(), GetMemoryTagManager(), and lldb_private::MemoryTagManager::UnpackTagsData().

Referenced by CommandObjectMemoryTagRead::DoExecute().

◆ ReadModuleFromMemory()

ModuleSP Process::ReadModuleFromMemory ( const FileSpec file_spec,
lldb::addr_t  header_addr,
size_t  size_to_read = 512 
)

◆ ReadPointerFromMemory()

addr_t Process::ReadPointerFromMemory ( lldb::addr_t  vm_addr,
Status error 
)

Definition at line 2122 of file Process.cpp.

References error(), GetAddressByteSize(), LLDB_INVALID_ADDRESS, ReadScalarIntegerFromMemory(), and lldb_private::Scalar::ULongLong().

Referenced by PlatformPOSIX::DoLoadImage(), lldb_private::Address::Dump(), lldb_private::DWARFExpression::Evaluate(), lldb_private::CPPLanguageRuntime::FindLibCppStdFunctionCallableInfo(), lldb_private::AppleObjCRuntime::GetBacktraceThreadFromException(), lldb_private::AppleObjCRuntimeV2::GetCFBooleanValuesIfNeeded(), lldb_private::AppleObjCRuntimeV2::GetClassDescriptor(), lldb_private::AppleObjCRuntimeV2::TaggedPointerVendorRuntimeAssisted::GetClassDescriptor(), lldb_private::ObjCLanguageRuntime::GetClassDescriptor(), lldb_private::AppleObjCRuntimeV2::TaggedPointerVendorExtended::GetClassDescriptor(), lldb_private::ItaniumABILanguageRuntime::GetDynamicTypeAndAddress(), lldb_private::AppleObjCRuntimeV1::GetISAHashTablePointer(), lldb_private::AppleObjCRuntimeV2::GetISAHashTablePointer(), SystemRuntimeMacOSX::GetLibdispatchQueueAddressFromThreadQAddress(), SystemRuntimeMacOSX::GetQueueIDFromThreadQAddress(), SystemRuntimeMacOSX::GetQueueNameFromThreadQAddress(), lldb_private::AppleObjCRuntimeV2::GetTaggedPointerObfuscator(), GetVTableAddress(), lldb_private::RegisterContextUnwind::ReadFrameAddress(), HexagonDYLDRendezvous::ReadPointer(), DYLDRendezvous::ReadPointer(), lldb_private::DynamicLoader::ReadPointer(), ResolveRendezvousAddress(), DYLDRendezvous::ResolveRendezvousAddress(), and lldb_private::AppleObjCRuntimeV1::UpdateISAToDescriptorMapIfNeeded().

◆ ReadScalarIntegerFromMemory()

size_t Process::ReadScalarIntegerFromMemory ( lldb::addr_t  addr,
uint32_t  byte_size,
bool  is_signed,
Scalar scalar,
Status error 
)

◆ ReadSignedIntegerFromMemory()

int64_t Process::ReadSignedIntegerFromMemory ( lldb::addr_t  load_addr,
size_t  byte_size,
int64_t  fail_value,
Status error 
)

◆ ReadStringFromMemory()

size_t Process::ReadStringFromMemory ( lldb::addr_t  vm_addr,
char *  str,
size_t  max_bytes,
Status error,
size_t  type_width = 1 
)

Read a NULL terminated string from memory.

This function will read a cache page at a time until a NULL string terminator is found. It will stop reading if an aligned sequence of NULL termination type_width bytes is not found before reading cstr_max_len bytes. The results are always guaranteed to be NULL terminated, and that no more than (max_bytes - type_width) bytes will be read.

Parameters
[in]vm_addrThe virtual load address to start the memory read.
[in]strA character buffer containing at least max_bytes.
[in]max_bytesThe maximum number of bytes to read.
[in]errorThe error status of the read operation.
[in]type_widthThe size of the null terminator (1 to 4 bytes per character). Defaults to 1.
Returns
The error status or the number of bytes prior to the null terminator.

Definition at line 1975 of file Process.cpp.

References error(), lldb_private::MemoryCache::GetMemoryCacheLineSize(), m_memory_cache, and ReadMemory().

◆ ReadUnsignedIntegerFromMemory()

uint64_t Process::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.

Parameters
[in]load_addrA load address of the integer to read.
[in]byte_sizeThe size in byte of the integer to read.
[in]fail_valueThe value to return if we fail to read an integer.
[out]errorAn error that indicates the success or failure of this operation. If error indicates success (error.Success()), then the value returned can be trusted, otherwise zero will be returned.
Returns
The unsigned integer that was read from the process memory space. If the integer was smaller than a uint64_t, any unused upper bytes will be zero filled. If the process byte order differs from the host byte order, the integer value will be appropriately byte swapped into host byte order.

Definition at line 2100 of file Process.cpp.

References error(), ReadScalarIntegerFromMemory(), and lldb_private::Scalar::ULongLong().

Referenced by SystemRuntimeMacOSX::BacktraceRecordingHeadersInitialized(), DynamicLoaderMacOS::CanLoadImage(), ExtractRuntimeGlobalSymbol(), lldb_private::FunctionCaller::FetchFunctionResults(), HexagonDYLDRendezvous::FindMetadata(), DYLDRendezvous::FindMetadata(), lldb_private::AppleObjCRuntimeV2::GetByteOffsetForIvar(), lldb_private::AppleGetQueuesHandler::GetCurrentQueues(), lldb_private::AppleGetItemInfoHandler::GetItemInfo(), lldb_private::AppleGetPendingItemsHandler::GetPendingItems(), SystemRuntimeMacOSX::GetQueueIDFromThreadQAddress(), SystemRuntimeMacOSX::GetQueueKind(), DynamicLoaderMacOSXDYLD::GetSharedCacheInformation(), lldb_private::AppleGetThreadItemInfoHandler::GetThreadItemInfo(), DynamicLoaderMacOS::NotifyBreakpointHit(), lldb_private::ClassDescriptorV2::method_t::Read(), lldb_private::ClassDescriptorV2::Read_class_row(), ReadInt(), lldb_private::DynamicLoader::ReadUnsignedIntWithSizeInBytes(), HexagonDYLDRendezvous::ReadWord(), and DYLDRendezvous::ReadWord().

◆ RefreshStateAfterStop()

virtual void lldb_private::Process::RefreshStateAfterStop ( )
pure virtual

Currently called as part of ShouldStop.

FIXME: Should really happen when the target stops before the event is taken from the queue...

This callback is called as the event is about to be queued up to allow Process plug-ins to execute some code prior to clients being notified that a process was stopped. Common operations include updating the thread list, invalidating any thread state (registers, stack, etc) prior to letting the notification go out.

Implemented in lldb_private::process_gdb_remote::ProcessGDBRemote, ProcessKDP, lldb_private::ScriptedProcess, ProcessElfCore, lldb_private::ProcessWindows, lldb_private::minidump::ProcessMinidump, ProcessMachCore, and lldb_private::ProcessTrace.

Referenced by ShouldBroadcastEvent().

◆ RegisterNotificationCallbacks()

void Process::RegisterNotificationCallbacks ( const Process::Notifications callbacks)

Register for process and thread notifications.

Clients can register notification callbacks by filling out a Process::Notifications structure and calling this function.

Parameters
[in]callbacksA structure that contains the notification baton and callback functions.
See also
Process::Notifications

Definition at line 574 of file Process.cpp.

References lldb_private::Process::Notifications::baton, lldb_private::Process::Notifications::initialize, and m_notifications.

◆ RemoveBreakpointOpcodesFromBuffer()

size_t Process::RemoveBreakpointOpcodesFromBuffer ( lldb::addr_t  addr,
size_t  size,
uint8_t *  buf 
) const
protected

◆ RemoveInvalidMemoryRange()

bool Process::RemoveInvalidMemoryRange ( const LoadRange region)

◆ RemoveOwnerFromBreakpointSite()

void Process::RemoveOwnerFromBreakpointSite ( lldb::user_id_t  owner_id,
lldb::user_id_t  owner_loc_id,
lldb::BreakpointSiteSP &  bp_site_sp 
)

◆ ResetImageToken()

void Process::ResetImageToken ( size_t  token)

Definition at line 5836 of file Process.cpp.

References LLDB_INVALID_ADDRESS, and m_image_tokens.

Referenced by PlatformPOSIX::UnloadImage().

◆ ResolveIndirectFunction()

addr_t Process::ResolveIndirectFunction ( const Address address,
Status error 
)
virtual

Resolve dynamically loaded indirect functions.

Parameters
[in]addressThe load address of the indirect function to resolve.
[out]errorAn error value in case the resolve fails.
Returns
The address of the resolved function. LLDB_INVALID_ADDRESS if the resolution failed.

Definition at line 5656 of file Process.cpp.

References lldb_private::ConstString::AsCString(), lldb_private::Address::CalculateSymbolContextSymbol(), CallVoidArgVoidPtrReturn(), error(), GetABI(), lldb_private::Address::GetLoadAddress(), lldb_private::Symbol::GetName(), GetTarget(), LLDB_INVALID_ADDRESS, and m_resolved_indirect_addresses.

Referenced by CreateBreakpointSite().

◆ RestoreProcessEvents()

void Process::RestoreProcessEvents ( )

◆ Resume()

Status Process::Resume ( )

Resumes all of a process's threads as configured using the Thread run control functions.

Threads for a process should be updated with one of the run control actions (resume, step, or suspend) that they should take when the process is resumed. If no run control action is given to a thread it will be resumed by default.

This function is not meant to be overridden by Process subclasses. This function will take care of disabling any breakpoints that threads may be stopped at, single stepping, and re-enabling breakpoints, and enabling the basic flow control that the plug-in instances need not worry about.

N.B. This function also sets the Write side of the Run Lock, which is unset when the corresponding stop event is pulled off the Public Event Queue. If you need to resume the process without setting the Run Lock, use PrivateResume (though you should only do that from inside the Process class.

Returns
Returns an error object.
See also
Thread:Resume()
Thread:Step()
Thread:Suspend()

Definition at line 1330 of file Process.cpp.

References error(), lldb_private::GetLogIfAnyCategoriesSet(), LIBLLDB_LOG_PROCESS, LIBLLDB_LOG_STATE, LLDB_LOGF, m_public_run_lock, PrivateResume(), lldb_private::ProcessRunLock::SetStopped(), and lldb_private::ProcessRunLock::TrySetRunning().

Referenced by lldb_private::process_gdb_remote::ProcessGDBRemote::DoDestroy(), CommandObjectThreadStepWithTypeAndScope::DoExecute(), CommandObjectProcessContinue::DoExecute(), CommandObjectThreadContinue::DoExecute(), CommandObjectThreadUntil::DoExecute(), lldb::SBThread::ResumeNewPlan(), lldb_private::Thread::StepIn(), lldb_private::Thread::StepOut(), and lldb_private::Thread::StepOver().

◆ ResumePrivateStateThread()

void Process::ResumePrivateStateThread ( )
protected

◆ ResumeSynchronous()

Status Process::ResumeSynchronous ( Stream stream)

◆ RouteAsyncStructuredData()

bool Process::RouteAsyncStructuredData ( const StructuredData::ObjectSP  object_sp)
protected

Route the incoming structured data dictionary to the right plugin.

The incoming structured data must be a dictionary, and it must have a key named 'type' that stores a string value. The string value must be the name of the structured data feature that knows how to handle it.

Parameters
[in]object_spWhen non-null and pointing to a dictionary, the 'type' key's string value is used to look up the plugin that was registered for that structured data type. It then calls the following method on the StructuredDataPlugin instance:

virtual void HandleArrivalOfStructuredData(Process &process, ConstString type_name, const StructuredData::ObjectSP &object_sp)

Returns
True if the structured data was routed to a plugin; otherwise, false.

Definition at line 6003 of file Process.cpp.

References lldb_private::StructuredData::Object::GetAsDictionary(), lldb_private::StructuredData::Dictionary::GetValueForKeyAsString(), and m_structured_data_plugin_map.

Referenced by lldb_private::process_gdb_remote::ProcessGDBRemote::HandleAsyncStructuredDataPacket().

◆ RunPreResumeActions()

bool Process::RunPreResumeActions ( )

◆ RunPrivateStateThread()

thread_result_t Process::RunPrivateStateThread ( bool  is_secondary_thread)
private

◆ RunThreadPlan()

ExpressionResults Process::RunThreadPlan ( ExecutionContext exe_ctx,
lldb::ThreadPlanSP &  thread_plan_sp,
const EvaluateExpressionOptions options,
DiagnosticManager diagnostic_manager 
)

Definition at line 4651 of file Process.cpp.

References lldb_private::Status::AsCString(), lldb_private::Broadcaster::BroadcastEvent(), lldb_private::Thread::DiscardThreadPlansUpToPlan(), lldb_private::EvaluateExpressionOptions::DoesIgnoreBreakpoints(), lldb_private::EvaluateExpressionOptions::DoesUnwindOnError(), eBroadcastBitInterrupt, lldb::eDescriptionLevelVerbose, lldb_private::eDiagnosticSeverityError, lldb_private::eDiagnosticSeverityRemark, lldb::eExpressionCompleted, lldb::eExpressionDiscarded, lldb::eExpressionHitBreakpoint, lldb::eExpressionInterrupted, lldb::eExpressionSetupError, lldb::eExpressionStoppedForDebug, lldb::eExpressionThreadVanished, lldb_private::HostThread::EqualsThread(), error(), lldb::eStateExited, lldb::eStateInvalid, lldb::eStateRunning, lldb::eStateStopped, lldb_private::ThreadList::FindThreadByIndexID(), lldb_private::Thread::Flush(), ForceNextEventDelivery(), lldb_private::Host::GetCurrentThread(), lldb_private::StreamString::GetData(), lldb_private::EvaluateExpressionOptions::GetDebug(), lldb_private::Process::ProcessEventData::GetEventDataFromEvent(), GetExpressionTimeout(), lldb_private::Thread::GetFrameWithStackID(), lldb_private::UserID::GetID(), lldb_private::Thread::GetIndexID(), lldb_private::Process::ProcessEventData::GetInterruptedFromEvent(), lldb_private::GetLogIfAnyCategoriesSet(), lldb_private::EvaluateExpressionOptions::GetOneThreadTimeout(), lldb_private::RegisterContext::GetPC(), lldb_private::Thread::GetPrivateStopInfo(), lldb_private::ExecutionContext::GetProcessPtr(), lldb_private::Process::ProcessEventData::GetProcessSP(), lldb_private::Thread::GetRegisterContext(), lldb_private::Process::ProcessEventData::GetRestartedFromEvent(), lldb_private::Thread::GetSelectedFrame(), lldb_private::ThreadList::GetSelectedThread(), lldb_private::ThreadList::GetSize(), lldb_private::Thread::GetStackFrameStatus(), lldb_private::Process::ProcessEventData::GetStateFromEvent(), lldb_private::EvaluateExpressionOptions::GetStopOthers(), lldb_private::StreamString::GetString(), lldb_private::ThreadList::GetThreadAtIndex(), GetThreadList(), lldb_private::ExecutionContext::GetThreadPtr(), lldb_private::EvaluateExpressionOptions::GetTimeout(), lldb_private::EvaluateExpressionOptions::GetTryAllThreads(), lldb_private::ProcessProperties::GetUtilityExpressionTimeout(), lldb_private::ThreadSafeValue< T >::GetValue(), Halt(), HandleStoppedEvent(), lldb_private::EvaluateExpressionOptions::IsForUtilityExpr(), lldb_private::HostThread::IsJoinable(), lldb_private::Thread::IsThreadPlanDone(), lldb_private::StackID::IsValid(), LIBLLDB_LOG_PROCESS, LIBLLDB_LOG_STEP, LLDB_INVALID_THREAD_ID, LLDB_LOG, LLDB_LOGF, m_private_state, m_private_state_thread, m_public_state, m_run_thread_plan_lock, lldb_private::Listener::MakeListener(), lldb_private::DiagnosticManager::Printf(), lldb_private::Stream::Printf(), PrivateResume(), lldb_private::Log::PutCString(), lldb_private::Stream::PutCString(), lldb_private::DiagnosticManager::PutString(), lldb_private::Log::PutString(), lldb_private::Thread::QueueThreadPlan(), lldb_private::ExecutionContext::SetFrameSP(), lldb_private::Thread::SetSelectedFrame(), lldb_private::ThreadSafeValue< T >::SetValueNoLock(), StartPrivateStateThread(), lldb_private::StateAsCString(), StopPrivateStateThread(), lldb_private::Status::Success(), UINT32_MAX, and lldb_private::Thread::WasThreadPlanDiscarded().

Referenced by CallVoidArgVoidPtrReturn(), lldb_private::LLVMUserExpression::DoExecute(), lldb_private::FunctionCaller::ExecuteFunction(), lldb_private::DynamicLoaderDarwin::GetThreadLocalData(), lldb_private::InferiorCallMmap(), lldb_private::InferiorCallMunmap(), and IRInterpreter::Interpret().

◆ SaveCore()

llvm::Expected< bool > Process::SaveCore ( llvm::StringRef  outfile)
virtual

Save core dump into the specified file.

Parameters
[in]outfilePath to store core dump in.
Returns
true if saved successfully, false if saving the core dump is not supported by the plugin, error otherwise.

Reimplemented in lldb_private::process_gdb_remote::ProcessGDBRemote.

Definition at line 2653 of file Process.cpp.

◆ SendAsyncInterrupt()

void Process::SendAsyncInterrupt ( )

◆ SendEventData()

virtual Status lldb_private::Process::SendEventData ( const char *  data)
inlinevirtual

Reimplemented in lldb_private::process_gdb_remote::ProcessGDBRemote.

Definition at line 2403 of file Process.h.

◆ SetCanInterpretFunctionCalls()

void lldb_private::Process::SetCanInterpretFunctionCalls ( bool  can_interpret_function_calls)
inline

Sets whether executing function calls using the interpreter is possible for this process.

Parameters
[in]can_interpret_function_callsTrue if possible; false otherwise.

Definition at line 1905 of file Process.h.

References m_can_interpret_function_calls.

Referenced by DynamicLoaderHexagonDYLD::DidAttach().

◆ SetCanJIT()

void Process::SetCanJIT ( bool  can_jit)

Sets whether executing JIT-compiled code in this process is possible.

Parameters
[in]can_jitTrue if execution of JIT code is possible; false otherwise.

Definition at line 2359 of file Process.cpp.

References eCanJITNo, eCanJITYes, and m_can_jit.

Referenced by DynamicLoaderHexagonDYLD::DidAttach(), lldb_private::ProcessTrace::DidAttach(), ProcessKDP::DoConnectRemote(), ProcessMachCore::DoLoadCore(), ProcessElfCore::DoLoadCore(), DynamicLoaderStatic::LoadAllImagesAtFileAddresses(), and SetCanRunCode().

◆ SetCanRunCode()

void Process::SetCanRunCode ( bool  can_run_code)

Sets whether executing code in this process is possible.

This could be either through JIT or interpreting.

Parameters
[in]can_run_codeTrue if execution of code is possible; false otherwise.

Definition at line 2363 of file Process.cpp.

References m_can_interpret_function_calls, and SetCanJIT().

Referenced by DynamicLoaderDarwinKernel::CreateInstance().

◆ SetCodeAddressMask()

void lldb_private::Process::SetCodeAddressMask ( lldb::addr_t  code_address_mask)
inline

◆ SetDataAddressMask()

void lldb_private::Process::SetDataAddressMask ( lldb::addr_t  data_address_mask)
inline

◆ SetDynamicCheckers()

void Process::SetDynamicCheckers ( DynamicCheckerFunctions dynamic_checkers)

◆ SetExitStatus()

bool Process::SetExitStatus ( int  exit_status,
const char *  cstr 
)
virtual

Set accessor for the process exit status (return code).

Sometimes a child exits and the exit can be detected by global functions (signal handler for SIGCHLD for example). This accessor allows the exit status to be set from an external source.

Setting this will cause a eStateExited event to be posted to the process event queue.

Parameters
[in]exit_statusThe value for the process's return code.
See also
lldb::StateType

Definition at line 1050 of file Process.cpp.

References DidExit(), lldb::eStateExited, lldb_private::GetLogIfAnyCategoriesSet(), lldb_private::ThreadSafeValue< T >::GetValue(), LIBLLDB_LOG_PROCESS, LIBLLDB_LOG_STATE, LLDB_LOGF, m_exit_status, m_exit_status_mutex, m_exit_string, m_mod_id, m_private_state, SetPrivateState(), and lldb_private::ProcessModID::SetStopEventForLastNaturalStopID().

Referenced by lldb_private::process_gdb_remote::ProcessGDBRemote::AsyncThread(), Attach(), lldb_private::process_gdb_remote::ProcessGDBRemote::DoAttachToProcessWithID(), lldb_private::process_gdb_remote::ProcessGDBRemote::DoAttachToProcessWithName(), lldb_private::process_gdb_remote::ProcessGDBRemote::DoDestroy(), Halt(), HandlePrivateEvent(), and Launch().

◆ SetID()

void lldb_private::Process::SetID ( lldb::pid_t  new_pid)
inline

◆ SetNextEventAction()

void lldb_private::Process::SetNextEventAction ( Process::NextEventAction next_event_action)
inlineprotected

Definition at line 2719 of file Process.h.

References m_next_event_action_up.

Referenced by Attach(), and HandlePrivateEvent().

◆ SetPrivateState()

void Process::SetPrivateState ( lldb::StateType  state)
protected

Definition at line 1406 of file Process.cpp.

References lldb_private::Broadcaster::BroadcastEvent(), lldb_private::ProcessModID::BumpStopID(), lldb_private::MemoryCache::Clear(), lldb_private::ThreadList::DidStop(), eBroadcastBitStateChanged, lldb_private::Broadcaster::Event, lldb_private::GetLogIfAnyCategoriesSet(), lldb_private::ThreadSafeValue< T >::GetMutex(), lldb_private::ThreadList::GetMutex(), lldb_private::ProcessModID::GetStopID(), lldb_private::ThreadSafeValue< T >::GetValueNoLock(), lldb_private::ProcessModID::IsLastResumeForUserExpression(), LIBLLDB_LOG_PROCESS, LIBLLDB_LOG_STATE, LIBLLDB_LOG_UNWIND, LLDB_LOGF, m_finalizing, m_memory_cache, m_mod_id, m_private_run_lock, m_private_state, m_private_state_broadcaster, m_thread_list, ProcessEventData, lldb_private::ProcessRunLock::SetRunning(), lldb_private::ProcessModID::SetStopEventForLastNaturalStopID(), lldb_private::ProcessRunLock::SetStopped(), lldb_private::ThreadSafeValue< T >::SetValueNoLock(), lldb_private::StateAsCString(), and lldb_private::StateIsStoppedState().

Referenced by ProcessKDP::AsyncThread(), lldb_private::process_gdb_remote::ProcessGDBRemote::AsyncThread(), lldb_private::ProcessTrace::DidAttach(), ProcessKDP::DoConnectRemote(), lldb_private::process_gdb_remote::ProcessGDBRemote::DoConnectRemote(), lldb_private::ProcessWindows::DoDetach(), ProcessKDP::DoDetach(), lldb_private::process_gdb_remote::ProcessGDBRemote::DoDetach(), ProcessKDP::DoHalt(), lldb_private::ScriptedProcess::DoLaunch(), lldb_private::process_gdb_remote::ProcessGDBRemote::DoLaunch(), lldb_private::ProcessWindows::DoResume(), lldb_private::ScriptedProcess::DoResume(), ProcessKDP::DoResume(), lldb_private::ScriptedProcess::DoStop(), lldb_private::process_gdb_remote::ProcessGDBRemote::HandleNotifyPacket(), LoadCore(), lldb_private::ProcessWindows::OnDebugException(), lldb_private::ProcessWindows::OnExitProcess(), PrivateResume(), and SetExitStatus().

◆ SetProcessExitStatus()

bool Process::SetProcessExitStatus ( lldb::pid_t  pid,
bool  exited,
int  signo,
int  status 
)
static

Static function that can be used with the host function Host::StartMonitoringChildProcess ().

This function can be used by lldb_private::Process subclasses when they want to watch for a local process and have its exit status automatically set when the host child process exits. Subclasses should call Host::StartMonitoringChildProcess () with: callback = Process::SetHostProcessExitStatus pid = Process::GetID() monitor_signals = false

Definition at line 1105 of file Process.cpp.

References lldb_private::Debugger::FindTargetWithProcessID(), lldb_private::GetLogIfAnyCategoriesSet(), LIBLLDB_LOG_PROCESS, and LLDB_LOGF.

Referenced by lldb_private::ProcessWindows::OnExitProcess().

◆ SetPublicState()

void Process::SetPublicState ( lldb::StateType  new_state,
bool  restarted 
)
protected

◆ SetRunningUserExpression()

void Process::SetRunningUserExpression ( bool  on)

◆ SetRunningUtilityFunction()

void Process::SetRunningUtilityFunction ( bool  on)

◆ SetShouldDetach()

void lldb_private::Process::SetShouldDetach ( bool  b)
inline

Definition at line 738 of file Process.h.

References m_should_detach.

◆ SetSTDIOFileDescriptor()

void Process::SetSTDIOFileDescriptor ( int  file_descriptor)

◆ SettingsInitialize()

void Process::SettingsInitialize ( )
static

◆ SettingsTerminate()

void Process::SettingsTerminate ( )
static

◆ SetUnixSignals()

void Process::SetUnixSignals ( lldb::UnixSignalsSP &&  signals_sp)

◆ ShouldBroadcastEvent()

bool Process::ShouldBroadcastEvent ( Event event_ptr)
private

This is the part of the event handling that for a process event.

It decides what to do with the event and returns true if the event needs to be propagated to the user, and false otherwise. If the event is not propagated, this call will most likely set the target to executing again. There is only one place where this call should be called, HandlePrivateEvent. Don't call it from anywhere else...

Parameters
[in]event_ptrThis is the event we are handling.
Returns
Returns true if the event should be reported to the user, false otherwise.

Definition at line 3344 of file Process.cpp.

References lldb_private::Communication::Disconnect(), lldb::eStateAttaching, lldb::eStateConnected, lldb::eStateCrashed, lldb::eStateDetached, lldb::eStateExited, lldb::eStateInvalid, lldb::eStateLaunching, lldb::eStateRunning, lldb::eStateStepping, lldb::eStateStopped, lldb::eStateSuspended, lldb::eStateUnloaded, lldb_private::eVoteNo, lldb_private::eVoteNoOpinion, lldb_private::eVoteYes, lldb_private::Process::ProcessEventData::GetInterruptedFromEvent(), lldb_private::GetLogIfAnyCategoriesSet(), lldb_private::Process::ProcessEventData::GetRestartedFromEvent(), lldb_private::Process::ProcessEventData::GetStateFromEvent(), LIBLLDB_LOG_EVENTS, LIBLLDB_LOG_PROCESS, LLDB_LOGF, m_force_next_event_delivery, m_last_broadcast_state, m_resume_requested, m_stdin_forward, m_stdio_communication, m_thread_list, PrivateResume(), RefreshStateAfterStop(), lldb_private::Process::ProcessEventData::SetRestartedInEvent(), lldb_private::ThreadList::ShouldReportRun(), lldb_private::ThreadList::ShouldReportStop(), lldb_private::ThreadList::ShouldStop(), lldb_private::StateAsCString(), lldb_private::Communication::StopReadThread(), lldb_private::Communication::SynchronizeWithReadThread(), and SynchronouslyNotifyStateChanged().

Referenced by HandlePrivateEvent().

◆ Signal()

Status Process::Signal ( int  signal)

Sends a process a UNIX signal signal.

This function is not meant to be overridden by Process subclasses.

Returns
Returns an error object.

Definition at line 3316 of file Process.cpp.

References DidSignal(), DoSignal(), error(), and WillSignal().

Referenced by CommandObjectProcessSignal::DoExecute(), and lldb_private::TargetList::SignalIfRunning().

◆ StartNoticingNewThreads()

virtual bool lldb_private::Process::StartNoticingNewThreads ( )
inlinevirtual

Call this to set the lldb in the mode where it breaks on new thread creations, and then auto-restarts.

This is useful when you are trying to run only one thread, but either that thread or the kernel is creating new threads in the process. If you stop when the thread is created, you can immediately suspend it, and keep executing only the one thread you intend.

Returns
Returns true if we were able to start up the notification false otherwise.

Reimplemented in lldb_private::process_gdb_remote::ProcessGDBRemote.

Definition at line 2345 of file Process.h.

Referenced by lldb_private::ThreadList::WillResume().

◆ StartPrivateStateThread()

bool Process::StartPrivateStateThread ( bool  is_secondary_thread = false)
protected

◆ StateChangedIsExternallyHijacked()

bool Process::StateChangedIsExternallyHijacked ( )

◆ StateChangedIsHijackedForSynchronousResume()

bool Process::StateChangedIsHijackedForSynchronousResume ( )

◆ STDIOReadThreadBytesReceived()

void Process::STDIOReadThreadBytesReceived ( void *  baton,
const void *  src,
size_t  src_len 
)
staticprotected

Definition at line 4324 of file Process.cpp.

References AppendSTDOUT().

Referenced by SetSTDIOFileDescriptor().

◆ StopForDestroyOrDetach()

Status Process::StopForDestroyOrDetach ( lldb::EventSP &  exit_event_sp)
protected

◆ StopNoticingNewThreads()

virtual bool lldb_private::Process::StopNoticingNewThreads ( )
inlinevirtual

Call this to turn off the stop & notice new threads mode.

Returns
Returns true if we were able to start up the notification false otherwise.

Reimplemented in lldb_private::process_gdb_remote::ProcessGDBRemote.

Definition at line 2352 of file Process.h.

Referenced by lldb_private::ThreadList::WillResume().

◆ StopPrivateStateThread()

void Process::StopPrivateStateThread ( )
protected

◆ SupportsMemoryTagging()

virtual bool lldb_private::Process::SupportsMemoryTagging ( )
inlineprotectedvirtual

Check whether the process supports memory tagging.

Returns
true if the process supports memory tagging, false otherwise.

Reimplemented in lldb_private::process_gdb_remote::ProcessGDBRemote.

Definition at line 2798 of file Process.h.

Referenced by GetMemoryTagManager().

◆ SynchronouslyNotifyStateChanged()

void Process::SynchronouslyNotifyStateChanged ( lldb::StateType  state)
protected

Definition at line 593 of file Process.cpp.

References m_notifications.

Referenced by ShouldBroadcastEvent().

◆ SyncIOHandler()

void Process::SyncIOHandler ( uint32_t  iohandler_id,
const Timeout< std::micro > &  timeout 
)

Waits for the process state to be running within a given msec timeout.

The main purpose of this is to implement an interlock waiting for HandlePrivateEvent to push an IOHandler.

Parameters
[in]timeoutThe maximum time length to wait for the process to transition to the eStateRunning state.

Definition at line 625 of file Process.cpp.

References lldb_private::GetLogIfAllCategoriesSet(), LIBLLDB_LOG_PROCESS, LLDB_LOG, m_iohandler_sync, m_process_input_reader, and lldb_private::Predicate< T >::WaitForValueNotEqualTo().

Referenced by CommandObjectThreadStepWithTypeAndScope::DoExecute(), and CommandObjectProcessContinue::DoExecute().

◆ Threads()

ThreadList::ThreadIterable lldb_private::Process::Threads ( )
inline

◆ TraceGetBinaryData()

virtual llvm::Expected<std::vector<uint8_t> > lldb_private::Process::TraceGetBinaryData ( const TraceGetBinaryDataRequest request)
inlineprotectedvirtual

Get binary data given a trace technology and a data identifier.

Parameters
[in]requestObject with the params of the requested data.
Returns
A vector of bytes with the requested data, or an llvm::Error in case of failures.

Reimplemented in lldb_private::process_gdb_remote::ProcessGDBRemote.

Definition at line 2601 of file Process.h.

◆ TraceGetState()

virtual llvm::Expected<std::string> lldb_private::Process::TraceGetState ( llvm::StringRef  type)
inlineprotectedvirtual

Get the current tracing state of the process and its threads.

Parameters
[in]typeTracing technology type to consider.
Returns
A JSON object string with custom data depending on the trace technology, or an llvm::Error in case of errors.

Reimplemented in lldb_private::process_gdb_remote::ProcessGDBRemote.

Definition at line 2588 of file Process.h.

◆ TraceStart()

virtual llvm::Error lldb_private::Process::TraceStart ( const llvm::json::Value &  request)
inlineprotectedvirtual

Start tracing a process or its threads.

Parameters
[in]requestJSON object with the information necessary to start tracing. In the case of gdb-remote processes, this JSON object should conform to the jLLDBTraceStart packet.
Returns
llvm::Error::success if the operation was successful, or llvm::Error otherwise.

Reimplemented in lldb_private::process_gdb_remote::ProcessGDBRemote.

Definition at line 2564 of file Process.h.

◆ TraceStop()

virtual llvm::Error lldb_private::Process::TraceStop ( const TraceStopRequest request)
inlineprotectedvirtual

Stop tracing a live process or its threads.

Parameters
[in]requestThe information determining which threads or process to stop tracing.
Returns
llvm::Error::success if the operation was successful, or llvm::Error otherwise.

Reimplemented in lldb_private::process_gdb_remote::ProcessGDBRemote.

Definition at line 2576 of file Process.h.

◆ TraceSupported()

llvm::Expected< TraceSupportedResponse > Process::TraceSupported ( )
protectedvirtual

Get the processor tracing type supported for this process.

Responses might be different depending on the architecture and capabilities of the underlying OS.

Returns
The supported trace type or an llvm::Error if tracing is not supported for the inferior.

Reimplemented in lldb_private::process_gdb_remote::ProcessGDBRemote.

Definition at line 6048 of file Process.cpp.

References IsLiveDebugSession().

◆ UnregisterNotificationCallbacks()

bool Process::UnregisterNotificationCallbacks ( const Process::Notifications callbacks)

Unregister for process and thread notifications.

Clients can unregister notification callbacks by passing a copy of the original baton and callbacks in callbacks.

Parameters
[in]callbacksA structure that contains the notification baton and callback functions.
Returns
Returns true if the notification callbacks were successfully removed from the process, false otherwise.
See also
Process::Notifications

Definition at line 580 of file Process.cpp.

References lldb_private::Process::Notifications::baton, lldb_private::Process::Notifications::initialize, m_notifications, and lldb_private::Process::Notifications::process_state_changed.

◆ UpdateAutomaticSignalFiltering()

Status Process::UpdateAutomaticSignalFiltering ( )
protectedvirtual

Reimplemented in lldb_private::process_gdb_remote::ProcessGDBRemote.

Definition at line 6032 of file Process.cpp.

Referenced by Launch(), and PrivateResume().

◆ UpdateQueueListIfNeeded()

void Process::UpdateQueueListIfNeeded ( )

◆ UpdateThreadList()

bool Process::UpdateThreadList ( ThreadList old_thread_list,
ThreadList new_thread_list 
)

Update the thread list.

This method performs some general clean up before invoking DoUpdateThreadList, which should be implemented by each process plugin.

Returns
true if the new thread list could be generated, false otherwise.

Definition at line 1133 of file Process.cpp.

References lldb_private::ThreadPlanStackMap::ClearThreadCache(), DoUpdateThreadList(), and m_thread_plans.

Referenced by UpdateThreadListIfNeeded().

◆ UpdateThreadListIfNeeded()

void Process::UpdateThreadListIfNeeded ( )

Definition at line 1139 of file Process.cpp.

References lldb_private::QueueList::Clear(), lldb_private::ThreadList::Clear(), lldb::eNoDynamicValues, GetLastNaturalStopID(), lldb_private::ThreadList::GetMutex(), GetOperatingSystem(), lldb_private::ProcessProperties::GetOSPluginReportsAllThreads(), lldb_private::TargetProperties::GetPreferDynamicValue(), GetPrivateState(), lldb_private::ThreadList::GetSize(), lldb_private::ThreadList::GetStopID(), GetStopID(), GetTarget(), lldb_private::ThreadList::GetThreadAtIndex(), m_destroy_in_process, m_extended_thread_list, m_extended_thread_stop_id, m_queue_list, m_queue_list_stop_id, m_thread_list, m_thread_list_real, m_thread_plans, lldb_private::TargetProperties::SetPreferDynamicValue(), lldb_private::ThreadList::SetStopID(), lldb_private::StateIsStoppedState(), lldb_private::ThreadPlanStackMap::Update(), lldb_private::ThreadList::Update(), lldb_private::OperatingSystem::UpdateThreadList(), and UpdateThreadList().

Referenced by CompleteAttach(), ProcessKDP::DoConnectRemote(), lldb_private::ScriptedProcess::DoLaunch(), lldb_private::ThreadList::FindThreadByID(), lldb_private::ThreadList::FindThreadByIndexID(), lldb_private::ThreadList::FindThreadByProtocolID(), lldb_private::ThreadList::GetSize(), lldb_private::ThreadList::GetThreadAtIndex(), lldb_private::ThreadList::RefreshStateAfterStop(), lldb_private::process_gdb_remote::ProcessGDBRemote::RefreshStateAfterStop(), lldb_private::ThreadList::RemoveThreadByID(), lldb_private::ThreadList::RemoveThreadByProtocolID(), lldb_private::ThreadList::SetShouldReportStop(), lldb_private::ThreadList::ShouldReportRun(), lldb_private::ThreadList::ShouldReportStop(), lldb_private::ThreadList::ShouldStop(), and lldb_private::ThreadList::WillResume().

◆ WaitForProcessStopPrivate()

StateType Process::WaitForProcessStopPrivate ( lldb::EventSP &  event_sp,
const Timeout< std::micro > &  timeout 
)
protected

◆ WaitForProcessToStop()

StateType Process::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 
)

◆ WarnBeforeDetach()

virtual bool lldb_private::Process::WarnBeforeDetach ( ) const
inlinevirtual

Before lldb detaches from a process, it warns the user that they are about to lose their debug session.

In some cases, this warning doesn't need to be emitted – for instance, with core file debugging where the user can reconstruct the "state" by simply re-running the debugger on the core file.

Returns
Returns true if the user should be warned about detaching from this process.

Reimplemented in ProcessElfCore, lldb_private::minidump::ProcessMinidump, ProcessMachCore, and lldb_private::ProcessTrace.

Definition at line 1422 of file Process.h.

◆ WillAttachToProcessWithID()

virtual Status lldb_private::Process::WillAttachToProcessWithID ( lldb::pid_t  pid)
inlinevirtual

Called before attaching to a process.

Allow Process plug-ins to execute some code before attaching a process.

Returns
Returns an error object.

Reimplemented in lldb_private::process_gdb_remote::ProcessGDBRemote, and ProcessKDP.

Definition at line 903 of file Process.h.

Referenced by Attach().

◆ WillAttachToProcessWithName()

virtual Status lldb_private::Process::WillAttachToProcessWithName ( const char *  process_name,
bool  wait_for_launch 
)
inlinevirtual

Called before attaching to a process.

Allow Process plug-ins to execute some code before attaching a process.

Returns
Returns an error object.

Reimplemented in lldb_private::process_gdb_remote::ProcessGDBRemote, and ProcessKDP.

Definition at line 911 of file Process.h.

Referenced by Attach().

◆ WillDestroy()

virtual Status lldb_private::Process::WillDestroy ( )
inlinevirtual

Definition at line 1167 of file Process.h.

Referenced by DestroyImpl().

◆ WillDetach()

virtual Status lldb_private::Process::WillDetach ( )
inlinevirtual

Called before detaching from a process.

Allow Process plug-ins to execute some code before detaching from a process.

Returns
Returns an error object.

Definition at line 1121 of file Process.h.

Referenced by Detach().

◆ WillHalt()

virtual Status lldb_private::Process::WillHalt ( )
inlinevirtual

Called before halting to a process.

Allow Process plug-ins to execute some code before halting a process.

Returns
Returns an error object.

Definition at line 1084 of file Process.h.

Referenced by HaltPrivate().

◆ WillLaunch()

virtual Status lldb_private::Process::WillLaunch ( Module module)
inlinevirtual

Called before launching to a process.

Allow Process plug-ins to execute some code before launching a process.

Returns
Returns an error object.

Reimplemented in lldb_private::process_gdb_remote::ProcessGDBRemote, and ProcessKDP.

Definition at line 1010 of file Process.h.

Referenced by Launch().

◆ WillPublicStop()

virtual void lldb_private::Process::WillPublicStop ( )
inlinevirtual

Called when the process is about to broadcast a public stop.

There are public and private stops. Private stops are when the process is doing things like stepping and the client doesn't need to know about starts and stop that implement a thread plan. Single stepping over a source line in code might end up being implemented by one or more process starts and stops. Public stops are when clients will be notified that the process is stopped. These events typically trigger UI updates (thread stack frames to be displayed, variables to be displayed, and more). This function can be overriden and allows process subclasses to do something before the eBroadcastBitStateChanged event is sent to public clients.

Reimplemented in lldb_private::process_gdb_remote::ProcessGDBRemote.

Definition at line 772 of file Process.h.

◆ WillResume()

virtual Status lldb_private::Process::WillResume ( )
inlinevirtual

Called before resuming to a process.

Allow Process plug-ins to execute some code before resuming a process.

Returns
Returns an error object.

Reimplemented in lldb_private::process_gdb_remote::ProcessGDBRemote, ProcessKDP, lldb_private::minidump::ProcessMinidump, ProcessElfCore, and lldb_private::ProcessTrace.

Definition at line 1048 of file Process.h.

Referenced by PrivateResume().

◆ WillSignal()

virtual Status lldb_private::Process::WillSignal ( )
inlinevirtual

Called before sending a signal to a process.

Allow Process plug-ins to execute some code before sending a signal to a process.

Returns
Returns no error if it is safe to proceed with a call to Process::DoSignal(int), otherwise an error describing what prevents the signal from being sent.

Definition at line 1153 of file Process.h.

Referenced by Signal().

◆ WriteMemory()

size_t Process::WriteMemory ( lldb::addr_t  vm_addr,
const void *  buf,
size_t  size,
Status error 
)

Write memory to a process.

This function will write memory to the current process's address space and maintain any traps that might be present due to software breakpoints.

This function is not meant to be overridden by Process subclasses, the subclasses should implement Process::DoWriteMemory (lldb::addr_t, size_t, void *).

Parameters
[in]vm_addrA virtual load address that indicates where to start writing memory to.
[in]bufA byte buffer that is at least size bytes long that contains the data to write.
[in]sizeThe number of bytes to write.
Returns
The number of bytes that were actually written.

Definition at line 2158 of file Process.cpp.

References lldb_private::ProcessModID::BumpMemoryID(), error(), lldb_private::BreakpointSite::eSoftware, lldb_private::BreakpointSiteList::FindInRange(), lldb_private::MemoryCache::Flush(), lldb_private::BreakpointSiteList::ForEach(), lldb_private::BreakpointSite::GetSavedOpcodeBytes(), lldb_private::BreakpointSite::GetType(), lldb_private::BreakpointSite::IntersectsRange(), lldb_private::BreakpointSiteList::IsEmpty(), m_breakpoint_site_list, m_memory_cache, m_mod_id, UNUSED_IF_ASSERT_DISABLED, and WriteMemoryPrivate().

Referenced by CallocateMemory(), CommandObjectMemoryWrite::DoExecute(), PlatformPOSIX::DoLoadImage(), lldb_private::ValueObject::SetData(), WriteObjectFile(), and WriteScalarToMemory().

◆ WriteMemoryPrivate()

size_t Process::WriteMemoryPrivate ( lldb::addr_t  addr,
const void *  buf,
size_t  size,
Status error 
)
protected

Definition at line 2142 of file Process.cpp.

References DoWriteMemory(), and error().

Referenced by WriteMemory().

◆ WriteMemoryTags()

Status Process::WriteMemoryTags ( lldb::addr_t  addr,
size_t  len,
const std::vector< lldb::addr_t > &  tags 
)

Write memory tags for a range of memory.

(calls DoWriteMemoryTags to do the target specific work)

Parameters
[in]addrThe address to start writing tags from. It is assumed that this address is granule aligned.
[in]lenThe size of the range to write tags for. It is assumed that this is some multiple of the granule size. This len can be different from (number of tags * granule size) in the case where you want lldb-server to repeat tags across the range.
[in]tagsAllocation tags to be written. Since lldb-server can repeat tags for a range, the number of tags doesn't have to match the number of granules in the range. (though most of the time it will)
Returns
A Status telling you if the write succeeded or not.

Definition at line 6146 of file Process.cpp.

References DoWriteMemoryTags(), lldb_private::MemoryTagManager::GetAllocationTagType(), GetMemoryTagManager(), and lldb_private::MemoryTagManager::PackTags().

Referenced by CommandObjectMemoryTagWrite::DoExecute().

◆ WriteObjectFile()

Status Process::WriteObjectFile ( std::vector< ObjectFile::LoadableData entries)
virtual

◆ WritePointerToMemory()

bool Process::WritePointerToMemory ( lldb::addr_t  vm_addr,
lldb::addr_t  ptr_value,
Status error 
)

Definition at line 2130 of file Process.cpp.

References error(), GetAddressByteSize(), and WriteScalarToMemory().

◆ WriteScalarToMemory()

size_t Process::WriteScalarToMemory ( lldb::addr_t  vm_addr,
const Scalar scalar,
size_t  size,
Status error 
)

Write all or part of a scalar value to memory.

The value contained in scalar will be swapped to match the byte order of the process that is being debugged. If size is less than the size of scalar, the least significant size bytes from scalar will be written. If size is larger than the byte size of scalar, then the extra space will be padded with zeros and the scalar value will be placed in the least significant bytes in memory.

Parameters
[in]vm_addrA virtual load address that indicates where to start writing memory to.
[in]scalarThe scalar to write to the debugged process.
[in]sizeThis value can be smaller or larger than the scalar value itself. If size is smaller than the size of scalar, the least significant bytes in scalar will be used. If size is larger than the byte size of scalar, then the extra space will be padded with zeros. If size is set to UINT32_MAX, then the size of scalar will be used.
[out]errorAn error value in case the memory write fails.
Returns
The number of bytes that were actually written.

Definition at line 2237 of file Process.cpp.

References error(), lldb_private::Scalar::GetAsMemoryData(), GetByteOrder(), lldb_private::Scalar::GetByteSize(), UINT32_MAX, and WriteMemory().

Referenced by lldb_private::ValueObject::SetValueFromCString(), lldb_private::FunctionCaller::WriteFunctionArguments(), and WritePointerToMemory().

Friends And Related Function Documentation

◆ Debugger

friend class Debugger
friend

Definition at line 348 of file Process.h.

◆ DynamicLoader

friend class DynamicLoader
friend

Definition at line 349 of file Process.h.

◆ FunctionCaller

friend class FunctionCaller
friend

Definition at line 347 of file Process.h.

◆ ProcessEventData

friend class ProcessEventData
friend

Definition at line 350 of file Process.h.

Referenced by AppendSTDERR(), AppendSTDOUT(), BroadcastAsyncProfileData(), and SetPrivateState().

◆ ProcessEventHijacker

friend class ProcessEventHijacker
friend

Definition at line 2223 of file Process.h.

◆ ProcessProperties

friend class ProcessProperties
friend

Definition at line 2224 of file Process.h.

Referenced by GetGlobalProperties().

◆ StopInfo

friend class StopInfo
friend

Definition at line 351 of file Process.h.

◆ Target

friend class Target
friend

Definition at line 352 of file Process.h.

◆ ThreadList

friend class ThreadList
friend

Definition at line 353 of file Process.h.

◆ Trace

friend class Trace
friend

Definition at line 2544 of file Process.h.

Member Data Documentation

◆ m_abi_sp

lldb::ABISP lldb_private::Process::m_abi_sp
protected

This is the current signal set for this process.

Definition at line 2934 of file Process.h.

Referenced by Attach(), ConnectRemote(), DidExec(), Finalize(), GetABI(), and Launch().

◆ m_allocated_memory_cache

AllocatedMemoryCache lldb_private::Process::m_allocated_memory_cache
protected

Definition at line 2946 of file Process.h.

Referenced by AllocateMemory(), DeallocateMemory(), DidExec(), and Finalize().

◆ m_breakpoint_site_list

BreakpointSiteList lldb_private::Process::m_breakpoint_site_list
protected

◆ m_can_interpret_function_calls

bool lldb_private::Process::m_can_interpret_function_calls
protected

◆ m_can_jit

enum { ... } lldb_private::Process::m_can_jit

Referenced by CanJIT(), and SetCanJIT().

◆ m_clear_thread_plans_on_stop

bool lldb_private::Process::m_clear_thread_plans_on_stop
protected

Definition at line 2974 of file Process.h.

Referenced by Halt(), and RunPrivateStateThread().

◆ m_code_address_mask

lldb::addr_t lldb_private::Process::m_code_address_mask = 0
protected

Mask for code an data addresses.

The default value (0) means no mask is set. The bits set to 1 indicate bits that are NOT significant for addressing.

Definition at line 2970 of file Process.h.

Referenced by GetCodeAddressMask(), and SetCodeAddressMask().

◆ m_currently_handling_do_on_removals

bool lldb_private::Process::m_currently_handling_do_on_removals
protected

Definition at line 2956 of file Process.h.

◆ m_data_address_mask

lldb::addr_t lldb_private::Process::m_data_address_mask = 0
protected

Definition at line 2971 of file Process.h.

Referenced by GetDataAddressMask(), and SetDataAddressMask().

◆ m_destroy_in_process

bool lldb_private::Process::m_destroy_in_process
protected

◆ m_dlopen_utility_func_flag_once

llvm::once_flag lldb_private::Process::m_dlopen_utility_func_flag_once
protected

Definition at line 2992 of file Process.h.

Referenced by GetLoadImageUtilityFunction().

◆ m_dlopen_utility_func_up

std::unique_ptr<UtilityFunction> lldb_private::Process::m_dlopen_utility_func_up
protected

Definition at line 2991 of file Process.h.

Referenced by GetLoadImageUtilityFunction().

◆ m_dyld_up

lldb::DynamicLoaderUP lldb_private::Process::m_dyld_up
protected

◆ m_dynamic_checkers_up

lldb::DynamicCheckerFunctionsUP lldb_private::Process::m_dynamic_checkers_up
protected

The functions used by the expression parser to validate data that expressions use.

Definition at line 2925 of file Process.h.

Referenced by DidExec(), Finalize(), GetDynamicCheckers(), and SetDynamicCheckers().

◆ m_exit_status

int lldb_private::Process::m_exit_status
protected

The exit status of the process, or -1 if not set.

Definition at line 2892 of file Process.h.

Referenced by GetExitStatus(), and SetExitStatus().

◆ m_exit_status_mutex

std::mutex lldb_private::Process::m_exit_status_mutex
protected

Mutex so m_exit_status m_exit_string can be safely accessed from multiple threads.

Definition at line 2894 of file Process.h.

Referenced by GetExitDescription(), GetExitStatus(), and SetExitStatus().

◆ m_exit_string

std::string lldb_private::Process::m_exit_string
protected

◆ m_extended_thread_list

ThreadList lldb_private::Process::m_extended_thread_list
protected

Owner for extended threads that may be generated, cleared on natural stops.

Definition at line 2907 of file Process.h.

Referenced by Finalize(), Flush(), GetExtendedThreadList(), and UpdateThreadListIfNeeded().

◆ m_extended_thread_stop_id

uint32_t lldb_private::Process::m_extended_thread_stop_id
protected

The natural stop id when extended_thread_list was last updated.

Definition at line 2909 of file Process.h.

Referenced by Flush(), and UpdateThreadListIfNeeded().

◆ m_finalizing

std::atomic<bool> lldb_private::Process::m_finalizing
protected

This is set at the beginning of Process::Finalize() to stop functions from looking up or creating things during or after a finalize call.

Definition at line 2964 of file Process.h.

Referenced by Destroy(), Finalize(), GetLanguageRuntime(), GetLanguageRuntimes(), IsPossibleDynamicValue(), IsValid(), and SetPrivateState().

◆ m_force_next_event_delivery

bool lldb_private::Process::m_force_next_event_delivery
protected

Definition at line 2975 of file Process.h.

Referenced by ForceNextEventDelivery(), and ShouldBroadcastEvent().

◆ m_image_tokens

std::vector<lldb::addr_t> lldb_private::Process::m_image_tokens
protected

◆ m_instrumentation_runtimes

InstrumentationRuntimeCollection lldb_private::Process::m_instrumentation_runtimes
protected

Definition at line 2951 of file Process.h.

Referenced by DidExec