Run GCF

Author: Jlalond

lldb/include/lldb/Target/Process.h

@@ -1592,17 +1592,15 @@ class Process : public std::enable_shared_from_this<Process>,
   // Callback definition for read Memory in chunks
   //
   // Status, the status returned from ReadMemoryFromInferior
-  // DataBufferHeap, buffer with bytes potentially written to it
+  // uint8_t*, pointer to the bytes read
   // addr_t, the current_addr, start + bytes read so far.
-  // uint64_t bytes_to_read, the expected bytes read, this 
+  // uint64_t bytes_to_read, the expected bytes read, this
   // is important if it's a partial read
-  // uint64_t bytes_read_for_chunk, the actual count of bytes read for this 
+  // uint64_t bytes_read_for_chunk, the actual count of bytes read for this
   // chunk
-  typedef std::function<IterationAction(lldb_private::Status&,
-                                        lldb_private::DataBufferHeap&,
-                                        lldb::addr_t,
-                                        uint64_t,
-                                        uint64_t)> ReadMemoryChunkCallback;
+  typedef std::function<IterationAction(lldb_private::Status &, const void *,
+    lldb::addr_t, uint64_t, uint64_t)>
+      ReadMemoryChunkCallback;
 
   /// Read of memory from a process in discrete chunks, terminating
   /// either when all bytes are read, or the supplied callback returns

lldb/source/Plugins/ObjectFile/Minidump/MinidumpFileBuilder.cpp

@@ -976,7 +976,7 @@ Status MinidumpFileBuilder::ReadWriteMemoryInChunks(
   Log *log = GetLog(LLDBLog::Object);
   Status addDataError;
   Process::ReadMemoryChunkCallback callback =
-      [&](Status &error, DataBufferHeap &data, lldb::addr_t current_addr,
+      [&](Status &error, const void *buf, lldb::addr_t current_addr,
           uint64_t bytes_to_read,
           uint64_t bytes_read_for_chunk) -> lldb_private::IterationAction {
     if (error.Fail() || bytes_read_for_chunk == 0) {
@@ -1000,7 +1000,7 @@ Status MinidumpFileBuilder::ReadWriteMemoryInChunks(
     // This error will be captured by the outer scope and is considered fatal.
     // If we get an error writing to disk we can't easily guarauntee that we
     // won't corrupt the minidump.
-    addDataError = AddData(data_buffer.GetBytes(), bytes_read_for_chunk);
+    addDataError = AddData(buf, bytes_read_for_chunk);
     if (addDataError.Fail())
       return lldb_private::IterationAction::Stop;
 
@@ -1022,8 +1022,8 @@ Status MinidumpFileBuilder::ReadWriteMemoryInChunks(
 
   const lldb::addr_t addr = range.range.start();
   const lldb::addr_t size = range.range.size();
-  bytes_read =
-      m_process_sp->ReadMemoryInChunks(addr, data_buffer, size, callback);
+  bytes_read = m_process_sp->ReadMemoryInChunks(
+      addr, data_buffer.GetBytes(), data_buffer.GetByteSize(), size, callback);
   return addDataError;
 }
 

lldb/source/Target/Process.cpp

@@ -2233,27 +2233,28 @@ size_t Process::ReadMemoryFromInferior(addr_t addr, void *buf, size_t size,
   return bytes_read;
 }
 
-size_t Process::ReadMemoryInChunks(lldb::addr_t vm_addr, DataBufferHeap &data,
-                                   size_t size, ReadMemoryChunkCallback callback) {
-  // Safety check to prevent an infinite loop.
-  if (data.GetByteSize() == 0)
-    return 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, data.GetByteSize());
-    const lldb::addr_t current_addr = vm_addr + bytes_read;
-    const size_t bytes_read_for_chunk =
-        ReadMemoryFromInferior(current_addr,
-                                 data.GetBytes(), bytes_to_read, error);
-
-    if (callback(error, data, current_addr, bytes_to_read, bytes_read_for_chunk) == IterationAction::Stop)
-      break;
+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;
 
     bytes_read += bytes_read_for_chunk;
     // If the bytes read in this chunk would cause us to overflow, something