Implement basic DidAttach and DidLaunch for DynamicLoaderWindowsDYLD

[lanza]

Summary

This commit implements basic DidAttach and DidLaunch for the windows
DynamicLoader plugin which allow us to load shared libraries from the
inferior.

[lanza]

This is https://reviews.llvm.org/D39314 with a test included.

[zturner]

Glad to see this finally getting committed, thanks!

[Hui]

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

75

I think DynamicLoaderWindowsDYLD::DidAttach & DidLaunch are intended for remote debugging. As the similar functionalities have been done in ProcessWindows::DidLaunch & DidAttach, the test in here is actually testing those native ones and they happen to be correct.

102

A remote debugging shows if the 'qFileLoadAddress' remote packet is not implemented or incorrectly handled, GetFileLoadAddress by the remote process will return error resulting base_addr stay '0. Since you are calling with the last argument 'false' to indicate it is not an offset, that will be an issue. Better to move it to line 99 and check if the load_addr is LLDB_INVALID_ADDRESS.

Moreover, if the load_addr is changed, make sure all the breakpoint address is recalculated. This feature could be a little bit complicated.

[zturner]

I had to revert this because it breaks many tests on Windows (found by
bisecting). It was reverted in r347174.

You can reproduce one of the failures by building with this patch applied,
then doing python bin/llvm-lit.py -sv ~/src/lldb/lit/SymbolFile/PDB.

2 of the tests should fail and you see an error about unable to read memory
location.

packages/Python/lldbsuite/test/functionalities/windows_dyld/Makefile

+LEVEL := ../../make
+
+LD_EXTRAS := -ldllfunc
+C_SOURCES := main.c
+
+include $(LEVEL)/Makefile.rules
+
+a.out: dllfunc
+
+dllfunc:
+  $(MAKE) VERBOSE=1 VPATH=$(SRCDIR) -I $(SRCDIR) -f $(SRCDIR)/dllfunc.mk
+
+clean::
+  $(MAKE) -f $(SRCDIR)/dllfunc.mk clean

packages/Python/lldbsuite/test/functionalities/windows_dyld/TestWindowsDYLD.py

+"""
+Test that breakpoints work in a DLL
+"""
+
+from __future__ import print_function
+
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+
+@skipUnlessWindows
+class WindowsDLLTestCase(TestBase):
+    def setUP(self):
+        TestBase.setUp(self)
+        self.build()
+
+    def test_dll_linking(self):
+        """test that the debugger works with DLLs"""
+
+        exe = self.getBuildArtifact("a.out")
+        target = self.dbg.CreateTarget(exe)
+        self.assertTrue(target and target.IsValid(), "Target is valid")
+
+        self.runCmd("breakpoint set --file main.c --line 16")
+        self.runCmd("breakpoint set --file dllfunc.c --line 18")
+
+        process = target.LaunchSimple(None, None, self.get_process_working_directory())
+
+        self.expect("p x", "16")
+        self.runCmd("thread step-out")
+        self.expect("p x", "16")
+        self.expect("thread step-in")
+        self.expect("thread step-in")
+        self.expect("p n", "8")
+        self.runCmd("c")
+        self.expect("p x", "64")
+        self.runCmd("breakpoint delete 2")
+        self.runCmd("c")
+
+        self.assertEqual(process.GetExitStatus(), 336, PROCESS_EXITED)

packages/Python/lldbsuite/test/functionalities/windows_dyld/dllfunc.c

+//===-- a.c -----------------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include <windows.h>
+
+BOOL WINAPI DllMain(HINSTANCE h, DWORD reason, void* reserved) {
+  return TRUE;
+}
+
+int __declspec(dllexport) DllFunc(int n) {
+  int x = n * n;  
+  return x;  // set breakpoint here
+}

packages/Python/lldbsuite/test/functionalities/windows_dyld/dllfunc.mk

+LEVEL := ../../make
+
+DYLIB_NAME := dllfunc
+DYLIB_C_SOURCES := dllfunc.c
+DYLIB_ONLY := YES
+
+include $(LEVEL)/Makefile.rules

packages/Python/lldbsuite/test/functionalities/windows_dyld/main.c

+//===-- main.c --------------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include <windows.h>
+
+int __declspec(dllimport) DllFunc(int n);
+
+int main(int argc, char ** argv) {
+  int x = DllFunc(4);
+  int y = DllFunc(8);   // set breakpoint here
+  int z = DllFunc(16);
+  return x + y + z;
+}

