Generalize a facility in MLIR CMake for producing aggregate shared and static libraries.

[stellaraccident]

Summary

• Uses this to build an aggregate of the MLIR C-API, as required by the Python bindings.
• Should be extensible to cover the libMLIR use cases with some more work, but check pointing on this simple form to start (it has fewer requirements and low potential to break anyone).
• I think that if this proves successful for MLIR, we may want to make a case to promote it to LLVM and use it to replace the current component system.
• Should allow for both static and shared linkage of aggregate libraries, as well as optionality in terms of what goes in them (while also being correct and not causing ODR issues in expected usage).
• Intended to be a piece to be used both in and out of tree, specifically for projects like npcomp and circt which need to instantiate their own Python and aggregate C-APIs.

[stellaraccident]

Rebase

[stephenneuendorffer]

mlir/cmake/modules/AddMLIR.cmake

57

IS the intention to deprecate usage of EXCLUDE_FROM_LIBMLIR in favor of DISABLE_AGGREGATE?
Seems like this changes the behavior of libMLIR.so. it might be better to not change libMLIR.so until we have a good replacement mechanism and then do the change once to reduce churn?

237–240

Do you mean to check in this debugging code? I don't think it's a bad thing, just asking :)

mlir/lib/Bindings/Python/CMakeLists.txt

13

It's not clear to me how targets depend on this. Do they depend on MLIRPythonCAPI directly? or do they depend on a contained library, like MLIRCAPIGPU?

16

spacing instead of tabs?

[mehdi_amini]

(quickly skimmed, not sure I totally understood it yet)

mlir/cmake/modules/AddMLIR.cmake

54

Can you document the new flag?

104

I don't follow the logic here: should it be an OR ?

[stephenneuendorffer]

Generally speaking I like this approach... It's much simpler than the alternatives that I've seen. I think we should try to take it to the next step....

mlir/cmake/modules/AddMLIR.cmake

176

Should this be a generator expression as well?

