Windows: support `DoLoadImage`

[compnerd]

Summary

This implements DoLoadImage and UnloadImage in the Windows platform
plugin modelled after the POSIX platform plugin. This was previously
unimplemented and resulted in a difficult to decipher error without any
logging.

This implementation is intended to support enables the use of LLDB's
Swift REPL on Windows.

Paths which are added to the library search path are persistent and
applied to all subsequent loads. This can be adjusted in the future by
storing all the cookies and restoring the path prior to returning from
the helper. However, the dynamic path count makes this a bit more
challenging.

[labath]

We have some existing tests (functionalities/load_using_paths/TestLoadUsingPaths.py) for this functionality, but they are are all skipped on windows. Can you check if they work now, or create a new test for the subset of functionality which does work?

Ideally, the user input would be converted from UTF-8 to UTF-16.

Would it be possible to do the conversion within lldb (llvm::ConvertUTF8toWide), and pass that as a prebaked string?

[compnerd]

Thanks for the hint about the string conversion, however, I think that it's going to complicate things as the string is going to be a mixture of UTF-8 and UTF-16 content.

As to the testing, functionalities/load_using_paths/TestLoadUsingPaths.py is not applicable to Windows. In fact, I don't really see a good way to really test much of this outside the context of the swift REPL which forces the loading of a DLL which is in fact how I discovered this. If there is an easy way to ensure that the dll that is needed is in the user's PATH, then I suppose creating an empty dll and loading that is theoretically possible, but that too can have a lot of flakiness due to dependencies to build and all.

[labath]

In D77287#1957472, @compnerd wrote:

Thanks for the hint about the string conversion, however, I think that it's going to complicate things as the string is going to be a mixture of UTF-8 and UTF-16 content.

That's true. Ok, plan B: have clang do the conversion for us. If you form the expression like printf("LoadLibraryW(L\"%s\")", path_in_utf8) then the path will get transformed to utf-16 by the compiler. However the path should also get sanitized/escaped into a form suitable for passing to the C compiler. (godbolt link)

As to the testing, functionalities/load_using_paths/TestLoadUsingPaths.py is not applicable to Windows. In fact, I don't really see a good way to really test much of this outside the context of the swift REPL which forces the loading of a DLL which is in fact how I discovered this. If there is an easy way to ensure that the dll that is needed is in the user's PATH, then I suppose creating an empty dll and loading that is theoretically possible, but that too can have a lot of flakiness due to dependencies to build and all.

Ok, so your patch does not implement that functionality. It does not sound like there's a fundamental limitation there, as you could do the same thing as what the posix code does ( == iterate over the path), but that's fine -- you don't need to implement everything straight away. In that case it would be good to check that the paths argument is empty and return an error instead of attempting to load a random library.

However, I believe you are implementing sufficient functionality for the SBProcess::LoadImage (aka "process load" in CLI) command. So, maybe you could take a look at API/functionalities/load_unload/TestLoadUnload.py and see if anything there can be enabled ? Or (if the test contains too many posix specifics), you could could create a windows version of that test doing something similar.

[compnerd]

Okay, thanks to some help from @JDevlieghere I was able to get a test going for this. I think that the basic test is sufficient for this. I think that the path sanitizing and conversion should be a subsequent change.

[JDevlieghere]

lldb/test/Shell/Process/Windows/process_load.cpp

4

We should probably have a lit.local.cfg in the Windows directory with

if 'system-windows' not in config.available_features:
  config.unsupported = True

[compnerd]

lldb/test/Shell/Process/Windows/process_load.cpp

4

I think that's a good idea, but, should be a separate change - it isn't related to the load/unload functionality.

[labath]

In D77287#1960390, @compnerd wrote:

I think that the basic test is sufficient for this.

That test does not seem to be exercising the "unload" part of this patch. It would also be nice to run some basic command like "image list" to verify that the loaded binary is indeed listed.

