Remove trap code from disassembly.

[chaoren]

Summary

NativeProcessProtocol uses ReadMemory internally for setting/checking
breakpoints but also for generic memory reads (Handle_m), this change adds a
ReadMemoryWithoutTrap for that purpose.

[clayborg]

Looks good.

[chaoren]

Fix some other places where addr_t is used as size.

lldb/trunk/include/lldb/Host/common/NativeBreakpointList.h

public:
         EnableBreakpoint (lldb::addr_t addr);
 
         Error
         DisableBreakpoint (lldb::addr_t addr);
 
         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;
 
         Mutex m_mutex;
         BreakpointMap m_breakpoints;
     };
 }
 
 #endif // ifndef liblldb_NativeBreakpointList_h_

lldb/trunk/include/lldb/Host/common/NativeProcessProtocol.h

public:
         //----------------------------------------------------------------------
         // Memory and memory region functions
         //----------------------------------------------------------------------
 
         virtual Error
         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;
 
         virtual lldb::addr_t
         GetSharedLibraryInfoAddress () = 0;
 
         virtual bool

lldb/trunk/include/lldb/Host/common/NativeRegisterContext.h

public:
 
     virtual lldb::addr_t
     GetWatchpointAddress (uint32_t wp_index);
 
     virtual bool
     HardwareSingleStep (bool enable);
 
     virtual Error
-    ReadRegisterValueFromMemory (const lldb_private::RegisterInfo *reg_info, lldb::addr_t src_addr, lldb::addr_t src_len, RegisterValue &reg_value);
+    ReadRegisterValueFromMemory (const lldb_private::RegisterInfo *reg_info, lldb::addr_t src_addr, size_t src_len, RegisterValue &reg_value);
 
     virtual Error
-    WriteRegisterValueToMemory (const lldb_private::RegisterInfo *reg_info, lldb::addr_t dst_addr, lldb::addr_t dst_len, const RegisterValue &reg_value);
+    WriteRegisterValueToMemory (const lldb_private::RegisterInfo *reg_info, lldb::addr_t dst_addr, size_t dst_len, const RegisterValue &reg_value);
 
     //------------------------------------------------------------------
     // Subclasses should not override these
     //------------------------------------------------------------------
     virtual lldb::tid_t
     GetThreadID() const;
 
     virtual NativeThreadProtocol &

lldb/trunk/include/lldb/Host/common/SoftwareBreakpoint.h

 
 #include "lldb/lldb-private-forward.h"
 #include "NativeBreakpoint.h"
 
 namespace lldb_private
 {
     class SoftwareBreakpoint : public NativeBreakpoint
     {
+        friend class NativeBreakpointList;
+
     public:
         static Error
         CreateSoftwareBreakpoint (NativeProcessProtocol &process, lldb::addr_t addr, size_t size_hint, NativeBreakpointSP &breakpoint_spn);
 
         SoftwareBreakpoint (NativeProcessProtocol &process, lldb::addr_t addr, const uint8_t *saved_opcodes, const uint8_t *trap_opcodes, size_t opcode_size);
 
     protected:
         Error

lldb/trunk/source/Host/common/NativeBreakpointList.cpp

 //===-- NativeBreakpointList.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/NativeBreakpointList.h"
 
 #include "lldb/Core/Log.h"
 
 #include "lldb/Host/common/NativeBreakpoint.h"
+#include "lldb/Host/common/SoftwareBreakpoint.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 NativeBreakpointList::NativeBreakpointList () :
     m_mutex (Mutex::eMutexTypeRecursive)
 {
 }
if (iter == m_breakpoints.end ())
         return Error ("breakpoint not found");
     }
 
     // Disable it.
     breakpoint_sp = iter->second;
     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();
+}

