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.

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_

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

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

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();
+}

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

source/Plugins/Process/Linux/NativeProcessLinux.cpp

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,

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)