Support compiler extensions as a normal component

[serge-sans-paille]

Summary

The approach here is to create a new component, Extensions, where all statically compiled extensions add their dependency. That way we're more natively compatible with LLVMBuild and llvm-config.

[serge-sans-paille]

Properly unparse dependency list from plugins into component / lib list, so that we can fill llvm-config with it.

[Meinersbur]

Did you consider making https://github.com/intel/opencl-clang/blob/83837744ef076c1285ed2ee9349febc2208d3252/CMakeLists.txt#L266 work as well. I haven't checked whether Polly is indeed not added by "LINK_COMPONENTS all", but otherwise I think it would not have been reported to not work.

[Meinersbur]

llvm/tools/llvm-config/llvm-config.cpp

153

Wasn't the intention to add it only 'all' only? LLVMPasses does not directly depend on statically linked pass extensions.

[Meinersbur]

llvm/tools/llvm-config/llvm-config.cpp

153

Thinking about, LLVMPasses seems to be a bag for all passes in other libs, so actually ,might be a good fit. Assuming that when using llvm-config passes -libs, other libraries don't just expect the vanilla passes.

[serge-sans-paille]

Instead of linking all compiler extensions to the different possible tagets (clang, opt lto etc), link them in a new component, named Extensions. That way a tool (or component) that needs to use compiler extension can just declare that dependency in the traditional way.

This is compatible with llvm-build and llvm-config, through a specific handler in llvm-config though.

[serge-sans-paille]

@Meinersbur with the latest updat, it should also be compatible with https://github.com/intel/opencl-clang/blob/83837744ef076c1285ed2ee9349febc2208d3252/CMakeLists.txt#L266 as all contains the Extensions component.

[serge-sans-paille]

Note that this should solve in an elegant (?) way the multiple link errors found when linking clang with LLVM_DYLIB.

[Meinersbur]

Is this ready to try out?

In D78192#1996859, @serge-sans-paille wrote:

Note that this should solve in an elegant (?) way the multiple link errors found when linking clang with LLVM_DYLIB.

Aren't these fixed already?

[Meinersbur]

I looks to work fine under my Windows and Linux configuration. One Point though:

llvm-config --libs Extensions

returns

[...] -lPollyPPCG -lPollyISL -lPolly

I think -lPolly must be first to work with bfd.ld order semantics. See https://stackoverflow.com/questions/45135/why-does-the-order-in-which-libraries-are-linked-sometimes-cause-errors-in-gcc , lld and Microsoft's link.exe don't care less about the order.

[serge-sans-paille]

In D78192#1997698, @Meinersbur wrote:

Is this ready to try out?

It is!

In D78192#1996859, @serge-sans-paille wrote:

Note that this should solve in an elegant (?) way the multiple link errors found when linking clang with LLVM_DYLIB.

Aren't these fixed already?

Indeed, but the fix is not generic (it made change to the polly Cmake code), and it's not compatible with Polly declaring component dependencies (see https://reviews.llvm.org/D78358).
Anyway, that's just a side effect of the cleanup, didn't want to emphazise too much on that.

[serge-sans-paille]

Fix dependency order for extension libraries, as spotted by @Meinersbur

[Meinersbur]

LGTM.

As with every change to the build system, please look out broken configurations after committing. You will have noticed already that there is a lot of variety in how others build LLVM, and its not possible for one person to test them all.

llvm/cmake/modules/AddLLVM.cmake

952–953

[typo] double 'be'

959

In contrast to the LLVMBuild.txt system, this actually uses cmake to get the dependency. Very cool! I am not sure whether LINK_LIBRARIES also includes transitive dependencies.

I think the community would love to see the LLVMBuild.txt gone completely. Interested in working on that?

[serge-sans-paille]

The patch landed without much errors, only added the patchset e307eeba0137700e75893089cf0de03383d851ca

clang/lib/CodeGen/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   Analysis
   BitReader
   BitWriter
   Core
   Coroutines
   Coverage