lldb/trunk/source/Host/common/NativeRegisterContext.cpp

 {
     return false;
 }
 
 Error
 NativeRegisterContext::ReadRegisterValueFromMemory (
     const RegisterInfo *reg_info,
     lldb::addr_t src_addr,
-    lldb::addr_t src_len,
+    size_t src_len,
     RegisterValue &reg_value)
 {
     Error error;
     if (reg_info == nullptr)
     {
         error.SetErrorString ("invalid register info argument.");
         return error;
     }
NativeRegisterContext::ReadRegisterValueFromMemory (
     //   |AABB0000| Register contents [on little-endian hardware]
     //   |0000AABB| Register contents [on big-endian hardware]
     if (src_len > RegisterValue::kMaxRegisterByteSize)
     {
         error.SetErrorString ("register too small to receive memory data");
         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)
     {
         error.SetErrorStringWithFormat("%" PRIu64 " bytes is too big to store in register %s (%" PRIu64 " bytes)", src_len, reg_info->name, dst_len);
         return error;
     }
 
     NativeProcessProtocolSP process_sp (m_thread.GetProcess ());
     if (!process_sp)
     {
         error.SetErrorString("invalid process");
         return error;
     }
 
     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;
 
     // Make sure the memory read succeeded...
     if (bytes_read != src_len)
     {
         // This might happen if we read _some_ bytes but not all
NativeRegisterContext::ReadRegisterValueFromMemory (
 
     return error;
 }
 
 Error
 NativeRegisterContext::WriteRegisterValueToMemory (
     const RegisterInfo *reg_info,
     lldb::addr_t dst_addr,
-    lldb::addr_t dst_len,
+    size_t dst_len,
     const RegisterValue &reg_value)
 {
     
     uint8_t dst[RegisterValue::kMaxRegisterByteSize];
 
     Error error;
 
     NativeProcessProtocolSP process_sp (m_thread.GetProcess ());
     if (process_sp)
     {
 
         // TODO: we might need to add a parameter to this function in case the byte
         // order of the memory data doesn't match the process. For now we are assuming
         // they are the same.
         lldb::ByteOrder byte_order;
         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,
             byte_order,
             error);
 
         if (error.Success())
         {
             if (bytes_copied == 0)
             {
                 error.SetErrorString("byte copy failed.");
             }
             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;
 
                 if (bytes_written != bytes_copied)
                 {
                     // This might happen if we read _some_ bytes but not all
                     error.SetErrorStringWithFormat("only wrote %" PRIu64 " of %" PRIu64 " bytes", bytes_written, bytes_copied);
                 }

lldb/trunk/source/Host/common/SoftwareBreakpoint.cpp

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_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.
-    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)
             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 != 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);
         return Error ("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);
     }
 
     // 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%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)
             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 != 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)
             log->PutCString (error.AsCString ());
         return error;
     }
 
     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)
             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 != 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);
         return Error ("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);
     }
 
     if (::memcmp(bp_opcode_bytes, verify_bp_opcode_bytes, bp_opcode_size) != 0)
     {
SoftwareBreakpoint::DoDisable ()
     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
-        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);
         }
         if (error.Success ())
         {
             bool verify = false;
             // Make sure we have the a 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.
-                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);
                 }
                 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
 
-                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);
                 }
                 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%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);
                         }
                         return error;
                     }
                     else
                     {
                         if (break_op_found)

lldb/trunk/source/Plugins/Process/Linux/NativeProcessLinux.h

public:
 
         Error
         Kill () override;
 
         Error
         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;
 
         lldb::addr_t
         GetSharedLibraryInfoAddress () override;
 
         size_t

lldb/trunk/source/Plugins/Process/Linux/NativeProcessLinux.cpp

#ifdef LLDB_CONFIGURATION_BUILDANDINTEGRATION
     }
 #endif
 
     //------------------------------------------------------------------------------
     // Static implementations of NativeProcessLinux::ReadMemory and
     // 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));
         if (log)
             ProcessPOSIXLog::IncNestLevel();
         if (log && ProcessPOSIXLog::AtTopNestLevel() && log->GetMask().Test(POSIX_LOG_MEMORY))
             log->Printf ("NativeProcessLinux::%s(%" PRIu64 ", %d, %p, %p, %zd, _)", __FUNCTION__,
                     pid, word_size, (void*)vm_addr, buf, size);
DoReadMemory(
             dst += word_size;
         }
 
         if (log)
             ProcessPOSIXLog::DecNestLevel();
         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)
             ProcessPOSIXLog::IncNestLevel();
         if (log && ProcessPOSIXLog::AtTopNestLevel() && log->GetMask().Test(POSIX_LOG_MEMORY))
             log->Printf ("NativeProcessLinux::%s(%" PRIu64 ", %u, %p, %p, %" PRIu64 ")", __FUNCTION__,
                     pid, word_size, (void*)vm_addr, buf, size);
 
