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

#include "lldb/Target/Process.h"

Inheritance diagram for lldb_private::Process:

[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

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) }

typedef Range< lldb::addr_t, lldb::addr_t >	LoadRange

typedef ProcessRunLock::ProcessRunLocker	StopLocker

typedef bool()	PreResumeActionCallback(void *)

Public Member Functions
ConstString &	GetBroadcasterClass () 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.

void	SetShadowListener (lldb::ListenerSP listener_sp) override

	~Process () override
	Destructor.

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.

void	SetID (lldb::pid_t new_pid)
	Sets the stored pid.

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.

virtual void	Finalize ()
	This object is about to be destroyed, do any necessary cleanup.

bool	IsValid () const
	Return whether this object is valid (i.e.

virtual CommandObject *	GetPluginCommandObject ()
	Return a multi-word command object that can be used to expose plug-in specific commands.

virtual Status	Launch (ProcessLaunchInfo &launch_info)
	Launch a new process.

virtual Status	LoadCore ()

virtual Status	DoLoadCore ()

UtilityFunction *	GetLoadImageUtilityFunction (Platform *platform, llvm::function_ref< std::unique_ptr< UtilityFunction >()> factory)
	Get the cached UtilityFunction that assists in loading binary images into the process.

virtual DynamicLoader *	GetDynamicLoader ()
	Get the dynamic loader plug-in for this process.

void	SetDynamicLoader (lldb::DynamicLoaderUP dyld)

virtual DataExtractor	GetAuxvData ()

virtual llvm::Error	LoadModules ()
	Sometimes processes know how to retrieve and load shared libraries.

virtual llvm::Expected< LoadedModuleInfoList >	GetLoadedModuleList ()
	Query remote GDBServer for a detailed loaded library list.

virtual llvm::Expected< bool >	SaveCore (llvm::StringRef outfile)
	Save core dump into the specified file.

virtual ArchSpec	GetSystemArchitecture ()
	Get the system architecture for this process.

virtual SystemRuntime *	GetSystemRuntime ()
	Get the system runtime plug-in for this process.

virtual Status	Attach (ProcessAttachInfo &attach_info)
	Attach to an existing process using the process attach info.

virtual Status	ConnectRemote (llvm::StringRef remote_url)
	Attach to a remote system via a URL.

bool	GetShouldDetach () const

void	SetShouldDetach (bool b)

const std::vector< lldb::addr_t > &	GetImageTokens ()
	Get the image vector for the current process.

virtual lldb::addr_t	GetImageInfoAddress ()
	Get the image information address for the current process.

virtual void	WillPublicStop ()
	Called when the process is about to broadcast a public stop.

void	RegisterNotificationCallbacks (const Process::Notifications &callbacks)
	Register for process and thread notifications.

bool	UnregisterNotificationCallbacks (const Process::Notifications &callbacks)
	Unregister for process and thread notifications.

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

Status	ResumeSynchronous (Stream *stream)
	Resume a process, and wait for it to stop.

Status	Halt (bool clear_thread_plans=false, bool use_run_lock=true)
	Halts a running process.

Status	Detach (bool keep_stopped)
	Detaches from a running or stopped process.

Status	Destroy (bool force_kill)
	Kills the process and shuts down all threads that were spawned to track and monitor the process.

Status	Signal (int signal)
	Sends a process a UNIX signal signal.

void	SetUnixSignals (lldb::UnixSignalsSP &&signals_sp)

const lldb::UnixSignalsSP &	GetUnixSignals ()

Status	WillAttachToProcessWithID (lldb::pid_t pid)
	Called before attaching to a process.

virtual Status	DoWillAttachToProcessWithID (lldb::pid_t pid)
	Called before attaching to a process.

Status	WillAttachToProcessWithName (const char *process_name, bool wait_for_launch)
	Called before attaching to a process.

virtual Status	DoWillAttachToProcessWithName (const char *process_name, bool wait_for_launch)
	Called before attaching to a process.

virtual Status	DoConnectRemote (llvm::StringRef remote_url)
	Attach to a remote system via a URL.

virtual Status	DoAttachToProcessWithID (lldb::pid_t pid, const ProcessAttachInfo &attach_info)
	Attach to an existing process using a process ID.

virtual Status	DoAttachToProcessWithName (const char *process_name, const ProcessAttachInfo &attach_info)
	Attach to an existing process using a partial process name.

virtual void	DidAttach (ArchSpec &process_arch)
	Called after attaching a process.

virtual void	DidExec ()
	Called after a process re-execs itself.

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

virtual void	DidFork (lldb::pid_t child_pid, lldb::tid_t child_tid)
	Called after a reported fork.

virtual void	DidVFork (lldb::pid_t child_pid, lldb::tid_t child_tid)
	Called after a reported vfork.

virtual void	DidVForkDone ()
	Called after reported vfork completion.

Status	WillLaunch (Module *module)
	Called before launching to a process.

virtual Status	DoWillLaunch (Module *module)
	Called before launching to a process.

virtual Status	DoLaunch (Module *exe_module, ProcessLaunchInfo &launch_info)
	Launch a new process.

virtual void	DidLaunch ()
	Called after launching a process.

virtual Status	WillResume ()
	Called before resuming to a process.

virtual Status	DoResume ()
	Resumes all of a process's threads as configured using the Thread run control functions.

virtual void	DidResume ()
	Called after resuming a process.

virtual Status	WillHalt ()
	Called before halting to a process.

virtual Status	DoHalt (bool &caused_stop)
	Halts a running process.

virtual void	DidHalt ()
	Called after halting a process.

virtual Status	WillDetach ()
	Called before detaching from a process.

virtual Status	DoDetach (bool keep_stopped)
	Detaches from a running or stopped process.

virtual void	DidDetach ()
	Called after detaching from a process.

virtual bool	DetachRequiresHalt ()

virtual Status	WillSignal ()
	Called before sending a signal to a process.

virtual Status	DoSignal (int signal)
	Sends a process a UNIX signal signal.

virtual Status	WillDestroy ()

virtual Status	DoDestroy ()=0

virtual void	DidDestroy ()

virtual bool	DestroyRequiresHalt ()

virtual void	DidSignal ()
	Called after sending a signal to a process.

virtual void	RefreshStateAfterStop ()=0
	Currently called as part of ShouldStop.

virtual llvm::VersionTuple	GetHostOSVersion ()
	Sometimes the connection to a process can detect the host OS version that the process is running on.

virtual llvm::VersionTuple	GetHostMacCatalystVersion ()

Target &	GetTarget ()
	Get the target object pointer for this module.

const Target &	GetTarget () const
	Get the const target object pointer for this module.

void	Flush ()
	Flush all data in the process.

lldb::StateType	GetState ()
	Get accessor for the current process state.

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.

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 ()

virtual lldb_private::StructuredData::ObjectSP	GetDynamicLoaderProcessState ()

void	PrintWarningOptimization (const SymbolContext &sc)
	Print a user-visible warning about a module being built with optimization.

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.

virtual bool	GetProcessInfo (ProcessInstanceInfo &info)

int	GetExitStatus ()
	Get the exit status for a process.

const char *	GetExitDescription ()
	Get a textual description of what the process exited.

virtual void	DidExit ()

lldb::addr_t	GetCodeAddressMask ()

lldb::addr_t	GetDataAddressMask ()

lldb::addr_t	GetHighmemCodeAddressMask ()

lldb::addr_t	GetHighmemDataAddressMask ()

void	SetCodeAddressMask (lldb::addr_t code_address_mask)

void	SetDataAddressMask (lldb::addr_t data_address_mask)

void	SetHighmemCodeAddressMask (lldb::addr_t code_address_mask)

void	SetHighmemDataAddressMask (lldb::addr_t data_address_mask)

ProcessModID	GetModID () const
	Get the Modification ID of the process.

const ProcessModID &	GetModIDRef () 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).

virtual bool	IsAlive ()
	Check if a process is still alive.

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.

virtual size_t	ReadMemory (lldb::addr_t vm_addr, void *buf, size_t size, Status &error)
	Read of memory from a process.

size_t	ReadMemoryFromInferior (lldb::addr_t vm_addr, void *buf, size_t size, Status &error)
	Read of memory from a process.

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.

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.

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.

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.

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.

virtual lldb::addr_t	DoAllocateMemory (size_t size, uint32_t permissions, Status &error)
	Actually allocate memory in the process.

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.

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.

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.

virtual llvm::Expected< std::vector< lldb::addr_t > >	ReadMemoryTags (lldb::addr_t addr, size_t len)
	Read memory tags for the range addr to addr+len.

Status	WriteMemoryTags (lldb::addr_t addr, size_t len, const std::vector< lldb::addr_t > &tags)
	Write memory tags for a range of memory.

virtual lldb::addr_t	ResolveIndirectFunction (const Address *address, Status &error)
	Resolve dynamically loaded indirect functions.

Status	GetMemoryRegionInfo (lldb::addr_t load_addr, MemoryRegionInfo &range_info)
	Locate the memory region that contains load_addr.

virtual Status	GetMemoryRegions (lldb_private::MemoryRegionInfos &region_list)
	Obtain all the mapped memory regions within this process.

virtual std::optional< uint32_t >	GetWatchpointSlotCount ()
	Get the number of watchpoints supported by this target.

bool	GetWatchpointReportedAfter ()
	Whether lldb will be notified about watchpoints after the instruction has completed executing, or if the instruction is rolled back and it is notified before it executes.

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.

bool	CanJIT ()
	Determines whether executing JIT-compiled code in this process is possible.

void	SetCanJIT (bool can_jit)
	Sets whether executing JIT-compiled code in this process is possible.

bool	CanInterpretFunctionCalls ()
	Determines whether executing function calls using the interpreter is possible for this process.

void	SetCanInterpretFunctionCalls (bool can_interpret_function_calls)
	Sets whether executing function calls using the interpreter is possible for this process.

void	SetCanRunCode (bool can_run_code)
	Sets whether executing code in this process is possible.

virtual Status	DoDeallocateMemory (lldb::addr_t ptr)
	Actually deallocate memory in the process.

Status	DeallocateMemory (lldb::addr_t ptr)
	The public interface to deallocating memory in the process.

virtual size_t	GetSTDOUT (char *buf, size_t buf_size, Status &error)
	Get any available STDOUT.

virtual size_t	GetSTDERR (char *buf, size_t buf_size, Status &error)
	Get any available STDERR.

virtual size_t	PutSTDIN (const char *buf, size_t buf_size, Status &error)
	Puts data into this process's STDIN.

virtual size_t	GetAsyncProfileData (char *buf, size_t buf_size, Status &error)
	Get any available profile data.

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)

BreakpointSiteList &	GetBreakpointSiteList ()

const BreakpointSiteList &	GetBreakpointSiteList () 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.

void	UpdateThreadListIfNeeded ()

ThreadList &	GetThreadList ()

ThreadList &	GetExtendedThreadList ()

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)

virtual void	UpdateQueueListIfNeeded ()

QueueList &	GetQueueList ()

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, SelectMostRelevant select_most_relevant=DoNoSelectMostRelevantFrame)

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.

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

Event *	PeekAtStateChangedEvents ()

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.

void	RestoreProcessEvents ()
	Restores the process event broadcasting to its normal state.

bool	StateChangedIsHijackedForSynchronousResume ()

bool	StateChangedIsExternallyHijacked ()

const lldb::ABISP &	GetABI ()

OperatingSystem *	GetOperatingSystem ()

std::vector< LanguageRuntime * >	GetLanguageRuntimes ()

LanguageRuntime *	GetLanguageRuntime (lldb::LanguageType language)

bool	IsPossibleDynamicValue (ValueObject &in_value)

bool	IsRunning () const

DynamicCheckerFunctions *	GetDynamicCheckers ()

void	SetDynamicCheckers (DynamicCheckerFunctions *dynamic_checkers)

bool	PruneThreadPlansForTID (lldb::tid_t tid)
	Prune ThreadPlanStacks for unreported threads.

void	PruneThreadPlans ()
	Prune ThreadPlanStacks for all unreported threads.

ThreadPlanStack *	FindThreadPlans (lldb::tid_t tid)
	Find the thread plan stack associated with thread with tid.

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.

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.

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

virtual bool	StopNoticingNewThreads ()
	Call this to turn off the stop & notice new threads mode.

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.

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)

ProcessRunLock &	GetRunLock ()

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.

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.

virtual StructuredData::DictionarySP	GetMetadata ()
	Fetch process defined metadata.

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.

virtual Status	ConfigureStructuredData (ConstString type_name, const StructuredData::ObjectSP &config_sp)
	Configure asynchronous structured data feature.

void	BroadcastStructuredData (const StructuredData::ObjectSP &object_sp, const lldb::StructuredDataPluginSP &plugin_sp)
	Broadcasts the given structured data object from the given plugin.

lldb::StructuredDataPluginSP	GetStructuredDataPlugin (ConstString type_name) const
	Returns the StructuredDataPlugin associated with a given type name, if there is one.

virtual void *	GetImplementation ()

virtual void	ForceScriptedState (lldb::StateType state)

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)

uint32_t	GetHighmemVirtualAddressableBits () const

void	SetHighmemVirtualAddressableBits (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, 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, bool is_json=false)

virtual void	DumpAllPropertyValues (const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask, bool is_json=false)

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)

template<typename T >
T	GetPropertyAtIndexAs (uint32_t idx, T default_value, const ExecutionContext *exe_ctx=nullptr) const

template<typename T , typename U = typename std::remove_pointer<T>::type, std::enable_if_t< std::is_pointer_v< T >, bool > = true>
const U *	GetPropertyAtIndexAs (uint32_t idx, const ExecutionContext *exe_ctx=nullptr) const

template<typename T >
bool	SetPropertyAtIndex (uint32_t idx, T t, const ExecutionContext *exe_ctx=nullptr) const

Public Member Functions inherited from lldb_private::Broadcaster
	Broadcaster (lldb::BroadcasterManagerSP manager_sp, const char *name)
	Construct with a broadcaster with a name.

virtual	~Broadcaster ()
	Destructor.

void	CheckInWithManager ()

void	BroadcastEvent (lldb::EventSP &event_sp)
	Broadcast an event which has no associated data.

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.

ConstString	GetBroadcasterName ()
	Get the NULL terminated C string name of this Broadcaster object.

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.

void	SetEventName (uint32_t event_mask, const char *name)
	Set the name for an event bit.

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.

bool	HijackBroadcaster (const lldb::ListenerSP &listener_sp, uint32_t event_mask=UINT32_MAX)
	Provides a simple mechanism to temporarily redirect events from broadcaster.

bool	IsHijackedForEvent (uint32_t event_mask)

void	RestoreBroadcaster ()
	Restore the state of the Broadcaster from a previous hijack attempt.

virtual ConstString &	GetBroadcasterClass () const
	This needs to be filled in if you are going to register the broadcaster with the broadcaster manager and do broadcaster class matching.

lldb::BroadcasterManagerSP	GetManager ()

virtual void	SetShadowListener (lldb::ListenerSP listener_sp)

Public Member Functions inherited from lldb_private::ExecutionContextScope
virtual	~ExecutionContextScope ()=default

virtual lldb::TargetSP	CalculateTarget ()=0

virtual lldb::ProcessSP	CalculateProcess ()=0

virtual lldb::ThreadSP	CalculateThread ()=0

virtual lldb::StackFrameSP	CalculateStackFrame ()=0

