llvmbuildectomy - replace llvm-build by plain cmake

No longer rely on an external tool to build the llvm component layout.

Instead, leverage the existing `add_llvm_componentlibrary` cmake function and
introduce `add_llvm_component_group` to accurately describe component behavior.

These function store extra properties in the created targets. These properties
are processed once all components are defined to resolve library dependencies
and produce the header expected by llvm-config.

Differential Revision: https://reviews.llvm.org/D90848

Author: serge-sans-paille

llvm/CMakeLists.txt

@@ -714,67 +714,6 @@ if(NOT Python3_Interpreter_FOUND)
   set(Python3_EXECUTABLE ${Python2_EXECUTABLE})
 endif()
 
-######
-# LLVMBuild Integration
-#
-# We use llvm-build to generate all the data required by the CMake based
-# build system in one swoop:
-#
-#  - We generate a file (a CMake fragment) in the object root which contains
-#    all the definitions that are required by CMake.
-#
-#  - We generate the library table used by llvm-config.
-#
-#  - We generate the dependencies for the CMake fragment, so that we will
-#    automatically reconfigure ourselves.
-
-set(LLVMBUILDTOOL "${LLVM_MAIN_SRC_DIR}/utils/llvm-build/llvm-build")
-set(LLVMCONFIGLIBRARYDEPENDENCIESINC
-  "${LLVM_BINARY_DIR}/tools/llvm-config/LibraryDependencies.inc")
-set(LLVMBUILDCMAKEFRAG
-  "${LLVM_BINARY_DIR}/LLVMBuild.cmake")
-
-# Create the list of optional components that are enabled
-if (LLVM_USE_INTEL_JITEVENTS)
-  set(LLVMOPTIONALCOMPONENTS IntelJITEvents)
-endif (LLVM_USE_INTEL_JITEVENTS)
-if (LLVM_USE_OPROFILE)
-  set(LLVMOPTIONALCOMPONENTS ${LLVMOPTIONALCOMPONENTS} OProfileJIT)
-endif (LLVM_USE_OPROFILE)
-if (LLVM_USE_PERF)
-  set(LLVMOPTIONALCOMPONENTS ${LLVMOPTIONALCOMPONENTS} PerfJITEvents)
-endif (LLVM_USE_PERF)
-
-message(STATUS "Constructing LLVMBuild project information")
-execute_process(
-  COMMAND "${Python3_EXECUTABLE}" -B ${LLVMBUILDTOOL}
-            --native-target "${LLVM_NATIVE_ARCH}"
-            --enable-targets "${LLVM_TARGETS_TO_BUILD}"
-            --enable-optional-components "${LLVMOPTIONALCOMPONENTS}"
-            --write-library-table ${LLVMCONFIGLIBRARYDEPENDENCIESINC}
-            --write-cmake-fragment ${LLVMBUILDCMAKEFRAG}
-            OUTPUT_VARIABLE LLVMBUILDOUTPUT
-            ERROR_VARIABLE LLVMBUILDERRORS
-            OUTPUT_STRIP_TRAILING_WHITESPACE
-            ERROR_STRIP_TRAILING_WHITESPACE
-  RESULT_VARIABLE LLVMBUILDRESULT)
-
-# On Win32, CMake doesn't properly handle piping the default output/error
-# streams into the GUI console. So, we explicitly catch and report them.
-if( NOT "${LLVMBUILDOUTPUT}" STREQUAL "")
-  message(STATUS "llvm-build output: ${LLVMBUILDOUTPUT}")
-endif()
-if( NOT "${LLVMBUILDRESULT}" STREQUAL "0" )
-  message(FATAL_ERROR
-    "Unexpected failure executing llvm-build: ${LLVMBUILDERRORS}")
-endif()
-
-# Include the generated CMake fragment. This will define properties from the
-# LLVMBuild files in a format which is easy to consume from CMake, and will add
-# the dependencies so that CMake will reconfigure properly when the LLVMBuild
-# files change.
-include(${LLVMBUILDCMAKEFRAG})
-
 ######
 
 # Configure all of the various header file fragments LLVM uses which depend on

