diff --git a/AWSCRTAndroidTestRunner/app/src/main/cpp/CMakeLists.txt b/AWSCRTAndroidTestRunner/app/src/main/cpp/CMakeLists.txt index a5e57e30d..9a91baba4 100644 --- a/AWSCRTAndroidTestRunner/app/src/main/cpp/CMakeLists.txt +++ b/AWSCRTAndroidTestRunner/app/src/main/cpp/CMakeLists.txt @@ -3,7 +3,7 @@ # Sets the minimum version of CMake required to build the native library. -cmake_minimum_required(VERSION 3.4.1) +cmake_minimum_required(VERSION 3.9) # AWS lib set(path_to_common "${CMAKE_CURRENT_LIST_DIR}/../../../../..") diff --git a/CMakeLists.txt b/CMakeLists.txt index d7cedeef9..6d14b0241 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,17 +1,15 @@ # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. # SPDX-License-Identifier: Apache-2.0. -cmake_minimum_required(VERSION 3.0) +# As of October 2024, we picked 3.9 as our version because internally we still support RHEL5 and AL2012, and CMake 3.9 +# was the latest version available on those platforms. +cmake_minimum_required(VERSION 3.9) option(ALLOW_CROSS_COMPILED_TESTS "Allow tests to be compiled via cross compile, for use with qemu" OFF) project(aws-c-common LANGUAGES C VERSION 0.1.0) message(STATUS "CMake ${CMAKE_VERSION}") -if (POLICY CMP0069) - cmake_policy(SET CMP0069 NEW) # Enable LTO/IPO if available in the compiler, see AwsCFlags -endif() - if (POLICY CMP0077) cmake_policy(SET CMP0077 OLD) # Enable options to get their values from normal variables endif() @@ -189,7 +187,6 @@ file(GLOB COMMON_SRC ${AWS_COMMON_EXTERNAL_SRC} ) - add_library(${PROJECT_NAME} ${COMMON_SRC}) aws_set_common_properties(${PROJECT_NAME} NO_WEXTRA) aws_prepare_symbol_visibility_args(${PROJECT_NAME} "AWS_COMMON") diff --git a/cmake/AwsCFlags.cmake b/cmake/AwsCFlags.cmake index 470f6db18..18ebb712c 100644 --- a/cmake/AwsCFlags.cmake +++ b/cmake/AwsCFlags.cmake @@ -4,7 +4,6 @@ include(CheckCCompilerFlag) include(CheckIncludeFile) include(CheckSymbolExists) -include(CMakeParseArguments) # needed for CMake v3.4 and lower 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) @@ -173,6 +172,7 @@ function(aws_set_common_properties target) set_property(TARGET ${target} APPEND_STRING PROPERTY LINK_FLAGS " -Wl,--exclude-libs,libcrypto.a") endif() + endif() check_include_file(stdint.h HAS_STDINT) @@ -230,30 +230,18 @@ function(aws_set_common_properties target) set(_ENABLE_LTO_EXPR $>) # try to check whether compiler supports LTO/IPO - if (POLICY CMP0069) - cmake_policy(SET CMP0069 NEW) - include(CheckIPOSupported OPTIONAL RESULT_VARIABLE ipo_check_exists) - if (ipo_check_exists) - 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() - endif() + 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(BUILD_SHARED_LIBS) - if (NOT MSVC) - # this should only be set when building shared libs. - list(APPEND AWS_C_FLAGS "-fvisibility=hidden") - endif() - endif() - if(AWS_ENABLE_TRACING) target_link_libraries(${target} PRIVATE ittnotify) else() @@ -264,4 +252,11 @@ function(aws_set_common_properties target) 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") + set_target_properties(${target} PROPERTIES C_VISIBILITY_PRESET hidden CXX_VISIBILITY_PRESET hidden VISIBILITY_INLINES_HIDDEN ON) + endif () endfunction() diff --git a/cmake/AwsTestHarness.cmake b/cmake/AwsTestHarness.cmake index 484b66635..a63ad61a7 100644 --- a/cmake/AwsTestHarness.cmake +++ b/cmake/AwsTestHarness.cmake @@ -39,9 +39,9 @@ function(generate_test_driver driver_exe_name) add_executable(${driver_exe_name} ${CMAKE_CURRENT_BINARY_DIR}/test_runner.c ${TESTS}) aws_set_common_properties(${driver_exe_name} NO_WEXTRA NO_PEDANTIC) - # Some versions of CMake (3.9-3.11) generate a test_runner.c file with - # a strncpy() call that triggers the "stringop-overflow" warning in GCC 8.1+ - # This warning doesn't exist until GCC 7 though, so test for it before disabling. + # Some versions of CMake (3.9-3.11) generate a test_runner.c file with + # a strncpy() call that triggers the "stringop-overflow" warning in GCC 8.1+ + # This warning doesn't exist until GCC 7 though, so test for it before disabling. if (NOT MSVC) check_c_compiler_flag(-Wno-stringop-overflow HAS_WNO_STRINGOP_OVERFLOW) if (HAS_WNO_STRINGOP_OVERFLOW) @@ -57,6 +57,9 @@ function(generate_test_driver driver_exe_name) target_compile_definitions(${driver_exe_name} PRIVATE AWS_UNSTABLE_TESTING_API=1) target_include_directories(${driver_exe_name} PRIVATE ${CMAKE_CURRENT_LIST_DIR}) + # Export symbols so that backtraces are more likely to show function names. + set_target_properties(${driver_exe_name} PROPERTIES ENABLE_EXPORTS ON) + foreach(name IN LISTS TEST_CASES) add_test(${name} ${driver_exe_name} "${name}") set_tests_properties("${name}" PROPERTIES SKIP_RETURN_CODE ${SKIP_RETURN_CODE_VALUE}) diff --git a/tests/memtrace_test.c b/tests/memtrace_test.c index b3be1b7e9..c161752b8 100644 --- a/tests/memtrace_test.c +++ b/tests/memtrace_test.c @@ -101,7 +101,7 @@ static int s_test_memtrace_stacks(struct aws_allocator *allocator, void *ctx) { /* only bother to run this test if the platform can do a backtrace */ void *probe_stack[1]; if (!aws_backtrace(probe_stack, 1)) { - return 0; + return AWS_OP_SKIP; } test_logger_init(&s_test_logger, allocator, AWS_LL_TRACE, 0); @@ -146,27 +146,26 @@ static int s_test_memtrace_stacks(struct aws_allocator *allocator, void *ctx) { /* if this is not a debug build, there may not be symbols, so the test cannot * verify if a best effort was made */ #if defined(DEBUG_BUILD) - /* fprintf(stderr, "%s\n", test_logger->log_buffer.buffer); */ + fprintf(stderr, "%s\n", test_logger->log_buffer.buffer); char s_alloc_1_addr[32]; char s_alloc_2_addr[32]; char s_alloc_3_addr[32]; char s_alloc_4_addr[32]; # if defined(_MSC_VER) -# pragma warning(push) # pragma warning(disable : 4054) /* type cast function pointer to data pointer */ +# endif + snprintf(s_alloc_1_addr, AWS_ARRAY_SIZE(s_alloc_1_addr), "0x%tx", (uintptr_t)(void *)s_alloc_1); snprintf(s_alloc_2_addr, AWS_ARRAY_SIZE(s_alloc_2_addr), "0x%tx", (uintptr_t)(void *)s_alloc_2); snprintf(s_alloc_3_addr, AWS_ARRAY_SIZE(s_alloc_3_addr), "0x%tx", (uintptr_t)(void *)s_alloc_3); snprintf(s_alloc_4_addr, AWS_ARRAY_SIZE(s_alloc_4_addr), "0x%tx", (uintptr_t)(void *)s_alloc_4); -# pragma warning(pop) -# endif /* defined(_MSC_VER) */ const char *log_buffer = (const char *)test_logger->log_buffer.buffer; ASSERT_TRUE(strstr(log_buffer, "s_alloc_1") || strstr(log_buffer, s_alloc_1_addr)); ASSERT_TRUE(strstr(log_buffer, "s_alloc_2") || strstr(log_buffer, s_alloc_2_addr)); ASSERT_TRUE(strstr(log_buffer, "s_alloc_3") || strstr(log_buffer, s_alloc_3_addr)); ASSERT_TRUE(strstr(log_buffer, "s_alloc_4") || strstr(log_buffer, s_alloc_4_addr)); -#endif +#endif /* DEBUG_BUILD */ /* reset log */ aws_byte_buf_reset(&test_logger->log_buffer, true);