virtual void	CalculateExecutionContext (ExecutionContext &exe_ctx)=0
	Reconstruct the object's execution context into sc.

Public Member Functions inherited from lldb_private::PluginInterface
	PluginInterface ()=default

virtual	~PluginInterface ()=default

virtual llvm::StringRef	GetPluginName ()=0

	PluginInterface (const PluginInterface &)=delete

PluginInterface &	operator= (const PluginInterface &)=delete

Static Public Member Functions
static ConstString &	GetStaticBroadcasterClass ()

static void	SettingsInitialize ()

static void	SettingsTerminate ()

static ProcessProperties &	GetGlobalProperties ()

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.

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 ().

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

static bool	HandleProcessStateChangedEvent (const lldb::EventSP &event_sp, Stream *stream, SelectMostRelevant select_most_relevant, bool &pop_process_io_handler)
	Centralize the code that handles and prints descriptions for process state changes.

Static Public Member Functions inherited from lldb_private::Properties
static const char *	GetExperimentalSettingsName ()

static bool	IsSettingExperimental (llvm::StringRef setting)

Static Public Attributes
static constexpr llvm::StringRef	AttachSynchronousHijackListenerName

static constexpr llvm::StringRef	LaunchSynchronousHijackListenerName

static constexpr llvm::StringRef	ResumeSynchronousHijackListenerName

Protected Types
enum	{ eCanJITDontKnow = 0 , eCanJITYes , eCanJITNo }

typedef std::map< lldb::LanguageType, lldb::LanguageRuntimeSP >	LanguageRuntimeCollection

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

Protected Types inherited from lldb_private::Broadcaster
typedef std::shared_ptr< BroadcasterImpl >	BroadcasterImplSP

typedef std::weak_ptr< BroadcasterImpl >	BroadcasterImplWP

Protected Member Functions
virtual JITLoaderList &	GetJITLoaders ()

	Process (lldb::TargetSP target_sp, lldb::ListenerSP listener_sp)
	Construct with a shared pointer to a target, and the Process listener.

	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.

virtual llvm::Expected< TraceSupportedResponse >	TraceSupported ()
	Get the processor tracing type supported for this process.

virtual llvm::Error	TraceStart (const llvm::json::Value &request)
	Start tracing a process or its threads.

virtual llvm::Error	TraceStop (const TraceStopRequest &request)
	Stop tracing a live process or its threads.

virtual llvm::Expected< std::string >	TraceGetState (llvm::StringRef type)
	Get the current tracing state of the process and its threads.

virtual llvm::Expected< std::vector< uint8_t > >	TraceGetBinaryData (const TraceGetBinaryDataRequest &request)
	Get binary data given a trace technology and a data identifier.

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.

virtual size_t	DoReadMemory (lldb::addr_t vm_addr, void *buf, size_t size, Status &error)=0
	Actually do the reading of memory from a process.

virtual Status	DoGetMemoryRegionInfo (lldb::addr_t load_addr, MemoryRegionInfo &range_info)
	DoGetMemoryRegionInfo is called by GetMemoryRegionInfo after it has removed non address bits from load_addr.

virtual std::optional< bool >	DoGetWatchpointReportedAfter ()
	Provide an override value in the subclass for lldb's CPU-based logic for whether watchpoint exceptions are received before or after an instruction executes.

lldb::StateType	GetPrivateState ()

Status	PrivateResume ()
	The "private" side of resuming a process.

void	CompleteAttach ()

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.

bool	RouteAsyncStructuredData (const StructuredData::ObjectSP object_sp)
	Route the incoming structured data dictionary to the right plugin.

virtual bool	SupportsMemoryTagging ()
	Check whether the process supports memory tagging.

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.

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.

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< Target >	m_target_wp
	The target that owns this process.

lldb::pid_t	m_pid = LLDB_INVALID_PROCESS_ID

ThreadSafeValue< lldb::StateType >	m_public_state

ThreadSafeValue< lldb::StateType >	m_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.

ProcessModID	m_mod_id
	Tracks the state of the process over stops and other alterations.

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.

uint32_t	m_thread_index_id
	Each thread is created with a 1 based index that won't get re-used.

std::map< uint64_t, uint32_t >	m_thread_id_to_index_id_map

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

std::string	m_exit_string
	A textual description of why a process exited.

std::mutex	m_exit_status_mutex
	Mutex so m_exit_status m_exit_string can be safely accessed from multiple threads.

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.

ThreadList	m_thread_list
	The threads for this process as the user will see them.

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.

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

uint32_t	m_extended_thread_stop_id
	The natural stop id when extended_thread_list was last updated.

QueueList	m_queue_list
	The list of libdispatch queues at a given stop point.

uint32_t	m_queue_list_stop_id
	The natural stop id when queue list was last fetched.

std::vector< Notifications >	m_notifications
	The list of notifications that this process can deliver.

std::vector< lldb::addr_t >	m_image_tokens

lldb::ListenerSP	m_listener_sp
	Shared pointer to the listener used for public events.

BreakpointSiteList	m_breakpoint_site_list
	This is the list of breakpoint locations we intend to insert in the target.

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.

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.

lldb::IOHandlerSP	m_process_input_reader

ThreadedCommunication	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.

std::string	m_stderr_data

std::recursive_mutex	m_profile_data_comm_mutex

std::vector< std::string >	m_profile_data

Predicate< uint32_t >	m_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?

std::recursive_mutex	m_language_runtimes_mutex

InstrumentationRuntimeCollection	m_instrumentation_runtimes

std::unique_ptr< NextEventAction >	m_next_event_action_up

std::vector< PreResumeCallbackAndBaton >	m_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.

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_t >	m_resolved_indirect_addresses
	This helps with the Public event coalescing in ShouldBroadcastEvent.

bool	m_destroy_in_process

bool	m_can_interpret_function_calls

std::mutex	m_run_thread_plan_lock

StructuredDataPluginMap	m_structured_data_plugin_map

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

std::unique_ptr< UtilityFunction >	m_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.

lldb::addr_t	m_data_address_mask = 0

lldb::addr_t	m_highmem_code_address_mask = 0

lldb::addr_t	m_highmem_data_address_mask = 0

Protected Attributes inherited from lldb_private::ProcessProperties
Process *	m_process

std::unique_ptr< ProcessExperimentalProperties >	m_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.

void	ControlPrivateStateThread (uint32_t signal)

Status	LaunchPrivate (ProcessLaunchInfo &launch_info, lldb::StateType &state, lldb::EventSP &event_sp)

	Process (const Process &)=delete

const Process &	operator= (const Process &)=delete

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 331 of file Process.h.

Member Typedef Documentation

◆ LanguageRuntimeCollection

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

protected

Definition at line 2898 of file Process.h.

◆ LoadRange

typedef Range<lldb::addr_t, lldb::addr_t> lldb_private::Process::LoadRange

Definition at line 361 of file Process.h.

◆ PreResumeActionCallback

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

Definition at line 2405 of file Process.h.

◆ StopLocker

typedef ProcessRunLock::ProcessRunLocker lldb_private::Process::StopLocker

Definition at line 368 of file Process.h.

◆ StructuredDataPluginMap

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

protected

Definition at line 2911 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 346 of file Process.h.

◆ anonymous enum

anonymous enum

Enumerator
eBroadcastInternalStateControlStop
eBroadcastInternalStateControlPause
eBroadcastInternalStateControlResume

Definition at line 355 of file Process.h.

◆ anonymous enum

anonymous enum

protected

Enumerator
eCanJITDontKnow
eCanJITYes
eCanJITNo

Definition at line 3038 of file Process.h.

Constructor & Destructor Documentation

◆ ~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 506 of file Process.cpp.

References lldb_private::ThreadList::Clear(), lldb_private::GetLog(), LLDB_LOGF, m_thread_list, lldb_private::Object, and StopPrivateStateThread().

◆ Process() [1/3]

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

protected

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
	)

protected

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

◆ 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 5857 of file Process.cpp.

References m_image_tokens.

Referenced by PlatformPOSIX::DoLoadImage(), and lldb_private::PlatformWindows::DoLoadImage().

◆ AddInvalidMemoryRegion()

void Process::AddInvalidMemoryRegion ( const LoadRange & region )

Definition at line 5606 of file Process.cpp.

References lldb_private::MemoryCache::AddInvalidRange(), lldb_private::Range< B, S >::GetByteSize(), lldb_private::Range< B, S >::GetRangeBase(), and m_memory_cache.

Referenced by lldb_private::DynamicLoaderDarwin::UpdateImageLoadAddress().

◆ AddPreResumeAction()

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

Definition at line 5615 of file Process.cpp.

References m_pre_resume_actions.

Referenced by lldb_private::AppleThreadPlanStepThroughObjCTrampoline::DidPush().

◆ 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_addr	The address of the instruction where lldb would put a breakpoint normally.
[in]	range_bounds	The 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 5874 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]	size	The size of the allocation requested.
[in]	permissions	Or 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]	error	An 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 2282 of file Process.cpp.

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

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

◆ AppendSTDERR()

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

protected

Definition at line 4282 of file Process.cpp.

References lldb_private::Broadcaster::BroadcastEventIfUnique(), eBroadcastBitSTDERR, GetState(), m_stderr_data, and m_stdio_communication_mutex.

◆ AppendSTDOUT()

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

protected

Definition at line 4275 of file Process.cpp.

References lldb_private::Broadcaster::BroadcastEventIfUnique(), eBroadcastBitSTDOUT, GetState(), m_stdio_communication_mutex, and m_stdout_data.

Referenced by lldb_private::process_gdb_remote::ProcessGDBRemote::HandleAsyncStdout(), and STDIOReadThreadBytesReceived().

◆ AssignIndexIDToThread()

uint32_t Process::AssignIndexIDToThread ( uint64_t thread_id )

Definition at line 1298 of file Process.cpp.

References m_thread_id_to_index_id_map, and m_thread_index_id.

Referenced by GetNextThreadIndexID(), and lldb_private::process_gdb_remote::ProcessGDBRemote::HarmonizeThreadIdsForProfileData().

◆ 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_info The process attach info.

Returns: Returns pid if attaching was successful, or LLDB_INVALID_PROCESS_ID if attaching fails.

Definition at line 2813 of file Process.cpp.

◆ BroadcastAsyncProfileData()

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

protected

Definition at line 4289 of file Process.cpp.

References lldb_private::Broadcaster::BroadcastEventIfUnique(), eBroadcastBitProfileData, GetState(), m_profile_data, and m_profile_data_comm_mutex.

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

◆ 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_sp	The structured data object to broadcast.
[in]	plugin_sp	The plugin that will be reported in the event's plugin parameter.

Definition at line 4296 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_ctx A reference to an execution context object that gets filled in.

Implements lldb_private::ExecutionContextScope.

Definition at line 4249 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 2376 of file Process.h.

◆ CalculateStackFrame()

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

inlineoverridevirtual

Implements lldb_private::ExecutionContextScope.

Definition at line 2380 of file Process.h.

◆ CalculateTarget()

lldb::TargetSP Process::CalculateTarget ( )

overridevirtual

Implements lldb_private::ExecutionContextScope.

Definition at line 4247 of file Process.cpp.

References m_target_wp.

Referenced by lldb_private::AppleObjCRuntimeV2::GetDynamicTypeAndAddress(), lldb_private::ThreadPlanAssemblyTracer::GetIntPointerType(), and lldb_private::ProcessWindows::OnExitProcess().

◆ CalculateThread()

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

inlineoverridevirtual

Implements lldb_private::ExecutionContextScope.

Definition at line 2378 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]	size	The size of the allocation requested.
[in]	permissions	Or 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]	error	An 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 2305 of file Process.cpp.

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

Referenced by PlatformPOSIX::DoLoadImage().

◆ CallVoidArgVoidPtrReturn()

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

protected

Definition at line 6101 of file Process.cpp.

References lldb_private::StackFrame::CalculateExecutionContext(), lldb::eBasicTypeVoid, lldb::eExpressionCompleted, lldb::eLanguageTypeC, GetAddressByteSize(), lldb_private::CompilerType::GetBasicTypeFromAST(), lldb_private::ThreadList::GetExpressionExecutionThread(), lldb_private::CompilerType::GetPointerType(), lldb_private::Target::GetScratchTypeSystemForLanguage(), lldb_private::Thread::GetStackFrameAtIndex(), GetTarget(), GetThreadList(), lldb_private::ProcessProperties::GetUtilityExpressionTimeout(), LLDB_INVALID_ADDRESS, RunThreadPlan(), lldb_private::EvaluateExpressionOptions::SetDebug(), lldb_private::EvaluateExpressionOptions::SetIgnoreBreakpoints(), lldb_private::EvaluateExpressionOptions::SetStopOthers(), lldb_private::EvaluateExpressionOptions::SetTimeout(), lldb_private::EvaluateExpressionOptions::SetTrapExceptions(), lldb_private::EvaluateExpressionOptions::SetTryAllThreads(), lldb_private::EvaluateExpressionOptions::SetUnwindOnError(), UINT32_MAX, and UINT64_MAX.

Referenced by ResolveIndirectFunction().

◆ 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::ProcessTrace, ProcessElfCore, ProcessFreeBSDKernel, lldb_private::process_gdb_remote::ProcessGDBRemote, ProcessMachCore, ProcessKDP, lldb_private::minidump::ProcessMinidump, lldb_private::ScriptedProcess, and lldb_private::ProcessWindows.

◆ 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 1910 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 2315 of file Process.cpp.

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

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

◆ ClearBreakpointSiteByID()

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

Definition at line 1596 of file Process.cpp.

References DisableBreakpointSiteByID(), error(), m_breakpoint_site_list, and lldb_private::BreakpointSiteList::Remove().

Referenced by DynamicLoaderDarwinKernel::Clear(), and SystemRuntimeMacOSX::Clear().

◆ ClearPreResumeAction()

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

Definition at line 5634 of file Process.cpp.

References m_pre_resume_actions.

◆ ClearPreResumeActions()

void Process::ClearPreResumeActions ( )

Definition at line 5632 of file Process.cpp.

References m_pre_resume_actions.

◆ CompleteAttach()

void Process::CompleteAttach ( )

protected

Definition at line 2934 of file Process.cpp.

References lldb_private::ThreadList::Clear(), lldb_private::ArchSpec::CompatibleMatch, lldb_private::JITLoaderList::DidAttach(), lldb_private::SystemRuntime::DidAttach(), lldb_private::DynamicLoader::DidAttach(), DidAttach(), lldb_private::eLoadDependentsNo, lldb_private::ProcessInfo::GetArchitecture(), lldb_private::Target::GetArchitecture(), lldb_private::Debugger::GetAsyncErrorStream(), lldb_private::Target::GetDebugger(), GetDynamicLoader(), lldb_private::Target::GetExecutableModule(), GetID(), GetJITLoaders(), lldb_private::GetLog(), lldb_private::PlatformList::GetOrCreate(), lldb_private::Debugger::GetPlatformList(), lldb_private::PluginInterface::GetPluginName(), GetProcessInfo(), GetSystemArchitecture(), GetSystemRuntime(), GetTarget(), lldb_private::ArchSpec::GetTriple(), lldb_private::ArchSpec::IsCompatibleMatch(), lldb_private::ArchSpec::IsExactMatch(), lldb_private::ArchSpec::IsValid(), LLDB_LOG, LLDB_LOGF, LoadOperatingSystemPlugin(), m_os_up, m_thread_list, m_unix_signals_sp, lldb_private::Modules, lldb_private::Process, lldb_private::Target::SetArchitecture(), lldb_private::Target::SetExecutableModule(), lldb_private::Target::SetPlatform(), lldb_private::Target, lldb_private::Target::UpdateSignalsFromDummy(), and UpdateThreadListIfNeeded().

