Merge pull request #114 from cmumford:werror-only-clang

PiperOrigin-RevId: 347660305
This commit is contained in:
Victor Costan
2020-12-15 19:49:13 +00:00
3 changed files with 372 additions and 372 deletions

View File

@@ -1,370 +1,372 @@
# Copyright 2019 Google Inc. All Rights Reserved. # Copyright 2019 Google Inc. All Rights Reserved.
# #
# Redistribution and use in source and binary forms, with or without # Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are # modification, are permitted provided that the following conditions are
# met: # met:
# #
# * Redistributions of source code must retain the above copyright # * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer. # notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above # * Redistributions in binary form must reproduce the above
# copyright notice, this list of conditions and the following disclaimer # copyright notice, this list of conditions and the following disclaimer
# in the documentation and/or other materials provided with the # in the documentation and/or other materials provided with the
# distribution. # distribution.
# * Neither the name of Google Inc. nor the names of its # * Neither the name of Google Inc. nor the names of its
# contributors may be used to endorse or promote products derived from # contributors may be used to endorse or promote products derived from
# this software without specific prior written permission. # this software without specific prior written permission.
# #
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
cmake_minimum_required(VERSION 3.1) cmake_minimum_required(VERSION 3.1)
project(Snappy VERSION 1.1.8 LANGUAGES C CXX) project(Snappy VERSION 1.1.8 LANGUAGES C CXX)
# C++ standard can be overridden when this is used as a sub-project. # C++ standard can be overridden when this is used as a sub-project.
if(NOT CMAKE_CXX_STANDARD) if(NOT CMAKE_CXX_STANDARD)
# This project requires C++11. # This project requires C++11.
set(CMAKE_CXX_STANDARD 11) set(CMAKE_CXX_STANDARD 11)
set(CMAKE_CXX_STANDARD_REQUIRED ON) set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF) set(CMAKE_CXX_EXTENSIONS OFF)
endif(NOT CMAKE_CXX_STANDARD) endif(NOT CMAKE_CXX_STANDARD)
# https://github.com/izenecloud/cmake/blob/master/SetCompilerWarningAll.cmake # https://github.com/izenecloud/cmake/blob/master/SetCompilerWarningAll.cmake
if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC") if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
# Use the highest warning level for Visual Studio. # Use the highest warning level for Visual Studio.
set(CMAKE_CXX_WARNING_LEVEL 4) set(CMAKE_CXX_WARNING_LEVEL 4)
if(CMAKE_CXX_FLAGS MATCHES "/W[0-4]") if(CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
string(REGEX REPLACE "/W[0-4]" "/W4" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}") string(REGEX REPLACE "/W[0-4]" "/W4" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
else(CMAKE_CXX_FLAGS MATCHES "/W[0-4]") else(CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4")
endif(CMAKE_CXX_FLAGS MATCHES "/W[0-4]") endif(CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
# Disable C++ exceptions. # Disable C++ exceptions.
string(REGEX REPLACE "/EH[a-z]+" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}") string(REGEX REPLACE "/EH[a-z]+" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /EHs-c-") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /EHs-c-")
add_definitions(-D_HAS_EXCEPTIONS=0) add_definitions(-D_HAS_EXCEPTIONS=0)
# Disable RTTI. # Disable RTTI.
string(REGEX REPLACE "/GR" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}") string(REGEX REPLACE "/GR" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /GR-") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /GR-")
else(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC") else(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
# Use -Wall for clang and gcc. # Use -Wall for clang and gcc.
if(NOT CMAKE_CXX_FLAGS MATCHES "-Wall") if(NOT CMAKE_CXX_FLAGS MATCHES "-Wall")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")
endif(NOT CMAKE_CXX_FLAGS MATCHES "-Wall") endif(NOT CMAKE_CXX_FLAGS MATCHES "-Wall")
# Use -Wextra for clang and gcc. # Use -Wextra for clang and gcc.
if(NOT CMAKE_CXX_FLAGS MATCHES "-Wextra") if(NOT CMAKE_CXX_FLAGS MATCHES "-Wextra")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wextra") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wextra")
endif(NOT CMAKE_CXX_FLAGS MATCHES "-Wextra") endif(NOT CMAKE_CXX_FLAGS MATCHES "-Wextra")
# Use -Werror for clang and gcc. # Use -Werror for clang only.
if(NOT CMAKE_CXX_FLAGS MATCHES "-Werror") if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror") if(NOT CMAKE_CXX_FLAGS MATCHES "-Werror")
endif(NOT CMAKE_CXX_FLAGS MATCHES "-Werror") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror")
endif(NOT CMAKE_CXX_FLAGS MATCHES "-Werror")
# Disable C++ exceptions. endif(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
string(REGEX REPLACE "-fexceptions" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-exceptions") # Disable C++ exceptions.
string(REGEX REPLACE "-fexceptions" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
# Disable RTTI. set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-exceptions")
string(REGEX REPLACE "-frtti" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-rtti") # Disable RTTI.
endif(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC") string(REGEX REPLACE "-frtti" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-rtti")
# BUILD_SHARED_LIBS is a standard CMake variable, but we declare it here to make endif(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
# it prominent in the GUI.
option(BUILD_SHARED_LIBS "Build shared libraries(DLLs)." OFF) # BUILD_SHARED_LIBS is a standard CMake variable, but we declare it here to make
# it prominent in the GUI.
option(SNAPPY_BUILD_TESTS "Build Snappy's own tests." ON) option(BUILD_SHARED_LIBS "Build shared libraries(DLLs)." OFF)
option(SNAPPY_FUZZING_BUILD "Build Snappy for fuzzing." OFF) option(SNAPPY_BUILD_TESTS "Build Snappy's own tests." ON)
option(SNAPPY_REQUIRE_AVX "Target processors with AVX support." OFF) option(SNAPPY_FUZZING_BUILD "Build Snappy for fuzzing." OFF)
option(SNAPPY_REQUIRE_AVX2 "Target processors with AVX2 support." OFF) option(SNAPPY_REQUIRE_AVX "Target processors with AVX support." OFF)
option(SNAPPY_INSTALL "Install Snappy's header and library" ON) option(SNAPPY_REQUIRE_AVX2 "Target processors with AVX2 support." OFF)
include(TestBigEndian) option(SNAPPY_INSTALL "Install Snappy's header and library" ON)
test_big_endian(SNAPPY_IS_BIG_ENDIAN)
include(TestBigEndian)
include(CheckIncludeFile) test_big_endian(SNAPPY_IS_BIG_ENDIAN)
check_include_file("sys/mman.h" HAVE_SYS_MMAN_H)
check_include_file("sys/resource.h" HAVE_SYS_RESOURCE_H) include(CheckIncludeFile)
check_include_file("sys/time.h" HAVE_SYS_TIME_H) check_include_file("sys/mman.h" HAVE_SYS_MMAN_H)
check_include_file("sys/uio.h" HAVE_SYS_UIO_H) check_include_file("sys/resource.h" HAVE_SYS_RESOURCE_H)
check_include_file("unistd.h" HAVE_UNISTD_H) check_include_file("sys/time.h" HAVE_SYS_TIME_H)
check_include_file("windows.h" HAVE_WINDOWS_H) check_include_file("sys/uio.h" HAVE_SYS_UIO_H)
check_include_file("unistd.h" HAVE_UNISTD_H)
include(CheckLibraryExists) check_include_file("windows.h" HAVE_WINDOWS_H)
check_library_exists(z zlibVersion "" HAVE_LIBZ)
check_library_exists(lzo2 lzo1x_1_15_compress "" HAVE_LIBLZO2) include(CheckLibraryExists)
check_library_exists(lz4 LZ4_compress_default "" HAVE_LIBLZ4) check_library_exists(z zlibVersion "" HAVE_LIBZ)
check_library_exists(lzo2 lzo1x_1_15_compress "" HAVE_LIBLZO2)
include(CheckCXXCompilerFlag) check_library_exists(lz4 LZ4_compress_default "" HAVE_LIBLZ4)
CHECK_CXX_COMPILER_FLAG("/arch:AVX" HAVE_VISUAL_STUDIO_ARCH_AVX)
CHECK_CXX_COMPILER_FLAG("/arch:AVX2" HAVE_VISUAL_STUDIO_ARCH_AVX2) include(CheckCXXCompilerFlag)
CHECK_CXX_COMPILER_FLAG("-mavx" HAVE_CLANG_MAVX) CHECK_CXX_COMPILER_FLAG("/arch:AVX" HAVE_VISUAL_STUDIO_ARCH_AVX)
CHECK_CXX_COMPILER_FLAG("-mbmi2" HAVE_CLANG_MBMI2) CHECK_CXX_COMPILER_FLAG("/arch:AVX2" HAVE_VISUAL_STUDIO_ARCH_AVX2)
if(SNAPPY_REQUIRE_AVX2) CHECK_CXX_COMPILER_FLAG("-mavx" HAVE_CLANG_MAVX)
if(HAVE_VISUAL_STUDIO_ARCH_AVX2) CHECK_CXX_COMPILER_FLAG("-mbmi2" HAVE_CLANG_MBMI2)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /arch:AVX2") if(SNAPPY_REQUIRE_AVX2)
endif(HAVE_VISUAL_STUDIO_ARCH_AVX2) if(HAVE_VISUAL_STUDIO_ARCH_AVX2)
if(HAVE_CLANG_MAVX) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /arch:AVX2")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mavx") endif(HAVE_VISUAL_STUDIO_ARCH_AVX2)
endif(HAVE_CLANG_MAVX) if(HAVE_CLANG_MAVX)
if(HAVE_CLANG_MBMI2) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mavx")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mbmi2") endif(HAVE_CLANG_MAVX)
endif(HAVE_CLANG_MBMI2) if(HAVE_CLANG_MBMI2)
elseif (SNAPPY_REQUIRE_AVX) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mbmi2")
if(HAVE_VISUAL_STUDIO_ARCH_AVX) endif(HAVE_CLANG_MBMI2)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /arch:AVX") elseif (SNAPPY_REQUIRE_AVX)
endif(HAVE_VISUAL_STUDIO_ARCH_AVX) if(HAVE_VISUAL_STUDIO_ARCH_AVX)
if(HAVE_CLANG_MAVX) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /arch:AVX")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mavx") endif(HAVE_VISUAL_STUDIO_ARCH_AVX)
endif(HAVE_CLANG_MAVX) if(HAVE_CLANG_MAVX)
endif(SNAPPY_REQUIRE_AVX2) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mavx")
endif(HAVE_CLANG_MAVX)
# Used by googletest. endif(SNAPPY_REQUIRE_AVX2)
check_cxx_compiler_flag(-Wno-missing-field-initializers
SNAPPY_HAVE_NO_MISSING_FIELD_INITIALIZERS) # Used by googletest.
check_cxx_compiler_flag(-Wno-missing-field-initializers
include(CheckCXXSourceCompiles) SNAPPY_HAVE_NO_MISSING_FIELD_INITIALIZERS)
check_cxx_source_compiles("
int main() { include(CheckCXXSourceCompiles)
return __builtin_expect(0, 1); check_cxx_source_compiles("
}" HAVE_BUILTIN_EXPECT) int main() {
return __builtin_expect(0, 1);
check_cxx_source_compiles(" }" HAVE_BUILTIN_EXPECT)
int main() {
return __builtin_ctzll(0); check_cxx_source_compiles("
}" HAVE_BUILTIN_CTZ) int main() {
return __builtin_ctzll(0);
check_cxx_source_compiles(" }" HAVE_BUILTIN_CTZ)
__attribute__((always_inline)) int zero() { return 0; }
check_cxx_source_compiles("
int main() { __attribute__((always_inline)) int zero() { return 0; }
return zero();
}" HAVE_ATTRIBUTE_ALWAYS_INLINE) int main() {
return zero();
check_cxx_source_compiles(" }" HAVE_ATTRIBUTE_ALWAYS_INLINE)
#include <tmmintrin.h>
check_cxx_source_compiles("
int main() { #include <tmmintrin.h>
const __m128i *src = 0;
__m128i dest; int main() {
const __m128i shuffle_mask = _mm_load_si128(src); const __m128i *src = 0;
const __m128i pattern = _mm_shuffle_epi8(_mm_loadl_epi64(src), shuffle_mask); __m128i dest;
_mm_storeu_si128(&dest, pattern); const __m128i shuffle_mask = _mm_load_si128(src);
return 0; const __m128i pattern = _mm_shuffle_epi8(_mm_loadl_epi64(src), shuffle_mask);
}" SNAPPY_HAVE_SSSE3) _mm_storeu_si128(&dest, pattern);
return 0;
check_cxx_source_compiles(" }" SNAPPY_HAVE_SSSE3)
#include <immintrin.h>
int main() { check_cxx_source_compiles("
return _bzhi_u32(0, 1); #include <immintrin.h>
}" SNAPPY_HAVE_BMI2) int main() {
return _bzhi_u32(0, 1);
include(CheckSymbolExists) }" SNAPPY_HAVE_BMI2)
check_symbol_exists("mmap" "sys/mman.h" HAVE_FUNC_MMAP)
check_symbol_exists("sysconf" "unistd.h" HAVE_FUNC_SYSCONF) include(CheckSymbolExists)
check_symbol_exists("mmap" "sys/mman.h" HAVE_FUNC_MMAP)
find_package(Gflags QUIET) check_symbol_exists("sysconf" "unistd.h" HAVE_FUNC_SYSCONF)
if(GFLAGS_FOUND OR GFLAGS_TARGET)
set(HAVE_GFLAGS 1) find_package(Gflags QUIET)
endif(GFLAGS_FOUND OR GFLAGS_TARGET) if(GFLAGS_FOUND OR GFLAGS_TARGET)
set(HAVE_GFLAGS 1)
configure_file( endif(GFLAGS_FOUND OR GFLAGS_TARGET)
"cmake/config.h.in"
"${PROJECT_BINARY_DIR}/config.h" configure_file(
) "cmake/config.h.in"
"${PROJECT_BINARY_DIR}/config.h"
# We don't want to define HAVE_ macros in public headers. Instead, we use )
# CMake's variable substitution with 0/1 variables, which will be seen by the
# preprocessor as constants. # We don't want to define HAVE_ macros in public headers. Instead, we use
set(HAVE_SYS_UIO_H_01 ${HAVE_SYS_UIO_H}) # CMake's variable substitution with 0/1 variables, which will be seen by the
if(NOT HAVE_SYS_UIO_H_01) # preprocessor as constants.
set(HAVE_SYS_UIO_H_01 0) set(HAVE_SYS_UIO_H_01 ${HAVE_SYS_UIO_H})
endif(NOT HAVE_SYS_UIO_H_01) if(NOT HAVE_SYS_UIO_H_01)
set(HAVE_SYS_UIO_H_01 0)
if (SNAPPY_FUZZING_BUILD) endif(NOT HAVE_SYS_UIO_H_01)
if (NOT "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
message(WARNING "Fuzzing builds are only supported with Clang") if (SNAPPY_FUZZING_BUILD)
endif (NOT "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang") if (NOT "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
message(WARNING "Fuzzing builds are only supported with Clang")
if(NOT CMAKE_CXX_FLAGS MATCHES "-fsanitize=address") endif (NOT "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address")
endif(NOT CMAKE_CXX_FLAGS MATCHES "-fsanitize=address") if(NOT CMAKE_CXX_FLAGS MATCHES "-fsanitize=address")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address")
if(NOT CMAKE_CXX_FLAGS MATCHES "-fsanitize=fuzzer-no-link") endif(NOT CMAKE_CXX_FLAGS MATCHES "-fsanitize=address")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=fuzzer-no-link")
endif(NOT CMAKE_CXX_FLAGS MATCHES "-fsanitize=fuzzer-no-link") if(NOT CMAKE_CXX_FLAGS MATCHES "-fsanitize=fuzzer-no-link")
endif (SNAPPY_FUZZING_BUILD) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=fuzzer-no-link")
endif(NOT CMAKE_CXX_FLAGS MATCHES "-fsanitize=fuzzer-no-link")
configure_file( endif (SNAPPY_FUZZING_BUILD)
"snappy-stubs-public.h.in"
"${PROJECT_BINARY_DIR}/snappy-stubs-public.h") configure_file(
"snappy-stubs-public.h.in"
add_library(snappy "") "${PROJECT_BINARY_DIR}/snappy-stubs-public.h")
target_sources(snappy
PRIVATE add_library(snappy "")
"snappy-internal.h" target_sources(snappy
"snappy-stubs-internal.h" PRIVATE
"snappy-c.cc" "snappy-internal.h"
"snappy-sinksource.cc" "snappy-stubs-internal.h"
"snappy-stubs-internal.cc" "snappy-c.cc"
"snappy.cc" "snappy-sinksource.cc"
"${PROJECT_BINARY_DIR}/config.h" "snappy-stubs-internal.cc"
"snappy.cc"
# Only CMake 3.3+ supports PUBLIC sources in targets exported by "install". "${PROJECT_BINARY_DIR}/config.h"
$<$<VERSION_GREATER:CMAKE_VERSION,3.2>:PUBLIC>
$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/snappy-c.h> # Only CMake 3.3+ supports PUBLIC sources in targets exported by "install".
$<INSTALL_INTERFACE:include/snappy-c.h> $<$<VERSION_GREATER:CMAKE_VERSION,3.2>:PUBLIC>
$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/snappy-sinksource.h> $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/snappy-c.h>
$<INSTALL_INTERFACE:include/snappy-sinksource.h> $<INSTALL_INTERFACE:include/snappy-c.h>
$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/snappy.h> $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/snappy-sinksource.h>
$<INSTALL_INTERFACE:include/snappy.h> $<INSTALL_INTERFACE:include/snappy-sinksource.h>
$<BUILD_INTERFACE:${PROJECT_BINARY_DIR}/snappy-stubs-public.h> $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/snappy.h>
$<INSTALL_INTERFACE:include/snappy-stubs-public.h> $<INSTALL_INTERFACE:include/snappy.h>
) $<BUILD_INTERFACE:${PROJECT_BINARY_DIR}/snappy-stubs-public.h>
target_include_directories(snappy $<INSTALL_INTERFACE:include/snappy-stubs-public.h>
PUBLIC )
$<BUILD_INTERFACE:${PROJECT_BINARY_DIR}> target_include_directories(snappy
$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}> PUBLIC
$<INSTALL_INTERFACE:include> $<BUILD_INTERFACE:${PROJECT_BINARY_DIR}>
) $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}>
set_target_properties(snappy $<INSTALL_INTERFACE:include>
PROPERTIES VERSION ${PROJECT_VERSION} SOVERSION ${PROJECT_VERSION_MAJOR}) )
set_target_properties(snappy
target_compile_definitions(snappy PRIVATE -DHAVE_CONFIG_H) PROPERTIES VERSION ${PROJECT_VERSION} SOVERSION ${PROJECT_VERSION_MAJOR})
if(BUILD_SHARED_LIBS)
set_target_properties(snappy PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS ON) target_compile_definitions(snappy PRIVATE -DHAVE_CONFIG_H)
endif(BUILD_SHARED_LIBS) if(BUILD_SHARED_LIBS)
set_target_properties(snappy PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS ON)
if(SNAPPY_BUILD_TESTS) endif(BUILD_SHARED_LIBS)
enable_testing()
if(SNAPPY_BUILD_TESTS)
# Prevent overriding the parent project's compiler/linker settings on Windows. enable_testing()
set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
set(install_gtest OFF) # Prevent overriding the parent project's compiler/linker settings on Windows.
set(install_gmock OFF) set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
set(build_gmock ON) set(install_gtest OFF)
set(install_gmock OFF)
# This project is tested using GoogleTest. set(build_gmock ON)
add_subdirectory("third_party/googletest")
# This project is tested using GoogleTest.
# This project uses Google benchmark for benchmarking. add_subdirectory("third_party/googletest")
set(BENCHMARK_ENABLE_TESTING OFF CACHE BOOL "" FORCE)
set(BENCHMARK_ENABLE_EXCEPTIONS OFF CACHE BOOL "" FORCE) # This project uses Google benchmark for benchmarking.
add_subdirectory("third_party/benchmark") set(BENCHMARK_ENABLE_TESTING OFF CACHE BOOL "" FORCE)
set(BENCHMARK_ENABLE_EXCEPTIONS OFF CACHE BOOL "" FORCE)
# GoogleTest triggers a missing field initializers warning. add_subdirectory("third_party/benchmark")
if(SNAPPY_HAVE_NO_MISSING_FIELD_INITIALIZERS)
set_property(TARGET gtest # GoogleTest triggers a missing field initializers warning.
APPEND PROPERTY COMPILE_OPTIONS -Wno-missing-field-initializers) if(SNAPPY_HAVE_NO_MISSING_FIELD_INITIALIZERS)
set_property(TARGET gmock set_property(TARGET gtest
APPEND PROPERTY COMPILE_OPTIONS -Wno-missing-field-initializers) APPEND PROPERTY COMPILE_OPTIONS -Wno-missing-field-initializers)
endif(SNAPPY_HAVE_NO_MISSING_FIELD_INITIALIZERS) set_property(TARGET gmock
APPEND PROPERTY COMPILE_OPTIONS -Wno-missing-field-initializers)
add_executable(snappy_unittest "") endif(SNAPPY_HAVE_NO_MISSING_FIELD_INITIALIZERS)
target_sources(snappy_unittest
PRIVATE add_executable(snappy_unittest "")
"snappy_unittest.cc" target_sources(snappy_unittest
"snappy-test.cc" PRIVATE
) "snappy_unittest.cc"
target_compile_definitions(snappy_unittest PRIVATE -DHAVE_CONFIG_H) "snappy-test.cc"
target_link_libraries(snappy_unittest )
snappy ${GFLAGS_LIBRARIES} gmock gtest benchmark) target_compile_definitions(snappy_unittest PRIVATE -DHAVE_CONFIG_H)
target_link_libraries(snappy_unittest
if(HAVE_LIBZ) snappy ${GFLAGS_LIBRARIES} gmock gtest benchmark)
target_link_libraries(snappy_unittest z)
endif(HAVE_LIBZ) if(HAVE_LIBZ)
if(HAVE_LIBLZO2) target_link_libraries(snappy_unittest z)
target_link_libraries(snappy_unittest lzo2) endif(HAVE_LIBZ)
endif(HAVE_LIBLZO2) if(HAVE_LIBLZO2)
if(HAVE_LIBLZ4) target_link_libraries(snappy_unittest lzo2)
target_link_libraries(snappy_unittest lz4) endif(HAVE_LIBLZO2)
endif(HAVE_LIBLZ4) if(HAVE_LIBLZ4)
target_link_libraries(snappy_unittest lz4)
target_include_directories(snappy_unittest endif(HAVE_LIBLZ4)
BEFORE PRIVATE
"${PROJECT_SOURCE_DIR}" target_include_directories(snappy_unittest
"${GFLAGS_INCLUDE_DIRS}" BEFORE PRIVATE
) "${PROJECT_SOURCE_DIR}"
"${GFLAGS_INCLUDE_DIRS}"
add_test( )
NAME snappy_unittest
WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}" add_test(
COMMAND "${PROJECT_BINARY_DIR}/snappy_unittest") NAME snappy_unittest
endif(SNAPPY_BUILD_TESTS) WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}"
COMMAND "${PROJECT_BINARY_DIR}/snappy_unittest")
if(SNAPPY_FUZZING_BUILD) endif(SNAPPY_BUILD_TESTS)
add_executable(snappy_compress_fuzzer "")
target_sources(snappy_compress_fuzzer if(SNAPPY_FUZZING_BUILD)
PRIVATE "snappy_compress_fuzzer.cc" add_executable(snappy_compress_fuzzer "")
) target_sources(snappy_compress_fuzzer
target_link_libraries(snappy_compress_fuzzer snappy) PRIVATE "snappy_compress_fuzzer.cc"
set_target_properties(snappy_compress_fuzzer )
PROPERTIES LINK_FLAGS "-fsanitize=fuzzer" target_link_libraries(snappy_compress_fuzzer snappy)
) set_target_properties(snappy_compress_fuzzer
PROPERTIES LINK_FLAGS "-fsanitize=fuzzer"
add_executable(snappy_uncompress_fuzzer "") )
target_sources(snappy_uncompress_fuzzer
PRIVATE "snappy_uncompress_fuzzer.cc" add_executable(snappy_uncompress_fuzzer "")
) target_sources(snappy_uncompress_fuzzer
target_link_libraries(snappy_uncompress_fuzzer snappy) PRIVATE "snappy_uncompress_fuzzer.cc"
set_target_properties(snappy_uncompress_fuzzer )
PROPERTIES LINK_FLAGS "-fsanitize=fuzzer" target_link_libraries(snappy_uncompress_fuzzer snappy)
) set_target_properties(snappy_uncompress_fuzzer
endif(SNAPPY_FUZZING_BUILD) PROPERTIES LINK_FLAGS "-fsanitize=fuzzer"
)
# Must be included before CMAKE_INSTALL_INCLUDEDIR is used. endif(SNAPPY_FUZZING_BUILD)
include(GNUInstallDirs)
# Must be included before CMAKE_INSTALL_INCLUDEDIR is used.
if(SNAPPY_INSTALL) include(GNUInstallDirs)
install(TARGETS snappy
EXPORT SnappyTargets if(SNAPPY_INSTALL)
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} install(TARGETS snappy
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} EXPORT SnappyTargets
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
) LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
install( ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
FILES )
"snappy-c.h" install(
"snappy-sinksource.h" FILES
"snappy.h" "snappy-c.h"
"${PROJECT_BINARY_DIR}/snappy-stubs-public.h" "snappy-sinksource.h"
DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}" "snappy.h"
) "${PROJECT_BINARY_DIR}/snappy-stubs-public.h"
DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
include(CMakePackageConfigHelpers) )
configure_package_config_file(
"cmake/${PROJECT_NAME}Config.cmake.in" include(CMakePackageConfigHelpers)
"${PROJECT_BINARY_DIR}/cmake/${PROJECT_NAME}Config.cmake" configure_package_config_file(
INSTALL_DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}" "cmake/${PROJECT_NAME}Config.cmake.in"
) "${PROJECT_BINARY_DIR}/cmake/${PROJECT_NAME}Config.cmake"
write_basic_package_version_file( INSTALL_DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}"
"${PROJECT_BINARY_DIR}/cmake/${PROJECT_NAME}ConfigVersion.cmake" )
COMPATIBILITY SameMajorVersion write_basic_package_version_file(
) "${PROJECT_BINARY_DIR}/cmake/${PROJECT_NAME}ConfigVersion.cmake"
install( COMPATIBILITY SameMajorVersion
EXPORT SnappyTargets )
NAMESPACE Snappy:: install(
DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}" EXPORT SnappyTargets
) NAMESPACE Snappy::
install( DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}"
FILES )
"${PROJECT_BINARY_DIR}/cmake/${PROJECT_NAME}Config.cmake" install(
"${PROJECT_BINARY_DIR}/cmake/${PROJECT_NAME}ConfigVersion.cmake" FILES
DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}" "${PROJECT_BINARY_DIR}/cmake/${PROJECT_NAME}Config.cmake"
) "${PROJECT_BINARY_DIR}/cmake/${PROJECT_NAME}ConfigVersion.cmake"
endif(SNAPPY_INSTALL) DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}"
)
endif(SNAPPY_INSTALL)

Submodule third_party/benchmark deleted from bf585a2789

Submodule third_party/googletest deleted from 18f8200e30