[llvm] Support autoloading vendor-defined plugins

[mgorny]

Summary

Provide a new LLVM_AUTOLOAD_PLUGINS CMake variable to specify plugins
that LLVM should attempt to load automatically. This is going
to be used to make it possible for LLVM to automatically take advantage
of installed Polly plugin without requiring it to be unconditionally
present at build or runtime.

[jdoerfert]

[DriveBy] We should test this ;)

[Meinersbur]

Adding @serge-sans-paille as he designed the latest plugin loading mechanism.

The new pass manager uses a separate mechanism using -fpass-plugin/-load-pass-plugin. Maybe that should be supported as well.

I think that some community members try to reduce the number of build configurations to reduce testing effort/improve reproducibility. This would run against that.

[mgorny]

I don't really know about the two plugin mechanisms. To be honest, I haven't been able to get Polly to work yet — however, one of our users has done some testing for me, and IIRC the 'pass plugin' mechanism didn't work for some reason.

[Meinersbur]

If it is passes that (like Polly) using the in-tree static plugin mechanism, I recommend using the LLVM_<plugin>_LINK_INTO_TOOLS=ON flag.

For adding yet another mechanism I would request additional motivation. Maintaining that many plugin loading mechanism cross-platforms is a lot of work.

[mgorny]

In D85299#2204537, @Meinersbur wrote:

If it is passes that (like Polly) using the in-tree static plugin mechanism, I recommend using the LLVM_<plugin>_LINK_INTO_TOOLS=ON flag.

I don't see how that would work if Polly is built after LLVM, and entirely optional.

[serge-sans-paille]

I have some difficulties to understand the exact scenario: if one knows at compile-time that polly is needed, why no just build it as a linked-in plugin, as suggested by @Meinersbur?
If one wants to specify a list of auto-loaded plugins at runtime, there's already several ways to do so, either through the C++ API or through CLI.

[mgorny]

In D85299#2204692, @serge-sans-paille wrote:

I have some difficulties to understand the exact scenario: if one knows at compile-time that polly is needed, why no just build it as a linked-in plugin, as suggested by @Meinersbur?

How does one know that? The whole point is to not have to know what's going to happen in the future, and not have to rebuild the whole LLVM to get Polly or get rid of it. That's pretty much the purpose of plugins, isn't it?

If one wants to specify a list of auto-loaded plugins at runtime, there's already several ways to do so, either through the C++ API or through CLI.

I don't think we have the same definition of 'auto-loaded'. The whole point is to have them autoloaded in all LLVM tools that might need plugins, *without* manual user effort, and in particular without requiring user to remember the exact paths or having to add wrappers for tools.

[Meinersbur]

The scenario sounds too specific for a single user requiring too much effort to maintain it across build configurations and platforms. Additionally, it makes clang's behavior dependent on the system configuration, which in the past the LLVM community was not in favor of. See http://lists.llvm.org/pipermail/cfe-dev/2016-September/050795.html.

There are a few other problems of this patch in particular:

1. Errors silently ignored
2. Does not handle new pass manager plugins
3. LLVM and Polly must exactly match, otherwise unpredictable errors occur. Picking up a plugin at some locations the user is not necessarily aware of is problematic.
4. Reproducibility is reduced: The output of clang -v doesn't even indicates that a pass is implicitly loaded.
5. Enlarges the build configuration space.

At most it saves the system maintainer from re-compiling LLVM with(/-out) LLVM_POLLY_LINK_INTO_TOOLS=ON. Sorry, I don't see myself supporting this patch.

[serge-sans-paille]

I 100% agree with the above arguments

llvm/CMakeLists.txt

if(WIN32 OR CYGWIN)
   else()
     set(LLVM_ENABLE_PLUGINS_default OFF)
   endif()
 else()
   set(LLVM_ENABLE_PLUGINS_default ${LLVM_ENABLE_PIC})
 endif()
 option(LLVM_ENABLE_PLUGINS "Enable plugin support" ${LLVM_ENABLE_PLUGINS_default})
 
+set(LLVM_AUTOLOAD_PLUGINS "" CACHE STRING
+    "List of plugin paths to attempt autoloading")
+mark_as_advanced(LLVM_AUTOLOAD_PLUGINS)
+
 include(HandleLLVMOptions)
 
 if(CMAKE_VERSION VERSION_LESS 3.12)
   include(FindPythonInterp)
   if( NOT PYTHONINTERP_FOUND )
     message(FATAL_ERROR
   "Unable to find Python interpreter, required for builds and testing.
 

llvm/include/llvm/Config/config.h.cmake

 #cmakedefine01 LLVM_GISEL_COV_ENABLED
 
 /* Define to the default GlobalISel coverage file prefix */
 #cmakedefine LLVM_GISEL_COV_PREFIX "${LLVM_GISEL_COV_PREFIX}"
 
 /* Whether Timers signpost passes in Xcode Instruments */
 #cmakedefine01 LLVM_SUPPORT_XCODE_SIGNPOSTS
 
+/* Define to the list of plugins to autoload */
+#define LLVM_AUTOLOAD_PLUGINS "${LLVM_AUTOLOAD_PLUGINS}"
+
 #endif

llvm/lib/Support/PluginLoader.cpp

 //===-- PluginLoader.cpp - Implement -load command line option ------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the -load <plugin> command line option handler.
 //
 //===----------------------------------------------------------------------===//
 
 #define DONT_GET_PLUGIN_LOADER_OPTION
 #include "llvm/Support/PluginLoader.h"
+#include "llvm/Config/config.h"
 #include "llvm/Support/DynamicLibrary.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/Mutex.h"
 #include "llvm/Support/raw_ostream.h"
 #include <vector>
 using namespace llvm;
 
 static ManagedStatic<std::vector<std::string> > Plugins;

 }
 
 std::string &PluginLoader::getPlugin(unsigned num) {
   sys::SmartScopedLock<true> Lock(*PluginsLock);
   assert(Plugins.isConstructed() && num < Plugins->size() &&
          "Asking for an out of bounds plugin");
   return (*Plugins)[num];
 }
+
+struct PluginAutoLoader {
+  PluginAutoLoader() {
+    SmallVector<StringRef, 4> PluginList;
+    StringRef(LLVM_AUTOLOAD_PLUGINS).split(PluginList, ';', -1, false);
+
+    for (auto &Val : PluginList) {
+      sys::SmartScopedLock<true> Lock(*PluginsLock);
+      std::string Filename = Val.str();
+      std::string Error;
+      if (!sys::DynamicLibrary::LoadLibraryPermanently(Filename.c_str(),
+                                                       &Error)) {
+        Plugins->push_back(Filename);
+      }
+    }
+  }
+};
+
+static PluginAutoLoader AutoPlugins;