f8b825f689
This recommits r341487, which was reverted due to failing tests with clang. It turned out I had incorrectly expected that the literal arrays passed to ArrayRef constructor will have static (permanent) storage. This was only the case with gcc, while clang was constructing them on stack, leading to dangling pointers when the function returns. The fix is to explicitly assign static storage duration to the opcode arrays. llvm-svn: 341758
314 lines
12 KiB
C++
314 lines
12 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.
|
|
auto expected_opcode = process.GetSoftwareBreakpointTrapOpcode(size_hint);
|
|
if (!expected_opcode)
|
|
return Status(expected_opcode.takeError());
|
|
|
|
assert(expected_opcode->size() > 0);
|
|
assert(expected_opcode->size() <= MAX_TRAP_OPCODE_SIZE);
|
|
|
|
// Enable the breakpoint.
|
|
uint8_t saved_opcode_bytes[MAX_TRAP_OPCODE_SIZE];
|
|
Status error =
|
|
EnableSoftwareBreakpoint(process, addr, expected_opcode->size(),
|
|
expected_opcode->data(), 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,
|
|
expected_opcode->data(),
|
|
expected_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; }
|