Move to void* buffer instead of data buffer heap

Author: Jlalond

lldb/include/lldb/Target/Process.h

@@ -396,11 +396,11 @@ class Process : public std::enable_shared_from_this<Process>,
     return GetStaticBroadcasterClass();
   }
 
-/// A notification structure that can be used by clients to listen
-/// for changes in a process's lifetime.
-///
-/// \see RegisterNotificationCallbacks (const Notifications&) @see
-/// UnregisterNotificationCallbacks (const Notifications&)
+  /// A notification structure that can be used by clients to listen
+  /// for changes in a process's lifetime.
+  ///
+  /// \see RegisterNotificationCallbacks (const Notifications&) @see
+  /// UnregisterNotificationCallbacks (const Notifications&)
   typedef struct {
     void *baton;
     void (*initialize)(void *baton, Process *process);
@@ -771,7 +771,7 @@ class Process : public std::enable_shared_from_this<Process>,
   ///
   /// \return
   ///     The constant reference to the member m_image_tokens.
-  const std::vector<lldb::addr_t>& GetImageTokens() { return m_image_tokens; }
+  const std::vector<lldb::addr_t> &GetImageTokens() { return m_image_tokens; }
 
   /// Get the image information address for the current process.
   ///
@@ -801,32 +801,32 @@ class Process : public std::enable_shared_from_this<Process>,
   /// public clients.
   virtual void WillPublicStop() {}
 
-/// Register for process and thread notifications.
-///
-/// Clients can register notification callbacks by filling out a
-/// Process::Notifications structure and calling this function.
-///
-/// \param[in] callbacks
-///     A structure that contains the notification baton and
-///     callback functions.
-///
-/// \see Process::Notifications
+  /// Register for process and thread notifications.
+  ///
+  /// Clients can register notification callbacks by filling out a
+  /// Process::Notifications structure and calling this function.
+  ///
+  /// \param[in] callbacks
+  ///     A structure that contains the notification baton and
+  ///     callback functions.
+  ///
+  /// \see Process::Notifications
   void RegisterNotificationCallbacks(const Process::Notifications &callbacks);
 
-/// Unregister for process and thread notifications.
-///
-/// Clients can unregister notification callbacks by passing a copy of the
-/// original baton and callbacks in \a callbacks.
-///
-/// \param[in] callbacks
-///     A structure that contains the notification baton and
-///     callback functions.
-///
-/// \return
-///     Returns \b true if the notification callbacks were
-///     successfully removed from the process, \b false otherwise.
-///
-/// \see Process::Notifications
+  /// Unregister for process and thread notifications.
+  ///
+  /// Clients can unregister notification callbacks by passing a copy of the
+  /// original baton and callbacks in \a callbacks.
+  ///
+  /// \param[in] callbacks
+  ///     A structure that contains the notification baton and
+  ///     callback functions.
+  ///
+  /// \return
+  ///     Returns \b true if the notification callbacks were
+  ///     successfully removed from the process, \b false otherwise.
+  ///
+  /// \see Process::Notifications
   bool UnregisterNotificationCallbacks(const Process::Notifications &callbacks);
 
   //==================================================================
@@ -1592,14 +1592,13 @@ 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
   // is important if it's a partial read
   // 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 &,
+  typedef std::function<IterationAction(lldb_private::Status &, const void *,
                                         lldb::addr_t, uint64_t, uint64_t)>
       ReadMemoryChunkCallback;
 
@@ -1611,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[out] buf
+  ///     A byte buffer that is at least \a chunk_size bytes long that
+  ///     will receive the memory bytes.
+  ///
+  /// \param[in] chunk_size
+  ///     The chunk size to use when reading, a local buffer will be created
+  ///     with a pointer passed to the callback
   ///
   /// \param[in] size
   ///     The number of bytes to read.
@@ -1628,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
   ///
@@ -1944,8 +1948,7 @@ class Process : public std::enable_shared_from_this<Process>,
   ///
   /// \return
   ///     An error value.
-  virtual Status
-  GetMemoryRegions(lldb_private::MemoryRegionInfos &region_list);
+  virtual Status GetMemoryRegions(lldb_private::MemoryRegionInfos &region_list);
 
   /// Get the number of watchpoints supported by this target.
   ///
@@ -2286,14 +2289,12 @@ class Process : public std::enable_shared_from_this<Process>,
   // If we are waiting to stop that will return control to the user,
   // then we also want to run SelectMostRelevantFrame, which is controlled
   // by "select_most_relevant".
-  lldb::StateType
-  WaitForProcessToStop(const Timeout<std::micro> &timeout,
-                       lldb::EventSP *event_sp_ptr = nullptr,
-                       bool wait_always = true,
-                       lldb::ListenerSP hijack_listener = lldb::ListenerSP(),
-                       Stream *stream = nullptr, bool use_run_lock = true,
-                       SelectMostRelevant select_most_relevant =
-                           DoNoSelectMostRelevantFrame);
+  lldb::StateType WaitForProcessToStop(
+      const Timeout<std::micro> &timeout, lldb::EventSP *event_sp_ptr = nullptr,
+      bool wait_always = true,
+      lldb::ListenerSP hijack_listener = lldb::ListenerSP(),
+      Stream *stream = nullptr, bool use_run_lock = true,
+      SelectMostRelevant select_most_relevant = DoNoSelectMostRelevantFrame);
 
   uint32_t GetIOHandlerID() const { return m_iohandler_sync.GetValue(); }
 
@@ -2394,17 +2395,17 @@ class Process : public std::enable_shared_from_this<Process>,
 
   void SetDynamicCheckers(DynamicCheckerFunctions *dynamic_checkers);
 
-/// Prune ThreadPlanStacks for unreported threads.
-///
-/// \param[in] tid
-///     The tid whose Plan Stack we are seeking to prune.
-///
-/// \return
-///     \b true if the TID is found or \b false if not.
-bool PruneThreadPlansForTID(lldb::tid_t tid);
+  /// Prune ThreadPlanStacks for unreported threads.
+  ///
+  /// \param[in] tid
+  ///     The tid whose Plan Stack we are seeking to prune.
+  ///
+  /// \return
+  ///     \b true if the TID is found or \b false if not.
+  bool PruneThreadPlansForTID(lldb::tid_t tid);
 
-/// Prune ThreadPlanStacks for all unreported threads.
-void PruneThreadPlans();
+  /// Prune ThreadPlanStacks for all unreported threads.
+  void PruneThreadPlans();
 
   /// Find the thread plan stack associated with thread with \a tid.
   ///
@@ -3093,7 +3094,7 @@ void PruneThreadPlans();
     PreResumeCallbackAndBaton(PreResumeActionCallback in_callback,
                               void *in_baton)
         : callback(in_callback), baton(in_baton) {}
-    bool operator== (const PreResumeCallbackAndBaton &rhs) {
+    bool operator==(const PreResumeCallbackAndBaton &rhs) {
       return callback == rhs.callback && baton == rhs.baton;
     }
   };
@@ -3114,26 +3115,26 @@ void PruneThreadPlans();
   lldb::ListenerSP m_private_state_listener_sp; // This is the listener for the
                                                 // private state thread.
   HostThread m_private_state_thread; ///< Thread ID for the thread that watches
-                                     ///internal state events
+                                     /// internal state events
   ProcessModID m_mod_id; ///< Tracks the state of the process over stops and
-                         ///other alterations.
+                         /// other alterations.
   uint32_t m_process_unique_id; ///< Each lldb_private::Process class that is
-                                ///created gets a unique integer ID that
-                                ///increments with each new instance
+                                /// created gets a unique integer ID that
+                                /// increments with each new instance
   uint32_t m_thread_index_id;   ///< Each thread is created with a 1 based index
-                                ///that won't get re-used.
+                                /// that won't get re-used.
   std::map<uint64_t, uint32_t> m_thread_id_to_index_id_map;
   int m_exit_status; ///< The exit status of the process, or -1 if not set.
   std::string m_exit_string; ///< A textual description of why a process exited.
   std::mutex m_exit_status_mutex; ///< Mutex so m_exit_status m_exit_string can
-                                  ///be safely accessed from multiple threads
+                                  /// be safely accessed from multiple threads
   std::recursive_mutex m_thread_mutex;
   ThreadList m_thread_list_real; ///< The threads for this process as are known
-                                 ///to the protocol we are debugging with
+                                 /// to the protocol we are debugging with
   ThreadList m_thread_list; ///< The threads for this process as the user will
-                            ///see them. This is usually the same as
+                            /// see them. This is usually the same as
   ///< m_thread_list_real, but might be different if there is an OS plug-in
-  ///creating memory threads
+  /// creating memory threads
   ThreadPlanStackMap m_thread_plans; ///< This is the list of thread plans for
                                      /// threads in m_thread_list, as well as
                                      /// threads we knew existed, but haven't
@@ -3142,16 +3143,16 @@ void PruneThreadPlans();
       m_extended_thread_list; ///< Constituent for extended threads that may be
                               /// generated, cleared on natural stops
   lldb::RunDirection m_base_direction; ///< ThreadPlanBase run direction
-  uint32_t m_extended_thread_stop_id; ///< The natural stop id when
-                                      ///extended_thread_list was last updated
+  uint32_t m_extended_thread_stop_id;  ///< The natural stop id when
+                                       /// extended_thread_list was last updated
   QueueList
       m_queue_list; ///< The list of libdispatch queues at a given stop point
   uint32_t m_queue_list_stop_id; ///< The natural stop id when queue list was
-                                 ///last fetched
+                                 /// last fetched
   StopPointSiteList<lldb_private::WatchpointResource>
       m_watchpoint_resource_list; ///< Watchpoint resources currently in use.
   std::vector<Notifications> m_notifications; ///< The list of notifications
-                                              ///that this process can deliver.
+                                              /// that this process can deliver.
   std::vector<lldb::addr_t> m_image_tokens;
   StopPointSiteList<lldb_private::BreakpointSite>
       m_breakpoint_site_list; ///< This is the list of breakpoint

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;
 }