CMakeLists.txt

cmake_minimum_required(VERSION 3.15.1)

# Allow VERSION for projects, as expected in CMake 3.0+
cmake_policy(SET CMP0048 NEW)
project(rocMLIR VERSION 2.0.0 LANGUAGES CXX C)

# New in CMake 3.20. https://cmake.org/cmake/help/latest/policy/CMP0116.html
if(POLICY CMP0116)
  cmake_policy(SET CMP0116 OLD)
endif()

set(CMAKE_POSITION_INDEPENDENT_CODE ON CACHE BOOL "")

# Adapted from https://blog.kitware.com/cmake-and-the-default-build-type/
set(default_build_type "Release")
if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
  message(STATUS "Setting build type to '${default_build_type}' as none was specified.")
  set(CMAKE_BUILD_TYPE "${default_build_type}" CACHE
      STRING "Choose the type of build." FORCE)
  # Set the possible values of build type for cmake-gui
  set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS
    "Debug" "Release" "MinSizeRel" "RelWithDebInfo")
endif()

# Set policy CMP0057 to support IN_LIST operators
cmake_policy(SET CMP0057 NEW)

if(CMAKE_SYSTEM_NAME STREQUAL "Windows")
  option(ROCMLIR_SILENCE_WARNINGS "Ignore certain warnings on Windows" ON)
  option(ROCMLIR_USE_BINSKIM_COMPLIANT_COMPILE_FLAGS "Prepare rocMLIR for BinSkim Binary Analyzer" OFF)
  option(ROCMLIR_USE_SPECTRE_MITIGATED_LIBRARIES "Use Spectre-mitigated libraries" OFF)
  if(MSVC AND MSVC_VERSION GREATER_EQUAL 1900)
    if(ROCMLIR_USE_BINSKIM_COMPLIANT_COMPILE_FLAGS)
      message(STATUS "Control Flow Guard enabled")
      add_compile_options($<$<COMPILE_LANGUAGE:C,CXX>:/guard:cf>)
      add_link_options(/guard:cf /DYNAMICBASE)
    endif()
    if(ROCMLIR_USE_SPECTRE_MITIGATED_LIBRARIES)
      message(STATUS "Using Spectre-mitigated libraries")
      add_compile_options($<$<COMPILE_LANGUAGE:C,CXX>:/Qspectre>)
    endif()
  elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
    if(ROCMLIR_USE_BINSKIM_COMPLIANT_COMPILE_FLAGS)
      message(STATUS "Control Flow Guard enabled (Clang)")
      add_compile_options("$<$<COMPILE_LANGUAGE:C,CXX>:SHELL:-Xclang -cfguard>")
      add_link_options(-Wl,-guard:cf)
    endif()
    if(ROCMLIR_USE_SPECTRE_MITIGATED_LIBRARIES)
        message(WARNING "Spectre mitigated libraries are not yet available for Clang in this project.")
    endif()
  endif()
  if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang" OR CMAKE_C_COMPILER_ID STREQUAL "Clang")
    add_compile_options(-fms-extensions -fms-compatibility -fdelayed-template-parsing)
    if(ROCMLIR_SILENCE_WARNINGS)
      add_compile_options(
          -Wno-sign-compare
          -Wno-covered-switch-default
          -Wno-unused-result
          -Wno-switch
          -Wno-language-extension-token
          -Wno-microsoft-enum-value
          -Wno-undef
          -Wno-deprecated-declarations
          -Wno-cast-function-type-mismatch
          -Wno-overlength-strings)
      add_compile_definitions(_SILENCE_NONFLOATING_COMPLEX_DEPRECATION_WARNING)
    endif()
  endif()
  set(LLVM_ENABLE_ASSERTIONS OFF CACHE BOOL "" FORCE)
endif()

#
# Seperate linking jobs from compiling
# Too many concurrent linking jobs can break the build
# Copied from LLVM
set(ROCMLIR_PARALLEL_LINK_JOBS "" CACHE STRING
  "Define the maximum number of concurrent link jobs (Ninja only).")
if(CMAKE_GENERATOR MATCHES "Ninja")
  if(ROCMLIR_PARALLEL_LINK_JOBS)
    set_property(GLOBAL APPEND PROPERTY JOB_POOLS link_job_pool=${ROCMLIR_PARALLEL_LINK_JOBS})
    set(CMAKE_JOB_POOL_LINK link_job_pool)
  endif()
