lldb/Target/Process.h

1 //===-- Process.h -----------------------------------------------*- C++ -*-===//
65   ProcessProperties(lldb_private::Process *process);
88   Process *m_process; // Can be nullptr for global ProcessProperties
349 /// \class Process Process.h "lldb/Target/Process.h"
351 class Process : public std::enable_shared_from_this<Process>,
382   /// Process warning types.
409     void (*initialize)(void *baton, Process *process);
410     void (*process_state_changed)(void *baton, Process *process,
415     friend class Process;
446     static const Process::ProcessEventData *
492   /// Construct with a shared pointer to a target, and the Process listener.
494   Process(lldb::TargetSP target_sp, lldb::ListenerSP listener_sp);
496   /// Construct with a shared pointer to a target, the Process listener, and
498   Process(lldb::TargetSP target_sp, lldb::ListenerSP listener_sp,
505   ~Process() override;
513   /// Find a Process plug-in that can debug \a module using the currently
517   /// Process plug-in interface and returns the first instance that can debug
520   /// \see Process::CanDebug ()
529   /// This function can be used by lldb_private::Process subclasses when they
533   ///     callback = Process::SetHostProcessExitStatus
534   ///     pid = Process::GetID()
551   /// \a module. If the Process plug-in instance can debug a file on the
555   ///     Returns \b true if this Process plug-in instance can
569   ///     Returns \b true if this Process has not been finalized
592   /// This function is not meant to be overridden by Process subclasses. It
593   /// will first call Process::WillLaunch (Module *) and if that returns \b
594   /// true, Process::DoLaunch (Module*, char const *[],char const *[],const
596   /// launching. If DoLaunch returns \b true, then Process::DidLaunch() will
619   // had of having other plugins cache data in the Process.  This is handy for
621   // lifetime is governed by the Process lifetime.  If we find we need to do
624   // Process. Some undecided questions are  (1) who manages the tokens.  It's
628   // should be simply owned by Process, and just go away when it does (3)
629   // whether the registree should be notified of the Process' demise.
654   /// desired, or if Process subclasses can only use a specific DynamicLoader
694   ///   Returns a pointer to the SystemRuntime plugin for this Process
700   /// This function is not meant to be overridden by Process subclasses. It
704   /// true, then Process::DidAttach() will be called.
736   /// loaded or unloaded. This function is in the Process interface (as
763 /// Process::Notifications structure and calling this function.
769 /// \see Process::Notifications
770   void RegisterNotificationCallbacks(const Process::Notifications &callbacks);
785 /// \see Process::Notifications
786   bool UnregisterNotificationCallbacks(const Process::Notifications &callbacks);
789   // Built in Process Control functions
799   /// This function is not meant to be overridden by Process subclasses. This
808   /// Process class.
822   /// This function is not meant to be overridden by Process subclasses. If
841   /// This function is not meant to be overridden by Process subclasses.
853   /// This function is not meant to be overridden by Process subclasses.
869   /// This function is not meant to be overridden by Process subclasses.
880   // Plug-in Process Control Overrides
885   /// Allow Process plug-ins to execute some code before attaching a process.
893   /// Allow Process plug-ins to execute some code before attaching a process.
970   /// Allow Process plug-ins to execute some code after attaching to a
976   /// Allow Process plug-ins to execute some code after a process has exec'ed
978   /// lldb_private::Process class needs to remove its dynamic loader, runtime,
982   /// Subclasses of Process should implement this function if they need to do
988   /// Allow Process plug-ins to execute some code before launching a process.
1021   /// Allow Process plug-ins to execute some code after launching a process.
1026   /// Allow Process plug-ins to execute some code before resuming a process.
1057   /// Allow Process plug-ins to execute some code after resuming a process.
1062   /// Allow Process plug-ins to execute some code before halting a process.
1093   /// Allow Process plug-ins to execute some code after halting a process.
1098   /// Allow Process plug-ins to execute some code before detaching from a
1120   /// Allow Process plug-ins to execute some code after detaching from a
1128   /// Allow Process plug-ins to execute some code before sending a signal to a
1133   ///     Process::DoSignal(int), otherwise an error describing what
1159   /// Allow Process plug-ins to execute some code after sending a signal to a
1168   /// is about to be queued up to allow Process plug-ins to execute some code
1305   /// function is found that was compiled with optimization, per Process.
1422   /// This function is not meant to be overridden by Process subclasses, the
1423   /// subclasses should implement Process::DoReadMemory (lldb::addr_t, size_t,
1631   /// This function is not meant to be overridden by Process subclasses, the
1632   /// subclasses should implement Process::DoWriteMemory (lldb::addr_t,
1766     error.SetErrorString("Process::GetMemoryRegionInfo() not supported");
1784     error.SetErrorString("Process::GetWatchpointSupportInfo() not supported");
1792     error.SetErrorString("Process::GetWatchpointSupportInfo() not supported");
1986   // Process Breakpoints
2005   // This is implemented completely using the lldb::Process API. Subclasses
2011   // This is implemented completely using the lldb::Process API. Subclasses
2038   // Process Watchpoints (optional)
2052   // need an owner -- they're saved here in the Process.  The threads in this
2128   ///     If this value comes in set to \b true, then pop the Process IOHandler
2145     ProcessEventHijacker(Process &process, lldb::ListenerSP listener_sp)
2153     Process &m_process;
2278   /// name and architecture. Process sub-classes have to override this method
2352   /// Each Process type that supports using an asynchronous StructuredData
2362   ///     the Process-derived instance.
2480   /// Print a user-visible warning one time per Process
2484   /// warning_type is from the Process::Warnings enums. repeat_key is a
2492   /// Classes outside Process should call a specific PrintWarning method so
2493   /// that the warning strings are all centralized in Process, instead of
2497   ///     One of the types defined in Process::Warnings.
2525     NextEventAction(Process *process) : m_process(process) {}
2536     Process *m_process;
2539   void SetNextEventAction(Process::NextEventAction *next_event_action) {
2549     AttachCompletionHandler(Process *process, uint32_t exec_count);
2603   ///     HandleArrivalOfStructuredData(Process &process,
2651   uint32_t m_process_unique_id; ///< Each lldb_private::Process class that is
2722   bool m_finalizing; // This is set at the beginning of Process::Finalize() to
2725   bool m_finalize_called; // This is set at the end of Process::Finalize()
2765     PrivateStateThreadArgs(Process *p, bool s)
2767     Process *process;
2846   DISALLOW_COPY_AND_ASSIGN(Process);
2852   Process *m_process;
2855   UtilityFunctionScope(Process *p) : m_process(p) {