#endif
     };
 
     //------------------------------------------------------------------------------
     /// @class ReadOperation
     /// @brief Implements NativeProcessLinux::ReadMemory.
     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),
             m_size (size),
             m_result (result)
             {
             }
 
         void Execute (NativeProcessLinux *process) override;
 
     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
     ReadOperation::Execute (NativeProcessLinux *process)
     {
         m_result = DoReadMemory (process->GetID (), m_addr, m_buff, m_size, m_error);
     }
 
     //------------------------------------------------------------------------------
     /// @class WriteOperation
     /// @brief Implements NativeProcessLinux::WriteMemory.
     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),
             m_size (size),
             m_result (result)
             {
             }
 
         void Execute (NativeProcessLinux *process) override;
 
     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
     WriteOperation::Execute(NativeProcessLinux *process)
     {
         m_result = DoWriteMemory (process->GetID (), m_addr, m_buff, m_size, m_error);
     }
 
ReadMemoryCallback (EmulateInstruction *instruction,
                     void *baton,
                     const EmulateInstruction::Context &context, 
                     lldb::addr_t addr, 
                     void *dst,
                     size_t length)
 {
     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;
 }
 
 static bool
 ReadRegisterCallback (EmulateInstruction *instruction,
                       void *baton,
                       const RegisterInfo *reg_info,
if (log)
         Mutex::Locker locker (m_mem_region_cache_mutex);
         if (log)
             log->Printf ("NativeProcessLinux::%s clearing %" PRIu64 " entries from the cache", __FUNCTION__, static_cast<uint64_t> (m_mem_region_cache.size ()));
         m_mem_region_cache.clear ();
     }
 }
 
 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
     // functional ThreadPlans working with Native*Protocol.
 #if 1
     return Error ("not implemented yet");
 #else
     addr = LLDB_INVALID_ADDRESS;
case BUS_OBJERR:
         break;
     }
 
     return reason;
 }
 #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);
     return op.GetError ();
 }
 
 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);
     return op.GetError ();
 }
 
 Error
 NativeProcessLinux::ReadRegisterValue(lldb::tid_t tid, uint32_t offset, const char* reg_name,
NativeProcessLinux::FixupBreakpointPCAsNeeded (NativeThreadProtocolSP &thread_sp)
     {
         if (log)
             log->Printf ("NativeProcessLinux::%s breakpoint size: %" PRIu32, __FUNCTION__, breakpoint_size);
     }
 
     // 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.
     NativeBreakpointSP breakpoint_sp;
     error = m_breakpoint_list.GetBreakpoint (breakpoint_addr, breakpoint_sp);
     if (!error.Success () || !breakpoint_sp)
     {
         // We didn't find one at a software probe location.  Nothing to do.

lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp

GDBRemoteCommunicationServerLLGS::Handle_m (StringExtractorGDBRemote &packet)
 
     // Allocate the response buffer.
     std::string buf(byte_count, '\0');
     if (buf.empty())
         return SendErrorResponse (0x78);
 
 
     // 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)
             log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 " mem 0x%" PRIx64 ": failed to read. Error: %s", __FUNCTION__, m_debugged_process_sp->GetID (), read_addr, error.AsCString ());
         return SendErrorResponse (0x08);
     }
 
     if (bytes_read == 0)
     {
         if (log)
             log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 " mem 0x%" PRIx64 ": read %" PRIu64 " of %" PRIu64 " requested bytes", __FUNCTION__, m_debugged_process_sp->GetID (), read_addr, bytes_read, byte_count);
         return SendErrorResponse (0x08);
     }
 
     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());
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_M (StringExtractorGDBRemote &packet)
 {
GDBRemoteCommunicationServerLLGS::Handle_M (StringExtractorGDBRemote &packet)
 
     // Allocate the conversion buffer.
     std::vector<uint8_t> buf(byte_count, 0);
     if (buf.empty())
         return SendErrorResponse (0x78);
 
     // 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)
             log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 " mem 0x%" PRIx64 ": asked to write %" PRIu64 " bytes, but only found %" PRIu64 " to convert.", __FUNCTION__, m_debugged_process_sp->GetID (), write_addr, byte_count, convert_count);
         return SendIllFormedResponse (packet, "M content byte length specified did not match hex-encoded content length");
     }
 
     // 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 ())
     {
         if (log)
             log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 " mem 0x%" PRIx64 ": failed to write. Error: %s", __FUNCTION__, m_debugged_process_sp->GetID (), write_addr, error.AsCString ());
         return SendErrorResponse (0x09);
     }