elseif(ROCMLIR_PARALLEL_LINK_JOBS)
  message(WARNING "Job pooling is only available with Ninja generators.")
endif()
# Similar for compiling
set(ROCMLIR_PARALLEL_COMPILE_JOBS "" CACHE STRING
  "Define the maximum number of concurrent compile jobs (Ninja only).")
if(CMAKE_GENERATOR MATCHES "Ninja")
  if(ROCMLIR_PARALLEL_COMPILE_JOBS)
    set_property(GLOBAL APPEND PROPERTY JOB_POOLS compile_job_pool=${ROCMLIR_PARALLEL_COMPILE_JOBS})
    set(CMAKE_JOB_POOL_COMPILE compile_job_pool)
  endif()
elseif(ROCMLIR_PARALLEL_COMPILE_JOBS)
  message(WARNING "Job pooling is only available with Ninja generators.")
endif()

# Rock dialect.
set(ROCMLIR_DRIVER_E2E_TEST_ENABLED 0 CACHE BOOL "Enable build E2E tests for Rock driver")
set(ROCMLIR_DRIVER_RANDOM_DATA_SEED "none" CACHE STRING "Enable E2E tests using random data")
set(ROCMLIR_GEN_FLAGS "" CACHE BOOL "Set feature flag for rocmlir-gen")
set(ROCMLIR_DRIVER_TEST_GPU_VALIDATION 1 CACHE BOOL "Enable E2E tests with GPU validation")
set(ROCK_E2E_TEST_ENABLED 0 CACHE BOOL "Enable build rock E2E tests")
option(ROCMLIR_BUILD_TUNING_DRIVER "Build rocmlir-tuning-driver (default ON when BUILD_FAT_LIBROCKCOMPILER)" OFF)
set(ROCMLIR_ENABLE_BENCHMARKS "" CACHE STRING "List of enabled benchmarks")

set(ROCMLIR_BIN_DIR "${CMAKE_CURRENT_BINARY_DIR}/bin" CACHE PATH "")
set(ROCMLIR_LIB_DIR "${CMAKE_CURRENT_BINARY_DIR}/lib" CACHE PATH "")
message(STATUS "ROCMLIR_BIN_DIR: ${ROCMLIR_BIN_DIR}")

if( ROCMLIR_ENABLE_BENCHMARKS STREQUAL "all" )
  set(ROCMLIR_ENABLE_BENCHMARKS CACHE STRING "ck;hipblaslt" FORCE)
endif()

# BUILD_MIXR_TARGET is deprecated but still available
if(BUILD_MIXR_TARGET)
  set(BUILD_FAT_LIBROCKCOMPILER ON CACHE BOOL "Build static rockCompiler library")
endif()

# Library type and linkage settings
if( NOT DEFINED BUILD_FAT_LIBROCKCOMPILER )
  set(BUILD_FAT_LIBROCKCOMPILER OFF CACHE BOOL "Build fat rockCompiler library to link into Rock driver")
endif()
if( BUILD_FAT_LIBROCKCOMPILER )
  set(BUILD_SHARED_LIBS OFF CACHE BOOL "")
  set(LLVM_BUILD_LLVM_DYLIB OFF CACHE BOOL "")
  # rocm-runner is not supported with static libraries
  set(MLIR_ENABLE_ROCM_RUNNER 0 CACHE BOOL "")
  # Enable tuning driver by default for fat-lib builds (it can link against static dialect libs + shared HIP)
  set(ROCMLIR_BUILD_TUNING_DRIVER ON CACHE BOOL "" FORCE)
  set(MLIR_INCLUDE_INTEGRATION_TESTS OFF CACHE BOOL "")
  set(ROCMLIR_DRIVER_PR_E2E_TEST_ENABLED 0 CACHE BOOL "Enable build PR-triggered E2E tests for Rock driver")
  set(MHAL_ENABLE_HOST_RUNNER OFF CACHE BOOL "Enable MHAL host runner")
  # rock.arch="native" runtime detection requires linking HIP and HSA, which
  # adds a hard DT_NEEDED on libamdhip64/libhsa-runtime64 to every consumer
  # of the static fat library. Disable it by default for the fat-lib build
  # so consumers (e.g. MIGraphX) do not transitively pull HIP/HSA from
  # rocMLIR alone. Pass -DROCMLIR_ENABLE_NATIVE_ARCH=ON to opt back in.
  set(ROCMLIR_ENABLE_NATIVE_ARCH OFF CACHE BOOL
    "Enable rock.arch=\"native\" runtime detection (requires HIP and HSA)")
  if(NOT WIN32)
    set(CMAKE_INSTALL_PREFIX "/opt/rocm" CACHE STRING "")
    # Note, this is a hack to ignore Pytorch added conda path
    list(APPEND CMAKE_IGNORE_PATH /opt/conda)
  endif()