packages/Python/lldbsuite/test/make/Makefile.rules

 ifeq "$(DYLIB_ONLY)" ""
 $(EXE) : $(OBJECTS) $(ARCHIVE_NAME) $(DYLIB_FILENAME)
   $(LD) $(OBJECTS) $(ARCHIVE_NAME) -L. -l$(DYLIB_NAME) $(LDFLAGS) -o "$(EXE)"
 else
 EXE = $(DYLIB_FILENAME)
 endif
 else
 $(EXE) : $(OBJECTS) $(ARCHIVE_NAME)
-  $(LD) $(OBJECTS) $(LDFLAGS) $(ARCHIVE_NAME) -o "$(EXE)"
+  "$(LD)" $(OBJECTS) $(LDFLAGS) $(ARCHIVE_NAME) -o "$(EXE)"
 ifneq "$(CODESIGN)" ""
   $(CODESIGN) -s - "$(EXE)"
 endif
 endif
 
 #----------------------------------------------------------------------
 # Make the dSYM file from the executable if $(MAKE_DSYM) != "NO"
 #----------------------------------------------------------------------
ifneq "$(CODESIGN)" ""
   $(CODESIGN) -s - "$(DYLIB_FILENAME)"
 endif
 ifneq "$(MAKE_DSYM)" "NO"
 ifneq "$(DS)" ""
   "$(DS)" $(DSFLAGS) "$(DYLIB_FILENAME)"
 endif
 endif
 else
-  $(LD) $(DYLIB_OBJECTS) $(LDFLAGS) -shared -o "$(DYLIB_FILENAME)"
+  "$(LD)" $(DYLIB_OBJECTS) $(LDFLAGS) -shared -o "$(DYLIB_FILENAME)"
 ifeq "$(SPLIT_DEBUG_SYMBOLS)" "YES"
   $(OBJCOPY) --only-keep-debug "$(DYLIB_FILENAME)" "$(DYLIB_FILENAME).debug"
   $(OBJCOPY) --strip-debug --add-gnu-debuglink="$(DYLIB_FILENAME).debug" "$(DYLIB_FILENAME)" "$(DYLIB_FILENAME)"
 endif
 endif
 
 #----------------------------------------------------------------------
 # Make the precompiled header and compile C++ sources against it

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/Module.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/ThreadPlanStepInstruction.h"
+#include "lldb/Utility/Log.h"
 
 #include "llvm/ADT/Triple.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 DynamicLoaderWindowsDYLD::DynamicLoaderWindowsDYLD(Process *process)
     : DynamicLoader(process) {}
DynamicLoader *DynamicLoaderWindowsDYLD::CreateInstance(Process *process,
   }
 
   if (should_create)
     return new DynamicLoaderWindowsDYLD(process);
 
   return nullptr;
 }
 
-void DynamicLoaderWindowsDYLD::DidAttach() {}
+void DynamicLoaderWindowsDYLD::DidAttach() {
+  Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
+  if (log)
+    log->Printf("DynamicLoaderWindowsDYLD::%s()", __FUNCTION__);
 
-void DynamicLoaderWindowsDYLD::DidLaunch() {}
+  DidLaunch();
+
+  m_process->LoadModules();
+}
+
+void DynamicLoaderWindowsDYLD::DidLaunch() {
+  Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
+  if (log)
+    log->Printf("DynamicLoaderWindowsDYLD::%s()", __FUNCTION__);
+
+  ModuleSP executable = GetTargetExecutable();
+
+  if (!executable.get())
+    return;
+
+  // Try to fetch the load address of the file from the process, since there
+  // could be randomization of the load address.
+
+  // It might happen that the remote has a different dir for the file, so we
+  // only send the basename of the executable in the query. I think this is safe
+  // because I doubt that two executables with the same basenames are loaded in
+  // memory...
+  FileSpec file_spec(
+      executable->GetPlatformFileSpec().GetFilename().GetCString());
+  bool is_loaded;
+  addr_t base_addr = 0;
+  lldb::addr_t load_addr;
+  Status error = m_process->GetFileLoadAddress(file_spec, is_loaded, load_addr);
+  if (error.Success() && is_loaded) {
+    base_addr = load_addr;
+  }
+
+  UpdateLoadedSections(executable, LLDB_INVALID_ADDRESS, base_addr, false);
+
+  ModuleList module_list;
+  module_list.Append(executable);
+  m_process->GetTarget().ModulesDidLoad(module_list);
+}
 
 Status DynamicLoaderWindowsDYLD::CanLoadImage() { return Status(); }
 
 ConstString DynamicLoaderWindowsDYLD::GetPluginName() {
   return GetPluginNameStatic();
 }
 
 uint32_t DynamicLoaderWindowsDYLD::GetPluginVersion() { return 1; }