contrib/llvm/tools/lldb/include/lldb/Target/ThreadList.h

   1 //===-- ThreadList.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_ThreadList_h_
  11 #define liblldb_ThreadList_h_
  12
  13 #include <vector>
  14
  15 #include "lldb/lldb-private.h"
  16 #include "lldb/Core/UserID.h"
  17 #include "lldb/Utility/Iterable.h"
  18
  19
  20 // FIXME: Currently this is a thread list with lots of functionality for use only by
  21 // the process for which this is the thread list.  If we ever want a container class
  22 // to hand out that is just a random subset of threads, with iterator functionality,
  23 // then we should make that part a base class, and make a ProcessThreadList for the
  24 // process.
  25 namespace lldb_private {
  26
  27 class ThreadList
  28 {
  29 friend class Process;
  30
  31 public:
  32
  33     ThreadList (Process *process);
  34
  35     ThreadList (const ThreadList &rhs);
  36
  37     ~ThreadList ();
  38
  39     const ThreadList&
  40     operator = (const ThreadList& rhs);
  41
  42     uint32_t
  43     GetSize(bool can_update = true);
  44
  45     void
  46     AddThread (const lldb::ThreadSP &thread_sp);
  47
  48     void
  49     InsertThread (const lldb::ThreadSP &thread_sp, uint32_t idx);
  50     // Return the selected thread if there is one.  Otherwise, return the thread
  51     // selected at index 0.
  52     lldb::ThreadSP
  53     GetSelectedThread ();
  54
  55     bool
  56     SetSelectedThreadByID (lldb::tid_t tid, bool notify = false);
  57
  58     bool
  59     SetSelectedThreadByIndexID (uint32_t index_id, bool notify = false);
  60
  61     void
  62     Clear();
  63
  64     void
  65     Flush();
  66
  67     void
  68     Destroy();
  69
  70     // Note that "idx" is not the same as the "thread_index". It is a zero
  71     // based index to accessing the current threads, whereas "thread_index"
  72     // is a unique index assigned
  73     lldb::ThreadSP
  74     GetThreadAtIndex (uint32_t idx, bool can_update = true);
  75
  76     typedef std::vector<lldb::ThreadSP> collection;
  77     typedef LockingAdaptedIterable<collection, lldb::ThreadSP, vector_adapter> ThreadIterable;
  78
  79     ThreadIterable
  80     Threads ()
  81     {
  82         return ThreadIterable(m_threads, GetMutex());
  83     }
  84
  85     lldb::ThreadSP
  86     FindThreadByID (lldb::tid_t tid, bool can_update = true);
  87
  88     lldb::ThreadSP
  89     FindThreadByProtocolID (lldb::tid_t tid, bool can_update = true);
  90
  91     lldb::ThreadSP
  92     RemoveThreadByID (lldb::tid_t tid, bool can_update = true);
  93
  94     lldb::ThreadSP
  95     RemoveThreadByProtocolID (lldb::tid_t tid, bool can_update = true);
  96
  97     lldb::ThreadSP
  98     FindThreadByIndexID (uint32_t index_id, bool can_update = true);
  99
 100     lldb::ThreadSP
 101     GetThreadSPForThreadPtr (Thread *thread_ptr);
 102
 103     bool
 104     ShouldStop (Event *event_ptr);
 105
 106     Vote
 107     ShouldReportStop (Event *event_ptr);
 108
 109     Vote
 110     ShouldReportRun (Event *event_ptr);
 111
 112     void
 113     RefreshStateAfterStop ();
 114
 115     //------------------------------------------------------------------
 116     /// The thread list asks tells all the threads it is about to resume.
 117     /// If a thread can "resume" without having to resume the target, it
 118     /// will return false for WillResume, and then the process will not be
 119     /// restarted.
 120     ///
 121     /// @return
 122     ///    \b true instructs the process to resume normally,
 123     ///    \b false means start & stopped events will be generated, but
 124     ///    the process will not actually run.  The thread must then return
 125     ///    the correct StopInfo when asked.
 126     ///
 127     //------------------------------------------------------------------
 128     bool
 129     WillResume ();
 130
 131     void
 132     DidResume ();
 133
 134     void
 135     DidStop ();
 136
 137     void
 138     DiscardThreadPlans();
 139
 140     uint32_t
 141     GetStopID () const;
 142
 143     void
 144     SetStopID (uint32_t stop_id);
 145
 146     Mutex &
 147     GetMutex ();
 148
 149     void
 150     Update (ThreadList &rhs);
 151
 152 protected:
 153
 154     void
 155     SetShouldReportStop (Vote vote);
 156
 157     void
 158     NotifySelectedThreadChanged (lldb::tid_t tid);
 159
 160     //------------------------------------------------------------------
 161     // Classes that inherit from Process can see and modify these
 162     //------------------------------------------------------------------
 163     Process *m_process; ///< The process that manages this thread list.
 164     uint32_t m_stop_id; ///< The process stop ID that this thread list is valid for.
 165     collection m_threads; ///< The threads for this process.
 166     lldb::tid_t m_selected_tid;  ///< For targets that need the notion of a current thread.
 167
 168 private:
 169     ThreadList ();
 170 };
 171
 172 } // namespace lldb_private
 173
 174 #endif  // liblldb_ThreadList_h_