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

   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