263 lines
11 KiB
CMake
263 lines
11 KiB
CMake
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
|
# SPDX-License-Identifier: Apache-2.0.
|
|
|
|
include(CheckCCompilerFlag)
|
|
include(CheckIncludeFile)
|
|
include(CheckSymbolExists)
|
|
|
|
option(AWS_ENABLE_LTO "Enables LTO on libraries. Ensure this is set on all consumed targets, or linking will fail" OFF)
|
|
option(LEGACY_COMPILER_SUPPORT "This enables builds with compiler versions such as gcc 4.1.2. This is not a 'supported' feature; it's just a best effort." OFF)
|
|
option(AWS_SUPPORT_WIN7 "Restricts WINAPI calls to Win7 and older (This will have implications in downstream libraries that use TLS especially)" OFF)
|
|
option(AWS_WARNINGS_ARE_ERRORS "Compiler warning is treated as an error. Try turning this off when observing errors on a new or uncommon compiler" OFF)
|
|
option(AWS_ENABLE_TRACING "Enable tracing macros" OFF)
|
|
option(AWS_STATIC_MSVC_RUNTIME_LIBRARY "Windows-only. Turn ON to use the statically-linked MSVC runtime lib, instead of the DLL" OFF)
|
|
option(STATIC_CRT "Deprecated. Use AWS_STATIC_MSVC_RUNTIME_LIBRARY instead" OFF)
|
|
|
|
# Check for Posix Large Files Support (LFS).
|
|
# On most 64bit systems, LFS is enabled by default.
|
|
# On some 32bit systems, LFS must be enabled by via defines before headers are included.
|
|
# For more info, see docs:
|
|
# https://www.gnu.org/software/libc/manual/html_node/File-Position-Primitive.html
|
|
# https://www.gnu.org/software/libc/manual/html_node/Feature-Test-Macros.html
|
|
function(aws_check_posix_lfs extra_flags variable)
|
|
list(APPEND CMAKE_REQUIRED_FLAGS ${extra_flags})
|
|
check_c_source_compiles("
|
|
#include <stdio.h>
|
|
|
|
/* fails to compile if off_t smaller than 64bits */
|
|
typedef char array[sizeof(off_t) >= 8 ? 1 : -1];
|
|
|
|
int main() {
|
|
return 0;
|
|
}"
|
|
HAS_64BIT_FILE_OFFSET_${variable})
|
|
|
|
if (HAS_64BIT_FILE_OFFSET_${variable})
|
|
# sometimes off_t is 64bit, but fseeko() is missing (ex: Android API < 24)
|
|
check_symbol_exists(fseeko "stdio.h" HAS_FSEEKO_${variable})
|
|
|
|
if (HAS_FSEEKO_${variable})
|
|
set(${variable} 1 PARENT_SCOPE)
|
|
endif()
|
|
endif()
|
|
endfunction()
|
|
|
|
# This function will set all common flags on a target
|
|
# Options:
|
|
# NO_WGNU: Disable -Wgnu
|
|
# NO_WEXTRA: Disable -Wextra
|
|
# NO_PEDANTIC: Disable -pedantic
|
|
function(aws_set_common_properties target)
|
|
set(options NO_WGNU NO_WEXTRA NO_PEDANTIC NO_LTO)
|
|
cmake_parse_arguments(SET_PROPERTIES "${options}" "" "" ${ARGN})
|
|
|
|
if(MSVC)
|
|
# Remove other /W flags
|
|
if(CMAKE_C_FLAGS MATCHES "/W[0-4]")
|
|
string(REGEX REPLACE "/W[0-4]" "" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
|
|
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS}" PARENT_SCOPE)
|
|
endif()
|
|
|
|
list(APPEND AWS_C_FLAGS /W4 /MP)
|
|
|
|
if(AWS_WARNINGS_ARE_ERRORS)
|
|
list(APPEND AWS_C_FLAGS /WX)
|
|
endif()
|
|
|
|
# /volatile:iso relaxes some implicit memory barriers that MSVC normally applies for volatile accesses
|
|
# Since we want to be compatible with user builds using /volatile:iso, use it for the tests.
|
|
list(APPEND AWS_C_FLAGS /volatile:iso)
|
|
|
|
# disable non-constant initializer warning, it's not non-standard, just for Microsoft
|
|
list(APPEND AWS_C_FLAGS /wd4204)
|
|
# disable passing the address of a local warning. Again, not non-standard, just for Microsoft
|
|
list(APPEND AWS_C_FLAGS /wd4221)
|
|
|
|
if (AWS_SUPPORT_WIN7)
|
|
# Use only APIs available in Win7 and later
|
|
message(STATUS "Windows 7 support requested, forcing WINVER and _WIN32_WINNT to 0x0601")
|
|
list(APPEND AWS_C_FLAGS /DWINVER=0x0601)
|
|
list(APPEND AWS_C_FLAGS /D_WIN32_WINNT=0x0601)
|
|
list(APPEND AWS_C_FLAGS /DAWS_SUPPORT_WIN7=1)
|
|
endif()
|
|
|
|
# Set MSVC runtime libary.
|
|
# Note: there are other ways of doing this if we bump our CMake minimum to 3.14+
|
|
# See: https://cmake.org/cmake/help/latest/policy/CMP0091.html
|
|
if (AWS_STATIC_MSVC_RUNTIME_LIBRARY OR STATIC_CRT)
|
|
list(APPEND AWS_C_FLAGS "/MT$<$<CONFIG:Debug>:d>")
|
|
else()
|
|
list(APPEND AWS_C_FLAGS "/MD$<$<CONFIG:Debug>:d>")
|
|
endif()
|
|
|
|
else()
|
|
list(APPEND AWS_C_FLAGS -Wall -Wstrict-prototypes)
|
|
|
|
list(APPEND AWS_C_FLAGS $<$<NOT:$<CONFIG:Release>>:-fno-omit-frame-pointer>)
|
|
|
|
if(NOT SET_PROPERTIES_NO_WEXTRA)
|
|
list(APPEND AWS_C_FLAGS -Wextra)
|
|
endif()
|
|
|
|
if(NOT SET_PROPERTIES_NO_PEDANTIC)
|
|
list(APPEND AWS_C_FLAGS -pedantic)
|
|
endif()
|
|
|
|
# Warning disables always go last to avoid future flags re-enabling them
|
|
list(APPEND AWS_C_FLAGS -Wno-long-long)
|
|
|
|
# Always enable position independent code, since this code will always end up in a shared lib
|
|
check_c_compiler_flag("-fPIC -Werror" HAS_FPIC_FLAG)
|
|
if (HAS_FPIC_FLAG)
|
|
list(APPEND AWS_C_FLAGS -fPIC)
|
|
endif()
|
|
|
|
if (LEGACY_COMPILER_SUPPORT)
|
|
list(APPEND AWS_C_FLAGS -Wno-strict-aliasing)
|
|
endif()
|
|
|
|
# -moutline-atomics generates code for both older load/store exclusive atomics and also
|
|
# Arm's Large System Extensions (LSE) which scale substantially better on large core count systems.
|
|
#
|
|
# Test by compiling a program that actually uses atomics.
|
|
# Previously we'd simply used check_c_compiler_flag() but that wasn't detecting
|
|
# some real-world problems (see https://github.com/awslabs/aws-c-common/issues/902).
|
|
if (AWS_ARCH_ARM64)
|
|
set(old_flags "${CMAKE_REQUIRED_FLAGS}")
|
|
set(CMAKE_REQUIRED_FLAGS "-moutline-atomics -Werror")
|
|
check_c_source_compiles("
|
|
int main() {
|
|
int x = 1;
|
|
__atomic_fetch_add(&x, -1, __ATOMIC_SEQ_CST);
|
|
return x;
|
|
}" HAS_MOUTLINE_ATOMICS)
|
|
set(CMAKE_REQUIRED_FLAGS "${old_flags}")
|
|
|
|
if (HAS_MOUTLINE_ATOMICS)
|
|
list(APPEND AWS_C_FLAGS -moutline-atomics)
|
|
endif()
|
|
endif()
|
|
|
|
# Check for Posix Large File Support (LFS).
|
|
# Doing this check here, instead of AwsFeatureTests.cmake,
|
|
# because we might need to modify AWS_C_FLAGS to enable it.
|
|
set(HAS_LFS FALSE)
|
|
aws_check_posix_lfs("" BY_DEFAULT)
|
|
if (BY_DEFAULT)
|
|
set(HAS_LFS TRUE)
|
|
else()
|
|
aws_check_posix_lfs("-D_FILE_OFFSET_BITS=64" VIA_DEFINES)
|
|
if (VIA_DEFINES)
|
|
list(APPEND AWS_C_FLAGS "-D_FILE_OFFSET_BITS=64")
|
|
set(HAS_LFS TRUE)
|
|
endif()
|
|
endif()
|
|
# This becomes a define in config.h
|
|
set(AWS_HAVE_POSIX_LARGE_FILE_SUPPORT ${HAS_LFS} CACHE BOOL "Posix Large File Support")
|
|
|
|
# Hide symbols from libcrypto.a
|
|
# This avoids problems when an application ends up using both libcrypto.a and libcrypto.so.
|
|
#
|
|
# An example of this happening is the aws-c-io tests.
|
|
# All the C libs are compiled statically, but then a PKCS#11 library is
|
|
# loaded at runtime which happens to use libcrypto.so from OpenSSL.
|
|
# If the symbols from libcrypto.a aren't hidden, then SOME function calls use the libcrypto.a implementation
|
|
# and SOME function calls use the libcrypto.so implementation, and this mismatch leads to weird crashes.
|
|
if (UNIX AND NOT APPLE)
|
|
# If we used target_link_options() (CMake 3.13+) we could make these flags PUBLIC
|
|
set_property(TARGET ${target} APPEND_STRING PROPERTY LINK_FLAGS " -Wl,--exclude-libs,libcrypto.a")
|
|
endif()
|
|
|
|
|
|
endif()
|
|
|
|
check_include_file(stdint.h HAS_STDINT)
|
|
check_include_file(stdbool.h HAS_STDBOOL)
|
|
|
|
if (NOT HAS_STDINT)
|
|
list(APPEND AWS_C_FLAGS -DNO_STDINT)
|
|
endif()
|
|
|
|
if (NOT HAS_STDBOOL)
|
|
list(APPEND AWS_C_FLAGS -DNO_STDBOOL)
|
|
endif()
|
|
|
|
if(NOT SET_PROPERTIES_NO_WGNU)
|
|
check_c_compiler_flag("-Wgnu -Werror" HAS_WGNU)
|
|
if(HAS_WGNU)
|
|
# -Wgnu-zero-variadic-macro-arguments results in a lot of false positives
|
|
list(APPEND AWS_C_FLAGS -Wgnu -Wno-gnu-zero-variadic-macro-arguments)
|
|
|
|
# some platforms implement htonl family of functions via GNU statement expressions (https://gcc.gnu.org/onlinedocs/gcc/Statement-Exprs.html)
|
|
# which generates -Wgnu-statement-expression warning.
|
|
set(old_flags "${CMAKE_REQUIRED_FLAGS}")
|
|
set(CMAKE_REQUIRED_FLAGS "-Wgnu -Werror")
|
|
check_c_source_compiles("
|
|
#include <netinet/in.h>
|
|
|
|
int main() {
|
|
uint32_t x = 0;
|
|
x = htonl(x);
|
|
return (int)x;
|
|
}" NO_GNU_EXPR)
|
|
set(CMAKE_REQUIRED_FLAGS "${old_flags}")
|
|
|
|
if (NOT NO_GNU_EXPR)
|
|
list(APPEND AWS_C_FLAGS -Wno-gnu-statement-expression)
|
|
endif()
|
|
endif()
|
|
endif()
|
|
|
|
# some platforms (especially when cross-compiling) do not have the sysconf API in their toolchain files.
|
|
check_c_source_compiles("
|
|
#include <unistd.h>
|
|
int main() {
|
|
sysconf(_SC_NPROCESSORS_ONLN);
|
|
}" HAVE_SYSCONF)
|
|
|
|
if (HAVE_SYSCONF)
|
|
list(APPEND AWS_C_DEFINES_PRIVATE -DHAVE_SYSCONF)
|
|
endif()
|
|
|
|
list(APPEND AWS_C_DEFINES_PRIVATE $<$<CONFIG:Debug>:DEBUG_BUILD>)
|
|
|
|
if ((NOT SET_PROPERTIES_NO_LTO) AND AWS_ENABLE_LTO)
|
|
# enable except in Debug builds
|
|
set(_ENABLE_LTO_EXPR $<NOT:$<CONFIG:Debug>>)
|
|
|
|
# try to check whether compiler supports LTO/IPO
|
|
include(CheckIPOSupported)
|
|
check_ipo_supported(RESULT ipo_supported)
|
|
if (ipo_supported)
|
|
message(STATUS "Enabling IPO/LTO for Release builds")
|
|
else()
|
|
message(STATUS "AWS_ENABLE_LTO is enabled, but cmake/compiler does not support it, disabling")
|
|
set(_ENABLE_LTO_EXPR OFF)
|
|
endif()
|
|
else()
|
|
set(_ENABLE_LTO_EXPR OFF)
|
|
endif()
|
|
|
|
if(AWS_ENABLE_TRACING)
|
|
target_link_libraries(${target} PRIVATE ittnotify)
|
|
else()
|
|
# Disable intel notify api if tracing is not enabled
|
|
list(APPEND AWS_C_DEFINES_PRIVATE -DINTEL_NO_ITTNOTIFY_API)
|
|
endif()
|
|
target_compile_options(${target} PRIVATE ${AWS_C_FLAGS})
|
|
target_compile_definitions(${target} PRIVATE ${AWS_C_DEFINES_PRIVATE} PUBLIC ${AWS_C_DEFINES_PUBLIC})
|
|
set_target_properties(${target} PROPERTIES LINKER_LANGUAGE C C_STANDARD 99 C_STANDARD_REQUIRED ON)
|
|
set_target_properties(${target} PROPERTIES INTERPROCEDURAL_OPTIMIZATION ${_ENABLE_LTO_EXPR}>)
|
|
|
|
# Don't hide symbols in Debug builds.
|
|
# We do this so that backtraces are more likely to show function names.
|
|
# We mostly use backtraces to diagnose memory leaks.
|
|
if (NOT CMAKE_BUILD_TYPE STREQUAL "Debug")
|
|
# And dont hide symbols on anything pre GCC 5.0 (Visibility support was not great on older compilers and some libraries didnt annotate visibility -
|
|
# looking at you jni, which does not annotate on gcc less than 4.2. Mixing no annotation and hidden symbols leads to unexpected failures.).
|
|
if (NOT (CMAKE_C_COMPILER_ID STREQUAL "GNU" AND CMAKE_C_COMPILER_VERSION VERSION_LESS "5.0"))
|
|
set_target_properties(${target} PROPERTIES C_VISIBILITY_PRESET hidden CXX_VISIBILITY_PRESET hidden VISIBILITY_INLINES_HIDDEN ON)
|
|
endif ()
|
|
endif ()
|
|
endfunction()
|