[flang][driver] Add support for Frontend Plugins

[stuartellis]

Summary

Introducing a plugin API and a simple HelloWorld Plugin example.
This patch adds the -load and -plugin flags to frontend driver and
the code around using custom frontend actions from within a plugin
shared library object.

It also adds to the Driver-help test to check the help option with the
updated driver flags.

Additionally, the patch creates a plugin-example test to check the
HelloWorld plugin example runs correctly. As part of this, a new CMake
flag (FLANG_BUILD_EXAMPLES) is added to allow the example to be built
and for the test to run.

This Plugin API has only been tested on Linux.

[awarzynski]

@stuartellis , thank you for working on this! I've left a few comments - mostly nits.

flang/examples/HelloWorld/CMakeLists.txt

1–5

I think that this should be fine as is, but will not work on Windows. Check this example: PrintFunctionNames. I think that it's fine not to support Windows for now, but we should document this. Also, your tests need to marked as Linux-only (e.g. with // REQUIRES: shell or something similar).

flang/examples/HelloWorld/HelloWorldPlugin.cpp

1

Missing LLVM file header: https://llvm.org/docs/CodingStandards.html#file-headers

flang/include/flang/Frontend/FrontendPluginRegistry.h

27

FIXME

flang/lib/Frontend/CompilerInvocation.cpp

202

[nit] Perhaps worth adding a comment to highlight _which_ option is being parsed?

flang/lib/FrontendTool/ExecuteCompilerInvocation.cpp

87

Lower case P

92

Could you add a test for this diagnostic?

flang/test/Driver/plugin-example.f90

7

[tiny nit] Could you make it Flang specific? E.g. Hello World from your new Flang plugin

flang/test/lit.cfg.py

55

Could llvm_plugin_ext be ever empty? Perhaps I'm missing something, but it feels that if config.has_plugins should be sufficient here.

flang/tools/flang-driver/CMakeLists.txt

30

We should make it possible to turn this off, perhaps:

# Some clever comment
if(FLANG_PLUGIN_SUPPORT)
  export_executable_symbols_for_plugins(flang-new)
endif()

[stuartellis]

Address review comments
Added some comments to a couple of places
Added new FLANG_PLUGIN_SUPPORT CMake flag to control exporting executable symbols

[stuartellis]

flang/lib/FrontendTool/ExecuteCompilerInvocation.cpp

92

Added diagnostic test to the end of plugin-example.f90 test

[awarzynski]

I think that this is almost ready to be merged. Just a couple more comments.

flang/examples/CMakeLists.txt

1

Could you add the following at the top of this file:

if(NOT FLANG_BUILD_EXAMPLES)
  set(EXCLUDE_FROM_ALL ON)
endif()

This will make sure that the examples are not build with e.g. ninja when FLANG_BUILD_EXAMPLES is Off.

In Clang, CMake also contains

set_property(DIRECTORY PROPERTY EXCLUDE_FROM_ALL ON)

I think that set(EXCLUDE_FROM_ALL ON) should be sufficient though (see CMake docs for EXCLUDE_FROM_ALL).

Note that in LLVM, there is add_llvm_example_library. It would be nice to use that, be we'd need to make sure that LLVM_BUILD_EXAMPLES is set correctly. But that's not required just now and could be added later.

flang/lib/FrontendTool/ExecuteCompilerInvocation.cpp

147

This will silence this warning:

if (flang->diagnostics().hasErrorOccurred()) {
    return false;
}

[stuartellis]

Address review comments
Small changes due to rebase

[awarzynski]

LGTM!

[DavidSpickett]

This has broken cmake config on the out of tree flang bot:
https://lab.llvm.org/buildbot/#/builders/175/builds/2026

