contrib/llvm/tools/lldb/source/API/SBBreakpointLocation.cpp

   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/SBAddress.h"
  12 #include "lldb/API/SBDebugger.h"
  13 #include "lldb/API/SBDefines.h"
  14 #include "lldb/API/SBStream.h"
  15 #include "lldb/API/SBStringList.h"
  16
  17 #include "lldb/Breakpoint/Breakpoint.h"
  18 #include "lldb/Breakpoint/BreakpointLocation.h"
  19 #include "lldb/Core/Debugger.h"
  20 #include "lldb/Core/StreamFile.h"
  21 #include "lldb/Interpreter/CommandInterpreter.h"
  22 #include "lldb/Interpreter/ScriptInterpreter.h"
  23 #include "lldb/Target/Target.h"
  24 #include "lldb/Target/ThreadSpec.h"
  25 #include "lldb/Utility/Log.h"
  26 #include "lldb/Utility/Stream.h"
  27 #include "lldb/lldb-defines.h"
  28 #include "lldb/lldb-types.h"
  29
  30 using namespace lldb;
  31 using namespace lldb_private;
  32
  33 SBBreakpointLocation::SBBreakpointLocation() {}
  34
  35 SBBreakpointLocation::SBBreakpointLocation(
  36     const lldb::BreakpointLocationSP &break_loc_sp)
  37     : m_opaque_wp(break_loc_sp) {
  38   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
  39
  40   if (log) {
  41     SBStream sstr;
  42     GetDescription(sstr, lldb::eDescriptionLevelBrief);
  43     LLDB_LOG(log, "location = {0} ({1})", break_loc_sp.get(), sstr.GetData());
  44   }
  45 }
  46
  47 SBBreakpointLocation::SBBreakpointLocation(const SBBreakpointLocation &rhs)
  48     : m_opaque_wp(rhs.m_opaque_wp) {}
  49
  50 const SBBreakpointLocation &SBBreakpointLocation::
  51 operator=(const SBBreakpointLocation &rhs) {
  52   m_opaque_wp = rhs.m_opaque_wp;
  53   return *this;
  54 }
  55
  56 SBBreakpointLocation::~SBBreakpointLocation() {}
  57
  58 BreakpointLocationSP SBBreakpointLocation::GetSP() const {
  59   return m_opaque_wp.lock();
  60 }
  61
  62 bool SBBreakpointLocation::IsValid() const { return bool(GetSP()); }
  63
  64 SBAddress SBBreakpointLocation::GetAddress() {
  65   BreakpointLocationSP loc_sp = GetSP();
  66   if (loc_sp)
  67     return SBAddress(&loc_sp->GetAddress());
  68   else
  69     return SBAddress();
  70 }
  71
  72 addr_t SBBreakpointLocation::GetLoadAddress() {
  73   addr_t ret_addr = LLDB_INVALID_ADDRESS;
  74   BreakpointLocationSP loc_sp = GetSP();
  75
  76   if (loc_sp) {
  77     std::lock_guard<std::recursive_mutex> guard(
  78         loc_sp->GetTarget().GetAPIMutex());
  79     ret_addr = loc_sp->GetLoadAddress();
  80   }
  81
  82   return ret_addr;
  83 }
  84
  85 void SBBreakpointLocation::SetEnabled(bool enabled) {
  86   BreakpointLocationSP loc_sp = GetSP();
  87   if (loc_sp) {
  88     std::lock_guard<std::recursive_mutex> guard(
  89         loc_sp->GetTarget().GetAPIMutex());
  90     loc_sp->SetEnabled(enabled);
  91   }
  92 }
  93
  94 bool SBBreakpointLocation::IsEnabled() {
  95   BreakpointLocationSP loc_sp = GetSP();
  96   if (loc_sp) {
  97     std::lock_guard<std::recursive_mutex> guard(
  98         loc_sp->GetTarget().GetAPIMutex());
  99     return loc_sp->IsEnabled();
 100   } else
 101     return false;
 102 }
 103
 104 uint32_t SBBreakpointLocation::GetHitCount() {
 105   BreakpointLocationSP loc_sp = GetSP();
 106   if (loc_sp) {
 107     std::lock_guard<std::recursive_mutex> guard(
 108         loc_sp->GetTarget().GetAPIMutex());
 109     return loc_sp->GetHitCount();
 110   } else
 111     return 0;
 112 }
 113
 114 uint32_t SBBreakpointLocation::GetIgnoreCount() {
 115   BreakpointLocationSP loc_sp = GetSP();
 116   if (loc_sp) {
 117     std::lock_guard<std::recursive_mutex> guard(
 118         loc_sp->GetTarget().GetAPIMutex());
 119     return loc_sp->GetIgnoreCount();
 120   } else
 121     return 0;
 122 }
 123
 124 void SBBreakpointLocation::SetIgnoreCount(uint32_t n) {
 125   BreakpointLocationSP loc_sp = GetSP();
 126   if (loc_sp) {
 127     std::lock_guard<std::recursive_mutex> guard(
 128         loc_sp->GetTarget().GetAPIMutex());
 129     loc_sp->SetIgnoreCount(n);
 130   }
 131 }
 132
 133 void SBBreakpointLocation::SetCondition(const char *condition) {
 134   BreakpointLocationSP loc_sp = GetSP();
 135   if (loc_sp) {
 136     std::lock_guard<std::recursive_mutex> guard(
 137         loc_sp->GetTarget().GetAPIMutex());
 138     loc_sp->SetCondition(condition);
 139   }
 140 }
 141
 142 const char *SBBreakpointLocation::GetCondition() {
 143   BreakpointLocationSP loc_sp = GetSP();
 144   if (loc_sp) {
 145     std::lock_guard<std::recursive_mutex> guard(
 146         loc_sp->GetTarget().GetAPIMutex());
 147     return loc_sp->GetConditionText();
 148   }
 149   return NULL;
 150 }
 151
 152 void SBBreakpointLocation::SetAutoContinue(bool auto_continue) {
 153   BreakpointLocationSP loc_sp = GetSP();
 154   if (loc_sp) {
 155     std::lock_guard<std::recursive_mutex> guard(
 156         loc_sp->GetTarget().GetAPIMutex());
 157     loc_sp->SetAutoContinue(auto_continue);
 158   }
 159 }
 160
 161 bool SBBreakpointLocation::GetAutoContinue() {
 162   BreakpointLocationSP loc_sp = GetSP();
 163   if (loc_sp) {
 164     std::lock_guard<std::recursive_mutex> guard(
 165         loc_sp->GetTarget().GetAPIMutex());
 166     return loc_sp->IsAutoContinue();
 167   }
 168   return false;
 169 }
 170
 171 void SBBreakpointLocation::SetScriptCallbackFunction(
 172     const char *callback_function_name) {
 173   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 174   BreakpointLocationSP loc_sp = GetSP();
 175   LLDB_LOG(log, "location = {0}, callback = {1}", loc_sp.get(),
 176            callback_function_name);
 177
 178   if (loc_sp) {
 179     std::lock_guard<std::recursive_mutex> guard(
 180         loc_sp->GetTarget().GetAPIMutex());
 181     BreakpointOptions *bp_options = loc_sp->GetLocationOptions();
 182     loc_sp->GetBreakpoint()
 183         .GetTarget()
 184         .GetDebugger()
 185         .GetCommandInterpreter()
 186         .GetScriptInterpreter()
 187         ->SetBreakpointCommandCallbackFunction(bp_options,
 188                                                callback_function_name);
 189   }
 190 }
 191
 192 SBError
 193 SBBreakpointLocation::SetScriptCallbackBody(const char *callback_body_text) {
 194   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 195   BreakpointLocationSP loc_sp = GetSP();
 196   LLDB_LOG(log, "location = {0}: callback body:\n{1}", loc_sp.get(),
 197            callback_body_text);
 198
 199   SBError sb_error;
 200   if (loc_sp) {
 201     std::lock_guard<std::recursive_mutex> guard(
 202         loc_sp->GetTarget().GetAPIMutex());
 203     BreakpointOptions *bp_options = loc_sp->GetLocationOptions();
 204     Status error =
 205         loc_sp->GetBreakpoint()
 206             .GetTarget()
 207             .GetDebugger()
 208             .GetCommandInterpreter()
 209             .GetScriptInterpreter()
 210             ->SetBreakpointCommandCallback(bp_options, callback_body_text);
 211     sb_error.SetError(error);
 212   } else
 213     sb_error.SetErrorString("invalid breakpoint");
 214
 215   return sb_error;
 216 }
 217
 218 void SBBreakpointLocation::SetCommandLineCommands(SBStringList &commands) {
 219   BreakpointLocationSP loc_sp = GetSP();
 220   if (!loc_sp)
 221     return;
 222   if (commands.GetSize() == 0)
 223     return;
 224
 225   std::lock_guard<std::recursive_mutex> guard(
 226       loc_sp->GetTarget().GetAPIMutex());
 227   std::unique_ptr<BreakpointOptions::CommandData> cmd_data_up(
 228       new BreakpointOptions::CommandData(*commands, eScriptLanguageNone));
 229
 230   loc_sp->GetLocationOptions()->SetCommandDataCallback(cmd_data_up);
 231 }
 232
 233 bool SBBreakpointLocation::GetCommandLineCommands(SBStringList &commands) {
 234   BreakpointLocationSP loc_sp = GetSP();
 235   if (!loc_sp)
 236     return false;
 237   StringList command_list;
 238   bool has_commands =
 239       loc_sp->GetLocationOptions()->GetCommandLineCallbacks(command_list);
 240   if (has_commands)
 241     commands.AppendList(command_list);
 242   return has_commands;
 243 }
 244
 245 void SBBreakpointLocation::SetThreadID(tid_t thread_id) {
 246   BreakpointLocationSP loc_sp = GetSP();
 247   if (loc_sp) {
 248     std::lock_guard<std::recursive_mutex> guard(
 249         loc_sp->GetTarget().GetAPIMutex());
 250     loc_sp->SetThreadID(thread_id);
 251   }
 252 }
 253
 254 tid_t SBBreakpointLocation::GetThreadID() {
 255   tid_t tid = LLDB_INVALID_THREAD_ID;
 256   BreakpointLocationSP loc_sp = GetSP();
 257   if (loc_sp) {
 258     std::lock_guard<std::recursive_mutex> guard(
 259         loc_sp->GetTarget().GetAPIMutex());
 260     return loc_sp->GetThreadID();
 261   }
 262   return tid;
 263 }
 264
 265 void SBBreakpointLocation::SetThreadIndex(uint32_t index) {
 266   BreakpointLocationSP loc_sp = GetSP();
 267   if (loc_sp) {
 268     std::lock_guard<std::recursive_mutex> guard(
 269         loc_sp->GetTarget().GetAPIMutex());
 270     loc_sp->SetThreadIndex(index);
 271   }
 272 }
 273
 274 uint32_t SBBreakpointLocation::GetThreadIndex() const {
 275   uint32_t thread_idx = UINT32_MAX;
 276   BreakpointLocationSP loc_sp = GetSP();
 277   if (loc_sp) {
 278     std::lock_guard<std::recursive_mutex> guard(
 279         loc_sp->GetTarget().GetAPIMutex());
 280     return loc_sp->GetThreadIndex();
 281   }
 282   return thread_idx;
 283 }
 284
 285 void SBBreakpointLocation::SetThreadName(const char *thread_name) {
 286   BreakpointLocationSP loc_sp = GetSP();
 287   if (loc_sp) {
 288     std::lock_guard<std::recursive_mutex> guard(
 289         loc_sp->GetTarget().GetAPIMutex());
 290     loc_sp->SetThreadName(thread_name);
 291   }
 292 }
 293
 294 const char *SBBreakpointLocation::GetThreadName() const {
 295   BreakpointLocationSP loc_sp = GetSP();
 296   if (loc_sp) {
 297     std::lock_guard<std::recursive_mutex> guard(
 298         loc_sp->GetTarget().GetAPIMutex());
 299     return loc_sp->GetThreadName();
 300   }
 301   return NULL;
 302 }
 303
 304 void SBBreakpointLocation::SetQueueName(const char *queue_name) {
 305   BreakpointLocationSP loc_sp = GetSP();
 306   if (loc_sp) {
 307     std::lock_guard<std::recursive_mutex> guard(
 308         loc_sp->GetTarget().GetAPIMutex());
 309     loc_sp->SetQueueName(queue_name);
 310   }
 311 }
 312
 313 const char *SBBreakpointLocation::GetQueueName() const {
 314   BreakpointLocationSP loc_sp = GetSP();
 315   if (loc_sp) {
 316     std::lock_guard<std::recursive_mutex> guard(
 317         loc_sp->GetTarget().GetAPIMutex());
 318     loc_sp->GetQueueName();
 319   }
 320   return NULL;
 321 }
 322
 323 bool SBBreakpointLocation::IsResolved() {
 324   BreakpointLocationSP loc_sp = GetSP();
 325   if (loc_sp) {
 326     std::lock_guard<std::recursive_mutex> guard(
 327         loc_sp->GetTarget().GetAPIMutex());
 328     return loc_sp->IsResolved();
 329   }
 330   return false;
 331 }
 332
 333 void SBBreakpointLocation::SetLocation(
 334     const lldb::BreakpointLocationSP &break_loc_sp) {
 335   // Uninstall the callbacks?
 336   m_opaque_wp = break_loc_sp;
 337 }
 338
 339 bool SBBreakpointLocation::GetDescription(SBStream &description,
 340                                           DescriptionLevel level) {
 341   Stream &strm = description.ref();
 342   BreakpointLocationSP loc_sp = GetSP();
 343
 344   if (loc_sp) {
 345     std::lock_guard<std::recursive_mutex> guard(
 346         loc_sp->GetTarget().GetAPIMutex());
 347     loc_sp->GetDescription(&strm, level);
 348     strm.EOL();
 349   } else
 350     strm.PutCString("No value");
 351
 352   return true;
 353 }
 354
 355 break_id_t SBBreakpointLocation::GetID() {
 356   BreakpointLocationSP loc_sp = GetSP();
 357   if (loc_sp) {
 358     std::lock_guard<std::recursive_mutex> guard(
 359         loc_sp->GetTarget().GetAPIMutex());
 360     return loc_sp->GetID();
 361   } else
 362     return LLDB_INVALID_BREAK_ID;
 363 }
 364
 365 SBBreakpoint SBBreakpointLocation::GetBreakpoint() {
 366   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 367   BreakpointLocationSP loc_sp = GetSP();
 368
 369   SBBreakpoint sb_bp;
 370   if (loc_sp) {
 371     std::lock_guard<std::recursive_mutex> guard(
 372         loc_sp->GetTarget().GetAPIMutex());
 373     sb_bp = loc_sp->GetBreakpoint().shared_from_this();
 374   }
 375
 376   if (log) {
 377     SBStream sstr;
 378     sb_bp.GetDescription(sstr);
 379     LLDB_LOG(log, "location = {0}, breakpoint = {1} ({2})", loc_sp.get(),
 380              sb_bp.GetSP().get(), sstr.GetData());
 381   }
 382   return sb_bp;
 383 }