anydsl_runtime-config.cmake.in

# Try to find AnyDSL Runtime library and include path.
# Once done this will define
#
# AnyDSL_runtime_DIR
# AnyDSL_runtime_LIBRARIES
# AnyDSL_runtime_ARTIC_JIT_LIBRARIES
# AnyDSL_runtime_IMPALA_JIT_LIBRARIES
# AnyDSL_runtime_INCLUDE_DIRS
# AnyDSL_runtime_FOUND
# AnyDSL_runtime_HAS_JIT_SUPPORT

cmake_minimum_required(VERSION 3.13.4)

enable_language(C)

find_path(AnyDSL_runtime_DIR
    NAMES
        anydsl_runtime-config.cmake
    PATHS
        ${AnyDSL_runtime_DIR}
        $ENV{AnyDSL_runtime_DIR}
        ${CMAKE_CURRENT_LIST_DIR}
        "@CMAKE_CURRENT_BINARY_DIR@"
        "@CMAKE_INSTALL_PREFIX@"
    PATH_SUFFIXES
        share/anydsl/cmake
)

find_path(AnyDSL_runtime_ROOT_DIR
    NAMES
        cmake/anydsl_runtime-config.cmake.in
        src/anydsl_runtime.h
        src/anydsl_runtime.hpp
    PATHS
        ${AnyDSL_runtime_ROOT_DIR}
        "@CMAKE_CURRENT_SOURCE_DIR@"
        "@CMAKE_SOURCE_DIR@"
)

find_path(AnyDSL_runtime_INCLUDE_DIR
    NAMES
        anydsl_runtime_config.h
    PATHS
        ${AnyDSL_runtime_ROOT_DIR}
        ${AnyDSL_runtime_DIR}
        "@CMAKE_CURRENT_BINARY_DIR@"
    PATH_SUFFIXES
        include
        ../../../include
)
set(AnyDSL_runtime_INCLUDE_DIRS ${AnyDSL_runtime_INCLUDE_DIR} ${AnyDSL_runtime_ROOT_DIR}/src)

if(NOT TARGET runtime)
    include(${AnyDSL_runtime_DIR}/anydsl_runtime-exports.cmake)
endif()

set(AnyDSL_runtime_LIBRARIES runtime)
set(AnyDSL_runtime_ARTIC_JIT_LIBRARIES runtime_jit_artic)
set(AnyDSL_runtime_IMPALA_JIT_LIBRARIES runtime_jit_impala)
if(MSVC)
    set(AnyDSL_runtime_LIBRARIES ${AnyDSL_runtime_LIBRARIES} optimized msvcrt debug msvcrtd)
    set(AnyDSL_runtime_ARTIC_JIT_LIBRARIES ${AnyDSL_runtime_ARTIC_JIT_LIBRARIES} optimized msvcrt debug msvcrtd)
    set(AnyDSL_runtime_IMPALA_JIT_LIBRARIES ${AnyDSL_runtime_IMPALA_JIT_LIBRARIES} optimized msvcrt debug msvcrtd)
endif()

# determine artic binary for toolchain
find_path(Artic_DIR
    NAMES artic-config.cmake
    PATHS ${Artic_DIR} $ENV{Artic_DIR} "@Artic_DIR@" "@CMAKE_CURRENT_BINARY_DIR@/share/anydsl/cmake"
    PATH_SUFFIXES share/anydsl/cmake
)
find_package(Artic QUIET PATHS ${Artic_DIR})
if(TARGET artic AND NOT Artic_BIN)
    get_target_property(Artic_BIN artic LOCATION)
    set(Artic_BIN ${Artic_BIN} CACHE FILEPATH "path to artic executable")
endif()
find_program(Artic_BIN artic
    PATHS ${Artic_BINARY_DIR} "@CMAKE_CURRENT_BINARY_DIR@/bin"
    PATH_SUFFIXES Release ${CMAKE_CONFIGURATION_TYPES})

# determine impala binary for toolchain
find_path(Impala_DIR
    NAMES impala-config.cmake
    PATHS ${Impala_DIR} $ENV{Impala_DIR} "@Impala_DIR@" "@CMAKE_CURRENT_BINARY_DIR@/share/anydsl/cmake"
    PATH_SUFFIXES share/anydsl/cmake
)
find_package(Impala QUIET PATHS ${Impala_DIR})
if(TARGET impala AND NOT Impala_BIN)
    get_target_property(Impala_BIN impala LOCATION)
    set(Impala_BIN ${Impala_BIN} CACHE FILEPATH "path to impala executable")
endif()
find_program(Impala_BIN impala
    PATHS ${Impala_BINARY_DIR} "@CMAKE_CURRENT_BINARY_DIR@/bin"
    PATH_SUFFIXES Release ${CMAKE_CONFIGURATION_TYPES})

