swift-plugin-server: adjust API for portability

This begins reworking the API to be less POSIX centric and more
generally usable.  The API was defined in terms of `dlopen`/`dlsym`
rather than the better suited `llvm::sys::DynamicLibrary` APIs which
would avoid most of the work that needs to be done here for platform
specifics.  Prefer to guard that with `_WIN32` until this is fully
tested on Windows.

Author: compnerd

lib/ASTGen/Sources/ASTGen/PluginHost.swift

@@ -121,7 +121,7 @@ struct CompilerPlugin {
 
   private func sendMessage(_ message: HostToPluginMessage) throws {
     let hadError = try LLVMJSON.encoding(message) { (data) -> Bool in
-      return Plugin_sendMessage(opaqueHandle, BridgedData(baseAddress: data.baseAddress, size: UInt(data.count)))
+      return Plugin_sendMessage(opaqueHandle, BridgedData(baseAddress: data.baseAddress, size: Int(data.count)))
     }
     if hadError {
       throw PluginError.failedToSendMessage

tools/swift-plugin-server/Sources/CSwiftPluginServer/PluginServer.cpp

@@ -13,25 +13,47 @@
 #include "PluginServer.h"
 #include "swift/ABI/MetadataValues.h"
 #include "swift/Demangling/Demangle.h"
+#include "llvm/Support/ConvertUTF.h"
+#include "llvm/Support/DynamicLibrary.h"
 
+#if defined(_WIN32)
+#define WIN32_LEAN_AND_MEAN
+#include <Windows.h>
+#elif defined(__unix__) || defined(__APPLE__)
 #include <dlfcn.h>
+#include <unistd.h>
+#endif
+
 #include <errno.h>
 #include <string.h>
-#include <unistd.h>
 
 using namespace swift;
 
 namespace {
+#if defined(_WIN32)
+struct ConnectionHandle {
+  HANDLE hInput;
+  HANDLE hOutput;
+
+  ConnectionHandle(HANDLE hInput, HANDLE hOutput)
+    : hInput(hInput), hOutput(hOutput) {}
+};
+#else
 struct ConnectionHandle {
   int inputFD;
   int outputFD;
 
   ConnectionHandle(int inputFD, int outputFD)
       : inputFD(inputFD), outputFD(outputFD) {}
 };
+#endif
 } // namespace
 
 const void *PluginServer_createConnection(const char **errorMessage) {
+#if defined(_WIN32)
+  return new ConnectionHandle(GetStdHandle(STD_INPUT_HANDLE),
+                              GetStdHandle(STD_OUTPUT_HANDLE));
+#else
   // Duplicate the `stdin` file descriptor, which we will then use for
   // receiving messages from the plugin host.
   auto inputFD = dup(STDIN_FILENO);
@@ -65,37 +87,73 @@ const void *PluginServer_createConnection(const char **errorMessage) {
 
   // Open a message channel for communicating with the plugin host.
   return new ConnectionHandle(inputFD, outputFD);
+#endif
 }
 
-void PluginServer_destroyConnection(const void *connHandle) {
-  const auto *conn = static_cast<const ConnectionHandle *>(connHandle);
-  delete conn;
+void PluginServer_destroyConnection(const void *server) {
+  delete static_cast<const ConnectionHandle *>(server);
 }
 
-long PluginServer_read(const void *connHandle, void *data,
-                       unsigned long nbyte) {
-  const auto *conn = static_cast<const ConnectionHandle *>(connHandle);
+size_t PluginServer_read(const void *server, void *data, size_t nbyte) {
+  const auto *connection = static_cast<const ConnectionHandle *>(server);
+#if defined(_WIN32)
+  DWORD NumberOfBytesRead;
+  llvm::SmallVector<wchar_t> buffer(nbyte);
+  if (!ReadFile(connection->hInput, buffer.data(),
+                buffer.size() * sizeof(wchar_t), &NumberOfBytesRead, NULL))
+    return 0;
+
+  llvm::SmallVector<char> converted;
+  if (llvm::sys::windows::UTF16ToUTF8(buffer.data(), buffer.size(), converted))
+    return 0;
+  memcpy(data, converted.data(), min(nbyte, converted.size()));
+  return min(nbyte, converted.size());
+#else
   return ::read(conn->inputFD, data, nbyte);
+#endif
 }
 
-long PluginServer_write(const void *connHandle, const void *data,
-                        unsigned long nbyte) {
-  const auto *conn = static_cast<const ConnectionHandle *>(connHandle);
+size_t PluginServer_write(const void *server, const void *data, size_t nbyte) {
+  const auto *connection = static_cast<const ConnectionHandle *>(server);
+#if defined(_WIN32)
+  using namespace llvm;
+
+  SmallVector<wchar_t> buffer;
+  if (sys::windows::UTF8ToUTF16(StringRef{static_cast<const char *>(data),
+                                          static_cast<size_t>(nbyte)}, buffer))
+    return 0;
+
+  DWORD NumberOfBytesWritten;
+  if (!WriteFile(connection->hOutput, buffer.data(),
+                 buffer.size() * sizeof(wchar_t), &NumberOfBytesWritten, NULL))
+    return 0;
+  return NumberOfBytesWritten;
+#else
   return ::write(conn->outputFD, data, nbyte);
+#endif
 }
 
-void *PluginServer_dlopen(const char *filename, const char **errorMessage) {
+void *PluginServer_load(const char *filename, const char **errorMessage) {
+#if defined(_WIN32)
+  std::string error;
+  llvm::sys::DynamicLibrary library =
+      llvm::sys::DynamicLibrary::getLibrary(filename, &error);
+  if (library.isValid())
+    return library.getOSSpecificHandle();
+  *errorMessage = ::strdup(error.c_str());
+  return nullptr;
+#else
   auto *handle = ::dlopen(filename, RTLD_LAZY | RTLD_LOCAL);
   if (!handle) {
     *errorMessage = dlerror();
   }
   return handle;
+#endif
 }
 
 const void *PluginServer_lookupMacroTypeMetadataByExternalName(
     const char *moduleName, const char *typeName, void *libraryHint,
     const char **errorMessage) {
-
   // Look up the type metadata accessor as a struct, enum, or class.
   const Demangle::Node::Kind typeKinds[] = {
       Demangle::Node::Kind::Structure,
@@ -108,8 +166,13 @@ const void *PluginServer_lookupMacroTypeMetadataByExternalName(
     auto symbolName =
         mangledNameForTypeMetadataAccessor(moduleName, typeName, typeKind);
 
+#if defined(_WIN32)
+    accessorAddr = llvm::sys::DynamicLibrary{libraryHint}
+                      .getAddressOfSymbol(symbolName.c_str());
+#else
     auto *handle = libraryHint ? libraryHint : RTLD_DEFAULT;
     accessorAddr = ::dlsym(handle, symbolName.c_str());
+#endif
     if (accessorAddr)
       break;
   }

tools/swift-plugin-server/Sources/CSwiftPluginServer/include/PluginServer.h

@@ -29,18 +29,17 @@ const void *PluginServer_createConnection(const char **errorMessage);
 void PluginServer_destroyConnection(const void *connHandle);
 
 /// Read bytes from the IPC communication handle.
-long PluginServer_read(const void *connHandle, void *data, unsigned long nbyte);
+size_t PluginServer_read(const void *connHandle, void *data, size_t nbyte);
 
 /// Write bytes to the IPC communication handle.
-long PluginServer_write(const void *connHandle, const void *data,
-                        unsigned long nbyte);
+size_t PluginServer_write(const void *connHandle, const void *data, size_t nbyte);
 
 //===----------------------------------------------------------------------===//
 // Dynamic link
 //===----------------------------------------------------------------------===//
 
 /// Load a dynamic link library, and return the handle.
-void *PluginServer_dlopen(const char *filename, const char **errorMessage);
+void *PluginServer_load(const char *filename, const char **errorMessage);
 
 /// Resolve a type metadata by a pair of the module name and the type name.
 /// 'libraryHint' is a

tools/swift-plugin-server/Sources/swift-plugin-server/swift-plugin-server.swift

@@ -47,7 +47,7 @@ extension SwiftPluginServer: PluginProvider {
   /// Load a macro implementation from the dynamic link library.
   func loadPluginLibrary(libraryPath: String, moduleName: String) throws {
     var errorMessage: UnsafePointer<CChar>?
-    guard let dlHandle = PluginServer_dlopen(libraryPath, &errorMessage) else {
+    guard let dlHandle = PluginServer_load(libraryPath, &errorMessage) else {
       throw PluginServerError(message: String(cString: errorMessage!))
     }
     loadedLibraryPlugins[moduleName] = dlHandle
@@ -172,7 +172,7 @@ final class PluginHostConnection: MessageConnection {
     var ptr = buffer.baseAddress!
 
     while (bytesToWrite > 0) {
-      let writtenSize = PluginServer_write(handle, ptr, UInt(bytesToWrite))
+      let writtenSize = PluginServer_write(handle, ptr, Int(bytesToWrite))
       if (writtenSize <= 0) {
         // error e.g. broken pipe.
         break
@@ -193,7 +193,7 @@ final class PluginHostConnection: MessageConnection {
     var ptr = buffer.baseAddress!
 
     while bytesToRead > 0 {
-      let readSize = PluginServer_read(handle, ptr, UInt(bytesToRead))
+      let readSize = PluginServer_read(handle, ptr, Int(bytesToRead))
       if (readSize <= 0) {
         // 0: EOF (the host closed), -1: Broken pipe (the host crashed?)
         break;