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