Referenced by ConnectRemote(), DidExec(), and lldb_private::Process::AttachCompletionHandler::PerformAction().

◆ 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_name	The StructuredData type name as previously discovered by the Process-derived instance.
[in]	config_sp	Configuration 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 5966 of file Process.cpp.

◆ ConnectRemote()

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

virtual

Attach to a remote system via a URL.

Parameters

[in] remote_url The URL format that we are connecting to.

Returns: Returns an error object.

Definition at line 3064 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

Definition at line 3632 of file Process.cpp.

References lldb_private::Broadcaster::BroadcastEvent(), eBroadcastInternalStateControlPause, eBroadcastInternalStateControlResume, eBroadcastInternalStateControlStop, lldb_private::GetLog(), lldb_private::ProcessProperties::GetUtilityExpressionTimeout(), lldb_private::HostThread::IsJoinable(), lldb_private::HostThread::Join(), LLDB_LOGF, m_private_state_control_broadcaster, m_private_state_thread, PrivateStateThreadIsValid(), lldb_private::Process, and lldb_private::HostThread::Reset().

Referenced by PausePrivateStateThread(), ResumePrivateStateThread(), and StopPrivateStateThread().

◆ CreateBreakpointSite()

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

Definition at line 1633 of file Process.cpp.

References lldb_private::BreakpointSiteList::Add(), lldb_private::Address::CalculateSymbolContextSymbol(), EnableBreakpointSite(), error(), 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::BreakpointSiteList::FindByAddress(), lldb_private::Symbol::GetAddress(), lldb_private::Target::GetDebugger(), lldb_private::Debugger::GetErrorStream(), lldb_private::Symbol::GetLoadAddress(), lldb_private::Address::GetOpcodeLoadAddress(), GetState(), GetTarget(), IsAlive(), lldb_private::Symbol::IsIndirect(), LLDB_INVALID_ADDRESS, LLDB_INVALID_BREAK_ID, m_breakpoint_site_list, lldb_private::Stream::Printf(), and ResolveIndirectFunction().

Referenced by lldb_private::BreakpointLocation::ResolveBreakpointSite().

◆ CreateOSPluginThread()

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

Definition at line 1282 of file Process.cpp.

References lldb_private::OperatingSystem::CreateThread(), and GetOperatingSystem().

◆ CurrentThreadIsPrivateStateThread()

bool Process::CurrentThreadIsPrivateStateThread ( )

Definition at line 5651 of file Process.cpp.

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

Referenced by GetState().

◆ DeallocateMemory()

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

The public interface to deallocating memory in the process.

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

Parameters

[in] ptr A return value from AllocateMemory, pointing to the memory you want to deallocate.

Returns: true if the memory was deallocated, false otherwise.

Definition at line 2353 of file Process.cpp.

References lldb_private::AllocatedMemoryCache::DeallocateMemory(), DoDeallocateMemory(), error(), lldb_private::GetLog(), lldb_private::ProcessModID::GetMemoryID(), lldb_private::ProcessModID::GetStopID(), LLDB_LOGF, m_allocated_memory_cache, m_mod_id, and lldb_private::Process.

Referenced by CanJIT(), lldb_private::FunctionCaller::DeallocateFunctionResults(), lldb_private::AppleGetItemInfoHandler::Detach(), lldb_private::AppleGetPendingItemsHandler::Detach(), lldb_private::AppleGetQueuesHandler::Detach(), lldb_private::AppleGetThreadItemInfoHandler::Detach(), PlatformPOSIX::DoLoadImage(), lldb_private::PlatformWindows::DoLoadImage(), lldb_private::AppleObjCRuntimeV2::SharedCacheClassInfoExtractor::UpdateISAToDescriptorMap(), and lldb_private::AppleObjCRuntimeV2::DynamicClassInfoExtractor::UpdateISAToDescriptorMap().

◆ 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_kill Whether 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 3302 of file Process.cpp.

References DestroyImpl(), and m_finalizing.

Referenced by CommandObjectProcessKill::DoExecute(), Halt(), LaunchPrivate(), 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 1183 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_stopped If true, don't resume the process on detach.

Returns: Returns an error object.

Definition at line 3250 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 1152 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_arch If 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 lldb_private::ProcessTrace, lldb_private::process_gdb_remote::ProcessGDBRemote, lldb_private::ScriptedProcess, lldb_private::ProcessWindows, and ProcessKDP.

Definition at line 989 of file Process.h.

References lldb_private::ArchSpec::Clear().

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

◆ DidDestroy()

virtual void lldb_private::Process::DidDestroy ( )

inlinevirtual

Definition at line 1181 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 1150 of file Process.h.

Referenced by Detach().

◆ DidExec()

void Process::DidExec ( )

virtual

Called after a process re-execs itself.

Allow Process plug-ins to execute some code after a process has exec'ed itself. Subclasses typically should override DoDidExec() as the lldb_private::Process class needs to remove its dynamic loader, runtime, ABI and other plug-ins, as well as unload all shared libraries.

Reimplemented in lldb_private::process_gdb_remote::ProcessGDBRemote.

Definition at line 5691 of file Process.cpp.

References lldb_private::Target::CleanupProcess(), lldb_private::MemoryCache::Clear(), lldb_private::AllocatedMemoryCache::Clear(), lldb_private::Target::ClearModules(), CompleteAttach(), lldb_private::Target::DidExec(), lldb_private::ThreadList::DiscardThreadPlans(), DoDidExec(), Flush(), lldb_private::GetLog(), GetTarget(), LLDB_LOGF, m_abi_sp, m_allocated_memory_cache, m_dyld_up, m_dynamic_checkers_up, m_image_tokens, m_instrumentation_runtimes, m_jit_loaders_up, m_language_runtimes, m_language_runtimes_mutex, m_memory_cache, m_os_up, m_system_runtime_up, m_thread_list, and lldb_private::Process.

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

◆ DidExit()

virtual void lldb_private::Process::DidExit ( )

inlinevirtual

Reimplemented in lldb_private::process_gdb_remote::ProcessGDBRemote.

Definition at line 1371 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 1004 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 1122 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 1052 of file Process.h.

Referenced by LaunchPrivate().

◆ 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.

Reimplemented in lldb_private::ScriptedProcess.

Definition at line 1087 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 1189 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 1007 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 1010 of file Process.h.

◆ DisableAllBreakpointSites()

void Process::DisableAllBreakpointSites ( )

Definition at line 1589 of file Process.cpp.

References DisableBreakpointSite(), lldb_private::BreakpointSiteList::ForEach(), and m_breakpoint_site_list.

Referenced by DestroyImpl(), and Detach().

◆ DisableBreakpointSite()

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

inlinevirtual

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

Definition at line 2066 of file Process.h.

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

Referenced by DisableAllBreakpointSites(), DisableBreakpointSiteByID(), lldb_private::ThreadPlanStepOverBreakpoint::DoWillResume(), and RemoveOwnerFromBreakpointSite().

◆ DisableBreakpointSiteByID()

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

Definition at line 1605 of file Process.cpp.

References DisableBreakpointSite(), error(), lldb_private::BreakpointSiteList::FindByID(), and m_breakpoint_site_list.

Referenced by ClearBreakpointSiteByID().

◆ DisableSoftwareBreakpoint()

Status Process::DisableSoftwareBreakpoint ( BreakpointSite * bp_site )

virtual

Definition at line 1847 of file Process.cpp.

References lldb_private::Breakpoints, DoReadMemory(), DoWriteMemory(), error(), lldb_private::StoppointSite::GetByteSize(), lldb_private::StoppointSite::GetID(), lldb_private::StoppointSite::GetLoadAddress(), lldb_private::GetLog(), lldb_private::BreakpointSite::GetSavedOpcodeBytes(), lldb_private::BreakpointSite::GetTrapOpcodeBytes(), lldb_private::BreakpointSite::IsEnabled(), lldb_private::BreakpointSite::IsHardware(), LLDB_LOGF, and lldb_private::BreakpointSite::SetEnabled().

Referenced by lldb_private::process_gdb_remote::ProcessGDBRemote::DisableBreakpointSite(), lldb_private::ProcessWindows::DisableBreakpointSite(), and ProcessKDP::DisableBreakpointSite().

◆ DisableWatchpoint()

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

virtual

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

Definition at line 2441 of file Process.cpp.

References error().

◆ 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] size The 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 ProcessKDP, lldb_private::process_gdb_remote::ProcessGDBRemote, and lldb_private::ProcessWindows.

Definition at line 1671 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]	pid	The process ID that we should attempt to attach to.
[in]	attach_info	Information 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 ProcessKDP, lldb_private::ProcessWindows, lldb_private::process_gdb_remote::ProcessGDBRemote, and lldb_private::ScriptedProcess.

Definition at line 951 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_name	The name of the process to attach to.
[in]	attach_info	Information 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 ProcessKDP, lldb_private::process_gdb_remote::ProcessGDBRemote, and lldb_private::ScriptedProcess.

Definition at line 974 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_url The 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 931 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] ptr A return value from AllocateMemory, pointing to the memory you want to deallocate.

Returns: true if the memory was deallocated, false otherwise.

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

Definition at line 1939 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

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

Referenced by DestroyImpl().

◆ 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 1138 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 1001 of file Process.h.

Referenced by DidExec().

◆ DoGetMemoryRegionInfo()

virtual Status lldb_private::Process::DoGetMemoryRegionInfo	(	lldb::addr_t	load_addr,
		MemoryRegionInfo &	range_info
	)

inlineprotectedvirtual

DoGetMemoryRegionInfo is called by GetMemoryRegionInfo after it has removed non address bits from load_addr.

Override this method in subclasses of Process.

See GetMemoryRegionInfo for details of the logic.

Parameters

[in]	load_addr	The load address to query the range_info for. (non address bits removed)
[out]	range_info	An range_info value containing the details of the range.

Returns: An error value.

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

Definition at line 2700 of file Process.h.

Referenced by GetMemoryRegionInfo().

◆ DoGetWatchpointReportedAfter()

virtual std::optional< bool > lldb_private::Process::DoGetWatchpointReportedAfter ( )

inlineprotectedvirtual

Provide an override value in the subclass for lldb's CPU-based logic for whether watchpoint exceptions are received before or after an instruction executes.

If a Process subclass needs to override this architecture-based result, it may do so by overriding this method.

Returns: No boolean returned means there is no override of the default architecture-based behavior. true is returned for targets where watchpoints are reported after the instruction has completed. false is returned for targets where watchpoints are reported before the instruction executes.

Reimplemented in lldb_private::process_gdb_remote::ProcessGDBRemote.

Definition at line 2719 of file Process.h.

Referenced by GetWatchpointReportedAfter().

◆ 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_stop If 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 1112 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_module	The module from which to extract the file specification and launch.
[in]	launch_info	Details (e.g. arguments, stdio redirection, etc.) for the requested launch.

Returns: An Status instance indicating success or failure of the operation.

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

Definition at line 1042 of file Process.h.

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

Referenced by LaunchPrivate().

◆ DoLoadCore()

virtual Status lldb_private::Process::DoLoadCore ( )

inlinevirtual

Reimplemented in ProcessElfCore, ProcessFreeBSDKernel, ProcessMachCore, lldb_private::minidump::ProcessMinidump, and lldb_private::ScriptedProcess.

Definition at line 601 of file Process.h.

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

Referenced by LoadCore().

◆ 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_addr	A virtual load address that indicates where to start reading memory from.
[in]	size	The number of bytes to read.
[out]	buf	A byte buffer that is at least size bytes long that will receive the memory bytes.
[out]	error	An 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 ProcessElfCore, ProcessMachCore, ProcessKDP, lldb_private::ProcessTrace, lldb_private::process_gdb_remote::ProcessGDBRemote, lldb_private::minidump::ProcessMinidump, lldb_private::ScriptedProcess, and lldb_private::ProcessWindows.

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]	addr	Start of address range to read memory tags for.
[in]	len	Length of the memory range to read tags for (in bytes).
[in]	type	Type 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 2863 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 1077 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 1169 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 ProcessElfCore, ProcessFreeBSDKernel, ProcessMachCore, ProcessKDP, lldb_private::ProcessTrace, lldb_private::process_gdb_remote::ProcessGDBRemote, lldb_private::minidump::ProcessMinidump, lldb_private::ScriptedProcess, and lldb_private::ProcessWindows.

Referenced by UpdateThreadList().

◆ DoWillAttachToProcessWithID()

virtual Status lldb_private::Process::DoWillAttachToProcessWithID ( 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 902 of file Process.h.

Referenced by WillAttachToProcessWithID().

◆ DoWillAttachToProcessWithName()

virtual Status lldb_private::Process::DoWillAttachToProcessWithName	(	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 919 of file Process.h.

Referenced by WillAttachToProcessWithName().

◆ DoWillLaunch()

virtual Status lldb_private::Process::DoWillLaunch ( 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 ProcessKDP, and lldb_private::process_gdb_remote::ProcessGDBRemote.

Definition at line 1023 of file Process.h.

Referenced by WillLaunch().

◆ 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_addr	A virtual load address that indicates where to start writing memory to.
[in]	buf	A byte buffer that is at least size bytes long that contains the data to write.
[in]	size	The number of bytes to write.
[out]	error	An error value in case the memory write fails.

Returns: The number of bytes that were actually written.

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

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]	addr	Start of address range to write memory tags for.
[in]	len	Length of the memory range to write tags for (in bytes).
[in]	type	Type of tags to read (get this from a MemoryTagManager)
[in]	tags	Packed tags to be written.

Returns: Status telling you whether the write succeeded.

Reimplemented in lldb_private::process_gdb_remote::ProcessGDBRemote.

Definition at line 2888 of file Process.h.

References lldb_private::PluginInterface::GetPluginName(), and lldb_private::Status::SetErrorStringWithFormatv().

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]	strm	The stream to which to dump the output
[in]	desc_level	How much detail to dump
[in]	internal	If true dump all plans, if false only user initiated plans
[in]	condense_trivial	If true, only dump a header if the plan stack is just the base plan.
[in]	skip_unreported_plans	If true, skip printing all thread plan stacks that don't currently have a backing lldb_private::Thread *.

Definition at line 1262 of file Process.cpp.

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

Referenced by CommandObjectThreadPlanList::DoExecute().

◆ 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]	strm	The stream to which to dump the output
[in]	tid	The tid whose Plan Stack we are dumping
[in]	desc_level	How much detail to dump
[in]	internal	If true dump all plans, if false only user initiated plans
[in]	condense_trivial	If true, only dump a header if the plan stack is just the base plan.
[in]	skip_unreported_plans	If 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 1255 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

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

Definition at line 2059 of file Process.h.

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

Referenced by CreateBreakpointSite(), EnableBreakpointSiteByID(), and lldb_private::ThreadPlanStepOverBreakpoint::ReenableBreakpointSite().

◆ EnableBreakpointSiteByID()

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

Definition at line 1619 of file Process.cpp.

References EnableBreakpointSite(), error(), lldb_private::BreakpointSiteList::FindByID(), and m_breakpoint_site_list.

