[lldb] Do not deallocate memory after exec

[bulbazord]

Summary

After an exec has occured, resources used to manage the state of a
Process are cleaned up. One such resource is the AllocatedMemoryCache
which keeps track of memory allocations made in the process for things
like expression evaluation. After an exec is performed, the allocated
memory regions in the process are gone, so it does not make sense to try
to deallocate those regions.

rdar://103188106

[jasonmolenda]

lldb/source/Target/Memory.cpp

337

Should we comment that if we've just exec'ed, the inferior is a new process and does not have these memory regions allocated.

[bulbazord]

lldb/source/Target/Memory.cpp

337

Yeah, I think that would be helpful.

[bulbazord]

Add a comment explaining why we do not dealloc after exec

[jingham]

It doesn't seem unreasonable that in the course of time we'll come across another circumstance where it's not worth deallocating these memory regions (for instance, we really don't need to do that if we're planning to kill the process). So it seems awkward to encode this particular reason in the Memory::Clear function. I think it would be better to have the parameter be "deallocate_memory", and then move the comment to Process::DidExec.

[bulbazord]

Address @jingham's comments

[jasonmolenda]

LGTM. Jim?

[jingham]

LGTM, thanks!

lldb/include/lldb/Target/Memory.h

 // some memory in a process that is being debugged.
 class AllocatedMemoryCache {
 public:
   // Constructors and Destructors
   AllocatedMemoryCache(Process &process);
 
   ~AllocatedMemoryCache();
 
-  void Clear();
+  void Clear(bool deallocate_memory);
 
   lldb::addr_t AllocateMemory(size_t byte_size, uint32_t permissions,
                               Status &error);
 
   bool DeallocateMemory(lldb::addr_t ptr);
 
 protected:
   typedef std::shared_ptr<AllocatedBlock> AllocatedBlockSP;

lldb/source/Target/Memory.cpp

bool AllocatedBlock::FreeBlock(addr_t addr) {
   return success;
 }
 
 AllocatedMemoryCache::AllocatedMemoryCache(Process &process)
     : m_process(process), m_mutex(), m_memory_map() {}
 
 AllocatedMemoryCache::~AllocatedMemoryCache() = default;
 
-void AllocatedMemoryCache::Clear() {
+void AllocatedMemoryCache::Clear(bool deallocate_memory) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
-  if (m_process.IsAlive()) {
+  if (m_process.IsAlive() && deallocate_memory) {
     PermissionsToBlockMap::iterator pos, end = m_memory_map.end();
     for (pos = m_memory_map.begin(); pos != end; ++pos)
       m_process.DoDeallocateMemory(pos->second->GetBaseAddress());
   }
   m_memory_map.clear();
 }
 
 AllocatedMemoryCache::AllocatedBlockSP

lldb/source/Target/Process.cpp

void Process::Finalize() {
   m_thread_list.Destroy();
   m_extended_thread_list.Destroy();
   m_queue_list.Clear();
   m_queue_list_stop_id = 0;
   std::vector<Notifications> empty_notifications;
   m_notifications.swap(empty_notifications);
   m_image_tokens.clear();
   m_memory_cache.Clear();
-  m_allocated_memory_cache.Clear();
+  m_allocated_memory_cache.Clear(/*deallocate_memory=*/true);
   {
     std::lock_guard<std::recursive_mutex> guard(m_language_runtimes_mutex);
     m_language_runtimes.clear();
   }
   m_instrumentation_runtimes.clear();
   m_next_event_action_up.reset();
   // Clear the last natural stop ID since it has a strong reference to this
   // process
void Process::DidExec() {
   target.ClearModules(false);
   m_dynamic_checkers_up.reset();
   m_abi_sp.reset();
   m_system_runtime_up.reset();
   m_os_up.reset();
   m_dyld_up.reset();
   m_jit_loaders_up.reset();
   m_image_tokens.clear();
-  m_allocated_memory_cache.Clear();
+  // After an exec, the inferior is a new process and these memory regions are
+  // no longer allocated.
+  m_allocated_memory_cache.Clear(/*deallocte_memory=*/false);
   {
     std::lock_guard<std::recursive_mutex> guard(m_language_runtimes_mutex);
     m_language_runtimes.clear();
   }
   m_instrumentation_runtimes.clear();
   m_thread_list.DiscardThreadPlans();
   m_memory_cache.Clear(true);
   DoDidExec();