diff --git a/CMake/AbseilConfigureCopts.cmake b/CMake/AbseilConfigureCopts.cmake new file mode 100644 index 000000000..96e0390b9 --- /dev/null +++ b/CMake/AbseilConfigureCopts.cmake @@ -0,0 +1,145 @@ +# Abseil-specific compiler flags. See absl/copts.bzl for description. +# DO NOT CHANGE THIS FILE WITHOUT THE CORRESPONDING CHANGE TO absl/copts.bzl + +list(APPEND GCC_FLAGS + -Wall + -Wextra + -Wcast-qual + -Wconversion-null + -Wmissing-declarations + -Woverlength-strings + -Wpointer-arith + -Wunused-local-typedefs + -Wunused-result + -Wvarargs + -Wwrite-strings + -Wno-sign-compare +) + +list(APPEND GCC_TEST_FLAGS + -Wno-conversion-null + -Wno-missing-declarations + -Wno-sign-compare + -Wno-unused-function + -Wno-unused-parameter + -Wno-unused-private-field +) + +list(APPEND LLVM_FLAGS + -Wall + -Wextra + -Weverything + -Wno-c++98-compat-pedantic + -Wno-conversion + -Wno-covered-switch-default + -Wno-deprecated + -Wno-disabled-macro-expansion + -Wno-double-promotion + -Wno-comma + -Wno-extra-semi + -Wno-packed + -Wno-padded + -Wno-sign-compare + -Wno-float-conversion + -Wno-float-equal + -Wno-format-nonliteral + -Wno-gcc-compat + -Wno-global-constructors + -Wno-exit-time-destructors + -Wno-nested-anon-types + -Wno-non-modular-include-in-module + -Wno-old-style-cast + -Wno-range-loop-analysis + -Wno-reserved-id-macro + -Wno-shorten-64-to-32 + -Wno-switch-enum + -Wno-thread-safety-negative + -Wno-undef + -Wno-unknown-warning-option + -Wno-unreachable-code + -Wno-unused-macros + -Wno-weak-vtables + -Wbitfield-enum-conversion + -Wbool-conversion + -Wconstant-conversion + -Wenum-conversion + -Wint-conversion + -Wliteral-conversion + -Wnon-literal-null-conversion + -Wnull-conversion + -Wobjc-literal-conversion + -Wno-sign-conversion + -Wstring-conversion +) + +list(APPEND LLVM_TEST_FLAGS + -Wno-c99-extensions + -Wno-missing-noreturn + -Wno-missing-prototypes + -Wno-missing-variable-declarations + -Wno-null-conversion + -Wno-shadow + -Wno-shift-sign-overflow + -Wno-sign-compare + -Wno-unused-function + -Wno-unused-member-function + -Wno-unused-parameter + -Wno-unused-private-field + -Wno-unused-template + -Wno-used-but-marked-unused + -Wno-zero-as-null-pointer-constant + -Wno-gnu-zero-variadic-macro-arguments +) + +list(APPEND MSVC_FLAGS + /W3 + /wd4005 + /wd4018 + /wd4068 + /wd4180 + /wd4244 + /wd4267 + /wd4800 + /DNOMINMAX + /DWIN32_LEAN_AND_MEAN + /D_CRT_SECURE_NO_WARNINGS + /D_SCL_SECURE_NO_WARNINGS + /D_ENABLE_EXTENDED_ALIGNED_STORAGE +) + +list(APPEND MSVC_TEST_FLAGS + /wd4101 + /wd4503 +) + +if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") + set(ABSL_DEFAULT_COPTS "${GCC_FLAGS}") + set(ABSL_TEST_COPTS "${GCC_FLAGS};${GCC_TEST_FLAGS}") + set(ABSL_EXCEPTIONS_FLAG "-fexceptions") +elseif("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang") + # MATCHES so we get both Clang and AppleClang + set(ABSL_DEFAULT_COPTS "${LLVM_FLAGS}") + set(ABSL_TEST_COPTS "${LLVM_FLAGS};${LLVM_TEST_FLAGS}") + set(ABSL_EXCEPTIONS_FLAG "-fexceptions") +elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC") + set(ABSL_DEFAULT_COPTS "${MSVC_FLAGS}") + set(ABSL_TEST_COPTS "${MSVC_FLAGS};${MSVC_TEST_FLAGS}") + set(ABSL_EXCEPTIONS_FLAG "/U_HAS_EXCEPTIONS;/D_HAS_EXCEPTIONS=1;/EHsc") +else() + message(WARNING "Unknown compiler: ${CMAKE_CXX_COMPILER}. Building with no default flags") + set(ABSL_DEFAULT_COPTS "") + set(ABSL_TEST_COPTS "") + set(ABSL_EXCEPTIONS_FLAG "") +endif() + +# This flag is used internally for Bazel builds and is kept here for consistency +set(ABSL_EXCEPTIONS_FLAG_LINKOPTS "") + +if("${CMAKE_CXX_STANDARD}" EQUAL 98) + message(FATAL_ERROR "Abseil requires at least C++11") +elseif(NOT "${CMAKE_CXX_STANDARD}") + message(STATUS "No CMAKE_CXX_STANDARD set, assuming 11") + set(ABSL_CXX_STANDARD 11) +else() + set(ABSL_CXX_STANDARD "${CMAKE_CXX_STANDARD}") +endif() diff --git a/CMake/AbseilHelpers.cmake b/CMake/AbseilHelpers.cmake index cc606ccbd..5402bf510 100644 --- a/CMake/AbseilHelpers.cmake +++ b/CMake/AbseilHelpers.cmake @@ -15,6 +15,7 @@ # include(CMakeParseArguments) +include(AbseilConfigureCopts) # The IDE folder for Abseil that will be used if Abseil is included in a CMake # project that sets @@ -48,7 +49,11 @@ function(absl_library) add_library(${_NAME} STATIC ${ABSL_LIB_SOURCES}) - target_compile_options(${_NAME} PRIVATE ${ABSL_LIB_PRIVATE_COMPILE_FLAGS}) + target_compile_options(${_NAME} + PRIVATE + ${ABSL_LIB_PRIVATE_COMPILE_FLAGS} + ${ABSL_DEFAULT_COPTS} + ) target_link_libraries(${_NAME} PUBLIC ${ABSL_LIB_PUBLIC_LIBRARIES}) target_include_directories(${_NAME} PUBLIC ${ABSL_COMMON_INCLUDE_DIRS} ${ABSL_LIB_PUBLIC_INCLUDE_DIRS} @@ -57,6 +62,9 @@ function(absl_library) # Add all Abseil targets to a a folder in the IDE for organization. set_property(TARGET ${_NAME} PROPERTY FOLDER ${ABSL_IDE_FOLDER}) + set_property(TARGET ${_NAME} PROPERTY CXX_STANDARD ${ABSL_CXX_STANDARD}) + set_property(TARGET ${_NAME} PROPERTY CXX_STANDARD_REQUIRED ON) + if(ABSL_LIB_EXPORT_NAME) add_library(absl::${ABSL_LIB_EXPORT_NAME} ALIAS ${_NAME}) endif() @@ -154,6 +162,10 @@ function(absl_cc_library) else() set_property(TARGET ${_NAME} PROPERTY FOLDER ${ABSL_IDE_FOLDER}/internal) endif() + + # INTERFACE libraries can't have the CXX_STANDARD property set + set_property(TARGET ${_NAME} PROPERTY CXX_STANDARD ${ABSL_CXX_STANDARD}) + set_property(TARGET ${_NAME} PROPERTY CXX_STANDARD_REQUIRED ON) else() # Generating header-only library add_library(${_NAME} INTERFACE) @@ -164,6 +176,7 @@ function(absl_cc_library) ) target_compile_definitions(${_NAME} INTERFACE ${ABSL_CC_LIB_DEFINES}) endif() + add_library(absl::${ABSL_CC_LIB_NAME} ALIAS ${_NAME}) endif() endfunction() @@ -237,6 +250,9 @@ function(absl_cc_test) # Add all Abseil targets to a a folder in the IDE for organization. set_property(TARGET ${_NAME} PROPERTY FOLDER ${ABSL_IDE_FOLDER}/test) + set_property(TARGET ${_NAME} PROPERTY CXX_STANDARD ${ABSL_CXX_STANDARD}) + set_property(TARGET ${_NAME} PROPERTY CXX_STANDARD_REQUIRED ON) + add_test(NAME ${_NAME} COMMAND ${_NAME}) endfunction() @@ -279,6 +295,9 @@ function(absl_header_library) # Add all Abseil targets to a a folder in the IDE for organization. set_property(TARGET ${_NAME} PROPERTY FOLDER ${ABSL_IDE_FOLDER}) + set_property(TARGET ${_NAME} PROPERTY CXX_STANDARD ${ABSL_CXX_STANDARD}) + set_property(TARGET ${_NAME} PROPERTY CXX_STANDARD_REQUIRED ON) + if(ABSL_HO_LIB_EXPORT_NAME) add_library(absl::${ABSL_HO_LIB_EXPORT_NAME} ALIAS ${_NAME}) endif() @@ -312,22 +331,29 @@ function(absl_test) if(ABSL_RUN_TESTS) - set(_NAME ${ABSL_TEST_TARGET}) + set(_NAME "absl_${ABSL_TEST_TARGET}") string(TOUPPER ${_NAME} _UPPER_NAME) - add_executable(${_NAME}_bin ${ABSL_TEST_SOURCES}) + add_executable(${_NAME} ${ABSL_TEST_SOURCES}) - target_compile_options(${_NAME}_bin PRIVATE ${ABSL_TEST_PRIVATE_COMPILE_FLAGS}) - target_link_libraries(${_NAME}_bin PUBLIC ${ABSL_TEST_PUBLIC_LIBRARIES} ${ABSL_TEST_COMMON_LIBRARIES}) - target_include_directories(${_NAME}_bin + target_compile_options(${_NAME} + PRIVATE + ${ABSL_TEST_PRIVATE_COMPILE_FLAGS} + ${ABSL_TEST_COPTS} + ) + target_link_libraries(${_NAME} PUBLIC ${ABSL_TEST_PUBLIC_LIBRARIES} ${ABSL_TEST_COMMON_LIBRARIES}) + target_include_directories(${_NAME} PUBLIC ${ABSL_COMMON_INCLUDE_DIRS} ${ABSL_TEST_PUBLIC_INCLUDE_DIRS} PRIVATE ${GMOCK_INCLUDE_DIRS} ${GTEST_INCLUDE_DIRS} ) # Add all Abseil targets to a a folder in the IDE for organization. - set_property(TARGET ${_NAME}_bin PROPERTY FOLDER ${ABSL_IDE_FOLDER}) + set_property(TARGET ${_NAME} PROPERTY FOLDER ${ABSL_IDE_FOLDER}) - add_test(${_NAME} ${_NAME}_bin) + set_property(TARGET ${_NAME} PROPERTY CXX_STANDARD ${ABSL_CXX_STANDARD}) + set_property(TARGET ${_NAME} PROPERTY CXX_STANDARD_REQUIRED ON) + + add_test(NAME ${_NAME} COMMAND ${_NAME}) endif(ABSL_RUN_TESTS) endfunction() diff --git a/CMakeLists.txt b/CMakeLists.txt index ea45dcaaf..77ae631d0 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -19,7 +19,7 @@ cmake_minimum_required(VERSION 3.1) project(absl) -list(APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/CMake) +list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR}/CMake) include(GNUInstallDirs) include(AbseilHelpers) diff --git a/absl/algorithm/CMakeLists.txt b/absl/algorithm/CMakeLists.txt index 6608f184c..87a165c06 100644 --- a/absl/algorithm/CMakeLists.txt +++ b/absl/algorithm/CMakeLists.txt @@ -19,6 +19,8 @@ absl_cc_library( algorithm HDRS "algorithm.h" + COPTS + ${ABSL_DEFAULT_COPTS} PUBLIC ) @@ -37,6 +39,8 @@ absl_cc_library( algorithm_container HDRS "container.h" + COPTS + ${ABSL_DEFAULT_COPTS} DEPS absl::algorithm absl::core_headers diff --git a/absl/base/CMakeLists.txt b/absl/base/CMakeLists.txt index 04dbf39e1..212dd0836 100644 --- a/absl/base/CMakeLists.txt +++ b/absl/base/CMakeLists.txt @@ -36,6 +36,8 @@ absl_cc_library( HDRS "config.h" "policy_checks.h" + COPTS + ${ABSL_DEFAULT_COPTS} PUBLIC ) @@ -46,6 +48,8 @@ absl_cc_library( "dynamic_annotations.h" SRCS "dynamic_annotations.cc" + COPTS + ${ABSL_DEFAULT_COPTS} DEFINES "__CLANG_SUPPORT_DYN_ANNOTATION__" PUBLIC @@ -60,6 +64,8 @@ absl_cc_library( "optimization.h" "port.h" "thread_annotations.h" + COPTS + ${ABSL_DEFAULT_COPTS} DEPS absl::config PUBLIC @@ -73,6 +79,8 @@ absl_cc_library( "internal/low_level_alloc.h" SRCS "internal/low_level_alloc.cc" + COPTS + ${ABSL_DEFAULT_COPTS} DEPS absl::base absl::config @@ -89,6 +97,8 @@ absl_cc_library( "internal/identity.h" "internal/inline_variable.h" "internal/invoke.h" + COPTS + ${ABSL_DEFAULT_COPTS} ) absl_cc_library( @@ -115,6 +125,8 @@ absl_cc_library( "internal/sysinfo.cc" "internal/thread_identity.cc" "internal/unscaledcycleclock.cc" + COPTS + ${ABSL_DEFAULT_COPTS} DEPS absl::base_internal absl::config @@ -132,6 +144,7 @@ absl_cc_library( SRCS "internal/throw_delegate.cc" COPTS + ${ABSL_DEFAULT_COPTS} ${ABSL_EXCEPTIONS_FLAG} DEPS absl::base @@ -142,6 +155,8 @@ absl_cc_library( exception_testing HDRS "internal/exception_testing.h" + COPTS + ${ABSL_DEFAULT_COPTS} DEPS absl::config gtest @@ -153,6 +168,8 @@ absl_cc_library( pretty_function HDRS "internal/pretty_function.h" + COPTS + ${ABSL_DEFAULT_COPTS} ) absl_cc_library( @@ -163,6 +180,7 @@ absl_cc_library( SRCS "internal/exception_safety_testing.cc" COPTS + ${ABSL_DEFAULT_COPTS} ${ABSL_EXCEPTIONS_FLAG} DEPS absl::base @@ -263,7 +281,7 @@ absl_cc_library( absl::spinlock_wait absl::synchronization gtest - PUBLIC + TESTONLY ) # On bazel BUILD this target use "alwayslink = 1" which is not implemented here @@ -286,6 +304,8 @@ absl_cc_library( HDRS "internal/endian.h" "internal/unaligned_access.h" + COPTS + ${ABSL_DEFAULT_COPTS} DEPS absl::config absl::core_headers @@ -377,6 +397,8 @@ absl_cc_library( bits HDRS "internal/bits.h" + COPTS + ${ABSL_DEFAULT_COPTS} DEPS absl::core_headers ) diff --git a/absl/container/CMakeLists.txt b/absl/container/CMakeLists.txt index 72113e195..7cddd84bd 100644 --- a/absl/container/CMakeLists.txt +++ b/absl/container/CMakeLists.txt @@ -14,164 +14,674 @@ # limitations under the License. # - -list(APPEND CONTAINER_PUBLIC_HEADERS - "fixed_array.h" - "flat_hash_map.h" - "flat_hash_set.h" - "inlined_vector.h" - "node_hash_map.h" - "node_hash_set.h" -) - - -list(APPEND CONTAINER_INTERNAL_HEADERS - "internal/compressed_tuple.h" - "internal/container_memory.h" - "internal/hash_function_defaults.h" - "internal/hash_generator_testing.h" - "internal/hash_policy_testing.h" - "internal/hash_policy_traits.h" - "internal/hashtable_debug.h" - "internal/layout.h" - "internal/node_hash_policy.h" - "internal/raw_hash_map.h" - "internal/raw_hash_set.h" - "internal/test_instance_tracker.h" - "internal/tracked.h" - "internal/unordered_map_constructor_test.h" - "internal/unordered_map_lookup_test.h" - "internal/unordered_map_modifiers_test.h" - "internal/unordered_set_constructor_test.h" - "internal/unordered_set_lookup_test.h" - "internal/unordered_set_modifiers_test.h" -) - - -absl_library( - TARGET - absl_container - SOURCES - "internal/raw_hash_set.cc" - EXPORT_NAME +# This is deprecated and will be removed in the future. It also doesn't do +# anything anyways. Prefer to use the library associated with the API you are +# using. +absl_cc_library( + NAME container + SRCS + "internal/raw_hash_set.cc" + COPTS + ${ABSL_DEFAULT_COPTS} + PUBLIC ) -# -## TESTS -# - -list(APPEND TEST_INSTANCE_TRACKER_LIB_SRC - "internal/test_instance_tracker.cc" - ${CONTAINER_PUBLIC_HEADERS} - ${CONTAINER_INTERNAL_HEADERS} +absl_cc_library( + NAME + compressed_tuple + SRCS + "internal/compressed_tuple.h" + DEPS + absl::utility + PUBLIC ) - -absl_library( - TARGET - test_instance_tracker_lib - SOURCES - ${TEST_INSTANCE_TRACKER_LIB_SRC} - PUBLIC_LIBRARIES - absl::container +absl_cc_test( + NAME + compressed_tuple_test + SRCS + "internal/compressed_tuple_test.cc" + DEPS + absl::compressed_tuple + gmock_main ) +absl_cc_library( + NAME + fixed_array + HDRS + "fixed_array.h" + COPTS + ${ABSL_DEFAULT_COPTS} + DEPS + absl::compressed_tuple + absl::algorithm + absl::core_headers + absl::dynamic_annotations + absl::throw_delegate + absl::memory + PUBLIC +) - -# test fixed_array_test -set(FIXED_ARRAY_TEST_SRC "fixed_array_test.cc") -set(FIXED_ARRAY_TEST_PUBLIC_LIBRARIES absl::base absl_internal_throw_delegate test_instance_tracker_lib) - -absl_test( - TARGET +absl_cc_test( + NAME fixed_array_test - SOURCES - ${FIXED_ARRAY_TEST_SRC} - PUBLIC_LIBRARIES - ${FIXED_ARRAY_TEST_PUBLIC_LIBRARIES} - PRIVATE_COMPILE_FLAGS + SRCS + "fixed_array_test.cc" + COPTS ${ABSL_EXCEPTIONS_FLAG} + LINKOPTS + ${ABSL_EXCEPTIONS_FLAG_LINKOPTS} + DEPS + absl::fixed_array + absl::exception_testing + absl::hash_testing + absl::memory + gmock_main ) - - -absl_test( - TARGET +absl_cc_test( + NAME fixed_array_test_noexceptions - SOURCES - ${FIXED_ARRAY_TEST_SRC} - PUBLIC_LIBRARIES - ${FIXED_ARRAY_TEST_PUBLIC_LIBRARIES} + SRCS + "fixed_array_test.cc" + DEPS + absl::fixed_array + absl::exception_testing + absl::hash_testing + absl::memory + gmock_main ) - -# test fixed_array_exception_safety_test -set(FIXED_ARRAY_EXCEPTION_SAFETY_TEST_SRC "fixed_array_exception_safety_test.cc") -set(FIXED_ARRAY_EXCEPTION_SAFETY_TEST_PUBLIC_LIBRARIES - absl::container - absl_internal_exception_safety_testing -) - -absl_test( - TARGET +absl_cc_test( + NAME fixed_array_exception_safety_test - SOURCES - ${FIXED_ARRAY_EXCEPTION_SAFETY_TEST_SRC} - PUBLIC_LIBRARIES - ${FIXED_ARRAY_EXCEPTION_SAFETY_TEST_PUBLIC_LIBRARIES} - PRIVATE_COMPILE_FLAGS + SRCS + "fixed_array_exception_safety_test.cc" + COPTS ${ABSL_EXCEPTIONS_FLAG} + LINKOPTS + ${ABSL_EXCEPTIONS_FLAG_LINKOPTS} + DEPS + absl::fixed_array + absl::exception_safety_testing + gmock_main ) +absl_cc_library( + NAME + inlined_vector + HDRS + "inlined_vector.h" + COPTS + ${ABSL_DEFAULT_COPTS} + DEPS + absl::algorithm + absl::core_headers + absl::throw_delegate + absl::memory + PUBLIC +) -# test inlined_vector_test -set(INLINED_VECTOR_TEST_SRC "inlined_vector_test.cc") -set(INLINED_VECTOR_TEST_PUBLIC_LIBRARIES absl::base absl_internal_throw_delegate test_instance_tracker_lib) - -absl_test( - TARGET +absl_cc_test( + NAME inlined_vector_test - SOURCES - ${INLINED_VECTOR_TEST_SRC} - PUBLIC_LIBRARIES - ${INLINED_VECTOR_TEST_PUBLIC_LIBRARIES} -) - -absl_test( - TARGET - inlined_vector_test_noexceptions - SOURCES - ${INLINED_VECTOR_TEST_SRC} - PUBLIC_LIBRARIES - ${INLINED_VECTOR_TEST_PUBLIC_LIBRARIES} - PRIVATE_COMPILE_FLAGS - ${ABSL_NOEXCEPTION_CXXFLAGS} -) - - -# test test_instance_tracker_test -set(TEST_INSTANCE_TRACKER_TEST_SRC "internal/test_instance_tracker_test.cc") -set(TEST_INSTANCE_TRACKER_TEST_PUBLIC_LIBRARIES absl::base absl_internal_throw_delegate test_instance_tracker_lib) - - -absl_test( - TARGET - test_instance_tracker_test - SOURCES - ${TEST_INSTANCE_TRACKER_TEST_SRC} - PUBLIC_LIBRARIES - ${TEST_INSTANCE_TRACKER_TEST_PUBLIC_LIBRARIES} -) - -absl_test( - TARGET - raw_hash_set_test - SOURCES - "internal/raw_hash_set_test.cc" - PUBLIC_LIBRARIES + SRCS + "inlined_vector_test.cc" + COPTS + ${ABSL_EXCEPTIONS_FLAG} + LINKOPTS + ${ABSL_EXCEPTIONS_FLAG_LINKOPTS} + DEPS + absl::inlined_vector + absl::test_instance_tracker absl::base - absl::hash - absl_internal_throw_delegate - test_instance_tracker_lib + absl::core_headers + absl::exception_testing + absl::hash_testing + absl::memory + absl::strings + gmock_main +) + +absl_cc_test( + NAME + inlined_vector_test_noexceptions + SRCS + "inlined_vector_test.cc" + DEPS + absl::inlined_vector + absl::test_instance_tracker + absl::base + absl::core_headers + absl::exception_testing + absl::hash_testing + absl::memory + absl::strings + gmock_main +) + +absl_cc_library( + NAME + test_instance_tracker + HDRS + "internal/test_instance_tracker.h" + SRCS + "internal/test_instance_tracker.cc" + COPTS + ${ABSL_DEFAULT_COPTS} + TESTONLY +) + +absl_cc_test( + NAME + test_instance_tracker_test + SRCS + "internal/test_instance_tracker_test.cc" + DEPS + absl::test_instance_tracker + gmock_main +) + +absl_cc_library( + NAME + flat_hash_map + HDRS + "flat_hash_map.h" + COPTS + ${ABSL_DEFAULT_COPTS} + DEPS + absl::container_memory + absl::hash_function_defaults + absl::raw_hash_map + absl::algorithm_container + absl::memory + PUBLIC +) + +absl_cc_test( + NAME + flat_hash_map_test + SRCS + "flat_hash_map_test.cc" + COPTS + "-DUNORDERED_MAP_CXX17" + DEPS + absl::flat_hash_map + absl::hash_generator_testing + absl::unordered_map_constructor_test + absl::unordered_map_lookup_test + absl::unordered_map_modifiers_test + absl::any + gmock_main +) + +absl_cc_library( + NAME + flat_hash_set + HDRS + "flat_hash_set.h" + COPTS + ${ABSL_DEFAULT_COPTS} + DEPS + absl::container_memory + absl::hash_function_defaults + absl::raw_hash_set + absl::algorithm_container + absl::core_headers + absl::memory + PUBLIC +) + +absl_cc_test( + NAME + flat_hash_set_test + SRCS + "flat_hash_set_test.cc" + COPTS + "-DUNORDERED_SET_CXX17" + DEPS + absl::flat_hash_set + absl::hash_generator_testing + absl::unordered_set_constructor_test + absl::unordered_set_lookup_test + absl::unordered_set_modifiers_test + absl::memory + absl::strings + gmock_main +) + +absl_cc_library( + NAME + node_hash_map + HDRS + "node_hash_map.h" + COPTS + ${ABSL_DEFAULT_COPTS} + DEPS + absl::container_memory + absl::hash_function_defaults + absl::node_hash_policy + absl::raw_hash_map + absl::algorithm_container + absl::memory + PUBLIC +) + +absl_cc_test( + NAME + node_hash_map_test + SRCS + "node_hash_map_test.cc" + COPTS + "-DUNORDERED_MAP_CXX17" + DEPS + absl::hash_generator_testing + absl::node_hash_map + absl::tracked + absl::unordered_map_constructor_test + absl::unordered_map_lookup_test + absl::unordered_map_modifiers_test + gmock_main +) + +absl_cc_library( + NAME + node_hash_set + HDRS + "node_hash_set.h" + COPTS + ${ABSL_DEFAULT_COPTS} + DEPS + absl::hash_function_defaults + absl::node_hash_policy + absl::raw_hash_set + absl::algorithm_container + absl::memory + PUBLIC +) + +absl_cc_test( + NAME + node_hash_set_test + SRCS + "node_hash_set_test.cc" + COPTS + "-DUNORDERED_SET_CXX17" + DEPS + absl::hash_generator_testing + absl::node_hash_set + absl::unordered_set_constructor_test + absl::unordered_set_lookup_test + absl::unordered_set_modifiers_test + gmock_main +) + +absl_cc_library( + NAME + container_memory + HDRS + "internal/container_memory.h" + COPTS + ${ABSL_DEFAULT_COPTS} + DEPS + absl::memory + absl::utility + PUBLIC +) + +absl_cc_test( + NAME + container_memory_test + SRCS + "internal/container_memory_test.cc" + DEPS + absl::container_memory + absl::strings + gmock_main +) + +absl_cc_library( + NAME + hash_function_defaults + HDRS + "internal/hash_function_defaults.h" + COPTS + ${ABSL_DEFAULT_COPTS} + DEPS + absl::config + absl::hash + absl::strings + PUBLIC +) + +absl_cc_test( + NAME + hash_function_defaults_test + SRCS + "internal/hash_function_defaults_test.cc" + DEPS + absl::hash_function_defaults + absl::hash + absl::strings + gmock_main +) + +absl_cc_library( + NAME + hash_generator_testing + HDRS + "internal/hash_generator_testing.h" + SRCS + "internal/hash_generator_testing.cc" + COPTS + ${ABSL_TEST_COPTS} + DEPS + absl::hash_policy_testing + absl::meta + absl::strings + TESTONLY +) + +absl_cc_library( + NAME + hash_policy_testing + HDRS + "internal/hash_policy_testing.h" + COPTS + ${ABSL_TEST_COPTS} + DEPS + absl::hash + absl::strings + TESTONLY +) + +absl_cc_test( + NAME + hash_policy_testing_test + SRCS + "internal/hash_policy_testing_test.cc" + DEPS + absl::hash_policy_testing + gmock_main +) + +absl_cc_library( + NAME + hash_policy_traits + HDRS + "internal/hash_policy_traits.h" + COPTS + ${ABSL_DEFAULT_COPTS} + DEPS + absl::meta + PUBLIC +) + +absl_cc_test( + NAME + hash_policy_traits_test + SRCS + "internal/hash_policy_traits_test.cc" + DEPS + absl::hash_policy_traits + gmock_main +) + +absl_cc_library( + NAME + hashtable_debug + HDRS + "internal/hashtable_debug.h" + COPTS + ${ABSL_DEFAULT_COPTS} + DEPS + absl::hashtable_debug_hooks +) + +absl_cc_library( + NAME + hashtable_debug_hooks + HDRS + "internal/hashtable_debug_hooks.h" + COPTS + ${ABSL_DEFAULT_COPTS} + PUBLIC +) + +absl_cc_library( + NAME + node_hash_policy + HDRS + "internal/node_hash_policy.h" + COPTS + ${ABSL_DEFAULT_COPTS} + PUBLIC +) + +absl_cc_test( + NAME + node_hash_policy_test + SRCS + "internal/node_hash_policy_test.cc" + DEPS + absl::hash_policy_traits + absl::node_hash_policy + gmock_main +) + +absl_cc_library( + NAME + raw_hash_map + HDRS + "internal/raw_hash_map.h" + COPTS + ${ABSL_DEFAULT_COPTS} + DEPS + absl::container_memory + absl::raw_hash_set + PUBLIC +) + +absl_cc_library( + NAME + raw_hash_set + HDRS + "internal/raw_hash_set.h" + SRCS + "internal/raw_hash_set.cc" + COPTS + ${ABSL_DEFAULT_COPTS} + DEPS + absl::compressed_tuple + absl::container_memory + absl::hash_policy_traits + absl::hashtable_debug_hooks + absl::layout + absl::bits + absl::config + absl::core_headers + absl::endian + absl::memory + absl::meta + absl::optional + absl::utility + PUBLIC +) + +absl_cc_test( + NAME + raw_hash_set_test + SRCS + "internal/raw_hash_set_test.cc" + DEPS + absl::container_memory + absl::hash_function_defaults + absl::hash_policy_testing + absl::hashtable_debug + absl::raw_hash_set + absl::base + absl::core_headers + absl::strings + gmock_main +) + +absl_cc_test( + NAME + raw_hash_set_allocator_test + SRCS + "internal/raw_hash_set_allocator_test.cc" + DEPS + absl::raw_hash_set + absl::tracked + absl::core_headers + gmock_main +) + +absl_cc_library( + NAME + layout + HDRS + "internal/layout.h" + COPTS + ${ABSL_DEFAULT_COPTS} + DEPS + absl::core_headers + absl::meta + absl::strings + absl::span + absl::utility + PUBLIC +) + +absl_cc_test( + NAME + layout_test + SRCS + "internal/layout_test.cc" + DEPS + absl::layout + absl::base + absl::core_headers + absl::span + gmock_main +) + +absl_cc_library( + NAME + tracked + HDRS + "internal/tracked.h" + COPTS + ${ABSL_TEST_COPTS} + TESTONLY +) + +absl_cc_library( + NAME + unordered_map_constructor_test + HDRS + "internal/unordered_map_constructor_test.h" + COPTS + ${ABSL_TEST_COPTS} + DEPS + absl::hash_generator_testing + absl::hash_policy_testing + gmock + TESTONLY +) + +absl_cc_library( + NAME + unordered_map_lookup_test + HDRS + "internal/unordered_map_lookup_test.h" + COPTS + ${ABSL_TEST_COPTS} + DEPS + absl::hash_generator_testing + absl::hash_policy_testing + gmock + TESTONLY +) + +absl_cc_library( + NAME + unordered_map_modifiers_test + HDRS + "internal/unordered_map_modifiers_test.h" + COPTS + ${ABSL_TEST_COPTS} + DEPS + absl::hash_generator_testing + absl::hash_policy_testing + gmock + TESTONLY +) + +absl_cc_library( + NAME + unordered_set_constructor_test + HDRS + "internal/unordered_set_constructor_test.h" + COPTS + ${ABSL_TEST_COPTS} + DEPS + absl::hash_generator_testing + absl::hash_policy_testing + gmock + TESTONLY +) + +absl_cc_library( + NAME + unordered_set_lookup_test + HDRS + "internal/unordered_set_lookup_test.h" + COPTS + ${ABSL_TEST_COPTS} + DEPS + absl::hash_generator_testing + absl::hash_policy_testing + gmock + TESTONLY +) + +absl_cc_library( + NAME + unordered_set_modifiers_test + HDRS + "internal/unordered_set_modifiers_test.h" + COPTS + ${ABSL_TEST_COPTS} + DEPS + absl::hash_generator_testing + absl::hash_policy_testing + gmock + TESTONLY +) + +absl_cc_test( + NAME + unordered_set_test + SRCS + "internal/unordered_set_test.cc" + DEPS + absl::unordered_set_constructor_test + absl::unordered_set_lookup_test + absl::unordered_set_modifiers_test + gmock_main +) + +absl_cc_test( + NAME + unordered_map_test + SRCS + "internal/unordered_map_test.cc" + DEPS + absl::unordered_map_constructor_test + absl::unordered_map_lookup_test + absl::unordered_map_modifiers_test + gmock_main ) diff --git a/absl/container/internal/hash_policy_testing.h b/absl/container/internal/hash_policy_testing.h index 38bbec77a..7fb819a74 100644 --- a/absl/container/internal/hash_policy_testing.h +++ b/absl/container/internal/hash_policy_testing.h @@ -169,7 +169,11 @@ auto keys(const Set& s) // take allocator arguments. This test is defined ad-hoc for the platforms // we care about (notably Crosstool 17) because libstdcxx's useless // versioning scheme precludes a more principled solution. -#if defined(__GLIBCXX__) && __GLIBCXX__ <= 20140425 +// From GCC-4.9 Changelog: (src: https://gcc.gnu.org/gcc-4.9/changes.html) +// "the unordered associative containers in and +// meet the allocator-aware container requirements;" +#if (defined(__GLIBCXX__) && __GLIBCXX__ <= 20140425 ) || \ +( __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 9 )) #define ABSL_UNORDERED_SUPPORTS_ALLOC_CTORS 0 #else #define ABSL_UNORDERED_SUPPORTS_ALLOC_CTORS 1 diff --git a/absl/container/internal/layout.h b/absl/container/internal/layout.h index 676c7d67e..a9c1244a4 100644 --- a/absl/container/internal/layout.h +++ b/absl/container/internal/layout.h @@ -232,13 +232,17 @@ struct SizeOf : NotAligned, std::integral_constant {}; template struct SizeOf> : std::integral_constant {}; +// Note: workaround for https://gcc.gnu.org/PR88115 template -struct AlignOf : NotAligned, std::integral_constant {}; +struct AlignOf : NotAligned { + static constexpr size_t value = alignof(T); +}; template -struct AlignOf> : std::integral_constant { +struct AlignOf> { static_assert(N % alignof(T) == 0, "Custom alignment can't be lower than the type's alignment"); + static constexpr size_t value = N; }; // Does `Ts...` contain `T`? @@ -290,7 +294,7 @@ std::string TypeName() { #ifdef ABSL_INTERNAL_HAS_CXA_DEMANGLE demangled = abi::__cxa_demangle(typeid(T).name(), nullptr, nullptr, &status); #endif - if (status == 0 && demangled != nullptr) { // Demangling succeeeded. + if (status == 0 && demangled != nullptr) { // Demangling succeeded. absl::StrAppend(&out, "<", demangled, ">"); free(demangled); } else { @@ -396,7 +400,7 @@ class LayoutImpl, absl::index_sequence, static_assert(N < NumOffsets, "Index out of bounds"); return adl_barrier::Align( Offset() + SizeOf>() * size_[N - 1], - ElementAlignment()); + ElementAlignment::value); } // Offset in bytes of the array with the specified element type. There must @@ -445,7 +449,7 @@ class LayoutImpl, absl::index_sequence, return Size()>(); } - // The number of elements of all arrays for which they are known. + // The number of elements of all arrays for which they are known. constexpr std::array Sizes() const { return {{Size()...}}; } @@ -610,7 +614,7 @@ class LayoutImpl, absl::index_sequence, #ifdef ADDRESS_SANITIZER PoisonPadding(p); // The `if` is an optimization. It doesn't affect the observable behaviour. - if (ElementAlignment() % ElementAlignment()) { + if (ElementAlignment::value % ElementAlignment::value) { size_t start = Offset() + SizeOf>() * size_[N - 1]; ASAN_POISON_MEMORY_REGION(p + start, Offset() - start); @@ -690,7 +694,7 @@ class Layout : public internal_layout::LayoutType { // // It's allowed to pass fewer array sizes than the number of arrays. E.g., // if all you need is to the offset of the second array, you only need to - // pass one argument -- the number of elements in the first arrays. + // pass one argument -- the number of elements in the first array. // // // int[3] followed by 4 bytes of padding and an unknown number of // // doubles. diff --git a/absl/container/internal/layout_test.cc b/absl/container/internal/layout_test.cc index f35157a3b..224f741a7 100644 --- a/absl/container/internal/layout_test.cc +++ b/absl/container/internal/layout_test.cc @@ -45,7 +45,17 @@ Expected Type(Actual val) { return val; } -using Int128 = int64_t[2]; +// Helper class to test different size and alignments. +struct alignas(8) Int128 { + uint64_t a, b; + friend bool operator==(Int128 lhs, Int128 rhs) { + return std::tie(lhs.a, lhs.b) == std::tie(rhs.a, rhs.b); + } + + static std::string Name() { + return internal_layout::adl_barrier::TypeName(); + } +}; // Properties of types that this test relies on. static_assert(sizeof(int8_t) == 1, ""); @@ -1361,12 +1371,6 @@ TEST(Layout, PoisonPadding) { } TEST(Layout, DebugString) { - const std::string int64_type = -#ifdef _MSC_VER - "__int64"; -#else // _MSC_VER - std::is_same::value ? "long long" : "long"; // NOLINT -#endif // _MSC_VER { constexpr auto x = Layout::Partial(); EXPECT_EQ("@0(1)", x.DebugString()); @@ -1384,24 +1388,24 @@ TEST(Layout, DebugString) { constexpr auto x = Layout::Partial(1, 2, 3); EXPECT_EQ( "@0(1)[1]; @4(4)[2]; @12(1)[3]; " - "@16<" + - int64_type + " [2]>(16)", + "@16" + + Int128::Name() + "(16)", x.DebugString()); } { constexpr auto x = Layout::Partial(1, 2, 3, 4); EXPECT_EQ( "@0(1)[1]; @4(4)[2]; @12(1)[3]; " - "@16<" + - int64_type + " [2]>(16)[4]", + "@16" + + Int128::Name() + "(16)[4]", x.DebugString()); } { constexpr Layout x(1, 2, 3, 4); EXPECT_EQ( "@0(1)[1]; @4(4)[2]; @12(1)[3]; " - "@16<" + - int64_type + " [2]>(16)[4]", + "@16" + + Int128::Name() + "(16)[4]", x.DebugString()); } } @@ -1528,8 +1532,7 @@ class CompactString { const char* c_str() const { // Equivalent to reinterpret_cast(p.get() + sizeof(size_t)). // The argument in Partial(1) specifies that we have size_t[1] in front of - // the - // characters. + // the characters. return L::Partial(1).Pointer(p_.get()); } diff --git a/absl/copts.bzl b/absl/copts.bzl index 49bb697d6..49c4c9e0b 100644 --- a/absl/copts.bzl +++ b/absl/copts.bzl @@ -3,6 +3,8 @@ Flags specified here must not impact ABI. Code compiled with and without these opts will be linked together, and in some cases headers compiled with and without these options will be part of the same program. + +DO NOT CHANGE THIS FILE WITHOUT CHANGING THE SAME FLAG IN absl/CMake/AbseilConfigureCopts.cmake!! """ GCC_FLAGS = [ "-Wall", diff --git a/absl/hash/CMakeLists.txt b/absl/hash/CMakeLists.txt index 474092f0f..a0d59b0bd 100644 --- a/absl/hash/CMakeLists.txt +++ b/absl/hash/CMakeLists.txt @@ -31,7 +31,7 @@ list(APPEND HASH_SRC ${HASH_INTERNAL_HEADERS} ) -set(HASH_PUBLIC_LIBRARIES absl::hash absl::container absl::strings absl::str_format absl::utility) +set(HASH_PUBLIC_LIBRARIES absl::hash absl::fixed_array absl::strings absl::str_format absl::utility) absl_library( TARGET @@ -48,9 +48,35 @@ absl_library( ## TESTS # +absl_cc_library( + NAME + hash_testing + HDRS + "hash_testing.h" + DEPS + absl::spy_hash_state + absl::meta + absl::strings + absl::variant + gmock + TESTONLY +) + +absl_cc_library( + NAME + spy_hash_state + HDRS + "internal/spy_hash_state.h" + DEPS + absl::hash + absl::strings + absl::str_format + TESTONLY +) + # testing support set(HASH_TEST_HEADERS hash_testing.h internal/spy_hash_state.h) -set(HASH_TEST_PUBLIC_LIBRARIES absl::hash absl::container absl::numeric absl::strings absl::str_format) +set(HASH_TEST_PUBLIC_LIBRARIES absl::hash absl::flat_hash_set absl::numeric absl::strings absl::str_format) # hash_test set(HASH_TEST_SRC "hash_test.cc" ${HASH_TEST_HEADERS}) diff --git a/absl/strings/CMakeLists.txt b/absl/strings/CMakeLists.txt index dbb6ae6a4..a6574c17a 100644 --- a/absl/strings/CMakeLists.txt +++ b/absl/strings/CMakeLists.txt @@ -113,7 +113,7 @@ absl_library( absl::strings absl::base absl::numeric - absl::container + absl::inlined_vector absl::span ) diff --git a/absl/time/BUILD.bazel b/absl/time/BUILD.bazel index 969ddd2e6..4d9c01c40 100644 --- a/absl/time/BUILD.bazel +++ b/absl/time/BUILD.bazel @@ -110,6 +110,7 @@ cc_test( ":test_util", ":time", "//absl/base", + "//absl/hash", "@com_github_google_benchmark//:benchmark_main", ], ) diff --git a/absl/time/civil_time_benchmark.cc b/absl/time/civil_time_benchmark.cc index 567c2a33b..f30f636dc 100644 --- a/absl/time/civil_time_benchmark.cc +++ b/absl/time/civil_time_benchmark.cc @@ -14,17 +14,29 @@ #include "absl/time/civil_time.h" +#include +#include + +#include "absl/hash/hash.h" #include "benchmark/benchmark.h" namespace { -// Benchmark Time(ns) CPU(ns) Iterations -// ------------------------------------------------------------------------- -// BM_Difference_Days 20 20 34542508 -// BM_Step_Days 15 15 48098146 -// BM_Format 688 687 1019803 -// BM_Parse 921 920 762788 -// BM_RoundTripFormatParse 1766 1764 396092 +// Run on (12 X 3492 MHz CPUs); 2018-11-05T13:44:29.814239103-08:00 +// CPU: Intel Haswell with HyperThreading (6 cores) dL1:32KB dL2:256KB dL3:15MB +// Benchmark Time(ns) CPU(ns) Iterations +// ---------------------------------------------------------------- +// BM_Difference_Days 14.5 14.5 48531105 +// BM_Step_Days 12.6 12.6 54876006 +// BM_Format 587 587 1000000 +// BM_Parse 692 692 1000000 +// BM_RoundTripFormatParse 1309 1309 532075 +// BM_CivilYearAbslHash 0.710 0.710 976400000 +// BM_CivilMonthAbslHash 1.13 1.13 619500000 +// BM_CivilDayAbslHash 1.70 1.70 426000000 +// BM_CivilHourAbslHash 2.45 2.45 287600000 +// BM_CivilMinuteAbslHash 3.21 3.21 226200000 +// BM_CivilSecondAbslHash 4.10 4.10 171800000 void BM_Difference_Days(benchmark::State& state) { const absl::CivilDay c(2014, 8, 22); @@ -54,4 +66,42 @@ void BM_Format(benchmark::State& state) { } BENCHMARK(BM_Format); +template +void BM_CivilTimeAbslHash(benchmark::State& state) { + const int kSize = 100000; + std::vector civil_times(kSize); + std::iota(civil_times.begin(), civil_times.end(), T(2018)); + + absl::Hash absl_hasher; + while (state.KeepRunningBatch(kSize)) { + for (const T civil_time : civil_times) { + benchmark::DoNotOptimize(absl_hasher(civil_time)); + } + } +} +void BM_CivilYearAbslHash(benchmark::State& state) { + BM_CivilTimeAbslHash(state); +} +void BM_CivilMonthAbslHash(benchmark::State& state) { + BM_CivilTimeAbslHash(state); +} +void BM_CivilDayAbslHash(benchmark::State& state) { + BM_CivilTimeAbslHash(state); +} +void BM_CivilHourAbslHash(benchmark::State& state) { + BM_CivilTimeAbslHash(state); +} +void BM_CivilMinuteAbslHash(benchmark::State& state) { + BM_CivilTimeAbslHash(state); +} +void BM_CivilSecondAbslHash(benchmark::State& state) { + BM_CivilTimeAbslHash(state); +} +BENCHMARK(BM_CivilYearAbslHash); +BENCHMARK(BM_CivilMonthAbslHash); +BENCHMARK(BM_CivilDayAbslHash); +BENCHMARK(BM_CivilHourAbslHash); +BENCHMARK(BM_CivilMinuteAbslHash); +BENCHMARK(BM_CivilSecondAbslHash); + } // namespace diff --git a/absl/time/internal/cctz/BUILD.bazel b/absl/time/internal/cctz/BUILD.bazel index e913fad33..e2cfe801f 100644 --- a/absl/time/internal/cctz/BUILD.bazel +++ b/absl/time/internal/cctz/BUILD.bazel @@ -12,6 +12,8 @@ # See the License for the specific language governing permissions and # limitations under the License. +package(features = ["-parse_headers"]) + licenses(["notice"]) # Apache License ### libraries diff --git a/absl/time/time.h b/absl/time/time.h index de12e5608..3fa9378fc 100644 --- a/absl/time/time.h +++ b/absl/time/time.h @@ -1336,9 +1336,12 @@ constexpr Duration MakeNormalizedDuration(int64_t sec, int64_t ticks) { return (ticks < 0) ? MakeDuration(sec - 1, ticks + kTicksPerSecond) : MakeDuration(sec, ticks); } + // Provide access to the Duration representation. constexpr int64_t GetRepHi(Duration d) { return d.rep_hi_; } constexpr uint32_t GetRepLo(Duration d) { return d.rep_lo_; } + +// Returns true iff d is positive or negative infinity. constexpr bool IsInfiniteDuration(Duration d) { return GetRepLo(d) == ~0U; } // Returns an infinite Duration with the opposite sign. diff --git a/absl/types/CMakeLists.txt b/absl/types/CMakeLists.txt index bc6c39e9c..e86207668 100644 --- a/absl/types/CMakeLists.txt +++ b/absl/types/CMakeLists.txt @@ -123,7 +123,7 @@ absl_library( # test any_test set(ANY_TEST_SRC "any_test.cc") -set(ANY_TEST_PUBLIC_LIBRARIES absl::base absl_internal_throw_delegate absl::any absl::bad_any_cast test_instance_tracker_lib) +set(ANY_TEST_PUBLIC_LIBRARIES absl::base absl_internal_throw_delegate absl::any absl::bad_any_cast absl::test_instance_tracker) absl_test( TARGET @@ -169,7 +169,7 @@ absl_test( # test span_test set(SPAN_TEST_SRC "span_test.cc") -set(SPAN_TEST_PUBLIC_LIBRARIES absl::base absl::strings absl_internal_throw_delegate absl::span test_instance_tracker_lib) +set(SPAN_TEST_PUBLIC_LIBRARIES absl::base absl::strings absl_internal_throw_delegate absl::span absl::test_instance_tracker) absl_test( TARGET diff --git a/absl/types/variant.h b/absl/types/variant.h index 2f78722f8..28aaef4fe 100644 --- a/absl/types/variant.h +++ b/absl/types/variant.h @@ -399,9 +399,9 @@ constexpr absl::add_pointer_t get_if( // Calls a provided functor on a given set of variants. `absl::visit()` is // commonly used to conditionally inspect the state of a given variant (or set // of variants). -// Requires: The expression in the Effects: element shall be a valid expression -// of the same type and value category, for all combinations of alternative -// types of all variants. Otherwise, the program is ill-formed. +// +// The functor must return the same type when called with any of the variants' +// alternatives. // // Example: // @@ -414,6 +414,7 @@ constexpr absl::add_pointer_t get_if( // }; // // // Declare our variant, and call `absl::visit()` on it. +// // Note that `GetVariant()` returns void in either case. // absl::variant foo = std::string("foo"); // GetVariant visitor; // absl::visit(visitor, foo); // Prints `The variant's value is: foo'