◆ EnableSoftwareBreakpoint()

Status Process::EnableSoftwareBreakpoint ( BreakpointSite * bp_site )

virtual

◆ EnableWatchpoint()

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

virtual

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

Definition at line 2435 of file Process.cpp.

References error().

◆ ExecutionResultAsCString()

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

static

Definition at line 5503 of file Process.cpp.

References lldb::eExpressionCompleted, lldb::eExpressionDiscarded, lldb::eExpressionHitBreakpoint, lldb::eExpressionInterrupted, lldb::eExpressionParseError, lldb::eExpressionResultUnavailable, lldb::eExpressionSetupError, lldb::eExpressionStoppedForDebug, lldb::eExpressionThreadVanished, and lldb::eExpressionTimedOut.

Referenced by lldb_private::LLVMUserExpression::DoExecute(), and lldb_private::FunctionCaller::ExecuteFunction().

◆ Finalize()

void Process::Finalize ( )

virtual

This object is about to be destroyed, do any necessary cleanup.

Subclasses that override this method should always call this superclass method.

Definition at line 525 of file Process.cpp.

References lldb_private::QueueList::Clear(), lldb_private::ThreadPlanStackMap::Clear(), lldb_private::Broadcaster::Clear(), lldb_private::MemoryCache::Clear(), lldb_private::AllocatedMemoryCache::Clear(), lldb_private::ThreadList::Destroy(), DestroyImpl(), m_abi_sp, m_allocated_memory_cache, m_dyld_up, m_dynamic_checkers_up, m_extended_thread_list, m_finalizing, m_image_tokens, m_instrumentation_runtimes, m_jit_loaders_up, m_language_runtimes, m_language_runtimes_mutex, m_memory_cache, m_mod_id, m_next_event_action_up, m_notifications, m_os_up, m_private_run_lock, m_private_state_listener_sp, m_public_run_lock, m_queue_list, m_queue_list_stop_id, m_structured_data_plugin_map, m_system_runtime_up, m_thread_list, m_thread_list_real, m_thread_plans, lldb_private::ProcessModID::SetStopEventForLastNaturalStopID(), lldb_private::ProcessRunLock::SetStopped(), and lldb_private::ProcessRunLock::TrySetRunning().

Referenced by ProcessElfCore::~ProcessElfCore(), lldb_private::process_gdb_remote::ProcessGDBRemote::~ProcessGDBRemote(), ProcessKDP::~ProcessKDP(), ProcessMachCore::~ProcessMachCore(), lldb_private::minidump::ProcessMinidump::~ProcessMinidump(), lldb_private::ProcessTrace::~ProcessTrace(), and lldb_private::ScriptedProcess::~ScriptedProcess().

◆ 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 372 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] tid The tid whose Plan Stack we are seeking.

Returns: Returns a ThreadPlan if the TID is found or nullptr if not.

Definition at line 1243 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 5657 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(), ObjectFileMachO::LoadCoreFileImages(), LoadOperatingSystemPlugin(), and lldb_private::ProcessProperties::SetDisableLangRuntimeUnwindPlans().

◆ ForceNextEventDelivery()

void lldb_private::Process::ForceNextEventDelivery ( )

inlineprotected

Definition at line 2794 of file Process.h.

References m_force_next_event_delivery.

Referenced by RunThreadPlan().

◆ ForceScriptedState()

virtual void lldb_private::Process::ForceScriptedState ( lldb::StateType state )

inlinevirtual

Reimplemented in lldb_private::ScriptedProcess.

Definition at line 2568 of file Process.h.

◆ GetABI()

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

Definition at line 1502 of file Process.cpp.

References lldb_private::ABI::FindPlugin(), GetTarget(), and m_abi_sp.

Referenced by lldb_private::ThreadPlanStepOut::CalculateReturnValue(), lldb_private::StopInfoMachException::DeterminePtrauthFailure(), CommandObjectMemoryTagRead::DoExecute(), CommandObjectMemoryTagWrite::DoExecute(), CommandObjectTargetModulesShowUnwind::DoExecute(), lldb_private::DWARFExpression::Evaluate(), lldb_private::AppleObjCRuntimeV2::TaggedPointerVendorRuntimeAssisted::GetClassDescriptor(), lldb_private::AppleObjCRuntimeV2::GetClassDescriptor(), lldb_private::ObjCLanguageRuntime::GetClassDescriptorFromISA(), lldb_private::RegisterContextUnwind::GetFullUnwindPlanForFrame(), GetMemoryRegionInfo(), GetMemoryRegions(), lldb_private::RegisterContextUnwind::InitializeNonZerothFrame(), lldb_private::RegisterContextUnwind::InitializeZerothFrame(), lldb_private::ThreadPlanAssemblyTracer::Log(), DynamicLoaderMacOS::NotifyBreakpointHit(), DynamicLoaderMacOSXDYLD::NotifyBreakpointHit(), lldb_private::ClassDescriptorV2::objc_class_t::Read(), lldb_private::ClassDescriptorV2::class_rw_t::Read(), lldb_private::ClassDescriptorV2::method_list_t::Read(), ProcessElfCore::ReadMemory(), lldb_private::ProcessTrace::ReadMemory(), ReadMemory(), ReadMemoryFromInferior(), lldb_private::AppleObjCTrampolineHandler::AppleObjCVTables::RefreshTrampolines(), ResolveIndirectFunction(), lldb_private::RegisterContextUnwind::SavedLocationForRegister(), lldb_private::ThreadPlanCallFunction::SetReturnValue(), lldb_private::ThreadPlanCallFunctionUsingABI::SetReturnValue(), and WriteMemory().

◆ GetAddressByteSize()

uint32_t Process::GetAddressByteSize ( ) const

Definition at line 3404 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(), CommandObjectMemoryFind::DoExecute(), CommandObjectProcessMinidumpDump::DoExecute(), PlatformPOSIX::DoLoadImage(), lldb_private::PlatformWindows::DoLoadImage(), lldb_private::ScriptedProcess::DoWriteMemory(), CommandObjectRegisterRead::DumpRegister(), lldb_private::AppleObjCRuntimeV2::NonPointerISACache::EvaluateNonPointerISA(), ExtractRuntimeGlobalSymbol(), lldb_private::CPPLanguageRuntime::FindLibCppStdFunctionCallableInfo(), ABIMacOSX_arm64::GetArgumentValues(), ABISysV_arm64::GetArgumentValues(), ABIMacOSX_arm::GetArgumentValues(), ABISysV_arm::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(), lldb_private::ItaniumABILanguageRuntime::GetExceptionObjectForThread(), SystemRuntimeMacOSX::GetExtendedBacktraceFromItemRef(), SystemRuntimeMacOSX::GetExtendedBacktraceThread(), lldb_private::formatters::InferiorSizedWord::GetMaximum(), SystemRuntimeMacOSX::GetPendingItemRefsForQueue(), ABIMacOSX_arm64::GetReturnValueObjectImpl(), ABISysV_arm64::GetReturnValueObjectImpl(), DynamicLoaderMacOSXDYLD::GetSharedCacheInformation(), lldb_private::ClassDescriptorV2::ivar_t::GetSize(), lldb_private::ClassDescriptorV2::method_t::GetSize(), 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::ivar_list_t::Read(), lldb_private::ClassDescriptorV2::ivar_t::Read(), lldb_private::ClassDescriptorV2::method_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::SharedCacheClassInfoExtractor::UpdateISAToDescriptorMap(), lldb_private::AppleObjCRuntimeV2::DynamicClassInfoExtractor::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]	buf	A buffer that will receive any profile data bytes that are currently available.
[out]	buf_size	The 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 4312 of file Process.cpp.

References lldb_private::GetLog(), LLDB_LOGF, m_profile_data, m_profile_data_comm_mutex, and lldb_private::Process.

◆ GetAuxvData()

DataExtractor Process::GetAuxvData ( )

virtual

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

Definition at line 2697 of file Process.cpp.

Referenced by DynamicLoaderPOSIXDYLD::DidAttach(), and DynamicLoaderPOSIXDYLD::DidLaunch().

◆ GetBreakpointSiteList() [1/2]

BreakpointSiteList & Process::GetBreakpointSiteList ( )

Definition at line 1581 of file Process.cpp.

References m_breakpoint_site_list.

Referenced by lldb_private::ThreadPlanStepUntil::AnalyzeStop(), lldb_private::process_gdb_remote::ProcessGDBRemote::DidForkSwitchHardwareTraps(), lldb_private::process_gdb_remote::ProcessGDBRemote::DidForkSwitchSoftwareBreakpoints(), CommandObjectProcessContinue::DoExecute(), lldb_private::ThreadPlanCallFunction::DoPlanExplainsStop(), lldb_private::ThreadPlanStepOut::DoPlanExplainsStop(), lldb_private::ThreadPlanStepOverBreakpoint::DoWillResume(), lldb_private::ItaniumABILanguageRuntime::ExceptionBreakpointsExplainStop(), lldb_private::AppleObjCRuntime::ExceptionBreakpointsExplainStop(), lldb::SBThread::GetStopReasonDataAtIndex(), lldb::SBThread::GetStopReasonDataCount(), lldb_private::ThreadPlanStepThrough::HitOurBackstopBreakpoint(), lldb_private::ThreadPlanStepRange::NextRangeBreakpointExplainsStop(), lldb_private::ThreadPlanStepOverBreakpoint::ReenableBreakpointSite(), and lldb_private::ProcessWindows::RefreshStateAfterStop().

◆ GetBreakpointSiteList() [2/2]

const BreakpointSiteList & Process::GetBreakpointSiteList ( ) const

Definition at line 1585 of file Process.cpp.

References m_breakpoint_site_list.

◆ 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 381 of file Process.h.

References GetStaticBroadcasterClass().

◆ GetByteOrder()

lldb::ByteOrder Process::GetByteOrder ( ) const

Definition at line 3400 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::ScriptedProcess::DoWriteMemory(), 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(), lldb_private::ItaniumABILanguageRuntime::GetExceptionObjectForThread(), 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::ivar_list_t::Read(), lldb_private::ClassDescriptorV2::ivar_t::Read(), lldb_private::ClassDescriptorV2::method_t::Read(), lldb_private::RegisterContextUnwind::ReadFrameAddress(), ReadJITEntry(), SystemRuntimeMacOSX::ReadLibdispatchOffsets(), SystemRuntimeMacOSX::ReadLibpthreadOffsets(), ReadScalarIntegerFromMemory(), lldb_private::RegisterContextUnwind::SavedLocationForRegister(), DynamicLoaderDarwinKernel::SearchForKernelWithDebugHints(), lldb_private::process_gdb_remote::ProcessGDBRemote::SetThreadPc(), lldb_private::AppleObjCRuntimeV2::SharedCacheClassInfoExtractor::UpdateISAToDescriptorMap(), lldb_private::AppleObjCRuntimeV2::DynamicClassInfoExtractor::UpdateISAToDescriptorMap(), lldb_private::AppleObjCRuntimeV1::UpdateISAToDescriptorMapIfNeeded(), and WriteScalarToMemory().

◆ GetCodeAddressMask()

lldb::addr_t Process::GetCodeAddressMask ( )

Definition at line 5665 of file Process.cpp.

References lldb_private::ProcessProperties::GetVirtualAddressableBits(), and m_code_address_mask.

Referenced by CommandObjectProcessStatus::DoExecute(), GetHighmemCodeAddressMask(), and DynamicLoaderDarwinKernel::LoadKernelModuleIfNeeded().

◆ GetDataAddressMask()

lldb::addr_t Process::GetDataAddressMask ( )

Definition at line 5672 of file Process.cpp.

References lldb_private::ProcessProperties::GetVirtualAddressableBits(), and m_data_address_mask.

Referenced by CommandObjectProcessStatus::DoExecute(), GetHighmemDataAddressMask(), and DynamicLoaderDarwinKernel::LoadKernelModuleIfNeeded().

◆ GetDynamicCheckers()

DynamicCheckerFunctions * lldb_private::Process::GetDynamicCheckers ( )

inline

Definition at line 2276 of file Process.h.

References m_dynamic_checkers_up.

Referenced by lldb_private::ThreadPlanCallUserExpression::GetRealStopInfo(), and lldb_private::ClangExpressionParser::PrepareForExecution().

◆ 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::ProcessTrace, ProcessElfCore, ProcessFreeBSDKernel, lldb_private::process_gdb_remote::ProcessGDBRemote, ProcessMachCore, ProcessKDP, lldb_private::minidump::ProcessMinidump, lldb_private::ScriptedProcess, and lldb_private::ProcessWindows.

Definition at line 2687 of file Process.cpp.

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

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

◆ GetDynamicLoaderProcessState()

virtual lldb_private::StructuredData::ObjectSP lldb_private::Process::GetDynamicLoaderProcessState ( )

inlinevirtual

Reimplemented in lldb_private::process_gdb_remote::ProcessGDBRemote.

Definition at line 1334 of file Process.h.

Referenced by DynamicLoaderMacOS::IsFullyInitialized().

◆ GetEventsPrivate()

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

protected

Definition at line 1033 of file Process.cpp.

References lldb_private::GetLog(), LLDB_LOG, m_private_state_control_broadcaster, m_private_state_listener_sp, and lldb_private::Process.

Referenced by RunPrivateStateThread().

◆ 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 1058 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 1050 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

Definition at line 2132 of file Process.h.

References m_extended_thread_list.

Referenced by lldb_private::AppleObjCRuntime::GetBacktraceThreadFromException(), and lldb::SBThread::GetExtendedBacktraceThread().

◆ 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]	file	The name of the file whose load address we are looking for
[out]	is_loaded	True if the file is loaded into the memory and false otherwise.
[out]	load_addr	The 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 2467 of file Process.h.

Referenced by lldb_private::DynamicLoaderWindowsDYLD::GetLoadAddress(), and DYLDRendezvous::UpdateBaseAddrIfNecessary().

◆ GetGlobalProperties()

ProcessProperties & Process::GetGlobalProperties ( )

static

Definition at line 517 of file Process.cpp.

References ProcessProperties.

Referenced by lldb_private::ProcessProperties::ProcessProperties(), and lldb_private::TargetProperties::TargetProperties().

◆ GetHighmemCodeAddressMask()

lldb::addr_t Process::GetHighmemCodeAddressMask ( )

Definition at line 5679 of file Process.cpp.

References GetCodeAddressMask(), and lldb_private::ProcessProperties::GetHighmemVirtualAddressableBits().

◆ GetHighmemDataAddressMask()

lldb::addr_t Process::GetHighmemDataAddressMask ( )

Definition at line 5685 of file Process.cpp.

References GetDataAddressMask(), and lldb_private::ProcessProperties::GetHighmemVirtualAddressableBits().

◆ GetHistoryThreads()

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

Definition at line 5825 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 1217 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 1214 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 530 of file Process.h.

References m_pid.

◆ 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 ProcessElfCore, lldb_private::process_gdb_remote::ProcessGDBRemote, ProcessMachCore, ProcessKDP, and lldb_private::ProcessWindows.

Definition at line 1500 of file Process.cpp.

References LLDB_INVALID_ADDRESS.

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

◆ GetImagePtrFromToken()

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

Definition at line 5862 of file Process.cpp.

References LLDB_INVALID_ADDRESS, and m_image_tokens.

Referenced by PlatformPOSIX::UnloadImage(), and lldb_private::PlatformWindows::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 736 of file Process.h.

