[lldb] Inform every language runtime of the modified modules

[JDevlieghere]

Summary

When a process is notified that modules got loaded, currently only existing language runtimes are given a chance to deal with that. This means that if the runtime for a given language wasn't needed before it won't be informed of the module chance. This is wrong because the module change might be what triggers the need for a certain runtime. Instead, we should give the language runtime for every supported language a chance to deal with the modified modules.

[teemperor]

(Mea culpa, I thought the Swift recognizers would be as trivial to fix as the upstream ones)

[jingham]

LGTM

[clayborg]

LGTM with a few nits that can be fixed if needed

lldb/source/Target/Process.cpp

5762–5764

remove braces?

5772–5774

remove braces now that this is just a single line

lldb/source/Target/Process.cpp

if (!CallVoidArgVoidPtrReturn(address, function_addr)) {
       m_resolved_indirect_addresses.insert(
           std::pair<addr_t, addr_t>(addr, function_addr));
     }
   }
   return function_addr;
 }
 
 void Process::ModulesDidLoad(ModuleList &module_list) {
+  // Inform the system runtime of the modified modules.
   SystemRuntime *sys_runtime = GetSystemRuntime();
-  if (sys_runtime) {
+  if (sys_runtime)
     sys_runtime->ModulesDidLoad(module_list);
-  }
 
   GetJITLoaders().ModulesDidLoad(module_list);
 
-  // Give runtimes a chance to be created.
+  // Give the instrumentation runtimes a chance to be created before informing
+  // them of the modified modules.
   InstrumentationRuntime::ModulesDidLoad(module_list, this,
                                          m_instrumentation_runtimes);
+  for (auto &runtime : m_instrumentation_runtimes)
+    runtime.second->ModulesDidLoad(module_list);
 
-  // Tell runtimes about new modules.
-  for (auto pos = m_instrumentation_runtimes.begin();
-       pos != m_instrumentation_runtimes.end(); ++pos) {
-    InstrumentationRuntimeSP runtime = pos->second;
+  // Give the language runtimes a chance to be created before informing them of
+  // the modified modules.
+  for (const lldb::LanguageType lang_type : Language::GetSupportedLanguages()) {
+    if (LanguageRuntime *runtime = GetLanguageRuntime(lang_type))
       runtime->ModulesDidLoad(module_list);
   }
 
-  // Let any language runtimes we have already created know about the modules
-  // that loaded.
-
-  // Iterate over a copy of this language runtime list in case the language
-  // runtime ModulesDidLoad somehow causes the language runtime to be
-  // unloaded.
-  {
-    std::lock_guard<std::recursive_mutex> guard(m_language_runtimes_mutex);
-    LanguageRuntimeCollection language_runtimes(m_language_runtimes);
-    for (const auto &pair : language_runtimes) {
-      // We must check language_runtime_sp to make sure it is not nullptr as we
-      // might cache the fact that we didn't have a language runtime for a
-      // language.
-      LanguageRuntimeSP language_runtime_sp = pair.second;
-      if (language_runtime_sp)
-        language_runtime_sp->ModulesDidLoad(module_list);
-    }
-  }
-
   // If we don't have an operating system plug-in, try to load one since
   // loading shared libraries might cause a new one to try and load
   if (!m_os_up)
     LoadOperatingSystemPlugin(false);
 
-  // Give structured-data plugins a chance to see the modified modules.
+  // Inform the structured-data plugins of the modified modules.
   for (auto pair : m_structured_data_plugin_map) {
     if (pair.second)
       pair.second->ModulesDidLoad(*this, module_list);
   }
 }
 
 void Process::PrintWarning(uint64_t warning_type, const void *repeat_key,
                            const char *fmt, ...) {