contrib/llvm/tools/lldb/source/Breakpoint/BreakpointOptions.cpp

   1 //===-- BreakpointOptions.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/Breakpoint/BreakpointOptions.h"
  11
  12 // C Includes
  13 // C++ Includes
  14 // Other libraries and framework includes
  15 // Project includes
  16 #include "lldb/Core/Stream.h"
  17 #include "lldb/Core/StringList.h"
  18 #include "lldb/Core/Value.h"
  19 #include "lldb/Breakpoint/StoppointCallbackContext.h"
  20 #include "lldb/Target/Process.h"
  21 #include "lldb/Target/Target.h"
  22 #include "lldb/Target/ThreadSpec.h"
  23 #include "lldb/Expression/ClangUserExpression.h"
  24
  25 using namespace lldb;
  26 using namespace lldb_private;
  27
  28 bool
  29 BreakpointOptions::NullCallback (void *baton, StoppointCallbackContext *context, lldb::user_id_t break_id, lldb::user_id_t break_loc_id)
  30 {
  31     return true;
  32 }
  33
  34 //----------------------------------------------------------------------
  35 // BreakpointOptions constructor
  36 //----------------------------------------------------------------------
  37 BreakpointOptions::BreakpointOptions() :
  38     m_callback (BreakpointOptions::NullCallback),
  39     m_callback_baton_sp (),
  40     m_callback_is_synchronous (false),
  41     m_enabled (true),
  42     m_one_shot (false),
  43     m_ignore_count (0),
  44     m_thread_spec_ap (),
  45     m_condition_text (),
  46     m_condition_text_hash (0)
  47 {
  48 }
  49
  50 //----------------------------------------------------------------------
  51 // BreakpointOptions copy constructor
  52 //----------------------------------------------------------------------
  53 BreakpointOptions::BreakpointOptions(const BreakpointOptions& rhs) :
  54     m_callback (rhs.m_callback),
  55     m_callback_baton_sp (rhs.m_callback_baton_sp),
  56     m_callback_is_synchronous (rhs.m_callback_is_synchronous),
  57     m_enabled (rhs.m_enabled),
  58     m_one_shot (rhs.m_one_shot),
  59     m_ignore_count (rhs.m_ignore_count),
  60     m_thread_spec_ap ()
  61 {
  62     if (rhs.m_thread_spec_ap.get() != NULL)
  63         m_thread_spec_ap.reset (new ThreadSpec(*rhs.m_thread_spec_ap.get()));
  64     m_condition_text = rhs.m_condition_text;
  65     m_condition_text_hash = rhs.m_condition_text_hash;
  66 }
  67
  68 //----------------------------------------------------------------------
  69 // BreakpointOptions assignment operator
  70 //----------------------------------------------------------------------
  71 const BreakpointOptions&
  72 BreakpointOptions::operator=(const BreakpointOptions& rhs)
  73 {
  74     m_callback = rhs.m_callback;
  75     m_callback_baton_sp = rhs.m_callback_baton_sp;
  76     m_callback_is_synchronous = rhs.m_callback_is_synchronous;
  77     m_enabled = rhs.m_enabled;
  78     m_one_shot = rhs.m_one_shot;
  79     m_ignore_count = rhs.m_ignore_count;
  80     if (rhs.m_thread_spec_ap.get() != NULL)
  81         m_thread_spec_ap.reset(new ThreadSpec(*rhs.m_thread_spec_ap.get()));
  82     m_condition_text = rhs.m_condition_text;
  83     m_condition_text_hash = rhs.m_condition_text_hash;
  84     return *this;
  85 }
  86
  87 BreakpointOptions *
  88 BreakpointOptions::CopyOptionsNoCallback (BreakpointOptions &orig)
  89 {
  90     BreakpointHitCallback orig_callback = orig.m_callback;
  91     lldb::BatonSP orig_callback_baton_sp = orig.m_callback_baton_sp;
  92     bool orig_is_sync = orig.m_callback_is_synchronous;
  93
  94     orig.ClearCallback();
  95     BreakpointOptions *ret_val = new BreakpointOptions(orig);
  96
  97     orig.SetCallback (orig_callback, orig_callback_baton_sp, orig_is_sync);
  98
  99     return ret_val;
 100 }
 101
 102 //----------------------------------------------------------------------
 103 // Destructor
 104 //----------------------------------------------------------------------
 105 BreakpointOptions::~BreakpointOptions()
 106 {
 107 }
 108
 109 //------------------------------------------------------------------
 110 // Callbacks
 111 //------------------------------------------------------------------
 112 void
 113 BreakpointOptions::SetCallback (BreakpointHitCallback callback, const BatonSP &callback_baton_sp, bool callback_is_synchronous)
 114 {
 115     m_callback_is_synchronous = callback_is_synchronous;
 116     m_callback = callback;
 117     m_callback_baton_sp = callback_baton_sp;
 118 }
 119
 120 void
 121 BreakpointOptions::ClearCallback ()
 122 {
 123     m_callback = BreakpointOptions::NullCallback;
 124     m_callback_is_synchronous = false;
 125     m_callback_baton_sp.reset();
 126 }
 127
 128 Baton *
 129 BreakpointOptions::GetBaton ()
 130 {
 131     return m_callback_baton_sp.get();
 132 }
 133
 134 const Baton *
 135 BreakpointOptions::GetBaton () const
 136 {
 137     return m_callback_baton_sp.get();
 138 }
 139
 140 bool
 141 BreakpointOptions::InvokeCallback (StoppointCallbackContext *context,
 142                                    lldb::user_id_t break_id,
 143                                    lldb::user_id_t break_loc_id)
 144 {
 145     if (m_callback && context->is_synchronous == IsCallbackSynchronous())
 146     {
 147         return m_callback (m_callback_baton_sp ? m_callback_baton_sp->m_data : NULL,
 148                            context,
 149                            break_id,
 150                            break_loc_id);
 151     }
 152     else
 153         return true;
 154 }
 155
 156 bool
 157 BreakpointOptions::HasCallback ()
 158 {
 159     return m_callback != BreakpointOptions::NullCallback;
 160 }
 161
 162 void
 163 BreakpointOptions::SetCondition (const char *condition)
 164 {
 165     if (!condition)
 166         condition = "";
 167
 168     m_condition_text.assign(condition);
 169     std::hash<std::string> hasher;
 170     m_condition_text_hash = hasher(m_condition_text);
 171 }
 172
 173 const char *
 174 BreakpointOptions::GetConditionText (size_t *hash) const
 175 {
 176     if (!m_condition_text.empty())
 177     {
 178         if (hash)
 179             *hash = m_condition_text_hash;
 180
 181         return m_condition_text.c_str();
 182     }
 183     else
 184     {
 185         return NULL;
 186     }
 187 }
 188
 189 const ThreadSpec *
 190 BreakpointOptions::GetThreadSpecNoCreate () const
 191 {
 192     return m_thread_spec_ap.get();
 193 }
 194
 195 ThreadSpec *
 196 BreakpointOptions::GetThreadSpec ()
 197 {
 198     if (m_thread_spec_ap.get() == NULL)
 199         m_thread_spec_ap.reset (new ThreadSpec());
 200
 201     return m_thread_spec_ap.get();
 202 }
 203
 204 void
 205 BreakpointOptions::SetThreadID (lldb::tid_t thread_id)
 206 {
 207     GetThreadSpec()->SetTID(thread_id);
 208 }
 209
 210 void
 211 BreakpointOptions::GetDescription (Stream *s, lldb::DescriptionLevel level) const
 212 {
 213
 214     // Figure out if there are any options not at their default value, and only print
 215     // anything if there are:
 216
 217     if (m_ignore_count != 0 || !m_enabled || m_one_shot || (GetThreadSpecNoCreate() != NULL && GetThreadSpecNoCreate()->HasSpecification ()))
 218     {
 219         if (level == lldb::eDescriptionLevelVerbose)
 220         {
 221             s->EOL ();
 222             s->IndentMore();
 223             s->Indent();
 224             s->PutCString("Breakpoint Options:\n");
 225             s->IndentMore();
 226             s->Indent();
 227         }
 228         else
 229             s->PutCString(" Options: ");
 230
 231         if (m_ignore_count > 0)
 232             s->Printf("ignore: %d ", m_ignore_count);
 233         s->Printf("%sabled ", m_enabled ? "en" : "dis");
 234
 235         if (m_one_shot)
 236             s->Printf ("one-shot ");
 237
 238         if (m_thread_spec_ap.get())
 239             m_thread_spec_ap->GetDescription (s, level);
 240         else if (level == eDescriptionLevelBrief)
 241             s->PutCString ("thread spec: no ");
 242         if (level == lldb::eDescriptionLevelFull)
 243         {
 244             s->IndentLess();
 245             s->IndentMore();
 246         }
 247     }
 248
 249     if (m_callback_baton_sp.get())
 250     {
 251         if (level != eDescriptionLevelBrief)
 252         {
 253             s->EOL();
 254             m_callback_baton_sp->GetDescription (s, level);
 255         }
 256     }
 257     if (!m_condition_text.empty())
 258     {
 259        if (level != eDescriptionLevelBrief)
 260        {
 261             s->EOL();
 262             s->Printf("Condition: %s\n", m_condition_text.c_str());
 263         }
 264     }
 265 }
 266
 267 void
 268 BreakpointOptions::CommandBaton::GetDescription (Stream *s, lldb::DescriptionLevel level) const
 269 {
 270     CommandData *data = (CommandData *)m_data;
 271
 272     if (level == eDescriptionLevelBrief)
 273     {
 274         s->Printf (", commands = %s", (data && data->user_source.GetSize() > 0) ? "yes" : "no");
 275         return;
 276     }
 277
 278     s->IndentMore ();
 279     s->Indent("Breakpoint commands:\n");
 280
 281     s->IndentMore ();
 282     if (data && data->user_source.GetSize() > 0)
 283     {
 284         const size_t num_strings = data->user_source.GetSize();
 285         for (size_t i = 0; i < num_strings; ++i)
 286         {
 287             s->Indent(data->user_source.GetStringAtIndex(i));
 288             s->EOL();
 289         }
 290     }
 291     else
 292     {
 293         s->PutCString ("No commands.\n");
 294     }
 295     s->IndentLess ();
 296     s->IndentLess ();
 297 }
 298