Implement basic DidAttach and DidLaunch for DynamicLoaderWindowsDYLD

[sas]

Summary

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

This is an improved version of D12245 and should work much better.

[clayborg]

Wow. I didn't realize windows support didn't do any of this. Looks good. Zach will want to ok this as he is one of the main windows contributors.

[davide]

can you please try adding a test for this one? :)

[sas]

In D39314#908065, @davide wrote:

can you please try adding a test for this one? :)

To be fully honest, I'm not 100% sure how I'm supposed to add tests for this. I looked through the directories containing unit tests and didn't find anything specific to DYLD testing.

I'm going to try to sync with @zturner to see if he is still able to run unit tests on Windows. We exclusively debug Windows remotes from a macOS or Linux host, so I don't have any setup to run local windows tests.

[davide]

In D39314#908115, @sas wrote:

In D39314#908065, @davide wrote:

can you please try adding a test for this one? :)

To be fully honest, I'm not 100% sure how I'm supposed to add tests for this. I looked through the directories containing unit tests and didn't find anything specific to DYLD testing.

I'm going to try to sync with @zturner to see if he is still able to run unit tests on Windows. We exclusively debug Windows remotes from a macOS or Linux host, so I don't have any setup to run local windows tests.

I understand. I'm not picking on you, of course, and I appreciate you trying to do that.
From what I can tell, lack of testing can cause a lot of problems in the future [i.e. I could just remove part of your functions, and all the tests would pass anyway].
This is not ideal, from somebody who's trying to get more involved in lldb with a LLVM background :)
I think every change committed to the codebase should have a test associated, unless it's NFC.
Sorry if this sounds like captain obvious, but in case we can't test something, we might consider slowing down and revisiting the testing infrastructure that's there and improve it.
There's of course a tension between adding features and reducing technical debt, but keep checking fixes for new code without tests associated is a slippery road. Happy to discuss this further (and i know @zturner has ideas on how to fix this)

[clayborg]

Testing would include a test that dynamically loads a shared library and sets a breakpoint it in. We have these tests, but I am guessing they are disabled on windows probably because they might use "dlopen(...)" which is probably not available on windows? I know we have attach tests as well. Many tests are disabled on windows, but probably shouldn't be. So I would start looking for those tests. The code will need to be window-ized with #ifdefs and such, but it shouldn't be hard. The shared libraries tests will dynamically open a shared library and then verify we can hit a breakpoint in that shared library (a hint that the DYLD worked). So these tests don't need to be windows specific.

[zturner]

A test would be something like this:

// dll.cpp
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
}

// main.cpp
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;
}

Run main.exe in the debugger, when you're stopped at the breakpoint get the value of x and ensure that it's 4.
Step out and get the value of x and ensure that it's 8.
Step in and ensure the value of n is 8, then run and ensure the value of x is 16.
Delete the breakpoint in the dll, then run and ensure the program terminates with a return value of 56

[zturner]

Ahh, you might also run the exact same test again but where you've loaded this inside of main with LoadLibrary instead of relying on early binding by the loader.

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(), false);
+  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; }