[lldb] Tighten lock in Language::ForEach

[bulbazord]

Summary

It is easy to accidentally introduce a deadlock by having the callback
passed to Language::ForEach also attempt to acquire the same lock. It
is easy enough to disallow the callback from calling anything in
Language directly, but it may happen through a series of other
function/method calls.

The solution I am proposing is to tighten the lock in Language::ForEach
so that it is only held as we gather the currently loaded language
plugins. We store them in a vector and then iterate through them with
the callback so that the callback can't introduce a callback.

[bulbazord]

For further context, I encountered this when debugging the test failures from D108229. BreakpointResolverName::AddNameLookup constructs a Module::LookupInfo in a callback that it passes to Language::ForEach.

[clayborg]

The language map is a global that contains unique pointers to a "Language *", so the language objects are intentionally leaked because the language map is kept alive due to C++ destructor chain issues, so this should be safe.

LGTM. Anyone else have any objections?

[teemperor]

Yay! It's probably worth adding comment that callback might end up calling back into ForEach :)

lldb/source/Target/Language.cpp

 //===-- Language.cpp ------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include <functional>
 #include <map>
 #include <mutex>
 
 #include "lldb/Target/Language.h"
 
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/TypeList.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/Stream.h"
 
 #include "llvm/Support/Threading.h"
void Language::ForEach(std::function<bool(Language *)> callback) {
   static llvm::once_flag g_initialize;
   llvm::call_once(g_initialize, [] {
     for (unsigned lang = eLanguageTypeUnknown; lang < eNumLanguageTypes;
          ++lang) {
       FindPlugin(static_cast<lldb::LanguageType>(lang));
     }
   });
 
+  std::vector<Language *> loaded_plugins;
+  {
     std::lock_guard<std::mutex> guard(GetLanguagesMutex());
     LanguagesMap &map(GetLanguagesMap());
     for (const auto &entry : map) {
-    if (!callback(entry.second.get()))
+      if (entry.second)
+        loaded_plugins.push_back(entry.second.get());
+    }
+  }
+
+  for (auto *lang : loaded_plugins) {
+    if (!callback(lang))
       break;
   }
 }
 
 bool Language::IsTopLevelFunction(Function &function) { return false; }
 
 lldb::TypeCategoryImplSP Language::GetFormatters() { return nullptr; }