+  Extensions
   FrontendOpenMP
   IPO
   IRReader
   AggressiveInstCombine
   InstCombine
   Instrumentation
   LTO
   Linker
add_clang_library(clangCodeGen
   ModuleBuilder.cpp
   ObjectFilePCHContainerOperations.cpp
   PatternInit.cpp
   SanitizerMetadata.cpp
   SwiftCallingConv.cpp
   TargetInfo.cpp
   VarBypassDetector.cpp
 
-  ENABLE_PLUGINS
-
   DEPENDS
   ${codegen_deps}
 
   LINK_LIBS
   clangAnalysis
   clangAST
   clangASTMatchers
   clangBasic
   clangFrontend
   clangLex
   clangSerialization
   )

llvm/cmake/modules/AddLLVM.cmake

 #     The tool (i.e. cmake target) that this plugin will link against
 #   COMPONENT_LIB
 #      This is used to specify that this is a component library of
 #      LLVM which means that the source resides in llvm/lib/ and it is a
 #      candidate for inclusion into libLLVM.so.
 #   )
 function(llvm_add_library name)
   cmake_parse_arguments(ARG
-    "MODULE;SHARED;STATIC;OBJECT;DISABLE_LLVM_LINK_LLVM_DYLIB;SONAME;NO_INSTALL_RPATH;COMPONENT_LIB;ENABLE_PLUGINS"
+    "MODULE;SHARED;STATIC;OBJECT;DISABLE_LLVM_LINK_LLVM_DYLIB;SONAME;NO_INSTALL_RPATH;COMPONENT_LIB"
     "OUTPUT_NAME;PLUGIN_TOOL;ENTITLEMENTS;BUNDLE_PATH"
     "ADDITIONAL_HEADERS;DEPENDS;LINK_COMPONENTS;LINK_LIBS;OBJLIBS"
     ${ARGN})
   list(APPEND LLVM_COMMON_DEPENDS ${ARG_DEPENDS})
   if(ARG_ADDITIONAL_HEADERS)
     # Pass through ADDITIONAL_HEADERS.
     set(ARG_ADDITIONAL_HEADERS ADDITIONAL_HEADERS ${ARG_ADDITIONAL_HEADERS})
   endif()
   if(ARG_OBJLIBS)
     set(ALL_FILES ${ARG_OBJLIBS})
   else()
     llvm_process_sources(ALL_FILES ${ARG_UNPARSED_ARGUMENTS} ${ARG_ADDITIONAL_HEADERS})
   endif()
-  if(ARG_ENABLE_PLUGINS)
-    set_property(GLOBAL APPEND PROPERTY LLVM_PLUGIN_TARGETS ${name})
-  endif()
 
   if(ARG_MODULE)
     if(ARG_SHARED OR ARG_STATIC)
       message(WARNING "MODULE with SHARED|STATIC doesn't make sense.")
     endif()
     # Plugins that link against a tool are allowed even when plugins in general are not
     if(NOT LLVM_ENABLE_PLUGINS AND NOT (ARG_PLUGIN_TOOL AND LLVM_EXPORT_SYMBOLS_FOR_PLUGINS))
       message(STATUS "${name} ignored -- Loadable modules not supported on this platform.")
if (ARG_MODULE)
     set_target_properties(${name} PROPERTIES FOLDER "Loadable modules")
   else()
     set_target_properties(${name} PROPERTIES FOLDER "Libraries")
   endif()
 endmacro(add_llvm_library name)
 
 macro(add_llvm_executable name)
   cmake_parse_arguments(ARG
-    "DISABLE_LLVM_LINK_LLVM_DYLIB;IGNORE_EXTERNALIZE_DEBUGINFO;NO_INSTALL_RPATH;SUPPORT_PLUGINS;ENABLE_PLUGINS"
+    "DISABLE_LLVM_LINK_LLVM_DYLIB;IGNORE_EXTERNALIZE_DEBUGINFO;NO_INSTALL_RPATH;SUPPORT_PLUGINS"
     "ENTITLEMENTS;BUNDLE_PATH"
     "DEPENDS"
     ${ARGN})
 
   llvm_process_sources( ALL_FILES ${ARG_UNPARSED_ARGUMENTS} )
 
   list(APPEND LLVM_COMMON_DEPENDS ${ARG_DEPENDS})
 