(with perhaps the least helpful cmake error I've ever seen)

Not personally familiar with what "out of tree" means for flang but you should be able to pull the steps from the buildbot UI. (perhaps your change assumes it's "in tree")

[awarzynski]

In D106137#2941616, @DavidSpickett wrote:

This has broken cmake config on the out of tree flang bot:
https://lab.llvm.org/buildbot/#/builders/175/builds/2026

(with perhaps the least helpful cmake error I've ever seen)

Not personally familiar with what "out of tree" means for flang but you should be able to pull the steps from the buildbot UI. (perhaps your change assumes it's "in tree")

Thank you David, I've been able to reproduce this locally. I hope to submit a workaround shortly. This is failing because out-of-tree SHLIBDIR is not defined.

EDIT: Fixed in https://reviews.llvm.org/D107973

clang/include/clang/Driver/Options.td

def disable_free : Flag<["-"], "disable-free">,
   HelpText<"Disable freeing of memory on exit">,
   MarshallingInfoFlag<FrontendOpts<"DisableFree">>;
 def enable_noundef_analysis : Flag<["-"], "enable-noundef-analysis">, Group<f_Group>,
   HelpText<"Enable analyzing function argument and return types for mandatory definedness">,
   MarshallingInfoFlag<CodeGenOpts<"EnableNoundefAttrs">>;
 def discard_value_names : Flag<["-"], "discard-value-names">,
   HelpText<"Discard value names in LLVM IR">,
   MarshallingInfoFlag<CodeGenOpts<"DiscardValueNames">>;
-def load : Separate<["-"], "load">, MetaVarName<"<dsopath>">,
-  HelpText<"Load the named plugin (dynamic shared object)">;
-def plugin : Separate<["-"], "plugin">, MetaVarName<"<name>">,
-  HelpText<"Use the named plugin action instead of the default action (use \"help\" to list available options)">;
 def plugin_arg : JoinedAndSeparate<["-"], "plugin-arg-">,
     MetaVarName<"<name> <arg>">,
     HelpText<"Pass <arg> to plugin <name>">;
 def add_plugin : Separate<["-"], "add-plugin">, MetaVarName<"<name>">,
   HelpText<"Use the named plugin action in addition to the default action">,
   MarshallingInfoStringVector<FrontendOpts<"AddPluginActions">>;
 def ast_dump_filter : Separate<["-"], "ast-dump-filter">,
   MetaVarName<"<dump_filter>">,

 let Group = Action_Group in {
 
 def emit_obj : Flag<["-"], "emit-obj">,
   HelpText<"Emit native object files">;
 def init_only : Flag<["-"], "init-only">,
   HelpText<"Only execute frontend initialization">;
 
 } // let Group = Action_Group
+
+def load : Separate<["-"], "load">, MetaVarName<"<dsopath>">,
+  HelpText<"Load the named plugin (dynamic shared object)">;
+def plugin : Separate<["-"], "plugin">, MetaVarName<"<name>">,
+  HelpText<"Use the named plugin action instead of the default action (use \"help\" to list available options)">;
+
 } // let Flags = [CC1Option, FC1Option, NoDriverOption]
 
 //===----------------------------------------------------------------------===//
 // cc1as-only Options
 //===----------------------------------------------------------------------===//
 
 let Flags = [CC1AsOption, NoDriverOption] in {
 

flang/CMakeLists.txt

 add_subdirectory(cmake/modules)
 
 option(FLANG_BUILD_TOOLS
   "Build the Flang tools. If OFF, just generate build targets." ON)
 if (FLANG_BUILD_TOOLS)
   add_subdirectory(tools)
 endif()
 add_subdirectory(runtime)
+
+option(FLANG_BUILD_EXAMPLES "Build FLANG example programs by default." OFF)
 add_subdirectory(examples)
 
 if (FLANG_INCLUDE_TESTS)
   add_subdirectory(test)
   if (FLANG_GTEST_AVAIL)
     add_subdirectory(unittests)
   endif ()
 endif()

flang/examples/CMakeLists.txt

 # This test is not run by default as it requires input.
 add_executable(external-hello-world
   external-hello.cpp
 )
 
 target_link_libraries(external-hello-world
   FortranRuntime
 )
+
+add_subdirectory(HelloWorld)

flang/examples/HelloWorld/CMakeLists.txt

+add_llvm_library(
+    flangHelloWorldPlugin
+    MODULE
+    HelloWorldPlugin.cpp
+)

flang/examples/HelloWorld/HelloWorldPlugin.cpp

+#include "flang/Frontend/FrontendActions.h"
+#include "flang/Frontend/FrontendPluginRegistry.h"
+
+using namespace Fortran::frontend;
+
+class HelloWorldFlangPlugin : public PluginParseTreeAction {
+  void ExecuteAction() override {
+    llvm::outs() << "Hello World from your new plugin\n";
+  }
+};
+
+static FrontendPluginRegistry::Add<HelloWorldFlangPlugin> X(
+    "-hello-world", "Hello World Plugin example");

flang/include/flang/Frontend/FrontendActions.h

struct MeasurementVisitor {
   }
   size_t objects{0}, bytes{0};
 };
 
 //===----------------------------------------------------------------------===//
 // Custom Consumer Actions
 //===----------------------------------------------------------------------===//
 
+class PluginParseTreeAction : public FrontendAction {
+  void ExecuteAction() override;
+};
+
 class InputOutputTestAction : public FrontendAction {
   void ExecuteAction() override;
 };
 
 class EmitObjAction : public FrontendAction {
   void ExecuteAction() override;
 };
 

flang/include/flang/Frontend/FrontendOptions.h

enum ActionKind {
 
   /// `-fget-definition`
   GetDefinition,
 
   /// Parse, run semantics and then dump symbol sources map
   GetSymbolsSources,
 
   /// Only execute frontend initialization
-  InitOnly
+  InitOnly,
+
+  /// Run a plugin action
+  PluginAction
 
   /// TODO: RunPreprocessor, EmitLLVM, EmitLLVMOnly,
   /// EmitCodeGenOnly, EmitAssembly, (...)
 };
 
 /// \param suffix The file extension
 /// \return True if the file extension should be processed as fixed form
 bool isFixedFormSuffix(llvm::StringRef suffix);
public:
   InputKind dashX_;
 
   // Language features
   common::LanguageFeatureControl features_;
 
   // Source file encoding
   Fortran::parser::Encoding encoding_{Fortran::parser::Encoding::UTF_8};
 
+  /// The list of plugins to load.
+  std::vector<std::string> plugins;
+
+  /// The name of the action to run when using a plugin action.
+  std::string ActionName;
+
 public:
   FrontendOptions()
       : showHelp_(false), showVersion_(false), instrumentedParse_(false),
         needProvenanceRangeToCharBlockMappings_(false) {}
 
   // Return the appropriate input kind for a file extension. For example,
   /// "*.f" would return Language::Fortran.
   ///
   /// \return The input kind for the extension, or Language::Unknown if the
   /// extension is not recognized.
   static InputKind GetInputKindForExtension(llvm::StringRef extension);
 };
 } // namespace Fortran::frontend
 
 #endif // LLVM_FLANG_FRONTEND_FRONTENDOPTIONS_H

flang/include/flang/Frontend/FrontendPluginRegistry.h

+//===- FrontendPluginRegistry.h ---------------------------------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Pluggable Frontend Action Interface
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_FLANG_FRONTEND_FRONTENDPLUGINREGISTRY_H
+#define LLVM_FLANG_FRONTEND_FRONTENDPLUGINREGISTRY_H
+
+#include "flang/Frontend/FrontendAction.h"
+#include "llvm/Support/Registry.h"
+
+namespace Fortran::frontend {
+
+/// The frontend plugin registry.
+using FrontendPluginRegistry = llvm::Registry<PluginParseTreeAction>;
+
+} // namespace Fortran::frontend
+
+#endif // LLVM_FLANG_FRONTEND_FRONTENDPLUGINREGISTRY_H
 No newline at end of file

flang/lib/Frontend/CompilerInvocation.cpp

if (llvm::opt::OptSpecifier(a->getOption().getID()) ==
         }
       }
       opts.getDefVals_.line = optVals[0];
       opts.getDefVals_.startColumn = optVals[1];
       opts.getDefVals_.endColumn = optVals[2];
     }
   }
 