References m_image_tokens.

Referenced by CommandObjectProcessUnload::HandleArgumentCompletion().

◆ GetImplementation()

virtual void * lldb_private::Process::GetImplementation ( )

inlinevirtual

Reimplemented in lldb_private::ScriptedProcess.

Definition at line 2566 of file Process.h.

◆ GetInstrumentationRuntime()

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

Definition at line 5842 of file Process.cpp.

References m_instrumentation_runtimes.

◆ GetIOHandlerID()

uint32_t lldb_private::Process::GetIOHandlerID ( ) const

inline

Definition at line 2183 of file Process.h.

References lldb_private::Predicate< T >::GetValue(), and m_iohandler_sync.

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

◆ GetJITLoaders()

JITLoaderList & Process::GetJITLoaders ( )

protectedvirtual

Reimplemented in lldb_private::minidump::ProcessMinidump.

Definition at line 2703 of file Process.cpp.

References lldb_private::JITLoader::LoadPlugins(), and m_jit_loaders_up.

Referenced by CompleteAttach(), LaunchPrivate(), LoadCore(), and ModulesDidLoad().

◆ GetLanguageRuntime()

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

Definition at line 1528 of file Process.cpp.

References lldb_private::LanguageRuntime::FindPlugin(), lldb_private::LanguageRuntime::GetLanguageType(), lldb_private::Language::GetPrimaryLanguage(), m_finalizing, m_language_runtimes, and m_language_runtimes_mutex.

Referenced by lldb_private::CPPLanguageRuntime::Get(), lldb_private::ObjCLanguageRuntime::Get(), lldb_private::AppleObjCRuntime::GetExceptionObjectForThread(), GetLanguageRuntimes(), lldb_private::ValueObject::GetObjectDescription(), IsPossibleDynamicValue(), lldb_private::ValueObject::IsRuntimeSupportValue(), ModulesDidLoad(), lldb_private::ThreadPlanCallFunction::SetBreakpoints(), and lldb_private::ValueObjectDynamicValue::UpdateValue().

◆ GetLanguageRuntimes()

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

Definition at line 1508 of file Process.cpp.

References GetLanguageRuntime(), lldb_private::Language::GetSupportedLanguages(), m_finalizing, and m_language_runtimes_mutex.

Referenced by IsPossibleDynamicValue(), and lldb_private::ThreadPlanStepThrough::LookForPlanToStepThroughFromCurrentPC().

◆ GetLastNaturalStopID()

uint32_t lldb_private::Process::GetLastNaturalStopID ( ) const

inline

Definition at line 1411 of file Process.h.

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

Referenced by UpdateQueueListIfNeeded(), and UpdateThreadListIfNeeded().

◆ GetLastUserExpressionResumeID()

uint32_t lldb_private::Process::GetLastUserExpressionResumeID ( ) const

inline

Definition at line 1407 of file Process.h.

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

◆ 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_addr	The address of interest in the process.
[out]	permissions	If 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 2410 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, and lldb_private::ScriptedProcess.

Definition at line 1308 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 1314 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_address	The 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_count	The 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 1300 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 674 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]	platform	The platform fetching the UtilityFunction.
[in]	factory	A 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 6084 of file Process.cpp.

References GetTarget(), m_dlopen_utility_func_flag_once, and m_dlopen_utility_func_up.

Referenced by PlatformPOSIX::DoLoadImage(), and lldb_private::PlatformWindows::DoLoadImage().

◆ GetMemoryRegionInfo()

Status Process::GetMemoryRegionInfo	(	lldb::addr_t	load_addr,
		MemoryRegionInfo &	range_info
	)

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 calls DoGetMemoryRegionInfo. Override that function in process subclasses.

Parameters

[in]	load_addr	The load address to query the range_info for. May include non address bits, these will be removed by the the ABI plugin if there is one.
[out]	range_info	An range_info value containing the details of the range.

Returns: An error value.

Definition at line 5922 of file Process.cpp.

References DoGetMemoryRegionInfo(), and GetABI().

Referenced by lldb_private::process_gdb_remote::ProcessGDBRemote::DoWriteMemory(), lldb_private::process_gdb_remote::ProcessGDBRemote::FlashErase(), GetLoadAddressPermissions(), GetMemoryRegions(), DynamicLoaderPOSIXDYLD::LoadInterpreterModule(), DynamicLoaderPOSIXDYLD::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_list A vector to contain MemoryRegionInfo objects for all mapped ranges.

Returns: An error value.

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

Definition at line 5929 of file Process.cpp.

References error(), lldb_private::MemoryRegionInfo::eYes, GetABI(), 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 6159 of file Process.cpp.

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

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

◆ GetMetadata()

virtual StructuredData::DictionarySP lldb_private::Process::GetMetadata ( )

inlinevirtual

Fetch process defined metadata.

Returns: A StructuredDataSP object which, if non-empty, will contain the information related to the process.

Reimplemented in lldb_private::ScriptedProcess.

Definition at line 2477 of file Process.h.

Referenced by lldb_private::PlatformDarwin::ExtractAppSpecificInfo().

◆ 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 1399 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 1401 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_spec	The file name of the module to get specification for.
[in]	arch	The architecture of the module to get specification for.
[out]	module_spec	The 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 5851 of file Process.cpp.

References lldb_private::ModuleSpec::Clear().

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

◆ GetNextEvent()

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

Definition at line 628 of file Process.cpp.

References lldb::eStateInvalid, lldb_private::Process::ProcessEventData::GetStateFromEvent(), and m_listener_sp.

◆ GetNextThreadIndexID()

uint32_t Process::GetNextThreadIndexID ( uint64_t thread_id )

Definition at line 1289 of file Process.cpp.

References AssignIndexIDToThread().

◆ GetOperatingSystem()

OperatingSystem * lldb_private::Process::GetOperatingSystem ( )

inline

Definition at line 2266 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 576 of file Process.h.

Referenced by CommandObjectProcessPlugin::GetProxyCommandObject().

◆ GetPrivateState()

StateType Process::GetPrivateState ( )

protected

Definition at line 1429 of file Process.cpp.

References lldb_private::ThreadSafeValue< T >::GetValue(), and m_private_state.

Referenced by AllocateMemory(), lldb_private::process_gdb_remote::ProcessGDBRemote::AsyncThread(), lldb_private::ProcessWindows::DidAttach(), lldb_private::ProcessWindows::DoDestroy(), lldb_private::ProcessWindows::DoDetach(), lldb_private::ProcessWindows::DoHalt(), lldb_private::ProcessWindows::DoResume(), lldb_private::ProcessWindows::IsAlive(), UpdateQueueListIfNeeded(), UpdateThreadListIfNeeded(), and WaitForProcessToStop().

◆ GetProcessInfo()

bool Process::GetProcessInfo ( ProcessInstanceInfo & info )

virtual

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

Definition at line 5815 of file Process.cpp.

References lldb_private::ProcessInstanceInfo::Clear(), GetID(), lldb_private::Target::GetPlatform(), and GetTarget().

Referenced by CompleteAttach(), and DynamicLoaderPOSIXDYLD::ResolveExecutableModule().

◆ GetQueueList()

QueueList & lldb_private::Process::GetQueueList ( )

inline

Definition at line 2152 of file Process.h.

References m_queue_list, and UpdateQueueListIfNeeded().

◆ GetResumeID()

uint32_t lldb_private::Process::GetResumeID ( ) const

inline

Definition at line 1405 of file Process.h.

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

◆ GetRunLock()

ProcessRunLock & Process::GetRunLock ( )

Definition at line 5644 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.

◆ GetSharedCacheInfo()

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

inlinevirtual

Reimplemented in lldb_private::process_gdb_remote::ProcessGDBRemote.

Definition at line 1325 of file Process.h.

Referenced by lldb_private::AppleObjCRuntimeV2::GetSharedCacheBaseAddress(), and DynamicLoaderMacOS::GetSharedCacheInformation().

◆ GetShouldDetach()

bool lldb_private::Process::GetShouldDetach ( ) const

inline

Definition at line 728 of file Process.h.

References m_should_detach.

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

◆ GetSoftwareBreakpointTrapOpcode()

size_t Process::GetSoftwareBreakpointTrapOpcode ( BreakpointSite * bp_site )

Definition at line 1764 of file Process.cpp.

References GetTarget().

Referenced by lldb_private::process_gdb_remote::ProcessGDBRemote::DisableBreakpointSite(), lldb_private::process_gdb_remote::ProcessGDBRemote::EnableBreakpointSite(), and EnableSoftwareBreakpoint().

◆ GetState()

StateType Process::GetState ( )

Get accessor for the current process state.

Returns: The current state of the process.

See also: lldb::StateType

Definition at line 1312 of file Process.cpp.

References CurrentThreadIsPrivateStateThread(), lldb_private::ThreadSafeValue< T >::GetValue(), m_private_state, and m_public_state.

Referenced by CommandObjectTargetSymbolsAdd::AddSymbolsForFrame(), CommandObjectTargetSymbolsAdd::AddSymbolsForStack(), AppendSTDERR(), AppendSTDOUT(), BroadcastAsyncProfileData(), lldb_private::CommandObject::CheckRequirements(), CreateBreakpointSite(), CommandObjectProcessContinue::DoExecute(), CommandObjectThreadContinue::DoExecute(), CommandObjectProcessKDPPacketSend::DoExecute(), lldb_private::Process::ProcessEventData::Dump(), lldb_private::UserExpression::Evaluate(), GetStatus(), lldb_private::Value::GetValueAsData(), Halt(), HandlePrivateEvent(), lldb_private::FunctionCaller::InsertFunction(), lldb_private::ClangUtilityFunction::Install(), lldb_private::CommandInterpreter::IOHandlerInterrupt(), DynamicLoaderDarwinKernel::PrivateInitialize(), lldb_private::DynamicLoaderDarwin::PrivateInitialize(), DynamicLoaderMacOSXDYLD::SetNotificationBreakpoint(), DynamicLoaderDarwinKernel::SetNotificationBreakpointIfNeeded(), lldb_private::Thread::StepIn(), lldb_private::Thread::StepOut(), lldb_private::Thread::StepOver(), StopForDestroyOrDetach(), CommandObjectProcessLaunchOrAttach::StopProcessIfNecessary(), WaitForProcessToStop(), and lldb_private::FunctionCaller::WriteFunctionWrapper().

◆ GetStateChangedEvents()

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

Definition at line 971 of file Process.cpp.

References eBroadcastBitInterrupt, eBroadcastBitStateChanged, lldb::eStateInvalid, lldb_private::GetLog(), lldb_private::Process::ProcessEventData::GetStateFromEvent(), LLDB_LOG, m_listener_sp, and lldb_private::Process.

Referenced by WaitForProcessToStop().

◆ GetStateChangedEventsPrivate()

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

protected

Definition at line 1015 of file Process.cpp.

References eBroadcastBitInterrupt, eBroadcastBitStateChanged, lldb::eStateInvalid, lldb_private::GetLog(), lldb_private::Process::ProcessEventData::GetStateFromEvent(), LLDB_LOG, m_private_state_broadcaster, m_private_state_listener_sp, lldb_private::Process, and lldb_private::StateAsCString().

Referenced by WaitForProcessStopPrivate().

◆ GetStaticBroadcasterClass()

ConstString & Process::GetStaticBroadcasterClass ( )

static

Definition at line 413 of file Process.cpp.

Referenced by lldb_private::Debugger::DefaultEventHandler(), lldb::SBProcess::GetBroadcasterClass(), GetBroadcasterClass(), and lldb::SBProcess::GetBroadcasterClassName().

◆ GetStatus()

void Process::GetStatus ( Stream & ostrm )

Definition at line 5540 of file Process.cpp.

References lldb::eStateConnected, lldb::eStateExited, GetExitDescription(), GetExitStatus(), GetID(), GetState(), lldb_private::Stream::Printf(), lldb_private::StateAsCString(), and lldb_private::StateIsStoppedState().

Referenced by CommandObjectProcessStatus::DoExecute(), and CommandObjectThreadList::DoExecute().

◆ 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]	buf	A buffer that will receive any STDERR bytes that are currently available.
[out]	buf_size	The 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 4356 of file Process.cpp.

References lldb_private::GetLog(), LLDB_LOGF, m_stderr_data, m_stdio_communication_mutex, and lldb_private::Process.

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]	buf	A buffer that will receive any STDOUT bytes that are currently available.
[in]	buf_size	The 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 4337 of file Process.cpp.

References lldb_private::GetLog(), LLDB_LOGF, m_stdio_communication_mutex, m_stdout_data, and lldb_private::Process.

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

◆ GetStopEventForStopID()

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

inline

Definition at line 1415 of file Process.h.

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

◆ GetStopID()

uint32_t lldb_private::Process::GetStopID ( ) const

inline

Definition at line 1403 of file Process.h.

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

Referenced by DynamicLoaderMacOS::AddBinaries(), lldb_private::DynamicLoaderDarwin::AddModulesUsingImageInfos(), DynamicLoaderMacOSXDYLD::AddModulesUsingImageInfosAddress(), DynamicLoaderMacOS::DoInitialImageFetch(), lldb_private::process_gdb_remote::ProcessGDBRemote::HandleStopReply(), DynamicLoaderMacOSXDYLD::InitializeFromAllImageInfos(), DynamicLoaderDarwinKernel::KextImageInfo::LoadImageAtFileAddress(), DynamicLoaderDarwinKernel::KextImageInfo::LoadImageUsingMemoryModule(), DynamicLoaderDarwinKernel::LoadKernelModuleIfNeeded(), DynamicLoaderMacOS::NotifyBreakpointHit(), DynamicLoaderDarwinKernel::ParseKextSummaries(), DynamicLoaderMacOSXDYLD::ReadAllImageInfosStructure(), lldb_private::Trace::RefreshLiveProcessState(), DynamicLoaderMacOSXDYLD::RemoveModulesUsingImageInfosAddress(), lldb_private::process_gdb_remote::ProcessGDBRemote::SetThreadStopInfo(), lldb_private::DynamicLoaderDarwin::UnloadAllImages(), lldb_private::DynamicLoaderDarwin::UnloadImages(), lldb_private::DynamicLoaderDarwin::UpdateImageLoadAddress(), lldb_private::ObjCLanguageRuntime::UpdateISAToDescriptorMap(), lldb_private::AppleObjCRuntimeV1::UpdateISAToDescriptorMapIfNeeded(), lldb_private::AppleObjCRuntimeV2::UpdateISAToDescriptorMapIfNeeded(), UpdateThreadListIfNeeded(), and lldb_private::ThreadList::WillResume().

◆ 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 4304 of file Process.cpp.

References m_structured_data_plugin_map.

◆ GetSystemArchitecture()

virtual ArchSpec lldb_private::Process::GetSystemArchitecture ( )

inlinevirtual

Get the system architecture for this process.

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

Definition at line 694 of file Process.h.

Referenced by CompleteAttach(), and lldb_private::Platform::GetRemoteSharedModule().

◆ GetSystemRuntime()

SystemRuntime * Process::GetSystemRuntime ( )

virtual

Get the system runtime plug-in for this process.

Returns: Returns a pointer to the SystemRuntime plugin for this Process if one is available. Else returns nullptr.

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

Definition at line 2711 of file Process.cpp.

References lldb_private::SystemRuntime::FindPlugin(), and m_system_runtime_up.