mlir/cmake/modules/AddMLIR.cmake

 endfunction()
 
 # Declare an mlir library which can be compiled in libMLIR.so
 # In addition to everything that llvm_add_librar accepts, this
 # also has the following option:
 # EXCLUDE_FROM_LIBMLIR
 #   Don't include this library in libMLIR.so.  This option should be used
 #   for test libraries, executable-specific libraries, or rarely used libraries
 #   with large dependencies.
 function(add_mlir_library name)
   cmake_parse_arguments(ARG
-    "SHARED;INSTALL_WITH_TOOLCHAIN;EXCLUDE_FROM_LIBMLIR"
+    "SHARED;INSTALL_WITH_TOOLCHAIN;EXCLUDE_FROM_LIBMLIR;DISABLE_AGGREGATE"
     ""
     "ADDITIONAL_HEADERS;DEPENDS;LINK_COMPONENTS;LINK_LIBS"
     ${ARGN})
   set(srcs)
   if(MSVC_IDE OR XCODE)
     # Add public headers
     file(RELATIVE_PATH lib_path
       ${MLIR_SOURCE_DIR}/lib/
function(add_mlir_library name)
   else()
     # llvm_add_library ignores BUILD_SHARED_LIBS if STATIC is explicitly set,
     # so we need to handle it here.
     if(BUILD_SHARED_LIBS)
       set(LIBTYPE SHARED)
     else()
       set(LIBTYPE STATIC)
     endif()
-    if(NOT XCODE)
-      # The Xcode generator doesn't handle object libraries correctly.
-      list(APPEND LIBTYPE OBJECT)
-    endif()
     # Test libraries and such shouldn't be include in libMLIR.so
-    if(NOT ARG_EXCLUDE_FROM_LIBMLIR)
+    if(NOT ARG_EXCLUDE_FROM_LIBMLIR AND NOT ARG_DISABLE_AGGREGATE)
       set_property(GLOBAL APPEND PROPERTY MLIR_STATIC_LIBS ${name})
       set_property(GLOBAL APPEND PROPERTY MLIR_LLVM_LINK_COMPONENTS ${ARG_LINK_COMPONENTS})
       set_property(GLOBAL APPEND PROPERTY MLIR_LLVM_LINK_COMPONENTS ${LLVM_LINK_COMPONENTS})
     endif()
   endif()
 
+  if(NOT XCODE AND NOT ARG_DISABLE_AGGREGATE)
+    # The Xcode generator doesn't handle object libraries correctly.
+    list(APPEND LIBTYPE OBJECT)
+  endif()
+
   # MLIR libraries uniformly depend on LLVMSupport.  Just specify it once here.
   list(APPEND ARG_LINK_COMPONENTS Support)
 
   # LINK_COMPONENTS is necessary to allow libLLVM.so to be properly
   # substituted for individual library dependencies if LLVM_LINK_LLVM_DYLIB
   # Perhaps this should be in llvm_add_library instead?  However, it fails
   # on libclang-cpp.so
   get_property(llvm_component_libs GLOBAL PROPERTY LLVM_COMPONENT_LIBS)
function(add_mlir_library name)
   if(TARGET ${name})
     target_link_libraries(${name} INTERFACE ${LLVM_COMMON_LIBS})
     add_mlir_library_install(${name})
   else()
     # Add empty "phony" target
     add_custom_target(${name})
   endif()
   set_target_properties(${name} PROPERTIES FOLDER "MLIR libraries")
+
+  # Setup aggregate.
+  if(NOT ARG_DISABLE_AGGREGATE)
+    # Compute and store the properties needed to build aggregates.
+    set(AGGREGATE_OBJECTS)
+    set(AGGREGATE_DEPS)
+    if(XCODE)
+      # XCode has limited support for object libraries. Instead, add dep flags
+      # that force the entire library to be embedded.
+      list(APPEND AGGREGATE_DEPS "-force_load" "${name}")
+    else()
+      list(APPEND AGGREGATE_OBJECTS "$<TARGET_OBJECTS:obj.${name}>")
+    endif()
+
+    # For each declared dependency, transform it into a generator expression
+    # which excludes it if the ultimate link target is excluding the library.
+    set(NEW_LINK_LIBRARIES)
+    get_target_property(CURRENT_LINK_LIBRARIES  ${name} LINK_LIBRARIES)
+    get_mlir_filtered_link_libraries(NEW_LINK_LIBRARIES ${CURRENT_LINK_LIBRARIES})
+    set_target_properties(${name} PROPERTIES LINK_LIBRARIES "${NEW_LINK_LIBRARIES}")
+    list(APPEND AGGREGATE_DEPS ${NEW_LINK_LIBRARIES})
+    set_target_properties(${name} PROPERTIES
+      MLIR_AGGREGATE_OBJECTS "${AGGREGATE_OBJECTS}"
+    )
+    set_target_properties(${name} PROPERTIES
+      MLIR_AGGREGATE_DEPS "${AGGREGATE_DEPS}"
+    )
+  endif()
 endfunction(add_mlir_library)
 
+# Sets a variable with a transformed list of link libraries such individual
+# libraries will be dynamically excluded when evaluated on a final library
+# which defines an MLIR_AGGREGATE_EXCLUDE_LIBS which contains any of the
+# libraries. Each link library can be a generator expression but must not
+# resolve to an arity > 1 (i.e. it can be optional).
+function(get_mlir_filtered_link_libraries output)
+  set(_results)
+  foreach(linklib ${ARGN})
+    # In English, what this expression does:
+    # For each link library, resolve the property MLIR_AGGREGATE_EXCLUDE_LIBS
+    # on the context target (i.e. the executable or shared library being linked)
+    # and, if it is not in that list, emit the library name. Otherwise, empty.
+    list(APPEND _results
+      "$<$<NOT:$<IN_LIST:${linklib},$<GENEX_EVAL:$<TARGET_PROPERTY:MLIR_AGGREGATE_EXCLUDE_LIBS>>>>:${linklib}>"
+    )
+  endforeach()
+  set(${output} "${_results}" PARENT_SCOPE)
+endfunction(get_mlir_filtered_link_libraries)
+
+# Declares an aggregate library. Such a library is a combination of arbitrary
+# regular add_mlir_library() libraries with the special feature that they can
+# be configured to statically embed some subset of their dependencies, as is
+# typical when creating a .so/.dylib/.dll or a mondo static library.
+#
+# It is always safe to depend on the aggregate directly in order to compile/link
+# against the superset of embedded entities and transitive deps.
+#
+# Arguments:
+#   PUBLIC_LIBS: list of dependent libraries to add to the
+#     INTERFACE_LINK_LIBRARIES property, exporting them to users. This list
+#     will be transitively filtered to exclude any EMBED_LIBS.
+#   EMBED_LIBS: list of dependent libraries that should be embedded directly
+#     into this library. Each of these must be an add_mlir_library() library
+#     without DISABLE_AGGREGATE.
+#
+# Note: This is a work in progress and is presently only sufficient for certain
+# non nested cases involving the C-API.
+function(add_mlir_aggregate name)
+  cmake_parse_arguments(ARG
+    "SHARED;STATIC"
+    ""
+    "PUBLIC_LIBS;EMBED_LIBS"
+    ${ARGN})
+  set(_libtype)
+  if(ARG_STATIC)
+    list(APPEND _libtype STATIC)
+  endif()
+  if(ARG_SHARED)
+    list(APPEND _libtype SHARED)
+  endif()
+  set(_debugmsg)
+
+  set(_embed_libs)
+  set(_objects)
+  set(_deps)
+  foreach(lib ${ARG_EMBED_LIBS})
+    # What these expressions do:
+    # In the context of this aggregate, resolve the list of OBJECTS and DEPS
+    # that each library advertises and patch it into the whole.
+    set(_local_objects $<TARGET_GENEX_EVAL:${name},$<TARGET_PROPERTY:${lib},MLIR_AGGREGATE_OBJECTS>>)
+    set(_local_deps $<TARGET_GENEX_EVAL:${name},$<TARGET_PROPERTY:${lib},MLIR_AGGREGATE_DEPS>>)
+
+    list(APPEND _embed_libs ${lib})
+    list(APPEND _objects ${_local_objects})
+    list(APPEND _deps ${_local_deps})
+
+    string(APPEND _debugmsg
+      ": EMBED_LIB ${lib}:\n"
+      "    OBJECTS = ${_local_objects}\n"
+      "    DEPS = ${_local_deps}\n\n")
+  endforeach()
+
+  add_mlir_library(${name}
+    ${_libtype}
+    ${ARG_UNPARSED_ARGUMENTS}
+    PARTIAL_SOURCES_INTENDED
+    DISABLE_AGGREGATE
+    "${LLVM_MAIN_SRC_DIR}/cmake/dummy.cpp"
+    LINK_LIBS PRIVATE
+    ${_deps}
+    ${ARG_PUBLIC_LIBS}
+  )
+  target_sources(${name} PRIVATE ${_objects})
+  # TODO: Should be transitive.
+  set_target_properties(${name} PROPERTIES
+    MLIR_AGGREGATE_EXCLUDE_LIBS "${_embed_libs}")
+  if(MSVC)
+    set_property(TARGET ${name} PROPERTY WINDOWS_EXPORT_ALL_SYMBOLS ON)
+  endif()
+  string(APPEND _debugmsg
+    ": MAIN LIBRARY:\n"
+    "    OBJECTS = ${_objects}\n"
+    "    SOURCES = $<TARGET_GENEX_EVAL:${name},$<TARGET_PROPERTY:${name},SOURCES>>\n"
+    "    DEPS = ${_deps}\n"
+    "    LINK_LIBRARIES = $<TARGET_GENEX_EVAL:${name},$<TARGET_PROPERTY:${name},LINK_LIBRARIES>>\n"
+    "    MLIR_AGGREGATE_EXCLUDE_LIBS = $<TARGET_GENEX_EVAL:${name},$<TARGET_PROPERTY:${name},MLIR_AGGREGATE_EXCLUDE_LIBS>>\n"
+  )
+  file(GENERATE OUTPUT
+    "${CMAKE_CURRENT_BINARY_DIR}/${name}.aggregate_debug.txt"
+    CONTENT "${_debugmsg}"
+  )
+endfunction(add_mlir_aggregate)
+
 # Adds an MLIR library target for installation.
 # This is usually done as part of add_mlir_library but is broken out for cases
 # where non-standard library builds can be installed.
 function(add_mlir_library_install name)
   if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY)
   get_target_export_arg(${name} MLIR export_to_mlirtargets UMBRELLA mlir-libraries)
   install(TARGETS ${name}
     COMPONENT ${name}

mlir/cmake/modules/AddMLIRPython.cmake

set_target_properties(
     # the output directory must be at the same level of the lib directory
     # where libMLIR.so is installed. This is presently not optimal from a
     # project separation perspective and a discussion on how to better
     # segment MLIR libraries needs to happen.
     LIBRARY_OUTPUT_DIRECTORY ${LLVM_BINARY_DIR}/python
     OUTPUT_NAME "${extname}"
     PREFIX "${PYTHON_MODULE_PREFIX}"
     SUFFIX "${PYTHON_MODULE_SUFFIX}${PYTHON_MODULE_EXTENSION}"
+    NO_SONAME ON
   )
 
   if(WIN32)
     # Need to also set the RUNTIME_OUTPUT_DIRECTORY on Windows in order to
     # control where the .dll gets written.
     set_target_properties(
       ${libname} PROPERTIES
       RUNTIME_OUTPUT_DIRECTORY ${LLVM_BINARY_DIR}/python
     )
   endif()
 
   # pybind11 requires binding code to be compiled with -fvisibility=hidden
   # For static linkage, better code can be generated if the entire project
   # compiles that way, but that is not enforced here. Instead, include a linker
   # script that explicitly hides anything but the PyInit_* symbols, allowing gc
   # to take place.
   set_target_properties(${libname} PROPERTIES CXX_VISIBILITY_PRESET "hidden")
 
-  # Python extensions depends *only* on the public API and LLVMSupport unless
-  # if further dependencies are added explicitly.
   target_link_libraries(${libname}
     PRIVATE
     ${ARG_LINK_LIBS}
     ${PYEXT_LIBADD}
   )
 
   target_link_options(${libname}
     PRIVATE

mlir/lib/Bindings/Python/CMakeLists.txt

 include(AddMLIRPython)
 add_custom_target(MLIRBindingsPythonExtension)
 
 ################################################################################
 # All python extensions must link through one DSO which exports the CAPI, and
 # this must have a globally unique name amongst all embeddors of the python
 # library since it will effectively have global scope.
 #
 # The presence of this aggregate library is part of the long term plan, but its
 # use needs to be made more flexible.
 ################################################################################
 
-set(public_api_libs
+add_mlir_aggregate(MLIRPythonCAPI
+  SHARED
+  EMBED_LIBS
     MLIRCAPIConversion
     MLIRCAPIDebug
     MLIRCEXECUTIONENGINE
     MLIRCAPIIR
     MLIRCAPIRegistration
     MLIRCAPITransforms
 
     # Dialects
     MLIRCAPIAsync
     MLIRCAPIGPU
     MLIRCAPILinalg
     MLIRCAPILLVM
     MLIRCAPIShape
     MLIRCAPISparseTensor
     MLIRCAPIStandard
     MLIRCAPISCF
     MLIRCAPITensor
 )
 
-foreach(lib ${public_api_libs})
-  if(XCODE)
-    # Xcode doesn't support object libraries, so we have to trick it into
-    # linking the static libraries instead.
-    list(APPEND _DEPS "-force_load" ${lib})
-  else()
-    list(APPEND _OBJECTS $<TARGET_OBJECTS:obj.${lib}>)
-  endif()
-  # Accumulate transitive deps of each exported lib into _DEPS.
-  list(APPEND _DEPS  $<TARGET_PROPERTY:${lib},LINK_LIBRARIES>)
-endforeach()
-
-add_mlir_library(MLIRPythonCAPI
-  PARTIAL_SOURCES_INTENDED
-  SHARED
-  ${_OBJECTS}
-  EXCLUDE_FROM_LIBMLIR
-  LINK_LIBS
-  ${_DEPS}
-)
-if(MSVC)
-  set_property(TARGET MLIRPythonCAPI PROPERTY WINDOWS_EXPORT_ALL_SYMBOLS ON)
-endif()
-
 ################################################################################
 # Build core python extension
 ################################################################################
 add_mlir_python_extension(MLIRCoreBindingsPythonExtension _mlir
   INSTALL_DIR
     python
   SOURCES
     DialectLinalg.cpp

mlir/lib/ExecutionEngine/CMakeLists.txt

set(LLVM_OPTIONAL_SOURCES
   OptUtils.cpp
   JitRunner.cpp
   )
 
 add_mlir_library(MLIRExecutionEngine
   ExecutionEngine.cpp
   OptUtils.cpp
 
-  EXCLUDE_FROM_LIBMLIR
+  DISABLE_AGGREGATE
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/ExecutionEngine
 
   DEPENDS
   intrinsics_gen
 
   LINK_COMPONENTS
add_mlir_library(MLIRExecutionEngine
   MLIRLLVMToLLVMIRTranslation
   MLIRTargetLLVMIRExport
   )
 
 get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
 add_mlir_library(MLIRJitRunner
   JitRunner.cpp
 
-  EXCLUDE_FROM_LIBMLIR
+  DISABLE_AGGREGATE
 
   DEPENDS
   intrinsics_gen
 
   LINK_COMPONENTS
   Core
   OrcJIT
   JITLink
 
   LINK_LIBS PUBLIC
   ${dialect_libs}
   MLIRExecutionEngine
   MLIRIR
   MLIRParser
   MLIRStandard
   MLIRLLVMToLLVMIRTranslation
   MLIRTargetLLVMIRExport
   MLIRTransforms
   MLIRStandardToLLVM
   MLIRSupport
 )
 
 add_mlir_library(mlir_c_runner_utils
-  SHARED
+  SHARED DISABLE_AGGREGATE
   CRunnerUtils.cpp
   SparseUtils.cpp
-
-  EXCLUDE_FROM_LIBMLIR
   )
 set_property(TARGET mlir_c_runner_utils PROPERTY CXX_STANDARD 11)
 target_compile_definitions(mlir_c_runner_utils PRIVATE mlir_c_runner_utils_EXPORTS)
 
 add_mlir_library(mlir_runner_utils
-  SHARED
+  SHARED DISABLE_AGGREGATE
   RunnerUtils.cpp
-
-  EXCLUDE_FROM_LIBMLIR
 )
 target_compile_definitions(mlir_runner_utils PRIVATE mlir_runner_utils_EXPORTS)
 
 add_mlir_library(mlir_async_runtime
-  SHARED
+  SHARED DISABLE_AGGREGATE
   AsyncRuntime.cpp
 
-  EXCLUDE_FROM_LIBMLIR
-
   LINK_LIBS PUBLIC
   ${LLVM_PTHREAD_LIB}
 )
 set_property(TARGET mlir_async_runtime PROPERTY CXX_VISIBILITY_PRESET hidden)
 target_compile_definitions(mlir_async_runtime PRIVATE mlir_async_runtime_EXPORTS)
 
 if(MLIR_ENABLE_CUDA_RUNNER)
   # Configure CUDA support. Using check_language first allows us to give a
   # custom error message.
   include(CheckLanguage)
   check_language(CUDA)
   if (CMAKE_CUDA_COMPILER)
     enable_language(CUDA)
   else()
     message(SEND_ERROR
       "Building the mlir cuda runner requires a working CUDA install")
   endif()
 
   # We need the libcuda.so library.
   find_library(CUDA_RUNTIME_LIBRARY cuda)
 
   add_mlir_library(mlir_cuda_runtime
-    SHARED
+    SHARED DISABLE_AGGREGATE
     CudaRuntimeWrappers.cpp
-
-    EXCLUDE_FROM_LIBMLIR
   )
   set_property(TARGET mlir_cuda_runtime PROPERTY CXX_STANDARD 14)
   target_include_directories(mlir_cuda_runtime
     PRIVATE
     ${CMAKE_CUDA_TOOLKIT_INCLUDE_DIRECTORIES}
   )
   target_link_libraries(mlir_cuda_runtime
     PRIVATE
find_library(ROCM_RUNTIME_LIBRARY amdhip64
                PATHS "${HIP_PATH}/lib")
   if (NOT ROCM_RUNTIME_LIBRARY)
     message(SEND_ERROR "Could not locate ROCm HIP runtime library")
   else()
     message(STATUS "ROCm HIP runtime lib: ${ROCM_RUNTIME_LIBRARY}")
   endif()
 
   add_mlir_library(mlir_rocm_runtime
-    SHARED
+    SHARED DISABLE_AGGREGATE
     RocmRuntimeWrappers.cpp
-
-    EXCLUDE_FROM_LIBMLIR
   )
   target_compile_definitions(mlir_rocm_runtime
     PRIVATE
     __HIP_PLATFORM_HCC__
   )
   target_include_directories(mlir_rocm_runtime
     PRIVATE
     ${HIP_PATH}/include
     ${ROCM_PATH}/include
   )
   target_link_libraries(mlir_rocm_runtime
     PRIVATE
     ${ROCM_RUNTIME_LIBRARY}
   )
 endif()