+  if (llvm::opt::Arg *a = args.getLastArg(clang::driver::options::OPT_load)) {
+    opts.plugins.push_back(a->getValue());
+  }
+
+  if (const llvm::opt::Arg *a =
+          args.getLastArg(clang::driver::options::OPT_plugin)) {
+    opts.programAction_ = PluginAction;
+    opts.ActionName = a->getValue();
+  }
+
   opts.outputFile_ = args.getLastArgValue(clang::driver::options::OPT_o);
   opts.showHelp_ = args.hasArg(clang::driver::options::OPT_help);
   opts.showVersion_ = args.hasArg(clang::driver::options::OPT_version);
 
   // Get the input kind (from the value passed via `-x`)
   InputKind dashX(Language::Unknown);
   if (const llvm::opt::Arg *a =
           args.getLastArg(clang::driver::options::OPT_x)) {

flang/lib/Frontend/FrontendAction.cpp

 //===--- FrontendAction.cpp -----------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Frontend/FrontendAction.h"
 #include "flang/Frontend/CompilerInstance.h"
 #include "flang/Frontend/FrontendActions.h"
 #include "flang/Frontend/FrontendOptions.h"
+#include "flang/Frontend/FrontendPluginRegistry.h"
 #include "flang/FrontendTool/Utils.h"
 #include "clang/Basic/DiagnosticFrontend.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/VirtualFileSystem.h"
 
 using namespace Fortran::frontend;
 
+LLVM_INSTANTIATE_REGISTRY(FrontendPluginRegistry)
+
 void FrontendAction::set_currentInput(const FrontendInputFile &currentInput) {
   this->currentInput_ = currentInput;
 }
 
 // Call this method if BeginSourceFile fails.
 // Deallocate compiler instance, input and output descriptors
 static void BeginSourceFileCleanUp(FrontendAction &fa, CompilerInstance &ci) {
   ci.ClearOutputFiles(/*EraseFiles=*/true);

flang/lib/Frontend/FrontendActions.cpp

 
 void InitOnlyAction::ExecuteAction() {
   CompilerInstance &ci = this->instance();
   unsigned DiagID =
       ci.diagnostics().getCustomDiagID(clang::DiagnosticsEngine::Warning,
           "Use `-init-only` for testing purposes only");
   ci.diagnostics().Report(DiagID);
 }
+
+void PluginParseTreeAction::ExecuteAction() {}

flang/lib/FrontendTool/ExecuteCompilerInvocation.cpp

 //===--- ExecuteCompilerInvocation.cpp ------------------------------------===//
 //
 // 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 holds ExecuteCompilerInvocation(). It is split into its own file to
 // minimize the impact of pulling in essentially everything else in Flang.
 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Frontend/CompilerInstance.h"
 #include "flang/Frontend/FrontendActions.h"
+#include "flang/Frontend/FrontendPluginRegistry.h"
 #include "clang/Driver/Options.h"
 #include "llvm/Option/OptTable.h"
 #include "llvm/Option/Option.h"
 #include "llvm/Support/BuryPointer.h"
 #include "llvm/Support/CommandLine.h"
 
 namespace Fortran::frontend {
 
case GetDefinition:
     return std::make_unique<GetDefinitionAction>();
     break;
   case GetSymbolsSources:
     return std::make_unique<GetSymbolsSourcesAction>();
     break;
   case InitOnly:
     return std::make_unique<InitOnlyAction>();
     break;
+  case PluginAction: {
+    for (const FrontendPluginRegistry::entry &plugin :
+        FrontendPluginRegistry::entries()) {
+      if (plugin.getName() == ci.frontendOpts().ActionName) {
+        std::unique_ptr<PluginParseTreeAction> P(plugin.instantiate());
+        return std::move(P);
+      }
+    }
+    unsigned diagID = ci.diagnostics().getCustomDiagID(
+        clang::DiagnosticsEngine::Error, "unable to find plugin '%0'");
+    ci.diagnostics().Report(diagID) << ci.frontendOpts().ActionName;
+    return nullptr;
+  }
   default:
     break;
     // TODO:
     // case RunPreprocessor:
     // case ParserSyntaxOnly:
     // case EmitLLVM:
     // case EmitLLVMOnly:
     // case EmitCodeGenOnly:
     // (...)
   }
   return 0;
 }
 
 std::unique_ptr<FrontendAction> CreateFrontendAction(CompilerInstance &ci) {
   // Create the underlying action.
   std::unique_ptr<FrontendAction> act = CreateFrontendBaseAction(ci);
   if (!act)
     return nullptr;
 
   return act;
 }
+
 bool ExecuteCompilerInvocation(CompilerInstance *flang) {
   // Honor -help.
   if (flang->frontendOpts().showHelp_) {
     clang::driver::getDriverOptTable().printHelp(llvm::outs(),
         "flang-new -fc1 [options] file...", "LLVM 'Flang' Compiler",
         /*Include=*/clang::driver::options::FC1Option,
         /*Exclude=*/llvm::opt::DriverFlag::HelpHidden,
         /*ShowAllAliases=*/false);
     return true;
   }
 
   // Honor -version.
   if (flang->frontendOpts().showVersion_) {
     llvm::cl::PrintVersionMessage();
     return true;
   }
 
+  // Load any requested plugins.
+  for (const std::string &Path : flang->frontendOpts().plugins) {
+    std::string Error;
+    if (llvm::sys::DynamicLibrary::LoadLibraryPermanently(
+            Path.c_str(), &Error)) {
+      unsigned diagID = flang->diagnostics().getCustomDiagID(
+          clang::DiagnosticsEngine::Error, "unable to load plugin '%0': '%1'");
+      flang->diagnostics().Report(diagID) << Path << Error;
+    }
+  }
+
+  // If there were errors in processing arguments, don't do anything else.
+  if (flang->diagnostics().hasErrorOccurred())
+    return false;
+
   // Create and execute the frontend action.
   std::unique_ptr<FrontendAction> act(CreateFrontendAction(*flang));
   if (!act)
     return false;
 
   bool success = flang->ExecuteAction(*act);
   return success;
 }
 
 } // namespace Fortran::frontend

