File Manager

003 File Manager

Current Path: /usr/src/contrib/llvm-project/lldb/source/Target

usr / src / contrib / llvm-project / lldb / source / Target /

📁 ..
📄 ABI.cpp(9.36 KB)
📄 AssertFrameRecognizer.cpp(5.4 KB)
📄 ExecutionContext.cpp(18.19 KB)
📄 InstrumentationRuntime.cpp(2.38 KB)
📄 InstrumentationRuntimeStopInfo.cpp(1.2 KB)
📄 JITLoader.cpp(1.07 KB)
📄 JITLoaderList.cpp(1.94 KB)
📄 Language.cpp(12.97 KB)
📄 LanguageRuntime.cpp(9.71 KB)
📄 Memory.cpp(15.12 KB)
📄 MemoryHistory.cpp(943 B)
📄 MemoryRegionInfo.cpp(1.55 KB)
📄 ModuleCache.cpp(11.87 KB)
📄 OperatingSystem.cpp(1.74 KB)
📄 PathMappingList.cpp(9.73 KB)
📄 Platform.cpp(66.82 KB)
📄 Process.cpp(221.69 KB)
📄 Queue.cpp(2.52 KB)
📄 QueueItem.cpp(3 KB)
📄 QueueList.cpp(1.68 KB)
📄 RegisterContext.cpp(15.76 KB)
📄 RegisterContextUnwind.cpp(86.86 KB)
📄 RegisterNumber.cpp(3.34 KB)
📄 RemoteAwarePlatform.cpp(16.06 KB)
📄 SectionLoadHistory.cpp(6.39 KB)
📄 SectionLoadList.cpp(9.57 KB)
📄 StackFrame.cpp(70.8 KB)
📄 StackFrameList.cpp(34.82 KB)
📄 StackFrameRecognizer.cpp(7.27 KB)
📄 StackID.cpp(3.39 KB)
📄 StopInfo.cpp(44.17 KB)
📄 StructuredDataPlugin.cpp(2.35 KB)
📄 SystemRuntime.cpp(1.54 KB)
📄 Target.cpp(146.79 KB)
📄 TargetList.cpp(22.59 KB)
📄 TargetProperties.td(15.71 KB)
📄 Thread.cpp(70.22 KB)
📄 ThreadCollection.cpp(2.18 KB)
📄 ThreadList.cpp(24.9 KB)
📄 ThreadPlan.cpp(9.54 KB)
📄 ThreadPlanBase.cpp(6.32 KB)
📄 ThreadPlanCallFunction.cpp(16.54 KB)
📄 ThreadPlanCallFunctionUsingABI.cpp(2.35 KB)
📄 ThreadPlanCallOnFunctionExit.cpp(3.3 KB)
📄 ThreadPlanCallUserExpression.cpp(3.77 KB)
📄 ThreadPlanPython.cpp(5.94 KB)
📄 ThreadPlanRunToAddress.cpp(6.53 KB)
📄 ThreadPlanShouldStopHere.cpp(5.82 KB)
📄 ThreadPlanStack.cpp(14.76 KB)
📄 ThreadPlanStepInRange.cpp(18.45 KB)
📄 ThreadPlanStepInstruction.cpp(8.78 KB)
📄 ThreadPlanStepOut.cpp(18.25 KB)
📄 ThreadPlanStepOverBreakpoint.cpp(6.63 KB)
📄 ThreadPlanStepOverRange.cpp(16.61 KB)
📄 ThreadPlanStepRange.cpp(18.23 KB)
📄 ThreadPlanStepThrough.cpp(8.79 KB)
📄 ThreadPlanStepUntil.cpp(11.14 KB)
📄 ThreadPlanTracer.cpp(7.78 KB)
📄 ThreadSpec.cpp(4.46 KB)
📄 UnixSignals.cpp(11.04 KB)
📄 UnwindAssembly.cpp(1.09 KB)
📄 UnwindLLDB.cpp(19.02 KB)

Editing: ThreadPlanStepOverBreakpoint.cpp

//===-- ThreadPlanStepOverBreakpoint.cpp ----------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#include "lldb/Target/ThreadPlanStepOverBreakpoint.h"

#include "lldb/Target/Process.h"
#include "lldb/Target/RegisterContext.h"
#include "lldb/Utility/Log.h"
#include "lldb/Utility/Stream.h"

using namespace lldb;
using namespace lldb_private;

// ThreadPlanStepOverBreakpoint: Single steps over a breakpoint bp_site_sp at
// the pc.

ThreadPlanStepOverBreakpoint::ThreadPlanStepOverBreakpoint(Thread &thread)
    : ThreadPlan(
          ThreadPlan::eKindStepOverBreakpoint, "Step over breakpoint trap",
          thread, eVoteNo,
          eVoteNoOpinion), // We need to report the run since this happens
                           // first in the thread plan stack when stepping over
                           // a breakpoint
      m_breakpoint_addr(LLDB_INVALID_ADDRESS),
      m_auto_continue(false), m_reenabled_breakpoint_site(false)

{
  m_breakpoint_addr = thread.GetRegisterContext()->GetPC();
  m_breakpoint_site_id =
      thread.GetProcess()->GetBreakpointSiteList().FindIDByAddress(
          m_breakpoint_addr);
}

ThreadPlanStepOverBreakpoint::~ThreadPlanStepOverBreakpoint() {}

