[lldb] Remove orphaned modules in a loop

[teemperor]

Summary

When modules reference each other (which happens for example with the different modules LLDB loads
when debugging -gmodules-compiled binaries), just iterating over the module list once isn't good enough
to find all orphans. Any removed modules in the module list will also clear up the shared pointers they
hold to other modules, so after any module was removed from the list, LLDB should iterate again and
check if any additional modules can no be safely deleted.

This is currently causing that many gmodules tests are not cleaning up all allocated modules which causes
cleanup asserts to fail (right now these asserts just mark the test as unsupported, but after D83865 the
tests will start failing).

[JDevlieghere]

Makes sense, the RemoveOrphans should be idempotent if nothing else changed.

[aprantl]

lldb/source/Core/ModuleList.cpp

298

bool made_progress = false;
while (!made_progress) {
  ...
}

[teemperor]

• Refactored loop away from while (true) (thanks Adrian!)

[shafik]

Thank you for this fix!

lldb/source/Core/ModuleList.cpp

size_t ModuleList::RemoveOrphans(bool mandatory) {
 
   if (mandatory) {
     lock.lock();
   } else {
     // Not mandatory, remove orphans if we can get the mutex
     if (!lock.try_lock())
       return 0;
   }
-  collection::iterator pos = m_modules.begin();
   size_t remove_count = 0;
+  // Modules might hold shared pointers to other modules, so removing one
+  // module might make other other modules orphans. Keep removing modules until
+  // there are no further modules that can be removed.
+  while (true) {
+    bool made_progress = false;
+    collection::iterator pos = m_modules.begin();
     while (pos != m_modules.end()) {
       if (pos->unique()) {
         pos = RemoveImpl(pos);
         ++remove_count;
+        made_progress = true;
       } else {
         ++pos;
       }
     }
+    if (!made_progress)
+      break;
+  }
   return remove_count;
 }
 
 size_t ModuleList::Remove(ModuleList &module_list) {
   std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
   size_t num_removed = 0;
   collection::iterator pos, end = module_list.m_modules.end();
   for (pos = module_list.m_modules.begin(); pos != end; ++pos) {