llvm/LLVMBuild.txt

@@ -616,6 +616,13 @@ function(llvm_add_library name)
     endif()
   endif()
 
+  if(ARG_STATIC)
+    set(libtype PUBLIC)
+  else()
+    # We can use PRIVATE since SO knows its dependent libs.
+    set(libtype PRIVATE)
+  endif()
+
   if(ARG_MODULE AND LLVM_EXPORT_SYMBOLS_FOR_PLUGINS AND ARG_PLUGIN_TOOL AND (WIN32 OR CYGWIN))
     # On DLL platforms symbols are imported from the tool by linking against it.
     set(llvm_libs ${ARG_PLUGIN_TOOL})
@@ -630,19 +637,19 @@ function(llvm_add_library name)
     endif()
   else()
     # Components have not been defined explicitly in CMake, so add the
-    # dependency information for this library as defined by LLVMBuild.
+    # dependency information for this library through their name, and let
+    # LLVMBuildResolveComponentsLink resolve the mapping.
     #
     # It would be nice to verify that we have the dependencies for this library
     # name, but using get_property(... SET) doesn't suffice to determine if a
     # property has been set to an empty value.
-    get_property(lib_deps GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_${name})
-  endif()
+    set_property(TARGET ${name} PROPERTY LLVM_LINK_COMPONENTS ${ARG_LINK_COMPONENTS} ${LLVM_LINK_COMPONENTS})
 