if(NOT ARG_IGNORE_EXTERNALIZE_DEBUGINFO)
     llvm_externalize_debuginfo(${name})
   endif()
   if (LLVM_PTHREAD_LIB)
     # libpthreads overrides some standard library symbols, so main
     # executable must be linked with it in order to provide consistent
     # API for all shared libaries loaded by this executable.
     target_link_libraries(${name} PRIVATE ${LLVM_PTHREAD_LIB})
   endif()
-  if(ARG_ENABLE_PLUGINS)
-    set_property(GLOBAL APPEND PROPERTY LLVM_PLUGIN_TARGETS ${name})
-  endif()
 
   llvm_codesign(${name} ENTITLEMENTS ${ARG_ENTITLEMENTS} BUNDLE_PATH ${ARG_BUNDLE_PATH})
 endmacro(add_llvm_executable name)
 
 # add_llvm_pass_plugin(name [NO_MODULE] ...)
 #   Add ${name} as an llvm plugin.
 #   If option LLVM_${name_upper}_LINK_INTO_TOOLS is set to ON, the plugin is registered statically.
 #   Otherwise a pluggable shared library is registered.
cmake_parse_arguments(ARG
     ${ARGN})
 
   if(ARG_GEN_CONFIG)
       get_property(LLVM_STATIC_EXTENSIONS GLOBAL PROPERTY LLVM_STATIC_EXTENSIONS)
   else()
       include(LLVMConfigExtensions)
   endif()
 
-  # Add static plugins to each plugin target.
+  # Add static plugins to the Extension component
   foreach(llvm_extension ${LLVM_STATIC_EXTENSIONS})
-    get_property(llvm_plugin_targets GLOBAL PROPERTY LLVM_PLUGIN_TARGETS)
-    foreach(llvm_plugin_target ${llvm_plugin_targets})
-      set_property(TARGET ${llvm_plugin_target} APPEND PROPERTY LINK_LIBRARIES ${llvm_extension})
-      set_property(TARGET ${llvm_plugin_target} APPEND PROPERTY INTERFACE_LINK_LIBRARIES ${llvm_extension})
-    endforeach()
+      set_property(TARGET LLVMExtensions APPEND PROPERTY LINK_LIBRARIES ${llvm_extension})
+      set_property(TARGET LLVMExtensions APPEND PROPERTY INTERFACE_LINK_LIBRARIES ${llvm_extension})
   endforeach()
 
-  # Eventually generate the extension header, and store config to a cmake file
+  # Eventually generate the extension headers, and store config to a cmake file
   # for usage in third-party configuration.
   if(ARG_GEN_CONFIG)
+
+      ## Part 1: Extension header to be included whenever we need extension
+      #  processing.
       set(LLVM_INSTALL_PACKAGE_DIR lib${LLVM_LIBDIR_SUFFIX}/cmake/llvm)
       set(llvm_cmake_builddir "${LLVM_BINARY_DIR}/${LLVM_INSTALL_PACKAGE_DIR}")
       file(WRITE
           "${llvm_cmake_builddir}/LLVMConfigExtensions.cmake"
           "set(LLVM_STATIC_EXTENSIONS ${LLVM_STATIC_EXTENSIONS})")
       install(FILES
           ${llvm_cmake_builddir}/LLVMConfigExtensions.cmake
           DESTINATION ${LLVM_INSTALL_PACKAGE_DIR}
           COMPONENT cmake-exports)
 
       set(ExtensionDef "${LLVM_BINARY_DIR}/include/llvm/Support/Extension.def")
       file(WRITE "${ExtensionDef}.tmp" "//extension handlers\n")
       foreach(llvm_extension ${LLVM_STATIC_EXTENSIONS})
           file(APPEND "${ExtensionDef}.tmp" "HANDLE_EXTENSION(${llvm_extension})\n")
       endforeach()
       file(APPEND "${ExtensionDef}.tmp" "#undef HANDLE_EXTENSION\n")
 
       # only replace if there's an actual change
       execute_process(COMMAND ${CMAKE_COMMAND} -E copy_if_different
           "${ExtensionDef}.tmp"
           "${ExtensionDef}")
       file(REMOVE "${ExtensionDef}.tmp")
