97206d5727
This renames the LLDB error class to Status, as discussed on the lldb-dev mailing list. A change of this magnitude cannot easily be done without find and replace, but that has potential to catch unwanted occurrences of common strings such as "Error". Every effort was made to find all the obvious things such as the word "Error" appearing in a string, etc, but it's possible there are still some lingering occurences left around. Hopefully nothing too serious. llvm-svn: 302872
354 lines
14 KiB
C++
354 lines
14 KiB
C++
//===-- SoftwareBreakpoint.cpp ----------------------------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "lldb/Host/common/SoftwareBreakpoint.h"
|
|
|
|
#include "lldb/Host/Debug.h"
|
|
#include "lldb/Utility/Log.h"
|
|
#include "lldb/Utility/Status.h"
|
|
|
|
#include "lldb/Host/common/NativeProcessProtocol.h"
|
|
|
|
using namespace lldb_private;
|
|
|
|
// -------------------------------------------------------------------
|
|
// static members
|
|
// -------------------------------------------------------------------
|
|
|
|
Status SoftwareBreakpoint::CreateSoftwareBreakpoint(
|
|
NativeProcessProtocol &process, lldb::addr_t addr, size_t size_hint,
|
|
NativeBreakpointSP &breakpoint_sp) {
|
|
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
|
|
if (log)
|
|
log->Printf("SoftwareBreakpoint::%s addr = 0x%" PRIx64, __FUNCTION__, addr);
|
|
|
|
// Validate the address.
|
|
if (addr == LLDB_INVALID_ADDRESS)
|
|
return Status("SoftwareBreakpoint::%s invalid load address specified.",
|
|
__FUNCTION__);
|
|
|
|
// Ask the NativeProcessProtocol subclass to fill in the correct software
|
|
// breakpoint
|
|
// trap for the breakpoint site.
|
|
size_t bp_opcode_size = 0;
|
|
const uint8_t *bp_opcode_bytes = NULL;
|
|
Status error = process.GetSoftwareBreakpointTrapOpcode(
|
|
size_hint, bp_opcode_size, bp_opcode_bytes);
|
|
|
|
if (error.Fail()) {
|
|
if (log)
|
|
log->Printf("SoftwareBreakpoint::%s failed to retrieve software "
|
|
"breakpoint trap opcode: %s",
|
|
__FUNCTION__, error.AsCString());
|
|
return error;
|
|
}
|
|
|
|
// Validate size of trap opcode.
|
|
if (bp_opcode_size == 0) {
|
|
if (log)
|
|
log->Printf("SoftwareBreakpoint::%s failed to retrieve any trap opcodes",
|
|
__FUNCTION__);
|
|
return Status("SoftwareBreakpoint::GetSoftwareBreakpointTrapOpcode() "
|
|
"returned zero, unable to get breakpoint trap for address "
|
|
"0x%" PRIx64,
|
|
addr);
|
|
}
|
|
|
|
if (bp_opcode_size > MAX_TRAP_OPCODE_SIZE) {
|
|
if (log)
|
|
log->Printf("SoftwareBreakpoint::%s cannot support %zu trapcode bytes, "
|
|
"max size is %zu",
|
|
__FUNCTION__, bp_opcode_size, MAX_TRAP_OPCODE_SIZE);
|
|
return Status("SoftwareBreakpoint::GetSoftwareBreakpointTrapOpcode() "
|
|
"returned too many trap opcode bytes: requires %zu but we "
|
|
"only support a max of %zu",
|
|
bp_opcode_size, MAX_TRAP_OPCODE_SIZE);
|
|
}
|
|
|
|
// Validate that we received opcodes.
|
|
if (!bp_opcode_bytes) {
|
|
if (log)
|
|
log->Printf("SoftwareBreakpoint::%s failed to retrieve trap opcode bytes",
|
|
__FUNCTION__);
|
|
return Status("SoftwareBreakpoint::GetSoftwareBreakpointTrapOpcode() "
|
|
"returned NULL trap opcode bytes, unable to get breakpoint "
|
|
"trap for address 0x%" PRIx64,
|
|
addr);
|
|
}
|
|
|
|
// Enable the breakpoint.
|
|
uint8_t saved_opcode_bytes[MAX_TRAP_OPCODE_SIZE];
|
|
error = EnableSoftwareBreakpoint(process, addr, bp_opcode_size,
|
|
bp_opcode_bytes, saved_opcode_bytes);
|
|
if (error.Fail()) {
|
|
if (log)
|
|
log->Printf("SoftwareBreakpoint::%s: failed to enable new breakpoint at "
|
|
"0x%" PRIx64 ": %s",
|
|
__FUNCTION__, addr, error.AsCString());
|
|
return error;
|
|
}
|
|
|
|
if (log)
|
|
log->Printf("SoftwareBreakpoint::%s addr = 0x%" PRIx64 " -- SUCCESS",
|
|
__FUNCTION__, addr);
|
|
|
|
// Set the breakpoint and verified it was written properly. Now
|
|
// create a breakpoint remover that understands how to undo this
|
|
// breakpoint.
|
|
breakpoint_sp.reset(new SoftwareBreakpoint(process, addr, saved_opcode_bytes,
|
|
bp_opcode_bytes, bp_opcode_size));
|
|
return Status();
|
|
}
|
|
|
|
Status SoftwareBreakpoint::EnableSoftwareBreakpoint(
|
|
NativeProcessProtocol &process, lldb::addr_t addr, size_t bp_opcode_size,
|
|
const uint8_t *bp_opcode_bytes, uint8_t *saved_opcode_bytes) {
|
|
assert(bp_opcode_size <= MAX_TRAP_OPCODE_SIZE &&
|
|
"bp_opcode_size out of valid range");
|
|
assert(bp_opcode_bytes && "bp_opcode_bytes is NULL");
|
|
assert(saved_opcode_bytes && "saved_opcode_bytes is NULL");
|
|
|
|
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
|
|
if (log)
|
|
log->Printf("SoftwareBreakpoint::%s addr = 0x%" PRIx64, __FUNCTION__, addr);
|
|
|
|
// Save the original opcodes by reading them so we can restore later.
|
|
size_t bytes_read = 0;
|
|
|
|
Status error =
|
|
process.ReadMemory(addr, saved_opcode_bytes, bp_opcode_size, bytes_read);
|
|
if (error.Fail()) {
|
|
if (log)
|
|
log->Printf("SoftwareBreakpoint::%s failed to read memory while "
|
|
"attempting to set breakpoint: %s",
|
|
__FUNCTION__, error.AsCString());
|
|
return error;
|
|
}
|
|
|
|
// Ensure we read as many bytes as we expected.
|
|
if (bytes_read != bp_opcode_size) {
|
|
if (log)
|
|
log->Printf("SoftwareBreakpoint::%s failed to read memory while "
|
|
"attempting to set breakpoint: attempted to read %zu bytes "
|
|
"but only read %zu",
|
|
__FUNCTION__, bp_opcode_size, bytes_read);
|
|
return Status("SoftwareBreakpoint::%s failed to read memory while "
|
|
"attempting to set breakpoint: attempted to read %zu bytes "
|
|
"but only read %zu",
|
|
__FUNCTION__, bp_opcode_size, bytes_read);
|
|
}
|
|
|
|
// Log what we read.
|
|
if (log) {
|
|
int i = 0;
|
|
for (const uint8_t *read_byte = saved_opcode_bytes;
|
|
read_byte < saved_opcode_bytes + bp_opcode_size; ++read_byte) {
|
|
log->Printf("SoftwareBreakpoint::%s addr = 0x%" PRIx64
|
|
" ovewriting byte index %d (was 0x%hhx)",
|
|
__FUNCTION__, addr, i++, *read_byte);
|
|
}
|
|
}
|
|
|
|
// Write a software breakpoint in place of the original opcode.
|
|
size_t bytes_written = 0;
|
|
error =
|
|
process.WriteMemory(addr, bp_opcode_bytes, bp_opcode_size, bytes_written);
|
|
if (error.Fail()) {
|
|
if (log)
|
|
log->Printf("SoftwareBreakpoint::%s failed to write memory while "
|
|
"attempting to set breakpoint: %s",
|
|
__FUNCTION__, error.AsCString());
|
|
return error;
|
|
}
|
|
|
|
// Ensure we wrote as many bytes as we expected.
|
|
if (bytes_written != bp_opcode_size) {
|
|
error.SetErrorStringWithFormat(
|
|
"SoftwareBreakpoint::%s failed write memory while attempting to set "
|
|
"breakpoint: attempted to write %zu bytes but only wrote %zu",
|
|
__FUNCTION__, bp_opcode_size, bytes_written);
|
|
if (log)
|
|
log->PutCString(error.AsCString());
|
|
return error;
|
|
}
|
|
|
|
uint8_t verify_bp_opcode_bytes[MAX_TRAP_OPCODE_SIZE];
|
|
size_t verify_bytes_read = 0;
|
|
error = process.ReadMemory(addr, verify_bp_opcode_bytes, bp_opcode_size,
|
|
verify_bytes_read);
|
|
if (error.Fail()) {
|
|
if (log)
|
|
log->Printf("SoftwareBreakpoint::%s failed to read memory while "
|
|
"attempting to verify the breakpoint set: %s",
|
|
__FUNCTION__, error.AsCString());
|
|
return error;
|
|
}
|
|
|
|
// Ensure we read as many verification bytes as we expected.
|
|
if (verify_bytes_read != bp_opcode_size) {
|
|
if (log)
|
|
log->Printf("SoftwareBreakpoint::%s failed to read memory while "
|
|
"attempting to verify breakpoint: attempted to read %zu "
|
|
"bytes but only read %zu",
|
|
__FUNCTION__, bp_opcode_size, verify_bytes_read);
|
|
return Status(
|
|
"SoftwareBreakpoint::%s failed to read memory while "
|
|
"attempting to verify breakpoint: attempted to read %zu bytes "
|
|
"but only read %zu",
|
|
__FUNCTION__, bp_opcode_size, verify_bytes_read);
|
|
}
|
|
|
|
if (::memcmp(bp_opcode_bytes, verify_bp_opcode_bytes, bp_opcode_size) != 0) {
|
|
if (log)
|
|
log->Printf("SoftwareBreakpoint::%s: verification of software breakpoint "
|
|
"writing failed - trap opcodes not successfully read back "
|
|
"after writing when setting breakpoint at 0x%" PRIx64,
|
|
__FUNCTION__, addr);
|
|
return Status("SoftwareBreakpoint::%s: verification of software breakpoint "
|
|
"writing failed - trap opcodes not successfully read back "
|
|
"after writing when setting breakpoint at 0x%" PRIx64,
|
|
__FUNCTION__, addr);
|
|
}
|
|
|
|
if (log)
|
|
log->Printf("SoftwareBreakpoint::%s addr = 0x%" PRIx64 " -- SUCCESS",
|
|
__FUNCTION__, addr);
|
|
|
|
return Status();
|
|
}
|
|
|
|
// -------------------------------------------------------------------
|
|
// instance-level members
|
|
// -------------------------------------------------------------------
|
|
|
|
SoftwareBreakpoint::SoftwareBreakpoint(NativeProcessProtocol &process,
|
|
lldb::addr_t addr,
|
|
const uint8_t *saved_opcodes,
|
|
const uint8_t *trap_opcodes,
|
|
size_t opcode_size)
|
|
: NativeBreakpoint(addr), m_process(process), m_saved_opcodes(),
|
|
m_trap_opcodes(), m_opcode_size(opcode_size) {
|
|
assert(opcode_size > 0 && "setting software breakpoint with no trap opcodes");
|
|
assert(opcode_size <= MAX_TRAP_OPCODE_SIZE && "trap opcode size too large");
|
|
|
|
::memcpy(m_saved_opcodes, saved_opcodes, opcode_size);
|
|
::memcpy(m_trap_opcodes, trap_opcodes, opcode_size);
|
|
}
|
|
|
|
Status SoftwareBreakpoint::DoEnable() {
|
|
return EnableSoftwareBreakpoint(m_process, m_addr, m_opcode_size,
|
|
m_trap_opcodes, m_saved_opcodes);
|
|
}
|
|
|
|
Status SoftwareBreakpoint::DoDisable() {
|
|
Status error;
|
|
assert(m_addr && (m_addr != LLDB_INVALID_ADDRESS) &&
|
|
"can't remove a software breakpoint for an invalid address");
|
|
|
|
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
|
|
if (log)
|
|
log->Printf("SoftwareBreakpoint::%s addr = 0x%" PRIx64, __FUNCTION__,
|
|
m_addr);
|
|
|
|
assert((m_opcode_size > 0) &&
|
|
"cannot restore opcodes when there are no opcodes");
|
|
|
|
if (m_opcode_size > 0) {
|
|
// Clear a software breakpoint instruction
|
|
uint8_t curr_break_op[MAX_TRAP_OPCODE_SIZE];
|
|
bool break_op_found = false;
|
|
assert(m_opcode_size <= sizeof(curr_break_op));
|
|
|
|
// Read the breakpoint opcode
|
|
size_t bytes_read = 0;
|
|
error =
|
|
m_process.ReadMemory(m_addr, curr_break_op, m_opcode_size, bytes_read);
|
|
if (error.Success() && bytes_read < m_opcode_size) {
|
|
error.SetErrorStringWithFormat(
|
|
"SoftwareBreakpointr::%s addr=0x%" PRIx64
|
|
": tried to read %zu bytes but only read %zu",
|
|
__FUNCTION__, m_addr, m_opcode_size, bytes_read);
|
|
}
|
|
if (error.Success()) {
|
|
bool verify = false;
|
|
// Make sure the breakpoint opcode exists at this address
|
|
if (::memcmp(curr_break_op, m_trap_opcodes, m_opcode_size) == 0) {
|
|
break_op_found = true;
|
|
// We found a valid breakpoint opcode at this address, now restore
|
|
// the saved opcode.
|
|
size_t bytes_written = 0;
|
|
error = m_process.WriteMemory(m_addr, m_saved_opcodes, m_opcode_size,
|
|
bytes_written);
|
|
if (error.Success() && bytes_written < m_opcode_size) {
|
|
error.SetErrorStringWithFormat(
|
|
"SoftwareBreakpoint::%s addr=0x%" PRIx64
|
|
": tried to write %zu bytes but only wrote %zu",
|
|
__FUNCTION__, m_addr, m_opcode_size, bytes_written);
|
|
}
|
|
if (error.Success()) {
|
|
verify = true;
|
|
}
|
|
} else {
|
|
error.SetErrorString(
|
|
"Original breakpoint trap is no longer in memory.");
|
|
// Set verify to true and so we can check if the original opcode has
|
|
// already been restored
|
|
verify = true;
|
|
}
|
|
|
|
if (verify) {
|
|
uint8_t verify_opcode[MAX_TRAP_OPCODE_SIZE];
|
|
assert(m_opcode_size <= sizeof(verify_opcode));
|
|
// Verify that our original opcode made it back to the inferior
|
|
|
|
size_t verify_bytes_read = 0;
|
|
error = m_process.ReadMemory(m_addr, verify_opcode, m_opcode_size,
|
|
verify_bytes_read);
|
|
if (error.Success() && verify_bytes_read < m_opcode_size) {
|
|
error.SetErrorStringWithFormat(
|
|
"SoftwareBreakpoint::%s addr=0x%" PRIx64
|
|
": tried to read %zu verification bytes but only read %zu",
|
|
__FUNCTION__, m_addr, m_opcode_size, verify_bytes_read);
|
|
}
|
|
if (error.Success()) {
|
|
// compare the memory we just read with the original opcode
|
|
if (::memcmp(m_saved_opcodes, verify_opcode, m_opcode_size) == 0) {
|
|
// SUCCESS
|
|
if (log) {
|
|
int i = 0;
|
|
for (const uint8_t *verify_byte = verify_opcode;
|
|
verify_byte < verify_opcode + m_opcode_size; ++verify_byte) {
|
|
log->Printf("SoftwareBreakpoint::%s addr = 0x%" PRIx64
|
|
" replaced byte index %d with 0x%hhx",
|
|
__FUNCTION__, m_addr, i++, *verify_byte);
|
|
}
|
|
log->Printf("SoftwareBreakpoint::%s addr = 0x%" PRIx64
|
|
" -- SUCCESS",
|
|
__FUNCTION__, m_addr);
|
|
}
|
|
return error;
|
|
} else {
|
|
if (break_op_found)
|
|
error.SetErrorString("Failed to restore original opcode.");
|
|
}
|
|
} else
|
|
error.SetErrorString("Failed to read memory to verify that "
|
|
"breakpoint trap was restored.");
|
|
}
|
|
}
|
|
}
|
|
|
|
if (log && error.Fail())
|
|
log->Printf("SoftwareBreakpoint::%s addr = 0x%" PRIx64 " -- FAILED: %s",
|
|
__FUNCTION__, m_addr, error.AsCString());
|
|
return error;
|
|
}
|
|
|
|
bool SoftwareBreakpoint::IsSoftwareBreakpoint() const { return true; }
|