Referenced by CompleteAttach(), lldb::SBThread::GetExtendedBacktraceThread(), lldb_private::process_gdb_remote::ProcessGDBRemote::GetExtendedInfoForThread(), LaunchPrivate(), LoadCore(), ModulesDidLoad(), and lldb_private::Thread::SafeToCallFunctions().

◆ 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 1224 of file Process.h.

References m_target_wp.

◆ 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 1231 of file Process.h.

References m_target_wp.

◆ GetThreadList()

ThreadList & lldb_private::Process::GetThreadList ( )

inline

Definition at line 2126 of file Process.h.

References m_thread_list.

◆ 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
	)

Definition at line 5560 of file Process.cpp.

References lldb_private::GetLog(), lldb_private::ThreadList::GetSize(), lldb_private::ThreadList::GetThreadAtIndex(), GetThreadList(), LLDB_LOGF, and lldb_private::Process.

Referenced by CommandObjectProcessStatus::DoExecute(), and CommandObjectThreadList::DoExecute().

◆ GetUniqueID()

uint32_t lldb_private::Process::GetUniqueID ( ) const

inline

Definition at line 537 of file Process.h.

References m_process_unique_id.

Referenced by lldb_private::StructuredDataDarwinLog::AddInitCompletionHook(), and lldb_private::StructuredDataDarwinLog::ModulesDidLoad().

◆ GetUnixSignals()

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

Definition at line 3395 of file Process.cpp.

References m_unix_signals_sp.

Referenced by lldb_private::process_gdb_remote::ProcessGDBRemote::AsyncThread(), CommandObjectProcessSignal::DoExecute(), ProcessElfCore::DoLoadCore(), CommandObjectProcessSignal::HandleArgumentCompletion(), and lldb_private::process_gdb_remote::ThreadGDBRemote::WillResume().

◆ GetWatchpointReportedAfter()

bool Process::GetWatchpointReportedAfter ( )

Whether lldb will be notified about watchpoints after the instruction has completed executing, or if the instruction is rolled back and it is notified before it executes.

The default behavior is "exceptions received after instruction has executed", except for certain CPU architectures. Process subclasses may override this if they have additional information.

Returns: Returns true for targets where lldb is notified after the instruction has completed executing.

Definition at line 2373 of file Process.cpp.

References DoGetWatchpointReportedAfter(), lldb_private::Target::GetArchitecture(), GetTarget(), lldb_private::ArchSpec::GetTriple(), and lldb_private::ArchSpec::IsValid().

◆ GetWatchpointSlotCount()

virtual std::optional< uint32_t > lldb_private::Process::GetWatchpointSlotCount ( )

inlinevirtual

Get the number of watchpoints supported by this target.

We may be able to determine the number of watchpoints available on this target; retrieve this value if possible.

This number may be less than the number of watchpoints a user can specify. This is because a single user watchpoint may require multiple watchpoint slots to implement. Due to the size and/or alignment of objects.

Returns: Returns the number of watchpoints, if available.

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

Definition at line 1848 of file Process.h.

◆ 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_plans	If true, when the process stops, clear all thread plans.
[in]	use_run_lock	Whether 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 3152 of file Process.cpp.

References lldb_private::Broadcaster::BroadcastEvent(), Destroy(), DoNoSelectMostRelevantFrame, 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(), SelectMostRelevantFrame, SendAsyncInterrupt(), SetExitStatus(), SIGKILL, lldb_private::StateAsCString(), lldb_private::StateIsRunningState(), and WaitForProcessToStop().

Referenced by CommandObjectProcessInterrupt::DoExecute(), lldb_private::CommandInterpreter::IOHandlerInterrupt(), and RunThreadPlan().

◆ HaltPrivate()

Status Process::HaltPrivate ( )

protected

Definition at line 3801 of file Process.cpp.

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

Referenced by RunPrivateStateThread().

◆ HandlePrivateEvent()

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

protected

Definition at line 3690 of file Process.cpp.

References lldb_private::Broadcaster::BroadcastEvent(), lldb_private::eBroadcastAlways, eBroadcastBitStateChanged, lldb_private::Process::NextEventAction::eEventActionExit, lldb_private::Process::NextEventAction::eEventActionRetry, lldb_private::Process::NextEventAction::eEventActionSuccess, lldb::eStateAttaching, lldb::eStateExited, lldb::eStateLaunching, GetID(), lldb_private::GetLog(), lldb_private::Process::ProcessEventData::GetRestartedFromEvent(), GetState(), lldb_private::Process::ProcessEventData::GetStateFromEvent(), GetTarget(), lldb_private::Predicate< T >::GetValue(), lldb_private::Broadcaster::IsHijackedForEvent(), LLDB_LOGF, m_iohandler_sync, m_next_event_action_up, m_resume_requested, PopProcessIOHandler(), lldb_private::Process, PushProcessIOHandler(), SetExitStatus(), SetNextEventAction(), lldb_private::Process::ProcessEventData::SetUpdateStateOnRemoval(), lldb_private::Predicate< T >::SetValue(), ShouldBroadcastEvent(), lldb_private::StateAsCString(), lldb_private::StateIsRunningState(), and lldb_private::StateIsStoppedState().

Referenced by ConnectRemote(), Launch(), LaunchPrivate(), RunPrivateStateThread(), and WaitForProcessStopPrivate().

◆ HandleProcessStateChangedEvent()

bool Process::HandleProcessStateChangedEvent	(	const lldb::EventSP &	event_sp,
		Stream *	stream,
		SelectMostRelevant	select_most_relevant,
		bool &	pop_process_io_handler
	)

static

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

Parameters

[in]	event_sp	The process state changed event
[in]	stream	The output stream to get the state change description
[in,out]	pop_process_io_handler	If 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 728 of file Process.cpp.

References lldb::eDescriptionLevelBrief, lldb_private::ValueObject::eGetExpressionPathFormatHonorPointers, 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 )

Definition at line 1293 of file Process.cpp.

References m_thread_id_to_index_id_map.

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

◆ 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_sp This 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 961 of file Process.cpp.

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

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

◆ IsAlive()

bool Process::IsAlive ( )

virtual

Check if a process is still alive.

Returns: Returns true if the process is still valid, false otherwise.

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

Definition at line 1102 of file Process.cpp.

References lldb::eStateAttaching, lldb::eStateConnected, lldb::eStateCrashed, lldb::eStateLaunching, lldb::eStateRunning, lldb::eStateStepping, lldb::eStateStopped, lldb::eStateSuspended, lldb_private::ThreadSafeValue< T >::GetValue(), and m_private_state.

Referenced by DynamicLoaderDarwinKernel::Clear(), SystemRuntimeMacOSX::Clear(), lldb_private::AllocatedMemoryCache::Clear(), CreateBreakpointSite(), lldb_private::AppleGetItemInfoHandler::Detach(), lldb_private::AppleGetPendingItemsHandler::Detach(), lldb_private::AppleGetQueuesHandler::Detach(), lldb_private::AppleGetThreadItemInfoHandler::Detach(), CommandObjectProcessConnect::DoExecute(), lldb_private::ValueObjectVariable::DoUpdateChildrenAddressType(), lldb_private::Value::GetValueAsData(), lldb_private::process_gdb_remote::ProcessGDBRemote::IsAlive(), ProcessKDP::IsAlive(), JITLoaderGDB::ModulesDidLoad(), lldb_private::DynamicLoaderDarwin::PrivateProcessStateChanged(), RemoveOwnerFromBreakpointSite(), lldb_private::TargetList::SignalIfRunning(), CommandObjectProcessLaunchOrAttach::StopProcessIfNecessary(), and lldb_private::ValueObjectVariable::UpdateValue().

◆ IsLiveDebugSession()

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

inlinevirtual

Reimplemented in lldb_private::PostMortemProcess.

Definition at line 1441 of file Process.h.

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

◆ IsPossibleDynamicValue()

bool Process::IsPossibleDynamicValue ( ValueObject & in_value )

Definition at line 1556 of file Process.cpp.

References lldb_private::LanguageRuntime::CouldHaveDynamicValue(), lldb::eLanguageTypeC, lldb::eLanguageTypeUnknown, GetLanguageRuntime(), GetLanguageRuntimes(), lldb_private::ValueObject::GetObjectRuntimeLanguage(), lldb_private::ValueObject::IsDynamic(), and m_finalizing.

Referenced by lldb_private::ValueObject::CalculateDynamicValue(), lldb_private::ValueObjectConstResult::GetDynamicValue(), and lldb_private::ValueObject::IsPossibleDynamicType().

◆ IsRunning()

bool Process::IsRunning ( ) const

Definition at line 1046 of file Process.cpp.

References lldb_private::ThreadSafeValue< T >::GetValue(), m_public_state, and lldb_private::StateIsRunningState().

◆ 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 562 of file Process.h.

References m_finalizing.

Referenced by lldb_private::ScriptedThread::Create(), and lldb_private::process_gdb_remote::ProcessGDBRemote::DoConnectRemote().

◆ 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_info Details 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 2477 of file Process.cpp.

References lldb::eStateCrashed, lldb::eStateInvalid, lldb::eStateStopped, lldb_private::Status::Fail(), lldb_private::ProcessLaunchInfo::GetFlags(), HandlePrivateEvent(), LaunchPrivate(), PrivateStateThreadIsValid(), ResumePrivateStateThread(), SetPublicState(), StartPrivateStateThread(), and lldb_private::Flags::Test().

◆ LaunchPrivate()

Status Process::LaunchPrivate	(	ProcessLaunchInfo &	launch_info,
		lldb::StateType &	state,
		lldb::EventSP &	event_sp
	)

private

Definition at line 2509 of file Process.cpp.

References Destroy(), lldb_private::JITLoaderList::DidLaunch(), DidLaunch(), lldb_private::SystemRuntime::DidLaunch(), lldb_private::DynamicLoader::DidLaunch(), DoLaunch(), error(), lldb::eStateCrashed, lldb::eStateExited, lldb::eStateInvalid, lldb::eStateLaunching, lldb::eStateStopped, lldb_private::Debugger::GetAsyncErrorStream(), lldb_private::Target::GetDebugger(), GetDynamicLoader(), lldb_private::ProcessInfo::GetExecutableFile(), lldb_private::Target::GetExecutableModulePointer(), lldb_private::Module::GetFileSpec(), GetID(), GetJITLoaders(), lldb_private::FileSpec::GetPath(), GetSystemRuntime(), GetTarget(), HandlePrivateEvent(), HijackProcessEvents(), lldb_private::Target::Install(), lldb_private::FileSystem::Instance(), lldb_private::ProcessInfo::IsScriptedProcess(), 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, m_unix_signals_sp, lldb_private::Listener::MakeListener(), PausePrivateStateThread(), PrivateStateThreadIsValid(), RestoreProcessEvents(), SetExitStatus(), SetID(), SetPublicState(), lldb_private::StateAsCString(), lldb_private::ProcessRunLock::TrySetRunning(), UpdateAutomaticSignalFiltering(), lldb_private::Target::UpdateSignalsFromDummy(), WaitForProcessStopPrivate(), and WillLaunch().

Referenced by Launch().

◆ LoadCore()

◆ 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 666 of file Process.h.

Referenced by lldb_private::wasm::DynamicLoaderWasmDYLD::DidAttach(), lldb_private::DynamicLoaderWindowsDYLD::DidAttach(), and lldb_private::DynamicLoaderWindowsDYLD::DidLaunch().

◆ LoadOperatingSystemPlugin()

void Process::LoadOperatingSystemPlugin ( bool flush )

protected

Definition at line 2469 of file Process.cpp.

References lldb_private::ThreadList::Clear(), lldb_private::OperatingSystem::FindPlugin(), Flush(), m_os_up, and m_thread_list.

Referenced by CompleteAttach(), LaunchPrivate(), LoadCore(), lldb_private::DynamicLoader::LoadOperatingSystemPlugin(), ModulesDidLoad(), and lldb_private::ProcessProperties::ProcessProperties().

◆ 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_names An 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 5974 of file Process.cpp.

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

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

◆ ModulesDidLoad()

void Process::ModulesDidLoad ( ModuleList & module_list )

virtual

Reimplemented in lldb_private::process_gdb_remote::ProcessGDBRemote.

Definition at line 5757 of file Process.cpp.

References GetJITLoaders(), GetLanguageRuntime(), lldb_private::Language::GetSupportedLanguages(), GetSystemRuntime(), LoadOperatingSystemPlugin(), m_instrumentation_runtimes, m_os_up, m_structured_data_plugin_map, lldb_private::SystemRuntime::ModulesDidLoad(), lldb_private::InstrumentationRuntime::ModulesDidLoad(), and lldb_private::JITLoaderList::ModulesDidLoad().

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

◆ operator=()

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

privatedelete

◆ PausePrivateStateThread()

void Process::PausePrivateStateThread ( )

protected

Definition at line 3613 of file Process.cpp.

References ControlPrivateStateThread(), and eBroadcastInternalStateControlPause.

Referenced by LaunchPrivate().

◆ PeekAtStateChangedEvents()

Event * Process::PeekAtStateChangedEvents ( )

Definition at line 995 of file Process.cpp.

References eBroadcastBitStateChanged, lldb_private::GetLog(), lldb_private::Process::ProcessEventData::GetStateFromEvent(), LLDB_LOGF, m_listener_sp, lldb_private::Process, and lldb_private::StateAsCString().

◆ PopProcessIOHandler()

bool Process::PopProcessIOHandler ( )

protected

Definition at line 4567 of file Process.cpp.

References lldb_private::Target::GetDebugger(), GetTarget(), m_process_input_reader, and lldb_private::Debugger::RemoveIOHandler().

Referenced by HandlePrivateEvent().

◆ PrefetchModuleSpecs()

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

inlinevirtual

Reimplemented in lldb_private::process_gdb_remote::ProcessGDBRemote.

Definition at line 2450 of file Process.h.

Referenced by DynamicLoaderPOSIXDYLD::LoadAllCurrentModules().

◆ 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] sc A SymbolContext with eSymbolContextFunction and eSymbolContextModule pre-computed.

Definition at line 5791 of file Process.cpp.

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

◆ PrintWarningUnsupportedLanguage()

void Process::PrintWarningUnsupportedLanguage ( const SymbolContext & sc )

Print a user-visible warning about a function written in a language that this version of LLDB doesn't support.

See also: PrintWarningOptimization

Definition at line 5799 of file Process.cpp.

References lldb::eLanguageTypeUnknown, lldb_private::PluginManager::GetAllTypeSystemSupportedLanguagesForTypes(), GetID(), lldb_private::SymbolContext::GetLanguage(), GetTarget(), lldb_private::ProcessProperties::GetWarningsUnsupportedLanguage(), and lldb_private::SymbolContext::module_sp.

◆ PrivateResume()

Status Process::PrivateResume ( )

protected

The "private" side of resuming a process.

This doesn't alter the state of m_run_lock, but just causes the process to resume.

Returns: An Status object describing the success or failure of the resume.

Definition at line 3096 of file Process.cpp.

References lldb_private::ProcessModID::BumpResumeID(), DidResume(), lldb_private::ThreadList::DidResume(), DoResume(), error(), lldb::eStateRunning, lldb::eStateStopped, lldb_private::GetLog(), lldb_private::ProcessModID::GetStopID(), lldb_private::ThreadSafeValue< T >::GetValue(), LLDB_LOGF, m_mod_id, m_private_state, m_public_state, m_thread_list, lldb_private::Process, RunPreResumeActions(), SetPrivateState(), lldb_private::StateAsCString(), lldb_private::Step, UpdateAutomaticSignalFiltering(), WillResume(), and lldb_private::ThreadList::WillResume().

