blob: 750292f30ccc13c2062a0da520ab573044caa018 [file] [log] [blame]
cmake_minimum_required(VERSION 3.2)
project (CHAKRACORE)
# Keep CMake from caching static/shared library
# option. Otherwise, CMake fails to update cached
# references
# todo: create a sub cmake file to take care of _SH uncaching...
if(SHARED_LIBRARY_SH)
unset(SHARED_LIBRARY_SH CACHE)
unset(STATIC_LIBRARY_SH CACHE)
unset(STATIC_LIBRARY CACHE)
set(SHARED_LIBRARY 1)
endif()
if(STATIC_LIBRARY_SH)
unset(SHARED_LIBRARY_SH CACHE)
unset(STATIC_LIBRARY_SH CACHE)
unset(SHARED_LIBRARY CACHE)
set(STATIC_LIBRARY 1)
endif()
if(LIBS_ONLY_BUILD_SH)
unset(LIBS_ONLY_BUILD_SH CACHE)
set(CC_LIBS_ONLY_BUILD 1)
endif()
if(CC_USES_SYSTEM_ARCH_SH)
if(CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64")
set(CC_TARGETS_AMD64_SH 1)
elseif(CMAKE_SYSTEM_PROCESSOR STREQUAL "armv7l")
set(CC_TARGETS_ARM_SH 1)
endif()
unset(CC_USES_SYSTEM_ARCH_SH CACHE)
endif()
if(CC_TARGETS_AMD64_SH)
set(CC_TARGETS_AMD64 1)
elseif(CC_TARGETS_ARM_SH)
set(CC_TARGETS_ARM 1)
add_definitions(-D_ARM_=1)
set(CMAKE_SYSTEM_PROCESSOR "armv7l")
elseif(CC_TARGETS_X86_SH)
set(CC_TARGETS_X86 1)
set(CMAKE_SYSTEM_PROCESSOR "i386")
else()
message(FATAL_ERROR "Couldn't detect target processor, try `--arch` argument with build.sh")
endif()
unset(CC_TARGETS_ARM_SH CACHE)
unset(CC_TARGETS_X86_SH CACHE)
unset(CC_TARGETS_AMD64_SH CACHE)
if(CCACHE_PROGRAM_NAME_SH)
find_program(CCACHE_PROGRAM ${CCACHE_PROGRAM_NAME_SH})
if (CCACHE_PROGRAM)
set(CMAKE_CXX_COMPILER_LAUNCHER ${CCACHE_PROGRAM})
set(CMAKE_C_COMPILER_LAUNCHER ${CCACHE_PROGRAM})
endif()
unset(CCACHE_PROGRAM_NAME_SH CACHE)
endif()
if(ENABLE_VALGRIND_SH)
unset(ENABLE_VALGRIND_SH CACHE)
if(NOT CC_TARGETS_X86)
# Enable Valgrind is not needed for x86 builds. Already <= 32Gb address space
set(ENABLE_VALGRIND 1)
add_definitions(-DENABLE_VALGRIND=1)
endif()
endif()
if(ICU_SETTINGS_RESET)
unset(ICU_SETTINGS_RESET CACHE)
unset(ICU_INCLUDE_PATH_SH CACHE)
unset(NO_ICU_SH CACHE)
unset(LOCAL_ICU_SH CACHE)
unset(SYSTEM_ICU_SH CACHE)
endif()
if(CC_TARGET_OS_ANDROID_SH)
set(CC_TARGET_OS_ANDROID 1)
set(CMAKE_SYSTEM_NAME Android)
set(ANDROID_NDK "android-toolchain-arm/")
set(ANDROID_ABI armeabi-v7a)
set(CMAKE_SYSTEM_VERSION 21)
set(CMAKE_ANDROID_ARCH_ABI armeabi)
set(ANDROID_TOOLCHAIN_NAME arm-linux-androideabi-clang3.8)
set(ANDROID_STL "c++_static")
unset(CC_TARGET_OS_ANDROID_SH CACHE)
elseif(CMAKE_SYSTEM_NAME STREQUAL Linux)
set(CC_TARGET_OS_LINUX 1)
elseif(CMAKE_SYSTEM_NAME STREQUAL Darwin)
set(CC_TARGET_OS_OSX 1)
endif()
if (ENABLE_CC_XPLAT_TRACE_SH)
unset(ENABLE_CC_XPLAT_TRACE_SH CACHE)
set(ENABLE_CC_XPLAT_TRACE 1)
if (CC_TARGET_OS_ANDROID)
add_definitions(-DTRACE_OUTPUT_TO_LOGCAT=1)
else()
add_definitions(-DTRACE_OUTPUT_TARGET_FILE=1)
endif()
add_definitions(-DENABLE_CC_XPLAT_TRACE=1)
add_compile_options(-finstrument-functions)
add_compile_options(-g)
add_compile_options(-ggdb)
if(NOT STATIC_LIBRARY)
message(FATAL_ERROR "Trace option is available only for --static builds")
endif()
endif()
if(ICU_INCLUDE_PATH_SH)
set(ICU_INCLUDE_PATH ${ICU_INCLUDE_PATH_SH})
unset(ICU_INCLUDE_PATH_SH CACHE)
endif()
if(NO_ICU_SH)
set(NO_ICU 1)
unset(NO_ICU_SH CACHE)
endif()
if(SYSTEM_ICU_SH)
set(SYSTEM_ICU 1)
unset(SYSTEM_ICU_SH CACHE)
endif()
if(INTL_ICU_SH)
unset(INTL_ICU_SH CACHE)
set(INTL_ICU 1)
else()
unset(INTL_ICU_SH CACHE)
set(INTL_ICU 0)
endif()
if(ICU_INCLUDE_PATH)
add_definitions(-DHAS_REAL_ICU=1)
add_definitions(-DHAS_ICU)
set(ICU_LIBRARY_PATH "${ICU_INCLUDE_PATH}/../lib/")
find_library(ICUUC icuuc PATHS ${ICU_LIBRARY_PATH} NO_DEFAULT_PATH)
if(INTL_ICU)
add_definitions(-DINTL_ICU=1)
find_library(ICUIN icui18n PATHS ${ICU_LIBRARY_PATH} NO_DEFAULT_PATH)
# In a default install, ICU header files are all in ICU_ROOT/include
# However, for Node, the include/ folder is never generated, so we have to look
# in NODE/deps/icu/source/{common|i18n} for headers
set(ICU_INCLUDE_PATH
"${ICU_INCLUDE_PATH}"
"${ICU_INCLUDE_PATH}/../i18n/"
)
endif()
if(ICUUC)
message("-- found ICU libs: ${ICU_LIBRARY_PATH}")
find_library(ICUDATA icudata PATHS ${ICU_LIBRARY_PATH} NO_DEFAULT_PATH)
if (NOT ICUDATA)
set(ICUDATA "")
endif()
set(ICU_LIBRARIES
${ICUUC}
${ICUIN}
${ICUDATA}
)
endif()
endif()
if(CC_TARGET_OS_LINUX OR CC_TARGET_OS_ANDROID)
if(SYSTEM_ICU OR (NOT ICU_INCLUDE_PATH AND NOT NO_ICU))
set(ICU_LIBRARIES "icuuc")
if(INTL_ICU)
add_definitions(-DINTL_ICU=1)
set(ICU_LIBRARIES
${ICU_LIBRARIES}
icui18n
)
endif()
add_definitions(-DHAS_REAL_ICU=1)
add_definitions(-DHAS_ICU)
endif()
elseif(CC_TARGET_OS_OSX)
# in case ICU path was given but it doesn't exist, build script will fail.
# so, fallback only if ICU path wasn't given
if(NOT ICU_INCLUDE_PATH)
set(NO_ICU 1)
message("-- Couldn't find ICU. Falling back to --no-icu build")
endif()
endif()
set(CLR_CMAKE_PLATFORM_XPLAT 1)
if(CC_TARGETS_AMD64)
add_definitions(-DTARGET_64)
add_compile_options(-msse4.2)
if(NOT CMAKE_BUILD_TYPE STREQUAL Release)
set(CAN_BUILD_WABT 1)
endif()
elseif(CC_TARGETS_X86)
add_definitions(-D__i686__)
add_definitions(-DTARGET_32)
add_compile_options(-arch i386)
add_compile_options(-msse3)
set(CMAKE_ASM_FLAGS "${CMAKE_ASM_FLAGS} \
-m32"
)
elseif(CC_TARGETS_ARM)
add_definitions(-D__arm__)
add_definitions(-DTARGET_32)
add_definitions(-D_M_ARM32_OR_ARM64)
if(CC_TARGET_OS_OSX)
add_compile_options(-arch arm)
elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
# reduce link time memory usage
set(LINKER_REDUCED_MEMORY "-Xlinker --no-keep-memory")
endif()
else()
message(FATAL_ERROR "Only AMD64, ARM and I386 are supported")
endif()
if(CAN_BUILD_WABT)
add_definitions(-DCAN_BUILD_WABT)
endif()
if(CC_TARGET_OS_LINUX OR CC_TARGET_OS_ANDROID)
set(CLR_CMAKE_PLATFORM_LINUX 1)
# OSX 10.12 Clang deprecates libstdc++ [See GH #1599]
# So, -Werror is linux only for now
# + Android ARM ABI shows ld warnings
# xplat-todo: Do we need this ?
if (NOT CC_TARGET_OS_ANDROID)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} \
-Werror"
)
endif()
elseif(CC_TARGET_OS_OSX)
add_definitions(
-DPLATFORM_UNIX
)
if(NOT CC_XCODE_PROJECT)
set(OSX_DEPLOYMENT_TARGET "$ENV{MACOSX_DEPLOYMENT_TARGET} CC")
if (${OSX_DEPLOYMENT_TARGET} STREQUAL " CC")
set(OSX_DEPLOYMENT_TARGET "10.9")
add_compile_options(-mmacosx-version-min=10.9)
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} \
-mmacosx-version-min=10.9 -std=gnu99")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} \
-mmacosx-version-min=10.9 -std=gnu++11")
else()
set(OSX_DEPLOYMENT_TARGET "$ENV{MACOSX_DEPLOYMENT_TARGET}")
message(WARNING "-- !! macOS Deployment Target was set to $ENV{MACOSX_DEPLOYMENT_TARGET}. Using it as is.")
endif()
endif()
else()
message(FATAL_ERROR "This OS is not supported")
endif()
if (CMAKE_CXX_COMPILER_ID STREQUAL AppleClang
OR CMAKE_CXX_COMPILER_ID STREQUAL Clang
OR CMAKE_CXX_COMPILER_ID STREQUAL GNU)
# Color diagnostics for g++ and clang++
add_definitions("-fdiagnostics-color=always")
endif()
if(STATIC_LIBRARY)
add_definitions(-DCHAKRA_STATIC_LIBRARY=1)
endif()
if(CLR_CMAKE_PLATFORM_XPLAT)
add_definitions(-D_CHAKRACOREBUILD)
add_definitions(-DFEATURE_PAL)
add_definitions(-DPLATFORM_UNIX=1)
if(CLR_CMAKE_PLATFORM_LINUX)
add_definitions(-D__LINUX__=1)
if(CC_TARGETS_AMD64)
add_definitions(-DLINUX64)
endif(CC_TARGETS_AMD64)
endif(CLR_CMAKE_PLATFORM_LINUX)
if(CC_TARGETS_AMD64)
set(IS_64BIT_BUILD 1)
add_definitions(-D_M_X64 -D_M_AMD64 -D_AMD64_)
endif(CC_TARGETS_AMD64)
add_definitions(
-DUNICODE
-D_SAFECRT_USE_CPP_OVERLOADS=1
-D__STDC_WANT_LIB_EXT1__=1
)
set(CMAKE_CXX_STANDARD 11)
# CC WARNING FLAGS
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} \
-Wno-implicit-function-declaration"
)
# todo: fix general visibility of the interface
# do not set to `fvisibility=hidden` as it is going to
# prevent the required interface is being exported
# clang by default sets fvisibility=default
# CXX WARNING FLAGS
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} \
-Wno-ignored-attributes\
-Wno-deprecated-declarations\
-Wno-parentheses-equality\
-Wno-missing-braces\
-Wno-reorder\
-Wno-microsoft\
-Wno-unused-value\
-Wno-int-to-void-pointer-cast\
-Wno-invalid-offsetof\
-Wno-undefined-inline\
-Wno-inconsistent-missing-override\
-Wno-c++14-extensions\
-Wno-macro-redefined\
-Wno-pragmas\
-Wno-invalid-token-paste\
-Wno-format\
-Wno-invalid-noreturn\
-Wno-null-arithmetic\
-Wno-tautological-constant-out-of-range-compare\
-Wno-tautological-undefined-compare\
-Wno-address-of-temporary\
-Wno-null-conversion\
-Wno-return-type\
-Wno-switch\
-Wno-implicit-function-declaration\
-Wno-int-to-pointer-cast\
-Wno-tautological-constant-compare\
-Wno-enum-compare-switch\
-Wno-unknown-warning-option"
)
# notes..
# -Wno-address-of-temporary # vtinfo.h, VirtualTableInfo<T>::RegisterVirtualTable
# -Wno-null-conversion # Check shmemory.cpp and cs.cpp here...
# -Wno-return-type # switch unreachable code
# -Wno-switch # switch values not handled
# -W-enum-compare-switch # throws warning on enum1 == enum2 where both
# enums represent same value but do not share the type. ie. we use both AsmJsType
# and AsmJsRetType interchangably and filter things out by `default:` case.
# -W-tautological-constant-compare throws warning for checks known at compile time.
# Some of those checks are optimized out during compile / lto time, and others
# are platform / compiler dependent.
# -Wno-unknown-warning-option ... well, some of the new switches are not
# recognized by older compilers and they fail. So, put this one and not fail
include(Build/CMakeFeatureDetect.cmake)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} \
${CXX_DO_NOT_OPTIMIZE_SIBLING_CALLS} \
-fno-omit-frame-pointer \
-fdelayed-template-parsing"
)
# CXX / CC COMPILER FLAGS
add_compile_options(
-fasm-blocks
-fms-extensions
-fwrapv # Treat signed integer overflow as two's complement
)
# Only disable RTTI in release builds so that TrackAlloc works for debug and test builds
# Also disable RTTI when building a shared library
# TODO: why does the shared library break with rtti disabled?
if(CMAKE_BUILD_TYPE STREQUAL Release)
if(STATIC_LIBRARY)
add_compile_options(-fno-rtti)
endif()
endif()
endif(CLR_CMAKE_PLATFORM_XPLAT)
if (ENABLE_FULL_LTO_SH OR ENABLE_THIN_LTO_SH)
if (CC_TARGET_OS_LINUX)
set(CC_LTO_ENABLED -use-gold-plugin)
set(CC_LTO_ENABLED_C -c)
endif()
if (ENABLE_FULL_LTO_SH)
unset(DENABLE_FULL_LTO_SH CACHE)
add_compile_options(-flto ${CC_LTO_ENABLED_C})
if (CC_LTO_ENABLED)
set(CC_LTO_ENABLED "${CC_LTO_ENABLED} -flto")
endif()
elseif (ENABLE_THIN_LTO_SH)
unset(ENABLE_THIN_LTO_SH CACHE)
add_compile_options(-flto=thin)
if (CC_LTO_ENABLED)
set(CC_LTO_ENABLED "${CC_LTO_ENABLED} -flto=thin")
endif()
endif()
endif()
if(CMAKE_BUILD_TYPE STREQUAL Debug)
add_definitions(
-DDBG=1
-DDEBUG=1
-D_DEBUG=1 # for PAL
-DDBG_DUMP=1
)
elseif(CMAKE_BUILD_TYPE STREQUAL Test)
add_definitions(
-DENABLE_DEBUG_CONFIG_OPTIONS=1
)
add_compile_options(-g)
endif(CMAKE_BUILD_TYPE STREQUAL Debug)
if(NOT CMAKE_BUILD_TYPE STREQUAL Debug)
add_compile_options(-O3)
else()
add_compile_options(-O0)
endif(NOT CMAKE_BUILD_TYPE STREQUAL Debug)
if(IS_64BIT_BUILD)
add_definitions(
-DBIT64=1
-DSTACK_ALIGN=16
)
endif(IS_64BIT_BUILD)
if(NO_JIT_SH)
unset(NO_JIT_SH CACHE) # don't cache
unset(BuildJIT CACHE) # also clear it just in case
add_definitions(-DDISABLE_JIT=1)
else()
set(BuildJIT 1)
endif()
if(WITHOUT_FEATURES_SH)
add_definitions(${WITHOUT_FEATURES_SH})
unset(WITHOUT_FEATURES_SH CACHE) # don't cache
endif(WITHOUT_FEATURES_SH)
if(EXTRA_DEFINES_SH)
add_definitions(${EXTRA_DEFINES_SH})
unset(EXTRA_DEFINES_SH CACHE) #don't cache
endif(EXTRA_DEFINES_SH)
enable_language(ASM)
if(CMAKE_SYSTEM_NAME STREQUAL Darwin)
set(DYN_LIB_EXT "dylib")
else()
set(DYN_LIB_EXT "so")
endif()
################# Write-barrier check/analyze ##################
if (WB_CHECK_SH OR WB_ANALYZE_SH)
add_definitions(
-Xclang -load
-Xclang ${CMAKE_CURRENT_SOURCE_DIR}/tools/RecyclerChecker/Build/libclangRecyclerChecker.${DYN_LIB_EXT}
)
endif()
if (WB_CHECK_SH)
unset(WB_CHECK_SH CACHE) # don't cache
add_definitions(
-Xclang -add-plugin
-Xclang check-recycler
)
endif()
if (WB_ANALYZE_SH)
unset(WB_ANALYZE_SH CACHE) # don't cache
add_definitions(
-Xclang -analyze
-Xclang -analyzer-checker=chakra.RecyclerChecker
)
endif()
if (WB_ARGS_SH)
foreach(wb_arg IN LISTS WB_ARGS_SH)
add_definitions(
-Xclang -plugin-arg-check-recycler
-Xclang ${wb_arg}
)
endforeach(wb_arg)
unset(WB_ARGS_SH CACHE) # don't cache
endif()
include_directories(
.
lib/Common
lib/Common/PlaceHolder
pal
pal/inc
pal/inc/rt
${ICU_INCLUDE_PATH}
)
if(ICU_INCLUDE_PATH)
if(NOT HAVE_LIBICU_UCHAR_H)
set(HAVE_LIBICU_UCHAR_H 1)
endif()
endif()
# detect features
include_directories(SYSTEM /usr/local/include)
include(pal/src/configure.cmake)
# this should be after `detect feature` to not to affect feature detection
# Clang -fsanitize.
if (CLANG_SANITIZE_SH)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=${CLANG_SANITIZE_SH}")
set(CMAKE_CXX_LINK_FLAGS "${CMAKE_CXX_LINK_FLAGS} -fsanitize=${CLANG_SANITIZE_SH}")
unset(CLANG_SANITIZE_SH CACHE) # don't cache
endif()
add_subdirectory (pal)
# build the rest with NO_PAL_MINMAX and PAL_STDCPP_COMPAT
add_definitions(
-DNO_PAL_MINMAX
-DPAL_STDCPP_COMPAT
)
if (ENABLE_JS_LTTNG_SH)
unset(ENABLE_JS_LTTNG_SH CACHE)
include_directories (
${CMAKE_CURRENT_SOURCE_DIR}/out/lttng
)
add_subdirectory ($ENV{TARGET_PATH}/lttng ${CMAKE_CURRENT_BINARY_DIR}/lttng)
add_definitions(
-DENABLE_JS_ETW
-DENABLE_JS_LTTNG
)
set(USE_LTTNG "1")
endif()
add_subdirectory (lib)
add_subdirectory (bin)