CMakeLists.txt

cmake_minimum_required(VERSION 3.8)
project(JSIToolkit)

option(USE_ROCM                "Enable ROCM tracing & profiling"                OFF)
option(USE_MATRIX              "Enable MATRIX tracing & profiling"              OFF)
option(USE_LIBUNWIND           "Enable Libunwind backtracing"                   ON)
option(USE_ALLOCA              "Enable GNU C extension alloca"                  ON)

set(CXX_LEAST_VERSION 12.3)
if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS ${CXX_LEAST_VERSION})
    message(FATAL_ERROR "C++ Compiler version must be at least ${CXX_LEAST_VERSION}")
endif()

set(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake;${CMAKE_MODULE_PATH}")

set(CMAKE_CXX_FLAGS_DEBUG "-fsanitize=address -fsanitize=undefined -fsanitize=leak ${CMAKE_CXX_FLAGS_DEBUG} -Wall")

set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -gdwarf-4")
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -gdwarf-4")
try_compile(HAS_FS "${CMAKE_BINARY_DIR}/temp" 
"${CMAKE_SOURCE_DIR}/cmake/tests/has_filesystem.cc" 
            CMAKE_FLAGS -DCMAKE_CXX_STANDARD=17 -DCMAKE_CXX_STANDARD_REQUIRED=ON
            LINK_LIBRARIES stdc++fs)
if(HAS_FS)
    message(STATUS "Compiler has filesystem support")
else()
#   .... You could also try searching for boost::filesystem here.
    message(FATAL_ERROR "Compiler is missing filesystem capabilities")
endif(HAS_FS)

EXECUTE_PROCESS(COMMAND uname -a
        TIMEOUT 5
	OUTPUT_VARIABLE OS_TYPE
        OUTPUT_STRIP_TRAILING_WHITESPACE
        )
MESSAGE(STATUS "BUILD OS_TYPE ${OS_TYPE}")

if (OS_TYPE MATCHES ".*oe.*")
  message(STATUS "Building for OS:openEuler")
  add_compile_definitions(EULER)
endif()

if (OS_TYPE MATCHES ".*ky.*")
  message(STATUS "Building for OS:kylin")
  add_compile_definitions(KYLIN)
endif()
add_compile_definitions(KYLIN)

if (USE_ALLOCA)
  add_compile_definitions(USE_ALLOCA)
endif()

if (NOT NO_BACKTRACE)
    add_compile_definitions(ENABLE_BACKTRACE)
    if (USE_LIBUNWIND)
        add_compile_definitions( USE_LIBUNWIND )
        find_package(Libunwind REQUIRED)
    endif()
    message(STATUS "BACKTRACE ENABLED")
endif ()

if (NOT NO_PMU)
    add_compile_definitions(ENABLE_PMU)
    message(STATUS "PMU COLLECTING ENABLED")
endif ()

if (ARCH_HYGON_C86)
    add_compile_definitions(HYGON_C86)
endif ()

if (USE_MATRIX)
    add_compile_definitions(__MATRIX)
endif ()

# find_package(Python3 COMPONENTS Interpreter Development REQUIRED)
find_package(Python3 COMPONENTS Interpreter REQUIRED)

find_package(LLVMOpenMP)
if(LLVMOpenMP_FOUND)
  message(STATUS "Found LLVMOpenMP")
  add_compile_definitions(USING_OMPT)
else()
  message(STATUS "LLVMOpenMP not found")
endif()

# generate headers from scripts
if(LLVMOpenMP_FOUND)
    set(GENERATE_WRAPPER_SCRIPT "${CMAKE_CURRENT_SOURCE_DIR}/scripts/build_scripts/compile_type_defines.py")
else()
    set(GENERATE_WRAPPER_SCRIPT "${CMAKE_CURRENT_SOURCE_DIR}/scripts/build_scripts/compile_type_defines_noompt.py")
endif()
message(STATUS "Generating wrapper headers: ${GENERATE_WRAPPER_SCRIPT}")
execute_process(
  COMMAND ${Python3_EXECUTABLE} ${GENERATE_WRAPPER_SCRIPT} --workdir=${CMAKE_CURRENT_SOURCE_DIR}/
  RESULT_VARIABLE _result
  OUTPUT_VARIABLE _output
  ERROR_VARIABLE _error
  OUTPUT_STRIP_TRAILING_WHITESPACE
)

if(NOT _result EQUAL 0)
  message(FATAL_ERROR "Failed to execute Python script: ${_error}")
else()
  message(STATUS "Wrapper Generate Success")
endif()

find_package(OTF2)
# find_package(MPI QUIET)
# if (NOT MPI_FOUND)
#   find_path(MPI_INCLUDE_PATH
#       NAMES mpi.h
#       HINTS ENV C_INCLUDE_PATH
#       DOC "Path to MPI include directory"
#   )
#   message(STATUS "MPI_INCLUDE_PATH is ${MPI_INCLUDE_PATH}")
#   find_library(MPI_LIBRARIES
#       NAMES mpi
#       HINTS ENV LIBRARY_PATH
#       DOC "Path to MPI C library"
#   )
#   message(STATUS "MPI_LIBRARIES is ${MPI_LIBRARIES}")
# endif()

find_path(MPI_INCLUDE_PATH
    NAMES mpi.h
    HINTS ENV C_INCLUDE_PATH
    DOC "Path to MPI include directory"
)

message(STATUS "MPI_INCLUDE_PATH is ${MPI_INCLUDE_PATH}")

find_library(MPI_LIBRARIES
    NAMES mpi
    HINTS ENV LIBRARY_PATH
    DOC "Path to MPI C library"
)

message(STATUS "MPI_LIBRARIES is ${MPI_LIBRARIES}")

# find_package(Dyninst REQUIRED)
find_package(PAPI REQUIRED)
find_package (LibElf REQUIRED)
find_package (LibDwarf REQUIRED)
find_package(OpenMP REQUIRED)
find_package(Boost REQUIRED)
# find_package(LLVMOpenMP REQUIRED)

set(ENV{PKG_CONFIG_PATH} $prefix)
find_package(PkgConfig)
pkg_search_module(magic_enum REQUIRED magic_enum)
pkg_search_module(sqlite REQUIRED sqlite3)
include_directories(${sqlite_INCLUDE_DIRS})
link_directories(${sqlite_LIBRARY_DIRS})

add_definitions(-DFMT_HEADER_ONLY)

include_directories(SYSTEM ${Boost_INCLUDE_DIRS})

if (USE_ROCM)
  set(CMAKE_MODULE_PATH "$ENV{ROCM_PATH}/hip/cmake" ${CMAKE_MODULE_PATH})
  find_package(HIP   REQUIRED)
  find_package(ROCM REQUIRED)
  if(NOT ROCM_PATH OR ROCM_PATH STREQUAL "")
      if(DEFINED ENV{ROCM_PATH} AND NOT $ENV{ROCM_PATH} STREQUAL "")
          set(ROCM_PATH $ENV{ROCM_PATH})
      else()
          set(ROCM_PATH ${HIP_ROOT_DIR})
      endif()
  endif()
  add_compile_definitions( ROCM )
  message(STATUS "ROCM PATH: " ${ROCM_PATH})
endif ()

include_directories(./lib/pse/include/)

# find_package(fmt CONFIG REQUIRED)
# get_target_property(fmt_INCLUDE_DIRS fmt::fmt INTERFACE_INCLUDE_DIRECTORIES)
# message(INFO "fmt_INCLUDE_DIRS: ${fmt_INCLUDE_DIRS}")
# link_libraries(fmt::fmt)
# include_directories(${fmt_INCLUDE_DIRS})

# find_package(spdlog CONFIG REQUIRED)
# link_libraries(spdlog::spdlog)
# get_target_property(spdlog_INCLUDE_DIRS spdlog::spdlog INTERFACE_INCLUDE_DIRECTORIES)
# message(INFO "spdlog_INCLUDE_DIRS: ${spdlog_INCLUDE_DIRS}")
# include_directories(${spdlog_INCLUDE_DIRS})

add_subdirectory(lib)
add_subdirectory(tool)

# Test
# add_subdirectory(test)