lldb/source/Target/ThreadPlanStepRange.cpp

   1 //===-- ThreadPlanStepRange.cpp -------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "lldb/Target/ThreadPlanStepRange.h"
  10 #include "lldb/Breakpoint/BreakpointLocation.h"
  11 #include "lldb/Breakpoint/BreakpointSite.h"
  12 #include "lldb/Core/Disassembler.h"
  13 #include "lldb/Symbol/Function.h"
  14 #include "lldb/Symbol/Symbol.h"
  15 #include "lldb/Target/ExecutionContext.h"
  16 #include "lldb/Target/Process.h"
  17 #include "lldb/Target/RegisterContext.h"
  18 #include "lldb/Target/StopInfo.h"
  19 #include "lldb/Target/Target.h"
  20 #include "lldb/Target/Thread.h"
  21 #include "lldb/Target/ThreadPlanRunToAddress.h"
  22 #include "lldb/Utility/Log.h"
  23 #include "lldb/Utility/Stream.h"
  24
  25 using namespace lldb;
  26 using namespace lldb_private;
  27
  28 // ThreadPlanStepRange: Step through a stack range, either stepping over or
  29 // into based on the value of \a type.
  30
  31 ThreadPlanStepRange::ThreadPlanStepRange(ThreadPlanKind kind, const char *name,
  32                                          Thread &thread,
  33                                          const AddressRange &range,
  34                                          const SymbolContext &addr_context,
  35                                          lldb::RunMode stop_others,
  36                                          bool given_ranges_only)
  37     : ThreadPlan(kind, name, thread, eVoteNoOpinion, eVoteNoOpinion),
  38       m_addr_context(addr_context), m_address_ranges(),
  39       m_stop_others(stop_others), m_stack_id(), m_parent_stack_id(),
  40       m_no_more_plans(false), m_first_run_event(true), m_use_fast_step(false),
  41       m_given_ranges_only(given_ranges_only) {
  42   m_use_fast_step = GetTarget().GetUseFastStepping();
  43   AddRange(range);
  44   m_stack_id = thread.GetStackFrameAtIndex(0)->GetStackID();
  45   StackFrameSP parent_stack = thread.GetStackFrameAtIndex(1);
  46   if (parent_stack)
  47     m_parent_stack_id = parent_stack->GetStackID();
  48 }
  49
  50 ThreadPlanStepRange::~ThreadPlanStepRange() { ClearNextBranchBreakpoint(); }
  51
  52 void ThreadPlanStepRange::DidPush() {
  53   // See if we can find a "next range" breakpoint:
  54   SetNextBranchBreakpoint();
  55 }
  56
  57 bool ThreadPlanStepRange::ValidatePlan(Stream *error) {
  58   if (m_could_not_resolve_hw_bp) {
  59     if (error)
  60       error->PutCString(
  61           "Could not create hardware breakpoint for thread plan.");
  62     return false;
  63   }
  64   return true;
  65 }
  66
  67 Vote ThreadPlanStepRange::ShouldReportStop(Event *event_ptr) {
  68   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
  69
  70   const Vote vote = IsPlanComplete() ? eVoteYes : eVoteNo;
  71   LLDB_LOGF(log, "ThreadPlanStepRange::ShouldReportStop() returning vote %i\n",
  72             vote);
  73   return vote;
  74 }
  75
  76 void ThreadPlanStepRange::AddRange(const AddressRange &new_range) {
  77   // For now I'm just adding the ranges.  At some point we may want to condense
  78   // the ranges if they overlap, though I don't think it is likely to be very
  79   // important.
  80   m_address_ranges.push_back(new_range);
  81
  82   // Fill the slot for this address range with an empty DisassemblerSP in the
  83   // instruction ranges. I want the indices to match, but I don't want to do
  84   // the work to disassemble this range if I don't step into it.
  85   m_instruction_ranges.push_back(DisassemblerSP());
  86 }
  87
  88 void ThreadPlanStepRange::DumpRanges(Stream *s) {
  89   size_t num_ranges = m_address_ranges.size();
  90   if (num_ranges == 1) {
  91     m_address_ranges[0].Dump(s, &GetTarget(), Address::DumpStyleLoadAddress);
  92   } else {
  93     for (size_t i = 0; i < num_ranges; i++) {
  94       s->Printf(" %" PRIu64 ": ", uint64_t(i));
  95       m_address_ranges[i].Dump(s, &GetTarget(), Address::DumpStyleLoadAddress);
  96     }
  97   }
  98 }
  99
 100 bool ThreadPlanStepRange::InRange() {
 101   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
 102   bool ret_value = false;
 103   Thread &thread = GetThread();
 104   lldb::addr_t pc_load_addr = thread.GetRegisterContext()->GetPC();
 105
 106   size_t num_ranges = m_address_ranges.size();
 107   for (size_t i = 0; i < num_ranges; i++) {
 108     ret_value =
 109         m_address_ranges[i].ContainsLoadAddress(pc_load_addr, &GetTarget());
 110     if (ret_value)
 111       break;
 112   }
 113
 114   if (!ret_value && !m_given_ranges_only) {
 115     // See if we've just stepped to another part of the same line number...
 116     StackFrame *frame = thread.GetStackFrameAtIndex(0).get();
 117
 118     SymbolContext new_context(
 119         frame->GetSymbolContext(eSymbolContextEverything));
 120     if (m_addr_context.line_entry.IsValid() &&
 121         new_context.line_entry.IsValid()) {
 122       if (m_addr_context.line_entry.original_file ==
 123           new_context.line_entry.original_file) {
 124         if (m_addr_context.line_entry.line == new_context.line_entry.line) {
 125           m_addr_context = new_context;
 126           const bool include_inlined_functions =
 127               GetKind() == eKindStepOverRange;
 128           AddRange(m_addr_context.line_entry.GetSameLineContiguousAddressRange(
 129               include_inlined_functions));
 130           ret_value = true;
 131           if (log) {
 132             StreamString s;
 133             m_addr_context.line_entry.Dump(&s, &GetTarget(), true,
 134                                            Address::DumpStyleLoadAddress,
 135                                            Address::DumpStyleLoadAddress, true);
 136
 137             LLDB_LOGF(
 138                 log,
 139                 "Step range plan stepped to another range of same line: %s",
 140                 s.GetData());
 141           }
 142         } else if (new_context.line_entry.line == 0) {
 143           new_context.line_entry.line = m_addr_context.line_entry.line;
 144           m_addr_context = new_context;
 145           const bool include_inlined_functions =
 146               GetKind() == eKindStepOverRange;
 147           AddRange(m_addr_context.line_entry.GetSameLineContiguousAddressRange(
 148               include_inlined_functions));
 149           ret_value = true;
 150           if (log) {
 151             StreamString s;
 152             m_addr_context.line_entry.Dump(&s, &GetTarget(), true,
 153                                            Address::DumpStyleLoadAddress,
 154                                            Address::DumpStyleLoadAddress, true);
 155
 156             LLDB_LOGF(log,
 157                       "Step range plan stepped to a range at linenumber 0 "
 158                       "stepping through that range: %s",
 159                       s.GetData());
 160           }
 161         } else if (new_context.line_entry.range.GetBaseAddress().GetLoadAddress(
 162                        &GetTarget()) != pc_load_addr) {
 163           // Another thing that sometimes happens here is that we step out of
 164           // one line into the MIDDLE of another line.  So far I mostly see
 165           // this due to bugs in the debug information. But we probably don't
 166           // want to be in the middle of a line range, so in that case reset
 167           // the stepping range to the line we've stepped into the middle of
 168           // and continue.
 169           m_addr_context = new_context;
 170           m_address_ranges.clear();
 171           AddRange(m_addr_context.line_entry.range);
 172           ret_value = true;
 173           if (log) {
 174             StreamString s;
 175             m_addr_context.line_entry.Dump(&s, &GetTarget(), true,
 176                                            Address::DumpStyleLoadAddress,
 177                                            Address::DumpStyleLoadAddress, true);
 178
 179             LLDB_LOGF(log,
 180                       "Step range plan stepped to the middle of new "
 181                       "line(%d): %s, continuing to clear this line.",
 182                       new_context.line_entry.line, s.GetData());
 183           }
 184         }
 185       }
 186     }
 187   }
 188
 189   if (!ret_value && log)
 190     LLDB_LOGF(log, "Step range plan out of range to 0x%" PRIx64, pc_load_addr);
 191
 192   return ret_value;
 193 }
 194
 195 bool ThreadPlanStepRange::InSymbol() {
 196   lldb::addr_t cur_pc = GetThread().GetRegisterContext()->GetPC();
 197   if (m_addr_context.function != nullptr) {
 198     return m_addr_context.function->GetAddressRange().ContainsLoadAddress(
 199         cur_pc, &GetTarget());
 200   } else if (m_addr_context.symbol && m_addr_context.symbol->ValueIsAddress()) {
 201     AddressRange range(m_addr_context.symbol->GetAddressRef(),
 202                        m_addr_context.symbol->GetByteSize());
 203     return range.ContainsLoadAddress(cur_pc, &GetTarget());
 204   }
 205   return false;
 206 }
 207
 208 // FIXME: This should also handle inlining if we aren't going to do inlining in
 209 // the
 210 // main stack.
 211 //
 212 // Ideally we should remember the whole stack frame list, and then compare that
 213 // to the current list.
 214
 215 lldb::FrameComparison ThreadPlanStepRange::CompareCurrentFrameToStartFrame() {
 216   FrameComparison frame_order;
 217   Thread &thread = GetThread();
 218   StackID cur_frame_id = thread.GetStackFrameAtIndex(0)->GetStackID();
 219
 220   if (cur_frame_id == m_stack_id) {
 221     frame_order = eFrameCompareEqual;
 222   } else if (cur_frame_id < m_stack_id) {
 223     frame_order = eFrameCompareYounger;
 224   } else {
 225     StackFrameSP cur_parent_frame = thread.GetStackFrameAtIndex(1);
 226     StackID cur_parent_id;
 227     if (cur_parent_frame)
 228       cur_parent_id = cur_parent_frame->GetStackID();
 229     if (m_parent_stack_id.IsValid() && cur_parent_id.IsValid() &&
 230         m_parent_stack_id == cur_parent_id)
 231       frame_order = eFrameCompareSameParent;
 232     else
 233       frame_order = eFrameCompareOlder;
 234   }
 235   return frame_order;
 236 }
 237
 238 bool ThreadPlanStepRange::StopOthers() {
 239   switch (m_stop_others) {
 240   case lldb::eOnlyThisThread:
 241     return true;
 242   case lldb::eOnlyDuringStepping:
 243     // If there is a call in the range of the next branch breakpoint,
 244     // then we should always run all threads, since a call can execute
 245     // arbitrary code which might for instance take a lock that's held
 246     // by another thread.
 247     return !m_found_calls;
 248   case lldb::eAllThreads:
 249     return false;
 250   }
 251   llvm_unreachable("Unhandled run mode!");
 252 }
 253
 254 InstructionList *ThreadPlanStepRange::GetInstructionsForAddress(
 255     lldb::addr_t addr, size_t &range_index, size_t &insn_offset) {
 256   size_t num_ranges = m_address_ranges.size();
 257   for (size_t i = 0; i < num_ranges; i++) {
 258     if (m_address_ranges[i].ContainsLoadAddress(addr, &GetTarget())) {
 259       // Some joker added a zero size range to the stepping range...
 260       if (m_address_ranges[i].GetByteSize() == 0)
 261         return nullptr;
 262
 263       if (!m_instruction_ranges[i]) {
 264         // Disassemble the address range given:
 265         const char *plugin_name = nullptr;
 266         const char *flavor = nullptr;
 267         m_instruction_ranges[i] = Disassembler::DisassembleRange(
 268             GetTarget().GetArchitecture(), plugin_name, flavor, GetTarget(),
 269             m_address_ranges[i]);
 270       }
 271       if (!m_instruction_ranges[i])
 272         return nullptr;
 273       else {
 274         // Find where we are in the instruction list as well.  If we aren't at
 275         // an instruction, return nullptr. In this case, we're probably lost,
 276         // and shouldn't try to do anything fancy.
 277
 278         insn_offset =
 279             m_instruction_ranges[i]
 280                 ->GetInstructionList()
 281                 .GetIndexOfInstructionAtLoadAddress(addr, GetTarget());
 282         if (insn_offset == UINT32_MAX)
 283           return nullptr;
 284         else {
 285           range_index = i;
 286           return &m_instruction_ranges[i]->GetInstructionList();
 287         }
 288       }
 289     }
 290   }
 291   return nullptr;
 292 }
 293
 294 void ThreadPlanStepRange::ClearNextBranchBreakpoint() {
 295   if (m_next_branch_bp_sp) {
 296     Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
 297     LLDB_LOGF(log, "Removing next branch breakpoint: %d.",
 298               m_next_branch_bp_sp->GetID());
 299     GetTarget().RemoveBreakpointByID(m_next_branch_bp_sp->GetID());
 300     m_next_branch_bp_sp.reset();
 301     m_could_not_resolve_hw_bp = false;
 302     m_found_calls = false;
 303   }
 304 }
 305
 306 bool ThreadPlanStepRange::SetNextBranchBreakpoint() {
 307   if (m_next_branch_bp_sp)
 308     return true;
 309
 310   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
 311   // Stepping through ranges using breakpoints doesn't work yet, but with this
 312   // off we fall back to instruction single stepping.
 313   if (!m_use_fast_step)
 314     return false;
 315
 316   // clear the m_found_calls, we'll rediscover it for this range.
 317   m_found_calls = false;
 318
 319   lldb::addr_t cur_addr = GetThread().GetRegisterContext()->GetPC();
 320   // Find the current address in our address ranges, and fetch the disassembly
 321   // if we haven't already:
 322   size_t pc_index;
 323   size_t range_index;
 324   InstructionList *instructions =
 325       GetInstructionsForAddress(cur_addr, range_index, pc_index);
 326   if (instructions == nullptr)
 327     return false;
 328   else {
 329     const bool ignore_calls = GetKind() == eKindStepOverRange;
 330     uint32_t branch_index = instructions->GetIndexOfNextBranchInstruction(
 331         pc_index, ignore_calls, &m_found_calls);
 332     Address run_to_address;
 333
 334     // If we didn't find a branch, run to the end of the range.
 335     if (branch_index == UINT32_MAX) {
 336       uint32_t last_index = instructions->GetSize() - 1;
 337       if (last_index - pc_index > 1) {
 338         InstructionSP last_inst =
 339             instructions->GetInstructionAtIndex(last_index);
 340         size_t last_inst_size = last_inst->GetOpcode().GetByteSize();
 341         run_to_address = last_inst->GetAddress();
 342         run_to_address.Slide(last_inst_size);
 343       }
 344     } else if (branch_index - pc_index > 1) {
 345       run_to_address =
 346           instructions->GetInstructionAtIndex(branch_index)->GetAddress();
 347     }
 348
 349     if (run_to_address.IsValid()) {
 350       const bool is_internal = true;
 351       m_next_branch_bp_sp =
 352           GetTarget().CreateBreakpoint(run_to_address, is_internal, false);
 353       if (m_next_branch_bp_sp) {
 354
 355         if (m_next_branch_bp_sp->IsHardware() &&
 356             !m_next_branch_bp_sp->HasResolvedLocations())
 357           m_could_not_resolve_hw_bp = true;
 358
 359         if (log) {
 360           lldb::break_id_t bp_site_id = LLDB_INVALID_BREAK_ID;
 361           BreakpointLocationSP bp_loc =
 362               m_next_branch_bp_sp->GetLocationAtIndex(0);
 363           if (bp_loc) {
 364             BreakpointSiteSP bp_site = bp_loc->GetBreakpointSite();
 365             if (bp_site) {
 366               bp_site_id = bp_site->GetID();
 367             }
 368           }
 369           LLDB_LOGF(log,
 370                     "ThreadPlanStepRange::SetNextBranchBreakpoint - Setting "
 371                     "breakpoint %d (site %d) to run to address 0x%" PRIx64,
 372                     m_next_branch_bp_sp->GetID(), bp_site_id,
 373                     run_to_address.GetLoadAddress(&m_process.GetTarget()));
 374         }
 375
 376         m_next_branch_bp_sp->SetThreadID(m_tid);
 377         m_next_branch_bp_sp->SetBreakpointKind("next-branch-location");
 378
 379         return true;
 380       } else
 381         return false;
 382     }
 383   }
 384   return false;
 385 }
 386
 387 bool ThreadPlanStepRange::NextRangeBreakpointExplainsStop(
 388     lldb::StopInfoSP stop_info_sp) {
 389   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
 390   if (!m_next_branch_bp_sp)
 391     return false;
 392
 393   break_id_t bp_site_id = stop_info_sp->GetValue();
 394   BreakpointSiteSP bp_site_sp =
 395       m_process.GetBreakpointSiteList().FindByID(bp_site_id);
 396   if (!bp_site_sp)
 397     return false;
 398   else if (!bp_site_sp->IsBreakpointAtThisSite(m_next_branch_bp_sp->GetID()))
 399     return false;
 400   else {
 401     // If we've hit the next branch breakpoint, then clear it.
 402     size_t num_owners = bp_site_sp->GetNumberOfOwners();
 403     bool explains_stop = true;
 404     // If all the owners are internal, then we are probably just stepping over
 405     // this range from multiple threads, or multiple frames, so we want to
 406     // continue.  If one is not internal, then we should not explain the stop,
 407     // and let the user breakpoint handle the stop.
 408     for (size_t i = 0; i < num_owners; i++) {
 409       if (!bp_site_sp->GetOwnerAtIndex(i)->GetBreakpoint().IsInternal()) {
 410         explains_stop = false;
 411         break;
 412       }
 413     }
 414     LLDB_LOGF(log,
 415               "ThreadPlanStepRange::NextRangeBreakpointExplainsStop - Hit "
 416               "next range breakpoint which has %" PRIu64
 417               " owners - explains stop: %u.",
 418               (uint64_t)num_owners, explains_stop);
 419     ClearNextBranchBreakpoint();
 420     return explains_stop;
 421   }
 422 }
 423
 424 bool ThreadPlanStepRange::WillStop() { return true; }
 425
 426 StateType ThreadPlanStepRange::GetPlanRunState() {
 427   if (m_next_branch_bp_sp)
 428     return eStateRunning;
 429   else
 430     return eStateStepping;
 431 }
 432
 433 bool ThreadPlanStepRange::MischiefManaged() {
 434   // If we have pushed some plans between ShouldStop & MischiefManaged, then
 435   // we're not done...
 436   // I do this check first because we might have stepped somewhere that will
 437   // fool InRange into
 438   // thinking it needs to step past the end of that line.  This happens, for
 439   // instance, when stepping over inlined code that is in the middle of the
 440   // current line.
 441
 442   if (!m_no_more_plans)
 443     return false;
 444
 445   bool done = true;
 446   if (!IsPlanComplete()) {
 447     if (InRange()) {
 448       done = false;
 449     } else {
 450       FrameComparison frame_order = CompareCurrentFrameToStartFrame();
 451       done = (frame_order != eFrameCompareOlder) ? m_no_more_plans : true;
 452     }
 453   }
 454
 455   if (done) {
 456     Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
 457     LLDB_LOGF(log, "Completed step through range plan.");
 458     ClearNextBranchBreakpoint();
 459     ThreadPlan::MischiefManaged();
 460     return true;
 461   } else {
 462     return false;
 463   }
 464 }
 465
 466 bool ThreadPlanStepRange::IsPlanStale() {
 467   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
 468   FrameComparison frame_order = CompareCurrentFrameToStartFrame();
 469
 470   if (frame_order == eFrameCompareOlder) {
 471     if (log) {
 472       LLDB_LOGF(log, "ThreadPlanStepRange::IsPlanStale returning true, we've "
 473                      "stepped out.");
 474     }
 475     return true;
 476   } else if (frame_order == eFrameCompareEqual && InSymbol()) {
 477     // If we are not in a place we should step through, we've gotten stale. One
 478     // tricky bit here is that some stubs don't push a frame, so we should.
 479     // check that we are in the same symbol.
 480     if (!InRange()) {
 481       // Set plan Complete when we reach next instruction just after the range
 482       lldb::addr_t addr = GetThread().GetRegisterContext()->GetPC() - 1;
 483       size_t num_ranges = m_address_ranges.size();
 484       for (size_t i = 0; i < num_ranges; i++) {
 485         bool in_range =
 486             m_address_ranges[i].ContainsLoadAddress(addr, &GetTarget());
 487         if (in_range) {
 488           SetPlanComplete();
 489         }
 490       }
 491       return true;
 492     }
 493   }
 494   return false;
 495 }