flang/test/CMakeLists.txt

 # Test runner infrastructure for Flang. This configures the Flang test trees
 # for use by Lit, and delegates to LLVM's lit test handlers.
 
 llvm_canonicalize_cmake_booleans(
+  FLANG_BUILD_EXAMPLES
   FLANG_STANDALONE_BUILD
+  LLVM_ENABLE_PLUGINS
 )
 
 set(FLANG_TOOLS_DIR ${FLANG_BINARY_DIR}/bin)
 
 configure_lit_site_cfg(
   ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.py.in
   ${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg.py
   MAIN_CONFIG
   ${CMAKE_CURRENT_SOURCE_DIR}/lit.cfg.py
+  PATHS
+  "SHLIBDIR"
 )
 
 configure_lit_site_cfg(
   ${CMAKE_CURRENT_SOURCE_DIR}/Unit/lit.site.cfg.py.in
   ${CMAKE_CURRENT_BINARY_DIR}/Unit/lit.site.cfg.py
   MAIN_CONFIG
   ${CMAKE_CURRENT_SOURCE_DIR}/Unit/lit.cfg.py
 )

 endif()
 
 if (FLANG_INCLUDE_TESTS)
   if (FLANG_GTEST_AVAIL)
     list(APPEND FLANG_TEST_DEPENDS FlangUnitTests)
   endif()
 endif()
 
+if (FLANG_BUILD_EXAMPLES)
+  list(APPEND FLANG_TEST_DEPENDS flangHelloWorldPlugin)
+endif ()
+
 add_custom_target(flang-test-depends DEPENDS ${FLANG_TEST_DEPENDS})
 
 add_lit_testsuite(check-flang "Running the Flang regression tests"
   ${CMAKE_CURRENT_BINARY_DIR}
   PARAMS ${FLANG_TEST_PARAMS}
   DEPENDS ${FLANG_TEST_DEPENDS}
 )
 set_target_properties(check-flang PROPERTIES FOLDER "Tests")

flang/test/Driver/driver-help.f90

 ! HELP-FC1-NEXT: -fno-analyzed-objects-for-unparse
 ! HELP-FC1-NEXT:                        Do not use the analyzed objects when unparsing
 ! HELP-FC1-NEXT: -fopenacc              Enable OpenACC
 ! HELP-FC1-NEXT: -fopenmp               Parse OpenMP pragmas and generate parallel code.
 ! HELP-FC1-NEXT: -fxor-operator         Enable .XOR. as a synonym of .NEQV.
 ! HELP-FC1-NEXT: -help                  Display available options
 ! HELP-FC1-NEXT: -init-only             Only execute frontend initialization
 ! HELP-FC1-NEXT: -I <dir>               Add directory to the end of the list of include search paths
+! HELP-FC1-NEXT: -load <dsopath>        Load the named plugin (dynamic shared object)
 ! HELP-FC1-NEXT: -module-dir <dir>      Put MODULE files in <dir>
 ! HELP-FC1-NEXT: -module-suffix <suffix> Use <suffix> as the suffix for module files (the default value is `.mod`)
 ! HELP-FC1-NEXT: -nocpp                 Disable predefined and command line preprocessor macros
 ! HELP-FC1-NEXT: -o <file>              Write output to <file>
 ! HELP-FC1-NEXT: -pedantic              Warn on language extensions
+! HELP-FC1-NEXT: -plugin <name>         Use the named plugin action instead of the default action (use "help" to list available options)
 ! HELP-FC1-NEXT: -std=<value>           Language standard to compile for
 ! HELP-FC1-NEXT: -test-io               Run the InputOuputTest action. Use for development and testing only.
 ! HELP-FC1-NEXT: -U <macro>             Undefine macro <macro>
 ! HELP-FC1-NEXT: --version              Print version information
 ! HELP-FC1-NEXT: -W<warning>            Enable the specified warning
 
 !---------------
 ! EXPECTED ERROR
 !---------------
 ! ERROR: error: unknown argument '-helps'; did you mean '-help'

flang/test/Driver/plugin-example.f90

+! Check that loading and running the Hello World plugin example results in the correct print statement
+! This requires that the examples are built (FLANG_BUILD_EXAMPLES=ON)
+
+! REQUIRES: new-flang-driver, plugins, examples
+
+! RUN: %flang_fc1 -load %llvmshlibdir/flangHelloWorldPlugin%pluginext -plugin -hello-world %s 2>&1 | FileCheck %s
+! CHECK: Hello World from your new plugin

flang/test/lit.cfg.py

 config.test_format = lit.formats.ShTest(not llvm_config.use_lit_shell)
 
 # suffixes: A list of file extensions to treat as test files.
 config.suffixes = ['.c', '.cpp', '.f', '.F', '.ff', '.FOR', '.for', '.f77', '.f90', '.F90',
                    '.ff90', '.f95', '.F95', '.ff95', '.fpp', '.FPP', '.cuf'
                    '.CUF', '.f18', '.F18', '.fir', '.f03', '.F03', '.f08', '.F08']
 
 config.substitutions.append(('%PATH%', config.environment['PATH']))
+config.substitutions.append(('%llvmshlibdir', config.llvm_shlib_dir))
+config.substitutions.append(('%pluginext', config.llvm_plugin_ext))
 
 llvm_config.use_default_substitutions()
 
 # excludes: A list of directories to exclude from the testsuite. The 'Inputs'
 # subdirectories contain auxiliary inputs for various tests in their parent
 # directories.
 config.excludes = ['Inputs', 'CMakeLists.txt', 'README.txt', 'LICENSE.txt']
 
 # If the new Flang driver is enabled, add the corresponding feature to
 # config.
 if config.include_flang_new_driver_test:
   config.available_features.add('new-flang-driver')
 else:
   config.available_features.add('old-flang-driver')
 
+# If the flang examples are built, add examples to the config
+if config.flang_examples:
+    config.available_features.add('examples')
+
+# Plugins (loadable modules)
+if config.has_plugins and config.llvm_plugin_ext:
+    config.available_features.add('plugins')
+
 # test_source_root: The root path where tests are located.
 config.test_source_root = os.path.dirname(__file__)
 
 # test_exec_root: The root path where tests should be run.
 config.test_exec_root = os.path.join(config.flang_obj_root, 'test')
 
 # Tweak the PATH to include the tools dir.
 llvm_config.with_environment('PATH', config.flang_tools_dir, append_path=True)

flang/test/lit.site.cfg.py.in

 @LIT_SITE_CFG_IN_HEADER@
 
 import sys
 
 config.llvm_tools_dir = "@LLVM_TOOLS_DIR@"
+config.llvm_shlib_dir = path(r"@SHLIBDIR@")
+config.llvm_plugin_ext = "@LLVM_PLUGIN_EXT@"
 config.lit_tools_dir = "@LLVM_LIT_TOOLS_DIR@"
 config.flang_obj_root = "@FLANG_BINARY_DIR@"
 config.flang_src_dir = "@FLANG_SOURCE_DIR@"
 config.flang_tools_dir = "@FLANG_TOOLS_DIR@"
 config.flang_intrinsic_modules_dir = "@FLANG_INTRINSIC_MODULES_DIR@"
 config.flang_llvm_tools_dir = "@CMAKE_BINARY_DIR@/bin"
 config.flang_lib_dir = "@CMAKE_BINARY_DIR@/lib"
+config.flang_examples = @FLANG_BUILD_EXAMPLES@
 config.python_executable = "@PYTHON_EXECUTABLE@"
 config.flang_standalone_build = @FLANG_STANDALONE_BUILD@
+config.has_plugins = @LLVM_ENABLE_PLUGINS@
 config.cc = "@CMAKE_C_COMPILER@"
 
 # Control the regression test for flang-new driver
 import lit.util
 config.include_flang_new_driver_test = \
     lit.util.pythonize_bool("@FLANG_BUILD_NEW_DRIVER@")
 
 # Support substitution of the tools_dir with user parameters. This is
 # used when we can't determine the tool dir at configuration time.
 try:
     config.llvm_tools_dir = config.llvm_tools_dir % lit_config.params
     config.flang_tools_dir = config.flang_tools_dir % lit_config.params
+    config.llvm_shlib_dir = config.llvm_shlib_dir % lit_config.params
 except KeyError:
     e = sys.exc_info()[1]
     key, = e.args
     lit_config.fatal("unable to find %r parameter, use '--param=%s=VALUE'" % (key,key))
 
 import lit.llvm
 lit.llvm.initialize(lit_config, config)
 
 # Let the main config do the real work.
 lit_config.load_config(config, "@FLANG_SOURCE_DIR@/test/lit.cfg.py")

flang/tools/flang-driver/CMakeLists.txt

 )
 
 clang_target_link_libraries(flang-new
   PRIVATE
   clangDriver
   clangBasic
 )
 
+export_executable_symbols_for_plugins(flang-new)
+
 install(TARGETS flang-new DESTINATION bin)