cmake_minimum_required(VERSION 3.8 FATAL_ERROR) cmake_policy(PUSH) if (POLICY CMP0063) cmake_policy(SET CMP0063 NEW) # Honor visibility properties. endif() if (POLICY CMP0092) cmake_policy(SET CMP0092 NEW) # Don't add -W3 warning level by default. endif() # Don't create a project if it was already created by another CMakeLists.txt. # This allows one library to embed another library without making a collision. if (NOT CMAKE_PROJECT_NAME OR "${CMAKE_PROJECT_NAME}" STREQUAL "asmjit") project(asmjit CXX) endif() include(CheckCXXCompilerFlag) INCLUDE(CheckCXXSourceCompiles) include(GNUInstallDirs) # AsmJit - Deprecated # =================== if (DEFINED ASMJIT_BUILD_EMBED) message(DEPRECATION "ASMJIT_BUILD_EMBED is deprecated, use ASMJIT_EMBED") set(ASMJIT_EMBED "${ASMJIT_BUILD_EMBED}") endif() if (DEFINED ASMJIT_BUILD_STATIC) message(DEPRECATION "ASMJIT_BUILD_STATIC is deprecated, use ASMJIT_STATIC") set(ASMJIT_STATIC "${ASMJIT_BUILD_STATIC}") endif() # AsmJit - Configuration - Build # ============================== if (NOT DEFINED ASMJIT_TEST) set(ASMJIT_TEST FALSE) endif() if (NOT DEFINED ASMJIT_EMBED) set(ASMJIT_EMBED FALSE) endif() if (NOT DEFINED ASMJIT_STATIC) set(ASMJIT_STATIC ${ASMJIT_EMBED}) endif() if (NOT DEFINED ASMJIT_SANITIZE) set(ASMJIT_SANITIZE FALSE) endif() if (NOT DEFINED ASMJIT_NO_CUSTOM_FLAGS) set(ASMJIT_NO_CUSTOM_FLAGS FALSE) endif() if (NOT DEFINED ASMJIT_NO_NATVIS) set(ASMJIT_NO_NATVIS FALSE) endif() # EMBED implies STATIC. if (ASMJIT_EMBED AND NOT ASMJIT_STATIC) set(ASMJIT_STATIC TRUE) endif() # AsmJit - Configuration - Backend # ================================ if (NOT DEFINED ASMJIT_NO_X86) set(ASMJIT_NO_X86 FALSE) endif() if (NOT DEFINED ASMJIT_NO_AARCH64) set(ASMJIT_NO_AARCH64 FALSE) endif() if (NOT DEFINED ASMJIT_NO_FOREIGN) set(ASMJIT_NO_FOREIGN FALSE) endif() # AsmJit - Configuration - Features # ================================= if (NOT DEFINED ASMJIT_NO_DEPRECATED) set(ASMJIT_NO_DEPRECATED FALSE) endif() if (NOT DEFINED ASMJIT_NO_SHM_OPEN) set(ASMJIT_NO_SHM_OPEN FALSE) endif() if (NOT DEFINED ASMJIT_NO_JIT) set(ASMJIT_NO_JIT FALSE) endif() if (NOT DEFINED ASMJIT_NO_TEXT) set(ASMJIT_NO_TEXT FALSE) endif() if (NOT DEFINED ASMJIT_NO_LOGGING) set(ASMJIT_NO_LOGGING ${ASMJIT_NO_TEXT}) endif() if (NOT DEFINED ASMJIT_NO_VALIDATION) set(ASMJIT_NO_VALIDATION FALSE) endif() if (NOT DEFINED ASMJIT_NO_INTROSPECTION) set(ASMJIT_NO_INTROSPECTION FALSE) endif() if (NOT DEFINED ASMJIT_NO_BUILDER) set(ASMJIT_NO_BUILDER FALSE) endif() if (NOT DEFINED ASMJIT_NO_COMPILER) if (ASMJIT_NO_BUILDER OR ASMJIT_NO_INTROSPECTION) set(ASMJIT_NO_COMPILER TRUE) else() set(ASMJIT_NO_COMPILER FALSE) endif() endif() # AsmJit - Configuration - CMake Introspection # ============================================ set(ASMJIT_DIR "${CMAKE_CURRENT_LIST_DIR}" CACHE PATH "Location of 'asmjit'") set(ASMJIT_TEST "${ASMJIT_TEST}" CACHE BOOL "Build 'asmjit' test applications") set(ASMJIT_EMBED "${ASMJIT_EMBED}" CACHE BOOL "Embed 'asmjit' library (no targets)") set(ASMJIT_STATIC "${ASMJIT_STATIC}" CACHE BOOL "Build 'asmjit' library as static") set(ASMJIT_SANITIZE "${ASMJIT_SANITIZE}" CACHE STRING "Build with sanitizers: 'address', 'undefined', etc...") set(ASMJIT_NO_NATVIS "${ASMJIT_NO_NATVIS}" CACHE BOOL "Disable natvis support (embedding asmjit.natvis in PDB)") set(ASMJIT_NO_CUSTOM_FLAGS "${ASMJIT_NO_CUSTOM_FLAGS}" CACHE BOOL "Disable extra compilation flags added by AsmJit to its targets") set(ASMJIT_NO_X86 "${ASMJIT_NO_X86}" CACHE BOOL "Disable X86/X64 backend") set(ASMJIT_NO_AARCH64 "${ASMJIT_NO_AARCH64}" CACHE BOOL "Disable AArch64 backend") set(ASMJIT_NO_FOREIGN "${ASMJIT_NO_FOREIGN}" CACHE BOOL "Disable all foreign architectures (enables only a target architecture)") set(ASMJIT_NO_DEPRECATED "${ASMJIT_NO_DEPRECATED}" CACHE BOOL "Disable deprecated API at build time") set(ASMJIT_NO_SHM_OPEN "${ASMJIT_NO_SHM_OPEN}" CACHE BOOL "Disable the use of shm_open() even on platforms where it's supported") set(ASMJIT_NO_JIT "${ASMJIT_NO_JIT}" CACHE BOOL "Disable VirtMem, JitAllocator, and JitRuntime at build time") set(ASMJIT_NO_TEXT "${ASMJIT_NO_TEXT}" CACHE BOOL "Disable textual representation of instructions, enums, cpu features, ...") set(ASMJIT_NO_LOGGING "${ASMJIT_NO_LOGGING}" CACHE BOOL "Disable logging features at build time") set(ASMJIT_NO_VALIDATION "${ASMJIT_NO_VALIDATION}" CACHE BOOL "Disable instruction validation API at build time") set(ASMJIT_NO_INTROSPECTION "${ASMJIT_NO_INTROSPECTION}" CACHE BOOL "Disable instruction introspection API at build time") set(ASMJIT_NO_BUILDER "${ASMJIT_NO_BUILDER}" CACHE BOOL "Disable Builder emitter at build time") set(ASMJIT_NO_COMPILER "${ASMJIT_NO_COMPILER}" CACHE BOOL "Disable Compiler emitter at build time") # AsmJit - Project # ================ set(ASMJIT_INCLUDE_DIRS "${ASMJIT_DIR}/src") # Include directory is the same as source dir. set(ASMJIT_DEPS "") # AsmJit dependencies (libraries) for the linker. set(ASMJIT_LIBS "") # Dependencies of libs/apps that want to use AsmJit. set(ASMJIT_CFLAGS "") # Public compiler flags. set(ASMJIT_PRIVATE_CFLAGS "") # Private compiler flags independent of build type. set(ASMJIT_PRIVATE_CFLAGS_DBG "") # Private compiler flags used by debug builds. set(ASMJIT_PRIVATE_CFLAGS_REL "") # Private compiler flags used by release builds. set(ASMJIT_SANITIZE_CFLAGS "") # Compiler flags required by currently enabled sanitizers. set(ASMJIT_SANITIZE_LFLAGS "") # Linker flags required by currently enabled sanitizers. # AsmJit - Utilities # ================== function(asmjit_detect_cflags out) set(out_array ${${out}}) foreach(flag ${ARGN}) string(REGEX REPLACE "[+]" "x" flag_signature "${flag}") string(REGEX REPLACE "[-=:;/.\]" "_" flag_signature "${flag_signature}") check_cxx_compiler_flag(${flag} "__CxxFlag_${flag_signature}") if (${__CxxFlag_${flag_signature}}) list(APPEND out_array "${flag}") endif() endforeach() set(${out} "${out_array}" PARENT_SCOPE) endfunction() # Support for various sanitizers provided by C/C++ compilers. function(asmjit_detect_sanitizers out) set(_out_array ${${out}}) set(_flags "") foreach(_arg ${ARGN}) string(REPLACE "," ";" _arg "${_arg}") list(APPEND _flags ${_arg}) endforeach() foreach(_flag ${_flags}) if (NOT "${_flag}" MATCHES "^-fsanitize=") SET(_flag "-fsanitize=${_flag}") endif() # Sanitizers also require link flags, see CMAKE_REQUIRED_FLAGS. set(CMAKE_REQUIRED_FLAGS "${_flag}") asmjit_detect_cflags(_out_array ${_flag}) unset(CMAKE_REQUIRED_FLAGS) endforeach() set(${out} "${_out_array}" PARENT_SCOPE) endfunction() function(asmjit_add_target target target_type) set(single_val "") set(multi_val SOURCES LIBRARIES CFLAGS CFLAGS_DBG CFLAGS_REL) cmake_parse_arguments("X" "" "${single_val}" "${multi_val}" ${ARGN}) if ("${target_type}" MATCHES "^(EXECUTABLE|TEST)$") add_executable(${target} ${X_SOURCES}) else() add_library(${target} ${target_type} ${X_SOURCES}) endif() set_target_properties(${target} PROPERTIES DEFINE_SYMBOL "") target_link_libraries(${target} PRIVATE ${X_LIBRARIES}) # target_link_options was added in cmake v3.13, don't use it for now... foreach(link_flag ${ASMJIT_PRIVATE_LFLAGS}) set_property(TARGET ${target} APPEND_STRING PROPERTY LINK_FLAGS " ${link_flag}") endforeach() target_compile_features(${target} PUBLIC cxx_std_11) set_property(TARGET ${target} PROPERTY CXX_EXTENSIONS NO) set_property(TARGET ${target} PROPERTY CXX_VISIBILITY_PRESET hidden) target_compile_options(${target} PRIVATE ${X_CFLAGS} ${ASMJIT_SANITIZE_CFLAGS} $<$:${X_CFLAGS_DBG}> $<$>:${X_CFLAGS_REL}>) if ("${target_type}" STREQUAL "TEST") add_test(NAME ${target} COMMAND ${target}) endif() endfunction() # AsmJit - Compiler Support # ========================= set(ASMJIT_INCLUDE_DIRS "${ASMJIT_DIR}/src") # Include directory is the same as source dir. set(ASMJIT_DEPS "") # AsmJit dependencies (libraries) for the linker. set(ASMJIT_LIBS "") # Dependencies of libs/apps that want to use AsmJit. set(ASMJIT_CFLAGS "") # Public compiler flags. set(ASMJIT_PRIVATE_CFLAGS "") # Private compiler flags independent of build type. set(ASMJIT_PRIVATE_CFLAGS_DBG "") # Private compiler flags used by debug builds. set(ASMJIT_PRIVATE_CFLAGS_REL "") # Private compiler flags used by release builds. set(ASMJIT_PRIVATE_LFLAGS "") # Private linker flags. set(ASMJIT_SANITIZE_CFLAGS "") # Compiler flags required by currently enabled sanitizers. set(ASMJIT_SANITIZE_LFLAGS "") # Linker flags required by currently enabled sanitizers. # We will have to keep this most likely forever as some users may still be using it. set(ASMJIT_INCLUDE_DIR "${ASMJIT_INCLUDE_DIRS}") if (NOT ASMJIT_NO_CUSTOM_FLAGS) if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC" OR "x${CMAKE_CXX_COMPILER_FRONTEND_VARIANT}" STREQUAL "xMSVC") list(APPEND ASMJIT_PRIVATE_CFLAGS -MP # [+] Multi-Process Compilation. -GF # [+] Eliminate duplicate strings. -Zc:__cplusplus # [+] Conforming __cplusplus definition. -Zc:inline # [+] Remove unreferenced COMDAT. -Zc:strictStrings # [+] Strict const qualification of string literals. -Zc:threadSafeInit- # [-] Thread-safe statics. -W4) # [+] Warning level 4. list(APPEND ASMJIT_PRIVATE_CFLAGS_DBG -GS) # [+] Buffer security-check. list(APPEND ASMJIT_PRIVATE_CFLAGS_REL -GS- # [-] Buffer security-check. -O2 # [+] Favor speed over size. -Oi) # [+] Generate intrinsic functions. elseif ("${CMAKE_CXX_COMPILER_ID}" MATCHES "^(GNU|Clang|AppleClang)$") list(APPEND ASMJIT_PRIVATE_CFLAGS -Wall -Wextra -Wconversion) list(APPEND ASMJIT_PRIVATE_CFLAGS -fno-math-errno) list(APPEND ASMJIT_PRIVATE_CFLAGS_REL -O2) # -fno-semantic-interposition is not available on apple - the compiler issues a warning, which is not detected. if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "AppleClang") asmjit_detect_cflags(ASMJIT_PRIVATE_CFLAGS -fno-threadsafe-statics) else() asmjit_detect_cflags(ASMJIT_PRIVATE_CFLAGS -fno-threadsafe-statics -fno-semantic-interposition) endif() # The following flags can save few bytes in the resulting binary. asmjit_detect_cflags(ASMJIT_PRIVATE_CFLAGS_REL -fmerge-all-constants # Merge all constants even if it violates ISO C++. -fno-enforce-eh-specs) # Don't enforce termination if noexcept function throws. endif() endif() # Support for sanitizers. if (ASMJIT_SANITIZE) ASMJIT_detect_sanitizers(ASMJIT_SANITIZE_CFLAGS ${ASMJIT_SANITIZE}) if (ASMJIT_SANITIZE_CFLAGS) message("-- Enabling sanitizers: '${ASMJIT_SANITIZE_CFLAGS}'") # Linker must receive the same flags as the compiler when it comes to sanitizers. set(ASMJIT_SANITIZE_LFLAGS ${ASMJIT_SANITIZE_CFLAGS}) # Don't omit frame pointer if sanitizers are enabled. if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC" OR "x${CMAKE_CXX_COMPILER_FRONTEND_VARIANT}" STREQUAL "xMSVC") list(APPEND ASMJIT_SANITIZE_CFLAGS -Oy-) else() list(APPEND ASMJIT_SANITIZE_CFLAGS -fno-omit-frame-pointer -g) endif() list(APPEND ASMJIT_PRIVATE_CFLAGS ${ASMJIT_SANITIZE_CFLAGS}) list(APPEND ASMJIT_PRIVATE_LFLAGS ${ASMJIT_SANITIZE_LFLAGS}) endif() endif() if (WIN32) # Dependency: nothing extra at the moment. elseif ("${CMAKE_SYSTEM_NAME}" STREQUAL "Android") # Dependency: libc is the only required library on Android as it also provides libthread. message("-- Dependency: adding libc (Android target detected)") list(APPEND ASMJIT_DEPS c) elseif ("${CMAKE_SYSTEM_NAME}" STREQUAL "Haiku") # Dependency: libroot is used by Haiku instead of libc, so link to libroot and libpthread. message("-- Dependency: adding libroot and libpthread (Haiku target detected)") list(APPEND ASMJIT_DEPS root pthread) else() # Dependency: libc is always required. message("-- Dependency: adding libc (Linux, BSD, or other UNIX/POSIX environment)") list(APPEND ASMJIT_DEPS c) # Dependency: pthread (required so AsmJit can use pthread_lock). check_cxx_source_compiles(" #include int main() { pthread_mutex_t m; pthread_mutex_init(&m, nullptr); return pthread_mutex_destroy(&m); } " ASMJIT_LIBC_HAS_LIBPTHREAD) if (ASMJIT_LIBC_HAS_LIBPTHREAD) message("-- Dependency: libpthread provided by libc (not linking to libpthread)") else() message("-- Dependency: libpthread not provided by libc, linking to libpthread") list(APPEND ASMJIT_DEPS pthread) endif() # Dependency: shm_open (required so AsmJit can use shm_open on supported platforms). if ("${CMAKE_SYSTEM_NAME}" MATCHES "^(Linux|NetBSD)$" AND NOT ASMJIT_NO_SHM_OPEN) check_cxx_source_compiles(" #include int main() { const char file_name[1] {}; return shm_open(file_name, 0, 0); } " ASMJIT_LIBC_HAS_LIBRT) if (ASMJIT_LIBC_HAS_LIBRT) message("-- Dependency: shm_open provided by libc (not linking to librt)") else() message("-- Dependency: shm_open not provided by libc, linking to librt") list(APPEND ASMJIT_DEPS rt) endif() endif() endif() set(ASMJIT_LIBS ${ASMJIT_DEPS}) if (NOT ASMJIT_EMBED) list(INSERT ASMJIT_LIBS 0 asmjit) endif() if (ASMJIT_EMBED) set(ASMJIT_TARGET_TYPE "EMBED") elseif (ASMJIT_STATIC) set(ASMJIT_TARGET_TYPE "STATIC") else() set(ASMJIT_TARGET_TYPE "SHARED") endif() foreach(build_option # AsmJit build options. ASMJIT_STATIC ASMJIT_NO_DEPRECATED # AsmJit backends selection. ASMJIT_NO_X86 ASMJIT_NO_AARCH64 ASMJIT_NO_FOREIGN # AsmJit features selection. ASMJIT_NO_JIT ASMJIT_NO_TEXT ASMJIT_NO_LOGGING ASMJIT_NO_INTROSPECTION ASMJIT_NO_VALIDATION ASMJIT_NO_BUILDER ASMJIT_NO_COMPILER) if (${build_option}) List(APPEND ASMJIT_CFLAGS "-D${build_option}") List(APPEND ASMJIT_PRIVATE_CFLAGS "-D${build_option}") endif() endforeach() # AsmJit - Linker Support # ======================= if (WIN32) if (CMAKE_LINKER MATCHES "link\\.exe" OR CMAKE_LINKER MATCHES "lld-link\\.exe") set(ASMJIT_LINKER_SUPPORTS_NATVIS TRUE) endif() endif() # AsmJit - Source # =============== set(ASMJIT_SRC_LIST asmjit/asmjit.h asmjit/asmjit-scope-begin.h asmjit/asmjit-scope-end.h asmjit/core.h asmjit/core/api-build_p.h asmjit/core/api-config.h asmjit/core/archtraits.cpp asmjit/core/archtraits.h asmjit/core/archcommons.h asmjit/core/assembler.cpp asmjit/core/assembler.h asmjit/core/builder.cpp asmjit/core/builder.h asmjit/core/codebuffer.h asmjit/core/codeholder.cpp asmjit/core/codeholder.h asmjit/core/codewriter.cpp asmjit/core/codewriter_p.h asmjit/core/compiler.cpp asmjit/core/compiler.h asmjit/core/compilerdefs.h asmjit/core/constpool.cpp asmjit/core/constpool.h asmjit/core/cpuinfo.cpp asmjit/core/cpuinfo.h asmjit/core/emithelper.cpp asmjit/core/emithelper_p.h asmjit/core/emitter.cpp asmjit/core/emitter.h asmjit/core/emitterutils.cpp asmjit/core/emitterutils_p.h asmjit/core/environment.cpp asmjit/core/environment.h asmjit/core/errorhandler.cpp asmjit/core/errorhandler.h asmjit/core/formatter.cpp asmjit/core/formatter.h asmjit/core/func.cpp asmjit/core/func.h asmjit/core/funcargscontext.cpp asmjit/core/funcargscontext_p.h asmjit/core/globals.cpp asmjit/core/globals.h asmjit/core/inst.cpp asmjit/core/inst.h asmjit/core/instdb.cpp asmjit/core/instdb_p.h asmjit/core/jitallocator.cpp asmjit/core/jitallocator.h asmjit/core/jitruntime.cpp asmjit/core/jitruntime.h asmjit/core/logger.cpp asmjit/core/logger.h asmjit/core/misc_p.h asmjit/core/operand.cpp asmjit/core/operand.h asmjit/core/osutils.cpp asmjit/core/osutils.h asmjit/core/osutils_p.h asmjit/core/raassignment_p.h asmjit/core/rabuilders_p.h asmjit/core/radefs_p.h asmjit/core/ralocal.cpp asmjit/core/ralocal_p.h asmjit/core/rapass.cpp asmjit/core/rapass_p.h asmjit/core/rastack.cpp asmjit/core/rastack_p.h asmjit/core/string.cpp asmjit/core/string.h asmjit/core/support.cpp asmjit/core/support.h asmjit/core/target.cpp asmjit/core/target.h asmjit/core/type.cpp asmjit/core/type.h asmjit/core/virtmem.cpp asmjit/core/virtmem.h asmjit/core/zone.cpp asmjit/core/zone.h asmjit/core/zonehash.cpp asmjit/core/zonehash.h asmjit/core/zonelist.cpp asmjit/core/zonelist.h asmjit/core/zonestack.cpp asmjit/core/zonestack.h asmjit/core/zonestring.h asmjit/core/zonetree.cpp asmjit/core/zonetree.h asmjit/core/zonevector.cpp asmjit/core/zonevector.h asmjit/a64.h asmjit/arm.h asmjit/arm/armformatter.cpp asmjit/arm/armformatter_p.h asmjit/arm/armglobals.h asmjit/arm/armoperand.h asmjit/arm/armutils.h asmjit/arm/a64archtraits_p.h asmjit/arm/a64assembler.cpp asmjit/arm/a64assembler.h asmjit/arm/a64builder.cpp asmjit/arm/a64builder.h asmjit/arm/a64compiler.cpp asmjit/arm/a64compiler.h asmjit/arm/a64emithelper.cpp asmjit/arm/a64emithelper_p.h asmjit/arm/a64emitter.h asmjit/arm/a64formatter.cpp asmjit/arm/a64formatter_p.h asmjit/arm/a64func.cpp asmjit/arm/a64func_p.h asmjit/arm/a64globals.h asmjit/arm/a64instapi.cpp asmjit/arm/a64instapi_p.h asmjit/arm/a64instdb.cpp asmjit/arm/a64instdb.h asmjit/arm/a64operand.cpp asmjit/arm/a64operand.h asmjit/arm/a64rapass.cpp asmjit/arm/a64rapass_p.h asmjit/x86.h asmjit/x86/x86archtraits_p.h asmjit/x86/x86assembler.cpp asmjit/x86/x86assembler.h asmjit/x86/x86builder.cpp asmjit/x86/x86builder.h asmjit/x86/x86compiler.cpp asmjit/x86/x86compiler.h asmjit/x86/x86emithelper.cpp asmjit/x86/x86emithelper_p.h asmjit/x86/x86emitter.h asmjit/x86/x86formatter.cpp asmjit/x86/x86formatter_p.h asmjit/x86/x86func.cpp asmjit/x86/x86func_p.h asmjit/x86/x86globals.h asmjit/x86/x86instdb.cpp asmjit/x86/x86instdb.h asmjit/x86/x86instdb_p.h asmjit/x86/x86instapi.cpp asmjit/x86/x86instapi_p.h asmjit/x86/x86operand.cpp asmjit/x86/x86operand.h asmjit/x86/x86rapass.cpp asmjit/x86/x86rapass_p.h ) if (MSVC AND NOT ASMJIT_NO_NATVIS) list(APPEND ASMJIT_SRC_LIST asmjit.natvis) endif() set(ASMJIT_SRC "") foreach(src_file ${ASMJIT_SRC_LIST}) set(src_file "${ASMJIT_DIR}/src/${src_file}") list(APPEND ASMJIT_SRC ${src_file}) if ("${src_file}" MATCHES "\\.natvis") if (ASMJIT_LINKER_SUPPORTS_NATVIS) list(APPEND ASMJIT_PRIVATE_LFLAGS "-natvis:${src_file}") endif() endif() endforeach() source_group(TREE "${ASMJIT_DIR}" FILES ${ASMJIT_SRC}) # AsmJit - Summary # ================ message("** AsmJit Summary **") message(" ASMJIT_DIR=${ASMJIT_DIR}") message(" ASMJIT_TEST=${ASMJIT_TEST}") message(" ASMJIT_TARGET_TYPE=${ASMJIT_TARGET_TYPE}") message(" ASMJIT_DEPS=${ASMJIT_DEPS}") message(" ASMJIT_LIBS=${ASMJIT_LIBS}") message(" ASMJIT_CFLAGS=${ASMJIT_CFLAGS}") message(" ASMJIT_PRIVATE_CFLAGS=${ASMJIT_PRIVATE_CFLAGS}") message(" ASMJIT_PRIVATE_CFLAGS_DBG=${ASMJIT_PRIVATE_CFLAGS_DBG}") message(" ASMJIT_PRIVATE_CFLAGS_REL=${ASMJIT_PRIVATE_CFLAGS_REL}") # AsmJit - Targets # ================ if (NOT ASMJIT_EMBED) # Add AsmJit target. asmjit_add_target(asmjit "${ASMJIT_TARGET_TYPE}" SOURCES ${ASMJIT_SRC} LIBRARIES ${ASMJIT_DEPS} CFLAGS ${ASMJIT_PRIVATE_CFLAGS} CFLAGS_DBG ${ASMJIT_PRIVATE_CFLAGS_DBG} CFLAGS_REL ${ASMJIT_PRIVATE_CFLAGS_REL}) target_compile_options(asmjit INTERFACE ${ASMJIT_CFLAGS}) target_include_directories(asmjit BEFORE INTERFACE $ $) # Add blend2d::blend2d alias. add_library(asmjit::asmjit ALIAS asmjit) # TODO: [CMAKE] Deprecated alias - we use projectname::libraryname convention now. add_library(AsmJit::AsmJit ALIAS asmjit) # Add AsmJit install instructions (library and public headers). if (NOT ASMJIT_NO_INSTALL) install(TARGETS asmjit EXPORT asmjit-config RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}" ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}" LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}" INCLUDES DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}") install(EXPORT asmjit-config NAMESPACE asmjit:: DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/asmjit") foreach(_src_file ${ASMJIT_SRC_LIST}) if ("${_src_file}" MATCHES "\\.h$" AND NOT "${_src_file}" MATCHES "_p\\.h$") get_filename_component(_src_dir ${_src_file} PATH) install(FILES "${ASMJIT_DIR}/src/${_src_file}" DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/${_src_dir}") endif() endforeach() endif() # Add AsmJit tests. if (ASMJIT_TEST) enable_testing() # Special target that always uses embedded AsmJit. asmjit_add_target(asmjit_test_unit TEST SOURCES ${ASMJIT_SRC} test/asmjit_test_unit.cpp test/broken.cpp test/broken.h LIBRARIES ${ASMJIT_DEPS} CFLAGS ${ASMJIT_PRIVATE_CFLAGS} -DASMJIT_TEST -DASMJIT_STATIC CFLAGS_DBG ${ASMJIT_PRIVATE_CFLAGS_DBG} CFLAGS_REL ${ASMJIT_PRIVATE_CFLAGS_REL}) target_include_directories(asmjit_test_unit BEFORE PRIVATE ${ASMJIT_INCLUDE_DIRS}) asmjit_add_target(asmjit_test_assembler TEST SOURCES test/asmjit_test_assembler.cpp test/asmjit_test_assembler.h test/asmjit_test_assembler_a64.cpp test/asmjit_test_assembler_x64.cpp test/asmjit_test_assembler_x86.cpp LIBRARIES asmjit::asmjit CFLAGS ${ASMJIT_PRIVATE_CFLAGS} CFLAGS_DBG ${ASMJIT_PRIVATE_CFLAGS_DBG} CFLAGS_REL ${ASMJIT_PRIVATE_CFLAGS_REL}) asmjit_add_target(asmjit_test_perf EXECUTABLE SOURCES test/asmjit_test_perf.cpp test/asmjit_test_perf_a64.cpp test/asmjit_test_perf_x86.cpp SOURCES test/asmjit_test_perf.h LIBRARIES asmjit::asmjit CFLAGS ${ASMJIT_PRIVATE_CFLAGS} CFLAGS_DBG ${ASMJIT_PRIVATE_CFLAGS_DBG} CFLAGS_REL ${ASMJIT_PRIVATE_CFLAGS_REL}) foreach(_target asmjit_test_emitters asmjit_test_x86_sections) asmjit_add_target(${_target} TEST SOURCES test/${_target}.cpp LIBRARIES asmjit::asmjit CFLAGS ${ASMJIT_PRIVATE_CFLAGS} CFLAGS_DBG ${ASMJIT_PRIVATE_CFLAGS_DBG} CFLAGS_REL ${ASMJIT_PRIVATE_CFLAGS_REL}) endforeach() if (NOT ASMJIT_NO_INTROSPECTION) asmjit_add_target(asmjit_test_instinfo TEST SOURCES test/asmjit_test_instinfo.cpp LIBRARIES asmjit::asmjit CFLAGS ${ASMJIT_PRIVATE_CFLAGS} CFLAGS_DBG ${ASMJIT_PRIVATE_CFLAGS_DBG} CFLAGS_REL ${ASMJIT_PRIVATE_CFLAGS_REL}) endif() if (NOT (ASMJIT_NO_BUILDER OR ASMJIT_NO_COMPILER)) # Vectorcall tests and XMM tests require at least SSE2 in 32-bit mode (in 64-bit mode it's implicit). # Some compilers don't like passing -msse2 for 64-bit targets, and some compilers targeting non-x86 # would pass "-msse2" compile flag check, but with a warning not detected by CMake. Thus, verify that # our target is really 32-bit X86 and only use -msse2 or -arch:SSE2 flags when necessary. set(ASMJIT_SSE2_CFLAGS "") check_cxx_source_compiles(" #if defined(_M_IX86) || defined(__X86__) || defined(__i386__) int target_is_32_bit_x86() { return 1; } #else // Compile error... #endif int main() { return target_is_32_bit_x86(); } " ASMJIT_TARGET_IS_32_BIT_X86) if (ASMJIT_TARGET_IS_32_BIT_X86) if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC" OR "x${CMAKE_CXX_COMPILER_FRONTEND_VARIANT}" STREQUAL "xMSVC") asmjit_detect_cflags(ASMJIT_SSE2_CFLAGS "-arch:SSE2") else() asmjit_detect_cflags(ASMJIT_SSE2_CFLAGS "-msse2") endif() endif() asmjit_add_target(asmjit_test_compiler TEST SOURCES test/asmjit_test_compiler.cpp test/asmjit_test_compiler.h test/asmjit_test_compiler_a64.cpp test/asmjit_test_compiler_x86.cpp LIBRARIES asmjit::asmjit CFLAGS ${ASMJIT_PRIVATE_CFLAGS} ${ASMJIT_SSE2_CFLAGS} CFLAGS_DBG ${ASMJIT_PRIVATE_CFLAGS_DBG} CFLAGS_REL ${ASMJIT_PRIVATE_CFLAGS_REL}) endif() endif() endif() cmake_policy(POP)