Move to void* buffer instead of data buffer heap

Author: Jlalond

lldb/include/lldb/Target/Process.h

@@ -1599,7 +1599,7 @@ class Process : public std::enable_shared_from_this<Process>,
   // uint64_t bytes_read_for_chunk, the actual count of bytes read for this
   // chunk
   typedef std::function<IterationAction(lldb_private::Status &, const void *,
-    lldb::addr_t, uint64_t, uint64_t)>
+                                        lldb::addr_t, uint64_t, uint64_t)>
       ReadMemoryChunkCallback;
 
   /// Read of memory from a process in discrete chunks, terminating
@@ -1610,9 +1610,13 @@ class Process : public std::enable_shared_from_this<Process>,
   ///     A virtual load address that indicates where to start reading
   ///     memory from.
   ///
-  /// \param[in] data
-  ///     The data buffer heap to use to read the chunk. The chunk size
-  ///     depends upon the byte size of the buffer.
+  /// \param[in] buf
+  ///     A byte buffer that is at least \a chunk_size bytes long that
+  ///     will receive the memory bytes.
+  ///
+  /// \param[in] chunk_size
+  ///     The minimum size of the byte buffer, and the chunk size of memory
+  ///     to read.
   ///
   /// \param[in] size
   ///     The number of bytes to read.
@@ -1627,8 +1631,9 @@ class Process : public std::enable_shared_from_this<Process>,
   ///     size, then this function will get called again with \a
   ///     vm_addr, \a buf, and \a size updated appropriately. Zero is
   ///     returned in the case of an error.
-  size_t ReadMemoryInChunks(lldb::addr_t vm_addr, DataBufferHeap &data,
-                            size_t size, ReadMemoryChunkCallback callback);
+  size_t ReadMemoryInChunks(lldb::addr_t vm_addr, void *buf,
+                            lldb::addr_t chunk_size, size_t size,
+                            ReadMemoryChunkCallback callback);
 
   /// Read a NULL terminated C string from memory
   ///

lldb/source/Target/Process.cpp

@@ -2234,27 +2234,27 @@ size_t Process::ReadMemoryFromInferior(addr_t addr, void *buf, size_t size,
 }
 
 size_t Process::ReadMemoryInChunks(lldb::addr_t vm_addr, void *buf,
-  lldb::addr_t chunk_size, size_t size,
-  ReadMemoryChunkCallback callback) {
-// Safety check to prevent an infinite loop.
-if (chunk_size == 0)
-return 0;
-
-// Create a data buffer heap of the specified size, initialized to 0.
-uint64_t bytes_remaining = size;
-uint64_t bytes_read = 0;
-Status error;
-while (bytes_remaining > 0) {
-// Get the next read chunk size as the minimum of the remaining bytes and
-// the write chunk max size.
-const size_t bytes_to_read = std::min(bytes_remaining, chunk_size);
-const lldb::addr_t current_addr = vm_addr + bytes_read;
-const size_t bytes_read_for_chunk =
-ReadMemoryFromInferior(current_addr, buf, bytes_to_read, error);
-
-if (callback(error, buf, current_addr, bytes_to_read,
-bytes_read_for_chunk) == IterationAction::Stop)
-break;
+                                   lldb::addr_t chunk_size, size_t size,
+                                   ReadMemoryChunkCallback callback) {
+  // Safety check to prevent an infinite loop.
+  if (chunk_size == 0)
+    return 0;
+
+  // Create a data buffer heap of the specified size, initialized to 0.
+  uint64_t bytes_remaining = size;
+  uint64_t bytes_read = 0;
+  Status error;
+  while (bytes_remaining > 0) {
+    // Get the next read chunk size as the minimum of the remaining bytes and
+    // the write chunk max size.
+    const size_t bytes_to_read = std::min(bytes_remaining, chunk_size);
+    const lldb::addr_t current_addr = vm_addr + bytes_read;
+    const size_t bytes_read_for_chunk =
+        ReadMemoryFromInferior(current_addr, buf, bytes_to_read, error);
+
+    if (callback(error, buf, current_addr, bytes_to_read,
+                 bytes_read_for_chunk) == IterationAction::Stop)
+      break;
 
     bytes_read += bytes_read_for_chunk;
     // If the bytes read in this chunk would cause us to overflow, something