(I don't really have a hard objection to this being a lit test, but it does sound to me like at that point, this will be reimplementing TestLoadUnload.py)

I think that the path sanitizing and conversion should be a subsequent change.

Why is that? The need for sanitation is a direct consequence of how you've chosen to implement this patch -- the posix version of this function does not do sanitation, but it does not need to, as it does not embed the library name into the compiled expression. I can see how the support for wide strings might be considered a separate feature, but given that supporting that is a matter of adding a single L to the compiled expression, I don't see a problem with including that here.

[compnerd]

This comment was removed by compnerd.

[compnerd]

In D77287#1963242, @labath wrote:

In D77287#1960390, @compnerd wrote:

I think that the basic test is sufficient for this.

That test does not seem to be exercising the "unload" part of this patch. It would also be nice to run some basic command like "image list" to verify that the loaded binary is indeed listed.

(I don't really have a hard objection to this being a lit test, but it does sound to me like at that point, this will be reimplementing TestLoadUnload.py)

I think that the path sanitizing and conversion should be a subsequent change.

Why is that? The need for sanitation is a direct consequence of how you've chosen to implement this patch -- the posix version of this function does not do sanitation, but it does not need to, as it does not embed the library name into the compiled expression. I can see how the support for wide strings might be considered a separate feature, but given that supporting that is a matter of adding a single L to the compiled expression, I don't see a problem with including that here.

Actually, it changes the APIs used and the path that this goes down on the Windows side, so it has a much broader impact than it appears.

[compnerd]

This is a more complete implementation that allows for error reporting and use of UCS-2 as that is needed for the search path alteration.

[compnerd]

Fix build rules

[compnerd]

Add missing null-terminators.

[JDevlieghere]

I can't speak to the correctness of the Windows parts, but all the utility function stuff looks sane to me. LGTM if Pavel has no outstanding objections.

lldb/source/Plugins/Platform/Windows/PlatformWindows.h

47–51

I know it's an override, but what a horrible interface...

lldb/test/Shell/Process/Windows/process_load.cpp

4

Fair enough

[compnerd]

lldb/source/Plugins/Platform/Windows/PlatformWindows.h

47–51

I completely agree.

lldb/test/Shell/Process/Windows/process_load.cpp

4

I already pushed that change, so it's already taken care of, but it is not part of the set of changes :)

[thakis]

lldb/source/Plugins/Platform/Windows/PlatformWindows.cpp

397

../../lldb/source/Plugins/Platform/Windows/PlatformWindows.cpp:397:62: warning: format specifies type 'unsigned long' but the argument has type 'uint64_t' (aka 'unsigned long long') [-Wformat]
    error.SetErrorStringWithFormat("LoadLibrary Error: %lu", error_code);
                                                       ~~~   ^~~~~~~~~~
                                                       %llu

[compnerd]

Thanks @thakis - 906e60b9f923464cba0f71a9205846550752162f should have addressed that from a few days ago (sorry about not mentioning that here)

lldb/source/Plugins/Platform/Windows/CMakeLists.txt

 add_lldb_library(lldbPluginPlatformWindows PLUGIN
   PlatformWindows.cpp
 
    LINK_LIBS
     lldbBreakpoint
     lldbCore
     lldbHost
     lldbTarget
+
+   LINK_COMPONENTS
+    Support
   )

lldb/source/Plugins/Platform/Windows/PlatformWindows.h

public:
   llvm::StringRef GetDescription() override {
     return GetPluginDescriptionStatic(IsHost());
   }
 
   lldb_private::Status ConnectRemote(lldb_private::Args &args) override;
 
   lldb_private::Status DisconnectRemote() override;
 
+  uint32_t DoLoadImage(lldb_private::Process *process,
+                       const lldb_private::FileSpec &remote_file,
+                       const std::vector<std::string> *paths,
+                       lldb_private::Status &error,
+                       lldb_private::FileSpec *loaded_path) override;
+
+  lldb_private::Status UnloadImage(lldb_private::Process *process,
+                                   uint32_t image_token) override;
+
   lldb::ProcessSP DebugProcess(lldb_private::ProcessLaunchInfo &launch_info,
                                lldb_private::Debugger &debugger,
                                lldb_private::Target &target,
                                lldb_private::Status &error) override;
 
   lldb::ProcessSP Attach(lldb_private::ProcessAttachInfo &attach_info,
                          lldb_private::Debugger &debugger,
                          lldb_private::Target *target,
public:
   void CalculateTrapHandlerSymbolNames() override {}
 
   ConstString GetFullNameForDylib(ConstString basename) override;
 
   size_t GetSoftwareBreakpointTrapOpcode(Target &target,
                                          BreakpointSite *bp_site) override;
 
   std::vector<ArchSpec> m_supported_architectures;
+
+private:
+  std::unique_ptr<lldb_private::UtilityFunction>
+  MakeLoadImageUtilityFunction(lldb_private::ExecutionContext &context,
+                               lldb_private::Status &status);
+
+  lldb_private::Status EvaluateLoaderExpression(lldb_private::Process *process,
+                                                const char *expression,
+                                                lldb::ValueObjectSP &value);
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_PLATFORM_WINDOWS_PLATFORMWINDOWS_H

lldb/source/Plugins/Platform/Windows/PlatformWindows.cpp

 #include <winsock2.h>
 #endif
 
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Breakpoint/BreakpointSite.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
+#include "lldb/Expression/DiagnosticManager.h"
+#include "lldb/Expression/FunctionCaller.h"
+#include "lldb/Expression/UserExpression.h"
+#include "lldb/Expression/UtilityFunction.h"
 #include "lldb/Host/HostInfo.h"
+#include "lldb/Target/DynamicLoader.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Utility/Status.h"
 
+#include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
+
+#include "llvm/ADT/ScopeExit.h"
+#include "llvm/Support/ConvertUTF.h"
+
 using namespace lldb;
 using namespace lldb_private;
 
 LLDB_PLUGIN_DEFINE(PlatformWindows)
 
 static uint32_t g_initialize_count = 0;
 
 PlatformSP PlatformWindows::CreateInstance(bool force,
if (IsHost()) {
 
     if (error.Fail())
       m_remote_platform_sp.reset();
   }
 
   return error;
 }
 
+uint32_t PlatformWindows::DoLoadImage(Process *process,
+                                      const FileSpec &remote_file,
+                                      const std::vector<std::string> *paths,
+                                      Status &error, FileSpec *loaded_image) {
+  DiagnosticManager diagnostics;
+
+  if (loaded_image)
+    loaded_image->Clear();
+
+  ThreadSP thread = process->GetThreadList().GetExpressionExecutionThread();
+  if (!thread) {
+    error.SetErrorString("LoadLibrary error: no thread available to invoke LoadLibrary");
+    return LLDB_INVALID_IMAGE_TOKEN;
+  }
+
+  ExecutionContext context;
+  thread->CalculateExecutionContext(context);
+
+  Status status;
+  UtilityFunction *loader =
+      process->GetLoadImageUtilityFunction(this, [&]() -> std::unique_ptr<UtilityFunction> {
+        return MakeLoadImageUtilityFunction(context, status);
+      });
+  if (loader == nullptr)
+    return LLDB_INVALID_IMAGE_TOKEN;
+
+  FunctionCaller *invocation = loader->GetFunctionCaller();
+  if (!invocation) {
+    error.SetErrorString("LoadLibrary error: could not get function caller");
+    return LLDB_INVALID_IMAGE_TOKEN;
+  }
+
+  /* Convert name */
+  llvm::SmallVector<llvm::UTF16, 261> name;
+  if (!llvm::convertUTF8ToUTF16String(remote_file.GetPath(), name)) {
+    error.SetErrorString("LoadLibrary error: could not convert path to UCS2");
+    return LLDB_INVALID_IMAGE_TOKEN;
+  }
+  name.emplace_back(L'\0');
+
+  /* Inject name paramter into inferior */
+  lldb::addr_t injected_name =
+      process->AllocateMemory(name.size() * sizeof(llvm::UTF16),
+                              ePermissionsReadable | ePermissionsWritable,
+                              status);
+  if (injected_name == LLDB_INVALID_ADDRESS) {
+    error.SetErrorStringWithFormat("LoadLibrary error: unable to allocate memory for name: %s",
+                                   status.AsCString());
+    return LLDB_INVALID_IMAGE_TOKEN;
+  }
+
+  auto name_cleanup = llvm::make_scope_exit([process, injected_name]() {
+    process->DeallocateMemory(injected_name);
+  });
+
+  process->WriteMemory(injected_name, name.data(),
+                       name.size() * sizeof(llvm::UTF16), status);
+  if (status.Fail()) {
+    error.SetErrorStringWithFormat("LoadLibrary error: unable to write name: %s",
+                                   status.AsCString());
+    return LLDB_INVALID_IMAGE_TOKEN;
+  }
+
+  /* Inject paths parameter into inferior */
+  lldb::addr_t injected_paths{0x0};
+  llvm::Optional<llvm::detail::scope_exit<std::function<void()>>> paths_cleanup;
+  if (paths) {
+    llvm::SmallVector<llvm::UTF16, 261> search_paths;
+
+    for (const auto &path : *paths) {
+      if (path.empty())
+        continue;
+
+      llvm::SmallVector<llvm::UTF16, 261> buffer;
+      if (!llvm::convertUTF8ToUTF16String(path, buffer))
+        continue;
+
+      search_paths.append(std::begin(buffer), std::end(buffer));
+      search_paths.emplace_back(L'\0');
+    }
+    search_paths.emplace_back(L'\0');
+
+    injected_paths =
+        process->AllocateMemory(search_paths.size() * sizeof(llvm::UTF16),
+                                ePermissionsReadable | ePermissionsWritable,
+                                status);
+    if (injected_paths == LLDB_INVALID_ADDRESS) {
+      error.SetErrorStringWithFormat("LoadLibrary error: unable to allocate memory for paths: %s",
+                                     status.AsCString());
+      return LLDB_INVALID_IMAGE_TOKEN;
+    }
+
+    paths_cleanup.emplace([process, injected_paths]() {
+      process->DeallocateMemory(injected_paths);
+    });
+
+    process->WriteMemory(injected_paths, search_paths.data(),
+                         search_paths.size() * sizeof(llvm::UTF16), status);
+    if (status.Fail()) {
+      error.SetErrorStringWithFormat("LoadLibrary error: unable to write paths: %s",
+                                     status.AsCString());
+      return LLDB_INVALID_IMAGE_TOKEN;
+    }
+  }
+
+  /* Inject wszModulePath into inferior */
+  // FIXME(compnerd) should do something better for the length?
+  // GetModuleFileNameA is likely limited to PATH_MAX rather than the NT path
+  // limit.
+  unsigned injected_length = 261;
+
+  lldb::addr_t injected_module_path =
+      process->AllocateMemory(injected_length + 1,
+                              ePermissionsReadable | ePermissionsWritable,
+                              status);
+  if (injected_module_path == LLDB_INVALID_ADDRESS) {
+    error.SetErrorStringWithFormat("LoadLibrary error: unable to allocate memory for module location: %s",
+                                   status.AsCString());
+    return LLDB_INVALID_IMAGE_TOKEN;
+  }
+
+  auto injected_module_path_cleanup =
+      llvm::make_scope_exit([process, injected_module_path]() {
+    process->DeallocateMemory(injected_module_path);
+  });
+
+  /* Inject __lldb_LoadLibraryResult into inferior */
+  const uint32_t word_size = process->GetAddressByteSize();
+  lldb::addr_t injected_result =
+      process->AllocateMemory(3 * word_size,
+                              ePermissionsReadable | ePermissionsWritable,
+                              status);
+  if (status.Fail()) {
+    error.SetErrorStringWithFormat("LoadLibrary error: could not allocate memory for result: %s",
+                                   status.AsCString());
+    return LLDB_INVALID_IMAGE_TOKEN;
+  }
+
+  auto result_cleanup = llvm::make_scope_exit([process, injected_result]() {
+    process->DeallocateMemory(injected_result);
+  });
+
+  process->WritePointerToMemory(injected_result + word_size,
+                                injected_module_path, status);
+  if (status.Fail()) {
+    error.SetErrorStringWithFormat("LoadLibrary error: could not initialize result: %s",
+                                   status.AsCString());
+    return LLDB_INVALID_IMAGE_TOKEN;
+  }
+
+  // XXX(compnerd) should we use the compiler to get the sizeof(unsigned)?
+  process->WriteScalarToMemory(injected_result + 2 * word_size,
+                               Scalar{injected_length}, sizeof(unsigned),
+                               status);
+  if (status.Fail()) {
+    error.SetErrorStringWithFormat("LoadLibrary error: could not initialize result: %s",
+                                   status.AsCString());
+    return LLDB_INVALID_IMAGE_TOKEN;
+  }
+
+  /* Setup Formal Parameters */
+  ValueList parameters = invocation->GetArgumentValues();
+  parameters.GetValueAtIndex(0)->GetScalar() = injected_name;
+  parameters.GetValueAtIndex(1)->GetScalar() = injected_paths;
+  parameters.GetValueAtIndex(2)->GetScalar() = injected_result;
+
+  lldb::addr_t injected_parameters = LLDB_INVALID_ADDRESS;
+  diagnostics.Clear();
+  if (!invocation->WriteFunctionArguments(context, injected_parameters,
+                                          parameters, diagnostics)) {
+    error.SetErrorStringWithFormat("LoadLibrary error: unable to write function parameters: %s",
+                                   diagnostics.GetString().c_str());
+    return LLDB_INVALID_IMAGE_TOKEN;
+  }
+
+  auto parameter_cleanup = llvm::make_scope_exit([invocation, &context, injected_parameters]() {
+    invocation->DeallocateFunctionResults(context, injected_parameters);
+  });
+
+  TypeSystemClang *ast =
+      ScratchTypeSystemClang::GetForTarget(process->GetTarget());
+  if (!ast) {
+    error.SetErrorString("LoadLibrary error: unable to get (clang) type system");
+    return LLDB_INVALID_IMAGE_TOKEN;
+  }
+
+  /* Setup Return Type */
+  CompilerType VoidPtrTy = ast->GetBasicType(eBasicTypeVoid).GetPointerType();
+
+  Value value;
+  value.SetCompilerType(VoidPtrTy);
+
+  /* Invoke expression */
+  EvaluateExpressionOptions options;
+  options.SetExecutionPolicy(eExecutionPolicyAlways);
+  options.SetLanguage(eLanguageTypeC_plus_plus);
+  options.SetIgnoreBreakpoints(true);
+  options.SetUnwindOnError(true);
+  // LoadLibraryEx{A,W}/FreeLibrary cannot raise exceptions which we can handle.
+  // They may potentially throw SEH exceptions which we do not know how to
+  // handle currently.
+  options.SetTrapExceptions(false);
+  options.SetTimeout(process->GetUtilityExpressionTimeout());
+  options.SetIsForUtilityExpr(true);
+
+  ExpressionResults result =
+      invocation->ExecuteFunction(context, &injected_parameters, options,
+                                  diagnostics, value);
+  if (result != eExpressionCompleted) {
+    error.SetErrorStringWithFormat("LoadLibrary error: failed to execute LoadLibrary helper: %s",
+                                   diagnostics.GetString().c_str());
+    return LLDB_INVALID_IMAGE_TOKEN;
+  }
+
+  /* Read result */
+  lldb::addr_t token = process->ReadPointerFromMemory(injected_result, status);
+  if (status.Fail()) {
+    error.SetErrorStringWithFormat("LoadLibrary error: could not read the result: %s",
+                                   status.AsCString());
+    return LLDB_INVALID_IMAGE_TOKEN;
+  }
+
+  if (token == NULL) {
+    // XXX(compnerd) should we use the compiler to get the sizeof(unsigned)?
+    uint64_t error_code =
+        process->ReadUnsignedIntegerFromMemory(injected_result + 2 * word_size + sizeof(unsigned),
+                                               word_size, 0, status);
+    if (status.Fail()) {
+      error.SetErrorStringWithFormat("LoadLibrary error: could not read error status: %s",
+                                     status.AsCString());
+      return LLDB_INVALID_IMAGE_TOKEN;
+    }
+
+    error.SetErrorStringWithFormat("LoadLibrary Error: %lu", error_code);
+    return LLDB_INVALID_IMAGE_TOKEN;
+  }
+
+  std::string module_path;
+  process->ReadCStringFromMemory(injected_module_path, module_path, status);
+  if (status.Fail()) {
+    error.SetErrorStringWithFormat("LoadLibrary error: could not read module path: %s",
+                                   status.AsCString());
+    return LLDB_INVALID_IMAGE_TOKEN;
+  }
+
+  if (loaded_image)
+    loaded_image->SetFile(module_path, llvm::sys::path::Style::native);
+  return process->AddImageToken(token);
+}
+
+Status PlatformWindows::UnloadImage(Process *process, uint32_t image_token) {
+  const addr_t address = process->GetImagePtrFromToken(image_token);
+  if (address == LLDB_INVALID_ADDRESS)
+    return Status("invalid image token");
+
+  StreamString expression;
+  expression.Printf("FreeLibrary((HMODULE)0x%" PRIx64 ")", address);
+
+  ValueObjectSP value;
+  Status result =
+      EvaluateLoaderExpression(process, expression.GetData(), value);
+  if (result.Fail())
+    return result;
+
+  if (value->GetError().Fail())
+    return value->GetError();
+
+  Scalar scalar;
+  if (value->ResolveValue(scalar)) {
+    if (scalar.UInt(1))
+      return Status("expression failed: \"%s\"", expression.GetData());
+    process->ResetImageToken(image_token);
+  }
+
+  return Status();
+}
+
 Status PlatformWindows::DisconnectRemote() {
   Status error;
 
   if (IsHost()) {
     error.SetErrorStringWithFormatv(
         "can't disconnect from the host platform '{0}', always connected",
         GetPluginName());
   } else {
if (bp_site->SetTrapOpcode(trap_opcode, trap_opcode_size))
       return trap_opcode_size;
     return 0;
   } break;
 
   default:
     return Platform::GetSoftwareBreakpointTrapOpcode(target, bp_site);
   }
 }
+
+std::unique_ptr<UtilityFunction>
+PlatformWindows::MakeLoadImageUtilityFunction(ExecutionContext &context,
+                                              Status &status) {
+  // FIXME(compnerd) `-fdeclspec` is not passed to the clang instance?
+  static constexpr const char kLoaderDecls[] = R"(
+extern "C" {
+// errhandlingapi.h
+
+// `LOAD_LIBRARY_SEARCH_APPLICATION_DIR | LOAD_LIBRARY_SEARCH_SYSTEM32 | LOAD_LIBRARY_SEARCH_USER_DIRS`
+//
+// Directories in the standard search path are not searched. This value cannot
+// be combined with `LOAD_WITH_ALTERED_SEARCH_PATH`.
+//
+// This value represents the recommended maximum number of directories an
+// application should include in its DLL search path.
+#define LOAD_LIBRARY_SEARCH_DEFAULT_DIRS 0x00001000
+
+// WINBASEAPI DWORD WINAPI GetLastError(VOID);
+/* __declspec(dllimport) */ uint32_t __stdcall GetLastError();
+
+// libloaderapi.h
+
+// WINBASEAPI DLL_DIRECTORY_COOKIE WINAPI AddDllDirectory(LPCWSTR);
+/* __declspec(dllimport) */ void * __stdcall AddDllDirectory(const wchar_t *);
+
+// WINBASEAPI BOOL WINAPI FreeModule(HMODULE);
+/* __declspec(dllimport) */ int __stdcall FreeModule(void *hLibModule);
+
+// WINBASEAPI DWORD WINAPI GetModuleFileNameA(HMODULE hModule, LPSTR lpFilename, DWORD nSize);
+/* __declspec(dllimport) */ uint32_t GetModuleFileNameA(void *, char *, uint32_t);
+
+// WINBASEAPI HMODULE WINAPI LoadLibraryExW(LPCWSTR, HANDLE, DWORD);
+/* __declspec(dllimport) */ void * __stdcall LoadLibraryExW(const wchar_t *, void *, uint32_t);
+
+// corecrt_wstring.h
+
+// _ACRTIMP size_t __cdecl wcslen(wchar_t const *_String);
+/* __declspec(dllimport) */ size_t __cdecl wcslen(const wchar_t *);
+
+// lldb specific code
+
+struct __lldb_LoadLibraryResult {
+  void *ImageBase;
+  char *ModulePath;
+  unsigned Length;
+  unsigned ErrorCode;
+};
+
+_Static_assert(sizeof(struct __lldb_LoadLibraryResult) <= 3 * sizeof(void *),
+               "__lldb_LoadLibraryResult size mismatch");
+
+void * __lldb_LoadLibraryHelper(const wchar_t *name, const wchar_t *paths,
+                                __lldb_LoadLibraryResult *result) {
+  for (const wchar_t *path = paths; path; ) {
+    (void)AddDllDirectory(path);
+    path += wcslen(path) + 1;
+  }
+
+  result->ImageBase = LoadLibraryExW(name, nullptr,
+                                     LOAD_LIBRARY_SEARCH_DEFAULT_DIRS);
+  if (result->ImageBase == nullptr)
+    result->ErrorCode = GetLastError();
+  else
+    result->Length = GetModuleFileNameA(result->ImageBase, result->ModulePath,
+                                        result->Length);
+
+  return result->ImageBase;
+}
+}
+  )";
+
+  static constexpr const char kName[] = "__lldb_LoadLibraryHelper";
+
+  ProcessSP process = context.GetProcessSP();
+  Target &target = process->GetTarget();
+
+  auto function = target.CreateUtilityFunction(std::string{kLoaderDecls}, kName,
+                                               eLanguageTypeC_plus_plus,
+                                               context);
+  if (!function) {
+    std::string error = llvm::toString(function.takeError());
+    status.SetErrorStringWithFormat("LoadLibrary error: could not create utility function: %s",
+                                    error.c_str());
+    return nullptr;
+  }
+
+  TypeSystemClang *ast = ScratchTypeSystemClang::GetForTarget(target);
+  if (!ast)
+    return nullptr;
+
+  CompilerType VoidPtrTy = ast->GetBasicType(eBasicTypeVoid).GetPointerType();
+  CompilerType WCharPtrTy = ast->GetBasicType(eBasicTypeWChar).GetPointerType();
+
+  ValueList parameters;
+
+  Value value;
+  value.SetValueType(Value::ValueType::Scalar);
+
+  value.SetCompilerType(WCharPtrTy);
+  parameters.PushValue(value);  // name
+  parameters.PushValue(value);  // paths
+
+  value.SetCompilerType(VoidPtrTy);
+  parameters.PushValue(value);  // result
+
+  Status error;
+  std::unique_ptr<UtilityFunction> utility{std::move(*function)};
+  utility->MakeFunctionCaller(VoidPtrTy, parameters, context.GetThreadSP(),
+                              error);
+  if (error.Fail()) {
+    status.SetErrorStringWithFormat("LoadLibrary error: could not create function caller: %s",
+                                    error.AsCString());
+    return nullptr;
+  }
+
+  if (!utility->GetFunctionCaller()) {
+    status.SetErrorString("LoadLibrary error: could not get function caller");
+    return nullptr;
+  }
+
+  return utility;
+}
+
+Status PlatformWindows::EvaluateLoaderExpression(Process *process,
+                                                 const char *expression,
+                                                 ValueObjectSP &value) {
+  // FIXME(compnerd) `-fdeclspec` is not passed to the clang instance?
+  static constexpr const char kLoaderDecls[] = R"(
+extern "C" {
+// libloaderapi.h
+
+// WINBASEAPI DLL_DIRECTORY_COOKIE WINAPI AddDllDirectory(LPCWSTR);
+/* __declspec(dllimport) */ void * __stdcall AddDllDirectory(const wchar_t *);
+
+// WINBASEAPI BOOL WINAPI FreeModule(HMODULE);
+/* __declspec(dllimport) */ int __stdcall FreeModule(void *);
+
+// WINBASEAPI DWORD WINAPI GetModuleFileNameA(HMODULE, LPSTR, DWORD);
+/* __declspec(dllimport) */ uint32_t GetModuleFileNameA(void *, char *, uint32_t);
+
+// WINBASEAPI HMODULE WINAPI LoadLibraryExW(LPCWSTR, HANDLE, DWORD);
+/* __declspec(dllimport) */ void * __stdcall LoadLibraryExW(const wchar_t *, void *, uint32_t);
+}
+  )";
+
+  if (DynamicLoader *loader = process->GetDynamicLoader()) {
+    Status result = loader->CanLoadImage();
+    if (result.Fail())
+      return result;
+  }
+
+  ThreadSP thread = process->GetThreadList().GetExpressionExecutionThread();
+  if (!thread)
+    return Status("selected thread is invalid");
+
+  StackFrameSP frame = thread->GetStackFrameAtIndex(0);
+  if (!frame)
+    return Status("frame 0 is invalid");
+
+  ExecutionContext context;
+  frame->CalculateExecutionContext(context);
+
+  EvaluateExpressionOptions options;
+  options.SetUnwindOnError(true);
+  options.SetIgnoreBreakpoints(true);
+  options.SetExecutionPolicy(eExecutionPolicyAlways);
+  options.SetLanguage(eLanguageTypeC_plus_plus);
+  // LoadLibraryEx{A,W}/FreeLibrary cannot raise exceptions which we can handle.
+  // They may potentially throw SEH exceptions which we do not know how to
+  // handle currently.
+  options.SetTrapExceptions(false);
+  options.SetTimeout(process->GetUtilityExpressionTimeout());
+
+  Status error;
+  ExpressionResults result = UserExpression::Evaluate(
+      context, options, expression, kLoaderDecls, value, error);
+  if (result != eExpressionCompleted)
+    return error;
+
+  if (value->GetError().Fail())
+    return value->GetError();
+
+  return Status();
+}

lldb/test/Shell/Process/Windows/process_load.cpp

+// clang-format off
+
+// REQUIRES: system-windows
+// RUN: %build --compiler=clang-cl -o %t.exe -- %s
+// RUN: env LLDB_USE_NATIVE_PDB_READER=1 %lldb -f %t.exe -o "b main" -o "process launch" -o "process load kernel32.dll" | FileCheck %s
+
+int main(int argc, char *argv[]) {
+  return 0;
+}
+
+// CHECK: "Loading "kernel32.dll"...ok{{.*}}
+// CHECK: Image 0 loaded.