Referenced by Resume(), ResumeSynchronous(), RunThreadPlan(), and ShouldBroadcastEvent().

◆ PrivateStateThreadIsValid()

bool lldb_private::Process::PrivateStateThreadIsValid ( ) const

inlineprotected

Definition at line 2788 of file Process.h.

References lldb::eStateDetached, lldb::eStateExited, lldb::eStateInvalid, lldb_private::ThreadSafeValue< T >::GetValue(), lldb_private::HostThread::IsJoinable(), m_private_state, and m_private_state_thread.

Referenced by ConnectRemote(), ControlPrivateStateThread(), Launch(), LaunchPrivate(), LoadCore(), SendAsyncInterrupt(), and StartPrivateStateThread().

◆ ProcessIOHandlerExists()

bool lldb_private::Process::ProcessIOHandlerExists ( ) const

inlineprotected

Definition at line 3104 of file Process.h.

References m_process_input_reader.

◆ ProcessIOHandlerIsActive()

bool Process::ProcessIOHandlerIsActive ( )

protected

Definition at line 4542 of file Process.cpp.

References lldb_private::Target::GetDebugger(), GetTarget(), lldb_private::Debugger::IsTopIOHandler(), and m_process_input_reader.

◆ PruneThreadPlans()

void Process::PruneThreadPlans ( )

Prune ThreadPlanStacks for all unreported threads.

Definition at line 1251 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] tid The tid whose Plan Stack we are seeking to prune.

Returns: true if the TID is found or false if not.

Definition at line 1247 of file Process.cpp.

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

Referenced by CommandObjectThreadPlanPrune::DoExecute().

◆ PushProcessIOHandler()

bool Process::PushProcessIOHandler ( )

protected

Definition at line 4548 of file Process.cpp.

References lldb_private::Target::GetDebugger(), lldb_private::GetLog(), GetTarget(), lldb_private::ProcessModID::IsRunningUtilityFunction(), LLDB_LOGF, m_mod_id, m_process_input_reader, lldb_private::Process, and lldb_private::Debugger::RunIOHandlerAsync().

Referenced by HandlePrivateEvent().

◆ 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]	buf	A buffer that contains the data to write to the process's STDIN.
[in]	buf_size	The 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 2036 of file Process.h.

References error().

◆ Queues()

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

inline

Definition at line 2157 of file Process.h.

References m_queue_list, lldb_private::QueueList::Queues(), and UpdateQueueListIfNeeded().

◆ 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 2007 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 PlatformPOSIX::DoLoadImage(), lldb_private::PlatformWindows::DoLoadImage(), ProcessFreeBSDKernel::DoUpdateThreadList(), lldb_private::PlatformDarwin::ExtractCrashInfoAnnotations(), lldb_private::AppleObjCRuntime::GetObjectDescription(), SystemRuntimeMacOSX::GetQueueNameFromThreadQAddress(), lldb_private::ClassDescriptorV2::class_ro_t::Read(), lldb_private::ClassDescriptorV2::ivar_t::Read(), lldb_private::ClassDescriptorV2::method_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 1985 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_addr	A virtual load address that indicates where to start reading memory from.
[out]	buf	A byte buffer that is at least size bytes long that will receive the memory bytes.
[in]	size	The number of bytes to read.
[out]	error	An 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 ProcessElfCore, ProcessMachCore, lldb_private::ProcessTrace, and lldb_private::minidump::ProcessMinidump.

Definition at line 1941 of file Process.cpp.

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

◆ 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_addr	A virtual load address that indicates where to start reading memory from.
[out]	buf	A byte buffer that is at least size bytes long that will receive the memory bytes.
[in]	size	The number of bytes to read.
[out]	error	An 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 2053 of file Process.cpp.

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

Referenced by lldb_private::PlatformDarwin::ExtractCrashInfoAnnotations(), lldb_private::MemoryCache::GetL2CacheLine(), 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
	)

virtual

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]	addr	Start of memory range to read tags for.
[in]	len	Length 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.

Reimplemented in ProcessElfCore.

