Home | History | Annotate | Download | only in Breakpoint 
      1 //===-- BreakpointLocation.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/lldb-python.h"
     11 
     12 // C Includes
     13 // C++ Includes
     14 #include <string>
     15 
     16 // Other libraries and framework includes
     17 // Project includes
     18 #include "lldb/lldb-private-log.h"
     19 #include "lldb/Breakpoint/BreakpointLocation.h"
     20 #include "lldb/Breakpoint/BreakpointID.h"
     21 #include "lldb/Breakpoint/StoppointCallbackContext.h"
     22 #include "lldb/Core/Debugger.h"
     23 #include "lldb/Core/Log.h"
     24 #include "lldb/Core/Module.h"
     25 #include "lldb/Core/StreamString.h"
     26 #include "lldb/Symbol/CompileUnit.h"
     27 #include "lldb/Symbol/Symbol.h"
     28 #include "lldb/Target/Target.h"
     29 #include "lldb/Target/Process.h"
     30 #include "lldb/Target/Thread.h"
     31 #include "lldb/Target/ThreadSpec.h"
     32 
     33 using namespace lldb;
     34 using namespace lldb_private;
     35 
     36 BreakpointLocation::BreakpointLocation
     37 (
     38     break_id_t loc_id,
     39     Breakpoint &owner,
     40     const Address &addr,
     41     lldb::tid_t tid,
     42     bool hardware
     43 ) :
     44     StoppointLocation (loc_id, addr.GetOpcodeLoadAddress(&owner.GetTarget()), hardware),
     45     m_being_created(true),
     46     m_address (addr),
     47     m_owner (owner),
     48     m_options_ap (),
     49     m_bp_site_sp (),
     50     m_condition_mutex ()
     51 {
     52     SetThreadID (tid);
     53     m_being_created = false;
     54 }
     55 
     56 BreakpointLocation::~BreakpointLocation()
     57 {
     58     ClearBreakpointSite();
     59 }
     60 
     61 lldb::addr_t
     62 BreakpointLocation::GetLoadAddress () const
     63 {
     64     return m_address.GetOpcodeLoadAddress (&m_owner.GetTarget());
     65 }
     66 
     67 Address &
     68 BreakpointLocation::GetAddress ()
     69 {
     70     return m_address;
     71 }
     72 
     73 Breakpoint &
     74 BreakpointLocation::GetBreakpoint ()
     75 {
     76     return m_owner;
     77 }
     78 
     79 bool
     80 BreakpointLocation::IsEnabled () const
     81 {
     82     if (!m_owner.IsEnabled())
     83         return false;
     84     else if (m_options_ap.get() != NULL)
     85         return m_options_ap->IsEnabled();
     86     else
     87         return true;
     88 }
     89 
     90 void
     91 BreakpointLocation::SetEnabled (bool enabled)
     92 {
     93     GetLocationOptions()->SetEnabled(enabled);
     94     if (enabled)
     95     {
     96         ResolveBreakpointSite();
     97     }
     98     else
     99     {
    100         ClearBreakpointSite();
    101     }
    102     SendBreakpointLocationChangedEvent (enabled ? eBreakpointEventTypeEnabled : eBreakpointEventTypeDisabled);
    103 }
    104 
    105 void
    106 BreakpointLocation::SetThreadID (lldb::tid_t thread_id)
    107 {
    108     if (thread_id != LLDB_INVALID_THREAD_ID)
    109         GetLocationOptions()->SetThreadID(thread_id);
    110     else
    111     {
    112         // If we're resetting this to an invalid thread id, then
    113         // don't make an options pointer just to do that.
    114         if (m_options_ap.get() != NULL)
    115             m_options_ap->SetThreadID (thread_id);
    116     }
    117     SendBreakpointLocationChangedEvent (eBreakpointEventTypeThreadChanged);
    118 }
    119 
    120 lldb::tid_t
    121 BreakpointLocation::GetThreadID ()
    122 {
    123     if (GetOptionsNoCreate()->GetThreadSpecNoCreate())
    124         return GetOptionsNoCreate()->GetThreadSpecNoCreate()->GetTID();
    125     else
    126         return LLDB_INVALID_THREAD_ID;
    127 }
    128 
    129 void
    130 BreakpointLocation::SetThreadIndex (uint32_t index)
    131 {
    132     if (index != 0)
    133         GetLocationOptions()->GetThreadSpec()->SetIndex(index);
    134     else
    135     {
    136         // If we're resetting this to an invalid thread id, then
    137         // don't make an options pointer just to do that.
    138         if (m_options_ap.get() != NULL)
    139             m_options_ap->GetThreadSpec()->SetIndex(index);
    140     }
    141     SendBreakpointLocationChangedEvent (eBreakpointEventTypeThreadChanged);
    142 
    143 }
    144 
    145 uint32_t
    146 BreakpointLocation::GetThreadIndex() const
    147 {
    148     if (GetOptionsNoCreate()->GetThreadSpecNoCreate())
    149         return GetOptionsNoCreate()->GetThreadSpecNoCreate()->GetIndex();
    150     else
    151         return 0;
    152 }
    153 
    154 void
    155 BreakpointLocation::SetThreadName (const char *thread_name)
    156 {
    157     if (thread_name != NULL)
    158         GetLocationOptions()->GetThreadSpec()->SetName(thread_name);
    159     else
    160     {
    161         // If we're resetting this to an invalid thread id, then
    162         // don't make an options pointer just to do that.
    163         if (m_options_ap.get() != NULL)
    164             m_options_ap->GetThreadSpec()->SetName(thread_name);
    165     }
    166     SendBreakpointLocationChangedEvent (eBreakpointEventTypeThreadChanged);
    167 }
    168 
    169 const char *
    170 BreakpointLocation::GetThreadName () const
    171 {
    172     if (GetOptionsNoCreate()->GetThreadSpecNoCreate())
    173         return GetOptionsNoCreate()->GetThreadSpecNoCreate()->GetName();
    174     else
    175         return NULL;
    176 }
    177 
    178 void
    179 BreakpointLocation::SetQueueName (const char *queue_name)
    180 {
    181     if (queue_name != NULL)
    182         GetLocationOptions()->GetThreadSpec()->SetQueueName(queue_name);
    183     else
    184     {
    185         // If we're resetting this to an invalid thread id, then
    186         // don't make an options pointer just to do that.
    187         if (m_options_ap.get() != NULL)
    188             m_options_ap->GetThreadSpec()->SetQueueName(queue_name);
    189     }
    190     SendBreakpointLocationChangedEvent (eBreakpointEventTypeThreadChanged);
    191 }
    192 
    193 const char *
    194 BreakpointLocation::GetQueueName () const
    195 {
    196     if (GetOptionsNoCreate()->GetThreadSpecNoCreate())
    197         return GetOptionsNoCreate()->GetThreadSpecNoCreate()->GetQueueName();
    198     else
    199         return NULL;
    200 }
    201 
    202 bool
    203 BreakpointLocation::InvokeCallback (StoppointCallbackContext *context)
    204 {
    205     if (m_options_ap.get() != NULL && m_options_ap->HasCallback())
    206         return m_options_ap->InvokeCallback (context, m_owner.GetID(), GetID());
    207     else
    208         return m_owner.InvokeCallback (context, GetID());
    209 }
    210 
    211 void
    212 BreakpointLocation::SetCallback (BreakpointHitCallback callback, void *baton,
    213                  bool is_synchronous)
    214 {
    215     // The default "Baton" class will keep a copy of "baton" and won't free
    216     // or delete it when it goes goes out of scope.
    217     GetLocationOptions()->SetCallback(callback, BatonSP (new Baton(baton)), is_synchronous);
    218     SendBreakpointLocationChangedEvent (eBreakpointEventTypeCommandChanged);
    219 }
    220 
    221 void
    222 BreakpointLocation::SetCallback (BreakpointHitCallback callback, const BatonSP &baton_sp,
    223                  bool is_synchronous)
    224 {
    225     GetLocationOptions()->SetCallback (callback, baton_sp, is_synchronous);
    226     SendBreakpointLocationChangedEvent (eBreakpointEventTypeCommandChanged);
    227 }
    228 
    229 
    230 void
    231 BreakpointLocation::ClearCallback ()
    232 {
    233     GetLocationOptions()->ClearCallback();
    234 }
    235 
    236 void
    237 BreakpointLocation::SetCondition (const char *condition)
    238 {
    239     GetLocationOptions()->SetCondition (condition);
    240     SendBreakpointLocationChangedEvent (eBreakpointEventTypeConditionChanged);
    241 }
    242 
    243 const char *
    244 BreakpointLocation::GetConditionText (size_t *hash) const
    245 {
    246     return GetOptionsNoCreate()->GetConditionText(hash);
    247 }
    248 
    249 bool
    250 BreakpointLocation::ConditionSaysStop (ExecutionContext &exe_ctx, Error &error)
    251 {
    252     Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS);
    253 
    254     Mutex::Locker evaluation_locker(m_condition_mutex);
    255 
    256     size_t condition_hash;
    257     const char *condition_text = GetConditionText(&condition_hash);
    258 
    259     if (!condition_text)
    260     {
    261         m_user_expression_sp.reset();
    262         return false;
    263     }
    264 
    265     if (condition_hash != m_condition_hash ||
    266         !m_user_expression_sp ||
    267         !m_user_expression_sp->MatchesContext(exe_ctx))
    268     {
    269         m_user_expression_sp.reset(new ClangUserExpression(condition_text,
    270                                                            NULL,
    271                                                            lldb::eLanguageTypeUnknown,
    272                                                            ClangUserExpression::eResultTypeAny));
    273 
    274         StreamString errors;
    275 
    276         if (!m_user_expression_sp->Parse(errors,
    277                                          exe_ctx,
    278                                          eExecutionPolicyOnlyWhenNeeded,
    279                                          true))
    280         {
    281             error.SetErrorStringWithFormat("Couldn't parse conditional expression:\n%s",
    282                                            errors.GetData());
    283             m_user_expression_sp.reset();
    284             return false;
    285         }
    286 
    287         m_condition_hash = condition_hash;
    288     }
    289 
    290     // We need to make sure the user sees any parse errors in their condition, so we'll hook the
    291     // constructor errors up to the debugger's Async I/O.
    292 
    293     ValueObjectSP result_value_sp;
    294     const bool unwind_on_error = true;
    295     const bool ignore_breakpoints = true;
    296     const bool try_all_threads = true;
    297 
    298     Error expr_error;
    299 
    300     StreamString execution_errors;
    301 
    302     ClangExpressionVariableSP result_variable_sp;
    303 
    304     ExecutionResults result_code =
    305     m_user_expression_sp->Execute(execution_errors,
    306                                   exe_ctx,
    307                                   unwind_on_error,
    308                                   ignore_breakpoints,
    309                                   m_user_expression_sp,
    310                                   result_variable_sp,
    311                                   try_all_threads,
    312                                   ClangUserExpression::kDefaultTimeout);
    313 
    314     bool ret;
    315 
    316     if (result_code == eExecutionCompleted)
    317     {
    318         if (!result_variable_sp)
    319         {
    320             ret = false;
    321             error.SetErrorString("Expression did not return a result");
    322             return false;
    323         }
    324 
    325         result_value_sp = result_variable_sp->GetValueObject();
    326 
    327         if (result_value_sp)
    328         {
    329             Scalar scalar_value;
    330             if (result_value_sp->ResolveValue (scalar_value))
    331             {
    332                 if (scalar_value.ULongLong(1) == 0)
    333                     ret = false;
    334                 else
    335                     ret = true;
    336                 if (log)
    337                     log->Printf("Condition successfully evaluated, result is %s.\n",
    338                                 ret ? "true" : "false");
    339             }
    340             else
    341             {
    342                 ret = false;
    343                 error.SetErrorString("Failed to get an integer result from the expression");
    344             }
    345         }
    346         else
    347         {
    348             ret = false;
    349             error.SetErrorString("Failed to get any result from the expression");
    350         }
    351     }
    352     else
    353     {
    354         ret = false;
    355         error.SetErrorStringWithFormat("Couldn't execute expression:\n%s", execution_errors.GetData());
    356     }
    357 
    358     return ret;
    359 }
    360 
    361 uint32_t
    362 BreakpointLocation::GetIgnoreCount ()
    363 {
    364     return GetOptionsNoCreate()->GetIgnoreCount();
    365 }
    366 
    367 void
    368 BreakpointLocation::SetIgnoreCount (uint32_t n)
    369 {
    370     GetLocationOptions()->SetIgnoreCount(n);
    371     SendBreakpointLocationChangedEvent (eBreakpointEventTypeIgnoreChanged);
    372 }
    373 
    374 void
    375 BreakpointLocation::DecrementIgnoreCount()
    376 {
    377     if (m_options_ap.get() != NULL)
    378     {
    379         uint32_t loc_ignore = m_options_ap->GetIgnoreCount();
    380         if (loc_ignore != 0)
    381             m_options_ap->SetIgnoreCount(loc_ignore - 1);
    382     }
    383 }
    384 
    385 bool
    386 BreakpointLocation::IgnoreCountShouldStop()
    387 {
    388     if (m_options_ap.get() != NULL)
    389     {
    390         uint32_t loc_ignore = m_options_ap->GetIgnoreCount();
    391         if (loc_ignore != 0)
    392         {
    393             m_owner.DecrementIgnoreCount();
    394             DecrementIgnoreCount();          // Have to decrement our owners' ignore count, since it won't get a
    395                                              // chance to.
    396             return false;
    397         }
    398     }
    399     return true;
    400 }
    401 
    402 const BreakpointOptions *
    403 BreakpointLocation::GetOptionsNoCreate () const
    404 {
    405     if (m_options_ap.get() != NULL)
    406         return m_options_ap.get();
    407     else
    408         return m_owner.GetOptions ();
    409 }
    410 
    411 BreakpointOptions *
    412 BreakpointLocation::GetLocationOptions ()
    413 {
    414     // If we make the copy we don't copy the callbacks because that is potentially
    415     // expensive and we don't want to do that for the simple case where someone is
    416     // just disabling the location.
    417     if (m_options_ap.get() == NULL)
    418         m_options_ap.reset(BreakpointOptions::CopyOptionsNoCallback(*m_owner.GetOptions ()));
    419 
    420     return m_options_ap.get();
    421 }
    422 
    423 bool
    424 BreakpointLocation::ValidForThisThread (Thread *thread)
    425 {
    426     return thread->MatchesSpec(GetOptionsNoCreate()->GetThreadSpecNoCreate());
    427 }
    428 
    429 // RETURNS - true if we should stop at this breakpoint, false if we
    430 // should continue.  Note, we don't check the thread spec for the breakpoint
    431 // here, since if the breakpoint is not for this thread, then the event won't
    432 // even get reported, so the check is redundant.
    433 
    434 bool
    435 BreakpointLocation::ShouldStop (StoppointCallbackContext *context)
    436 {
    437     bool should_stop = true;
    438     Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS);
    439 
    440     IncrementHitCount();
    441 
    442     if (!IsEnabled())
    443         return false;
    444 
    445     if (!IgnoreCountShouldStop())
    446         return false;
    447 
    448     if (!m_owner.IgnoreCountShouldStop())
    449         return false;
    450 
    451     // We only run synchronous callbacks in ShouldStop:
    452     context->is_synchronous = true;
    453     should_stop = InvokeCallback (context);
    454 
    455     if (log)
    456     {
    457         StreamString s;
    458         GetDescription (&s, lldb::eDescriptionLevelVerbose);
    459         log->Printf ("Hit breakpoint location: %s, %s.\n", s.GetData(), should_stop ? "stopping" : "continuing");
    460     }
    461 
    462     return should_stop;
    463 }
    464 
    465 bool
    466 BreakpointLocation::IsResolved () const
    467 {
    468     return m_bp_site_sp.get() != NULL;
    469 }
    470 
    471 lldb::BreakpointSiteSP
    472 BreakpointLocation::GetBreakpointSite() const
    473 {
    474     return m_bp_site_sp;
    475 }
    476 
    477 bool
    478 BreakpointLocation::ResolveBreakpointSite ()
    479 {
    480     if (m_bp_site_sp)
    481         return true;
    482 
    483     Process *process = m_owner.GetTarget().GetProcessSP().get();
    484     if (process == NULL)
    485         return false;
    486 
    487     lldb::break_id_t new_id = process->CreateBreakpointSite (shared_from_this(), false);
    488 
    489     if (new_id == LLDB_INVALID_BREAK_ID)
    490     {
    491         Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS);
    492         if (log)
    493             log->Warning ("Tried to add breakpoint site at 0x%" PRIx64 " but it was already present.\n",
    494                           m_address.GetOpcodeLoadAddress (&m_owner.GetTarget()));
    495         return false;
    496     }
    497 
    498     return true;
    499 }
    500 
    501 bool
    502 BreakpointLocation::SetBreakpointSite (BreakpointSiteSP& bp_site_sp)
    503 {
    504     m_bp_site_sp = bp_site_sp;
    505     return true;
    506 }
    507 
    508 bool
    509 BreakpointLocation::ClearBreakpointSite ()
    510 {
    511     if (m_bp_site_sp.get())
    512     {
    513         m_owner.GetTarget().GetProcessSP()->RemoveOwnerFromBreakpointSite (GetBreakpoint().GetID(),
    514                                                                            GetID(), m_bp_site_sp);
    515         m_bp_site_sp.reset();
    516         return true;
    517     }
    518     return false;
    519 }
    520 
    521 void
    522 BreakpointLocation::GetDescription (Stream *s, lldb::DescriptionLevel level)
    523 {
    524     SymbolContext sc;
    525 
    526     // If the description level is "initial" then the breakpoint is printing out our initial state,
    527     // and we should let it decide how it wants to print our label.
    528     if (level != eDescriptionLevelInitial)
    529     {
    530         s->Indent();
    531         BreakpointID::GetCanonicalReference(s, m_owner.GetID(), GetID());
    532     }
    533 
    534     if (level == lldb::eDescriptionLevelBrief)
    535         return;
    536 
    537     if (level != eDescriptionLevelInitial)
    538         s->PutCString(": ");
    539 
    540     if (level == lldb::eDescriptionLevelVerbose)
    541         s->IndentMore();
    542 
    543     if (m_address.IsSectionOffset())
    544     {
    545         m_address.CalculateSymbolContext(&sc);
    546 
    547         if (level == lldb::eDescriptionLevelFull || level == eDescriptionLevelInitial)
    548         {
    549             s->PutCString("where = ");
    550             sc.DumpStopContext (s, m_owner.GetTarget().GetProcessSP().get(), m_address, false, true, false);
    551         }
    552         else
    553         {
    554             if (sc.module_sp)
    555             {
    556                 s->EOL();
    557                 s->Indent("module = ");
    558                 sc.module_sp->GetFileSpec().Dump (s);
    559             }
    560 
    561             if (sc.comp_unit != NULL)
    562             {
    563                 s->EOL();
    564                 s->Indent("compile unit = ");
    565                 static_cast<FileSpec*>(sc.comp_unit)->GetFilename().Dump (s);
    566 
    567                 if (sc.function != NULL)
    568                 {
    569                     s->EOL();
    570                     s->Indent("function = ");
    571                     s->PutCString (sc.function->GetMangled().GetName().AsCString("<unknown>"));
    572                 }
    573 
    574                 if (sc.line_entry.line > 0)
    575                 {
    576                     s->EOL();
    577                     s->Indent("location = ");
    578                     sc.line_entry.DumpStopContext (s, true);
    579                 }
    580 
    581             }
    582             else
    583             {
    584                 // If we don't have a comp unit, see if we have a symbol we can print.
    585                 if (sc.symbol)
    586                 {
    587                     s->EOL();
    588                     s->Indent("symbol = ");
    589                     s->PutCString(sc.symbol->GetMangled().GetName().AsCString("<unknown>"));
    590                 }
    591             }
    592         }
    593     }
    594 
    595     if (level == lldb::eDescriptionLevelVerbose)
    596     {
    597         s->EOL();
    598         s->Indent();
    599     }
    600 
    601     if (m_address.IsSectionOffset() && (level == eDescriptionLevelFull || level == eDescriptionLevelInitial))
    602         s->Printf (", ");
    603     s->Printf ("address = ");
    604 
    605     ExecutionContextScope *exe_scope = NULL;
    606     Target *target = &m_owner.GetTarget();
    607     if (target)
    608         exe_scope = target->GetProcessSP().get();
    609     if (exe_scope == NULL)
    610         exe_scope = target;
    611 
    612     if (eDescriptionLevelInitial)
    613         m_address.Dump(s, exe_scope, Address::DumpStyleLoadAddress, Address::DumpStyleFileAddress);
    614     else
    615         m_address.Dump(s, exe_scope, Address::DumpStyleLoadAddress, Address::DumpStyleModuleWithFileAddress);
    616 
    617     if (level == lldb::eDescriptionLevelVerbose)
    618     {
    619         s->EOL();
    620         s->Indent();
    621         s->Printf("resolved = %s\n", IsResolved() ? "true" : "false");
    622 
    623         s->Indent();
    624         s->Printf ("hit count = %-4u\n", GetHitCount());
    625 
    626         if (m_options_ap.get())
    627         {
    628             s->Indent();
    629             m_options_ap->GetDescription (s, level);
    630             s->EOL();
    631         }
    632         s->IndentLess();
    633     }
    634     else if (level != eDescriptionLevelInitial)
    635     {
    636         s->Printf(", %sresolved, hit count = %u ",
    637                   (IsResolved() ? "" : "un"),
    638                   GetHitCount());
    639         if (m_options_ap.get())
    640         {
    641             m_options_ap->GetDescription (s, level);
    642         }
    643     }
    644 }
    645 
    646 void
    647 BreakpointLocation::Dump(Stream *s) const
    648 {
    649     if (s == NULL)
    650         return;
    651 
    652     s->Printf("BreakpointLocation %u: tid = %4.4" PRIx64 "  load addr = 0x%8.8" PRIx64 "  state = %s  type = %s breakpoint  "
    653               "hw_index = %i  hit_count = %-4u  ignore_count = %-4u",
    654               GetID(),
    655               GetOptionsNoCreate()->GetThreadSpecNoCreate()->GetTID(),
    656               (uint64_t) m_address.GetOpcodeLoadAddress (&m_owner.GetTarget()),
    657               (m_options_ap.get() ? m_options_ap->IsEnabled() : m_owner.IsEnabled()) ? "enabled " : "disabled",
    658               IsHardware() ? "hardware" : "software",
    659               GetHardwareIndex(),
    660               GetHitCount(),
    661               GetOptionsNoCreate()->GetIgnoreCount());
    662 }
    663 
    664 void
    665 BreakpointLocation::SendBreakpointLocationChangedEvent (lldb::BreakpointEventType eventKind)
    666 {
    667     if (!m_being_created
    668         && !m_owner.IsInternal()
    669         && m_owner.GetTarget().EventTypeHasListeners(Target::eBroadcastBitBreakpointChanged))
    670     {
    671         Breakpoint::BreakpointEventData *data = new Breakpoint::BreakpointEventData (eventKind,
    672                                                                                      m_owner.shared_from_this());
    673         data->GetBreakpointLocationCollection().Add (shared_from_this());
    674         m_owner.GetTarget().BroadcastEvent (Target::eBroadcastBitBreakpointChanged, data);
    675     }
    676 }
    677 
    678