Process.h revision 36da2aa6dc5ad9994b638ed09eb81c44cc05540b 
1//===-- Process.h -----------------------------------------------*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10#ifndef liblldb_Process_h_
11#define liblldb_Process_h_
12
13// C Includes
14#include <limits.h>
15#include <spawn.h>
16
17// C++ Includes
18#include <list>
19#include <iosfwd>
20#include <vector>
21
22// Other libraries and framework includes
23// Project includes
24#include "lldb/lldb-private.h"
25#include "lldb/Core/ArchSpec.h"
26#include "lldb/Core/Broadcaster.h"
27#include "lldb/Core/Communication.h"
28#include "lldb/Core/Error.h"
29#include "lldb/Core/Event.h"
30#include "lldb/Core/RangeMap.h"
31#include "lldb/Core/StringList.h"
32#include "lldb/Core/ThreadSafeValue.h"
33#include "lldb/Core/PluginInterface.h"
34#include "lldb/Core/UserSettingsController.h"
35#include "lldb/Breakpoint/BreakpointSiteList.h"
36#include "lldb/Expression/ClangPersistentVariables.h"
37#include "lldb/Expression/IRDynamicChecks.h"
38#include "lldb/Host/FileSpec.h"
39#include "lldb/Host/Host.h"
40#include "lldb/Host/ReadWriteLock.h"
41#include "lldb/Interpreter/Args.h"
42#include "lldb/Interpreter/Options.h"
43#include "lldb/Target/ExecutionContextScope.h"
44#include "lldb/Target/Memory.h"
45#include "lldb/Target/ThreadList.h"
46#include "lldb/Target/UnixSignals.h"
47#include "lldb/Utility/PseudoTerminal.h"
48
49namespace lldb_private {
50
51//----------------------------------------------------------------------
52// ProcessProperties
53//----------------------------------------------------------------------
54class ProcessProperties : public Properties
55{
56public:
57    ProcessProperties(bool is_global);
58
59    virtual
60    ~ProcessProperties();
61
62    bool
63    GetDisableMemoryCache() const;
64
65    Args
66    GetExtraStartupCommands () const;
67
68    void
69    SetExtraStartupCommands (const Args &args);
70
71    FileSpec
72    GetPythonOSPluginPath () const;
73
74    void
75    SetPythonOSPluginPath (const FileSpec &file);
76
77    bool
78    GetIgnoreBreakpointsInExpressions () const;
79
80    void
81    SetIgnoreBreakpointsInExpressions (bool ignore);
82
83    bool
84    GetUnwindOnErrorInExpressions () const;
85
86    void
87    SetUnwindOnErrorInExpressions (bool ignore);
88};
89
90typedef STD_SHARED_PTR(ProcessProperties) ProcessPropertiesSP;
91
92//----------------------------------------------------------------------
93// ProcessInfo
94//
95// A base class for information for a process. This can be used to fill
96// out information for a process prior to launching it, or it can be
97// used for an instance of a process and can be filled in with the
98// existing values for that process.
99//----------------------------------------------------------------------
100class ProcessInfo
101{
102public:
103    ProcessInfo () :
104        m_executable (),
105        m_arguments (),
106        m_environment (),
107        m_uid (UINT32_MAX),
108        m_gid (UINT32_MAX),
109        m_arch(),
110        m_pid (LLDB_INVALID_PROCESS_ID)
111    {
112    }
113
114    ProcessInfo (const char *name,
115                 const ArchSpec &arch,
116                 lldb::pid_t pid) :
117        m_executable (name, false),
118        m_arguments (),
119        m_environment(),
120        m_uid (UINT32_MAX),
121        m_gid (UINT32_MAX),
122        m_arch (arch),
123        m_pid (pid)
124    {
125    }
126
127    void
128    Clear ()
129    {
130        m_executable.Clear();
131        m_arguments.Clear();
132        m_environment.Clear();
133        m_uid = UINT32_MAX;
134        m_gid = UINT32_MAX;
135        m_arch.Clear();
136        m_pid = LLDB_INVALID_PROCESS_ID;
137    }
138
139    const char *
140    GetName() const
141    {
142        return m_executable.GetFilename().GetCString();
143    }
144
145    size_t
146    GetNameLength() const
147    {
148        return m_executable.GetFilename().GetLength();
149    }
150
151    FileSpec &
152    GetExecutableFile ()
153    {
154        return m_executable;
155    }
156
157    void
158    SetExecutableFile (const FileSpec &exe_file, bool add_exe_file_as_first_arg)
159    {
160        if (exe_file)
161        {
162            m_executable = exe_file;
163            if (add_exe_file_as_first_arg)
164            {
165                char filename[PATH_MAX];
166                if (exe_file.GetPath(filename, sizeof(filename)))
167                    m_arguments.InsertArgumentAtIndex (0, filename);
168            }
169        }
170        else
171        {
172            m_executable.Clear();
173        }
174    }
175
176    const FileSpec &
177    GetExecutableFile () const
178    {
179        return m_executable;
180    }
181
182    uint32_t
183    GetUserID() const
184    {
185        return m_uid;
186    }
187
188    uint32_t
189    GetGroupID() const
190    {
191        return m_gid;
192    }
193
194    bool
195    UserIDIsValid () const
196    {
197        return m_uid != UINT32_MAX;
198    }
199
200    bool
201    GroupIDIsValid () const
202    {
203        return m_gid != UINT32_MAX;
204    }
205
206    void
207    SetUserID (uint32_t uid)
208    {
209        m_uid = uid;
210    }
211
212    void
213    SetGroupID (uint32_t gid)
214    {
215        m_gid = gid;
216    }
217
218    ArchSpec &
219    GetArchitecture ()
220    {
221        return m_arch;
222    }
223
224    const ArchSpec &
225    GetArchitecture () const
226    {
227        return m_arch;
228    }
229
230    lldb::pid_t
231    GetProcessID () const
232    {
233        return m_pid;
234    }
235
236    void
237    SetProcessID (lldb::pid_t pid)
238    {
239        m_pid = pid;
240    }
241
242    bool
243    ProcessIDIsValid() const
244    {
245        return m_pid != LLDB_INVALID_PROCESS_ID;
246    }
247
248    void
249    Dump (Stream &s, Platform *platform) const;
250
251    Args &
252    GetArguments ()
253    {
254        return m_arguments;
255    }
256
257    const Args &
258    GetArguments () const
259    {
260        return m_arguments;
261    }
262
263    const char *
264    GetArg0 () const
265    {
266        if (m_arg0.empty())
267            return NULL;
268        return m_arg0.c_str();
269    }
270
271    void
272    SetArg0 (const char *arg)
273    {
274        if (arg && arg[0])
275            m_arg0.clear();
276        else
277            m_arg0 = arg;
278    }
279
280    void
281    SetArguments (const Args& args, bool first_arg_is_executable);
282
283    void
284    SetArguments (char const **argv, bool first_arg_is_executable);
285
286    Args &
287    GetEnvironmentEntries ()
288    {
289        return m_environment;
290    }
291
292    const Args &
293    GetEnvironmentEntries () const
294    {
295        return m_environment;
296    }
297
298protected:
299    FileSpec m_executable;
300    std::string m_arg0; // argv[0] if supported. If empty, then use m_executable.
301                        // Not all process plug-ins support specifying an argv[0]
302                        // that differs from the resolved platform executable
303                        // (which is in m_executable)
304    Args m_arguments;   // All program arguments except argv[0]
305    Args m_environment;
306    uint32_t m_uid;
307    uint32_t m_gid;
308    ArchSpec m_arch;
309    lldb::pid_t m_pid;
310};
311
312//----------------------------------------------------------------------
313// ProcessInstanceInfo
314//
315// Describes an existing process and any discoverable information that
316// pertains to that process.
317//----------------------------------------------------------------------
318class ProcessInstanceInfo : public ProcessInfo
319{
320public:
321    ProcessInstanceInfo () :
322        ProcessInfo (),
323        m_euid (UINT32_MAX),
324        m_egid (UINT32_MAX),
325        m_parent_pid (LLDB_INVALID_PROCESS_ID)
326    {
327    }
328
329    ProcessInstanceInfo (const char *name,
330                 const ArchSpec &arch,
331                 lldb::pid_t pid) :
332        ProcessInfo (name, arch, pid),
333        m_euid (UINT32_MAX),
334        m_egid (UINT32_MAX),
335        m_parent_pid (LLDB_INVALID_PROCESS_ID)
336    {
337    }
338
339    void
340    Clear ()
341    {
342        ProcessInfo::Clear();
343        m_euid = UINT32_MAX;
344        m_egid = UINT32_MAX;
345        m_parent_pid = LLDB_INVALID_PROCESS_ID;
346    }
347
348    uint32_t
349    GetEffectiveUserID() const
350    {
351        return m_euid;
352    }
353
354    uint32_t
355    GetEffectiveGroupID() const
356    {
357        return m_egid;
358    }
359
360    bool
361    EffectiveUserIDIsValid () const
362    {
363        return m_euid != UINT32_MAX;
364    }
365
366    bool
367    EffectiveGroupIDIsValid () const
368    {
369        return m_egid != UINT32_MAX;
370    }
371
372    void
373    SetEffectiveUserID (uint32_t uid)
374    {
375        m_euid = uid;
376    }
377
378    void
379    SetEffectiveGroupID (uint32_t gid)
380    {
381        m_egid = gid;
382    }
383
384    lldb::pid_t
385    GetParentProcessID () const
386    {
387        return m_parent_pid;
388    }
389
390    void
391    SetParentProcessID (lldb::pid_t pid)
392    {
393        m_parent_pid = pid;
394    }
395
396    bool
397    ParentProcessIDIsValid() const
398    {
399        return m_parent_pid != LLDB_INVALID_PROCESS_ID;
400    }
401
402    void
403    Dump (Stream &s, Platform *platform) const;
404
405    static void
406    DumpTableHeader (Stream &s, Platform *platform, bool show_args, bool verbose);
407
408    void
409    DumpAsTableRow (Stream &s, Platform *platform, bool show_args, bool verbose) const;
410
411protected:
412    uint32_t m_euid;
413    uint32_t m_egid;
414    lldb::pid_t m_parent_pid;
415};
416
417
418//----------------------------------------------------------------------
419// ProcessLaunchInfo
420//
421// Describes any information that is required to launch a process.
422//----------------------------------------------------------------------
423
424class ProcessLaunchInfo : public ProcessInfo
425{
426public:
427
428    class FileAction
429    {
430    public:
431        enum Action
432        {
433            eFileActionNone,
434            eFileActionClose,
435            eFileActionDuplicate,
436            eFileActionOpen
437        };
438
439
440        FileAction () :
441            m_action (eFileActionNone),
442            m_fd (-1),
443            m_arg (-1),
444            m_path ()
445        {
446        }
447
448        void
449        Clear()
450        {
451            m_action = eFileActionNone;
452            m_fd = -1;
453            m_arg = -1;
454            m_path.clear();
455        }
456
457        bool
458        Close (int fd);
459
460        bool
461        Duplicate (int fd, int dup_fd);
462
463        bool
464        Open (int fd, const char *path, bool read, bool write);
465
466        static bool
467        AddPosixSpawnFileAction (posix_spawn_file_actions_t *file_actions,
468                                 const FileAction *info,
469                                 Log *log,
470                                 Error& error);
471
472        int
473        GetFD () const
474        {
475            return m_fd;
476        }
477
478        Action
479        GetAction () const
480        {
481            return m_action;
482        }
483
484        int
485        GetActionArgument () const
486        {
487            return m_arg;
488        }
489
490        const char *
491        GetPath () const
492        {
493            if (m_path.empty())
494                return NULL;
495            return m_path.c_str();
496        }
497
498    protected:
499        Action m_action;    // The action for this file
500        int m_fd;           // An existing file descriptor
501        int m_arg;          // oflag for eFileActionOpen*, dup_fd for eFileActionDuplicate
502        std::string m_path; // A file path to use for opening after fork or posix_spawn
503    };
504
505    ProcessLaunchInfo () :
506        ProcessInfo(),
507        m_working_dir (),
508        m_plugin_name (),
509        m_shell (),
510        m_flags (0),
511        m_file_actions (),
512        m_pty (),
513        m_resume_count (0),
514        m_monitor_callback (NULL),
515        m_monitor_callback_baton (NULL),
516        m_monitor_signals (false)
517    {
518    }
519
520    ProcessLaunchInfo (const char *stdin_path,
521                       const char *stdout_path,
522                       const char *stderr_path,
523                       const char *working_directory,
524                       uint32_t launch_flags) :
525        ProcessInfo(),
526        m_working_dir (),
527        m_plugin_name (),
528        m_shell (),
529        m_flags (launch_flags),
530        m_file_actions (),
531        m_pty (),
532        m_resume_count (0),
533        m_monitor_callback (NULL),
534        m_monitor_callback_baton (NULL),
535        m_monitor_signals (false)
536    {
537        if (stdin_path)
538        {
539            ProcessLaunchInfo::FileAction file_action;
540            const bool read = true;
541            const bool write = false;
542            if (file_action.Open(STDIN_FILENO, stdin_path, read, write))
543                AppendFileAction (file_action);
544        }
545        if (stdout_path)
546        {
547            ProcessLaunchInfo::FileAction file_action;
548            const bool read = false;
549            const bool write = true;
550            if (file_action.Open(STDOUT_FILENO, stdout_path, read, write))
551                AppendFileAction (file_action);
552        }
553        if (stderr_path)
554        {
555            ProcessLaunchInfo::FileAction file_action;
556            const bool read = false;
557            const bool write = true;
558            if (file_action.Open(STDERR_FILENO, stderr_path, read, write))
559                AppendFileAction (file_action);
560        }
561        if (working_directory)
562            SetWorkingDirectory(working_directory);
563    }
564
565    void
566    AppendFileAction (const FileAction &info)
567    {
568        m_file_actions.push_back(info);
569    }
570
571    bool
572    AppendCloseFileAction (int fd)
573    {
574        FileAction file_action;
575        if (file_action.Close (fd))
576        {
577            AppendFileAction (file_action);
578            return true;
579        }
580        return false;
581    }
582
583    bool
584    AppendDuplicateFileAction (int fd, int dup_fd)
585    {
586        FileAction file_action;
587        if (file_action.Duplicate (fd, dup_fd))
588        {
589            AppendFileAction (file_action);
590            return true;
591        }
592        return false;
593    }
594
595    bool
596    AppendOpenFileAction (int fd, const char *path, bool read, bool write)
597    {
598        FileAction file_action;
599        if (file_action.Open (fd, path, read, write))
600        {
601            AppendFileAction (file_action);
602            return true;
603        }
604        return false;
605    }
606
607    bool
608    AppendSuppressFileAction (int fd, bool read, bool write)
609    {
610        FileAction file_action;
611        if (file_action.Open (fd, "/dev/null", read, write))
612        {
613            AppendFileAction (file_action);
614            return true;
615        }
616        return false;
617    }
618
619    void
620    FinalizeFileActions (Target *target,
621                         bool default_to_use_pty);
622
623    size_t
624    GetNumFileActions () const
625    {
626        return m_file_actions.size();
627    }
628
629    const FileAction *
630    GetFileActionAtIndex (size_t idx) const
631    {
632        if (idx < m_file_actions.size())
633            return &m_file_actions[idx];
634        return NULL;
635    }
636
637    const FileAction *
638    GetFileActionForFD (int fd) const
639    {
640        for (size_t idx=0, count=m_file_actions.size(); idx < count; ++idx)
641        {
642            if (m_file_actions[idx].GetFD () == fd)
643                return &m_file_actions[idx];
644        }
645        return NULL;
646    }
647
648    Flags &
649    GetFlags ()
650    {
651        return m_flags;
652    }
653
654    const Flags &
655    GetFlags () const
656    {
657        return m_flags;
658    }
659
660    const char *
661    GetWorkingDirectory () const
662    {
663        if (m_working_dir.empty())
664            return NULL;
665        return m_working_dir.c_str();
666    }
667
668    void
669    SetWorkingDirectory (const char *working_dir)
670    {
671        if (working_dir && working_dir[0])
672            m_working_dir.assign (working_dir);
673        else
674            m_working_dir.clear();
675    }
676
677    void
678    SwapWorkingDirectory (std::string &working_dir)
679    {
680        m_working_dir.swap (working_dir);
681    }
682
683
684    const char *
685    GetProcessPluginName () const
686    {
687        if (m_plugin_name.empty())
688            return NULL;
689        return m_plugin_name.c_str();
690    }
691
692    void
693    SetProcessPluginName (const char *plugin)
694    {
695        if (plugin && plugin[0])
696            m_plugin_name.assign (plugin);
697        else
698            m_plugin_name.clear();
699    }
700
701    const char *
702    GetShell () const
703    {
704        if (m_shell.empty())
705            return NULL;
706        return m_shell.c_str();
707    }
708
709    void
710    SetShell (const char * path)
711    {
712        if (path && path[0])
713        {
714            m_shell.assign (path);
715            m_flags.Set (lldb::eLaunchFlagLaunchInShell);
716        }
717        else
718        {
719            m_shell.clear();
720            m_flags.Clear (lldb::eLaunchFlagLaunchInShell);
721        }
722    }
723
724    uint32_t
725    GetResumeCount () const
726    {
727        return m_resume_count;
728    }
729
730    void
731    SetResumeCount (uint32_t c)
732    {
733        m_resume_count = c;
734    }
735
736    bool
737    GetLaunchInSeparateProcessGroup ()
738    {
739        return m_flags.Test(lldb::eLaunchFlagLaunchInSeparateProcessGroup);
740    }
741
742    void
743    SetLaunchInSeparateProcessGroup (bool separate)
744    {
745        if (separate)
746            m_flags.Set(lldb::eLaunchFlagLaunchInSeparateProcessGroup);
747        else
748            m_flags.Clear (lldb::eLaunchFlagLaunchInSeparateProcessGroup);
749
750    }
751
752    void
753    Clear ()
754    {
755        ProcessInfo::Clear();
756        m_working_dir.clear();
757        m_plugin_name.clear();
758        m_shell.clear();
759        m_flags.Clear();
760        m_file_actions.clear();
761        m_resume_count = 0;
762    }
763
764    bool
765    ConvertArgumentsForLaunchingInShell (Error &error,
766                                         bool localhost,
767                                         bool will_debug,
768                                         bool first_arg_is_full_shell_command);
769
770    void
771    SetMonitorProcessCallback (Host::MonitorChildProcessCallback callback,
772                               void *baton,
773                               bool monitor_signals)
774    {
775        m_monitor_callback = callback;
776        m_monitor_callback_baton = baton;
777        m_monitor_signals = monitor_signals;
778    }
779
780    bool
781    MonitorProcess () const
782    {
783        if (m_monitor_callback && ProcessIDIsValid())
784        {
785            Host::StartMonitoringChildProcess (m_monitor_callback,
786                                               m_monitor_callback_baton,
787                                               GetProcessID(),
788                                               m_monitor_signals);
789            return true;
790        }
791        return false;
792    }
793
794    lldb_utility::PseudoTerminal &
795    GetPTY ()
796    {
797        return m_pty;
798    }
799
800protected:
801    std::string m_working_dir;
802    std::string m_plugin_name;
803    std::string m_shell;
804    Flags m_flags;       // Bitwise OR of bits from lldb::LaunchFlags
805    std::vector<FileAction> m_file_actions; // File actions for any other files
806    lldb_utility::PseudoTerminal m_pty;
807    uint32_t m_resume_count; // How many times do we resume after launching
808    Host::MonitorChildProcessCallback m_monitor_callback;
809    void *m_monitor_callback_baton;
810    bool m_monitor_signals;
811
812};
813
814//----------------------------------------------------------------------
815// ProcessLaunchInfo
816//
817// Describes any information that is required to launch a process.
818//----------------------------------------------------------------------
819
820class ProcessAttachInfo : public ProcessInstanceInfo
821{
822public:
823    ProcessAttachInfo() :
824        ProcessInstanceInfo(),
825        m_plugin_name (),
826        m_resume_count (0),
827        m_wait_for_launch (false),
828        m_ignore_existing (true),
829        m_continue_once_attached (false)
830    {
831    }
832
833    ProcessAttachInfo (const ProcessLaunchInfo &launch_info) :
834        ProcessInstanceInfo(),
835        m_plugin_name (),
836        m_resume_count (0),
837        m_wait_for_launch (false),
838        m_ignore_existing (true),
839        m_continue_once_attached (false)
840    {
841        ProcessInfo::operator= (launch_info);
842        SetProcessPluginName (launch_info.GetProcessPluginName());
843        SetResumeCount (launch_info.GetResumeCount());
844    }
845
846    bool
847    GetWaitForLaunch () const
848    {
849        return m_wait_for_launch;
850    }
851
852    void
853    SetWaitForLaunch (bool b)
854    {
855        m_wait_for_launch = b;
856    }
857
858    bool
859    GetIgnoreExisting () const
860    {
861        return m_ignore_existing;
862    }
863
864    void
865    SetIgnoreExisting (bool b)
866    {
867        m_ignore_existing = b;
868    }
869
870    bool
871    GetContinueOnceAttached () const
872    {
873        return m_continue_once_attached;
874    }
875
876    void
877    SetContinueOnceAttached (bool b)
878    {
879        m_continue_once_attached = b;
880    }
881
882    uint32_t
883    GetResumeCount () const
884    {
885        return m_resume_count;
886    }
887
888    void
889    SetResumeCount (uint32_t c)
890    {
891        m_resume_count = c;
892    }
893
894    const char *
895    GetProcessPluginName () const
896    {
897        if (m_plugin_name.empty())
898            return NULL;
899        return m_plugin_name.c_str();
900    }
901
902    void
903    SetProcessPluginName (const char *plugin)
904    {
905        if (plugin && plugin[0])
906            m_plugin_name.assign (plugin);
907        else
908            m_plugin_name.clear();
909    }
910
911    void
912    Clear ()
913    {
914        ProcessInstanceInfo::Clear();
915        m_plugin_name.clear();
916        m_resume_count = 0;
917        m_wait_for_launch = false;
918        m_ignore_existing = true;
919        m_continue_once_attached = false;
920    }
921
922    bool
923    ProcessInfoSpecified () const
924    {
925        if (GetExecutableFile())
926            return true;
927        if (GetProcessID() != LLDB_INVALID_PROCESS_ID)
928            return true;
929        if (GetParentProcessID() != LLDB_INVALID_PROCESS_ID)
930            return true;
931        return false;
932    }
933protected:
934    std::string m_plugin_name;
935    uint32_t m_resume_count; // How many times do we resume after launching
936    bool m_wait_for_launch;
937    bool m_ignore_existing;
938    bool m_continue_once_attached; // Supports the use-case scenario of immediately continuing the process once attached.
939};
940
941class ProcessLaunchCommandOptions : public Options
942{
943public:
944
945    ProcessLaunchCommandOptions (CommandInterpreter &interpreter) :
946        Options(interpreter)
947    {
948        // Keep default values of all options in one place: OptionParsingStarting ()
949        OptionParsingStarting ();
950    }
951
952    ~ProcessLaunchCommandOptions ()
953    {
954    }
955
956    Error
957    SetOptionValue (uint32_t option_idx, const char *option_arg);
958
959    void
960    OptionParsingStarting ()
961    {
962        launch_info.Clear();
963    }
964
965    const OptionDefinition*
966    GetDefinitions ()
967    {
968        return g_option_table;
969    }
970
971    // Options table: Required for subclasses of Options.
972
973    static OptionDefinition g_option_table[];
974
975    // Instance variables to hold the values for command options.
976
977    ProcessLaunchInfo launch_info;
978};
979
980//----------------------------------------------------------------------
981// ProcessInstanceInfoMatch
982//
983// A class to help matching one ProcessInstanceInfo to another.
984//----------------------------------------------------------------------
985
986class ProcessInstanceInfoMatch
987{
988public:
989    ProcessInstanceInfoMatch () :
990        m_match_info (),
991        m_name_match_type (eNameMatchIgnore),
992        m_match_all_users (false)
993    {
994    }
995
996    ProcessInstanceInfoMatch (const char *process_name,
997                              NameMatchType process_name_match_type) :
998        m_match_info (),
999        m_name_match_type (process_name_match_type),
1000        m_match_all_users (false)
1001    {
1002        m_match_info.GetExecutableFile().SetFile(process_name, false);
1003    }
1004
1005    ProcessInstanceInfo &
1006    GetProcessInfo ()
1007    {
1008        return m_match_info;
1009    }
1010
1011    const ProcessInstanceInfo &
1012    GetProcessInfo () const
1013    {
1014        return m_match_info;
1015    }
1016
1017    bool
1018    GetMatchAllUsers () const
1019    {
1020        return m_match_all_users;
1021    }
1022
1023    void
1024    SetMatchAllUsers (bool b)
1025    {
1026        m_match_all_users = b;
1027    }
1028
1029    NameMatchType
1030    GetNameMatchType () const
1031    {
1032        return m_name_match_type;
1033    }
1034
1035    void
1036    SetNameMatchType (NameMatchType name_match_type)
1037    {
1038        m_name_match_type = name_match_type;
1039    }
1040
1041    bool
1042    NameMatches (const char *process_name) const;
1043
1044    bool
1045    Matches (const ProcessInstanceInfo &proc_info) const;
1046
1047    bool
1048    MatchAllProcesses () const;
1049    void
1050    Clear ();
1051
1052protected:
1053    ProcessInstanceInfo m_match_info;
1054    NameMatchType m_name_match_type;
1055    bool m_match_all_users;
1056};
1057
1058class ProcessInstanceInfoList
1059{
1060public:
1061    ProcessInstanceInfoList () :
1062        m_infos()
1063    {
1064    }
1065
1066    void
1067    Clear()
1068    {
1069        m_infos.clear();
1070    }
1071
1072    size_t
1073    GetSize()
1074    {
1075        return m_infos.size();
1076    }
1077
1078    void
1079    Append (const ProcessInstanceInfo &info)
1080    {
1081        m_infos.push_back (info);
1082    }
1083
1084    const char *
1085    GetProcessNameAtIndex (size_t idx)
1086    {
1087        if (idx < m_infos.size())
1088            return m_infos[idx].GetName();
1089        return NULL;
1090    }
1091
1092    size_t
1093    GetProcessNameLengthAtIndex (size_t idx)
1094    {
1095        if (idx < m_infos.size())
1096            return m_infos[idx].GetNameLength();
1097        return 0;
1098    }
1099
1100    lldb::pid_t
1101    GetProcessIDAtIndex (size_t idx)
1102    {
1103        if (idx < m_infos.size())
1104            return m_infos[idx].GetProcessID();
1105        return 0;
1106    }
1107
1108    bool
1109    GetInfoAtIndex (size_t idx, ProcessInstanceInfo &info)
1110    {
1111        if (idx < m_infos.size())
1112        {
1113            info = m_infos[idx];
1114            return true;
1115        }
1116        return false;
1117    }
1118
1119    // You must ensure "idx" is valid before calling this function
1120    const ProcessInstanceInfo &
1121    GetProcessInfoAtIndex (size_t idx) const
1122    {
1123        assert (idx < m_infos.size());
1124        return m_infos[idx];
1125    }
1126
1127protected:
1128    typedef std::vector<ProcessInstanceInfo> collection;
1129    collection m_infos;
1130};
1131
1132
1133// This class tracks the Modification state of the process.  Things that can currently modify
1134// the program are running the program (which will up the StopID) and writing memory (which
1135// will up the MemoryID.)
1136// FIXME: Should we also include modification of register states?
1137
1138class ProcessModID
1139{
1140friend bool operator== (const ProcessModID &lhs, const ProcessModID &rhs);
1141public:
1142    ProcessModID () :
1143        m_stop_id (0),
1144        m_last_natural_stop_id(0),
1145        m_resume_id (0),
1146        m_memory_id (0),
1147        m_last_user_expression_resume (0),
1148        m_running_user_expression (false)
1149    {}
1150
1151    ProcessModID (const ProcessModID &rhs) :
1152        m_stop_id (rhs.m_stop_id),
1153        m_memory_id (rhs.m_memory_id)
1154    {}
1155
1156    const ProcessModID & operator= (const ProcessModID &rhs)
1157    {
1158        if (this != &rhs)
1159        {
1160            m_stop_id = rhs.m_stop_id;
1161            m_memory_id = rhs.m_memory_id;
1162        }
1163        return *this;
1164    }
1165
1166    ~ProcessModID () {}
1167
1168    void BumpStopID () {
1169        m_stop_id++;
1170        if (!IsLastResumeForUserExpression())
1171            m_last_natural_stop_id++;
1172    }
1173
1174    void BumpMemoryID () { m_memory_id++; }
1175
1176    void BumpResumeID () {
1177        m_resume_id++;
1178        if (m_running_user_expression > 0)
1179            m_last_user_expression_resume = m_resume_id;
1180    }
1181
1182    uint32_t GetStopID() const { return m_stop_id; }
1183    uint32_t GetLastNaturalStopID() const { return m_last_natural_stop_id; }
1184    uint32_t GetMemoryID () const { return m_memory_id; }
1185    uint32_t GetResumeID () const { return m_resume_id; }
1186    uint32_t GetLastUserExpressionResumeID () const { return m_last_user_expression_resume; }
1187
1188    bool MemoryIDEqual (const ProcessModID &compare) const
1189    {
1190        return m_memory_id == compare.m_memory_id;
1191    }
1192
1193    bool StopIDEqual (const ProcessModID &compare) const
1194    {
1195        return m_stop_id == compare.m_stop_id;
1196    }
1197
1198    void SetInvalid ()
1199    {
1200        m_stop_id = UINT32_MAX;
1201    }
1202
1203    bool IsValid () const
1204    {
1205        return m_stop_id != UINT32_MAX;
1206    }
1207
1208    bool
1209    IsLastResumeForUserExpression () const
1210    {
1211        return m_resume_id == m_last_user_expression_resume;
1212    }
1213
1214    void
1215    SetRunningUserExpression (bool on)
1216    {
1217        // REMOVEME printf ("Setting running user expression %s at resume id %d - value: %d.\n", on ? "on" : "off", m_resume_id, m_running_user_expression);
1218        if (on)
1219            m_running_user_expression++;
1220        else
1221            m_running_user_expression--;
1222    }
1223
1224private:
1225    uint32_t m_stop_id;
1226    uint32_t m_last_natural_stop_id;
1227    uint32_t m_resume_id;
1228    uint32_t m_memory_id;
1229    uint32_t m_last_user_expression_resume;
1230    uint32_t m_running_user_expression;
1231};
1232inline bool operator== (const ProcessModID &lhs, const ProcessModID &rhs)
1233{
1234    if (lhs.StopIDEqual (rhs)
1235        && lhs.MemoryIDEqual (rhs))
1236        return true;
1237    else
1238        return false;
1239}
1240
1241inline bool operator!= (const ProcessModID &lhs, const ProcessModID &rhs)
1242{
1243    if (!lhs.StopIDEqual (rhs)
1244        || !lhs.MemoryIDEqual (rhs))
1245        return true;
1246    else
1247        return false;
1248}
1249
1250class MemoryRegionInfo
1251{
1252public:
1253    typedef Range<lldb::addr_t, lldb::addr_t> RangeType;
1254
1255    enum OptionalBool {
1256        eDontKnow  = -1,
1257        eNo         = 0,
1258        eYes        = 1
1259    };
1260
1261    MemoryRegionInfo () :
1262        m_range (),
1263        m_read (eDontKnow),
1264        m_write (eDontKnow),
1265        m_execute (eDontKnow)
1266    {
1267    }
1268
1269    ~MemoryRegionInfo ()
1270    {
1271    }
1272
1273    RangeType &
1274    GetRange()
1275    {
1276        return m_range;
1277    }
1278
1279    void
1280    Clear()
1281    {
1282        m_range.Clear();
1283        m_read = m_write = m_execute = eDontKnow;
1284    }
1285
1286    const RangeType &
1287    GetRange() const
1288    {
1289        return m_range;
1290    }
1291
1292    OptionalBool
1293    GetReadable () const
1294    {
1295        return m_read;
1296    }
1297
1298    OptionalBool
1299    GetWritable () const
1300    {
1301        return m_write;
1302    }
1303
1304    OptionalBool
1305    GetExecutable () const
1306    {
1307        return m_execute;
1308    }
1309
1310    void
1311    SetReadable (OptionalBool val)
1312    {
1313        m_read = val;
1314    }
1315
1316    void
1317    SetWritable (OptionalBool val)
1318    {
1319        m_write = val;
1320    }
1321
1322    void
1323    SetExecutable (OptionalBool val)
1324    {
1325        m_execute = val;
1326    }
1327
1328protected:
1329    RangeType m_range;
1330    OptionalBool m_read;
1331    OptionalBool m_write;
1332    OptionalBool m_execute;
1333};
1334
1335//----------------------------------------------------------------------
1336/// @class Process Process.h "lldb/Target/Process.h"
1337/// @brief A plug-in interface definition class for debugging a process.
1338//----------------------------------------------------------------------
1339class Process :
1340    public STD_ENABLE_SHARED_FROM_THIS(Process),
1341    public ProcessProperties,
1342    public UserID,
1343    public Broadcaster,
1344    public ExecutionContextScope,
1345    public PluginInterface
1346{
1347friend class ThreadList;
1348friend class ClangFunction; // For WaitForStateChangeEventsPrivate
1349friend class CommandObjectProcessLaunch;
1350friend class ProcessEventData;
1351friend class CommandObjectBreakpointCommand;
1352friend class StopInfo;
1353
1354public:
1355
1356    //------------------------------------------------------------------
1357    /// Broadcaster event bits definitions.
1358    //------------------------------------------------------------------
1359    enum
1360    {
1361        eBroadcastBitStateChanged   = (1 << 0),
1362        eBroadcastBitInterrupt      = (1 << 1),
1363        eBroadcastBitSTDOUT         = (1 << 2),
1364        eBroadcastBitSTDERR         = (1 << 3),
1365        eBroadcastBitProfileData    = (1 << 4)
1366    };
1367
1368    enum
1369    {
1370        eBroadcastInternalStateControlStop = (1<<0),
1371        eBroadcastInternalStateControlPause = (1<<1),
1372        eBroadcastInternalStateControlResume = (1<<2)
1373    };
1374
1375    typedef Range<lldb::addr_t, lldb::addr_t> LoadRange;
1376    // We use a read/write lock to allow on or more clients to
1377    // access the process state while the process is stopped (reader).
1378    // We lock the write lock to control access to the process
1379    // while it is running (readers, or clients that want the process
1380    // stopped can block waiting for the process to stop, or just
1381    // try to lock it to see if they can immediately access the stopped
1382    // process. If the try read lock fails, then the process is running.
1383    typedef ReadWriteLock::ReadLocker StopLocker;
1384    typedef ReadWriteLock::WriteLocker RunLocker;
1385
1386    // These two functions fill out the Broadcaster interface:
1387
1388    static ConstString &GetStaticBroadcasterClass ();
1389
1390    virtual ConstString &GetBroadcasterClass() const
1391    {
1392        return GetStaticBroadcasterClass();
1393    }
1394
1395
1396    //------------------------------------------------------------------
1397    /// A notification structure that can be used by clients to listen
1398    /// for changes in a process's lifetime.
1399    ///
1400    /// @see RegisterNotificationCallbacks (const Notifications&)
1401    /// @see UnregisterNotificationCallbacks (const Notifications&)
1402    //------------------------------------------------------------------
1403#ifndef SWIG
1404    typedef struct
1405    {
1406        void *baton;
1407        void (*initialize)(void *baton, Process *process);
1408        void (*process_state_changed) (void *baton, Process *process, lldb::StateType state);
1409    } Notifications;
1410
1411    class ProcessEventData :
1412        public EventData
1413    {
1414        friend class Process;
1415
1416        public:
1417            ProcessEventData ();
1418            ProcessEventData (const lldb::ProcessSP &process, lldb::StateType state);
1419
1420            virtual ~ProcessEventData();
1421
1422            static const ConstString &
1423            GetFlavorString ();
1424
1425            virtual const ConstString &
1426            GetFlavor () const;
1427
1428            const lldb::ProcessSP &
1429            GetProcessSP() const
1430            {
1431                return m_process_sp;
1432            }
1433            lldb::StateType
1434            GetState() const
1435            {
1436                return m_state;
1437            }
1438            bool
1439            GetRestarted () const
1440            {
1441                return m_restarted;
1442            }
1443            bool
1444            GetInterrupted () const
1445            {
1446                return m_interrupted;
1447            }
1448
1449            virtual void
1450            Dump (Stream *s) const;
1451
1452            virtual void
1453            DoOnRemoval (Event *event_ptr);
1454
1455            static const Process::ProcessEventData *
1456            GetEventDataFromEvent (const Event *event_ptr);
1457
1458            static lldb::ProcessSP
1459            GetProcessFromEvent (const Event *event_ptr);
1460
1461            static lldb::StateType
1462            GetStateFromEvent (const Event *event_ptr);
1463
1464            static bool
1465            GetRestartedFromEvent (const Event *event_ptr);
1466
1467            static void
1468            SetRestartedInEvent (Event *event_ptr, bool new_value);
1469
1470            static bool
1471            GetInterruptedFromEvent (const Event *event_ptr);
1472
1473            static void
1474            SetInterruptedInEvent (Event *event_ptr, bool new_value);
1475
1476            static bool
1477            SetUpdateStateOnRemoval (Event *event_ptr);
1478
1479       private:
1480
1481            void
1482            SetUpdateStateOnRemoval()
1483            {
1484                m_update_state++;
1485            }
1486            void
1487            SetRestarted (bool new_value)
1488            {
1489                m_restarted = new_value;
1490            }
1491            void
1492            SetInterrupted (bool new_value)
1493            {
1494                m_interrupted = new_value;
1495            }
1496
1497            lldb::ProcessSP m_process_sp;
1498            lldb::StateType m_state;
1499            bool m_restarted;  // For "eStateStopped" events, this is true if the target was automatically restarted.
1500            int m_update_state;
1501            bool m_interrupted;
1502            DISALLOW_COPY_AND_ASSIGN (ProcessEventData);
1503
1504    };
1505
1506#endif
1507
1508    static void
1509    SettingsInitialize ();
1510
1511    static void
1512    SettingsTerminate ();
1513
1514    static const ProcessPropertiesSP &
1515    GetGlobalProperties();
1516
1517    //------------------------------------------------------------------
1518    /// Construct with a shared pointer to a target, and the Process listener.
1519    //------------------------------------------------------------------
1520    Process(Target &target, Listener &listener);
1521
1522    //------------------------------------------------------------------
1523    /// Destructor.
1524    ///
1525    /// The destructor is virtual since this class is designed to be
1526    /// inherited from by the plug-in instance.
1527    //------------------------------------------------------------------
1528    virtual
1529    ~Process();
1530
1531    //------------------------------------------------------------------
1532    /// Find a Process plug-in that can debug \a module using the
1533    /// currently selected architecture.
1534    ///
1535    /// Scans all loaded plug-in interfaces that implement versions of
1536    /// the Process plug-in interface and returns the first instance
1537    /// that can debug the file.
1538    ///
1539    /// @param[in] module_sp
1540    ///     The module shared pointer that this process will debug.
1541    ///
1542    /// @param[in] plugin_name
1543    ///     If NULL, select the best plug-in for the binary. If non-NULL
1544    ///     then look for a plugin whose PluginInfo's name matches
1545    ///     this string.
1546    ///
1547    /// @see Process::CanDebug ()
1548    //------------------------------------------------------------------
1549    static lldb::ProcessSP
1550    FindPlugin (Target &target,
1551                const char *plugin_name,
1552                Listener &listener,
1553                const FileSpec *crash_file_path);
1554
1555
1556
1557    //------------------------------------------------------------------
1558    /// Static function that can be used with the \b host function
1559    /// Host::StartMonitoringChildProcess ().
1560    ///
1561    /// This function can be used by lldb_private::Process subclasses
1562    /// when they want to watch for a local process and have its exit
1563    /// status automatically set when the host child process exits.
1564    /// Subclasses should call Host::StartMonitoringChildProcess ()
1565    /// with:
1566    ///     callback = Process::SetHostProcessExitStatus
1567    ///     callback_baton = NULL
1568    ///     pid = Process::GetID()
1569    ///     monitor_signals = false
1570    //------------------------------------------------------------------
1571    static bool
1572    SetProcessExitStatus (void *callback_baton,   // The callback baton which should be set to NULL
1573                          lldb::pid_t pid,        // The process ID we want to monitor
1574                          bool exited,
1575                          int signo,              // Zero for no signal
1576                          int status);            // Exit value of process if signal is zero
1577
1578    lldb::ByteOrder
1579    GetByteOrder () const;
1580
1581    uint32_t
1582    GetAddressByteSize () const;
1583
1584    uint32_t
1585    GetUniqueID() const
1586    {
1587        return m_process_unique_id;
1588    }
1589    //------------------------------------------------------------------
1590    /// Check if a plug-in instance can debug the file in \a module.
1591    ///
1592    /// Each plug-in is given a chance to say whether it can debug
1593    /// the file in \a module. If the Process plug-in instance can
1594    /// debug a file on the current system, it should return \b true.
1595    ///
1596    /// @return
1597    ///     Returns \b true if this Process plug-in instance can
1598    ///     debug the executable, \b false otherwise.
1599    //------------------------------------------------------------------
1600    virtual bool
1601    CanDebug (Target &target,
1602              bool plugin_specified_by_name) = 0;
1603
1604
1605    //------------------------------------------------------------------
1606    /// This object is about to be destroyed, do any necessary cleanup.
1607    ///
1608    /// Subclasses that override this method should always call this
1609    /// superclass method.
1610    //------------------------------------------------------------------
1611    virtual void
1612    Finalize();
1613
1614
1615    //------------------------------------------------------------------
1616    /// Return whether this object is valid (i.e. has not been finalized.)
1617    ///
1618    /// @return
1619    ///     Returns \b true if this Process has not been finalized
1620    ///     and \b false otherwise.
1621    //------------------------------------------------------------------
1622    bool
1623    IsValid() const
1624    {
1625        return !m_finalize_called;
1626    }
1627
1628    //------------------------------------------------------------------
1629    /// Return a multi-word command object that can be used to expose
1630    /// plug-in specific commands.
1631    ///
1632    /// This object will be used to resolve plug-in commands and can be
1633    /// triggered by a call to:
1634    ///
1635    ///     (lldb) process commmand <args>
1636    ///
1637    /// @return
1638    ///     A CommandObject which can be one of the concrete subclasses
1639    ///     of CommandObject like CommandObjectRaw, CommandObjectParsed,
1640    ///     or CommandObjectMultiword.
1641    //------------------------------------------------------------------
1642    virtual CommandObject *
1643    GetPluginCommandObject()
1644    {
1645        return NULL;
1646    }
1647
1648    //------------------------------------------------------------------
1649    /// Launch a new process.
1650    ///
1651    /// Launch a new process by spawning a new process using the
1652    /// target object's executable module's file as the file to launch.
1653    /// Arguments are given in \a argv, and the environment variables
1654    /// are in \a envp. Standard input and output files can be
1655    /// optionally re-directed to \a stdin_path, \a stdout_path, and
1656    /// \a stderr_path.
1657    ///
1658    /// This function is not meant to be overridden by Process
1659    /// subclasses. It will first call Process::WillLaunch (Module *)
1660    /// and if that returns \b true, Process::DoLaunch (Module*,
1661    /// char const *[],char const *[],const char *,const char *,
1662    /// const char *) will be called to actually do the launching. If
1663    /// DoLaunch returns \b true, then Process::DidLaunch() will be
1664    /// called.
1665    ///
1666    /// @param[in] argv
1667    ///     The argument array.
1668    ///
1669    /// @param[in] envp
1670    ///     The environment array.
1671    ///
1672    /// @param[in] launch_flags
1673    ///     Flags to modify the launch (@see lldb::LaunchFlags)
1674    ///
1675    /// @param[in] stdin_path
1676    ///     The path to use when re-directing the STDIN of the new
1677    ///     process. If all stdXX_path arguments are NULL, a pseudo
1678    ///     terminal will be used.
1679    ///
1680    /// @param[in] stdout_path
1681    ///     The path to use when re-directing the STDOUT of the new
1682    ///     process. If all stdXX_path arguments are NULL, a pseudo
1683    ///     terminal will be used.
1684    ///
1685    /// @param[in] stderr_path
1686    ///     The path to use when re-directing the STDERR of the new
1687    ///     process. If all stdXX_path arguments are NULL, a pseudo
1688    ///     terminal will be used.
1689    ///
1690    /// @param[in] working_directory
1691    ///     The working directory to have the child process run in
1692    ///
1693    /// @return
1694    ///     An error object. Call GetID() to get the process ID if
1695    ///     the error object is success.
1696    //------------------------------------------------------------------
1697    virtual Error
1698    Launch (const ProcessLaunchInfo &launch_info);
1699
1700    virtual Error
1701    LoadCore ();
1702
1703    virtual Error
1704    DoLoadCore ()
1705    {
1706        Error error;
1707        error.SetErrorStringWithFormat("error: %s does not support loading core files.", GetShortPluginName());
1708        return error;
1709    }
1710
1711    //------------------------------------------------------------------
1712    /// Get the dynamic loader plug-in for this process.
1713    ///
1714    /// The default action is to let the DynamicLoader plug-ins check
1715    /// the main executable and the DynamicLoader will select itself
1716    /// automatically. Subclasses can override this if inspecting the
1717    /// executable is not desired, or if Process subclasses can only
1718    /// use a specific DynamicLoader plug-in.
1719    //------------------------------------------------------------------
1720    virtual DynamicLoader *
1721    GetDynamicLoader ();
1722
1723    //------------------------------------------------------------------
1724    /// Attach to an existing process using the process attach info.
1725    ///
1726    /// This function is not meant to be overridden by Process
1727    /// subclasses. It will first call WillAttach (lldb::pid_t)
1728    /// or WillAttach (const char *), and if that returns \b
1729    /// true, DoAttach (lldb::pid_t) or DoAttach (const char *) will
1730    /// be called to actually do the attach. If DoAttach returns \b
1731    /// true, then Process::DidAttach() will be called.
1732    ///
1733    /// @param[in] pid
1734    ///     The process ID that we should attempt to attach to.
1735    ///
1736    /// @return
1737    ///     Returns \a pid if attaching was successful, or
1738    ///     LLDB_INVALID_PROCESS_ID if attaching fails.
1739    //------------------------------------------------------------------
1740    virtual Error
1741    Attach (ProcessAttachInfo &attach_info);
1742
1743    //------------------------------------------------------------------
1744    /// Attach to a remote system via a URL
1745    ///
1746    /// @param[in] strm
1747    ///     A stream where output intended for the user
1748    ///     (if the driver has a way to display that) generated during
1749    ///     the connection.  This may be NULL if no output is needed.A
1750    ///
1751    /// @param[in] remote_url
1752    ///     The URL format that we are connecting to.
1753    ///
1754    /// @return
1755    ///     Returns an error object.
1756    //------------------------------------------------------------------
1757    virtual Error
1758    ConnectRemote (Stream *strm, const char *remote_url);
1759
1760    bool
1761    GetShouldDetach () const
1762    {
1763        return m_should_detach;
1764    }
1765
1766    void
1767    SetShouldDetach (bool b)
1768    {
1769        m_should_detach = b;
1770    }
1771
1772    //------------------------------------------------------------------
1773    /// Get the image information address for the current process.
1774    ///
1775    /// Some runtimes have system functions that can help dynamic
1776    /// loaders locate the dynamic loader information needed to observe
1777    /// shared libraries being loaded or unloaded. This function is
1778    /// in the Process interface (as opposed to the DynamicLoader
1779    /// interface) to ensure that remote debugging can take advantage of
1780    /// this functionality.
1781    ///
1782    /// @return
1783    ///     The address of the dynamic loader information, or
1784    ///     LLDB_INVALID_ADDRESS if this is not supported by this
1785    ///     interface.
1786    //------------------------------------------------------------------
1787    virtual lldb::addr_t
1788    GetImageInfoAddress ();
1789
1790    //------------------------------------------------------------------
1791    /// Load a shared library into this process.
1792    ///
1793    /// Try and load a shared library into the current process. This
1794    /// call might fail in the dynamic loader plug-in says it isn't safe
1795    /// to try and load shared libraries at the moment.
1796    ///
1797    /// @param[in] image_spec
1798    ///     The image file spec that points to the shared library that
1799    ///     you want to load.
1800    ///
1801    /// @param[out] error
1802    ///     An error object that gets filled in with any errors that
1803    ///     might occur when trying to load the shared library.
1804    ///
1805    /// @return
1806    ///     A token that represents the shared library that can be
1807    ///     later used to unload the shared library. A value of
1808    ///     LLDB_INVALID_IMAGE_TOKEN will be returned if the shared
1809    ///     library can't be opened.
1810    //------------------------------------------------------------------
1811    virtual uint32_t
1812    LoadImage (const FileSpec &image_spec, Error &error);
1813
1814    virtual Error
1815    UnloadImage (uint32_t image_token);
1816
1817    //------------------------------------------------------------------
1818    /// Register for process and thread notifications.
1819    ///
1820    /// Clients can register nofication callbacks by filling out a
1821    /// Process::Notifications structure and calling this function.
1822    ///
1823    /// @param[in] callbacks
1824    ///     A structure that contains the notification baton and
1825    ///     callback functions.
1826    ///
1827    /// @see Process::Notifications
1828    //------------------------------------------------------------------
1829#ifndef SWIG
1830    void
1831    RegisterNotificationCallbacks (const Process::Notifications& callbacks);
1832#endif
1833    //------------------------------------------------------------------
1834    /// Unregister for process and thread notifications.
1835    ///
1836    /// Clients can unregister nofication callbacks by passing a copy of
1837    /// the original baton and callbacks in \a callbacks.
1838    ///
1839    /// @param[in] callbacks
1840    ///     A structure that contains the notification baton and
1841    ///     callback functions.
1842    ///
1843    /// @return
1844    ///     Returns \b true if the notification callbacks were
1845    ///     successfully removed from the process, \b false otherwise.
1846    ///
1847    /// @see Process::Notifications
1848    //------------------------------------------------------------------
1849#ifndef SWIG
1850    bool
1851    UnregisterNotificationCallbacks (const Process::Notifications& callbacks);
1852#endif
1853    //==================================================================
1854    // Built in Process Control functions
1855    //==================================================================
1856    //------------------------------------------------------------------
1857    /// Resumes all of a process's threads as configured using the
1858    /// Thread run control functions.
1859    ///
1860    /// Threads for a process should be updated with one of the run
1861    /// control actions (resume, step, or suspend) that they should take
1862    /// when the process is resumed. If no run control action is given
1863    /// to a thread it will be resumed by default.
1864    ///
1865    /// This function is not meant to be overridden by Process
1866    /// subclasses. This function will take care of disabling any
1867    /// breakpoints that threads may be stopped at, single stepping, and
1868    /// re-enabling breakpoints, and enabling the basic flow control
1869    /// that the plug-in instances need not worry about.
1870    ///
1871    /// N.B. This function also sets the Write side of the Run Lock,
1872    /// which is unset when the corresponding stop event is pulled off
1873    /// the Public Event Queue.  If you need to resume the process without
1874    /// setting the Run Lock, use PrivateResume (though you should only do
1875    /// that from inside the Process class.
1876    ///
1877    /// @return
1878    ///     Returns an error object.
1879    ///
1880    /// @see Thread:Resume()
1881    /// @see Thread:Step()
1882    /// @see Thread:Suspend()
1883    //------------------------------------------------------------------
1884    Error
1885    Resume();
1886
1887    //------------------------------------------------------------------
1888    /// Halts a running process.
1889    ///
1890    /// This function is not meant to be overridden by Process
1891    /// subclasses.
1892    /// If the process is successfully halted, a eStateStopped
1893    /// process event with GetInterrupted will be broadcast.  If false, we will
1894    /// halt the process with no events generated by the halt.
1895    ///
1896    /// @return
1897    ///     Returns an error object.  If the error is empty, the process is halted.
1898    ///     otherwise the halt has failed.
1899    //------------------------------------------------------------------
1900    Error
1901    Halt ();
1902
1903    //------------------------------------------------------------------
1904    /// Detaches from a running or stopped process.
1905    ///
1906    /// This function is not meant to be overridden by Process
1907    /// subclasses.
1908    ///
1909    /// @return
1910    ///     Returns an error object.
1911    //------------------------------------------------------------------
1912    Error
1913    Detach ();
1914
1915    //------------------------------------------------------------------
1916    /// Kills the process and shuts down all threads that were spawned
1917    /// to track and monitor the process.
1918    ///
1919    /// This function is not meant to be overridden by Process
1920    /// subclasses.
1921    ///
1922    /// @return
1923    ///     Returns an error object.
1924    //------------------------------------------------------------------
1925    Error
1926    Destroy();
1927
1928    //------------------------------------------------------------------
1929    /// Sends a process a UNIX signal \a signal.
1930    ///
1931    /// This function is not meant to be overridden by Process
1932    /// subclasses.
1933    ///
1934    /// @return
1935    ///     Returns an error object.
1936    //------------------------------------------------------------------
1937    Error
1938    Signal (int signal);
1939
1940    virtual UnixSignals &
1941    GetUnixSignals ()
1942    {
1943        return m_unix_signals;
1944    }
1945
1946    //==================================================================
1947    // Plug-in Process Control Overrides
1948    //==================================================================
1949
1950    //------------------------------------------------------------------
1951    /// Called before attaching to a process.
1952    ///
1953    /// Allow Process plug-ins to execute some code before attaching a
1954    /// process.
1955    ///
1956    /// @return
1957    ///     Returns an error object.
1958    //------------------------------------------------------------------
1959    virtual Error
1960    WillAttachToProcessWithID (lldb::pid_t pid)
1961    {
1962        return Error();
1963    }
1964
1965    //------------------------------------------------------------------
1966    /// Called before attaching to a process.
1967    ///
1968    /// Allow Process plug-ins to execute some code before attaching a
1969    /// process.
1970    ///
1971    /// @return
1972    ///     Returns an error object.
1973    //------------------------------------------------------------------
1974    virtual Error
1975    WillAttachToProcessWithName (const char *process_name, bool wait_for_launch)
1976    {
1977        return Error();
1978    }
1979
1980    //------------------------------------------------------------------
1981    /// Attach to a remote system via a URL
1982    ///
1983    /// @param[in] strm
1984    ///     A stream where output intended for the user
1985    ///     (if the driver has a way to display that) generated during
1986    ///     the connection.  This may be NULL if no output is needed.A
1987    ///
1988    /// @param[in] remote_url
1989    ///     The URL format that we are connecting to.
1990    ///
1991    /// @return
1992    ///     Returns an error object.
1993    //------------------------------------------------------------------
1994    virtual Error
1995    DoConnectRemote (Stream *strm, const char *remote_url)
1996    {
1997        Error error;
1998        error.SetErrorString ("remote connections are not supported");
1999        return error;
2000    }
2001
2002    //------------------------------------------------------------------
2003    /// Attach to an existing process using a process ID.
2004    ///
2005    /// @param[in] pid
2006    ///     The process ID that we should attempt to attach to.
2007    ///
2008    /// @return
2009    ///     Returns \a pid if attaching was successful, or
2010    ///     LLDB_INVALID_PROCESS_ID if attaching fails.
2011    //------------------------------------------------------------------
2012    virtual Error
2013    DoAttachToProcessWithID (lldb::pid_t pid)
2014    {
2015        Error error;
2016        error.SetErrorStringWithFormat("error: %s does not support attaching to a process by pid", GetShortPluginName());
2017        return error;
2018    }
2019
2020    //------------------------------------------------------------------
2021    /// Attach to an existing process using a process ID.
2022    ///
2023    /// @param[in] pid
2024    ///     The process ID that we should attempt to attach to.
2025    ///
2026    /// @param[in] attach_info
2027    ///     Information on how to do the attach. For example, GetUserID()
2028    ///     will return the uid to attach as.
2029    ///
2030    /// @return
2031    ///     Returns \a pid if attaching was successful, or
2032    ///     LLDB_INVALID_PROCESS_ID if attaching fails.
2033    /// hanming : need flag
2034    //------------------------------------------------------------------
2035    virtual Error
2036    DoAttachToProcessWithID (lldb::pid_t pid,  const ProcessAttachInfo &attach_info)
2037    {
2038        Error error;
2039        error.SetErrorStringWithFormat("error: %s does not support attaching to a process by pid", GetShortPluginName());
2040        return error;
2041    }
2042
2043    //------------------------------------------------------------------
2044    /// Attach to an existing process using a partial process name.
2045    ///
2046    /// @param[in] process_name
2047    ///     The name of the process to attach to.
2048    ///
2049    /// @param[in] wait_for_launch
2050    ///     If \b true, wait for the process to be launched and attach
2051    ///     as soon as possible after it does launch. If \b false, then
2052    ///     search for a matching process the currently exists.
2053    ///
2054    /// @param[in] attach_info
2055    ///     Information on how to do the attach. For example, GetUserID()
2056    ///     will return the uid to attach as.
2057    ///
2058    /// @return
2059    ///     Returns \a pid if attaching was successful, or
2060    ///     LLDB_INVALID_PROCESS_ID if attaching fails.
2061    //------------------------------------------------------------------
2062    virtual Error
2063    DoAttachToProcessWithName (const char *process_name, bool wait_for_launch, const ProcessAttachInfo &attach_info)
2064    {
2065        Error error;
2066        error.SetErrorString("attach by name is not supported");
2067        return error;
2068    }
2069
2070    //------------------------------------------------------------------
2071    /// Called after attaching a process.
2072    ///
2073    /// Allow Process plug-ins to execute some code after attaching to
2074    /// a process.
2075    //------------------------------------------------------------------
2076    virtual void
2077    DidAttach () {}
2078
2079
2080    //------------------------------------------------------------------
2081    /// Called after a process re-execs itself.
2082    ///
2083    /// Allow Process plug-ins to execute some code after a process has
2084    /// exec'ed itself. Subclasses typically should override DoDidExec()
2085    /// as the lldb_private::Process class needs to remove its dynamic
2086    /// loader, runtime, ABI and other plug-ins, as well as unload all
2087    /// shared libraries.
2088    //------------------------------------------------------------------
2089    virtual void
2090    DidExec ();
2091
2092    //------------------------------------------------------------------
2093    /// Subclasses of Process should implement this function if they
2094    /// need to do anything after a process exec's itself.
2095    //------------------------------------------------------------------
2096    virtual void
2097    DoDidExec ()
2098    {
2099    }
2100
2101    //------------------------------------------------------------------
2102    /// Called before launching to a process.
2103    ///
2104    /// Allow Process plug-ins to execute some code before launching a
2105    /// process.
2106    ///
2107    /// @return
2108    ///     Returns an error object.
2109    //------------------------------------------------------------------
2110    virtual Error
2111    WillLaunch (Module* module)
2112    {
2113        return Error();
2114    }
2115
2116    //------------------------------------------------------------------
2117    /// Launch a new process.
2118    ///
2119    /// Launch a new process by spawning a new process using \a module's
2120    /// file as the file to launch. Arguments are given in \a argv,
2121    /// and the environment variables are in \a envp. Standard input
2122    /// and output files can be optionally re-directed to \a stdin_path,
2123    /// \a stdout_path, and \a stderr_path.
2124    ///
2125    /// @param[in] module
2126    ///     The module from which to extract the file specification and
2127    ///     launch.
2128    ///
2129    /// @param[in] argv
2130    ///     The argument array.
2131    ///
2132    /// @param[in] envp
2133    ///     The environment array.
2134    ///
2135    /// @param[in] launch_flags
2136    ///     Flags to modify the launch (@see lldb::LaunchFlags)
2137    ///
2138    /// @param[in] stdin_path
2139    ///     The path to use when re-directing the STDIN of the new
2140    ///     process. If all stdXX_path arguments are NULL, a pseudo
2141    ///     terminal will be used.
2142    ///
2143    /// @param[in] stdout_path
2144    ///     The path to use when re-directing the STDOUT of the new
2145    ///     process. If all stdXX_path arguments are NULL, a pseudo
2146    ///     terminal will be used.
2147    ///
2148    /// @param[in] stderr_path
2149    ///     The path to use when re-directing the STDERR of the new
2150    ///     process. If all stdXX_path arguments are NULL, a pseudo
2151    ///     terminal will be used.
2152    ///
2153    /// @param[in] working_directory
2154    ///     The working directory to have the child process run in
2155    ///
2156    /// @return
2157    ///     A new valid process ID, or LLDB_INVALID_PROCESS_ID if
2158    ///     launching fails.
2159    //------------------------------------------------------------------
2160    virtual Error
2161    DoLaunch (Module *exe_module,
2162              const ProcessLaunchInfo &launch_info)
2163    {
2164        Error error;
2165        error.SetErrorStringWithFormat("error: %s does not support launching processes", GetShortPluginName());
2166        return error;
2167    }
2168
2169
2170    //------------------------------------------------------------------
2171    /// Called after launching a process.
2172    ///
2173    /// Allow Process plug-ins to execute some code after launching
2174    /// a process.
2175    //------------------------------------------------------------------
2176    virtual void
2177    DidLaunch () {}
2178
2179
2180
2181    //------------------------------------------------------------------
2182    /// Called before resuming to a process.
2183    ///
2184    /// Allow Process plug-ins to execute some code before resuming a
2185    /// process.
2186    ///
2187    /// @return
2188    ///     Returns an error object.
2189    //------------------------------------------------------------------
2190    virtual Error
2191    WillResume () { return Error(); }
2192
2193    //------------------------------------------------------------------
2194    /// Resumes all of a process's threads as configured using the
2195    /// Thread run control functions.
2196    ///
2197    /// Threads for a process should be updated with one of the run
2198    /// control actions (resume, step, or suspend) that they should take
2199    /// when the process is resumed. If no run control action is given
2200    /// to a thread it will be resumed by default.
2201    ///
2202    /// @return
2203    ///     Returns \b true if the process successfully resumes using
2204    ///     the thread run control actions, \b false otherwise.
2205    ///
2206    /// @see Thread:Resume()
2207    /// @see Thread:Step()
2208    /// @see Thread:Suspend()
2209    //------------------------------------------------------------------
2210    virtual Error
2211    DoResume ()
2212    {
2213        Error error;
2214        error.SetErrorStringWithFormat("error: %s does not support resuming processes", GetShortPluginName());
2215        return error;
2216    }
2217
2218
2219    //------------------------------------------------------------------
2220    /// Called after resuming a process.
2221    ///
2222    /// Allow Process plug-ins to execute some code after resuming
2223    /// a process.
2224    //------------------------------------------------------------------
2225    virtual void
2226    DidResume () {}
2227
2228
2229    //------------------------------------------------------------------
2230    /// Called before halting to a process.
2231    ///
2232    /// Allow Process plug-ins to execute some code before halting a
2233    /// process.
2234    ///
2235    /// @return
2236    ///     Returns an error object.
2237    //------------------------------------------------------------------
2238    virtual Error
2239    WillHalt () { return Error(); }
2240
2241    //------------------------------------------------------------------
2242    /// Halts a running process.
2243    ///
2244    /// DoHalt must produce one and only one stop StateChanged event if it actually
2245    /// stops the process.  If the stop happens through some natural event (for
2246    /// instance a SIGSTOP), then forwarding that event will do.  Otherwise, you must
2247    /// generate the event manually.  Note also, the private event thread is stopped when
2248    /// DoHalt is run to prevent the events generated while halting to trigger
2249    /// other state changes before the halt is complete.
2250    ///
2251    /// @param[out] caused_stop
2252    ///     If true, then this Halt caused the stop, otherwise, the
2253    ///     process was already stopped.
2254    ///
2255    /// @return
2256    ///     Returns \b true if the process successfully halts, \b false
2257    ///     otherwise.
2258    //------------------------------------------------------------------
2259    virtual Error
2260    DoHalt (bool &caused_stop)
2261    {
2262        Error error;
2263        error.SetErrorStringWithFormat("error: %s does not support halting processes", GetShortPluginName());
2264        return error;
2265    }
2266
2267
2268    //------------------------------------------------------------------
2269    /// Called after halting a process.
2270    ///
2271    /// Allow Process plug-ins to execute some code after halting
2272    /// a process.
2273    //------------------------------------------------------------------
2274    virtual void
2275    DidHalt () {}
2276
2277    //------------------------------------------------------------------
2278    /// Called before detaching from a process.
2279    ///
2280    /// Allow Process plug-ins to execute some code before detaching
2281    /// from a process.
2282    ///
2283    /// @return
2284    ///     Returns an error object.
2285    //------------------------------------------------------------------
2286    virtual Error
2287    WillDetach ()
2288    {
2289        return Error();
2290    }
2291
2292    //------------------------------------------------------------------
2293    /// Detaches from a running or stopped process.
2294    ///
2295    /// @return
2296    ///     Returns \b true if the process successfully detaches, \b
2297    ///     false otherwise.
2298    //------------------------------------------------------------------
2299    virtual Error
2300    DoDetach ()
2301    {
2302        Error error;
2303        error.SetErrorStringWithFormat("error: %s does not support detaching from processes", GetShortPluginName());
2304        return error;
2305    }
2306
2307
2308    //------------------------------------------------------------------
2309    /// Called after detaching from a process.
2310    ///
2311    /// Allow Process plug-ins to execute some code after detaching
2312    /// from a process.
2313    //------------------------------------------------------------------
2314    virtual void
2315    DidDetach () {}
2316
2317    //------------------------------------------------------------------
2318    /// Called before sending a signal to a process.
2319    ///
2320    /// Allow Process plug-ins to execute some code before sending a
2321    /// signal to a process.
2322    ///
2323    /// @return
2324    ///     Returns no error if it is safe to proceed with a call to
2325    ///     Process::DoSignal(int), otherwise an error describing what
2326    ///     prevents the signal from being sent.
2327    //------------------------------------------------------------------
2328    virtual Error
2329    WillSignal () { return Error(); }
2330
2331    //------------------------------------------------------------------
2332    /// Sends a process a UNIX signal \a signal.
2333    ///
2334    /// @return
2335    ///     Returns an error object.
2336    //------------------------------------------------------------------
2337    virtual Error
2338    DoSignal (int signal)
2339    {
2340        Error error;
2341        error.SetErrorStringWithFormat("error: %s does not support senging signals to processes", GetShortPluginName());
2342        return error;
2343    }
2344
2345    virtual Error
2346    WillDestroy () { return Error(); }
2347
2348    virtual Error
2349    DoDestroy () = 0;
2350
2351    virtual void
2352    DidDestroy () { }
2353
2354
2355    //------------------------------------------------------------------
2356    /// Called after sending a signal to a process.
2357    ///
2358    /// Allow Process plug-ins to execute some code after sending a
2359    /// signal to a process.
2360    //------------------------------------------------------------------
2361    virtual void
2362    DidSignal () {}
2363
2364    //------------------------------------------------------------------
2365    /// Currently called as part of ShouldStop.
2366    /// FIXME: Should really happen when the target stops before the
2367    /// event is taken from the queue...
2368    ///
2369    /// This callback is called as the event
2370    /// is about to be queued up to allow Process plug-ins to execute
2371    /// some code prior to clients being notified that a process was
2372    /// stopped. Common operations include updating the thread list,
2373    /// invalidating any thread state (registers, stack, etc) prior to
2374    /// letting the notification go out.
2375    ///
2376    //------------------------------------------------------------------
2377    virtual void
2378    RefreshStateAfterStop () = 0;
2379
2380    //------------------------------------------------------------------
2381    /// Get the target object pointer for this module.
2382    ///
2383    /// @return
2384    ///     A Target object pointer to the target that owns this
2385    ///     module.
2386    //------------------------------------------------------------------
2387    Target &
2388    GetTarget ()
2389    {
2390        return m_target;
2391    }
2392
2393    //------------------------------------------------------------------
2394    /// Get the const target object pointer for this module.
2395    ///
2396    /// @return
2397    ///     A const Target object pointer to the target that owns this
2398    ///     module.
2399    //------------------------------------------------------------------
2400    const Target &
2401    GetTarget () const
2402    {
2403        return m_target;
2404    }
2405
2406    //------------------------------------------------------------------
2407    /// Flush all data in the process.
2408    ///
2409    /// Flush the memory caches, all threads, and any other cached data
2410    /// in the process.
2411    ///
2412    /// This function can be called after a world changing event like
2413    /// adding a new symbol file, or after the process makes a large
2414    /// context switch (from boot ROM to booted into an OS).
2415    //------------------------------------------------------------------
2416    void
2417    Flush ();
2418
2419    //------------------------------------------------------------------
2420    /// Get accessor for the current process state.
2421    ///
2422    /// @return
2423    ///     The current state of the process.
2424    ///
2425    /// @see lldb::StateType
2426    //------------------------------------------------------------------
2427    lldb::StateType
2428    GetState ();
2429
2430    ExecutionResults
2431    RunThreadPlan (ExecutionContext &exe_ctx,
2432                    lldb::ThreadPlanSP &thread_plan_sp,
2433                    bool stop_others,
2434                    bool run_others,
2435                    bool unwind_on_error,
2436                    bool ignore_breakpoints,
2437                    uint32_t timeout_usec,
2438                    Stream &errors);
2439
2440    static const char *
2441    ExecutionResultAsCString (ExecutionResults result);
2442
2443    void
2444    GetStatus (Stream &ostrm);
2445
2446    size_t
2447    GetThreadStatus (Stream &ostrm,
2448                     bool only_threads_with_stop_reason,
2449                     uint32_t start_frame,
2450                     uint32_t num_frames,
2451                     uint32_t num_frames_with_source);
2452
2453    void
2454    SendAsyncInterrupt ();
2455
2456protected:
2457
2458    void
2459    SetState (lldb::EventSP &event_sp);
2460
2461    lldb::StateType
2462    GetPrivateState ();
2463
2464    //------------------------------------------------------------------
2465    /// The "private" side of resuming a process.  This doesn't alter the
2466    /// state of m_run_lock, but just causes the process to resume.
2467    ///
2468    /// @return
2469    ///     An Error object describing the success or failure of the resume.
2470    //------------------------------------------------------------------
2471    Error
2472    PrivateResume ();
2473
2474    //------------------------------------------------------------------
2475    // Called internally
2476    //------------------------------------------------------------------
2477    void
2478    CompleteAttach ();
2479
2480public:
2481    //------------------------------------------------------------------
2482    /// Get the exit status for a process.
2483    ///
2484    /// @return
2485    ///     The process's return code, or -1 if the current process
2486    ///     state is not eStateExited.
2487    //------------------------------------------------------------------
2488    int
2489    GetExitStatus ();
2490
2491    //------------------------------------------------------------------
2492    /// Get a textual description of what the process exited.
2493    ///
2494    /// @return
2495    ///     The textual description of why the process exited, or NULL
2496    ///     if there is no description available.
2497    //------------------------------------------------------------------
2498    const char *
2499    GetExitDescription ();
2500
2501
2502    virtual void
2503    DidExit ()
2504    {
2505    }
2506
2507    //------------------------------------------------------------------
2508    /// Get the Modification ID of the process.
2509    ///
2510    /// @return
2511    ///     The modification ID of the process.
2512    //------------------------------------------------------------------
2513    ProcessModID
2514    GetModID () const
2515    {
2516        return m_mod_id;
2517    }
2518
2519    const ProcessModID &
2520    GetModIDRef () const
2521    {
2522        return m_mod_id;
2523    }
2524
2525    uint32_t
2526    GetStopID () const
2527    {
2528        return m_mod_id.GetStopID();
2529    }
2530
2531    uint32_t
2532    GetResumeID () const
2533    {
2534        return m_mod_id.GetResumeID();
2535    }
2536
2537    uint32_t
2538    GetLastUserExpressionResumeID () const
2539    {
2540        return m_mod_id.GetLastUserExpressionResumeID();
2541    }
2542
2543    uint32_t
2544    GetLastNaturalStopID()
2545    {
2546        return m_mod_id.GetLastNaturalStopID();
2547    }
2548
2549    //------------------------------------------------------------------
2550    /// Set accessor for the process exit status (return code).
2551    ///
2552    /// Sometimes a child exits and the exit can be detected by global
2553    /// functions (signal handler for SIGCHLD for example). This
2554    /// accessor allows the exit status to be set from an external
2555    /// source.
2556    ///
2557    /// Setting this will cause a eStateExited event to be posted to
2558    /// the process event queue.
2559    ///
2560    /// @param[in] exit_status
2561    ///     The value for the process's return code.
2562    ///
2563    /// @see lldb::StateType
2564    //------------------------------------------------------------------
2565    virtual bool
2566    SetExitStatus (int exit_status, const char *cstr);
2567
2568    //------------------------------------------------------------------
2569    /// Check if a process is still alive.
2570    ///
2571    /// @return
2572    ///     Returns \b true if the process is still valid, \b false
2573    ///     otherwise.
2574    //------------------------------------------------------------------
2575    virtual bool
2576    IsAlive () = 0;
2577
2578    //------------------------------------------------------------------
2579    /// Actually do the reading of memory from a process.
2580    ///
2581    /// Subclasses must override this function and can return fewer
2582    /// bytes than requested when memory requests are too large. This
2583    /// class will break up the memory requests and keep advancing the
2584    /// arguments along as needed.
2585    ///
2586    /// @param[in] vm_addr
2587    ///     A virtual load address that indicates where to start reading
2588    ///     memory from.
2589    ///
2590    /// @param[in] size
2591    ///     The number of bytes to read.
2592    ///
2593    /// @param[out] buf
2594    ///     A byte buffer that is at least \a size bytes long that
2595    ///     will receive the memory bytes.
2596    ///
2597    /// @return
2598    ///     The number of bytes that were actually read into \a buf.
2599    //------------------------------------------------------------------
2600    virtual size_t
2601    DoReadMemory (lldb::addr_t vm_addr,
2602                  void *buf,
2603                  size_t size,
2604                  Error &error) = 0;
2605
2606    //------------------------------------------------------------------
2607    /// Read of memory from a process.
2608    ///
2609    /// This function will read memory from the current process's
2610    /// address space and remove any traps that may have been inserted
2611    /// into the memory.
2612    ///
2613    /// This function is not meant to be overridden by Process
2614    /// subclasses, the subclasses should implement
2615    /// Process::DoReadMemory (lldb::addr_t, size_t, void *).
2616    ///
2617    /// @param[in] vm_addr
2618    ///     A virtual load address that indicates where to start reading
2619    ///     memory from.
2620    ///
2621    /// @param[out] buf
2622    ///     A byte buffer that is at least \a size bytes long that
2623    ///     will receive the memory bytes.
2624    ///
2625    /// @param[in] size
2626    ///     The number of bytes to read.
2627    ///
2628    /// @return
2629    ///     The number of bytes that were actually read into \a buf. If
2630    ///     the returned number is greater than zero, yet less than \a
2631    ///     size, then this function will get called again with \a
2632    ///     vm_addr, \a buf, and \a size updated appropriately. Zero is
2633    ///     returned to indicate an error.
2634    //------------------------------------------------------------------
2635    virtual size_t
2636    ReadMemory (lldb::addr_t vm_addr,
2637                void *buf,
2638                size_t size,
2639                Error &error);
2640
2641    //------------------------------------------------------------------
2642    /// Read a NULL terminated C string from memory
2643    ///
2644    /// This function will read a cache page at a time until the NULL
2645    /// C string terminator is found. It will stop reading if the NULL
2646    /// termination byte isn't found before reading \a cstr_max_len
2647    /// bytes, and the results are always guaranteed to be NULL
2648    /// terminated (at most cstr_max_len - 1 bytes will be read).
2649    //------------------------------------------------------------------
2650    size_t
2651    ReadCStringFromMemory (lldb::addr_t vm_addr,
2652                           char *cstr,
2653                           size_t cstr_max_len,
2654                           Error &error);
2655
2656    size_t
2657    ReadCStringFromMemory (lldb::addr_t vm_addr,
2658                           std::string &out_str,
2659                           Error &error);
2660
2661    size_t
2662    ReadMemoryFromInferior (lldb::addr_t vm_addr,
2663                            void *buf,
2664                            size_t size,
2665                            Error &error);
2666
2667    //------------------------------------------------------------------
2668    /// Reads an unsigned integer of the specified byte size from
2669    /// process memory.
2670    ///
2671    /// @param[in] load_addr
2672    ///     A load address of the integer to read.
2673    ///
2674    /// @param[in] byte_size
2675    ///     The size in byte of the integer to read.
2676    ///
2677    /// @param[in] fail_value
2678    ///     The value to return if we fail to read an integer.
2679    ///
2680    /// @param[out] error
2681    ///     An error that indicates the success or failure of this
2682    ///     operation. If error indicates success (error.Success()),
2683    ///     then the value returned can be trusted, otherwise zero
2684    ///     will be returned.
2685    ///
2686    /// @return
2687    ///     The unsigned integer that was read from the process memory
2688    ///     space. If the integer was smaller than a uint64_t, any
2689    ///     unused upper bytes will be zero filled. If the process
2690    ///     byte order differs from the host byte order, the integer
2691    ///     value will be appropriately byte swapped into host byte
2692    ///     order.
2693    //------------------------------------------------------------------
2694    uint64_t
2695    ReadUnsignedIntegerFromMemory (lldb::addr_t load_addr,
2696                                   size_t byte_size,
2697                                   uint64_t fail_value,
2698                                   Error &error);
2699
2700    lldb::addr_t
2701    ReadPointerFromMemory (lldb::addr_t vm_addr,
2702                           Error &error);
2703
2704    bool
2705    WritePointerToMemory (lldb::addr_t vm_addr,
2706                          lldb::addr_t ptr_value,
2707                          Error &error);
2708
2709    //------------------------------------------------------------------
2710    /// Actually do the writing of memory to a process.
2711    ///
2712    /// @param[in] vm_addr
2713    ///     A virtual load address that indicates where to start writing
2714    ///     memory to.
2715    ///
2716    /// @param[in] buf
2717    ///     A byte buffer that is at least \a size bytes long that
2718    ///     contains the data to write.
2719    ///
2720    /// @param[in] size
2721    ///     The number of bytes to write.
2722    ///
2723    /// @param[out] error
2724    ///     An error value in case the memory write fails.
2725    ///
2726    /// @return
2727    ///     The number of bytes that were actually written.
2728    //------------------------------------------------------------------
2729    virtual size_t
2730    DoWriteMemory (lldb::addr_t vm_addr, const void *buf, size_t size, Error &error)
2731    {
2732        error.SetErrorStringWithFormat("error: %s does not support writing to processes", GetShortPluginName());
2733        return 0;
2734    }
2735
2736
2737    //------------------------------------------------------------------
2738    /// Write all or part of a scalar value to memory.
2739    ///
2740    /// The value contained in \a scalar will be swapped to match the
2741    /// byte order of the process that is being debugged. If \a size is
2742    /// less than the size of scalar, the least significate \a size bytes
2743    /// from scalar will be written. If \a size is larger than the byte
2744    /// size of scalar, then the extra space will be padded with zeros
2745    /// and the scalar value will be placed in the least significant
2746    /// bytes in memory.
2747    ///
2748    /// @param[in] vm_addr
2749    ///     A virtual load address that indicates where to start writing
2750    ///     memory to.
2751    ///
2752    /// @param[in] scalar
2753    ///     The scalar to write to the debugged process.
2754    ///
2755    /// @param[in] size
2756    ///     This value can be smaller or larger than the scalar value
2757    ///     itself. If \a size is smaller than the size of \a scalar,
2758    ///     the least significant bytes in \a scalar will be used. If
2759    ///     \a size is larger than the byte size of \a scalar, then
2760    ///     the extra space will be padded with zeros. If \a size is
2761    ///     set to UINT32_MAX, then the size of \a scalar will be used.
2762    ///
2763    /// @param[out] error
2764    ///     An error value in case the memory write fails.
2765    ///
2766    /// @return
2767    ///     The number of bytes that were actually written.
2768    //------------------------------------------------------------------
2769    size_t
2770    WriteScalarToMemory (lldb::addr_t vm_addr,
2771                         const Scalar &scalar,
2772                         size_t size,
2773                         Error &error);
2774
2775    size_t
2776    ReadScalarIntegerFromMemory (lldb::addr_t addr,
2777                                 uint32_t byte_size,
2778                                 bool is_signed,
2779                                 Scalar &scalar,
2780                                 Error &error);
2781
2782    //------------------------------------------------------------------
2783    /// Write memory to a process.
2784    ///
2785    /// This function will write memory to the current process's
2786    /// address space and maintain any traps that might be present due
2787    /// to software breakpoints.
2788    ///
2789    /// This function is not meant to be overridden by Process
2790    /// subclasses, the subclasses should implement
2791    /// Process::DoWriteMemory (lldb::addr_t, size_t, void *).
2792    ///
2793    /// @param[in] vm_addr
2794    ///     A virtual load address that indicates where to start writing
2795    ///     memory to.
2796    ///
2797    /// @param[in] buf
2798    ///     A byte buffer that is at least \a size bytes long that
2799    ///     contains the data to write.
2800    ///
2801    /// @param[in] size
2802    ///     The number of bytes to write.
2803    ///
2804    /// @return
2805    ///     The number of bytes that were actually written.
2806    //------------------------------------------------------------------
2807    size_t
2808    WriteMemory (lldb::addr_t vm_addr, const void *buf, size_t size, Error &error);
2809
2810
2811    //------------------------------------------------------------------
2812    /// Actually allocate memory in the process.
2813    ///
2814    /// This function will allocate memory in the process's address
2815    /// space.  This can't rely on the generic function calling mechanism,
2816    /// since that requires this function.
2817    ///
2818    /// @param[in] size
2819    ///     The size of the allocation requested.
2820    ///
2821    /// @return
2822    ///     The address of the allocated buffer in the process, or
2823    ///     LLDB_INVALID_ADDRESS if the allocation failed.
2824    //------------------------------------------------------------------
2825
2826    virtual lldb::addr_t
2827    DoAllocateMemory (size_t size, uint32_t permissions, Error &error)
2828    {
2829        error.SetErrorStringWithFormat("error: %s does not support allocating in the debug process", GetShortPluginName());
2830        return LLDB_INVALID_ADDRESS;
2831    }
2832
2833
2834    //------------------------------------------------------------------
2835    /// The public interface to allocating memory in the process.
2836    ///
2837    /// This function will allocate memory in the process's address
2838    /// space.  This can't rely on the generic function calling mechanism,
2839    /// since that requires this function.
2840    ///
2841    /// @param[in] size
2842    ///     The size of the allocation requested.
2843    ///
2844    /// @param[in] permissions
2845    ///     Or together any of the lldb::Permissions bits.  The permissions on
2846    ///     a given memory allocation can't be changed after allocation.  Note
2847    ///     that a block that isn't set writable can still be written on from lldb,
2848    ///     just not by the process itself.
2849    ///
2850    /// @param[in/out] error
2851    ///     An error object to fill in if things go wrong.
2852    /// @return
2853    ///     The address of the allocated buffer in the process, or
2854    ///     LLDB_INVALID_ADDRESS if the allocation failed.
2855    //------------------------------------------------------------------
2856
2857    lldb::addr_t
2858    AllocateMemory (size_t size, uint32_t permissions, Error &error);
2859
2860    virtual Error
2861    GetMemoryRegionInfo (lldb::addr_t load_addr,
2862                        MemoryRegionInfo &range_info)
2863    {
2864        Error error;
2865        error.SetErrorString ("Process::GetMemoryRegionInfo() not supported");
2866        return error;
2867    }
2868
2869    virtual Error
2870    GetWatchpointSupportInfo (uint32_t &num)
2871    {
2872        Error error;
2873        error.SetErrorString ("Process::GetWatchpointSupportInfo() not supported");
2874        return error;
2875    }
2876
2877    virtual Error
2878    GetWatchpointSupportInfo (uint32_t &num, bool& after)
2879    {
2880        Error error;
2881        error.SetErrorString ("Process::GetWatchpointSupportInfo() not supported");
2882        return error;
2883    }
2884
2885    lldb::ModuleSP
2886    ReadModuleFromMemory (const FileSpec& file_spec,
2887                          lldb::addr_t header_addr,
2888                          bool add_image_to_target,
2889                          bool load_sections_in_target);
2890
2891    //------------------------------------------------------------------
2892    /// Attempt to get the attributes for a region of memory in the process.
2893    ///
2894    /// It may be possible for the remote debug server to inspect attributes
2895    /// for a region of memory in the process, such as whether there is a
2896    /// valid page of memory at a given address or whether that page is
2897    /// readable/writable/executable by the process.
2898    ///
2899    /// @param[in] load_addr
2900    ///     The address of interest in the process.
2901    ///
2902    /// @param[out] permissions
2903    ///     If this call returns successfully, this bitmask will have
2904    ///     its Permissions bits set to indicate whether the region is
2905    ///     readable/writable/executable.  If this call fails, the
2906    ///     bitmask values are undefined.
2907    ///
2908    /// @return
2909    ///     Returns true if it was able to determine the attributes of the
2910    ///     memory region.  False if not.
2911    //------------------------------------------------------------------
2912
2913    virtual bool
2914    GetLoadAddressPermissions (lldb::addr_t load_addr, uint32_t &permissions)
2915    {
2916        MemoryRegionInfo range_info;
2917        permissions = 0;
2918        Error error (GetMemoryRegionInfo (load_addr, range_info));
2919        if (!error.Success())
2920            return false;
2921        if (range_info.GetReadable() == MemoryRegionInfo::eDontKnow
2922            || range_info.GetWritable() == MemoryRegionInfo::eDontKnow
2923            || range_info.GetExecutable() == MemoryRegionInfo::eDontKnow)
2924        {
2925            return false;
2926        }
2927
2928        if (range_info.GetReadable() == MemoryRegionInfo::eYes)
2929            permissions |= lldb::ePermissionsReadable;
2930
2931        if (range_info.GetWritable() == MemoryRegionInfo::eYes)
2932            permissions |= lldb::ePermissionsWritable;
2933
2934        if (range_info.GetExecutable() == MemoryRegionInfo::eYes)
2935            permissions |= lldb::ePermissionsExecutable;
2936
2937        return true;
2938    }
2939
2940    //------------------------------------------------------------------
2941    /// Determines whether executing JIT-compiled code in this process
2942    /// is possible.
2943    ///
2944    /// @return
2945    ///     True if execution of JIT code is possible; false otherwise.
2946    //------------------------------------------------------------------
2947    bool CanJIT ();
2948
2949    //------------------------------------------------------------------
2950    /// Sets whether executing JIT-compiled code in this process
2951    /// is possible.
2952    ///
2953    /// @param[in] can_jit
2954    ///     True if execution of JIT code is possible; false otherwise.
2955    //------------------------------------------------------------------
2956    void SetCanJIT (bool can_jit);
2957
2958    //------------------------------------------------------------------
2959    /// Actually deallocate memory in the process.
2960    ///
2961    /// This function will deallocate memory in the process's address
2962    /// space that was allocated with AllocateMemory.
2963    ///
2964    /// @param[in] ptr
2965    ///     A return value from AllocateMemory, pointing to the memory you
2966    ///     want to deallocate.
2967    ///
2968    /// @return
2969    ///     \btrue if the memory was deallocated, \bfalse otherwise.
2970    //------------------------------------------------------------------
2971
2972    virtual Error
2973    DoDeallocateMemory (lldb::addr_t ptr)
2974    {
2975        Error error;
2976        error.SetErrorStringWithFormat("error: %s does not support deallocating in the debug process", GetShortPluginName());
2977        return error;
2978    }
2979
2980
2981    //------------------------------------------------------------------
2982    /// The public interface to deallocating memory in the process.
2983    ///
2984    /// This function will deallocate memory in the process's address
2985    /// space that was allocated with AllocateMemory.
2986    ///
2987    /// @param[in] ptr
2988    ///     A return value from AllocateMemory, pointing to the memory you
2989    ///     want to deallocate.
2990    ///
2991    /// @return
2992    ///     \btrue if the memory was deallocated, \bfalse otherwise.
2993    //------------------------------------------------------------------
2994
2995    Error
2996    DeallocateMemory (lldb::addr_t ptr);
2997
2998    //------------------------------------------------------------------
2999    /// Get any available STDOUT.
3000    ///
3001    /// If the process was launched without supplying valid file paths
3002    /// for stdin, stdout, and stderr, then the Process class might
3003    /// try to cache the STDOUT for the process if it is able. Events
3004    /// will be queued indicating that there is STDOUT available that
3005    /// can be retrieved using this function.
3006    ///
3007    /// @param[out] buf
3008    ///     A buffer that will receive any STDOUT bytes that are
3009    ///     currently available.
3010    ///
3011    /// @param[out] buf_size
3012    ///     The size in bytes for the buffer \a buf.
3013    ///
3014    /// @return
3015    ///     The number of bytes written into \a buf. If this value is
3016    ///     equal to \a buf_size, another call to this function should
3017    ///     be made to retrieve more STDOUT data.
3018    //------------------------------------------------------------------
3019    virtual size_t
3020    GetSTDOUT (char *buf, size_t buf_size, Error &error);
3021
3022    //------------------------------------------------------------------
3023    /// Get any available STDERR.
3024    ///
3025    /// If the process was launched without supplying valid file paths
3026    /// for stdin, stdout, and stderr, then the Process class might
3027    /// try to cache the STDERR for the process if it is able. Events
3028    /// will be queued indicating that there is STDERR available that
3029    /// can be retrieved using this function.
3030    ///
3031    /// @param[out] buf
3032    ///     A buffer that will receive any STDERR bytes that are
3033    ///     currently available.
3034    ///
3035    /// @param[out] buf_size
3036    ///     The size in bytes for the buffer \a buf.
3037    ///
3038    /// @return
3039    ///     The number of bytes written into \a buf. If this value is
3040    ///     equal to \a buf_size, another call to this function should
3041    ///     be made to retrieve more STDERR data.
3042    //------------------------------------------------------------------
3043    virtual size_t
3044    GetSTDERR (char *buf, size_t buf_size, Error &error);
3045
3046    virtual size_t
3047    PutSTDIN (const char *buf, size_t buf_size, Error &error)
3048    {
3049        error.SetErrorString("stdin unsupported");
3050        return 0;
3051    }
3052
3053    //------------------------------------------------------------------
3054    /// Get any available profile data.
3055    ///
3056    /// @param[out] buf
3057    ///     A buffer that will receive any profile data bytes that are
3058    ///     currently available.
3059    ///
3060    /// @param[out] buf_size
3061    ///     The size in bytes for the buffer \a buf.
3062    ///
3063    /// @return
3064    ///     The number of bytes written into \a buf. If this value is
3065    ///     equal to \a buf_size, another call to this function should
3066    ///     be made to retrieve more profile data.
3067    //------------------------------------------------------------------
3068    virtual size_t
3069    GetAsyncProfileData (char *buf, size_t buf_size, Error &error);
3070
3071    //----------------------------------------------------------------------
3072    // Process Breakpoints
3073    //----------------------------------------------------------------------
3074    size_t
3075    GetSoftwareBreakpointTrapOpcode (BreakpointSite* bp_site);
3076
3077    virtual Error
3078    EnableBreakpoint (BreakpointSite *bp_site)
3079    {
3080        Error error;
3081        error.SetErrorStringWithFormat("error: %s does not support enabling breakpoints", GetShortPluginName());
3082        return error;
3083    }
3084
3085
3086    virtual Error
3087    DisableBreakpoint (BreakpointSite *bp_site)
3088    {
3089        Error error;
3090        error.SetErrorStringWithFormat("error: %s does not support disabling breakpoints", GetShortPluginName());
3091        return error;
3092    }
3093
3094
3095    // This is implemented completely using the lldb::Process API. Subclasses
3096    // don't need to implement this function unless the standard flow of
3097    // read existing opcode, write breakpoint opcode, verify breakpoint opcode
3098    // doesn't work for a specific process plug-in.
3099    virtual Error
3100    EnableSoftwareBreakpoint (BreakpointSite *bp_site);
3101
3102    // This is implemented completely using the lldb::Process API. Subclasses
3103    // don't need to implement this function unless the standard flow of
3104    // restoring original opcode in memory and verifying the restored opcode
3105    // doesn't work for a specific process plug-in.
3106    virtual Error
3107    DisableSoftwareBreakpoint (BreakpointSite *bp_site);
3108
3109    BreakpointSiteList &
3110    GetBreakpointSiteList();
3111
3112    const BreakpointSiteList &
3113    GetBreakpointSiteList() const;
3114
3115    void
3116    DisableAllBreakpointSites ();
3117
3118    Error
3119    ClearBreakpointSiteByID (lldb::user_id_t break_id);
3120
3121    lldb::break_id_t
3122    CreateBreakpointSite (const lldb::BreakpointLocationSP &owner,
3123                          bool use_hardware);
3124
3125    Error
3126    DisableBreakpointSiteByID (lldb::user_id_t break_id);
3127
3128    Error
3129    EnableBreakpointSiteByID (lldb::user_id_t break_id);
3130
3131
3132    // BreakpointLocations use RemoveOwnerFromBreakpointSite to remove
3133    // themselves from the owner's list of this breakpoint sites.  This has to
3134    // be a static function because you can't be sure that removing the
3135    // breakpoint from it's containing map won't delete the breakpoint site,
3136    // and doing that in an instance method isn't copasetic.
3137    void
3138    RemoveOwnerFromBreakpointSite (lldb::user_id_t owner_id,
3139                                   lldb::user_id_t owner_loc_id,
3140                                   lldb::BreakpointSiteSP &bp_site_sp);
3141
3142    //----------------------------------------------------------------------
3143    // Process Watchpoints (optional)
3144    //----------------------------------------------------------------------
3145    virtual Error
3146    EnableWatchpoint (Watchpoint *wp, bool notify = true);
3147
3148    virtual Error
3149    DisableWatchpoint (Watchpoint *wp, bool notify = true);
3150
3151    //------------------------------------------------------------------
3152    // Thread Queries
3153    //------------------------------------------------------------------
3154    virtual bool
3155    UpdateThreadList (ThreadList &old_thread_list, ThreadList &new_thread_list) = 0;
3156
3157    void
3158    UpdateThreadListIfNeeded ();
3159
3160    ThreadList &
3161    GetThreadList ()
3162    {
3163        return m_thread_list;
3164    }
3165
3166    // This is obsoleted and will be removed very soon.
3167    uint32_t
3168    GetNextThreadIndexID ();
3169
3170    uint32_t
3171    GetNextThreadIndexID (uint64_t thread_id);
3172
3173    lldb::ThreadSP
3174    CreateOSPluginThread (lldb::tid_t tid, lldb::addr_t context);
3175
3176    // Returns true if an index id has been assigned to a thread.
3177    bool
3178    HasAssignedIndexIDToThread(uint64_t sb_thread_id);
3179
3180    // Given a thread_id, it will assign a more reasonable index id for display to the user.
3181    // If the thread_id has previously been assigned, the same index id will be used.
3182    uint32_t
3183    AssignIndexIDToThread(uint64_t thread_id);
3184
3185    //------------------------------------------------------------------
3186    // Event Handling
3187    //------------------------------------------------------------------
3188    lldb::StateType
3189    GetNextEvent (lldb::EventSP &event_sp);
3190
3191    lldb::StateType
3192    WaitForProcessToStop (const TimeValue *timeout, lldb::EventSP *event_sp_ptr = NULL);
3193
3194    lldb::StateType
3195    WaitForStateChangedEvents (const TimeValue *timeout, lldb::EventSP &event_sp);
3196
3197    Event *
3198    PeekAtStateChangedEvents ();
3199
3200
3201    class
3202    ProcessEventHijacker
3203    {
3204    public:
3205        ProcessEventHijacker (Process &process, Listener *listener) :
3206            m_process (process)
3207        {
3208            m_process.HijackProcessEvents (listener);
3209        }
3210        ~ProcessEventHijacker ()
3211        {
3212            m_process.RestoreProcessEvents();
3213        }
3214
3215    private:
3216        Process &m_process;
3217    };
3218    friend class ProcessEventHijacker;
3219    //------------------------------------------------------------------
3220    /// If you need to ensure that you and only you will hear about some public
3221    /// event, then make a new listener, set to listen to process events, and
3222    /// then call this with that listener.  Then you will have to wait on that
3223    /// listener explicitly for events (rather than using the GetNextEvent & WaitFor*
3224    /// calls above.  Be sure to call RestoreProcessEvents when you are done.
3225    ///
3226    /// @param[in] listener
3227    ///     This is the new listener to whom all process events will be delivered.
3228    ///
3229    /// @return
3230    ///     Returns \b true if the new listener could be installed,
3231    ///     \b false otherwise.
3232    //------------------------------------------------------------------
3233    bool
3234    HijackProcessEvents (Listener *listener);
3235
3236    //------------------------------------------------------------------
3237    /// Restores the process event broadcasting to its normal state.
3238    ///
3239    //------------------------------------------------------------------
3240    void
3241    RestoreProcessEvents ();
3242
3243protected:
3244    //------------------------------------------------------------------
3245    /// This is the part of the event handling that for a process event.
3246    /// It decides what to do with the event and returns true if the
3247    /// event needs to be propagated to the user, and false otherwise.
3248    /// If the event is not propagated, this call will most likely set
3249    /// the target to executing again.
3250    ///
3251    /// @param[in] event_ptr
3252    ///     This is the event we are handling.
3253    ///
3254    /// @return
3255    ///     Returns \b true if the event should be reported to the
3256    ///     user, \b false otherwise.
3257    //------------------------------------------------------------------
3258    bool
3259    ShouldBroadcastEvent (Event *event_ptr);
3260
3261public:
3262    const lldb::ABISP &
3263    GetABI ();
3264
3265    OperatingSystem *
3266    GetOperatingSystem ()
3267    {
3268        return m_os_ap.get();
3269    }
3270
3271
3272    virtual LanguageRuntime *
3273    GetLanguageRuntime (lldb::LanguageType language, bool retry_if_null = true);
3274
3275    virtual CPPLanguageRuntime *
3276    GetCPPLanguageRuntime (bool retry_if_null = true);
3277
3278    virtual ObjCLanguageRuntime *
3279    GetObjCLanguageRuntime (bool retry_if_null = true);
3280
3281    bool
3282    IsPossibleDynamicValue (ValueObject& in_value);
3283
3284    bool
3285    IsRunning () const;
3286
3287    DynamicCheckerFunctions *GetDynamicCheckers()
3288    {
3289        return m_dynamic_checkers_ap.get();
3290    }
3291
3292    void SetDynamicCheckers(DynamicCheckerFunctions *dynamic_checkers)
3293    {
3294        m_dynamic_checkers_ap.reset(dynamic_checkers);
3295    }
3296
3297    //------------------------------------------------------------------
3298    /// Call this to set the lldb in the mode where it breaks on new thread
3299    /// creations, and then auto-restarts.  This is useful when you are trying
3300    /// to run only one thread, but either that thread or the kernel is creating
3301    /// new threads in the process.  If you stop when the thread is created, you
3302    /// can immediately suspend it, and keep executing only the one thread you intend.
3303    ///
3304    /// @return
3305    ///     Returns \b true if we were able to start up the notification
3306    ///     \b false otherwise.
3307    //------------------------------------------------------------------
3308    virtual bool
3309    StartNoticingNewThreads()
3310    {
3311        return true;
3312    }
3313
3314    //------------------------------------------------------------------
3315    /// Call this to turn off the stop & notice new threads mode.
3316    ///
3317    /// @return
3318    ///     Returns \b true if we were able to start up the notification
3319    ///     \b false otherwise.
3320    //------------------------------------------------------------------
3321    virtual bool
3322    StopNoticingNewThreads()
3323    {
3324        return true;
3325    }
3326
3327    void
3328    SetRunningUserExpression (bool on);
3329
3330    //------------------------------------------------------------------
3331    // lldb::ExecutionContextScope pure virtual functions
3332    //------------------------------------------------------------------
3333    virtual lldb::TargetSP
3334    CalculateTarget ();
3335
3336    virtual lldb::ProcessSP
3337    CalculateProcess ()
3338    {
3339        return shared_from_this();
3340    }
3341
3342    virtual lldb::ThreadSP
3343    CalculateThread ()
3344    {
3345        return lldb::ThreadSP();
3346    }
3347
3348    virtual lldb::StackFrameSP
3349    CalculateStackFrame ()
3350    {
3351        return lldb::StackFrameSP();
3352    }
3353
3354    virtual void
3355    CalculateExecutionContext (ExecutionContext &exe_ctx);
3356
3357    void
3358    SetSTDIOFileDescriptor (int file_descriptor);
3359
3360    //------------------------------------------------------------------
3361    // Add a permanent region of memory that should never be read or
3362    // written to. This can be used to ensure that memory reads or writes
3363    // to certain areas of memory never end up being sent to the
3364    // DoReadMemory or DoWriteMemory functions which can improve
3365    // performance.
3366    //------------------------------------------------------------------
3367    void
3368    AddInvalidMemoryRegion (const LoadRange &region);
3369
3370    //------------------------------------------------------------------
3371    // Remove a permanent region of memory that should never be read or
3372    // written to that was previously added with AddInvalidMemoryRegion.
3373    //------------------------------------------------------------------
3374    bool
3375    RemoveInvalidMemoryRange (const LoadRange &region);
3376
3377    //------------------------------------------------------------------
3378    // If the setup code of a thread plan needs to do work that might involve
3379    // calling a function in the target, it should not do that work directly
3380    // in one of the thread plan functions (DidPush/WillResume) because
3381    // such work needs to be handled carefully.  Instead, put that work in
3382    // a PreResumeAction callback, and register it with the process.  It will
3383    // get done before the actual "DoResume" gets called.
3384    //------------------------------------------------------------------
3385
3386    typedef bool (PreResumeActionCallback)(void *);
3387
3388    void
3389    AddPreResumeAction (PreResumeActionCallback callback, void *baton);
3390
3391    bool
3392    RunPreResumeActions ();
3393
3394    void
3395    ClearPreResumeActions ();
3396
3397    ReadWriteLock &
3398    GetRunLock ()
3399    {
3400        return m_run_lock;
3401    }
3402
3403protected:
3404    //------------------------------------------------------------------
3405    // NextEventAction provides a way to register an action on the next
3406    // event that is delivered to this process.  There is currently only
3407    // one next event action allowed in the process at one time.  If a
3408    // new "NextEventAction" is added while one is already present, the
3409    // old action will be discarded (with HandleBeingUnshipped called
3410    // after it is discarded.)
3411    //------------------------------------------------------------------
3412    class NextEventAction
3413    {
3414    public:
3415        typedef enum EventActionResult
3416        {
3417            eEventActionSuccess,
3418            eEventActionRetry,
3419            eEventActionExit
3420        } EventActionResult;
3421
3422        NextEventAction (Process *process) :
3423            m_process(process)
3424        {
3425        }
3426
3427        virtual
3428        ~NextEventAction()
3429        {
3430        }
3431
3432        virtual EventActionResult PerformAction (lldb::EventSP &event_sp) = 0;
3433        virtual void HandleBeingUnshipped () {}
3434        virtual EventActionResult HandleBeingInterrupted () = 0;
3435        virtual const char *GetExitString() = 0;
3436    protected:
3437        Process *m_process;
3438    };
3439
3440    void SetNextEventAction (Process::NextEventAction *next_event_action)
3441    {
3442        if (m_next_event_action_ap.get())
3443            m_next_event_action_ap->HandleBeingUnshipped();
3444
3445        m_next_event_action_ap.reset(next_event_action);
3446    }
3447
3448    // This is the completer for Attaching:
3449    class AttachCompletionHandler : public NextEventAction
3450    {
3451    public:
3452        AttachCompletionHandler (Process *process, uint32_t exec_count) :
3453            NextEventAction (process),
3454            m_exec_count (exec_count)
3455        {
3456        }
3457
3458        virtual
3459        ~AttachCompletionHandler()
3460        {
3461        }
3462
3463        virtual EventActionResult PerformAction (lldb::EventSP &event_sp);
3464        virtual EventActionResult HandleBeingInterrupted ();
3465        virtual const char *GetExitString();
3466    private:
3467        uint32_t m_exec_count;
3468        std::string m_exit_string;
3469    };
3470
3471    bool
3472    HijackPrivateProcessEvents (Listener *listener);
3473
3474    void
3475    RestorePrivateProcessEvents ();
3476
3477    bool
3478    PrivateStateThreadIsValid () const
3479    {
3480        return IS_VALID_LLDB_HOST_THREAD(m_private_state_thread);
3481    }
3482
3483    //------------------------------------------------------------------
3484    // Type definitions
3485    //------------------------------------------------------------------
3486    typedef std::map<lldb::LanguageType, lldb::LanguageRuntimeSP> LanguageRuntimeCollection;
3487
3488    struct PreResumeCallbackAndBaton
3489    {
3490        bool (*callback) (void *);
3491        void *baton;
3492        PreResumeCallbackAndBaton (PreResumeActionCallback in_callback, void *in_baton) :
3493            callback (in_callback),
3494            baton (in_baton)
3495        {
3496        }
3497    };
3498
3499    //------------------------------------------------------------------
3500    // Member variables
3501    //------------------------------------------------------------------
3502    Target &                    m_target;               ///< The target that owns this process.
3503    ThreadSafeValue<lldb::StateType>  m_public_state;
3504    ThreadSafeValue<lldb::StateType>  m_private_state; // The actual state of our process
3505    Broadcaster                 m_private_state_broadcaster;  // This broadcaster feeds state changed events into the private state thread's listener.
3506    Broadcaster                 m_private_state_control_broadcaster; // This is the control broadcaster, used to pause, resume & stop the private state thread.
3507    Listener                    m_private_state_listener;     // This is the listener for the private state thread.
3508    Predicate<bool>             m_private_state_control_wait; /// This Predicate is used to signal that a control operation is complete.
3509    lldb::thread_t              m_private_state_thread;  // Thread ID for the thread that watches interal state events
3510    ProcessModID                m_mod_id;               ///< Tracks the state of the process over stops and other alterations.
3511    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
3512    uint32_t                    m_thread_index_id;      ///< Each thread is created with a 1 based index that won't get re-used.
3513    std::map<uint64_t, uint32_t> m_thread_id_to_index_id_map;
3514    int                         m_exit_status;          ///< The exit status of the process, or -1 if not set.
3515    std::string                 m_exit_string;          ///< A textual description of why a process exited.
3516    ThreadList                  m_thread_list;          ///< The threads for this process.
3517    std::vector<Notifications>  m_notifications;        ///< The list of notifications that this process can deliver.
3518    std::vector<lldb::addr_t>   m_image_tokens;
3519    Listener                    &m_listener;
3520    BreakpointSiteList          m_breakpoint_site_list; ///< This is the list of breakpoint locations we intend to insert in the target.
3521    std::auto_ptr<DynamicLoader> m_dyld_ap;
3522    std::auto_ptr<DynamicCheckerFunctions> m_dynamic_checkers_ap; ///< The functions used by the expression parser to validate data that expressions use.
3523    std::auto_ptr<OperatingSystem> m_os_ap;
3524    UnixSignals                 m_unix_signals;         /// This is the current signal set for this process.
3525    lldb::ABISP                 m_abi_sp;
3526    lldb::InputReaderSP         m_process_input_reader;
3527    Communication               m_stdio_communication;
3528    Mutex                       m_stdio_communication_mutex;
3529    std::string                 m_stdout_data;
3530    std::string                 m_stderr_data;
3531    Mutex                       m_profile_data_comm_mutex;
3532    std::vector<std::string>    m_profile_data;
3533    MemoryCache                 m_memory_cache;
3534    AllocatedMemoryCache        m_allocated_memory_cache;
3535    bool                        m_should_detach;   /// Should we detach if the process object goes away with an explicit call to Kill or Detach?
3536    LanguageRuntimeCollection   m_language_runtimes;
3537    std::auto_ptr<NextEventAction> m_next_event_action_ap;
3538    std::vector<PreResumeCallbackAndBaton> m_pre_resume_actions;
3539    ReadWriteLock               m_run_lock;
3540    Predicate<bool>             m_currently_handling_event;
3541    bool                        m_finalize_called;
3542
3543    enum {
3544        eCanJITDontKnow= 0,
3545        eCanJITYes,
3546        eCanJITNo
3547    } m_can_jit;
3548
3549    size_t
3550    RemoveBreakpointOpcodesFromBuffer (lldb::addr_t addr, size_t size, uint8_t *buf) const;
3551
3552    void
3553    SynchronouslyNotifyStateChanged (lldb::StateType state);
3554
3555    void
3556    SetPublicState (lldb::StateType new_state);
3557
3558    void
3559    SetPrivateState (lldb::StateType state);
3560
3561    bool
3562    StartPrivateStateThread (bool force = false);
3563
3564    void
3565    StopPrivateStateThread ();
3566
3567    void
3568    PausePrivateStateThread ();
3569
3570    void
3571    ResumePrivateStateThread ();
3572
3573    static void *
3574    PrivateStateThread (void *arg);
3575
3576    void *
3577    RunPrivateStateThread ();
3578
3579    void
3580    HandlePrivateEvent (lldb::EventSP &event_sp);
3581
3582    lldb::StateType
3583    WaitForProcessStopPrivate (const TimeValue *timeout, lldb::EventSP &event_sp);
3584
3585    // This waits for both the state change broadcaster, and the control broadcaster.
3586    // If control_only, it only waits for the control broadcaster.
3587
3588    bool
3589    WaitForEventsPrivate (const TimeValue *timeout, lldb::EventSP &event_sp, bool control_only);
3590
3591    lldb::StateType
3592    WaitForStateChangedEventsPrivate (const TimeValue *timeout, lldb::EventSP &event_sp);
3593
3594    lldb::StateType
3595    WaitForState (const TimeValue *timeout,
3596                  const lldb::StateType *match_states,
3597                  const uint32_t num_match_states);
3598
3599    size_t
3600    WriteMemoryPrivate (lldb::addr_t addr, const void *buf, size_t size, Error &error);
3601
3602    void
3603    AppendSTDOUT (const char *s, size_t len);
3604
3605    void
3606    AppendSTDERR (const char *s, size_t len);
3607
3608    void
3609    BroadcastAsyncProfileData(const char *s, size_t len);
3610
3611    static void
3612    STDIOReadThreadBytesReceived (void *baton, const void *src, size_t src_len);
3613
3614    void
3615    PushProcessInputReader ();
3616
3617    void
3618    PopProcessInputReader ();
3619
3620    void
3621    ResetProcessInputReader ();
3622
3623    static size_t
3624    ProcessInputReaderCallback (void *baton,
3625                                InputReader &reader,
3626                                lldb::InputReaderAction notification,
3627                                const char *bytes,
3628                                size_t bytes_len);
3629
3630
3631private:
3632    //------------------------------------------------------------------
3633    // For Process only
3634    //------------------------------------------------------------------
3635    void ControlPrivateStateThread (uint32_t signal);
3636
3637    DISALLOW_COPY_AND_ASSIGN (Process);
3638
3639};
3640
3641} // namespace lldb_private
3642
3643#endif  // liblldb_Process_h_
3644