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

   1 //===-- SBWatchpoint.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/SBWatchpoint.h"
  11 #include "lldb/API/SBDefines.h"
  12 #include "lldb/API/SBAddress.h"
  13 #include "lldb/API/SBDebugger.h"
  14 #include "lldb/API/SBEvent.h"
  15 #include "lldb/API/SBStream.h"
  16
  17 #include "lldb/lldb-types.h"
  18 #include "lldb/lldb-defines.h"
  19 #include "lldb/Breakpoint/Watchpoint.h"
  20 #include "lldb/Breakpoint/WatchpointList.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
  26 using namespace lldb;
  27 using namespace lldb_private;
  28
  29
  30 SBWatchpoint::SBWatchpoint () :
  31     m_opaque_sp ()
  32 {
  33 }
  34
  35 SBWatchpoint::SBWatchpoint (const lldb::WatchpointSP &wp_sp) :
  36     m_opaque_sp (wp_sp)
  37 {
  38     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
  39
  40     if (log)
  41     {
  42         SBStream sstr;
  43         GetDescription (sstr, lldb::eDescriptionLevelBrief);
  44         log->Printf ("SBWatchpoint::SBWatchpoint (const lldb::WatchpointSP &wp_sp"
  45                      "=%p)  => this.sp = %p (%s)", wp_sp.get(), m_opaque_sp.get(), sstr.GetData());
  46     }
  47 }
  48
  49 SBWatchpoint::SBWatchpoint(const SBWatchpoint &rhs) :
  50     m_opaque_sp (rhs.m_opaque_sp)
  51 {
  52 }
  53
  54 const SBWatchpoint &
  55 SBWatchpoint::operator = (const SBWatchpoint &rhs)
  56 {
  57     if (this != &rhs)
  58         m_opaque_sp = rhs.m_opaque_sp;
  59     return *this;
  60 }
  61
  62
  63 SBWatchpoint::~SBWatchpoint ()
  64 {
  65 }
  66
  67 watch_id_t
  68 SBWatchpoint::GetID ()
  69 {
  70     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
  71
  72     watch_id_t watch_id = LLDB_INVALID_WATCH_ID;
  73     lldb::WatchpointSP watchpoint_sp(GetSP());
  74     if (watchpoint_sp)
  75         watch_id = watchpoint_sp->GetID();
  76
  77     if (log)
  78     {
  79         if (watch_id == LLDB_INVALID_WATCH_ID)
  80             log->Printf ("SBWatchpoint(%p)::GetID () => LLDB_INVALID_WATCH_ID", watchpoint_sp.get());
  81         else
  82             log->Printf ("SBWatchpoint(%p)::GetID () => %u", watchpoint_sp.get(), watch_id);
  83     }
  84
  85     return watch_id;
  86 }
  87
  88 bool
  89 SBWatchpoint::IsValid() const
  90 {
  91     return (bool) m_opaque_sp;
  92 }
  93
  94 SBError
  95 SBWatchpoint::GetError ()
  96 {
  97     SBError sb_error;
  98     lldb::WatchpointSP watchpoint_sp(GetSP());
  99     if (watchpoint_sp)
 100     {
 101         sb_error.SetError(watchpoint_sp->GetError());
 102     }
 103     return sb_error;
 104 }
 105
 106 int32_t
 107 SBWatchpoint::GetHardwareIndex ()
 108 {
 109     int32_t hw_index = -1;
 110
 111     lldb::WatchpointSP watchpoint_sp(GetSP());
 112     if (watchpoint_sp)
 113     {
 114         Mutex::Locker api_locker (watchpoint_sp->GetTarget().GetAPIMutex());
 115         hw_index = watchpoint_sp->GetHardwareIndex();
 116     }
 117
 118     return hw_index;
 119 }
 120
 121 addr_t
 122 SBWatchpoint::GetWatchAddress ()
 123 {
 124     addr_t ret_addr = LLDB_INVALID_ADDRESS;
 125
 126     lldb::WatchpointSP watchpoint_sp(GetSP());
 127     if (watchpoint_sp)
 128     {
 129         Mutex::Locker api_locker (watchpoint_sp->GetTarget().GetAPIMutex());
 130         ret_addr = watchpoint_sp->GetLoadAddress();
 131     }
 132
 133     return ret_addr;
 134 }
 135
 136 size_t
 137 SBWatchpoint::GetWatchSize ()
 138 {
 139     size_t watch_size = 0;
 140
 141     lldb::WatchpointSP watchpoint_sp(GetSP());
 142     if (watchpoint_sp)
 143     {
 144         Mutex::Locker api_locker (watchpoint_sp->GetTarget().GetAPIMutex());
 145         watch_size = watchpoint_sp->GetByteSize();
 146     }
 147
 148     return watch_size;
 149 }
 150
 151 void
 152 SBWatchpoint::SetEnabled (bool enabled)
 153 {
 154     lldb::WatchpointSP watchpoint_sp(GetSP());
 155     if (watchpoint_sp)
 156     {
 157         Mutex::Locker api_locker (watchpoint_sp->GetTarget().GetAPIMutex());
 158         watchpoint_sp->GetTarget().DisableWatchpointByID(watchpoint_sp->GetID());
 159     }
 160 }
 161
 162 bool
 163 SBWatchpoint::IsEnabled ()
 164 {
 165     lldb::WatchpointSP watchpoint_sp(GetSP());
 166     if (watchpoint_sp)
 167     {
 168         Mutex::Locker api_locker (watchpoint_sp->GetTarget().GetAPIMutex());
 169         return watchpoint_sp->IsEnabled();
 170     }
 171     else
 172         return false;
 173 }
 174
 175 uint32_t
 176 SBWatchpoint::GetHitCount ()
 177 {
 178     uint32_t count = 0;
 179     lldb::WatchpointSP watchpoint_sp(GetSP());
 180     if (watchpoint_sp)
 181     {
 182         Mutex::Locker api_locker (watchpoint_sp->GetTarget().GetAPIMutex());
 183         count = watchpoint_sp->GetHitCount();
 184     }
 185
 186     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
 187     if (log)
 188         log->Printf ("SBWatchpoint(%p)::GetHitCount () => %u", watchpoint_sp.get(), count);
 189
 190     return count;
 191 }
 192
 193 uint32_t
 194 SBWatchpoint::GetIgnoreCount ()
 195 {
 196     lldb::WatchpointSP watchpoint_sp(GetSP());
 197     if (watchpoint_sp)
 198     {
 199         Mutex::Locker api_locker (watchpoint_sp->GetTarget().GetAPIMutex());
 200         return watchpoint_sp->GetIgnoreCount();
 201     }
 202     else
 203         return 0;
 204 }
 205
 206 void
 207 SBWatchpoint::SetIgnoreCount (uint32_t n)
 208 {
 209     lldb::WatchpointSP watchpoint_sp(GetSP());
 210     if (watchpoint_sp)
 211     {
 212         Mutex::Locker api_locker (watchpoint_sp->GetTarget().GetAPIMutex());
 213         watchpoint_sp->SetIgnoreCount (n);
 214     }
 215 }
 216
 217 const char *
 218 SBWatchpoint::GetCondition ()
 219 {
 220     lldb::WatchpointSP watchpoint_sp(GetSP());
 221     if (watchpoint_sp)
 222     {
 223         Mutex::Locker api_locker (watchpoint_sp->GetTarget().GetAPIMutex());
 224         return watchpoint_sp->GetConditionText ();
 225     }
 226     return NULL;
 227 }
 228
 229 void
 230 SBWatchpoint::SetCondition (const char *condition)
 231 {
 232     lldb::WatchpointSP watchpoint_sp(GetSP());
 233     if (watchpoint_sp)
 234     {
 235         Mutex::Locker api_locker (watchpoint_sp->GetTarget().GetAPIMutex());
 236         watchpoint_sp->SetCondition (condition);
 237     }
 238 }
 239
 240 bool
 241 SBWatchpoint::GetDescription (SBStream &description, DescriptionLevel level)
 242 {
 243     Stream &strm = description.ref();
 244
 245     lldb::WatchpointSP watchpoint_sp(GetSP());
 246     if (watchpoint_sp)
 247     {
 248         Mutex::Locker api_locker (watchpoint_sp->GetTarget().GetAPIMutex());
 249         watchpoint_sp->GetDescription (&strm, level);
 250         strm.EOL();
 251     }
 252     else
 253         strm.PutCString ("No value");
 254
 255     return true;
 256 }
 257
 258 void
 259 SBWatchpoint::Clear ()
 260 {
 261     m_opaque_sp.reset();
 262 }
 263
 264 lldb::WatchpointSP
 265 SBWatchpoint::GetSP () const
 266 {
 267     return m_opaque_sp;
 268 }
 269
 270 void
 271 SBWatchpoint::SetSP (const lldb::WatchpointSP &sp)
 272 {
 273     m_opaque_sp = sp;
 274 }
 275
 276 bool
 277 SBWatchpoint::EventIsWatchpointEvent (const lldb::SBEvent &event)
 278 {
 279     return Watchpoint::WatchpointEventData::GetEventDataFromEvent(event.get()) != NULL;
 280
 281 }
 282
 283 WatchpointEventType
 284 SBWatchpoint::GetWatchpointEventTypeFromEvent (const SBEvent& event)
 285 {
 286     if (event.IsValid())
 287         return Watchpoint::WatchpointEventData::GetWatchpointEventTypeFromEvent (event.GetSP());
 288     return eWatchpointEventTypeInvalidType;
 289 }
 290
 291 SBWatchpoint
 292 SBWatchpoint::GetWatchpointFromEvent (const lldb::SBEvent& event)
 293 {
 294     SBWatchpoint sb_watchpoint;
 295     if (event.IsValid())
 296         sb_watchpoint.m_opaque_sp = Watchpoint::WatchpointEventData::GetWatchpointFromEvent (event.GetSP());
 297     return sb_watchpoint;
 298 }