macros: work towards supporting macros on Windows

Start fleshing out some of the executor path for supporting Windows with
macros.

Author: compnerd

include/swift/AST/PluginRegistry.h

@@ -53,13 +53,11 @@ class LoadedExecutablePlugin {
   /// Represents the current process of the executable plugin.
   struct PluginProcess {
     const llvm::sys::procid_t pid;
-    const int inputFileDescriptor;
-    const int outputFileDescriptor;
+    const void *input;
+    const void *output;
     bool isStale = false;
 
-    PluginProcess(llvm::sys::procid_t pid, int inputFileDescriptor,
-                  int outputFileDescriptor);
-
+    PluginProcess(llvm::sys::procid_t pid, void *input, void *output);
     ~PluginProcess();
 
     ssize_t write(const void *buf, size_t nbyte) const;

include/swift/Basic/Program.h

@@ -40,14 +40,12 @@ int ExecuteInPlace(const char *Program, const char **args,
                    const char **env = nullptr);
 
 struct ChildProcessInfo {
-  llvm::sys::procid_t Pid;
-  int WriteFileDescriptor;
-  int ReadFileDescriptor;
+  llvm::sys::ProcessInfo ProcessInfo;
+  void *Write;
+  void *Read;
 
-  ChildProcessInfo(llvm::sys::procid_t Pid, int WriteFileDescriptor,
-                   int ReadFileDescriptor)
-      : Pid(Pid), WriteFileDescriptor(WriteFileDescriptor),
-        ReadFileDescriptor(ReadFileDescriptor) {}
+  ChildProcessInfo(llvm::sys::ProcessInfo ProcessInfo, void *Write, void *Read)
+      : ProcessInfo(ProcessInfo), Write(Write), Read(Read) {}
 };
 
 /// This function executes the program using the argument provided.

lib/AST/PluginLoader.cpp

@@ -41,8 +41,13 @@ PluginRegistry *PluginLoader::getRegistry() {
 static StringRef pluginModuleNameStringFromPath(StringRef path) {
   // Plugin library must be named 'lib${module name}(.dylib|.so|.dll)'.
   // FIXME: Shared library prefix might be different between platforms.
+#if defined(_WIN32)
+  constexpr StringRef libPrefix{};
+  constexpr StringRef libSuffix = ".dll";
+#else
   constexpr StringRef libPrefix = "lib";
   constexpr StringRef libSuffix = LTDL_SHLIB_EXT;
+#endif
 
   StringRef filename = llvm::sys::path::filename(path);
   if (filename.starts_with(libPrefix) && filename.ends_with(libSuffix)) {

lib/AST/PluginRegistry.cpp

@@ -75,7 +75,9 @@ void *LoadedLibraryPlugin::getAddressOfSymbol(const char *symbolName) {
   auto &cached = resolvedSymbols[symbolName];
   if (cached)
     return cached;
-#if !defined(_WIN32)
+#if defined(_WIN32)
+  cached = GetProcAddress(static_cast<HMODULE>(handle), symbolName);
+#else
   cached = dlsym(handle, symbolName);
 #endif
   return cached;
@@ -153,9 +155,8 @@ llvm::Error LoadedExecutablePlugin::spawnIfNeeded() {
     return llvm::errorCodeToError(childInfo.getError());
   }
 
-  Process = std::make_unique<PluginProcess>(childInfo->Pid,
-                                            childInfo->ReadFileDescriptor,
-                                            childInfo->WriteFileDescriptor);
+  Process = std::make_unique<PluginProcess>(childInfo->ProcessInfo.Pid,
+                                            childInfo->Read, childInfo->Write);
 
   // Call "on reconnect" callbacks.
   for (auto *callback : onReconnect) {
@@ -166,14 +167,14 @@ llvm::Error LoadedExecutablePlugin::spawnIfNeeded() {
 }
 
 LoadedExecutablePlugin::PluginProcess::PluginProcess(llvm::sys::procid_t pid,
-                                                     int inputFileDescriptor,
-                                                     int outputFileDescriptor)
-    : pid(pid), inputFileDescriptor(inputFileDescriptor),
-      outputFileDescriptor(outputFileDescriptor) {}
+                                                     HANDLE input,
+                                                     HANDLE output)
+    : pid(pid), input(input),
+      output(output) {}
 
 LoadedExecutablePlugin::PluginProcess::~PluginProcess() {
-  close(inputFileDescriptor);
-  close(outputFileDescriptor);
+  CloseHandle((HANDLE)input);
+  CloseHandle((HANDLE)output);
 }
 
 LoadedExecutablePlugin::~LoadedExecutablePlugin() {
@@ -184,6 +185,18 @@ LoadedExecutablePlugin::~LoadedExecutablePlugin() {
 
 ssize_t LoadedExecutablePlugin::PluginProcess::read(void *buf,
                                                     size_t nbyte) const {
+  size_t read = 0;
+  while (read < nbyte) {
+    DWORD NumberOfBytesRead = 0;
+    BOOL bSuccess = ReadFile((HANDLE)input,
+                             (char *)buf + read, nbyte - read,
+                             &NumberOfBytesRead, NULL);
+    if (bSuccess == FALSE && NumberOfBytesRead == 0)
+      return read;
+    read += NumberOfBytesRead;
+  }
+  return read;
+#if 0
   ssize_t bytesToRead = nbyte;
   void *ptr = buf;
 
@@ -206,10 +219,24 @@ ssize_t LoadedExecutablePlugin::PluginProcess::read(void *buf,
   }
 
   return nbyte - bytesToRead;
+#endif
+  return 0;
 }
 
 ssize_t LoadedExecutablePlugin::PluginProcess::write(const void *buf,
                                                      size_t nbyte) const {
+  size_t written = 0;
+  while (written < nbyte) {
+    DWORD NumberOfBytesWritten = 0;
+    BOOL bSuccess = WriteFile((HANDLE)output,
+                              (const char *)buf + written, nbyte - written,
+                              &NumberOfBytesWritten, NULL);
+    if (bSuccess == FALSE && NumberOfBytesWritten == 0)
+      return written;
+    written += NumberOfBytesWritten;
+  }
+  return written;
+#if 0
   ssize_t bytesToWrite = nbyte;
   const void *ptr = buf;
 
@@ -231,6 +258,7 @@ ssize_t LoadedExecutablePlugin::PluginProcess::write(const void *buf,
     bytesToWrite -= writtenSize;
   }
   return nbyte - bytesToWrite;
+#endif
 }
 
 llvm::Error LoadedExecutablePlugin::sendMessage(llvm::StringRef message) const {

lib/Basic/Program.cpp

@@ -17,6 +17,7 @@
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Config/config.h"
 #include "llvm/Support/Allocator.h"
+#include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/Program.h"
 
 #include <system_error>
@@ -29,6 +30,11 @@
 #include <unistd.h>
 #endif
 
+#if defined(_WIN32)
+#define WIN32_LEAN_AND_MEAN
+#include <Windows.h>
+#endif
+
 using namespace swift;
 
 int swift::ExecuteInPlace(const char *Program, const char **args,
@@ -178,6 +184,54 @@ swift::ExecuteWithPipe(llvm::StringRef program,
   return ChildProcessInfo(pid, p1.write, p2.read);
 }
 
+#elif defined(_WIN32)
+
+llvm::ErrorOr<swift::ChildProcessInfo>
+swift::ExecuteWithPipe(llvm::StringRef program,
+                       llvm::ArrayRef<llvm::StringRef> args,
+                       llvm::Optional<llvm::ArrayRef<llvm::StringRef>> env) {
+  enum { PI_READ, PI_WRITE };
+
+  HANDLE input[2] = {INVALID_HANDLE_VALUE,INVALID_HANDLE_VALUE};
+  HANDLE output[2] = {INVALID_HANDLE_VALUE,INVALID_HANDLE_VALUE};
+  SECURITY_ATTRIBUTES saAttrs{sizeof(SECURITY_ATTRIBUTES), NULL, TRUE};
+
+  if (!CreatePipe(&output[PI_READ], &output[PI_WRITE], &saAttrs, 0))
+    return std::error_code(GetLastError(), std::system_category());
+
+  if (!SetHandleInformation(output[PI_READ], HANDLE_FLAG_INHERIT, FALSE))
+    return std::error_code(GetLastError(), std::system_category());
+
+  if (!CreatePipe(&input[PI_READ], &input[PI_WRITE], &saAttrs, 0))
+    return std::error_code(GetLastError(), std::system_category());
+
+  if (!SetHandleInformation(input[PI_WRITE], HANDLE_FLAG_INHERIT, FALSE))
+    return std::error_code(GetLastError(), std::system_category());
+
+  STARTUPINFO si = {0};
+  si.cb = sizeof(si);
+  si.hStdInput = input[PI_READ];
+  si.hStdOutput = output[PI_WRITE];
+  si.hStdError = output[PI_WRITE];
+  si.dwFlags = STARTF_USESTDHANDLES;
+
+  llvm::SmallVector<llvm::UTF16, 261> converted;
+  llvm::convertUTF8ToUTF16String(program, converted);
+  converted.push_back(L'\0');
+  PROCESS_INFORMATION pi = {0};
+  if (!CreateProcess((LPWSTR)converted.data(), NULL, NULL, NULL, TRUE, 0, NULL, NULL,
+                     &si, &pi))
+    return std::error_code(GetLastError(), std::system_category());
+
+  CloseHandle(input[PI_READ]);
+  CloseHandle(output[PI_WRITE]);
+  CloseHandle(pi.hThread);
+
+  llvm::sys::ProcessInfo proc;
+  proc.Process = pi.hProcess;
+  return ChildProcessInfo(proc, input[PI_WRITE], output[PI_READ]);
+}
+
 #else // HAVE_UNISTD_H
 
 llvm::ErrorOr<swift::ChildProcessInfo>