+
+      ## Part 2: Extension header that captures each extension dependency, to be
+      #  by llvm-config.
+      set(ExtensionDeps "${LLVM_BINARY_DIR}/tools/llvm-config/ExtensionDependencies.inc")
+
+      # Max needed to correctly size the required library array.
+      set(llvm_plugin_max_deps_length 0)
+      foreach(llvm_extension ${LLVM_STATIC_EXTENSIONS})
+        get_property(llvm_plugin_deps TARGET ${llvm_extension} PROPERTY LINK_LIBRARIES)
+        list(LENGTH llvm_plugin_deps llvm_plugin_deps_length)
+        if(llvm_plugin_deps_length GREATER llvm_plugin_max_deps_length)
+            set(llvm_plugin_max_deps_length ${llvm_plugin_deps_length})
+        endif()
+      endforeach()
+
+      list(LENGTH LLVM_STATIC_EXTENSIONS llvm_static_extension_count)
+      file(WRITE
+          "${ExtensionDeps}.tmp"
+          "#include <array>\n\
+           struct ExtensionDescriptor {\n\
+              const char* Name;\n\
+              const char* const RequiredLibraries[1 + 1 + ${llvm_plugin_max_deps_length}];\n\
+           };\n\
+           std::array<ExtensionDescriptor, ${llvm_static_extension_count}>  AvailableExtensions{\n")
+
+      foreach(llvm_extension ${LLVM_STATIC_EXTENSIONS})
+        get_property(llvm_plugin_deps TARGET ${llvm_extension} PROPERTY LINK_LIBRARIES)
+
+        file(APPEND "${ExtensionDeps}.tmp" "{\"${llvm_extension}\", {")
+        foreach(llvm_plugin_dep ${llvm_plugin_deps})
+            # Turn library dependency back to component name, if possible.
+            # That way llvm-config can avoid redundant dependencies.
+            STRING(REGEX REPLACE "^-l" ""  plugin_dep_name ${llvm_plugin_dep})
+            STRING(REGEX MATCH "^LLVM" is_llvm_library ${plugin_dep_name})
+            if(is_llvm_library)
+                STRING(REGEX REPLACE "^LLVM" ""  plugin_dep_name ${plugin_dep_name})
+                STRING(TOLOWER ${plugin_dep_name} plugin_dep_name)
+            endif()
+            file(APPEND "${ExtensionDeps}.tmp" "\"${plugin_dep_name}\", ")
+        endforeach()
+
+        # Self + mandatory trailing null, because the number of RequiredLibraries differs between extensions.
+        file(APPEND "${ExtensionDeps}.tmp" \"${llvm_extension}\", "nullptr}},\n")
+      endforeach()
+      file(APPEND "${ExtensionDeps}.tmp" "};\n")
+
+      # only replace if there's an actual change
+      execute_process(COMMAND ${CMAKE_COMMAND} -E copy_if_different
+          "${ExtensionDeps}.tmp"
+          "${ExtensionDeps}")
+      file(REMOVE "${ExtensionDeps}.tmp")
   endif()
 endfunction()
 
 function(export_executable_symbols target)
   if (LLVM_EXPORTED_SYMBOL_FILE)
     # The symbol file should contain the symbols we want the executable to
     # export
     set_target_properties(${target} PROPERTIES ENABLE_EXPORTS 1)

