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: ThreadPlanRunToAddress.cpp

//===-- ThreadPlanRunToAddress.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/ThreadPlanRunToAddress.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/RegisterContext.h"
#include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h"
#include "lldb/Utility/Log.h"
#include "lldb/Utility/Stream.h"

using namespace lldb;
using namespace lldb_private;

// ThreadPlanRunToAddress: Continue plan

ThreadPlanRunToAddress::ThreadPlanRunToAddress(Thread &thread, Address &address,
                                               bool stop_others)
    : ThreadPlan(ThreadPlan::eKindRunToAddress, "Run to address plan", thread,
                 eVoteNoOpinion, eVoteNoOpinion),
      m_stop_others(stop_others), m_addresses(), m_break_ids() {
  m_addresses.push_back(
      address.GetOpcodeLoadAddress(thread.CalculateTarget().get()));
  SetInitialBreakpoints();
}

ThreadPlanRunToAddress::ThreadPlanRunToAddress(Thread &thread,
                                               lldb::addr_t address,
                                               bool stop_others)
    : ThreadPlan(ThreadPlan::eKindRunToAddress, "Run to address plan", thread,
                 eVoteNoOpinion, eVoteNoOpinion),
      m_stop_others(stop_others), m_addresses(), m_break_ids() {
  m_addresses.push_back(
      thread.CalculateTarget()->GetOpcodeLoadAddress(address));
  SetInitialBreakpoints();
}

ThreadPlanRunToAddress::ThreadPlanRunToAddress(
    Thread &thread, const std::vector<lldb::addr_t> &addresses,
    bool stop_others)
    : ThreadPlan(ThreadPlan::eKindRunToAddress, "Run to address plan", thread,
                 eVoteNoOpinion, eVoteNoOpinion),
      m_stop_others(stop_others), m_addresses(addresses), m_break_ids() {
  // Convert all addresses into opcode addresses to make sure we set
  // breakpoints at the correct address.
  Target &target = thread.GetProcess()->GetTarget();
  std::vector<lldb::addr_t>::iterator pos, end = m_addresses.end();
  for (pos = m_addresses.begin(); pos != end; ++pos)
    *pos = target.GetOpcodeLoadAddress(*pos);

SetInitialBreakpoints();
}

void ThreadPlanRunToAddress::SetInitialBreakpoints() {
  size_t num_addresses = m_addresses.size();
  m_break_ids.resize(num_addresses);

for (size_t i = 0; i < num_addresses; i++) {
    Breakpoint *breakpoint;
    breakpoint =
        GetTarget().CreateBreakpoint(m_addresses[i], true, false).get();
    if (breakpoint != nullptr) {
      if (breakpoint->IsHardware() && !breakpoint->HasResolvedLocations())
        m_could_not_resolve_hw_bp = true;
      m_break_ids[i] = breakpoint->GetID();
      breakpoint->SetThreadID(m_tid);
      breakpoint->SetBreakpointKind("run-to-address");
    }
  }
}

ThreadPlanRunToAddress::~ThreadPlanRunToAddress() {
  size_t num_break_ids = m_break_ids.size();
  for (size_t i = 0; i < num_break_ids; i++) {
    GetTarget().RemoveBreakpointByID(m_break_ids[i]);
  }
  m_could_not_resolve_hw_bp = false;
}

void ThreadPlanRunToAddress::GetDescription(Stream *s,
                                            lldb::DescriptionLevel level) {
  size_t num_addresses = m_addresses.size();

if (level == lldb::eDescriptionLevelBrief) {
    if (num_addresses == 0) {
      s->Printf("run to address with no addresses given.");
      return;
    } else if (num_addresses == 1)
      s->Printf("run to address: ");
    else
      s->Printf("run to addresses: ");

for (size_t i = 0; i < num_addresses; i++) {
      DumpAddress(s->AsRawOstream(), m_addresses[i], sizeof(addr_t));
      s->Printf(" ");
    }
  } else {
    if (num_addresses == 0) {
      s->Printf("run to address with no addresses given.");
      return;
    } else if (num_addresses == 1)
      s->Printf("Run to address: ");
    else {
      s->Printf("Run to addresses: ");
    }

for (size_t i = 0; i < num_addresses; i++) {
      if (num_addresses > 1) {
        s->Printf("\n");
        s->Indent();
      }

DumpAddress(s->AsRawOstream(), m_addresses[i], sizeof(addr_t));
      s->Printf(" using breakpoint: %d - ", m_break_ids[i]);
      Breakpoint *breakpoint =
          GetTarget().GetBreakpointByID(m_break_ids[i]).get();
      if (breakpoint)
        breakpoint->Dump(s);
      else
        s->Printf("but the breakpoint has been deleted.");
    }
  }
}

bool ThreadPlanRunToAddress::ValidatePlan(Stream *error) {
  if (m_could_not_resolve_hw_bp) {
    if (error)
      error->Printf("Could not set hardware breakpoint(s)");
    return false;
  }

// If we couldn't set the breakpoint for some reason, then this won't work.
  bool all_bps_good = true;
  size_t num_break_ids = m_break_ids.size();
  for (size_t i = 0; i < num_break_ids; i++) {
    if (m_break_ids[i] == LLDB_INVALID_BREAK_ID) {
      all_bps_good = false;
      if (error) {
        error->Printf("Could not set breakpoint for address: ");
        DumpAddress(error->AsRawOstream(), m_addresses[i], sizeof(addr_t));
        error->Printf("\n");
      }
    }
  }
  return all_bps_good;
}

bool ThreadPlanRunToAddress::DoPlanExplainsStop(Event *event_ptr) {
  return AtOurAddress();
}

bool ThreadPlanRunToAddress::ShouldStop(Event *event_ptr) {
  return AtOurAddress();
}

bool ThreadPlanRunToAddress::StopOthers() { return m_stop_others; }

void ThreadPlanRunToAddress::SetStopOthers(bool new_value) {
  m_stop_others = new_value;
}

StateType ThreadPlanRunToAddress::GetPlanRunState() { return eStateRunning; }

bool ThreadPlanRunToAddress::WillStop() { return true; }

bool ThreadPlanRunToAddress::MischiefManaged() {
  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));

if (AtOurAddress()) {
    // Remove the breakpoint
    size_t num_break_ids = m_break_ids.size();

for (size_t i = 0; i < num_break_ids; i++) {
      if (m_break_ids[i] != LLDB_INVALID_BREAK_ID) {
        GetTarget().RemoveBreakpointByID(m_break_ids[i]);
        m_break_ids[i] = LLDB_INVALID_BREAK_ID;
      }
    }
    LLDB_LOGF(log, "Completed run to address plan.");
    ThreadPlan::MischiefManaged();
    return true;
  } else
    return false;
}

bool ThreadPlanRunToAddress::AtOurAddress() {
  lldb::addr_t current_address = GetThread().GetRegisterContext()->GetPC();
  bool found_it = false;
  size_t num_addresses = m_addresses.size();
  for (size_t i = 0; i < num_addresses; i++) {
    if (m_addresses[i] == current_address) {
      found_it = true;
      break;
    }
  }
  return found_it;
}

003 File Manager

Editing: ThreadPlanRunToAddress.cpp

Upload File

Create Folder