-  if(ARG_STATIC)
-    set(libtype PUBLIC)
-  else()
-    # We can use PRIVATE since SO knows its dependent libs.
-    set(libtype PRIVATE)
+    # These two properties are internal properties only used to make sure the
+    # link step applied in LLVMBuildResolveComponentsLink uses the same
+    # properties as the target_link_libraries call below.
+    set_property(TARGET ${name} PROPERTY LLVM_LINK_LIBS ${ARG_LINK_LIBS})
+    set_property(TARGET ${name} PROPERTY LLVM_LIBTYPE ${libtype})
   endif()
 
   target_link_libraries(${name} ${libtype}
@@ -723,8 +730,49 @@ function(add_llvm_install_targets target)
   endif()
 endfunction()
 
+# Define special targets that behave like a component group. They don't have any
+# source attached but other components can add themselves to them. If the
+# component supports is a Target and it supports JIT compilation, HAS_JIT must
+# be passed. One can use ADD_TO_COMPONENT option from add_llvm_component_library
+# to link extra component into an existing group.
+function(add_llvm_component_group name)
+  cmake_parse_arguments(ARG "HAS_JIT" "" "LINK_COMPONENTS" ${ARGN})
+  add_custom_target(${name})
+  if(ARG_HAS_JIT)
+    set_property(TARGET ${name} PROPERTY COMPONENT_HAS_JIT ON)
+  endif()
+  if(ARG_LINK_COMPONENTS)
+    set_property(TARGET ${name} PROPERTY LLVM_LINK_COMPONENTS ${ARG_LINK_COMPONENTS})
+  endif()
+endfunction()
+
+# An LLVM component is a cmake target with the following cmake properties
+# eventually set:
+#   - LLVM_COMPONENT_NAME: the name of the component, which can be the name of
+#     the associated library or the one specified through COMPONENT_NAME
+#   - LLVM_LINK_COMPONENTS: a list of component this component depends on
+#   - COMPONENT_HAS_JIT: (only for group component) whether this target group
+#     supports JIT compilation
+# Additionnaly, the ADD_TO_COMPONENT <component> option make it possible to add this
+# component to the LLVM_LINK_COMPONENTS of <component>.
 function(add_llvm_component_library name)
-  add_llvm_library(${name} COMPONENT_LIB ${ARGN})
+  cmake_parse_arguments(ARG
+    ""
+    "COMPONENT_NAME;ADD_TO_COMPONENT"
+    ""
+    ${ARGN})
+  add_llvm_library(${name} COMPONENT_LIB ${ARG_UNPARSED_ARGUMENTS})
+  string(REGEX REPLACE "^LLVM" "" component_name ${name})
+  set_property(TARGET ${name} PROPERTY LLVM_COMPONENT_NAME ${component_name})
+
+  if(ARG_COMPONENT_NAME)
+    set_property(GLOBAL PROPERTY LLVM_COMPONENT_NAME_${ARG_COMPONENT_NAME} ${component_name})
+  endif()
+
+  if(ARG_ADD_TO_COMPONENT)
+    set_property(TARGET ${ARG_ADD_TO_COMPONENT} APPEND PROPERTY LLVM_LINK_COMPONENTS ${component_name})
+  endif()
+
 endfunction()
 
 macro(add_llvm_library name)

llvm/bindings/LLVMBuild.txt

@@ -0,0 +1,99 @@
+# Generate C code in the file provided as OUTPUT that describes the properties
+# of all components. This C code is suitable for inclusion in `llvm-config`
+function(LLVMBuildGenerateCFragment)
+  cmake_parse_arguments(ARG "" "OUTPUT" "" ${ARGN})
+
+  # Write C header
+  #################
+  get_property(llvmbuild_components GLOBAL PROPERTY LLVM_COMPONENT_LIBS)
+  foreach(llvmbuild_component ${llvmbuild_components})
+    string(REGEX REPLACE "^LLVM" "" component_name ${llvmbuild_component})
+    list(APPEND all_component_libdeps ${component_name})
+  endforeach()
+  list(APPEND llvmbuild_components all)
+  list(APPEND llvmbuild_components all-targets)
+  list(APPEND llvmbuild_components Engine)
+  list(APPEND llvmbuild_components Native)
+  list(APPEND llvmbuild_components NativeCodeGen)
+  foreach(llvm_target_to_build ${LLVM_TARGETS_TO_BUILD})
+    list(APPEND llvmbuild_components ${llvm_target_to_build})
+  endforeach()
+
+  list(LENGTH llvmbuild_components llvmbuild_components_size)
+  file(WRITE ${ARG_OUTPUT}
+  "
+  struct AvailableComponent {
+    /// The name of the component.
+    const char *Name;
+
+    /// The name of the library for this component (or NULL).
+    const char *Library;
+
+    /// Whether the component is installed.
+    bool IsInstalled;
+
+    /// The list of libraries required when linking this component.
+    const char *RequiredLibraries[${llvmbuild_components_size}];
+  } AvailableComponents[${llvmbuild_components_size}] = {
+  ")
+
+  foreach(llvmbuild_component ${llvmbuild_components})
+    if(llvmbuild_component STREQUAL "all")
+      unset(llvmbuild_libname)
+      set(llvmbuild_libdeps ${all_component_libdeps})
+    else()
+      get_property(llvmbuild_libname TARGET ${llvmbuild_component} PROPERTY LLVM_COMPONENT_NAME)
+      get_property(llvmbuild_libdeps TARGET ${llvmbuild_component} PROPERTY LLVM_LINK_COMPONENTS)
+    endif()
+    string(TOLOWER ${llvmbuild_component} llvmbuild_componentname)
+
+    if(NOT llvmbuild_libname)
+      set(llvmbuild_llvmlibname nullptr)
+      string(TOLOWER ${llvmbuild_component} llvmbuild_libname)
+    else()
+      set(llvmbuild_llvmlibname "\"LLVM${llvmbuild_libname}\"")
+      string(TOLOWER ${llvmbuild_libname} llvmbuild_libname)
+    endif()
+
+    set(llvmbuild_clibdeps "")
+    foreach(llvmbuild_libdep ${llvmbuild_libdeps})
+      get_property(llvmbuild_libdepname GLOBAL PROPERTY LLVM_COMPONENT_NAME_${llvmbuild_libdep})
+      if(NOT llvmbuild_libdepname)
+        string(TOLOWER ${llvmbuild_libdep} llvmbuild_clibdep)
+      else()
+        string(TOLOWER ${llvmbuild_libdepname} llvmbuild_clibdep)
+      endif()
+      list(APPEND llvmbuild_clibdeps ${llvmbuild_clibdep})
+    endforeach()
+
+    list(TRANSFORM llvmbuild_clibdeps PREPEND "\"")
+    list(TRANSFORM llvmbuild_clibdeps APPEND "\"")
+    list(JOIN llvmbuild_clibdeps ", " llvmbuild_clibdeps_joint)
+    list(APPEND llvmbuild_centries "{ \"${llvmbuild_libname}\", ${llvmbuild_llvmlibname}, true, {${llvmbuild_clibdeps_joint}} },\n")
+  endforeach()
+
+  list(SORT llvmbuild_centries)
+  foreach(llvmbuild_centry ${llvmbuild_centries})
+    file(APPEND ${ARG_OUTPUT} "${llvmbuild_centry}")
+  endforeach()
+  file(APPEND ${ARG_OUTPUT} "};")
+endfunction()
+
+# Resolve cross-component dependencies, for each available component.
+function(LLVMBuildResolveComponentsLink)
+  get_property(llvm_components GLOBAL PROPERTY LLVM_COMPONENT_LIBS)
+  get_property(llvm_has_jit_native TARGET ${LLVM_NATIVE_ARCH} PROPERTY LLVM_HAS_JIT)
+  if(llvm_has_jit_native)
+    set_property(TARGET Engine APPEND PROPERTY LLVM_LINK_COMPONENTS "MCJIT" "Native")
+  else()
+    set_property(TARGET Engine APPEND PROPERTY LLVM_LINK_COMPONENTS "Interpreter")
+  endif()
+  foreach(llvm_component ${llvm_components})
+    get_property(link_components TARGET ${llvm_component} PROPERTY LLVM_LINK_COMPONENTS)
+    llvm_map_components_to_libnames(llvm_libs ${link_components})
+    if(llvm_libs)
+      get_property(libtype TARGET ${llvm_component} PROPERTY LLVM_LIBTYPE)
+      target_link_libraries(${llvm_component} ${libtype} ${llvm_libs})
+    endif()
+  endforeach()
+endfunction()

llvm/cmake/modules/AddLLVM.cmake

@@ -253,6 +253,10 @@ function(llvm_map_components_to_libnames out_libs)
   # Translate symbolic component names to real libraries:
   llvm_expand_pseudo_components(link_components ${link_components})
   foreach(c ${link_components})
+    get_property(c_rename GLOBAL PROPERTY LLVM_COMPONENT_NAME_${c})
+    if(c_rename)
+        set(c ${c_rename})
+    endif()
     if( c STREQUAL "native" )
       # already processed
     elseif( c STREQUAL "backend" )

llvm/cmake/modules/LLVM-Build.cmake

@@ -748,8 +748,7 @@ Library Layering
 ^^^^^^^^^^^^^^^^
 
 A directory of header files (for example ``include/llvm/Foo``) defines a
-library (``Foo``). Dependencies between libraries are defined by the
-``LLVMBuild.txt`` file in their implementation (``lib/Foo``). One library (both
+library (``Foo``). One library (both
 its headers and implementation) should only use things from the libraries
 listed in its dependencies.
 

llvm/cmake/modules/LLVM-Config.cmake

@@ -73,7 +73,6 @@ Developer Tools
    FileCheck
    tblgen
    lit
-   llvm-build
    llvm-exegesis
    llvm-pdbutil
    llvm-locstats