[MLIR] Add rudimentary Swift bindings test case

[GeorgeLyon]

Summary

This commit adds a rudimentary Swift bindings test to MLIR. The basic model for Swift bindings is very similar to Python, in that they are both hidden behind a CMake flag (in Swift's case, MLIR_ENABLE_BINDINGS_SWIFT), and do not affect the build otherwise.

As a compiled, C-style language, Swift can be more deeply integrated into the build system than Python. Specifically, we can actually create Swift targets in CMake that are more-or-less indistinguishable from C and C++ targets (via add_llvm_executable and friends). This will eventually allow us to develop libraries in Swift that do not require a working Swift compiler to be run (assuming we statically link Swift's standard library).
One downside to adding Swift in this way, is that a few places in LLVM's build system add compile definitions and flags which are not compatible with Swift globally to any LLVM target. I have fixed the few such places where this affected Swift bindings for MLIR by using CMake's COMPILE_LANGUAGE generator feature, which allows us to specify directly that certain options or flags are only relevant to C and C++ sources.

Notably, this commit does not add the bindings themselves, just the initial test case demonstrating compiling a Swift target which depends on an MLIR library. My hope is that I can address feedback about how I am integrating with the build system independently of the bindings themselves, and upon merging this to main perhaps add this path to CI so new flags are not added in a way that is incompatible with Swift.

[GeorgeLyon]

Fix a comment

[GeorgeLyon]

Remove some accidental debug code

[Mogball]

Is the eventual end goal adding swift bindings to MLIR upstream?

[GeorgeLyon]

In D128862#3625589, @Mogball wrote:

Is the eventual end goal adding swift bindings to MLIR upstream?

Yes! Sorry if this wasn't clear.

[rriddle]

In D128862#3625612, @GeorgeLyon wrote:

In D128862#3625589, @Mogball wrote:

Is the eventual end goal adding swift bindings to MLIR upstream?

Yes! Sorry if this wasn't clear.

Do you have a discourse link? If not can you post a formal RFC on the LLVM discourse? Feels like this is missing a lot of context.

[GeorgeLyon]

Sure, I’ll post a discourse thread later today.

[GeorgeLyon]

I'll revisit this after some discussion on Discourse.

llvm/cmake/modules/AddLLVM.cmake

 include(GNUInstallDirs)
 include(LLVMDistributionSupport)
 include(LLVMProcessSources)
 include(LLVM-Config)
 include(DetermineGCCCompatible)
 
 function(llvm_update_compile_flags name)
   get_property(sources TARGET ${name} PROPERTY SOURCES)
-  if("${sources}" MATCHES "\\.c(;|$)")
+  if("${sources}" MATCHES "\\.(c|swift)(;|$)")
     set(update_src_props ON)
   endif()
 
   list(APPEND LLVM_COMPILE_CFLAGS " ${LLVM_COMPILE_FLAGS}")
 
   # LLVM_REQUIRES_EH is an internal flag that individual targets can use to
   # force EH
   if(LLVM_REQUIRES_EH OR LLVM_ENABLE_EH)
function(llvm_update_compile_flags name)
   string(REPLACE ";" " " target_compile_cflags " ${LLVM_COMPILE_CFLAGS}")
 
   if(update_src_props)
     foreach(fn ${sources})
       get_filename_component(suf ${fn} EXT)
       if("${suf}" STREQUAL ".cpp")
         set_property(SOURCE ${fn} APPEND_STRING PROPERTY
           COMPILE_FLAGS "${target_compile_flags}")
+        set_property(SOURCE ${fn} APPEND PROPERTY COMPILE_DEFINITIONS ${LLVM_COMPILE_DEFINITIONS})
       endif()
       if("${suf}" STREQUAL ".c")
         set_property(SOURCE ${fn} APPEND_STRING PROPERTY
           COMPILE_FLAGS "${target_compile_cflags}")
+        set_property(SOURCE ${fn} APPEND PROPERTY COMPILE_DEFINITIONS ${LLVM_COMPILE_DEFINITIONS})
       endif()
     endforeach()
   else()
     # Update target props, since all sources are C++.
     set_property(TARGET ${name} APPEND_STRING PROPERTY
       COMPILE_FLAGS "${target_compile_flags}")
-  endif()
-
     set_property(TARGET ${name} APPEND PROPERTY COMPILE_DEFINITIONS ${LLVM_COMPILE_DEFINITIONS})
+  endif()
 endfunction()
 
 function(add_llvm_symbol_exports target_name export_file)
   if(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
     set(native_export_file "${target_name}.exports")
     add_custom_command(OUTPUT ${native_export_file}
       COMMAND sed -e "s/^/_/" < ${export_file} > ${native_export_file}
       DEPENDS ${export_file}

llvm/cmake/modules/HandleLLVMOptions.cmake

 
 # Turn on -gsplit-dwarf if requested in debug builds.
 if (LLVM_USE_SPLIT_DWARF AND
     ((uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG") OR
      (uppercase_CMAKE_BUILD_TYPE STREQUAL "RELWITHDEBINFO")))
   # Limit to clang and gcc so far. Add compilers supporting this option.
   if (CMAKE_CXX_COMPILER_ID MATCHES "Clang" OR
       CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-    add_compile_options(-gsplit-dwarf)
+    add_compile_options($<$<COMPILE_LANGUAGE:C,CXX>:-gsplit-dwarf>)
   include(LLVMCheckLinkerFlag)
   llvm_check_linker_flag(CXX "-Wl,--gdb-index" LINKER_SUPPORTS_GDB_INDEX)
   append_if(LINKER_SUPPORTS_GDB_INDEX "-Wl,--gdb-index"
     CMAKE_EXE_LINKER_FLAGS CMAKE_MODULE_LINKER_FLAGS CMAKE_SHARED_LINKER_FLAGS)
   endif()
 endif()
 
 add_definitions( -D__STDC_CONSTANT_MACROS )

mlir/CMakeLists.txt

 # Build the CUDA conversions and run according tests if the NVPTX backend
 # is available
 if ("NVPTX" IN_LIST LLVM_TARGETS_TO_BUILD)
   set(MLIR_ENABLE_CUDA_CONVERSIONS 1)
 else()
   set(MLIR_ENABLE_CUDA_CONVERSIONS 0)
 endif()
 # TODO: we should use a config.h file like LLVM does
-add_definitions(-DMLIR_CUDA_CONVERSIONS_ENABLED=${MLIR_ENABLE_CUDA_CONVERSIONS})
+add_compile_definitions($<$<COMPILE_LANGUAGE:C,CXX>:MLIR_CUDA_CONVERSIONS_ENABLED=${MLIR_ENABLE_CUDA_CONVERSIONS}>)
 
 # Build the ROCm conversions and run according tests if the AMDGPU backend
 # is available
 if ("AMDGPU" IN_LIST LLVM_TARGETS_TO_BUILD)
   set(MLIR_ENABLE_ROCM_CONVERSIONS 1)
 else()
   set(MLIR_ENABLE_ROCM_CONVERSIONS 0)
 endif()
-add_definitions(-DMLIR_ROCM_CONVERSIONS_ENABLED=${MLIR_ENABLE_ROCM_CONVERSIONS})
+add_compile_definitions($<$<COMPILE_LANGUAGE:C,CXX>:MLIR_ROCM_CONVERSIONS_ENABLED=${MLIR_ENABLE_ROCM_CONVERSIONS}>)
 
 set(MLIR_ENABLE_CUDA_RUNNER 0 CACHE BOOL "Enable building the mlir CUDA runner")
 set(MLIR_ENABLE_ROCM_RUNNER 0 CACHE BOOL "Enable building the mlir ROCm runner")
 set(MLIR_ENABLE_SPIRV_CPU_RUNNER 0 CACHE BOOL "Enable building the mlir SPIR-V cpu runner")
 set(MLIR_ENABLE_VULKAN_RUNNER 0 CACHE BOOL "Enable building the mlir Vulkan runner")
 
 option(MLIR_INCLUDE_TESTS
        "Generate build targets for the MLIR unit tests."
        ${LLVM_INCLUDE_TESTS})
 
 option(MLIR_INCLUDE_INTEGRATION_TESTS
        "Generate build targets for the MLIR integration tests.")
 
 set(MLIR_INSTALL_AGGREGATE_OBJECTS 1 CACHE BOOL
     "Installs object files needed for add_mlir_aggregate to work out of \
     tree. Package maintainers can disable this to exclude these assets if \
     not desired. Enabling this will result in object files being written \
     under lib/objects-{CMAKE_BUILD_TYPE}.")
 
 set(MLIR_BUILD_MLIR_C_DYLIB 0 CACHE BOOL "Builds libMLIR-C shared library.")
 
 #-------------------------------------------------------------------------------
+# Swift Bindings Configuration
+# Requires:
+#   Swift 5.7
+#-------------------------------------------------------------------------------
+
+set(MLIR_ENABLE_BINDINGS_SWIFT 0 CACHE BOOL
+       "Enables building of Swift bindings.")
+if(MLIR_ENABLE_BINDINGS_SWIFT)
+  enable_language(Swift)
+endif()
+
+#-------------------------------------------------------------------------------
 # Python Bindings Configuration
 # Requires:
 #   The pybind11 library can be found (set with -DPYBIND_DIR=...)
 #   The python executable is correct (set with -DPython3_EXECUTABLE=...)
 #-------------------------------------------------------------------------------
 
 set(MLIR_ENABLE_BINDINGS_PYTHON 0 CACHE BOOL
        "Enables building of Python bindings.")

mlir/test/CMakeLists.txt

 add_subdirectory(CAPI)
 add_subdirectory(lib)
 
+if (MLIR_ENABLE_BINDINGS_SWIFT)
+  add_subdirectory(swift)
+endif()
+
 if (MLIR_ENABLE_BINDINGS_PYTHON)
   add_subdirectory(python)
 endif()
 
 # Passed to lit.site.cfg.py.so that the out of tree Standalone dialect test
 # can find MLIR's CMake configuration
 set(MLIR_CMAKE_DIR
   "${CMAKE_BINARY_DIR}/lib${LLVM_LIBDIR_SUFFIX}/cmake/mlir")
file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/Integration/data/mttkrp_b.tns
             ${CMAKE_CURRENT_SOURCE_DIR}/Integration/data/test_symmetric_complex.mtx
             ${CMAKE_CURRENT_SOURCE_DIR}/Integration/data/test.tns
             ${CMAKE_CURRENT_SOURCE_DIR}/Integration/data/wide.mtx
           DESTINATION ${MLIR_INTEGRATION_TEST_DIR}/data/)
 endif()
 
 llvm_canonicalize_cmake_booleans(
   LLVM_BUILD_EXAMPLES
+  MLIR_ENABLE_BINDINGS_SWIFT
   MLIR_ENABLE_BINDINGS_PYTHON
   MLIR_ENABLE_CUDA_CONVERSIONS
   MLIR_ENABLE_CUDA_RUNNER
   MLIR_ENABLE_ROCM_CONVERSIONS
   MLIR_ENABLE_ROCM_RUNNER
   MLIR_ENABLE_SPIRV_CPU_RUNNER
   MLIR_ENABLE_VULKAN_RUNNER
   MLIR_INCLUDE_INTEGRATION_TESTS

 endif()
 
 if(MLIR_ENABLE_VULKAN_RUNNER)
   list(APPEND MLIR_TEST_DEPENDS
     mlir-vulkan-runner
   )
 endif()
 
+if(MLIR_ENABLE_BINDINGS_SWIFT)
+  list(APPEND MLIR_TEST_DEPENDS
+    mlir-swift-ir-test
+  )
+endif()
+
 if(MLIR_ENABLE_BINDINGS_PYTHON)
   list(APPEND MLIR_TEST_DEPENDS
     MLIRPythonModules
   )
 endif()
 
 # This target can be used to just build the dependencies
 # for the check-mlir target without executing the tests.

mlir/test/lit.cfg.py

tools = [
     'mlir-lsp-server',
     'mlir-capi-execution-engine-test',
     'mlir-capi-ir-test',
     'mlir-capi-llvm-test',
     'mlir-capi-pass-test',
     'mlir-capi-sparse-tensor-test',
     'mlir-capi-quant-test',
     'mlir-capi-pdl-test',
+    'mlir-swift-ir-test',
     'mlir-cpu-runner',
     'mlir-linalg-ods-yaml-gen',
     'mlir-reduce',
     'mlir-pdll',
 ]
 
 # The following tools are optional
 tools.extend([

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

 config.enable_cuda_runner = @MLIR_ENABLE_CUDA_RUNNER@
 config.run_rocm_tests = @MLIR_ENABLE_ROCM_CONVERSIONS@
 config.enable_rocm_runner = @MLIR_ENABLE_ROCM_RUNNER@
 config.rocm_test_chipset = "@ROCM_TEST_CHIPSET@"
 config.spirv_wrapper_library_dir = "@MLIR_SPIRV_WRAPPER_LIBRARY_DIR@"
 config.enable_spirv_cpu_runner = @MLIR_ENABLE_SPIRV_CPU_RUNNER@
 config.vulkan_wrapper_library_dir = "@MLIR_VULKAN_WRAPPER_LIBRARY_DIR@"
 config.enable_vulkan_runner = @MLIR_ENABLE_VULKAN_RUNNER@
+config.enable_bindings_swift = @MLIR_ENABLE_BINDINGS_SWIFT@
 config.enable_bindings_python = @MLIR_ENABLE_BINDINGS_PYTHON@
 config.mlir_integration_test_dir = "@MLIR_INTEGRATION_TEST_DIR@"
 config.intel_sde_executable = "@INTEL_SDE_EXECUTABLE@"
 config.mlir_run_amx_tests = @MLIR_RUN_AMX_TESTS@
 config.mlir_run_x86vector_tests = @MLIR_RUN_X86VECTOR_TESTS@
 config.mlir_run_cuda_tensor_core_tests = @MLIR_RUN_CUDA_TENSOR_CORE_TESTS@
 config.mlir_include_integration_tests = @MLIR_INCLUDE_INTEGRATION_TESTS@
 config.arm_emulator_executable = "@ARM_EMULATOR_EXECUTABLE@"

mlir/test/swift/CMakeLists.txt

+function(_add_swift_test_executable name)
+  cmake_parse_arguments(ARG
+    ""
+    ""
+    "LINK_LIBS"
+    ${ARGN})
+  set(LLVM_LINK_COMPONENTS
+    )
+  add_llvm_executable(${name}
+    PARTIAL_SOURCES_INTENDED
+    ${ARG_UNPARSED_ARGUMENTS})
+  llvm_update_compile_flags(${name})
+  if(MLIR_BUILD_MLIR_C_DYLIB)
+    target_link_libraries(${name} PRIVATE
+      MLIR-C)
+  else()
+    target_link_libraries(${name} PRIVATE
+      ${ARG_LINK_LIBS})
+  endif()
+endfunction(_add_swift_test_executable)
+
+_add_swift_test_executable(mlir-swift-ir-test
+  ir.swift
+  LINK_LIBS PRIVATE
+    MLIRIR
+)

mlir/test/swift/ir.swift

+//===- ir.swift - Simple test of Swift APIs -------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+/* RUN: mlir-swift-ir-test 2>&1 | FileCheck %s
+ */
+
+// CHECK-LABEL: @swift
+print("@swift")

mlir/test/swift/lit.local.cfg

+config.suffixes.add('.swift')
+
+if not config.enable_bindings_swift:
+  config.unsupported = True