SBThread.h revision 269024 
1//===-- SBThread.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 LLDB_SBThread_h_
11#define LLDB_SBThread_h_
12
13#include "lldb/API/SBDefines.h"
14
15#include <stdio.h>
16
17namespace lldb {
18
19class SBFrame;
20
21class SBThread
22{
23public:
24    enum
25    {
26        eBroadcastBitStackChanged           = (1 << 0),
27        eBroadcastBitThreadSuspended        = (1 << 1),
28        eBroadcastBitThreadResumed          = (1 << 2),
29        eBroadcastBitSelectedFrameChanged   = (1 << 3),
30        eBroadcastBitThreadSelected         = (1 << 4)
31    };
32
33    static const char *
34    GetBroadcasterClassName ();
35
36    SBThread ();
37
38    SBThread (const lldb::SBThread &thread);
39
40    SBThread (const lldb::ThreadSP& lldb_object_sp);
41
42   ~SBThread();
43
44    bool
45    IsValid() const;
46
47    void
48    Clear ();
49
50    lldb::StopReason
51    GetStopReason();
52
53    /// Get the number of words associated with the stop reason.
54    /// See also GetStopReasonDataAtIndex().
55    size_t
56    GetStopReasonDataCount();
57
58    //--------------------------------------------------------------------------
59    /// Get information associated with a stop reason.
60    ///
61    /// Breakpoint stop reasons will have data that consists of pairs of
62    /// breakpoint IDs followed by the breakpoint location IDs (they always come
63    /// in pairs).
64    ///
65    /// Stop Reason              Count Data Type
66    /// ======================== ===== =========================================
67    /// eStopReasonNone          0
68    /// eStopReasonTrace         0
69    /// eStopReasonBreakpoint    N     duple: {breakpoint id, location id}
70    /// eStopReasonWatchpoint    1     watchpoint id
71    /// eStopReasonSignal        1     unix signal number
72    /// eStopReasonException     N     exception data
73    /// eStopReasonExec          0
74    /// eStopReasonPlanComplete  0
75    //--------------------------------------------------------------------------
76    uint64_t
77    GetStopReasonDataAtIndex(uint32_t idx);
78
79    size_t
80    GetStopDescription (char *dst, size_t dst_len);
81
82    SBValue
83    GetStopReturnValue ();
84
85    lldb::tid_t
86    GetThreadID () const;
87
88    uint32_t
89    GetIndexID () const;
90
91    const char *
92    GetName () const;
93
94    const char *
95    GetQueueName() const;
96
97    lldb::queue_id_t
98    GetQueueID() const;
99
100    void
101    StepOver (lldb::RunMode stop_other_threads = lldb::eOnlyDuringStepping);
102
103    void
104    StepInto (lldb::RunMode stop_other_threads = lldb::eOnlyDuringStepping);
105
106    void
107    StepInto (const char *target_name, lldb::RunMode stop_other_threads = lldb::eOnlyDuringStepping);
108
109    void
110    StepOut ();
111
112    void
113    StepOutOfFrame (lldb::SBFrame &frame);
114
115    void
116    StepInstruction(bool step_over);
117
118    SBError
119    StepOverUntil (lldb::SBFrame &frame,
120                   lldb::SBFileSpec &file_spec,
121                   uint32_t line);
122
123    SBError
124    JumpToLine (lldb::SBFileSpec &file_spec, uint32_t line);
125
126    void
127    RunToAddress (lldb::addr_t addr);
128
129    SBError
130    ReturnFromFrame (SBFrame &frame, SBValue &return_value);
131
132    //--------------------------------------------------------------------------
133    /// LLDB currently supports process centric debugging which means when any
134    /// thread in a process stops, all other threads are stopped. The Suspend()
135    /// call here tells our process to suspend a thread and not let it run when
136    /// the other threads in a process are allowed to run. So when
137    /// SBProcess::Continue() is called, any threads that aren't suspended will
138    /// be allowed to run. If any of the SBThread functions for stepping are
139    /// called (StepOver, StepInto, StepOut, StepInstruction, RunToAddres), the
140    /// thread will not be allowed to run and these funtions will simply return.
141    ///
142    /// Eventually we plan to add support for thread centric debugging where
143    /// each thread is controlled individually and each thread would broadcast
144    /// its state, but we haven't implemented this yet.
145    ///
146    /// Likewise the SBThread::Resume() call will again allow the thread to run
147    /// when the process is continued.
148    ///
149    /// Suspend() and Resume() functions are not currently reference counted, if
150    /// anyone has the need for them to be reference counted, please let us
151    /// know.
152    //--------------------------------------------------------------------------
153    bool
154    Suspend();
155
156    bool
157    Resume ();
158
159    bool
160    IsSuspended();
161
162    bool
163    IsStopped();
164
165    uint32_t
166    GetNumFrames ();
167
168    lldb::SBFrame
169    GetFrameAtIndex (uint32_t idx);
170
171    lldb::SBFrame
172    GetSelectedFrame ();
173
174    lldb::SBFrame
175    SetSelectedFrame (uint32_t frame_idx);
176
177    static bool
178    EventIsThreadEvent (const SBEvent &event);
179
180    static SBFrame
181    GetStackFrameFromEvent (const SBEvent &event);
182
183    static SBThread
184    GetThreadFromEvent (const SBEvent &event);
185
186    lldb::SBProcess
187    GetProcess ();
188
189    const lldb::SBThread &
190    operator = (const lldb::SBThread &rhs);
191
192    bool
193    operator == (const lldb::SBThread &rhs) const;
194
195    bool
196    operator != (const lldb::SBThread &rhs) const;
197
198    bool
199    GetDescription (lldb::SBStream &description) const;
200
201    bool
202    GetStatus (lldb::SBStream &status) const;
203
204    SBThread
205    GetExtendedBacktraceThread (const char *type);
206
207    uint32_t
208    GetExtendedBacktraceOriginatingIndexID ();
209
210protected:
211    friend class SBBreakpoint;
212    friend class SBBreakpointLocation;
213    friend class SBFrame;
214    friend class SBProcess;
215    friend class SBDebugger;
216    friend class SBValue;
217    friend class lldb_private::QueueImpl;
218    friend class SBQueueItem;
219
220    void
221    SetThread (const lldb::ThreadSP& lldb_object_sp);
222
223#ifndef SWIG
224    SBError
225    ResumeNewPlan (lldb_private::ExecutionContext &exe_ctx, lldb_private::ThreadPlan *new_plan);
226#endif
227
228private:
229    lldb::ExecutionContextRefSP m_opaque_sp;
230};
231
232} // namespace lldb
233
234#endif  // LLDB_SBThread_h_
235