llvm/lib/CMakeLists.txt

 # `Demangle', `Support' and `TableGen' libraries are added on the top-level
 # CMakeLists.txt
 
 add_subdirectory(IR)
 add_subdirectory(FuzzMutate)
 add_subdirectory(IRReader)
 add_subdirectory(CodeGen)
 add_subdirectory(BinaryFormat)
 add_subdirectory(Bitcode)
 add_subdirectory(Bitstream)
 add_subdirectory(DWARFLinker)
+add_subdirectory(Extensions)
 add_subdirectory(Frontend)
 add_subdirectory(Transforms)
 add_subdirectory(Linker)
 add_subdirectory(Analysis)
 add_subdirectory(LTO)
 add_subdirectory(MC)
 add_subdirectory(MCA)
 add_subdirectory(Object)

llvm/lib/Extensions/CMakeLists.txt

+add_llvm_component_library(LLVMExtensions
+    Extensions.cpp
+)

llvm/lib/Extensions/LLVMBuild.txt

+;===- ./lib/Extensions/LLVMBuild.txt -------------------------------*- Conf -*--===;
+;
+; 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 is an LLVMBuild description file for the components in this subdirectory.
+;
+; For more information on the LLVMBuild system, please see:
+;
+;   http://llvm.org/docs/LLVMBuild.html
+;
+;===------------------------------------------------------------------------===;
+
+[component_0]
+type = Library
+name = Extensions
+parent = Libraries
+required_libraries =

llvm/lib/LLVMBuild.txt

  AsmParser
  Bitcode
  Bitstream
  CodeGen
  DebugInfo
  Demangle
  DWARFLinker
  ExecutionEngine
+ Extensions
  Frontend
  FuzzMutate
  LineEditor
  Linker
  IR
  IRReader
  LTO
  MC

llvm/lib/LTO/CMakeLists.txt

 add_llvm_component_library(LLVMLTO
   Caching.cpp
   LTO.cpp
   LTOBackend.cpp
   LTOModule.cpp
   LTOCodeGenerator.cpp
   SummaryBasedOptimizations.cpp
   UpdateCompilerUsed.cpp
   ThinLTOCodeGenerator.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/LTO
-
-  ENABLE_PLUGINS
-
   DEPENDS
   intrinsics_gen
   llvm_vcsrevision_h
 )

llvm/lib/LTO/LLVMBuild.txt

 required_libraries =
  AggressiveInstCombine
  Analysis
  BinaryFormat
  BitReader
  BitWriter
  CodeGen
  Core
+ Extensions
  IPO
  InstCombine
  Linker
  MC
  ObjCARC
  Object
  Passes
  Remarks
  Scalar
  Support
  Target
  TransformUtils

llvm/tools/bugpoint/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   AllTargetsAsmParsers
   AllTargetsCodeGens
   AllTargetsDescs
   AllTargetsInfos
   Analysis
   BitWriter
   CodeGen
+  Extensions
   Core
   IPO
   IRReader
   AggressiveInstCombine
   InstCombine
   Instrumentation
   Linker
   ObjCARCOpts
add_llvm_tool(bugpoint
   ExecutionDriver.cpp
   ExtractFunction.cpp
   FindBugs.cpp
   Miscompilation.cpp
   OptimizerDriver.cpp
   ToolRunner.cpp
   bugpoint.cpp
 
-  ENABLE_PLUGINS
-
   DEPENDS
   intrinsics_gen
   SUPPORT_PLUGINS
   )
 export_executable_symbols_for_plugins(bugpoint)

llvm/tools/llvm-config/llvm-config.cpp

 // Include the component table. This creates an array of struct
 // AvailableComponent entries, which record the component name, library name,
 // and required components for all of the available libraries.
 //
 // Not all components define a library, we also use "library groups" as a way to
 // create entries for pseudo groups like x86 or all-targets.
 #include "LibraryDependencies.inc"
 
