Error
GetBreakpoint (lldb::addr_t addr, NativeBreakpointSP &breakpoint_sp);
+ Error
+ RemoveTrapsFromBuffer(lldb::addr_t addr, void *buf, size_t size) const;
+
private:
typedef std::map<lldb::addr_t, NativeBreakpointSP> BreakpointMap;
GetMemoryRegionInfo (lldb::addr_t load_addr, MemoryRegionInfo &range_info);
virtual Error
- ReadMemory (lldb::addr_t addr, void *buf, lldb::addr_t size, lldb::addr_t &bytes_read) = 0;
+ ReadMemory(lldb::addr_t addr, void *buf, size_t size, size_t &bytes_read) = 0;
virtual Error
- WriteMemory (lldb::addr_t addr, const void *buf, lldb::addr_t size, lldb::addr_t &bytes_written) = 0;
+ ReadMemoryWithoutTrap(lldb::addr_t addr, void *buf, size_t size, size_t &bytes_read) = 0;
virtual Error
- AllocateMemory (lldb::addr_t size, uint32_t permissions, lldb::addr_t &addr) = 0;
+ WriteMemory(lldb::addr_t addr, const void *buf, size_t size, size_t &bytes_written) = 0;
+
+ virtual Error
+ AllocateMemory(size_t size, uint32_t permissions, lldb::addr_t &addr) = 0;
virtual Error
DeallocateMemory (lldb::addr_t addr) = 0;
HardwareSingleStep (bool enable);
virtual Error
- ReadRegisterValueFromMemory (const lldb_private::RegisterInfo *reg_info, lldb::addr_t src_addr, lldb::addr_t src_len, RegisterValue ®_value);
+ ReadRegisterValueFromMemory (const lldb_private::RegisterInfo *reg_info, lldb::addr_t src_addr, size_t src_len, RegisterValue ®_value);
virtual Error
- WriteRegisterValueToMemory (const lldb_private::RegisterInfo *reg_info, lldb::addr_t dst_addr, lldb::addr_t dst_len, const RegisterValue ®_value);
+ WriteRegisterValueToMemory (const lldb_private::RegisterInfo *reg_info, lldb::addr_t dst_addr, size_t dst_len, const RegisterValue ®_value);
//------------------------------------------------------------------
// Subclasses should not override these
{
class SoftwareBreakpoint : public NativeBreakpoint
{
+ friend class NativeBreakpointList;
+
public:
static Error
CreateSoftwareBreakpoint (NativeProcessProtocol &process, lldb::addr_t addr, size_t size_hint, NativeBreakpointSP &breakpoint_spn);
#include "lldb/Core/Log.h"
#include "lldb/Host/common/NativeBreakpoint.h"
+#include "lldb/Host/common/SoftwareBreakpoint.h"
using namespace lldb;
using namespace lldb_private;
return Error ();
}
+Error
+NativeBreakpointList::RemoveTrapsFromBuffer(lldb::addr_t addr, void *buf, size_t size) const
+{
+ for (const auto &map : m_breakpoints)
+ {
+ lldb::addr_t bp_addr = map.first;
+ // Breapoint not in range, ignore
+ if (bp_addr < addr || addr + size <= bp_addr)
+ continue;
+ const auto &bp_sp = map.second;
+ // Not software breakpoint, ignore
+ if (!bp_sp->IsSoftwareBreakpoint())
+ continue;
+ auto software_bp_sp = std::static_pointer_cast<SoftwareBreakpoint>(bp_sp);
+ auto opcode_addr = static_cast<char *>(buf) + bp_addr - addr;
+ auto saved_opcodes = software_bp_sp->m_saved_opcodes;
+ auto opcode_size = software_bp_sp->m_opcode_size;
+ ::memcpy(opcode_addr, saved_opcodes, opcode_size);
+ }
+ return Error();
+}
NativeRegisterContext::ReadRegisterValueFromMemory (
const RegisterInfo *reg_info,
lldb::addr_t src_addr,
- lldb::addr_t src_len,
+ size_t src_len,
RegisterValue ®_value)
{
Error error;
return error;
}
- const lldb::addr_t dst_len = reg_info->byte_size;
+ const size_t dst_len = reg_info->byte_size;
if (src_len > dst_len)
{
uint8_t src[RegisterValue::kMaxRegisterByteSize];
// Read the memory
- lldb::addr_t bytes_read;
+ size_t bytes_read;
error = process_sp->ReadMemory (src_addr, src, src_len, bytes_read);
if (error.Fail ())
return error;
NativeRegisterContext::WriteRegisterValueToMemory (
const RegisterInfo *reg_info,
lldb::addr_t dst_addr,
- lldb::addr_t dst_len,
+ size_t dst_len,
const RegisterValue ®_value)
{
if (!process_sp->GetByteOrder (byte_order))
return Error ("NativeProcessProtocol::GetByteOrder () failed");
- const lldb::addr_t bytes_copied = reg_value.GetAsMemoryData (
+ const size_t bytes_copied = reg_value.GetAsMemoryData (
reg_info,
dst,
dst_len,
}
else
{
- lldb::addr_t bytes_written;
- error = process_sp->WriteMemory (dst_addr, dst, bytes_copied, bytes_written);
+ size_t bytes_written;
+ error = process_sp->WriteMemory(dst_addr, dst, bytes_copied, bytes_written);
if (error.Fail ())
return error;
log->Printf ("SoftwareBreakpoint::%s addr = 0x%" PRIx64, __FUNCTION__, addr);
// Save the original opcodes by reading them so we can restore later.
- lldb::addr_t bytes_read = 0;
+ size_t bytes_read = 0;
- Error error = process.ReadMemory(addr, saved_opcode_bytes, static_cast<lldb::addr_t> (bp_opcode_size), bytes_read);
+ Error error = process.ReadMemory(addr, saved_opcode_bytes, bp_opcode_size, bytes_read);
if (error.Fail ())
{
if (log)
}
// Ensure we read as many bytes as we expected.
- if (bytes_read != static_cast<lldb::addr_t> (bp_opcode_size))
+ if (bytes_read != bp_opcode_size)
{
if (log)
log->Printf ("SoftwareBreakpoint::%s failed to read memory while attempting to set breakpoint: attempted to read %lu bytes but only read %" PRIu64, __FUNCTION__, bp_opcode_size, bytes_read);
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%x)", __FUNCTION__, addr, i++, static_cast<int> (*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.
- lldb::addr_t bytes_written = 0;
- error = process.WriteMemory (addr, bp_opcode_bytes, static_cast<lldb::addr_t> (bp_opcode_size), bytes_written);
+ size_t bytes_written = 0;
+ error = process.WriteMemory(addr, bp_opcode_bytes, bp_opcode_size, bytes_written);
if (error.Fail ())
{
if (log)
}
// Ensure we wrote as many bytes as we expected.
- if (bytes_written != static_cast<lldb::addr_t> (bp_opcode_size))
+ if (bytes_written != bp_opcode_size)
{
error.SetErrorStringWithFormat("SoftwareBreakpoint::%s failed write memory while attempting to set breakpoint: attempted to write %lu bytes but only wrote %" PRIu64, __FUNCTION__, bp_opcode_size, bytes_written);
if (log)
}
uint8_t verify_bp_opcode_bytes [MAX_TRAP_OPCODE_SIZE];
- lldb::addr_t verify_bytes_read = 0;
- error = process.ReadMemory(addr, verify_bp_opcode_bytes, static_cast<lldb::addr_t> (bp_opcode_size), verify_bytes_read);
+ 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)
}
// Ensure we read as many verification bytes as we expected.
- if (verify_bytes_read != static_cast<lldb::addr_t> (bp_opcode_size))
+ 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 %lu bytes but only read %" PRIu64, __FUNCTION__, bp_opcode_size, verify_bytes_read);
assert (m_opcode_size <= sizeof (curr_break_op));
// Read the breakpoint opcode
- lldb::addr_t bytes_read = 0;
+ size_t bytes_read = 0;
error = m_process.ReadMemory (m_addr, curr_break_op, m_opcode_size, bytes_read);
- if (error.Success () && (bytes_read < static_cast<lldb::addr_t> (m_opcode_size)))
+ if (error.Success() && bytes_read < m_opcode_size)
{
error.SetErrorStringWithFormat ("SoftwareBreakpointr::%s addr=0x%" PRIx64 ": tried to read %lu bytes but only read %" PRIu64, __FUNCTION__, m_addr, m_opcode_size, bytes_read);
}
break_op_found = true;
// We found a valid breakpoint opcode at this address, now restore
// the saved opcode.
- lldb::addr_t bytes_written = 0;
+ size_t bytes_written = 0;
error = m_process.WriteMemory (m_addr, m_saved_opcodes, m_opcode_size, bytes_written);
- if (error.Success () && (bytes_written < static_cast<lldb::addr_t> (m_opcode_size)))
+ if (error.Success() && bytes_written < m_opcode_size)
{
error.SetErrorStringWithFormat ("SoftwareBreakpoint::%s addr=0x%" PRIx64 ": tried to write %lu bytes but only wrote %" PRIu64, __FUNCTION__, m_addr, m_opcode_size, bytes_written);
}
assert (m_opcode_size <= sizeof (verify_opcode));
// Verify that our original opcode made it back to the inferior
- lldb::addr_t verify_bytes_read = 0;
+ 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 < static_cast<lldb::addr_t> (m_opcode_size)))
+ if (error.Success() && verify_bytes_read < m_opcode_size)
{
error.SetErrorStringWithFormat ("SoftwareBreakpoint::%s addr=0x%" PRIx64 ": tried to read %lu verification bytes but only read %" PRIu64, __FUNCTION__, m_addr, m_opcode_size, verify_bytes_read);
}
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%x", __FUNCTION__, m_addr, i++, static_cast<int> (*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);
}
// NativeProcessLinux::WriteMemory. This enables mutual recursion between these
// functions without needed to go thru the thread funnel.
- lldb::addr_t
- DoReadMemory (
+ size_t
+ DoReadMemory(
lldb::pid_t pid,
lldb::addr_t vm_addr,
void *buf,
- lldb::addr_t size,
+ size_t size,
Error &error)
{
// ptrace word size is determined by the host, not the child
static const unsigned word_size = sizeof(void*);
unsigned char *dst = static_cast<unsigned char*>(buf);
- lldb::addr_t bytes_read;
- lldb::addr_t remainder;
+ size_t bytes_read;
+ size_t remainder;
long data;
Log *log (ProcessPOSIXLog::GetLogIfAllCategoriesSet (POSIX_LOG_ALL));
return bytes_read;
}
- lldb::addr_t
+ size_t
DoWriteMemory(
lldb::pid_t pid,
lldb::addr_t vm_addr,
const void *buf,
- lldb::addr_t size,
+ size_t size,
Error &error)
{
// ptrace word size is determined by the host, not the child
static const unsigned word_size = sizeof(void*);
const unsigned char *src = static_cast<const unsigned char*>(buf);
- lldb::addr_t bytes_written = 0;
- lldb::addr_t remainder;
+ size_t bytes_written = 0;
+ size_t remainder;
Log *log (ProcessPOSIXLog::GetLogIfAllCategoriesSet (POSIX_LOG_ALL));
if (log)
class ReadOperation : public Operation
{
public:
- ReadOperation (
+ ReadOperation(
lldb::addr_t addr,
void *buff,
- lldb::addr_t size,
- lldb::addr_t &result) :
+ size_t size,
+ size_t &result) :
Operation (),
m_addr (addr),
m_buff (buff),
private:
lldb::addr_t m_addr;
void *m_buff;
- lldb::addr_t m_size;
- lldb::addr_t &m_result;
+ size_t m_size;
+ size_t &m_result;
};
void
class WriteOperation : public Operation
{
public:
- WriteOperation (
+ WriteOperation(
lldb::addr_t addr,
const void *buff,
- lldb::addr_t size,
- lldb::addr_t &result) :
+ size_t size,
+ size_t &result) :
Operation (),
m_addr (addr),
m_buff (buff),
private:
lldb::addr_t m_addr;
const void *m_buff;
- lldb::addr_t m_size;
- lldb::addr_t &m_result;
+ size_t m_size;
+ size_t &m_result;
};
void
{
EmulatorBaton* emulator_baton = static_cast<EmulatorBaton*>(baton);
- lldb::addr_t bytes_read;
+ size_t bytes_read;
emulator_baton->m_process->ReadMemory(addr, dst, length, bytes_read);
return bytes_read;
}
}
Error
-NativeProcessLinux::AllocateMemory (
- lldb::addr_t size,
- uint32_t permissions,
- lldb::addr_t &addr)
+NativeProcessLinux::AllocateMemory(size_t size, uint32_t permissions, lldb::addr_t &addr)
{
// FIXME implementing this requires the equivalent of
// InferiorCallPOSIX::InferiorCallMmap, which depends on
#endif
Error
-NativeProcessLinux::ReadMemory (lldb::addr_t addr, void *buf, lldb::addr_t size, lldb::addr_t &bytes_read)
+NativeProcessLinux::ReadMemory(lldb::addr_t addr, void *buf, size_t size, size_t &bytes_read)
{
ReadOperation op(addr, buf, size, bytes_read);
m_monitor_up->DoOperation(&op);
}
Error
-NativeProcessLinux::WriteMemory (lldb::addr_t addr, const void *buf, lldb::addr_t size, lldb::addr_t &bytes_written)
+NativeProcessLinux::ReadMemoryWithoutTrap(lldb::addr_t addr, void *buf, size_t size, size_t &bytes_read)
+{
+ Error error = ReadMemory(addr, buf, size, bytes_read);
+ if (error.Fail()) return error;
+ return m_breakpoint_list.RemoveTrapsFromBuffer(addr, buf, size);
+}
+
+Error
+NativeProcessLinux::WriteMemory(lldb::addr_t addr, const void *buf, size_t size, size_t &bytes_written)
{
WriteOperation op(addr, buf, size, bytes_written);
m_monitor_up->DoOperation(&op);
// First try probing for a breakpoint at a software breakpoint location: PC - breakpoint size.
const lldb::addr_t initial_pc_addr = context_sp->GetPC ();
lldb::addr_t breakpoint_addr = initial_pc_addr;
- if (breakpoint_size > static_cast<lldb::addr_t> (0))
+ if (breakpoint_size > 0)
{
// Do not allow breakpoint probe to wrap around.
- if (breakpoint_addr >= static_cast<lldb::addr_t> (breakpoint_size))
- breakpoint_addr -= static_cast<lldb::addr_t> (breakpoint_size);
+ if (breakpoint_addr >= breakpoint_size)
+ breakpoint_addr -= breakpoint_size;
}
// Check if we stopped because of a breakpoint.
GetMemoryRegionInfo (lldb::addr_t load_addr, MemoryRegionInfo &range_info) override;
Error
- ReadMemory (lldb::addr_t addr, void *buf, lldb::addr_t size, lldb::addr_t &bytes_read) override;
+ ReadMemory(lldb::addr_t addr, void *buf, size_t size, size_t &bytes_read) override;
Error
- WriteMemory (lldb::addr_t addr, const void *buf, lldb::addr_t size, lldb::addr_t &bytes_written) override;
+ ReadMemoryWithoutTrap(lldb::addr_t addr, void *buf, size_t size, size_t &bytes_read) override;
Error
- AllocateMemory (lldb::addr_t size, uint32_t permissions, lldb::addr_t &addr) override;
+ WriteMemory(lldb::addr_t addr, const void *buf, size_t size, size_t &bytes_written) override;
+
+ Error
+ AllocateMemory(size_t size, uint32_t permissions, lldb::addr_t &addr) override;
Error
DeallocateMemory (lldb::addr_t addr) override;
// Retrieve the process memory.
- lldb::addr_t bytes_read = 0;
- Error error = m_debugged_process_sp->ReadMemory (read_addr, &buf[0], byte_count, bytes_read);
+ size_t bytes_read = 0;
+ Error error = m_debugged_process_sp->ReadMemoryWithoutTrap(read_addr, &buf[0], byte_count, bytes_read);
if (error.Fail ())
{
if (log)
}
StreamGDBRemote response;
- for (lldb::addr_t i = 0; i < bytes_read; ++i)
+ for (size_t i = 0; i < bytes_read; ++i)
response.PutHex8(buf[i]);
return SendPacketNoLock(response.GetData(), response.GetSize());
// Convert the hex memory write contents to bytes.
StreamGDBRemote response;
- const uint64_t convert_count = static_cast<uint64_t> (packet.GetHexBytes (&buf[0], byte_count, 0));
+ const uint64_t convert_count = packet.GetHexBytes(&buf[0], byte_count, 0);
if (convert_count != byte_count)
{
if (log)
}
// Write the process memory.
- lldb::addr_t bytes_written = 0;
+ size_t bytes_written = 0;
Error error = m_debugged_process_sp->WriteMemory (write_addr, &buf[0], byte_count, bytes_written);
if (error.Fail ())
{