lldb/source/Target/ThreadPlanShouldStopHere.cpp

   1 //===-- ThreadPlanShouldStopHere.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/ThreadPlanShouldStopHere.h"
  10 #include "lldb/Symbol/Symbol.h"
  11 #include "lldb/Target/RegisterContext.h"
  12 #include "lldb/Target/Thread.h"
  13 #include "lldb/Utility/Log.h"
  14
  15 using namespace lldb;
  16 using namespace lldb_private;
  17
  18 // ThreadPlanShouldStopHere constructor
  19 ThreadPlanShouldStopHere::ThreadPlanShouldStopHere(ThreadPlan *owner)
  20     : m_callbacks(), m_baton(nullptr), m_owner(owner),
  21       m_flags(ThreadPlanShouldStopHere::eNone) {
  22   m_callbacks.should_stop_here_callback =
  23       ThreadPlanShouldStopHere::DefaultShouldStopHereCallback;
  24   m_callbacks.step_from_here_callback =
  25       ThreadPlanShouldStopHere::DefaultStepFromHereCallback;
  26 }
  27
  28 ThreadPlanShouldStopHere::ThreadPlanShouldStopHere(
  29     ThreadPlan *owner, const ThreadPlanShouldStopHereCallbacks *callbacks,
  30     void *baton)
  31     : m_callbacks(), m_baton(), m_owner(owner),
  32       m_flags(ThreadPlanShouldStopHere::eNone) {
  33   SetShouldStopHereCallbacks(callbacks, baton);
  34 }
  35
  36 ThreadPlanShouldStopHere::~ThreadPlanShouldStopHere() = default;
  37
  38 bool ThreadPlanShouldStopHere::InvokeShouldStopHereCallback(
  39     FrameComparison operation, Status &status) {
  40   bool should_stop_here = true;
  41   if (m_callbacks.should_stop_here_callback) {
  42     should_stop_here = m_callbacks.should_stop_here_callback(
  43         m_owner, m_flags, operation, status, m_baton);
  44     Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
  45     if (log) {
  46       lldb::addr_t current_addr =
  47           m_owner->GetThread().GetRegisterContext()->GetPC(0);
  48
  49       LLDB_LOGF(log, "ShouldStopHere callback returned %u from 0x%" PRIx64 ".",
  50                 should_stop_here, current_addr);
  51     }
  52   }
  53
  54   return should_stop_here;
  55 }
  56
  57 bool ThreadPlanShouldStopHere::DefaultShouldStopHereCallback(
  58     ThreadPlan *current_plan, Flags &flags, FrameComparison operation,
  59     Status &status, void *baton) {
  60   bool should_stop_here = true;
  61   StackFrame *frame = current_plan->GetThread().GetStackFrameAtIndex(0).get();
  62   if (!frame)
  63     return true;
  64
  65   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
  66
  67   if ((operation == eFrameCompareOlder && flags.Test(eStepOutAvoidNoDebug)) ||
  68       (operation == eFrameCompareYounger && flags.Test(eStepInAvoidNoDebug)) ||
  69       (operation == eFrameCompareSameParent &&
  70        flags.Test(eStepInAvoidNoDebug))) {
  71     if (!frame->HasDebugInformation()) {
  72       LLDB_LOGF(log, "Stepping out of frame with no debug info");
  73
  74       should_stop_here = false;
  75     }
  76   }
  77
  78   // Always avoid code with line number 0.
  79   // FIXME: At present the ShouldStop and the StepFromHere calculate this
  80   // independently.  If this ever
  81   // becomes expensive (this one isn't) we can try to have this set a state
  82   // that the StepFromHere can use.
  83   if (frame) {
  84     SymbolContext sc;
  85     sc = frame->GetSymbolContext(eSymbolContextLineEntry);
  86     if (sc.line_entry.line == 0)
  87       should_stop_here = false;
  88   }
  89
  90   return should_stop_here;
  91 }
  92
  93 ThreadPlanSP ThreadPlanShouldStopHere::DefaultStepFromHereCallback(
  94     ThreadPlan *current_plan, Flags &flags, FrameComparison operation,
  95     Status &status, void *baton) {
  96   const bool stop_others = false;
  97   const size_t frame_index = 0;
  98   ThreadPlanSP return_plan_sp;
  99   // If we are stepping through code at line number 0, then we need to step
 100   // over this range.  Otherwise we will step out.
 101   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
 102
 103   StackFrame *frame = current_plan->GetThread().GetStackFrameAtIndex(0).get();
 104   if (!frame)
 105     return return_plan_sp;
 106   SymbolContext sc;
 107   sc = frame->GetSymbolContext(eSymbolContextLineEntry | eSymbolContextSymbol);
 108
 109   if (sc.line_entry.line == 0) {
 110     AddressRange range = sc.line_entry.range;
 111
 112     // If the whole function is marked line 0 just step out, that's easier &
 113     // faster than continuing to step through it.
 114     bool just_step_out = false;
 115     if (sc.symbol && sc.symbol->ValueIsAddress()) {
 116       Address symbol_end = sc.symbol->GetAddress();
 117       symbol_end.Slide(sc.symbol->GetByteSize() - 1);
 118       if (range.ContainsFileAddress(sc.symbol->GetAddress()) &&
 119           range.ContainsFileAddress(symbol_end)) {
 120         LLDB_LOGF(log, "Stopped in a function with only line 0 lines, just "
 121                        "stepping out.");
 122         just_step_out = true;
 123       }
 124     }
 125     if (!just_step_out) {
 126       LLDB_LOGF(log, "ThreadPlanShouldStopHere::DefaultStepFromHereCallback "
 127                      "Queueing StepInRange plan to step through line 0 code.");
 128
 129       return_plan_sp = current_plan->GetThread().QueueThreadPlanForStepInRange(
 130           false, range, sc, nullptr, eOnlyDuringStepping, status,
 131           eLazyBoolCalculate, eLazyBoolNo);
 132     }
 133   }
 134
 135   if (!return_plan_sp)
 136     return_plan_sp =
 137         current_plan->GetThread().QueueThreadPlanForStepOutNoShouldStop(
 138             false, nullptr, true, stop_others, eVoteNo, eVoteNoOpinion,
 139             frame_index, status, true);
 140   return return_plan_sp;
 141 }
 142
 143 ThreadPlanSP ThreadPlanShouldStopHere::QueueStepOutFromHerePlan(
 144     lldb_private::Flags &flags, lldb::FrameComparison operation,
 145     Status &status) {
 146   ThreadPlanSP return_plan_sp;
 147   if (m_callbacks.step_from_here_callback) {
 148     return_plan_sp = m_callbacks.step_from_here_callback(
 149         m_owner, flags, operation, status, m_baton);
 150   }
 151   return return_plan_sp;
 152 }
 153
 154 lldb::ThreadPlanSP ThreadPlanShouldStopHere::CheckShouldStopHereAndQueueStepOut(
 155     lldb::FrameComparison operation, Status &status) {
 156   if (!InvokeShouldStopHereCallback(operation, status))
 157     return QueueStepOutFromHerePlan(m_flags, operation, status);
 158   else
 159     return ThreadPlanSP();
 160 }