[Macros] PluginRegistry vends 'LoadedLibraryPlugin' instead of 'void *'

`LoadedLibraryPlugin` is currently just a wrapper of `void` pointer from
`dlopen`. This will be convenient for abstracting platform specific
dynamic linrary handling.

Author: rintaro

include/swift/AST/ASTContext.h

@@ -82,6 +82,7 @@ namespace swift {
   class ExtensionDecl;
   struct ExternalSourceLocs;
   class LoadedExecutablePlugin;
+  class LoadedLibraryPlugin;
   class ForeignRepresentationInfo;
   class FuncDecl;
   class GenericContext;
@@ -1496,7 +1497,7 @@ class ASTContext final {
   /// returns a nullptr.
   /// NOTE: This method is idempotent. If the plugin is already loaded, the same
   /// instance is simply returned.
-  void *loadLibraryPlugin(StringRef path);
+  LoadedLibraryPlugin *loadLibraryPlugin(StringRef path);
 
   /// Lookup an executable plugin that is declared to handle \p moduleName
   /// module by '-load-plugin-executable'.

include/swift/AST/PluginRegistry.h

@@ -22,6 +22,21 @@
 
 namespace swift {
 
+/// Represent a 'dlopen'ed plugin library.
+class LoadedLibraryPlugin {
+  // Opaque handle used to interface with OS-specific dynamic library.
+  void *handle;
+
+  /// Cache of loaded symbols.
+  llvm::StringMap<void *> resolvedSymbols;
+
+public:
+  LoadedLibraryPlugin(void *handle) : handle(handle) {}
+
+  /// Finds the address of the given symbol within the library.
+  void *getAddressOfSymbol(const char *symbolName);
+};
+
 /// Represent a "resolved" exectuable plugin.
 ///
 /// Plugin clients usually deal with this object to communicate with the actual
@@ -130,7 +145,7 @@ class LoadedExecutablePlugin {
 
 class PluginRegistry {
   /// Record of loaded plugin library modules.
-  llvm::StringMap<void *> LoadedPluginLibraries;
+  llvm::StringMap<std::unique_ptr<LoadedLibraryPlugin>> LoadedPluginLibraries;
 
   /// Record of loaded plugin executables.
   llvm::StringMap<std::unique_ptr<LoadedExecutablePlugin>>
@@ -146,7 +161,7 @@ class PluginRegistry {
 
   /// Load a dynamic link library specified by \p path.
   /// If \p path plugin is already loaded, this returns the cached object.
-  llvm::Expected<void *> loadLibraryPlugin(llvm::StringRef path);
+  llvm::Expected<LoadedLibraryPlugin *> loadLibraryPlugin(llvm::StringRef path);
 
   /// Load an executable plugin specified by \p path .
   /// If \p path plugin is already loaded, this returns the cached object.

include/swift/AST/TypeCheckRequests.h

@@ -50,6 +50,7 @@ class ClosureExpr;
 class GenericParamList;
 class LabeledStmt;
 class LoadedExecutablePlugin;
+class LoadedLibraryPlugin;
 class MacroDefinition;
 class PrecedenceGroupDecl;
 class PropertyWrapperInitializerInfo;
@@ -4017,15 +4018,17 @@ class LoadedCompilerPlugin {
 public:
   LoadedCompilerPlugin(std::nullptr_t) : kind(PluginKind::None), ptr(nullptr) {}
 
-  static LoadedCompilerPlugin inProcess(void *ptr) {
+  static LoadedCompilerPlugin inProcess(LoadedLibraryPlugin *ptr) {
     return {PluginKind::InProcess, ptr};
   }
   static LoadedCompilerPlugin executable(LoadedExecutablePlugin *ptr) {
     return {PluginKind::Executable, ptr};
   }
 
-  void *getAsInProcessPlugin() const {
-    return kind == PluginKind::InProcess ? ptr : nullptr;
+  LoadedLibraryPlugin *getAsInProcessPlugin() const {
+    return kind == PluginKind::InProcess
+               ? static_cast<LoadedLibraryPlugin *>(ptr)
+               : nullptr;
   }
   LoadedExecutablePlugin *getAsExecutablePlugin() const {
     return kind == PluginKind::Executable

lib/AST/ASTContext.cpp

@@ -6412,7 +6412,7 @@ LoadedExecutablePlugin *ASTContext::loadExecutablePlugin(StringRef path) {
   return plugin.get();
 }
 
-void *ASTContext::loadLibraryPlugin(StringRef path) {
+LoadedLibraryPlugin *ASTContext::loadLibraryPlugin(StringRef path) {
   // Remember the path (even if it fails to load.)
   getImpl().LoadedPluginLibraryPaths.insert(path);
 

lib/AST/PluginRegistry.cpp

@@ -44,13 +44,15 @@ PluginRegistry::PluginRegistry() {
   dumpMessaging = ::getenv("SWIFT_DUMP_PLUGIN_MESSAGING") != nullptr;
 }
 
-llvm::Expected<void *> PluginRegistry::loadLibraryPlugin(StringRef path) {
+llvm::Expected<LoadedLibraryPlugin *>
+PluginRegistry::loadLibraryPlugin(StringRef path) {
   std::lock_guard<std::mutex> lock(mtx);
-  auto found = LoadedPluginLibraries.find(path);
-  if (found != LoadedPluginLibraries.end()) {
+  auto &storage = LoadedPluginLibraries[path];
+  if (storage) {
     // Already loaded.
-    return found->second;
+    return storage.get();
   }
+
   void *lib = nullptr;
 #if defined(_WIN32)
   lib = LoadLibraryA(path.str().c_str());
@@ -64,8 +66,19 @@ llvm::Expected<void *> PluginRegistry::loadLibraryPlugin(StringRef path) {
     return llvm::createStringError(llvm::inconvertibleErrorCode(), dlerror());
   }
 #endif
-  LoadedPluginLibraries.insert({path, lib});
-  return lib;
+
+  storage = std::unique_ptr<LoadedLibraryPlugin>(new LoadedLibraryPlugin(lib));
+  return storage.get();
+}
+
+void *LoadedLibraryPlugin::getAddressOfSymbol(const char *symbolName) {
+  auto &cached = resolvedSymbols[symbolName];
+  if (cached)
+    return cached;
+#if !defined(_WIN32)
+  cached = dlsym(handle, symbolName);
+#endif
+  return cached;
 }
 
 llvm::Expected<LoadedExecutablePlugin *>

lib/Sema/TypeCheckMacros.cpp

@@ -38,14 +38,6 @@
 #include "swift/Subsystems.h"
 #include "llvm/Config/config.h"
 
-#if defined(_WIN32)
-#define WIN32_LEAN_AND_MEAN
-#define NOMINMAX
-#include <windows.h>
-#else
-#include <dlfcn.h>
-#endif
-
 using namespace swift;
 
 extern "C" void *swift_ASTGen_resolveMacroType(const void *macroType);
@@ -90,10 +82,10 @@ extern "C" bool swift_ASTGen_pluginServerLoadLibraryPlugin(
 
 #if SWIFT_SWIFT_PARSER
 /// Look for macro's type metadata given its external module and type name.
-static void const *lookupMacroTypeMetadataByExternalName(
-    ASTContext &ctx, StringRef moduleName, StringRef typeName,
-    void *libraryHint = nullptr
-) {
+static void const *
+lookupMacroTypeMetadataByExternalName(ASTContext &ctx, StringRef moduleName,
+                                      StringRef typeName,
+                                      LoadedLibraryPlugin *plugin) {
   // Look up the type metadata accessor as a struct, enum, or class.
   const Demangle::Node::Kind typeKinds[] = {
     Demangle::Node::Kind::Structure,
@@ -105,11 +97,7 @@ static void const *lookupMacroTypeMetadataByExternalName(
   for (auto typeKind : typeKinds) {
     auto symbolName = Demangle::mangledNameForTypeMetadataAccessor(
         moduleName, typeName, typeKind);
-#if !defined(_WIN32)
-    /// FIXME: 'PluginRegistry' should vend a wrapper object of the library
-    /// handle (like llvm::sys::DynamicLibrary) and dlsym should be abstracted.
-    accessorAddr = dlsym(libraryHint, symbolName.c_str());
-#endif
+    accessorAddr = plugin->getAddressOfSymbol(symbolName.c_str());
     if (accessorAddr)
       break;
   }
@@ -276,7 +264,8 @@ MacroDefinition MacroDefinitionRequest::evaluate(
 }
 
 /// Load a plugin library based on a module name.
-static void *loadLibraryPluginByName(ASTContext &ctx, Identifier moduleName) {
+static LoadedLibraryPlugin *loadLibraryPluginByName(ASTContext &ctx,
+                                                    Identifier moduleName) {
   std::string libraryPath;
   if (auto found = ctx.lookupLibraryPluginByModuleName(moduleName)) {
     libraryPath = *found;
@@ -367,10 +356,6 @@ loadExecutablePluginByName(ASTContext &ctx, Identifier moduleName) {
 LoadedCompilerPlugin
 CompilerPluginLoadRequest::evaluate(Evaluator &evaluator, ASTContext *ctx,
                                     Identifier moduleName) const {
-  auto fs = ctx->SourceMgr.getFileSystem();
-  auto &searchPathOpts = ctx->SearchPathOpts;
-  auto *registry = ctx->getPluginRegistry();
-
   // Check dynamic link library plugins.
   // i.e. '-plugin-path', and '-load-plugin-library'.
   if (auto found = loadLibraryPluginByName(*ctx, moduleName))
@@ -386,14 +371,12 @@ CompilerPluginLoadRequest::evaluate(Evaluator &evaluator, ASTContext *ctx,
 }
 
 static Optional<ExternalMacroDefinition>
-resolveInProcessMacro(
-    ASTContext &ctx, Identifier moduleName, Identifier typeName,
-    void *libraryHint = nullptr
-) {
+resolveInProcessMacro(ASTContext &ctx, Identifier moduleName,
+                      Identifier typeName, LoadedLibraryPlugin *plugin) {
 #if SWIFT_SWIFT_PARSER
   /// Look for the type metadata given the external module and type names.
   auto macroMetatype = lookupMacroTypeMetadataByExternalName(
-      ctx, moduleName.str(), typeName.str(), libraryHint);
+      ctx, moduleName.str(), typeName.str(), plugin);
   if (macroMetatype) {
     // Check whether the macro metatype is in-process.
     if (auto inProcess = swift_ASTGen_resolveMacroType(macroMetatype)) {