[Plugins] Add a slim plugin API to work together with the new PM

[philip.pfaffe]

Summary

Add a new plugin API. This closes the gap between pass registration and out-of-tree passes for the new PassManager.

Unlike with the existing API, interaction with a plugin is always initiated from the tools perspective. I.e., when a plugin is loaded by the PluginLoader, it resolves and calls a well-known symbol llvmPluginGetInfo to obtain details about the plugin. The fundamental motivation is to get rid of as many global constructors as possible.
The API exposed by the plugin info is kept intentionally minimal.

[philip.pfaffe]

Retain backwards compatibility with plugins for the legacy PM.

[grosser]

Very cool to see this working!

[philip.pfaffe]

Correctly value-initialize the PluginInfo.

[philip.pfaffe]

Humble Ping

[chandlerc]

include/llvm/Support/Plugin.h

33 ↗

(On Diff #108063)

This seems like a somewhat nasty layering...

If plugins fundamentally deal in pass builders, I wouldn't expect the plugin infrastructure to be in the Support library at all. I think the only reason the plugin stuff started off in the support library is because it relied exclusively on global ctors to connect to any functionality. I really like the idea of moving away from that for plugins and having a more proper callback mechanism, but I think it means we need to either use some abstraction or just make the plugin logic (somewhat) specific to *pass builder* plugins.

Beyond getting the layering and pass build stuff designed nicely, I suspect we should rope some folks more broadly in the community in to make sure the high level approach to plugins here makes sense long term... I'll try to ask around and see who has opinions here.

[philip.pfaffe]

Improve Layering: Move New-PM Pass Plugins into the Passes library

[philip.pfaffe]

[NFC] clang-format

[chandlerc]

include/llvm/Passes/PassPlugin.h

23 ↗

(On Diff #136808)

We should have some documentation around when/where this should be incremented...

25–29 ↗

(On Diff #136808)

We should probably stick this into Compiler.h

40 ↗

(On Diff #136808)

Probably some documentation here would be good. ;]

Also, should this be weak so that it is OK if we never load a library that defines it?

44 ↗

(On Diff #136808)

Out of curiosity -- why use a macro rather than just documenting that a plugin must define the above function?

include/llvm/Passes/PassPluginLoader.h

18 ↗

(On Diff #136808)

This whole class needs doxygen comments. =D

Also, should it be called PassPlugin? And maybe be in the same header as above?

lib/Passes/PassPluginLoader.cpp

37–39 ↗

(On Diff #136808)

I think this is indicative that optional isn't the right return type here... I think you want something more like llvm::Expected here so you can put the error message into return and make this more library friendly.

tools/opt/NewPMDriver.cpp

47 ↗

(On Diff #136808)

maybe load-pass-plugin?

[philip.pfaffe]

include/llvm/Passes/PassPlugin.h

44 ↗

(On Diff #136808)

Mostly so that clients don't forget the extern "C". I just thought it was convenient and liked the declarative style.

If you have strong feelings about this I can document it instead, I'm not really married to the idea.

include/llvm/Passes/PassPluginLoader.h

18 ↗

(On Diff #136808)

I put the two classes in different headers because they have different clients. The PassPlugin.h header contains what's required on the client side, i.e. in the actual pass plugin. The Plugin class here is on the other hand only used by the driver to represent loaded plugins.

[philip.pfaffe]

Address review comments, mostly adding commentary and renaming things.

[philip.pfaffe]

Ping

[chandlerc]

include/llvm/Passes/PassPlugin.h

44 ↗

(On Diff #136808)

You can close the block-level extern "C" above after the type, and use a direct one here so that copy/paste of the declaration Just Works:

extern "C" PluginInfo LLVM_ATTRIBUTE_WEAK LLVM_PLUGIN_EXPORT llvmPluginGetInfo();

But maybe better to just give an example definition for copy/paste because I suspect it needn't be so long. At least, I would hope that the declaration here suffices to get the attributes and exports correct and the user can just:

extern "C" PluginInfo llvmPluginGetInfo() {
  ...
}

I'm always hesitant to generate code with a macro. It feels ... icky to me. Maybe that's just my bias.

25 ↗

(On Diff #138387)

Here and below, we turn on Doxygen's auto-brief feature so I suspect most of the \brief tags can be dropped. This one might be the exception, I don't recall if autobrief works for \macro blocks or not.

55 ↗

(On Diff #138387)

A separate question: should this be spelled to be more specific? I'm imagining: llvmGetPassPluginInfo. Similar question about the name of the struct as well -- should it be specific to this being a pass plugin?

include/llvm/Passes/PassPluginLoader.h

18 ↗

(On Diff #136808)

I don't (personally) see a big problem with having these in one file. It seems unlikely to be a burden on the plugin author to have this code included and keeps it co-located.

I would try to use names that differentiate the loaded plugin object from the C-struct used by a plugin to describe itself. I'm not sure what the best naming pair is there....

[philip.pfaffe]

Rename, move around, and simplify some things.

Most importantly: Rename the plugin-provided callback descriptor to
PassPluginLibraryInfo, and the handle to the loaded library to
PassPlugin.

[chandlerc]

This is looking really awesome. Starting to get into more mundane / nit picky comments below.

include/llvm/Passes/PassPlugin.h

66–67 ↗

(On Diff #140067)

Rather than expose the info object, maybe expose nice APIs for everything that wrap it up?

93 ↗

(On Diff #140067)

I don't know anything about Windows or DLLs really... But I would naively expect that *here* we want __declspec(dllimport), and we want plugins to use __declspec(dllexport). Is that not the case? I'm happy to just be told "nope, this is how it works" without even a comment. Mostly asking to learn.

lib/Passes/PassPlugin.cpp

20–21 ↗

(On Diff #140067)

Bundle the error string provided by getPermanentLibrary here?

20–21 ↗

(On Diff #140067)

This will be substantially more efficient if you cast the first component to a Twine as then the +s will be saved and evaluated at the end. Something like: Twine("foo") + a + "bar" + c is ideal when dealing with Twine operands (and that is how StringError is built).

38–40 ↗

(On Diff #140067)

Here in particular using the Twine composition is likely especially good. You should be able to either directly pass the C-strings or build StringRef's around them and avoid any allocation at this layer.

tools/opt/NewPMDriver.cpp

31 ↗

(On Diff #140067)

Stale header.

218 ↗

(On Diff #140067)

Expand a bit? "Walk the pass plugins and let them register any pass builder callbacks." or some such.

221–223 ↗

(On Diff #140067)

Generally LLVM style would suggest to continue here rather than using an else. Nto a big deal in this case.

unittests/Passes/Plugin.cxx

1 ↗

(On Diff #140067)

.cpp?

Also, maybe "TestPlugin"?

unittests/Passes/PluginsTest.cpp

26–34 ↗

(On Diff #140067)

Do we have any tests that do this successfully already?

I'm worried it will be a nightmare to get this to work portably. But it is a really awesome level of testing, so seems worth at least trying, just wanted you to be prepared for the potential churn required to get it to work.

37 ↗

(On Diff #140067)

Use StringRef instead? Or see below...

[philip.pfaffe]

unittests/Passes/PluginsTest.cpp

26–34 ↗

(On Diff #140067)

I think I copied this from unittests/Support/DynamicLibrary. Maybe it makes sense to factor this out into a common header in llvm/Testing?

[philip.pfaffe]

Address review comments:

• Use more StringRef and Twine
• Hide the PassPluginLibraryInfo object

[chandlerc]

LGTM with doc fixes and Twine fixes below. Really excited about this!

Thanks for the ton of work getting us from zero plugins to rich plugins!

include/llvm/Passes/PassPlugin.h

37 ↗

(On Diff #140946)

Maybe expand this a bit to explain this defines the core interface used to interact with plugins but is primarily for plugin implementors (as opposed to plugin users) and point users to the class below that loads and wraps the plugin?

53 ↗

(On Diff #140946)

%Metadata?

lib/Passes/PassPlugin.cpp

38–40 ↗

(On Diff #140067)

Rather than std::to_string, you can just call Twine on integers.

In fact, I think the operator+ overload will do the right thing here, and you can just add these together and it will do twine-based concatenation.

[miyuki]

The PluginsTest test is failing in our builds:

/work/llvm/src/unittests/Passes/PluginsTest.cpp:42: Failure
Value of: !!Plugin
  Actual: false
Expected: true
Plugin path: /work/llvm/build/unittests/Passes/TestPlugin.so
Expected<T> must be checked before access or destruction.
Unchecked Expected<T> contained error:
Could not load library '/work/llvm/build/unittests/Passes/TestPlugin.so': /work/llvm/build/unittests/Passes/TestPlugin.so: undefined symbol: _ZN4llvm23EnableABIBreakingChecksE

This is probably related to the fact that we use -DLLVM_EXPORT_SYMBOLS_FOR_PLUGINS=ON. The host platform is x86_64-linux. Could you please check, if the test is supposed to work in such configuration.

llvm/trunk/include/llvm/Demangle/Compiler.h

 #if __has_feature(cxx_exceptions)
 #define LLVM_ENABLE_EXCEPTIONS 1
 #elif defined(__GNUC__) && defined(__EXCEPTIONS)
 #define LLVM_ENABLE_EXCEPTIONS 1
 #elif defined(_MSC_VER) && defined(_CPPUNWIND)
 #define LLVM_ENABLE_EXCEPTIONS 1
 #endif
 
+/// \macro LLVM_PLUGIN_IMPORT
+/// \brief Used to import the well-known entry point for registering loaded pass
+/// plugins
+#ifdef WIN32
+#define LLVM_PLUGIN_IMPORT __declspec(dllimport)
+#else
+#define LLVM_PLUGIN_IMPORT
+#endif
+
+/// \macro LLVM_PLUGIN_EXPORT
+/// \brief Used to export the well-known entry point for registering loaded pass
+/// plugins
+#ifdef WIN32
+#define LLVM_PLUGIN_EXPORT __declspec(dllexport)
+#else
+#define LLVM_PLUGIN_EXPORT
+#endif
+
 #endif

llvm/trunk/include/llvm/Passes/PassPlugin.h

+//===- llvm/Passes/PassPlugin.h - Public Plugin API -----------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This defines the public entry point for new-PM pass plugins.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_PASSES_PASSPLUGIN_H
+#define LLVM_PASSES_PASSPLUGIN_H
+
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Compiler.h"
+#include "llvm/Support/DynamicLibrary.h"
+#include "llvm/Support/Error.h"
+#include <cstdint>
+#include <string>
+
+namespace llvm {
+class PassBuilder;
+
+/// \macro LLVM_PLUGIN_API_VERSION
+/// Identifies the API version understood by this plugin.
+///
+/// When a plugin is loaded, the driver will check it's supported plugin version
+/// against that of the plugin. A mismatch is an error. The supported version
+/// will be incremented for ABI-breaking changes to the \c PassPluginLibraryInfo
+/// struct, i.e. when callbacks are added, removed, or reordered.
+#define LLVM_PLUGIN_API_VERSION 1
+
+extern "C" {
+/// Information about the plugin required to load its passes
+///
+/// This struct defines the core interface for pass plugins and is supposed to
+/// be filled out by plugin implementors. LLVM-side users of a plugin are
+/// expected to use the \c PassPlugin class below to interface with it.
+struct PassPluginLibraryInfo {
+  /// The API version understood by this plugin, usually \c
+  /// LLVM_PLUGIN_API_VERSION
+  uint32_t APIVersion;
+  /// A meaningful name of the plugin.
+  const char *PluginName;
+  /// The version of the plugin.
+  const char *PluginVersion;
+
+  /// The callback for registering plugin passes with a \c PassBuilder
+  /// instance
+  void (*RegisterPassBuilderCallbacks)(PassBuilder &);
+};
+}
+
+/// A loaded pass plugin.
+///
+/// An instance of this class wraps a loaded pass plugin and gives access to
+/// its interface defined by the \c PassPluginLibraryInfo it exposes.
+class PassPlugin {
+public:
+  /// Attempts to load a pass plugin from a given file.
+  ///
+  /// \returns Returns an error if either the library cannot be found or loaded,
+  /// there is no public entry point, or the plugin implements the wrong API
+  /// version.
+  static Expected<PassPlugin> Load(const std::string &Filename);
+
+  /// Get the filename of the loaded plugin.
+  StringRef getFilename() const { return Filename; }
+
+  /// Get the plugin name
+  StringRef getPluginName() const { return Info.PluginName; }
+
+  /// Get the plugin version
+  StringRef getPluginVersion() const { return Info.PluginVersion; }
+
+  /// Get the plugin API version
+  uint32_t getAPIVersion() const { return Info.APIVersion; }
+
+  /// Invoke the PassBuilder callback registration
+  void registerPassBuilderCallbacks(PassBuilder &PB) const {
+    Info.RegisterPassBuilderCallbacks(PB);
+  }
+
+private:
+  PassPlugin(const std::string &Filename, const sys::DynamicLibrary &Library)
+      : Filename(Filename), Library(Library), Info() {}
+
+  std::string Filename;
+  sys::DynamicLibrary Library;
+  PassPluginLibraryInfo Info;
+};
+}
+
+/// The public entry point for a pass plugin.
+///
+/// When a plugin is loaded by the driver, it will call this entry point to
+/// obtain information about this plugin and about how to register its passes.
+/// This function needs to be implemented by the plugin, see the example below:
+///
+/// ```
+/// extern "C" ::llvm::PassPluginLibraryInfo LLVM_ATTRIBUTE_WEAK
+/// LLVM_PLUGIN_EXPORT llvmGetPassPluginInfo() {
+///   return {
+///     LLVM_PLUGIN_API_VERSION, "MyPlugin", "v0.1", [](PassBuilder &PB) { ... }
+///   };
+/// }
+/// ```
+extern "C" ::llvm::PassPluginLibraryInfo LLVM_ATTRIBUTE_WEAK LLVM_PLUGIN_IMPORT
+llvmGetPassPluginInfo();
+
+#endif /* LLVM_PASSES_PASSPLUGIN_H */

llvm/trunk/include/llvm/Support/Compiler.h

 // wrapper around the implementation that lives in llvm-c, though most clients
 // can/should think of this as being provided by Support for simplicity (not
 // many clients are aware of their dependency on Demangler/it's a weird place to
 // own this - but didn't seem to justify splitting Support into "lower support"
 // and "upper support").
 //
 //===----------------------------------------------------------------------===//
 
+
 #include "llvm/Demangle/Compiler.h"

llvm/trunk/lib/Passes/CMakeLists.txt

 add_llvm_library(LLVMPasses
   PassBuilder.cpp
+  PassPlugin.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/Passes
 
   DEPENDS
   intrinsics_gen
   )

llvm/trunk/lib/Passes/PassPlugin.cpp

+//===- lib/Passes/PassPluginLoader.cpp - Load Plugins for New PM Passes ---===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Passes/PassPlugin.h"
+#include "llvm/Support/raw_ostream.h"
+
+using namespace llvm;
+
+Expected<PassPlugin> PassPlugin::Load(const std::string &Filename) {
+  std::string Error;
+  auto Library =
+      sys::DynamicLibrary::getPermanentLibrary(Filename.c_str(), &Error);
+  if (!Library.isValid())
+    return make_error<StringError>(Twine("Could not load library '") +
+                                       Filename + "': " + Error,
+                                   inconvertibleErrorCode());
+
+  PassPlugin P{Filename, Library};
+  auto *getDetailsFn =
+      Library.SearchForAddressOfSymbol("llvmGetPassPluginInfo");
+
+  if (!getDetailsFn)
+    // If the symbol isn't found, this is probably a legacy plugin, which is an
+    // error
+    return make_error<StringError>(Twine("Plugin entry point not found in '") +
+                                       Filename + "'. Is this a legacy plugin?",
+                                   inconvertibleErrorCode());
+
+  P.Info = reinterpret_cast<decltype(llvmGetPassPluginInfo) *>(getDetailsFn)();
+
+  if (P.Info.APIVersion != LLVM_PLUGIN_API_VERSION)
+    return make_error<StringError>(
+        Twine("Wrong API version on plugin '") + Filename + "'. Got version " +
+            Twine(P.Info.APIVersion) + ", supported version is " +
+            Twine(LLVM_PLUGIN_API_VERSION) + ".",
+        inconvertibleErrorCode());
+
+  if (!P.Info.RegisterPassBuilderCallbacks)
+    return make_error<StringError>(Twine("Empty entry callback in plugin '") +
+                                       Filename + "'.'",
+                                   inconvertibleErrorCode());
+
+  return P;
+}

llvm/trunk/tools/opt/NewPMDriver.cpp

 #include "llvm/Config/config.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/IRPrintingPasses.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/Passes/PassBuilder.h"
+#include "llvm/Passes/PassPlugin.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/ToolOutputFile.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Transforms/IPO/ThinLTOBitcodeWriter.h"
 #include "llvm/Transforms/Scalar/LoopPassManager.h"
 
 using namespace llvm;
 using namespace opt_tool;
 
 static cl::opt<bool>
     DebugPM("debug-pass-manager", cl::Hidden,
             cl::desc("Print pass management debugging information"));
 
+static cl::list<std::string>
+    PassPlugins("load-pass-plugin",
+                cl::desc("Load passes from plugin library"));
+
 // This flag specifies a textual description of the alias analysis pipeline to
 // use when querying for aliasing information. It only works in concert with
 // the "passes" flag above.
 static cl::opt<std::string>
     AAPipeline("aa-pipeline",
                cl::desc("A textual description of the alias analysis "
                         "pipeline for handling managed aliasing queries"),
                cl::Hidden);
case NoPGO:
       if (DebugInfoForProfiling)
         P = PGOOptions("", "", "", false, true);
       else
         P = None;
   }
   PassBuilder PB(TM, P);
   registerEPCallbacks(PB, VerifyEachPass, DebugPM);
 
+  // Load requested pass plugins and let them register pass builder callbacks
+  for (auto &PluginFN : PassPlugins) {
+    auto PassPlugin = PassPlugin::Load(PluginFN);
+    if (!PassPlugin) {
+      errs() << "Failed to load passes from '" << PluginFN
+             << "'. Request ignored.\n";
+      continue;
+    }
+
+    PassPlugin->registerPassBuilderCallbacks(PB);
+  }
+
   // Register a callback that creates the debugify passes as needed.
   PB.registerPipelineParsingCallback(
       [](StringRef Name, ModulePassManager &MPM,
          ArrayRef<PassBuilder::PipelineElement>) {
         if (Name == "debugify") {
           MPM.addPass(NewPMDebugifyPass());
           return true;
         } else if (Name == "check-debugify") {

llvm/trunk/unittests/CMakeLists.txt

 add_subdirectory(LineEditor)
 add_subdirectory(Linker)
 add_subdirectory(MC)
 add_subdirectory(MI)
 add_subdirectory(Object)
 add_subdirectory(BinaryFormat)
 add_subdirectory(ObjectYAML)
 add_subdirectory(Option)
+add_subdirectory(Passes)
 add_subdirectory(ProfileData)
 add_subdirectory(Support)
 add_subdirectory(Target)
 add_subdirectory(Transforms)
 add_subdirectory(XRay)
 add_subdirectory(tools)

llvm/trunk/unittests/Passes/CMakeLists.txt

+set(LLVM_LINK_COMPONENTS Support Passes Core)
+
+add_llvm_unittest(PluginsTests PluginsTest.cpp)
+export_executable_symbols(PluginsTests)
+
+add_library(TestPlugin SHARED TestPlugin.cxx)
+
+set_output_directory(TestPlugin
+  BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}
+  LIBRARY_DIR ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}
+  )
+
+set_target_properties(TestPlugin
+  PROPERTIES PREFIX ""
+  SUFFIX ".so"
+  )
+
+llvm_map_components_to_libnames(LLVMDependencies ${LLVM_LINK_COMPONENTS})
+target_link_libraries(TestPlugin ${LLVMDependencies})
+
+add_dependencies(PluginsTests TestPlugin)

llvm/trunk/unittests/Passes/PluginsTest.cpp

+//===- unittests/Passes/Plugins/PluginsTest.cpp ---------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Analysis/CGSCCPassManager.h"
+#include "llvm/IR/PassManager.h"
+#include "llvm/Passes/PassBuilder.h"
+#include "llvm/Passes/PassPlugin.h"
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/ManagedStatic.h"
+#include "llvm/Support/Path.h"
+#include "llvm/Transforms/Scalar/LoopPassManager.h"
+#include "gtest/gtest.h"
+
+#include "TestPlugin.h"
+
+using namespace llvm;
+
+void anchor() {}
+
+static std::string LibPath(const std::string Name = "TestPlugin") {
+  const std::vector<testing::internal::string> &Argvs =
+      testing::internal::GetArgvs();
+  const char *Argv0 = Argvs.size() > 0 ? Argvs[0].c_str() : "PluginsTests";
+  void *Ptr = (void *)anchor;
+  std::string Path = sys::fs::getMainExecutable(Argv0, Ptr);
+  llvm::SmallString<256> Buf{sys::path::parent_path(Path)};
+  sys::path::append(Buf, (Name + ".so").c_str());
+  return Buf.str();
+}
+
+TEST(PluginsTests, LoadPlugin) {
+  auto PluginPath = LibPath();
+  ASSERT_NE("", PluginPath);
+
+  Expected<PassPlugin> Plugin = PassPlugin::Load(PluginPath);
+  ASSERT_TRUE(!!Plugin) << "Plugin path: " << PluginPath;
+
+  ASSERT_EQ(TEST_PLUGIN_NAME, Plugin->getPluginName());
+  ASSERT_EQ(TEST_PLUGIN_VERSION, Plugin->getPluginVersion());
+
+  PassBuilder PB;
+  ModulePassManager PM;
+  ASSERT_FALSE(PB.parsePassPipeline(PM, "plugin-pass"));
+
+  Plugin->registerPassBuilderCallbacks(PB);
+  ASSERT_TRUE(PB.parsePassPipeline(PM, "plugin-pass"));
+}

llvm/trunk/unittests/Passes/TestPlugin.h

+#define TEST_PLUGIN_NAME "TestPlugin"
+#define TEST_PLUGIN_VERSION "0.1-unit"

llvm/trunk/unittests/Passes/TestPlugin.cxx

+//===- unittests/Passes/Plugins/Plugin.cxx --------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Passes/PassBuilder.h"
+#include "llvm/Passes/PassPlugin.h"
+
+#include "TestPlugin.h"
+
+using namespace llvm;
+
+struct TestModulePass : public PassInfoMixin<TestModulePass> {
+  PreservedAnalyses run(Module &M, ModuleAnalysisManager &MAM) {
+    return PreservedAnalyses::all();
+  }
+};
+
+void registerCallbacks(PassBuilder &PB) {
+  PB.registerPipelineParsingCallback(
+      [](StringRef Name, ModulePassManager &PM,
+         ArrayRef<PassBuilder::PipelineElement> InnerPipeline) {
+        if (Name == "plugin-pass") {
+          PM.addPass(TestModulePass());
+          return true;
+        }
+        return false;
+      });
+}
+
+extern "C" ::llvm::PassPluginLibraryInfo LLVM_ATTRIBUTE_WEAK LLVM_PLUGIN_EXPORT
+llvmGetPassPluginInfo() {
+  return {LLVM_PLUGIN_API_VERSION, TEST_PLUGIN_NAME, TEST_PLUGIN_VERSION,
+          registerCallbacks};
+}