1//===-- SBBreakpointLocation.cpp --------------------------------*- 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#include "lldb/API/SBBreakpointLocation.h"
11#include "lldb/API/SBDefines.h"
12#include "lldb/API/SBAddress.h"
13#include "lldb/API/SBDebugger.h"
14#include "lldb/API/SBStream.h"
15
16#include "lldb/lldb-types.h"
17#include "lldb/lldb-defines.h"
18#include "lldb/Breakpoint/Breakpoint.h"
19#include "lldb/Breakpoint/BreakpointLocation.h"
20#include "lldb/Target/ThreadSpec.h"
21#include "lldb/Core/Log.h"
22#include "lldb/Core/Stream.h"
23#include "lldb/Core/StreamFile.h"
24#include "lldb/Target/Target.h"
25#include "lldb/Target/ThreadSpec.h"
26
27using namespace lldb;
28using namespace lldb_private;
29
30
31SBBreakpointLocation::SBBreakpointLocation () :
32    m_opaque_sp ()
33{
34}
35
36SBBreakpointLocation::SBBreakpointLocation (const lldb::BreakpointLocationSP &break_loc_sp) :
37    m_opaque_sp (break_loc_sp)
38{
39    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
40
41    if (log)
42    {
43        SBStream sstr;
44        GetDescription (sstr, lldb::eDescriptionLevelBrief);
45        log->Printf ("SBBreakpointLocation::SBBreakpointLocaiton (const lldb::BreakpointLocationsSP &break_loc_sp"
46                     "=%p)  => this.sp = %p (%s)", break_loc_sp.get(), m_opaque_sp.get(), sstr.GetData());
47    }
48}
49
50SBBreakpointLocation::SBBreakpointLocation(const SBBreakpointLocation &rhs) :
51    m_opaque_sp (rhs.m_opaque_sp)
52{
53}
54
55const SBBreakpointLocation &
56SBBreakpointLocation::operator = (const SBBreakpointLocation &rhs)
57{
58    if (this != &rhs)
59        m_opaque_sp = rhs.m_opaque_sp;
60    return *this;
61}
62
63
64SBBreakpointLocation::~SBBreakpointLocation ()
65{
66}
67
68bool
69SBBreakpointLocation::IsValid() const
70{
71    return m_opaque_sp.get() != NULL;
72}
73
74SBAddress
75SBBreakpointLocation::GetAddress ()
76{
77    if (m_opaque_sp)
78        return SBAddress(&m_opaque_sp->GetAddress());
79    else
80        return SBAddress();
81}
82
83addr_t
84SBBreakpointLocation::GetLoadAddress ()
85{
86    addr_t ret_addr = LLDB_INVALID_ADDRESS;
87
88    if (m_opaque_sp)
89    {
90        Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().GetTarget().GetAPIMutex());
91        ret_addr = m_opaque_sp->GetLoadAddress();
92    }
93
94    return ret_addr;
95}
96
97void
98SBBreakpointLocation::SetEnabled (bool enabled)
99{
100    if (m_opaque_sp)
101    {
102        Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().GetTarget().GetAPIMutex());
103        m_opaque_sp->SetEnabled (enabled);
104    }
105}
106
107bool
108SBBreakpointLocation::IsEnabled ()
109{
110    if (m_opaque_sp)
111    {
112        Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().GetTarget().GetAPIMutex());
113        return m_opaque_sp->IsEnabled();
114    }
115    else
116        return false;
117}
118
119uint32_t
120SBBreakpointLocation::GetIgnoreCount ()
121{
122    if (m_opaque_sp)
123    {
124        Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().GetTarget().GetAPIMutex());
125        return m_opaque_sp->GetIgnoreCount();
126    }
127    else
128        return 0;
129}
130
131void
132SBBreakpointLocation::SetIgnoreCount (uint32_t n)
133{
134    if (m_opaque_sp)
135    {
136        Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().GetTarget().GetAPIMutex());
137        m_opaque_sp->SetIgnoreCount (n);
138    }
139}
140
141void
142SBBreakpointLocation::SetCondition (const char *condition)
143{
144    if (m_opaque_sp)
145    {
146        Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().GetTarget().GetAPIMutex());
147        m_opaque_sp->SetCondition (condition);
148    }
149}
150
151const char *
152SBBreakpointLocation::GetCondition ()
153{
154    if (m_opaque_sp)
155    {
156        Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().GetTarget().GetAPIMutex());
157        return m_opaque_sp->GetConditionText ();
158    }
159    return NULL;
160}
161
162void
163SBBreakpointLocation::SetThreadID (tid_t thread_id)
164{
165    if (m_opaque_sp)
166    {
167        Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().GetTarget().GetAPIMutex());
168        m_opaque_sp->SetThreadID (thread_id);
169    }
170}
171
172tid_t
173SBBreakpointLocation::GetThreadID ()
174{
175    tid_t tid = LLDB_INVALID_THREAD_ID;
176    if (m_opaque_sp)
177    {
178        Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().GetTarget().GetAPIMutex());
179        return m_opaque_sp->GetThreadID();
180    }
181    return tid;
182}
183
184void
185SBBreakpointLocation::SetThreadIndex (uint32_t index)
186{
187    if (m_opaque_sp)
188    {
189        Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().GetTarget().GetAPIMutex());
190        m_opaque_sp->SetThreadIndex (index);
191    }
192}
193
194uint32_t
195SBBreakpointLocation::GetThreadIndex() const
196{
197    uint32_t thread_idx = UINT32_MAX;
198    if (m_opaque_sp)
199    {
200        Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().GetTarget().GetAPIMutex());
201        return m_opaque_sp->GetThreadIndex();
202    }
203    return thread_idx;
204}
205
206
207void
208SBBreakpointLocation::SetThreadName (const char *thread_name)
209{
210    if (m_opaque_sp)
211    {
212        Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().GetTarget().GetAPIMutex());
213        m_opaque_sp->SetThreadName (thread_name);
214    }
215}
216
217const char *
218SBBreakpointLocation::GetThreadName () const
219{
220    if (m_opaque_sp)
221    {
222        Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().GetTarget().GetAPIMutex());
223        return m_opaque_sp->GetThreadName();
224    }
225    return NULL;
226}
227
228void
229SBBreakpointLocation::SetQueueName (const char *queue_name)
230{
231    if (m_opaque_sp)
232    {
233        Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().GetTarget().GetAPIMutex());
234        m_opaque_sp->SetQueueName (queue_name);
235    }
236}
237
238const char *
239SBBreakpointLocation::GetQueueName () const
240{
241    if (m_opaque_sp)
242    {
243        Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().GetTarget().GetAPIMutex());
244        m_opaque_sp->GetQueueName ();
245    }
246    return NULL;
247}
248
249bool
250SBBreakpointLocation::IsResolved ()
251{
252    if (m_opaque_sp)
253    {
254        Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().GetTarget().GetAPIMutex());
255        return m_opaque_sp->IsResolved();
256    }
257    return false;
258}
259
260void
261SBBreakpointLocation::SetLocation (const lldb::BreakpointLocationSP &break_loc_sp)
262{
263    // Uninstall the callbacks?
264    m_opaque_sp = break_loc_sp;
265}
266
267bool
268SBBreakpointLocation::GetDescription (SBStream &description, DescriptionLevel level)
269{
270    Stream &strm = description.ref();
271
272    if (m_opaque_sp)
273    {
274        Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().GetTarget().GetAPIMutex());
275        m_opaque_sp->GetDescription (&strm, level);
276        strm.EOL();
277    }
278    else
279        strm.PutCString ("No value");
280
281    return true;
282}
283
284break_id_t
285SBBreakpointLocation::GetID ()
286{
287    if (m_opaque_sp)
288    {
289        Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().GetTarget().GetAPIMutex());
290        return m_opaque_sp->GetID ();
291    }
292    else
293        return LLDB_INVALID_BREAK_ID;
294}
295
296SBBreakpoint
297SBBreakpointLocation::GetBreakpoint ()
298{
299    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
300
301    //if (log)
302    //    log->Printf ("SBBreakpointLocation::GetBreakpoint ()");
303
304    SBBreakpoint sb_bp;
305    if (m_opaque_sp)
306    {
307        Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().GetTarget().GetAPIMutex());
308        *sb_bp = m_opaque_sp->GetBreakpoint ().shared_from_this();
309    }
310
311    if (log)
312    {
313        SBStream sstr;
314        sb_bp.GetDescription (sstr);
315        log->Printf ("SBBreakpointLocation(%p)::GetBreakpoint () => SBBreakpoint(%p) %s",
316                     m_opaque_sp.get(), sb_bp.get(), sstr.GetData());
317    }
318    return sb_bp;
319}
320
321