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