void ThreadPlanStepOverBreakpoint::GetDescription(
    Stream *s, lldb::DescriptionLevel level) {
  s->Printf("Single stepping past breakpoint site %" PRIu64 " at 0x%" PRIx64,
            m_breakpoint_site_id, (uint64_t)m_breakpoint_addr);
}

bool ThreadPlanStepOverBreakpoint::ValidatePlan(Stream *error) { return true; }

bool ThreadPlanStepOverBreakpoint::DoPlanExplainsStop(Event *event_ptr) {
  StopInfoSP stop_info_sp = GetPrivateStopInfo();
  if (stop_info_sp) {
    // It's a little surprising that we stop here for a breakpoint hit.
    // However, when you single step ONTO a breakpoint we still want to call
    // that a breakpoint hit, and trigger the actions, etc.  Otherwise you
    // would see the
    // PC at the breakpoint without having triggered the actions, then you'd
    // continue, the PC wouldn't change,
    // and you'd see the breakpoint hit, which would be odd. So the lower
    // levels fake "step onto breakpoint address" and return that as a
    // breakpoint.  So our trace step COULD appear as a breakpoint hit if the
    // next instruction also contained a breakpoint.
    StopReason reason = stop_info_sp->GetStopReason();

Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
    LLDB_LOGF(log, "Step over breakpoint stopped for reason: %s.",
              Thread::StopReasonAsCString(reason));

switch (reason) {
      case eStopReasonTrace:
      case eStopReasonNone:
        return true;
      case eStopReasonBreakpoint:
      {
        // It's a little surprising that we stop here for a breakpoint hit.
        // However, when you single step ONTO a breakpoint we still want to call
        // that a breakpoint hit, and trigger the actions, etc.  Otherwise you
        // would see the PC at the breakpoint without having triggered the
        // actions, then you'd continue, the PC wouldn't change, and you'd see
        // the breakpoint hit, which would be odd. So the lower levels fake 
        // "step onto breakpoint address" and return that as a breakpoint hit.  
        // So our trace step COULD appear as a breakpoint hit if the next 
        // instruction also contained a breakpoint.  We don't want to handle 
        // that, since we really don't know what to do with breakpoint hits.  
        // But make sure we don't set ourselves to auto-continue or we'll wrench
        // control away from the plans that can deal with this.
        // Be careful, however, as we may have "seen a breakpoint under the PC
        // because we stopped without changing the PC, in which case we do want
        // to re-claim this stop so we'll try again.
        lldb::addr_t pc_addr = GetThread().GetRegisterContext()->GetPC();

if (pc_addr == m_breakpoint_addr) {
          LLDB_LOGF(log,
                    "Got breakpoint stop reason but pc: 0x%" PRIx64
                    "hasn't changed.",
                    pc_addr);
          return true;
        }

SetAutoContinue(false);
        return false;
      }
      default:
        return false;
    }
  }
  return false;
}

bool ThreadPlanStepOverBreakpoint::ShouldStop(Event *event_ptr) {
  return !ShouldAutoContinue(event_ptr);
}

bool ThreadPlanStepOverBreakpoint::StopOthers() { return true; }

StateType ThreadPlanStepOverBreakpoint::GetPlanRunState() {
  return eStateStepping;
}

bool ThreadPlanStepOverBreakpoint::DoWillResume(StateType resume_state,
                                                bool current_plan) {
  if (current_plan) {
    BreakpointSiteSP bp_site_sp(
        m_process.GetBreakpointSiteList().FindByAddress(m_breakpoint_addr));
    if (bp_site_sp && bp_site_sp->IsEnabled()) {
      m_process.DisableBreakpointSite(bp_site_sp.get());
      m_reenabled_breakpoint_site = false;
    }
  }
  return true;
}

bool ThreadPlanStepOverBreakpoint::WillStop() {
  ReenableBreakpointSite();
  return true;
}

void ThreadPlanStepOverBreakpoint::WillPop() {
  ReenableBreakpointSite();
}

bool ThreadPlanStepOverBreakpoint::MischiefManaged() {
  lldb::addr_t pc_addr = GetThread().GetRegisterContext()->GetPC();

if (pc_addr == m_breakpoint_addr) {
    // If we are still at the PC of our breakpoint, then for some reason we
    // didn't get a chance to run.
    return false;
  } else {
    Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
    LLDB_LOGF(log, "Completed step over breakpoint plan.");
    // Otherwise, re-enable the breakpoint we were stepping over, and we're
    // done.
    ReenableBreakpointSite();
    ThreadPlan::MischiefManaged();
    return true;
  }
}

void ThreadPlanStepOverBreakpoint::ReenableBreakpointSite() {
  if (!m_reenabled_breakpoint_site) {
    m_reenabled_breakpoint_site = true;
    BreakpointSiteSP bp_site_sp(
        m_process.GetBreakpointSiteList().FindByAddress(m_breakpoint_addr));
    if (bp_site_sp) {
      m_process.EnableBreakpointSite(bp_site_sp.get());
    }
  }
}
void ThreadPlanStepOverBreakpoint::ThreadDestroyed() {
  ReenableBreakpointSite();
}

void ThreadPlanStepOverBreakpoint::SetAutoContinue(bool do_it) {
  m_auto_continue = do_it;
}

bool ThreadPlanStepOverBreakpoint::ShouldAutoContinue(Event *event_ptr) {
  return m_auto_continue;
}

bool ThreadPlanStepOverBreakpoint::IsPlanStale() {
  return GetThread().GetRegisterContext()->GetPC() != m_breakpoint_addr;
}

003 File Manager

Editing: ThreadPlanStepOverBreakpoint.cpp

Upload File

Create Folder