else()
  set(BUILD_SHARED_LIBS ON CACHE BOOL "")
  set(LLVM_BUILD_LLVM_DYLIB ON CACHE BOOL "")
  set(LLVM_BUILD_EXAMPLES ON CACHE BOOL "")
  set(MLIR_ENABLE_ROCM_RUNNER 1 CACHE BOOL "")
  set(MLIR_INCLUDE_INTEGRATION_TESTS ON CACHE BOOL "")
  set(ROCMLIR_DRIVER_PR_E2E_TEST_ENABLED 1 CACHE BOOL "Enable build PR-triggered E2E tests for Rock driver")
  set(ROCMLIR_ENABLE_NATIVE_ARCH ON CACHE BOOL
    "Enable rock.arch=\"native\" runtime detection (requires HIP and HSA)")
endif()

# Pointers to external llvm build, needed here to set up rpath project-wide
set(LLVM_EXTERNAL_BUILD_DIR "${CMAKE_CURRENT_BINARY_DIR}/external/llvm-project")
set(LLVM_EXTERNAL_SRC_DIR "${CMAKE_CURRENT_SOURCE_DIR}/external/llvm-project")
set(LLVM_EXTERNAL_BIN_DIR "${LLVM_EXTERNAL_BUILD_DIR}/llvm/bin")
set(LLVM_EXTERNAL_LIB_DIR "${LLVM_EXTERNAL_BUILD_DIR}/llvm/lib")

message(STATUS "LLVM_EXTERNAL_BIN_DIR: ${LLVM_EXTERNAL_BIN_DIR}")
message(STATUS "LLVM_EXTERNAL_LIB_DIR: ${LLVM_EXTERNAL_LIB_DIR}")
list(PREPEND CMAKE_BUILD_RPATH "${LLVM_EXTERNAL_LIB_DIR}")
### Workaround ROCm address sanitizer build not being able to propagate LD_LIBRARY_PATH
### Remove when https://github.com/pfultz2/cget/issues/110 is fixed.
if (DEFINED ENV{ADDRESS_SANITIZER})
  if ($ENV{ADDRESS_SANITIZER} MATCHES "ON")
    message("Address sanitizer workarounds")
    execute_process(
      COMMAND ${CMAKE_C_COMPILER} --print-file-name=libclang_rt.asan-x86_64.so
      OUTPUT_VARIABLE clang_asan_lib_file
      ERROR_VARIABLE clang_stderr
      OUTPUT_STRIP_TRAILING_WHITESPACE
      ERROR_STRIP_TRAILING_WHITESPACE
      RESULT_VARIABLE clang_exit_code)
    if (NOT "${clang_exit_code}" STREQUAL "0")
      message(FATAL_ERROR
      "Unable to invoke clang to find asan lib dir: ${clang_stderr}")
    endif()
    file(TO_CMAKE_PATH "${clang_asan_lib_file}" clang_asan_lib_file_cmake)
    get_filename_component(clang_asan_lib_dir "${clang_asan_lib_file_cmake}" DIRECTORY)
    message(STATUS "Asan lib directory ${clang_asan_lib_dir}")
    list(APPEND CMAKE_BUILD_RPATH "${clang_asan_lib_dir}")
  endif()
endif()
### End workaround

# Set up the build for the LLVM/MLIR git-submodule
include(cmake/llvm-project.cmake)

# Match LLVM's C++ standard settings so that all non-LLVM targets are compatible
# with the LLVMSupport precompiled header (set as normal variables because the
# cache-only values set by LLVM's add_subdirectory don't propagate to this scope).
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED YES)
set(CMAKE_CXX_EXTENSIONS NO)

include(cmake/mlir-hal.cmake)

if(NOT WIN32)
    # Update the build-tree RPATH
    list(PREPEND CMAKE_BUILD_RPATH "${ROCMLIR_LIB_DIR}")
    message(STATUS "Final CMAKE_BUILD_RPATH: ${CMAKE_BUILD_RPATH}")
endif()

# Set up the build for the rocMLIR dialects
add_subdirectory(mlir)