+// Built-in extensions also register their dependencies, but in a separate file,
+// later in the process.
+#include "ExtensionDependencies.inc"
+
 // LinkMode determines what libraries and flags are returned by llvm-config.
 enum LinkMode {
   // LinkModeAuto will link with the default link mode for the installation,
   // which is dependent on the value of LLVM_LINK_LLVM_DYLIB, and fall back
   // to the alternative if the required libraries are not available.
   LinkModeAuto = 0,
 
   // LinkModeShared will link with the dynamic component libraries if they
static void VisitComponent(const std::string &Name,
 
   // Otherwise, visit all the dependencies.
   for (unsigned i = 0; AC->RequiredLibraries[i]; ++i) {
     VisitComponent(AC->RequiredLibraries[i], ComponentMap, VisitedComponents,
                    RequiredLibs, IncludeNonInstalled, GetComponentNames,
                    GetComponentLibraryPath, Missing, DirSep);
   }
 
+  // Special handling for the special 'extensions' component. Its content is
+  // not populated by llvm-build, but later in the process and loaded from
+  // ExtensionDependencies.inc.
+  if (Name == "extensions") {
+    for (auto const &AvailableExtension : AvailableExtensions) {
+      for (const char *const *Iter = &AvailableExtension.RequiredLibraries[0];
+           *Iter; ++Iter) {
+        AvailableComponent *AC = ComponentMap.lookup(*Iter);
+        if (!AC) {
+          RequiredLibs.push_back(*Iter);
+        } else {
+          VisitComponent(*Iter, ComponentMap, VisitedComponents, RequiredLibs,
+                         IncludeNonInstalled, GetComponentNames,
+                         GetComponentLibraryPath, Missing, DirSep);
+        }
+      }
+    }
+  }
+
   if (GetComponentNames) {
     RequiredLibs.push_back(Name);
     return;
   }
 
   // Add to the required library list.
   if (AC->Library) {
     if (Missing && GetComponentLibraryPath) {
       std::string path = (*GetComponentLibraryPath)(AC->Library);
       if (DirSep == "\\") {
         std::replace(path.begin(), path.end(), '/', '\\');
       }
       if (!sys::fs::exists(path))
         Missing->push_back(path);
     }
     RequiredLibs.push_back(AC->Library);
   }
 }
 
 /// Compute the list of required libraries for a given list of
 /// components, in an order suitable for passing to a linker (that is, libraries
 /// appear prior to their dependencies).
 ///
 /// \param Components - The names of the components to find libraries for.
 /// \param IncludeNonInstalled - Whether non-installed components should be
 /// reported.

llvm/tools/opt/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   AllTargetsAsmParsers
   AllTargetsCodeGens
   AllTargetsDescs
   AllTargetsInfos
   AggressiveInstCombine
   Analysis
   BitWriter
   CodeGen
   Core
   Coroutines
+  Extensions
   IPO
   IRReader
   InstCombine
   Instrumentation
   MC
   ObjCARCOpts
   Remarks
   ScalarOpts
   Support
   Target
   TransformUtils
   Vectorize
   Passes
   )
 
 add_llvm_tool(opt
   AnalysisWrappers.cpp
   BreakpointPrinter.cpp
   GraphPrinters.cpp
   NewPMDriver.cpp
   PassPrinters.cpp
   PrintSCC.cpp
   opt.cpp
 
-  ENABLE_PLUGINS
-
   DEPENDS
   intrinsics_gen
   SUPPORT_PLUGINS
   )
 export_executable_symbols_for_plugins(opt)
 
 if(LLVM_BUILD_EXAMPLES)
     target_link_libraries(opt PRIVATE ExampleIRTransforms)
 endif(LLVM_BUILD_EXAMPLES)