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    void
98    StepOver (lldb::RunMode stop_other_threads = lldb::eOnlyDuringStepping);
99
100    void
101    StepInto (lldb::RunMode stop_other_threads = lldb::eOnlyDuringStepping);
102
103    void
104    StepInto (const char *target_name, lldb::RunMode stop_other_threads = lldb::eOnlyDuringStepping);
105
106    void
107    StepOut ();
108
109    void
110    StepOutOfFrame (lldb::SBFrame &frame);
111
112    void
113    StepInstruction(bool step_over);
114
115    SBError
116    StepOverUntil (lldb::SBFrame &frame,
117                   lldb::SBFileSpec &file_spec,
118                   uint32_t line);
119
120    void
121    RunToAddress (lldb::addr_t addr);
122
123    SBError
124    ReturnFromFrame (SBFrame &frame, SBValue &return_value);
125
126    //--------------------------------------------------------------------------
127    /// LLDB currently supports process centric debugging which means when any
128    /// thread in a process stops, all other threads are stopped. The Suspend()
129    /// call here tells our process to suspend a thread and not let it run when
130    /// the other threads in a process are allowed to run. So when
131    /// SBProcess::Continue() is called, any threads that aren't suspended will
132    /// be allowed to run. If any of the SBThread functions for stepping are
133    /// called (StepOver, StepInto, StepOut, StepInstruction, RunToAddres), the
134    /// thread will not be allowed to run and these funtions will simply return.
135    ///
136    /// Eventually we plan to add support for thread centric debugging where
137    /// each thread is controlled individually and each thread would broadcast
138    /// its state, but we haven't implemented this yet.
139    ///
140    /// Likewise the SBThread::Resume() call will again allow the thread to run
141    /// when the process is continued.
142    ///
143    /// Suspend() and Resume() functions are not currently reference counted, if
144    /// anyone has the need for them to be reference counted, please let us
145    /// know.
146    //--------------------------------------------------------------------------
147    bool
148    Suspend();
149
150    bool
151    Resume ();
152
153    bool
154    IsSuspended();
155
156    bool
157    IsStopped();
158
159    uint32_t
160    GetNumFrames ();
161
162    lldb::SBFrame
163    GetFrameAtIndex (uint32_t idx);
164
165    lldb::SBFrame
166    GetSelectedFrame ();
167
168    lldb::SBFrame
169    SetSelectedFrame (uint32_t frame_idx);
170
171    static bool
172    EventIsThreadEvent (const SBEvent &event);
173
174    static SBFrame
175    GetStackFrameFromEvent (const SBEvent &event);
176
177    static SBThread
178    GetThreadFromEvent (const SBEvent &event);
179
180    lldb::SBProcess
181    GetProcess ();
182
183    const lldb::SBThread &
184    operator = (const lldb::SBThread &rhs);
185
186    bool
187    operator == (const lldb::SBThread &rhs) const;
188
189    bool
190    operator != (const lldb::SBThread &rhs) const;
191
192    bool
193    GetDescription (lldb::SBStream &description) const;
194
195    bool
196    GetStatus (lldb::SBStream &status) const;
197
198protected:
199    friend class SBBreakpoint;
200    friend class SBBreakpointLocation;
201    friend class SBFrame;
202    friend class SBProcess;
203    friend class SBDebugger;
204    friend class SBValue;
205
206    void
207    SetThread (const lldb::ThreadSP& lldb_object_sp);
208
209#ifndef SWIG
210    SBError
211    ResumeNewPlan (lldb_private::ExecutionContext &exe_ctx, lldb_private::ThreadPlan *new_plan);
212#endif
213
214private:
215    lldb::ExecutionContextRefSP m_opaque_sp;
216};
217
218} // namespace lldb
219
220#endif  // LLDB_SBThread_h_
221