find_package(LLVM CONFIG QUIET PATHS ${LLVM_DIR} $ENV{LLVM_DIR} "@LLVM_DIR@" NO_DEFAULT_PATH)

set(AnyDSL_runtime_HAS_CUDA_SUPPORT    @AnyDSL_runtime_HAS_CUDA_SUPPORT@)
set(AnyDSL_runtime_HAS_OPENCL_SUPPORT  @AnyDSL_runtime_HAS_OPENCL_SUPPORT@)
set(AnyDSL_runtime_HAS_HSA_SUPPORT     @AnyDSL_runtime_HAS_HSA_SUPPORT@)
set(AnyDSL_runtime_HAS_PAL_SUPPORT     @AnyDSL_runtime_HAS_PAL_SUPPORT@)
set(AnyDSL_runtime_HAS_TBB_SUPPORT     @AnyDSL_runtime_HAS_TBB_SUPPORT@)
set(AnyDSL_runtime_HAS_LLVM_SUPPORT    @AnyDSL_runtime_HAS_LLVM_SUPPORT@)
set(AnyDSL_runtime_HAS_JIT_SUPPORT     @AnyDSL_runtime_HAS_JIT_SUPPORT@)

if(AnyDSL_runtime_HAS_LLVM_SUPPORT)
    find_package(LLVM REQUIRED)
endif()
if(AnyDSL_runtime_HAS_JIT_SUPPORT)
    find_package(Thorin REQUIRED)
endif()

# determine clang binary for toolchain
find_package(Clang CONFIG QUIET PATHS ${Clang_DIR} ${LLVM_DIR} PATH_SUFFIXES "../clang" "../lib/cmake/clang" NO_DEFAULT_PATH)
if(TARGET clang AND NOT Clang_BIN)
    get_target_property(Clang_BIN clang LOCATION)
    set(Clang_BIN ${Clang_BIN} CACHE FILEPATH "path to clang executable")
endif()
find_program(Clang_BIN clang
    PATHS ${LLVM_TOOLS_BINARY_DIR} ${LLVM_INSTALL_PREFIX}/bin
    PATH_SUFFIXES Release ${CMAKE_CONFIGURATION_TYPES}
)

find_program(LLVM_AS_BIN llvm-as
    PATHS ${LLVM_TOOLS_BINARY_DIR} ${LLVM_INSTALL_PREFIX}/bin
    PATH_SUFFIXES @CMAKE_CONFIGURATION_TYPES@)
if(LLVM_AS_BIN)
    message(STATUS "Found llvm-as: ${LLVM_AS_BIN}")
    message(STATUS "Note: llvm-as version needs to match the required LLVM bitcode version from NVVM.")
else()
    message(STATUS "Could not find llvm-as binary.")
    message(STATUS "llvm-as is required to generate LLVM bitcode for NVVM.")
    message(STATUS "llvm-as version needs to match the required LLVM bitcode version from NVVM.")
endif()

find_program(OPT_BIN opt
    PATHS ${LLVM_TOOLS_BINARY_DIR} ${LLVM_INSTALL_PREFIX}/bin
    PATH_SUFFIXES @CMAKE_CONFIGURATION_TYPES@)
if(OPT_BIN)
    message(STATUS "Found opt: ${OPT_BIN}")
else()
    message(STATUS "Could not find opt binary.")
    message(STATUS "opt is required to apply selective optimization passes for HLS code generation ")
endif()

# find python for post-patcher.py
find_package(Python3 COMPONENTS Interpreter REQUIRED)

# prepare function
# anydsl_runtime_wrap(
#   output
#   [INTERFACE header_file]
#   [NAME module_name]
#   [FRONTEND frontend_name]
#   [ARTIC_FLAGS [args1...]]
#   [IMPALA_FLAGS [args2...]]
#   [CLANG_FLAGS [args6...]]
#   [HLS_FLAGS [args7...]]
#   [FILES [files...]]
# )

set(OPT_FLAGS_DEBUG "-g")
set(OPT_FLAGS_RELEASE "-O3")
set(OPT_FLAGS)

get_property(_debug_configs GLOBAL PROPERTY DEBUG_CONFIGURATIONS)
if(NOT _debug_configs)
    set(_debug_configs "Debug")
endif()
set(_release_configs ${CMAKE_CONFIGURATION_TYPES} ${CMAKE_BUILD_TYPE})
if(NOT _release_configs)
    set(_release_configs "Release")
endif()
list(REMOVE_ITEM _release_configs ${_debug_configs})
list(REMOVE_DUPLICATES _release_configs)