Definition at line 6178 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`
	)

Definition at line 2390 of file Process.cpp.

References error(), lldb_private::GetLog(), lldb_private::FileSpec::GetPath(), lldb_private::Host, and LLDB_LOGF.

Referenced by lldb_private::DynamicLoaderDarwin::AddModulesUsingImageInfos(), DynamicLoaderDarwinKernel::CheckForKernelImageAtAddress(), lldb_private::DynamicLoaderDarwin::FindTargetModuleForImageInfo(), lldb_private::wasm::DynamicLoaderWasmDYLD::LoadModuleAtAddress(), DynamicLoaderPOSIXDYLD::LoadVDSO(), JITLoaderGDB::ReadJITDescriptorImpl(), DynamicLoaderDarwinKernel::KextImageInfo::ReadMemoryModule(), and ReadUnnamedMemoryModule().

◆ ReadPointerFromMemory()

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

Definition at line 2104 of file Process.cpp.

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

◆ ReadScalarIntegerFromMemory()

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

Definition at line 2240 of file Process.cpp.

References error(), GetAddressByteSize(), GetByteOrder(), lldb_private::DataExtractor::GetMaxU32(), lldb_private::DataExtractor::GetMaxU64(), ReadMemory(), and lldb_private::Scalar::SignExtend().

Referenced by lldb_private::ClassDescriptorV2::iVarsStorage::fill(), ABIMacOSX_arm64::GetArgumentValues(), ABISysV_arm64::GetArgumentValues(), ABIMacOSX_arm::GetArgumentValues(), ABISysV_arm::GetArgumentValues(), ReadIntegerArgument(), ReadPointerFromMemory(), ReadSignedIntegerFromMemory(), and ReadUnsignedIntegerFromMemory().

◆ ReadSignedIntegerFromMemory()

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

Definition at line 2093 of file Process.cpp.

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

Referenced by ProcessFreeBSDKernel::DoUpdateThreadList(), lldb_private::ItaniumABILanguageRuntime::GetDynamicTypeAndAddress(), and ReadVBaseOffsetFromVTable().

◆ 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_addr	A load address of the integer to read.
[in]	byte_size	The size in byte of the integer to read.
[in]	fail_value	The value to return if we fail to read an integer.
[out]	error	An 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 2082 of file Process.cpp.

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

Referenced by SystemRuntimeMacOSX::BacktraceRecordingHeadersInitialized(), DynamicLoaderMacOS::CanLoadImage(), lldb_private::PlatformWindows::DoLoadImage(), 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::ProcessTrace, ProcessElfCore, ProcessFreeBSDKernel, lldb_private::process_gdb_remote::ProcessGDBRemote, ProcessMachCore, ProcessKDP, lldb_private::minidump::ProcessMinidump, lldb_private::ScriptedProcess, and lldb_private::ProcessWindows.

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] callbacks A structure that contains the notification baton and callback functions.

See also: Process::Notifications

Definition at line 588 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

Definition at line 1734 of file Process.cpp.

References lldb_private::BreakpointSite::eSoftware, lldb_private::BreakpointSiteList::FindInRange(), lldb_private::BreakpointSiteList::ForEach(), lldb_private::BreakpointSite::GetType(), and m_breakpoint_site_list.

Referenced by ReadMemoryFromInferior().

◆ RemoveInvalidMemoryRange()

bool Process::RemoveInvalidMemoryRange ( const LoadRange & region )

Definition at line 5610 of file Process.cpp.

References lldb_private::Range< B, S >::GetByteSize(), lldb_private::Range< B, S >::GetRangeBase(), m_memory_cache, and lldb_private::MemoryCache::RemoveInvalidRange().

◆ RemoveOwnerFromBreakpointSite()

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

Definition at line 1722 of file Process.cpp.

References DisableBreakpointSite(), IsAlive(), m_breakpoint_site_list, and lldb_private::BreakpointSiteList::RemoveByAddress().

◆ ResetImageToken()

void Process::ResetImageToken ( size_t token )

Definition at line 5868 of file Process.cpp.

References LLDB_INVALID_ADDRESS, and m_image_tokens.

Referenced by PlatformPOSIX::UnloadImage(), and lldb_private::PlatformWindows::UnloadImage().

◆ ResolveIndirectFunction()

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

virtual

Resolve dynamically loaded indirect functions.

Parameters

[in]	address	The load address of the indirect function to resolve.
[out]	error	An error value in case the resolve fails.

Returns: The address of the resolved function. LLDB_INVALID_ADDRESS if the resolution failed.

Definition at line 5727 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 ( )

Restores the process event broadcasting to its normal state.

Definition at line 969 of file Process.cpp.

References lldb_private::Broadcaster::RestoreBroadcaster().

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

◆ 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 1359 of file Process.cpp.

References error(), lldb_private::GetLog(), lldb_private::PluginInterface::GetPluginName(), LLDB_LOGF, m_public_run_lock, PrivateResume(), lldb_private::Process, lldb_private::ProcessRunLock::SetStopped(), lldb_private::State, and lldb_private::ProcessRunLock::TrySetRunning().

Referenced by CommandObjectProcessContinue::DoExecute(), CommandObjectThreadStepWithTypeAndScope::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

Definition at line 3617 of file Process.cpp.

References ControlPrivateStateThread(), and eBroadcastInternalStateControlResume.

Referenced by ConnectRemote(), lldb_private::process_gdb_remote::ProcessGDBRemote::DoDetach(), ProcessKDP::DoDetach(), Launch(), LoadCore(), and StartPrivateStateThread().

◆ 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_sp When 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 6049 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 ( )

Definition at line 5620 of file Process.cpp.

References lldb_private::Process::PreResumeCallbackAndBaton::baton, lldb_private::Process::PreResumeCallbackAndBaton::callback, and m_pre_resume_actions.

Referenced by PrivateResume().

◆ RunPrivateStateThread()

thread_result_t Process::RunPrivateStateThread ( bool is_secondary_thread )

private

Definition at line 3815 of file Process.cpp.

References lldb_private::Broadcaster::BroadcastEvent(), lldb_private::ThreadList::DiscardThreadPlans(), eBroadcastBitInterrupt, eBroadcastInternalStateControlPause, eBroadcastInternalStateControlResume, eBroadcastInternalStateControlStop, error(), lldb::eStateAttaching, lldb::eStateDetached, lldb::eStateExited, lldb::eStateInvalid, GetEventsPrivate(), GetID(), lldb_private::GetLog(), lldb_private::Process::ProcessEventData::GetStateFromEvent(), lldb_private::ThreadSafeValue< T >::GetValue(), HaltPrivate(), HandlePrivateEvent(), LLDB_LOGF, m_clear_thread_plans_on_stop, m_last_broadcast_state, m_private_state_control_broadcaster, m_public_run_lock, m_public_state, m_thread_list, lldb_private::Process, lldb_private::Process::ProcessEventData::SetInterruptedInEvent(), lldb_private::ProcessRunLock::SetStopped(), lldb_private::StateAsCString(), lldb_private::StateIsRunningState(), and lldb_private::StateIsStoppedState().

Referenced by StartPrivateStateThread().

◆ RunThreadPlan()

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

Definition at line 4712 of file Process.cpp.

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] outfile Path 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 2699 of file Process.cpp.

◆ SendAsyncInterrupt()

void Process::SendAsyncInterrupt ( )

Definition at line 3682 of file Process.cpp.

References lldb_private::Broadcaster::BroadcastEvent(), eBroadcastBitInterrupt, m_private_state_broadcaster, and PrivateStateThreadIsValid().

Referenced by Halt(), lldb_private::TargetList::SendAsyncInterrupt(), and StopForDestroyOrDetach().

◆ SendEventData()

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

inlinevirtual

Reimplemented in lldb_private::process_gdb_remote::ProcessGDBRemote.

Definition at line 2419 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_calls True if possible; false otherwise.

Definition at line 1917 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_jit True if execution of JIT code is possible; false otherwise.

Definition at line 2344 of file Process.cpp.

References eCanJITNo, eCanJITYes, and m_can_jit.

Referenced by DynamicLoaderHexagonDYLD::DidAttach(), lldb_private::ProcessTrace::DidAttach(), ProcessKDP::DoConnectRemote(), ProcessElfCore::DoLoadCore(), ProcessMachCore::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_code True if execution of code is possible; false otherwise.

Definition at line 2348 of file Process.cpp.

References m_can_interpret_function_calls, and SetCanJIT().

Referenced by DynamicLoaderDarwinKernel::DynamicLoaderDarwinKernel().

◆ SetCodeAddressMask()

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

inline

Definition at line 1379 of file Process.h.

References m_code_address_mask.

Referenced by lldb_private::process_gdb_remote::ProcessGDBRemote::DidLaunchOrAttach(), ProcessMachCore::DoLoadCore(), DynamicLoaderDarwinKernel::LoadKernelModuleIfNeeded(), and lldb_private::process_gdb_remote::ProcessGDBRemote::SetThreadStopInfo().

◆ SetDataAddressMask()

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

inline

Definition at line 1383 of file Process.h.

References m_data_address_mask.

Referenced by lldb_private::process_gdb_remote::ProcessGDBRemote::DidLaunchOrAttach(), ProcessMachCore::DoLoadCore(), DynamicLoaderDarwinKernel::LoadKernelModuleIfNeeded(), and lldb_private::process_gdb_remote::ProcessGDBRemote::SetThreadStopInfo().

◆ SetDynamicCheckers()

void Process::SetDynamicCheckers ( DynamicCheckerFunctions * dynamic_checkers )

Definition at line 1577 of file Process.cpp.

References m_dynamic_checkers_up.

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

◆ SetDynamicLoader()

void Process::SetDynamicLoader ( lldb::DynamicLoaderUP dyld )

Definition at line 2693 of file Process.cpp.

References m_dyld_up.

◆ 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_status The value for the process's return code.

See also: lldb::StateType

Definition at line 1066 of file Process.cpp.

References DidExit(), lldb::eStateExited, lldb_private::GetLog(), lldb_private::PluginInterface::GetPluginName(), lldb_private::ThreadSafeValue< T >::GetValue(), LLDB_LOGF, m_exit_status, m_exit_status_mutex, m_exit_string, m_mod_id, m_private_state, lldb_private::Process, SetPrivateState(), lldb_private::ProcessModID::SetStopEventForLastNaturalStopID(), and lldb_private::State.

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 LaunchPrivate().

◆ SetHighmemCodeAddressMask()

void lldb_private::Process::SetHighmemCodeAddressMask ( lldb::addr_t code_address_mask )

inline

Definition at line 1387 of file Process.h.

References m_highmem_code_address_mask.

◆ SetHighmemDataAddressMask()

void lldb_private::Process::SetHighmemDataAddressMask ( lldb::addr_t data_address_mask )

inline

Definition at line 1391 of file Process.h.

References m_highmem_data_address_mask.

◆ SetID()

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

inline

Sets the stored pid.

This does not change the pid of underlying process.

Definition at line 535 of file Process.h.

References m_pid.

Referenced by Attach(), lldb_private::process_gdb_remote::ProcessGDBRemote::DidFork(), lldb_private::process_gdb_remote::ProcessGDBRemote::DidVFork(), lldb_private::ProcessWindows::DoAttachToProcessWithID(), lldb_private::process_gdb_remote::ProcessGDBRemote::DoAttachToProcessWithID(), lldb_private::process_gdb_remote::ProcessGDBRemote::DoConnectRemote(), ProcessKDP::DoConnectRemote(), lldb_private::process_gdb_remote::ProcessGDBRemote::DoLaunch(), lldb_private::ProcessWindows::DoLaunch(), lldb_private::minidump::ProcessMinidump::DoLoadCore(), lldb_private::process_gdb_remote::ProcessGDBRemote::HandleStopReply(), LaunchPrivate(), ParseFreeBSDPrPsInfo(), ProcessElfCore::parseLinuxNotes(), ProcessElfCore::parseNetBSDNotes(), and lldb_private::process_gdb_remote::ProcessGDBRemote::SetThreadStopInfo().

◆ SetNextEventAction()

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

inlineprotected

Definition at line 2765 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 1431 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::GetLog(), lldb_private::ThreadSafeValue< T >::GetMutex(), lldb_private::ThreadList::GetMutex(), lldb_private::PluginInterface::GetPluginName(), lldb_private::Target::GetStatistics(), lldb_private::ProcessModID::GetStopID(), GetTarget(), lldb_private::ThreadSafeValue< T >::GetValueNoLock(), lldb_private::ProcessModID::IsLastResumeForUserExpression(), LLDB_LOGF, m_finalizing, m_memory_cache, m_mod_id, m_private_run_lock, m_private_state, m_private_state_broadcaster, m_thread_list, lldb_private::Process, lldb_private::TargetStats::SetFirstPrivateStopTime(), lldb_private::ProcessRunLock::SetRunning(), lldb_private::ProcessModID::SetStopEventForLastNaturalStopID(), lldb_private::ProcessRunLock::SetStopped(), lldb_private::ThreadSafeValue< T >::SetValueNoLock(), lldb_private::State, lldb_private::StateAsCString(), lldb_private::StateIsStoppedState(), and lldb_private::Unwind.

Referenced by lldb_private::process_gdb_remote::ProcessGDBRemote::AsyncThread(), ProcessKDP::AsyncThread(), lldb_private::ProcessTrace::DidAttach(), lldb_private::ScriptedProcess::DoAttach(), lldb_private::process_gdb_remote::ProcessGDBRemote::DoConnectRemote(), ProcessKDP::DoConnectRemote(), lldb_private::process_gdb_remote::ProcessGDBRemote::DoDetach(), ProcessKDP::DoDetach(), lldb_private::ProcessWindows::DoDetach(), ProcessKDP::DoHalt(), lldb_private::process_gdb_remote::ProcessGDBRemote::DoLaunch(), lldb_private::ScriptedProcess::DoLaunch(), ProcessKDP::DoResume(), lldb_private::ProcessWindows::DoResume(), lldb_private::ScriptedProcess::ForceScriptedState(), 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 1122 of file Process.cpp.

References lldb_private::Debugger::FindTargetWithProcessID(), lldb_private::GetLog(), LLDB_LOGF, and lldb_private::Process.

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

◆ SetPublicState()

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

protected

◆ SetRunningUserExpression()

void Process::SetRunningUserExpression ( bool on )

Definition at line 1492 of file Process.cpp.

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

Referenced by lldb_private::LLVMUserExpression::DoExecute(), lldb_private::FunctionCaller::ExecuteFunction(), and IRInterpreter::Interpret().

◆ SetRunningUtilityFunction()

void Process::SetRunningUtilityFunction ( bool on )

Definition at line 1496 of file Process.cpp.

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

Referenced by lldb_private::UtilityFunctionScope::UtilityFunctionScope(), and lldb_private::UtilityFunctionScope::~UtilityFunctionScope().

◆ SetShadowListener()

void lldb_private::Process::SetShadowListener ( lldb::ListenerSP listener_sp )

inlineoverridevirtual

Reimplemented from lldb_private::Broadcaster.

Definition at line 385 of file Process.h.

References lldb_private::Broadcaster::SetShadowListener().

◆ SetShouldDetach()

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

inline

Definition at line 730 of file Process.h.

References m_should_detach.

◆ SetSTDIOFileDescriptor()

void Process::SetSTDIOFileDescriptor ( int file_descriptor )

Definition at line 4525 of file Process.cpp.

References lldb_private::Communication::IsConnected(), m_process_input_reader, m_stdio_communication, lldb_private::ThreadedCommunication::SetConnection(), lldb_private::ThreadedCommunication::SetReadThreadBytesReceivedCallback(), lldb_private::ThreadedCommunication::StartReadThread(), and STDIOReadThreadBytesReceived().

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

◆ SettingsInitialize()

void Process::SettingsInitialize ( )

static

Definition at line 4575 of file Process.cpp.

References lldb_private::Thread::SettingsInitialize().

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

◆ SettingsTerminate()

void Process::SettingsTerminate ( )

static

Definition at line 4577 of file Process.cpp.

References lldb_private::Thread::SettingsTerminate().

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

◆ SetUnixSignals()

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

Definition at line 3390 of file Process.cpp.

References m_unix_signals_sp.

Referenced by ProcessElfCore::Clear(), ProcessElfCore::DoLoadCore(), lldb_private::minidump::ProcessMinidump::DoLoadCore(), and lldb_private::process_gdb_remote::ProcessGDBRemote::SetUnixSignals().

◆ 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_ptr This is the event we are handling.

Returns: Returns true if the event should be reported to the user, false otherwise.

Definition at line 3408 of file Process.cpp.

References lldb_private::ThreadedCommunication::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::Events, lldb_private::eVoteNo, lldb_private::eVoteNoOpinion, lldb_private::eVoteYes, lldb_private::Process::ProcessEventData::GetInterruptedFromEvent(), lldb_private::GetLog(), lldb_private::Process::ProcessEventData::GetRestartedFromEvent(), lldb_private::Process::ProcessEventData::GetStateFromEvent(), LLDB_LOGF, m_force_next_event_delivery, m_last_broadcast_state, m_resume_requested, m_stdin_forward, m_stdio_communication, m_thread_list, PrivateResume(), lldb_private::Process, RefreshStateAfterStop(), lldb_private::Process::ProcessEventData::SetRestartedInEvent(), lldb_private::ThreadList::ShouldReportRun(), lldb_private::ThreadList::ShouldReportStop(), lldb_private::ThreadList::ShouldStop(), lldb_private::StateAsCString(), lldb_private::ThreadedCommunication::StopReadThread(), lldb_private::ThreadedCommunication::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 3380 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 2361 of file Process.h.

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

◆ StartPrivateStateThread()

bool Process::StartPrivateStateThread ( bool is_secondary_thread = false )

protected

Definition at line 3562 of file Process.cpp.

References lldb_private::Events, GetID(), lldb_private::GetLog(), lldb_private::Host, lldb_private::ThreadLauncher::LaunchThread(), LLDB_LOG, LLDB_LOGF, m_private_state_thread, PrivateStateThreadIsValid(), ResumePrivateStateThread(), and RunPrivateStateThread().

Referenced by Attach(), ConnectRemote(), lldb_private::ProcessTrace::DidAttach(), Launch(), LoadCore(), and RunThreadPlan().

◆ StateChangedIsExternallyHijacked()

bool Process::StateChangedIsExternallyHijacked ( )

Definition at line 1411 of file Process.cpp.

References eBroadcastBitStateChanged, lldb_private::Broadcaster::GetHijackingListenerName(), and lldb_private::Broadcaster::IsHijackedForEvent().

Referenced by SetPublicState().

◆ StateChangedIsHijackedForSynchronousResume()

bool Process::StateChangedIsHijackedForSynchronousResume ( )

Definition at line 1420 of file Process.cpp.

References eBroadcastBitStateChanged, lldb_private::Broadcaster::GetHijackingListenerName(), lldb_private::Broadcaster::IsHijackedForEvent(), and ResumeSynchronousHijackListenerName.

◆ STDIOReadThreadBytesReceived()

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

staticprotected

Definition at line 4375 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 2368 of file Process.h.

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

◆ StopPrivateStateThread()

void Process::StopPrivateStateThread ( )

protected

Definition at line 3621 of file Process.cpp.

References ControlPrivateStateThread(), eBroadcastInternalStateControlStop, lldb_private::GetLog(), lldb_private::HostThread::IsJoinable(), LLDB_LOGF, m_private_state_thread, and lldb_private::Process.

Referenced by DestroyImpl(), Detach(), RunThreadPlan(), and ~Process().

◆ 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 ProcessElfCore, and lldb_private::process_gdb_remote::ProcessGDBRemote.

Definition at line 2844 of file Process.h.

Referenced by GetMemoryTagManager().

◆ SynchronouslyNotifyStateChanged()

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

protected

Definition at line 607 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] timeout The maximum time length to wait for the process to transition to the eStateRunning state.

Definition at line 639 of file Process.cpp.

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

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

◆ Threads()

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

inline

Definition at line 2134 of file Process.h.

References m_thread_list, and lldb_private::ThreadCollection::Threads().

Referenced by BuildThreadsSection(), lldb_private::CommandObjectIterateOverThreads::DoExecute(), lldb_private::CommandObjectMultipleThreads::DoExecute(), SystemRuntimeMacOSX::PopulateQueueList(), and lldb_private::ScriptedProcess::UpdateQueueListIfNeeded().

◆ 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] request Object 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 2638 of file Process.h.

Referenced by lldb_private::Trace::GetLiveCpuBinaryData(), and lldb_private::Trace::GetLiveTraceBinaryData().

◆ 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] type Tracing 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 2625 of file Process.h.

Referenced by lldb_private::Trace::GetLiveProcessState().

◆ TraceStart()

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

inlineprotectedvirtual

Start tracing a process or its threads.

Parameters

[in] request JSON 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 2601 of file Process.h.

Referenced by lldb_private::Trace::Start().

◆ TraceStop()

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

inlineprotectedvirtual

Stop tracing a live process or its threads.

Parameters

[in] request The 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 2613 of file Process.h.

Referenced by lldb_private::Trace::Stop().

◆ 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 6094 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] callbacks A 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 594 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 6078 of file Process.cpp.

Referenced by LaunchPrivate(), and PrivateResume().

◆ UpdateQueueListIfNeeded()

void Process::UpdateQueueListIfNeeded ( )

virtual

Reimplemented in lldb_private::ScriptedProcess.

Definition at line 1269 of file Process.cpp.

References GetLastNaturalStopID(), GetPrivateState(), lldb_private::QueueList::GetSize(), m_queue_list, m_queue_list_stop_id, m_system_runtime_up, and lldb_private::StateIsStoppedState().

Referenced by GetQueueList(), and Queues().

◆ 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 1150 of file Process.cpp.

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

Referenced by UpdateThreadListIfNeeded().

◆ UpdateThreadListIfNeeded()

void Process::UpdateThreadListIfNeeded ( )

Definition at line 1156 of file Process.cpp.

◆ WaitForProcessStopPrivate()

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

protected

Definition at line 2448 of file Process.cpp.

References lldb::eStateInvalid, GetStateChangedEventsPrivate(), HandlePrivateEvent(), and lldb_private::StateIsStoppedState().

Referenced by ConnectRemote(), and LaunchPrivate().

◆ 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`,
		SelectMostRelevant	select_most_relevant = `DoNoSelectMostRelevantFrame`
	)

◆ 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 lldb_private::ProcessTrace, ProcessElfCore, ProcessMachCore, and lldb_private::minidump::ProcessMinidump.

Definition at line 1452 of file Process.h.

◆ WillAttachToProcessWithID()

Status Process::WillAttachToProcessWithID ( lldb::pid_t pid )

Called before attaching to a process.

Returns: Returns an error object.

Definition at line 2804 of file Process.cpp.

References DoWillAttachToProcessWithID().

Referenced by Attach().

◆ WillAttachToProcessWithName()

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

Called before attaching to a process.

Returns: Returns an error object.

Definition at line 2808 of file Process.cpp.

References DoWillAttachToProcessWithName().

Referenced by Attach().

◆ WillDestroy()

virtual Status lldb_private::Process::WillDestroy ( )

inlinevirtual

Definition at line 1177 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 1131 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 1095 of file Process.h.

Referenced by HaltPrivate().

◆ WillLaunch()

Status Process::WillLaunch ( Module * module )

Called before launching to a process.

Returns: Returns an error object.

Definition at line 2800 of file Process.cpp.

References DoWillLaunch().

Referenced by LaunchPrivate().

◆ 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 764 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::ProcessTrace, ProcessElfCore, lldb_private::process_gdb_remote::ProcessGDBRemote, ProcessKDP, and lldb_private::minidump::ProcessMinidump.

Definition at line 1060 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 1163 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_addr	A virtual load address that indicates where to start writing memory to.
[in]	buf	A byte buffer that is at least size bytes long that contains the data to write.
[in]	size	The number of bytes to write.

Returns: The number of bytes that were actually written.

Definition at line 2140 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(), GetABI(), lldb_private::BreakpointSite::GetSavedOpcodeBytes(), lldb_private::BreakpointSite::GetType(), lldb_private::BreakpointSite::IntersectsRange(), lldb_private::BreakpointSiteList::IsEmpty(), m_breakpoint_site_list,

Classes

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Types

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Private Member Functions

Friends

Detailed Description

Member Typedef Documentation

◆ LanguageRuntimeCollection

◆ LoadRange

◆ PreResumeActionCallback

◆ StopLocker

◆ StructuredDataPluginMap

Member Enumeration Documentation

◆ anonymous enum

◆ anonymous enum

◆ anonymous enum

Constructor & Destructor Documentation

◆ ~Process()

◆ Process() [1/3]

◆ Process() [2/3]

◆ Process() [3/3]

Member Function Documentation

◆ AddImageToken()

◆ AddInvalidMemoryRegion()

◆ AddPreResumeAction()

◆ AdvanceAddressToNextBranchInstruction()

◆ AllocateMemory()

◆ AppendSTDERR()

◆ AppendSTDOUT()

◆ AssignIndexIDToThread()

◆ Attach()

◆ BroadcastAsyncProfileData()

◆ BroadcastStructuredData()

◆ CalculateExecutionContext()

◆ CalculateProcess()

◆ CalculateStackFrame()

◆ CalculateTarget()

◆ CalculateThread()

◆ CallocateMemory()

◆ CallVoidArgVoidPtrReturn()

◆ CanDebug()

◆ CanInterpretFunctionCalls()

◆ CanJIT()

◆ ClearBreakpointSiteByID()

◆ ClearPreResumeAction()

◆ ClearPreResumeActions()

◆ CompleteAttach()

◆ ConfigureStructuredData()

◆ ConnectRemote()

◆ ControlPrivateStateThread()

◆ CreateBreakpointSite()

◆ CreateOSPluginThread()

◆ CurrentThreadIsPrivateStateThread()

◆ DeallocateMemory()

◆ Destroy()

◆ DestroyImpl()

◆ DestroyRequiresHalt()

◆ Detach()

◆ DetachRequiresHalt()

◆ DidAttach()

◆ DidDestroy()

◆ DidDetach()

◆ DidExec()

◆ DidExit()

◆ DidFork()

◆ DidHalt()

◆ DidLaunch()

◆ DidResume()

◆ DidSignal()

◆ DidVFork()

◆ DidVForkDone()

◆ DisableAllBreakpointSites()

◆ DisableBreakpointSite()

◆ DisableBreakpointSiteByID()