[win] Resolve the module only if there isn't one already

[stella.stamenova]

Summary

This commit modifies the OnLoadModule method to resolve the module
unless we already have one

Change by Hui Huang to fix the failing LLDB tests on Windows

source/Plugins/DynamicLoader/Windows-DYLD/DynamicLoaderWindowsDYLD.h

public:
 
   static void Initialize();
   static void Terminate();
   static ConstString GetPluginNameStatic();
   static const char *GetPluginDescriptionStatic();
 
   static DynamicLoader *CreateInstance(Process *process, bool force);
 
-  void OnLoadModule(const ModuleSpec &module_spec, lldb::addr_t module_addr);
+  void OnLoadModule(lldb::ModuleSP module_sp, const ModuleSpec module_spec,
+                    lldb::addr_t module_addr);
   void OnUnloadModule(lldb::addr_t module_addr);
 
   void DidAttach() override;
   void DidLaunch() override;
   Status CanLoadImage() override;
   lldb::ThreadPlanSP GetStepThroughTrampolinePlan(Thread &thread,
                                                   bool stop) override;
 

source/Plugins/DynamicLoader/Windows-DYLD/DynamicLoaderWindowsDYLD.cpp

DynamicLoader *DynamicLoaderWindowsDYLD::CreateInstance(Process *process,
   }
 
   if (should_create)
     return new DynamicLoaderWindowsDYLD(process);
 
   return nullptr;
 }
 
-void DynamicLoaderWindowsDYLD::OnLoadModule(const ModuleSpec &module_spec,
+void DynamicLoaderWindowsDYLD::OnLoadModule(lldb::ModuleSP module_sp,
+                                            const ModuleSpec module_spec,
                                             lldb::addr_t module_addr) {
+
+  // Resolve the module unless we already have one.
+  if (!module_sp) {
     // Confusingly, there is no Target::AddSharedModule.  Instead, calling
     // GetSharedModule() with a new module will add it to the module list and
     // return a corresponding ModuleSP.
     Status error;
-  ModuleSP module_sp =
-      m_process->GetTarget().GetSharedModule(module_spec, &error);
+    module_sp = m_process->GetTarget().GetSharedModule(module_spec, &error);
     if (error.Fail())
       return;
+  }
 
   m_loaded_modules[module_sp] = module_addr;
   UpdateLoadedSectionsCommon(module_sp, module_addr, false);
+  ModuleList module_list;
+  module_list.Append(module_sp);
+  m_process->GetTarget().ModulesDidLoad(module_list);
 }
 
 void DynamicLoaderWindowsDYLD::OnUnloadModule(lldb::addr_t module_addr) {
   Address resolved_addr;
   if (!m_process->GetTarget().ResolveLoadAddress(module_addr, resolved_addr))
     return;
 
   ModuleSP module_sp = resolved_addr.GetModule();
   if (module_sp) {
     m_loaded_modules.erase(module_sp);
     UnloadSectionsCommon(module_sp);
+    ModuleList module_list;
+    module_list.Append(module_sp);
+    m_process->GetTarget().ModulesDidUnload(module_list, false);
   }
 }
 
 lldb::addr_t DynamicLoaderWindowsDYLD::GetLoadAddress(ModuleSP executable) {
   // First, see if the load address is already cached.
   auto it = m_loaded_modules.find(executable);
   if (it != m_loaded_modules.end() && it->second != LLDB_INVALID_ADDRESS)
     return it->second;

source/Plugins/Process/Windows/Common/ProcessWindows.cpp

if (!module) {
     if (!module) {
       return;
     }
 
     GetTarget().SetExecutableModule(module, eLoadDependentsNo);
   }
 
   if (auto dyld = GetDynamicLoader())
-    dyld->OnLoadModule(
-        ModuleSpec(module->GetFileSpec(), module->GetArchitecture()),
-        image_base);
+    dyld->OnLoadModule(module, ModuleSpec(), image_base);
 
   // Add the main executable module to the list of pending module loads.  We
   // can't call GetTarget().ModulesDidLoad() here because we still haven't
   // returned from DoLaunch() / DoAttach() yet so the target may not have set
   // the process instance to `this` yet.
   llvm::sys::ScopedLock lock(m_mutex);
   const HostThreadWindows &wmain_thread =
       debugger->GetMainThread().GetNativeThread();
if (iter != m_session_data->m_new_threads.end())
     m_session_data->m_new_threads.erase(iter);
   else
     m_session_data->m_exited_threads.insert(thread_id);
 }
 
 void ProcessWindows::OnLoadDll(const ModuleSpec &module_spec,
                                lldb::addr_t module_addr) {
   if (auto dyld = GetDynamicLoader())
-    dyld->OnLoadModule(module_spec, module_addr);
+    dyld->OnLoadModule(nullptr, module_spec, module_addr);
 }
 
 void ProcessWindows::OnUnloadDll(lldb::addr_t module_addr) {
   if (auto dyld = GetDynamicLoader())
     dyld->OnUnloadModule(module_addr);
 }
 
 void ProcessWindows::OnDebugString(const std::string &string) {}