message(STATUS "AnyDSL debug flags (${_debug_configs}): ${OPT_FLAGS_DEBUG}")
foreach(_config ${_debug_configs})
    foreach(_flag ${OPT_FLAGS_DEBUG})
        list(APPEND OPT_FLAGS "$<$<CONFIG:${_config}>:${_flag}>")
    endforeach()
endforeach()

message(STATUS "AnyDSL release flags (${_release_configs}): ${OPT_FLAGS_RELEASE}")
foreach(_config ${_release_configs})
    foreach(_flag ${OPT_FLAGS_RELEASE})
        list(APPEND OPT_FLAGS "$<$<CONFIG:${_config}>:${_flag}>")
    endforeach()
endforeach()

function(anydsl_runtime_wrap outfiles)
    cmake_parse_arguments(
        "PARGS"
        "EMIT_C"
        "FRONTEND;INTERFACE;NAME"
        "ARTIC_FLAGS;IMPALA_FLAGS;CLANG_FLAGS;HLS_FLAGS;FILES" ${ARGN})
    if(NOT "${PARGS_UNPARSED_ARGUMENTS}" STREQUAL "")
        message(FATAL_ERROR "Unparsed arguments ${PARGS_UNPARSED_ARGUMENTS}")
    endif()

    set(_additional_platform_files)

    if(NOT PARGS_FRONTEND)
        set(_frontend "impala")
    else()
        string(TOLOWER ${PARGS_FRONTEND} _frontend)
    endif()

    if(${_frontend} STREQUAL "artic")
        # check for artic in toolchain
        if(NOT Artic_BIN)
            message(FATAL_ERROR "Could not find artic binary, please set Artic_DIR or Artic_BIN respectively")
        endif()
        set(_frontend_flags ${PARGS_ARTIC_FLAGS} ${OPT_FLAGS})
        set(_frontend_bin ${Artic_BIN})
        list(APPEND _additional_platform_files ${AnyDSL_runtime_ROOT_DIR}/platforms/artic/intrinsics_math.impala
                                               ${AnyDSL_runtime_ROOT_DIR}/platforms/artic/intrinsics_wmma.impala
                                               ${AnyDSL_runtime_ROOT_DIR}/platforms/artic/intrinsics_spirv.impala
                                               ${AnyDSL_runtime_ROOT_DIR}/platforms/artic/intrinsics_levelzero.impala)
    endif()

    if(${_frontend} STREQUAL "impala")
        # check for impala in toolchain
        if(NOT Impala_BIN)
            message(FATAL_ERROR "Could not find impala binary, please set Impala_DIR or Impala_BIN respectively")
        endif()
        set(_frontend_flags ${PARGS_IMPALA_FLAGS} ${OPT_FLAGS})
        set(_frontend_bin ${Impala_BIN})
    endif()

    # parse extra clang flags
    set(_clang_flags ${PARGS_CLANG_FLAGS} ${OPT_FLAGS})

    list(FIND _frontend_flags "--log-level" FRONTEND_FLAGS_LOG_LEVEL_IDX)
    if(FRONTEND_FLAGS_LOG_LEVEL_IDX EQUAL -1)
        list(APPEND _frontend_flags --log-level $<IF:$<CONFIG:Release>,error,info>)
    endif()

    # check for clang in toolchain
    if(NOT Clang_BIN)
        message(FATAL_ERROR "Could not find clang binary, it has to be in the PATH")
    endif()

    # get last filename and absolute filenames
    set(_infiles)
    foreach(_it ${PARGS_FILES})
        get_filename_component(_infile ${_it} ABSOLUTE)
        set(_infiles ${_infiles} ${_infile})
        set(_lastfile ${_it})
    endforeach()

    if(NOT PARGS_NAME)
        get_filename_component(_basename ${_lastfile} NAME_WE)
    else()
        set(_basename ${PARGS_NAME})
    endif()

    if(NOT PARGS_HLS_FLAGS)
        set(HLS_COMMAND)
    else()
        string(REPLACE ";" "," HLS_FLAGS "${PARGS_HLS_FLAGS}")
        set(HLS_COMMAND COMMAND ${CMAKE_COMMAND} -D_basename=${_basename} -DHLS_FLAGS=${HLS_FLAGS} -P ${AnyDSL_runtime_DIR}/build_xilinx_hls.cmake)
    endif()

    set(_basepath ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/${_basename})
    set(_llfile ${_basepath}.ll)
    set(_cfile ${_basepath}.c)
    set(_objfile ${_basepath}.o)

    set(_frontend_platform_files
        ${AnyDSL_runtime_ROOT_DIR}/platforms/${_frontend}/intrinsics.impala
        ${AnyDSL_runtime_ROOT_DIR}/platforms/${_frontend}/intrinsics_rv.impala
        ${AnyDSL_runtime_ROOT_DIR}/platforms/${_frontend}/intrinsics_cpu.impala
        ${AnyDSL_runtime_ROOT_DIR}/platforms/${_frontend}/intrinsics_hls.impala
        ${AnyDSL_runtime_ROOT_DIR}/platforms/${_frontend}/intrinsics_cuda.impala
        ${AnyDSL_runtime_ROOT_DIR}/platforms/${_frontend}/intrinsics_nvvm.impala
        ${AnyDSL_runtime_ROOT_DIR}/platforms/${_frontend}/intrinsics_amdgpu.impala
        ${AnyDSL_runtime_ROOT_DIR}/platforms/${_frontend}/intrinsics_opencl.impala
        ${AnyDSL_runtime_ROOT_DIR}/platforms/${_frontend}/intrinsics_thorin.impala
        ${AnyDSL_runtime_ROOT_DIR}/platforms/${_frontend}/intrinsics_vulkan.impala
        ${AnyDSL_runtime_ROOT_DIR}/platforms/${_frontend}/runtime.impala
        ${_additional_platform_files})

    if(NOT MSVC)
        list(APPEND _clang_flags -fPIE)
    endif()

    if(PARGS_EMIT_C)
        # generate .c file
        add_custom_command(OUTPUT ${_cfile}
            COMMAND ${_frontend_bin} ${_frontend_platform_files} ${_infiles} ${_frontend_flags} --emit-c -o ${_basepath}
            WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
            DEPENDS ${_frontend_bin} ${_frontend_platform_files} ${_infiles} VERBATIM COMMAND_EXPAND_LISTS)
        # run clang on the .c file to get the .o
        add_custom_command(OUTPUT ${_objfile}
            COMMAND ${Clang_BIN} ${_clang_flags} -c -o ${_objfile} ${_cfile}
            DEPENDS ${_cfile} VERBATIM COMMAND_EXPAND_LISTS)
    else()
        # generate .ll file and patch it
        add_custom_command(OUTPUT ${_llfile}
            COMMAND ${_frontend_bin} ${_frontend_platform_files} ${_infiles} ${_frontend_flags} --emit-llvm -o ${_basepath}
            COMMAND ${Python3_EXECUTABLE} ${AnyDSL_runtime_ROOT_DIR}/post-patcher.py ${_basepath}
            COMMAND ${CMAKE_COMMAND} -D_basename=${_basename} -DLLVM_AS_BIN=${LLVM_AS_BIN} -P ${AnyDSL_runtime_ROOT_DIR}/cmake/check_nvvmir.cmake
            ${HLS_COMMAND}
            WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
            DEPENDS ${_frontend_bin} ${Python3_EXECUTABLE} ${AnyDSL_runtime_ROOT_DIR}/post-patcher.py ${_frontend_platform_files} ${_infiles} VERBATIM COMMAND_EXPAND_LISTS)
        # run clang on the .ll file to get the .o
        add_custom_command(OUTPUT ${_objfile}
            COMMAND ${Clang_BIN} ${_clang_flags} -c -o ${_objfile} ${_llfile}
            DEPENDS ${_llfile} VERBATIM COMMAND_EXPAND_LISTS)
    endif()

    # generate C interface on request
    if(NOT ${PARGS_INTERFACE} STREQUAL "")
        set(_hfile ${PARGS_INTERFACE}.h)
        add_custom_command(OUTPUT ${_hfile}
           COMMAND ${_frontend_bin} ${_frontend_platform_files} ${_infiles} --emit-c-interface -o ${PARGS_INTERFACE}
           WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
           DEPENDS ${_frontend_bin} ${_frontend_platform_files} ${_infiles} VERBATIM)
        set_source_files_properties(${_hfile} PROPERTIES GENERATED TRUE)
    endif()

    set_source_files_properties(${_objfile} PROPERTIES EXTERNAL_OBJECT true GENERATED true LANGUAGE CXX)
    set(${outfiles} ${${outfiles}} ${_objfile} ${_frontend_platform_files} PARENT_SCOPE)
endfunction()

include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(AnyDSL_runtime DEFAULT_MSG AnyDSL_runtime_DIR AnyDSL_runtime_LIBRARIES AnyDSL_runtime_INCLUDE_DIRS)

mark_as_advanced(AnyDSL_runtime_LIBRARIES AnyDSL_runtime_ARTIC_JIT_LIBRARIES AnyDSL_runtime_IMPALA_JIT_LIBRARIES AnyDSL_runtime_ROOT_DIR AnyDSL_runtime_INCLUDE_DIR OPT_BIN)