# Copyright (c) 2006, 2014, Oracle and/or its affiliates
# Copyright (c) 2009, 2018, MariaDB Corporation
# 
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; version 2 of the License.
# 
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
# 
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1335 USA

INCLUDE_DIRECTORIES(${ZLIB_INCLUDE_DIRS} ${CMAKE_SOURCE_DIR}/include ${CMAKE_SOURCE_DIR}/mysys)

SET(MYSYS_SOURCES  array.c charset-def.c charset.c my_default.c
                get_password.c
    errors.c hash.c list.c
                                mf_cache.c mf_dirname.c mf_fn_ext.c
    mf_format.c mf_getdate.c mf_iocache.c mf_iocache2.c mf_keycache.c 
    mf_keycaches.c mf_loadpath.c mf_pack.c mf_path.c mf_qsort.c mf_qsort2.c
    mf_radix.c mf_same.c mf_sort.c mf_soundex.c mf_arr_appstr.c mf_tempdir.c
    mf_tempfile.c mf_unixpath.c mf_wcomp.c mulalloc.c my_access.c
    my_alloc.c my_bit.c my_bitmap.c my_chsize.c
    my_compress.c my_copy.c  my_create.c my_delete.c
    my_div.c my_error.c my_file.c my_fopen.c my_fstream.c 
    my_getexe.c
    my_gethwaddr.c my_getopt.c my_getsystime.c my_getwd.c my_compare.c my_init.c
    my_lib.c my_lock.c my_malloc.c my_mess.c
    my_mkdir.c my_mmap.c my_once.c my_open.c my_pread.c my_pthread.c
    my_quick.c my_read.c my_redel.c my_rename.c my_seek.c my_sleep.c
    my_static.c my_symlink.c my_symlink2.c my_sync.c my_thr_init.c 
    my_basename.c
    my_write.c ptr_cmp.c queues.c stacktrace.c
    string.c thr_lock.c thr_mutex.c
    thr_rwlock.c thr_timer.c my_stack.c
                                tree.c typelib.c base64.c my_memmem.c
                                my_getpagesize.c
                                guess_malloc_library.c
    lf_alloc-pin.c lf_dynarray.c lf_hash.cc
                                safemalloc.c my_new.cc
    my_getncpus.c my_safehash.c my_chmod.c my_rnd.c
                                my_uuid.c wqueue.c waiting_threads.c ma_dyncol.c ../sql-common/my_time.c
    my_rdtsc.c psi_noop.c
                                my_atomic_writes.c my_cpu.c my_likely.c my_largepage.c
                                file_logger.c my_dlerror.c   crc32/crc32c.cc
                                my_timezone.cc my_compr_int.cc my_thread_name.cc
                                my_virtual_mem.c)

IF (WIN32)
  SET (MYSYS_SOURCES ${MYSYS_SOURCES}
    my_winthread.c
    my_wintoken.c
    my_wincond.c
    my_winerr.c
    my_winfile.cc
    my_minidump.cc
    my_win_popen.cc)
ENDIF()

IF(MSVC_INTEL)
  SET(MYSYS_SOURCES ${MYSYS_SOURCES} crc32/crc32_x86.c crc32/crc32c_x86.cc)
  IF(CMAKE_SIZEOF_VOID_P EQUAL 8)
    SET (MYSYS_SOURCES ${MYSYS_SOURCES} crc32/crc32c_amd64.cc)
  ENDIF()
ELSEIF(MSVC_ARM64)
  SET (MYSYS_SOURCES ${MYSYS_SOURCES} crc32/crc32_arm64.c)
  ADD_DEFINITIONS(-DHAVE_ARMV8_CRC -DHAVE_ARMV8_CRC_CRYPTO_INTRINSICS -DHAVE_ARMV8_CRYPTO)
  IF(CLANG_CL)
    SET_SOURCE_FILES_PROPERTIES(
      crc32/crc32_arm64.c
      PROPERTIES
      COMPILE_FLAGS "-march=armv8-a+crc+crypto"
  )
  ENDIF()
