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