Move WindowsDYLD to the Plugins/DynamicLoader directory.

[sas]

Summary

This commit moves the Windows DyanamicLoader to the common DynamicLoader
directory. This is required to remote debug Windows targets.

This commit also initializes the Windows DYLD plugin in
SystemInitializerCommon (similarly to both POSIX and MacOSX DYLD
plugins) so that we can automatically instantiate this class when
connected to a windows process.

[sas]

Friendly ping.

[labath]

I think @zturner is still on holiday, but maybe @amccarth can help you with this.

[amccarth]

Looks straightforward. LGTM.

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

1 ↗

(On Diff #28901)

You lost the '.' before the 'h'.

[sas]

Thanks for the review.

lldb/trunk/cmake/LLDBDependencies.cmake

set( LLDB_USED_LIBS
 
   # Plugins
   lldbPluginDisassemblerLLVM
   lldbPluginSymbolFileDWARF
   lldbPluginSymbolFileSymtab
   lldbPluginDynamicLoaderStatic
   lldbPluginDynamicLoaderPosixDYLD
   lldbPluginDynamicLoaderHexagonDYLD
+  lldbPluginDynamicLoaderWindowsDYLD
 
   lldbPluginObjectFileELF
   lldbPluginObjectFileJIT
   lldbPluginSymbolVendorELF
   lldbPluginObjectContainerBSDArchive
   lldbPluginObjectContainerMachOArchive
   lldbPluginProcessGDBRemote
   lldbPluginProcessUtility

lldb/trunk/source/API/SystemInitializerFull.cpp

 #endif
 
 #if defined(__FreeBSD__)
 #include "Plugins/Process/FreeBSD/ProcessFreeBSD.h"
 #endif
 
 #if defined(_MSC_VER)
 #include "lldb/Host/windows/windows.h"
-#include "Plugins/Process/Windows/DynamicLoaderWindows.h"
 #include "Plugins/Process/Windows/ProcessWindows.h"
 #endif
 
 #if !defined(LLDB_DISABLE_PYTHON)
 #include "lldb/Interpreter/ScriptInterpreterPython.h"
 #endif
 
 #include "llvm/Support/TargetSelect.h"
SystemInitializerFull::Initialize()
     SymbolFileDWARFDebugMap::Initialize();
     ItaniumABILanguageRuntime::Initialize();
     AppleObjCRuntimeV2::Initialize();
     AppleObjCRuntimeV1::Initialize();
     SystemRuntimeMacOSX::Initialize();
     RenderScriptRuntime::Initialize();
 
 #if defined(_MSC_VER)
-    DynamicLoaderWindows::Initialize();
     ProcessWindows::Initialize();
 #endif
 #if defined(__FreeBSD__)
     ProcessFreeBSD::Initialize();
 #endif
 #if defined(__APPLE__)
     SymbolVendorMacOSX::Initialize();
     ProcessKDP::Initialize();
SystemInitializerFull::Terminate()
     SystemRuntimeMacOSX::Terminate();
     RenderScriptRuntime::Terminate();
 
 #if defined(__APPLE__)
     ProcessMachCore::Terminate();
     ProcessKDP::Terminate();
     SymbolVendorMacOSX::Terminate();
 #endif
-#if defined(_MSC_VER)
-    DynamicLoaderWindows::Terminate();
-#endif
 
 #if defined(__FreeBSD__)
     ProcessFreeBSD::Terminate();
 #endif
     Debugger::SettingsTerminate();
 
     platform_gdb_server::PlatformRemoteGDBServer::Terminate();
     process_gdb_remote::ProcessGDBRemote::Terminate();

lldb/trunk/source/Initialization/SystemInitializerCommon.cpp

 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Core/Log.h"
 #include "lldb/Core/Timer.h"
 #include "lldb/Interpreter/ScriptInterpreterPython.h"
 
 #include "Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.h"
 #include "Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.h"
+#include "Plugins/DynamicLoader/Windows-DYLD/DynamicLoaderWindowsDYLD.h"
 #include "Plugins/Instruction/ARM/EmulateInstructionARM.h"
 #include "Plugins/Instruction/MIPS/EmulateInstructionMIPS.h"
 #include "Plugins/Instruction/MIPS64/EmulateInstructionMIPS64.h"
 #include "Plugins/ObjectContainer/BSD-Archive/ObjectContainerBSDArchive.h"
 #include "Plugins/ObjectContainer/Universal-Mach-O/ObjectContainerUniversalMachO.h"
 #include "Plugins/ObjectFile/ELF/ObjectFileELF.h"
 #include "Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.h"
 #include "Plugins/OperatingSystem/Python/OperatingSystemPython.h"
#endif
 
     process_gdb_remote::ProcessGDBRemoteLog::Initialize();
 
     // Initialize plug-ins
     ObjectContainerBSDArchive::Initialize();
     ObjectFileELF::Initialize();
     ObjectFilePECOFF::Initialize();
     DynamicLoaderPOSIXDYLD::Initialize();
+    DynamicLoaderWindowsDYLD::Initialize();
     platform_freebsd::PlatformFreeBSD::Initialize();
     platform_linux::PlatformLinux::Initialize();
     PlatformWindows::Initialize();
     PlatformKalimba::Initialize();
     platform_android::PlatformAndroid::Initialize();
 
     EmulateInstructionARM::Initialize();
     EmulateInstructionMIPS::Initialize();

 void
 SystemInitializerCommon::Terminate()
 {
     Timer scoped_timer(__PRETTY_FUNCTION__, __PRETTY_FUNCTION__);
     ObjectContainerBSDArchive::Terminate();
     ObjectFileELF::Terminate();
     ObjectFilePECOFF::Terminate();
     DynamicLoaderPOSIXDYLD::Terminate();
+    DynamicLoaderWindowsDYLD::Terminate();
     platform_freebsd::PlatformFreeBSD::Terminate();
     platform_linux::PlatformLinux::Terminate();
     PlatformWindows::Terminate();
     PlatformKalimba::Terminate();
     platform_android::PlatformAndroid::Terminate();
     DynamicLoaderMacOSXDYLD::Terminate();
     ObjectContainerUniversalMachO::Terminate();
     PlatformMacOSX::Terminate();

lldb/trunk/source/Plugins/DynamicLoader/CMakeLists.txt

 add_subdirectory(MacOSX-DYLD)
 add_subdirectory(POSIX-DYLD)
 add_subdirectory(Static)
 add_subdirectory(Hexagon-DYLD)
+add_subdirectory(Windows-DYLD)
 
 if (CMAKE_SYSTEM_NAME MATCHES "Darwin")
   add_subdirectory(Darwin-Kernel)
 endif()
-

lldb/trunk/source/Plugins/DynamicLoader/Windows-DYLD/CMakeLists.txt

+set(LLVM_NO_RTTI 1)
+
+add_lldb_library(lldbPluginDynamicLoaderWindowsDYLD
+  DynamicLoaderWindowsDYLD.cpp
+  )

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

+//===-- DynamicLoaderWindowsDYLDh ----------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_Plugins_Process_Windows_DynamicLoaderWindowsDYLD_H_
+#define liblldb_Plugins_Process_Windows_DynamicLoaderWindowsDYLD_H_
+
+#include "lldb/lldb-forward.h"
+#include "lldb/Target/DynamicLoader.h"
+
+namespace lldb_private
+{
+
+class DynamicLoaderWindowsDYLD : public DynamicLoader
+{
+  public:
+    DynamicLoaderWindowsDYLD(Process *process);
+    virtual ~DynamicLoaderWindowsDYLD();
+
+    static void Initialize();
+    static void Terminate();
+    static ConstString GetPluginNameStatic();
+    static const char *GetPluginDescriptionStatic();
+
+    static DynamicLoader *CreateInstance(Process *process, bool force);
+
+    void DidAttach () override;
+    void DidLaunch () override;
+    Error CanLoadImage () override;
+    lldb::ThreadPlanSP GetStepThroughTrampolinePlan(Thread &thread, bool stop) override;
+
+    ConstString GetPluginName() override;
+    uint32_t GetPluginVersion() override;
+};
+
+}
+
+#endif

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

+//===-- DynamicLoaderWindowsDYLD.cpp --------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "DynamicLoaderWindowsDYLD.h"
+
+#include "lldb/Core/PluginManager.h"
+#include "lldb/Target/Process.h"
+#include "lldb/Target/Target.h"
+
+#include "llvm/ADT/Triple.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+DynamicLoaderWindowsDYLD::DynamicLoaderWindowsDYLD(Process *process)
+    : DynamicLoader(process)
+{
+
+}
+
+DynamicLoaderWindowsDYLD::~DynamicLoaderWindowsDYLD()
+{
+
+}
+
+void DynamicLoaderWindowsDYLD::Initialize()
+{
+    PluginManager::RegisterPlugin(GetPluginNameStatic(),
+                                  GetPluginDescriptionStatic(),
+                                  CreateInstance);
+}
+
+void DynamicLoaderWindowsDYLD::Terminate()
+{
+
+}
+
+ConstString DynamicLoaderWindowsDYLD::GetPluginNameStatic()
+{
+    static ConstString g_plugin_name("windows-dyld");
+    return g_plugin_name;
+}
+
+const char *DynamicLoaderWindowsDYLD::GetPluginDescriptionStatic()
+{
+    return "Dynamic loader plug-in that watches for shared library "
+           "loads/unloads in Windows processes.";
+}
+
+
+DynamicLoader *DynamicLoaderWindowsDYLD::CreateInstance(Process *process, bool force)
+{
+    bool should_create = force;
+    if (!should_create)
+    {
+        const llvm::Triple &triple_ref = process->GetTarget().GetArchitecture().GetTriple();
+        if (triple_ref.getOS() == llvm::Triple::Win32)
+            should_create = true;
+    }
+
+    if (should_create)
+        return new DynamicLoaderWindowsDYLD (process);
+
+    return nullptr;
+}
+
+void DynamicLoaderWindowsDYLD::DidAttach()
+{
+
+}
+
+void DynamicLoaderWindowsDYLD::DidLaunch()
+{
+
+}
+
+Error DynamicLoaderWindowsDYLD::CanLoadImage()
+{
+    return Error();
+}
+
+ConstString DynamicLoaderWindowsDYLD::GetPluginName()
+{
+    return GetPluginNameStatic();
+}
+
+uint32_t DynamicLoaderWindowsDYLD::GetPluginVersion()
+{
+    return 1;
+}
+
+ThreadPlanSP
+DynamicLoaderWindowsDYLD::GetStepThroughTrampolinePlan(Thread &thread, bool stop)
+{
+    return ThreadPlanSP();
+}

lldb/trunk/source/Plugins/Process/Windows/CMakeLists.txt

 set(LLVM_NO_RTTI 1)
 
 include_directories(.)
 include_directories(../Utility)
 
 set(PROC_WINDOWS_SOURCES
   DebuggerThread.cpp
-  DynamicLoaderWindows.cpp
   LocalDebugDelegate.cpp
   ProcessWindows.cpp
   ProcessWindowsLog.cpp
   RegisterContextWindows.cpp
   TargetThreadWindows.cpp
   )
 
 if (CMAKE_SIZEOF_VOID_P EQUAL 4)

lldb/trunk/source/Plugins/Process/Windows/DynamicLoaderWindows.h

-//===-- DynamicLoaderWindows.h ----------------------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef liblldb_Plugins_Process_Windows_DynamicLoaderWindows_H_
-#define liblldb_Plugins_Process_Windows_DynamicLoaderWindows_H_
-
-#include "lldb/lldb-forward.h"
-#include "lldb/Target/DynamicLoader.h"
-
-namespace lldb_private
-{
-
-class DynamicLoaderWindows : public DynamicLoader
-{
-  public:
-    DynamicLoaderWindows(Process *process);
-    virtual ~DynamicLoaderWindows();
-
-    static void Initialize();
-    static void Terminate();
-    static ConstString GetPluginNameStatic();
-    static const char *GetPluginDescriptionStatic();
-
-    static DynamicLoader *CreateInstance(Process *process, bool force);
-
-    void DidAttach () override;
-    void DidLaunch () override;
-    Error CanLoadImage () override;
-    lldb::ThreadPlanSP GetStepThroughTrampolinePlan(Thread &thread, bool stop) override;
-
-    ConstString GetPluginName() override;
-    uint32_t GetPluginVersion() override;
-};
-
-}
-
-#endif

lldb/trunk/source/Plugins/Process/Windows/DynamicLoaderWindows.cpp

-//===-- DynamicLoaderWindows.cpp --------------------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "DynamicLoaderWindows.h"
-#include "ProcessWindowsLog.h"
-
-#include "lldb/Core/PluginManager.h"
-#include "lldb/Target/Process.h"
-#include "lldb/Target/Target.h"
-
-#include "llvm/ADT/Triple.h"
-
-using namespace lldb;
-using namespace lldb_private;
-
-DynamicLoaderWindows::DynamicLoaderWindows(Process *process)
-    : DynamicLoader(process)
-{
-
-}
-
-DynamicLoaderWindows::~DynamicLoaderWindows()
-{
-}
-
-void DynamicLoaderWindows::Initialize()
-{
-    PluginManager::RegisterPlugin(GetPluginNameStatic(),
-                                  GetPluginDescriptionStatic(),
-                                  CreateInstance);
-}
-
-void DynamicLoaderWindows::Terminate()
-{
-
-}
-
-ConstString DynamicLoaderWindows::GetPluginNameStatic()
-{
-    static ConstString g_plugin_name("windows-dyld");
-    return g_plugin_name;
-}
-
-const char *DynamicLoaderWindows::GetPluginDescriptionStatic()
-{
-    return "Dynamic loader plug-in that watches for shared library "
-           "loads/unloads in Windows processes.";
-}
-
-
-DynamicLoader *DynamicLoaderWindows::CreateInstance(Process *process, bool force)
-{
-    bool should_create = force;
-    if (!should_create)
-    {
-        const llvm::Triple &triple_ref = process->GetTarget().GetArchitecture().GetTriple();
-        if (triple_ref.getOS() == llvm::Triple::Win32)
-            should_create = true;
-    }
-
-    if (should_create)
-        return new DynamicLoaderWindows (process);
-
-    return nullptr;
-}
-
-void DynamicLoaderWindows::DidAttach()
-{
-
-}
-
-void DynamicLoaderWindows::DidLaunch()
-{
-
-}
-
-Error DynamicLoaderWindows::CanLoadImage()
-{
-    return Error();
-}
-
-ConstString DynamicLoaderWindows::GetPluginName()
-{
-    return GetPluginNameStatic();
-}
-
-uint32_t DynamicLoaderWindows::GetPluginVersion()
-{
-    return 1;
-}
-
-ThreadPlanSP
-DynamicLoaderWindows::GetStepThroughTrampolinePlan(Thread &thread, bool stop)
-{
-    return ThreadPlanSP();
-}