ELSEIF(CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64|amd64|i386|i686")
  SET(MYSYS_SOURCES ${MYSYS_SOURCES} crc32/crc32_x86.c crc32/crc32c_x86.cc)
  IF(CMAKE_C_COMPILER_ID STREQUAL "GNU" AND CMAKE_C_COMPILER_VERSION VERSION_LESS "5")
    SET_SOURCE_FILES_PROPERTIES(crc32/crc32_x86.c PROPERTIES
      COMPILE_FLAGS "-msse4.2 -mpclmul")
  ENDIF()
  IF(CMAKE_SIZEOF_VOID_P EQUAL 8)
    SET(MYSYS_SOURCES ${MYSYS_SOURCES} crc32/crc32c_amd64.cc)
    IF(CMAKE_C_COMPILER_ID STREQUAL "GNU" AND CMAKE_C_COMPILER_VERSION VERSION_LESS "5")
      SET_SOURCE_FILES_PROPERTIES(crc32/crc32c_amd64.cc PROPERTIES
        COMPILE_FLAGS "-msse4.2 -mpclmul")
    ENDIF()
  ENDIF()
ELSEIF(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64|AARCH64")
  IF(CMAKE_C_COMPILER_ID MATCHES "Clang|GNU")
    include(CheckCSourceCompiles)

    CHECK_C_COMPILER_FLAG(-march=armv8-a+crc+crypto HAVE_ARMV8_CRC_CRYPTO_MARCH)
    IF(HAVE_ARMV8_CRC_CRYPTO_MARCH)
      SET(SAVE_CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS}")
      SET(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -march=armv8-a+crc+crypto")
    ENDIF()

    CHECK_C_SOURCE_COMPILES("
    #define CRC32CX(crc, value) __asm__(\"crc32cx %w[c], %w[c], %x[v]\":[c]\"+r\"(crc):[v]\"r\"(value))
    asm(\".arch_extension crc\");
    unsigned int foo(unsigned int ret) {
      CRC32CX(ret, 0);
      return ret;
    }
    #include <sys/auxv.h>
    int main() { foo(0);
    #ifdef __linux__
    getauxval(AT_HWCAP);
    #else
    unsigned long v;
    elf_aux_info(AT_HWCAP, &v, sizeof(v));
    #endif
    }" HAVE_ARMV8_CRC)

    CHECK_C_SOURCE_COMPILES("
    asm(\".arch_extension crypto\");
    unsigned int foo(unsigned int ret) {
      __asm__(\"pmull  v2.1q,          v2.1d,  v1.1d\");
      return ret;
    }
    #include <sys/auxv.h>
    int main() { foo(0);
    #ifdef __linux__
    getauxval(AT_HWCAP);
    #else
    unsigned long v;
    elf_aux_info(AT_HWCAP, &v, sizeof(v));
    #endif
    }" HAVE_ARMV8_CRYPTO)

    IF(HAVE_ARMV8_CRC_CRYPTO_MARCH)
      CHECK_INCLUDE_FILE(arm_acle.h HAVE_ARM_ACLE_H)
      IF(HAVE_ARM_ACLE_H)
       ADD_DEFINITIONS(-DHAVE_ARMV8_CRC_CRYPTO_INTRINSICS)
      ENDIF()
      IF(HAVE_ARMV8_CRC)
        ADD_DEFINITIONS(-DHAVE_ARMV8_CRC)
      ENDIF()
      IF(HAVE_ARMV8_CRYPTO)
        ADD_DEFINITIONS(-DHAVE_ARMV8_CRYPTO)
      ENDIF()
      SET(MYSYS_SOURCES ${MYSYS_SOURCES} crc32/crc32_arm64.c)
      SET_SOURCE_FILES_PROPERTIES(crc32/crc32_arm64.c PROPERTIES
        COMPILE_FLAGS "-march=armv8-a+crc+crypto")

      SET(CMAKE_REQUIRED_FLAGS "${SAVE_CMAKE_REQUIRED_FLAGS}")
    ENDIF()
  ENDIF()
ELSEIF(CMAKE_SYSTEM_PROCESSOR MATCHES "riscv64|RISCV64")
  IF(CMAKE_CXX_COMPILER_ID MATCHES "Clang|GNU")
    include(CheckCXXSourceCompiles)

    SET(SAVE_CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS}")
    SET(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -march=rv64gc_zbc_zbb")

    # Check for the Zbc extension by compiling the same inline assembler that
    # the implementation uses. This also verifies that the compiler/assembler
    # accepts the -march value.
    CHECK_CXX_SOURCE_COMPILES("
    #include <stdint.h>
    uint64_t clmul(uint64_t a, uint64_t b) {
      uint64_t r;
      __asm__ (\"clmul %0, %1, %2\" : \"=r\"(r) : \"r\"(a), \"r\"(b));
      return r;
    }
    uint64_t clmulh(uint64_t a, uint64_t b) {
      uint64_t r;
      __asm__ (\"clmulh %0, %1, %2\" : \"=r\"(r) : \"r\"(a), \"r\"(b));
      return r;
    }
    int main() { return (int) (clmul(1, 2) ^ clmulh(1, 2)); }
    " HAVE_RISCV_ZBC)

    SET(CMAKE_REQUIRED_FLAGS "${SAVE_CMAKE_REQUIRED_FLAGS}")

    IF(HAVE_RISCV_ZBC)
      ADD_DEFINITIONS(-DHAVE_RISCV_ZBC)
      # The ISA extension is enabled only for the core, so that the detection
      # and dispatch code in crc32c_riscv.cc cannot be compiled for it.
      SET(MYSYS_SOURCES ${MYSYS_SOURCES}
        crc32/crc32c_riscv.cc crc32/crc32c_riscv_zbc.cc)
      SET_SOURCE_FILES_PROPERTIES(crc32/crc32c_riscv_zbc.cc PROPERTIES
        COMPILE_FLAGS "-march=rv64gc_zbc_zbb")

      # Zvbc vector core (optional): separate TU compiled for the vector
      # extension; the runtime probe/dispatch stay in crc32c_riscv.cc.
      # Zbc is deliberately left out of the -march: this core is all-vector,
      # and with Zbc present GCC's -foptimize-crc (on by default at -O2 since
      # GCC 15) rewrites the bitwise fallback in that file into scalar clmul
      # instructions, which do not exist on the Zvbc-without-Zbc cores this
      # code is for.
      SET(SAVE_REQ_FLAGS2 "${CMAKE_REQUIRED_FLAGS}")
      SET(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -march=rv64gc_zbb_zvbc")
      CHECK_CXX_SOURCE_COMPILES("
      #include <riscv_vector.h>
      #include <stdint.h>
      uint64_t f(uint64_t a, const uint64_t *p, size_t vl) {
        vuint64m1_t v = __riscv_vle64_v_u64m1(p, vl);
        return __riscv_vmv_x_s_u64m1_u64(__riscv_vclmul_vx_u64m1(v, a, vl));
      }
      int main() { uint64_t x[4]={1,2,3,4}; return (int) f(5, x, 4); }
      " HAVE_RISCV_ZVBC)
      SET(CMAKE_REQUIRED_FLAGS "${SAVE_REQ_FLAGS2}")
      IF(HAVE_RISCV_ZVBC)
        MESSAGE(STATUS "RISC-V Zvbc detected: enabling vector CRC32C")
        SET(MYSYS_SOURCES ${MYSYS_SOURCES} crc32/crc32c_riscv_zvbc.cc)
        SET_SOURCE_FILES_PROPERTIES(crc32/crc32c_riscv_zvbc.cc PROPERTIES
          COMPILE_FLAGS "-march=rv64gc_zbb_zvbc")
        ADD_DEFINITIONS(-DHAVE_RISCV_ZVBC)
      ELSE()
        MESSAGE(STATUS "RISC-V Zvbc not available: using Zbc scalar CRC32C")
      ENDIF()
    ENDIF()
  ENDIF()
ENDIF()

IF(CMAKE_SYSTEM_PROCESSOR MATCHES "ppc64|powerpc64" OR CMAKE_SYSTEM_NAME MATCHES AIX)
  SET(MYSYS_SOURCES ${MYSYS_SOURCES} crc32/crc32_ppc64.c crc32/crc32c_ppc.c)
  SET_SOURCE_FILES_PROPERTIES(crc32/crc32_ppc64.c crc32/crc32c_ppc.c PROPERTIES
        COMPILE_FLAGS "${COMPILE_FLAGS} -maltivec -mvsx -mpower8-vector -mcrypto -mpower8-vector")
  ADD_DEFINITIONS(-DHAVE_POWER8 -DHAS_ALTIVEC)
ELSE()
  SET (MYSYS_SOURCES ${MYSYS_SOURCES} crc32ieee.cc)
ENDIF()

IF(UNIX)
 SET (MYSYS_SOURCES ${MYSYS_SOURCES} my_addr_resolve.c my_setuser.c)
ENDIF()

IF(HAVE_MLOCK)
 SET(MYSYS_SOURCES ${MYSYS_SOURCES} my_lockmem.c)
ENDIF()

ADD_CONVENIENCE_LIBRARY(mysys ${MYSYS_SOURCES})
MAYBE_DISABLE_IPO(mysys)
TARGET_LINK_LIBRARIES(mysys dbug strings ${ZLIB_LIBRARIES}
 ${LIBNSL} ${LIBM} ${LIBRT} ${CMAKE_DL_LIBS} ${LIBSOCKET} ${LIBEXECINFO})
DTRACE_INSTRUMENT(mysys)
IF(WIN32)
  TARGET_LINK_LIBRARIES(mysys icuuc icuin)
ENDIF()
IF (HAVE_GCC_C11_ATOMICS_WITH_LIBATOMIC)
  TARGET_LINK_LIBRARIES(mysys atomic)
ENDIF()

IF(HAVE_BFD_H)
  TARGET_LINK_LIBRARIES(mysys bfd)  
ENDIF(HAVE_BFD_H)

IF (WIN32)
  TARGET_LINK_LIBRARIES(mysys iphlpapi dbghelp ws2_32 synchronization)
ENDIF(WIN32)

# Need explicit pthread for gcc -fsanitize=address
IF(CMAKE_USE_PTHREADS_INIT AND CMAKE_C_FLAGS MATCHES "-fsanitize=")
  TARGET_LINK_LIBRARIES(mysys pthread)
ENDIF()

# This is a workaround for the warning about duplicate libraries on macOS.
# The issue is as follows: mysys depends on dbug and dbug depends on mysys.
# This causes cmake to append dbug twice when you append mysys as a library.
# And you get a warning from the MacOSX linker.
# TODO: to remove the circular dependency and this workaround.
IF(APPLE AND (CMAKE_VERSION VERSION_GREATER_EQUAL "3.18"))
  include(CheckLinkerFlag)
  CHECK_LINKER_FLAG(C "LINKER:-no_warn_duplicate_libraries" HAVE_NO_WARN_DUPLICATE_LIBRARIES)
  IF(HAVE_NO_WARN_DUPLICATE_LIBRARIES)
    TARGET_LINK_OPTIONS(mysys INTERFACE LINKER:-no_warn_duplicate_libraries)
  ENDIF()
ENDIF()


ADD_EXECUTABLE(thr_lock thr_lock.c)
TARGET_LINK_LIBRARIES(thr_lock mysys)
SET_TARGET_PROPERTIES(thr_lock PROPERTIES COMPILE_FLAGS "-DMAIN")

ADD_EXECUTABLE(thr_timer thr_timer.c)
TARGET_LINK_LIBRARIES(thr_timer mysys)
SET_TARGET_PROPERTIES(thr_timer PROPERTIES COMPILE_FLAGS "-DMAIN")

ADD_EXECUTABLE(test_hash hash.c)
TARGET_LINK_LIBRARIES(test_hash mysys)
SET_TARGET_PROPERTIES(test_hash PROPERTIES COMPILE_FLAGS "-DMAIN")