This is an automated email from the ASF dual-hosted git repository.
bbender pushed a commit to branch develop
in repository https://gitbox.apache.org/repos/asf/geode-native.git
The following commit(s) were added to refs/heads/develop by this push:
new f63fe93 Disables LTO on RHEL-8 (#855)
f63fe93 is described below
commit f63fe93858782505e4597765f275392b007f0626
Author: Jacob Barrett <jbarr...@pivotal.io>
AuthorDate: Wed Aug 25 07:17:28 2021 -0700
Disables LTO on RHEL-8 (#855)
* Adds LTO and sanitizer options.
* Adds checks for some sanitizer options.
* Adds options to enable sanitizers.
* Extracts checks for LTO.
* Adds options to disable LTO.
* Disables IPO on RHEL-8 because GCC 8.4.1 is broken.
---
BUILDING.md | 8 +++
CMakeLists.txt | 9 +--
CONTRIBUTING.md | 18 ++++++
ci/base/base.yml | 2 +
cmake/CXXFlags.cmake | 159 +++++++++++++++++++++++++++++++++++++++++++++++++++
5 files changed, 189 insertions(+), 7 deletions(-)
diff --git a/BUILDING.md b/BUILDING.md
index 6536b41..e8cd6d2 100644
--- a/BUILDING.md
+++ b/BUILDING.md
@@ -130,6 +130,14 @@ IPv6 support can be enabled by adding `-DWITH_IPV6=ON` to
the CMake [Generator](
$ cmake … -DWITH_IPV6=ON …
```
+#### Interprocedural, Link-Time, or Whole-Program Optimizations
+These optimizations are enabled by default where available. You can disable
them at configure time.
+
+```console
+$ cmake … -DUSE_IPO=NO …
+```
+
+
## Installing
By default a system-specific location is used by CMake as the destination of
the `install` target, e.g., `/usr/local` on
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 700d42d..9c3ed29 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -173,16 +173,11 @@ add_library(c++11 INTERFACE)
add_library(_WarningsAsError INTERFACE)
add_library(_CppCodeCoverage INTERFACE)
-include(CheckIPOSupported)
-check_ipo_supported(RESULT ipo_supported)
-if(ipo_supported)
- set(CMAKE_INTERPROCEDURAL_OPTIMIZATION_RELEASE TRUE)
- set(CMAKE_INTERPROCEDURAL_OPTIMIZATION_RELWITHDEBINFO TRUE)
-endif()
-
include(CheckLinkerFlag)
check_linker_flag(CXX -Wl,--exclude-libs,ALL has_linker_exclude_libs)
+include(CXXFlags)
+
include(CheckCXXSymbolExists)
check_cxx_symbol_exists("PRId8" "cinttypes" HAVE_STDC_FORMAT_MACROS)
if (NOT HAVE_STDC_FORMAT_MACROS)
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 52bd8e9..669d6e8 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -99,6 +99,24 @@ $ cd build/clicache/acceptance-test
$ ctest -C <Debug|RelWithDebInfo> -R <test_name> -j1
```
+## Google Sanitizers
+You can use the [Google Sanitizers](https://github.com/google/sanitizers),
where available. These sanitizers can
+be used to diagnose possible issues when running tests. You can enable them
using combinations of the options below.
+
+Address Sanitizer:
+```console
+$ cmake … -DUSE_SANITIZE_ADDRESS=YES …
+```
+Undefined Behavior Sanitizer:
+```console
+$ cmake … -DUSE_SANITIZE_UNDEFINED=YES …
+```
+Make sanitizer warnings fatal and exit:
+```console
+$ cmake … -DUSE_SANITIZE_FATAL=YES …
+```
+
+
## Style
### Formatting C++
diff --git a/ci/base/base.yml b/ci/base/base.yml
index 60ba0d5..f60c4dc 100644
--- a/ci/base/base.yml
+++ b/ci/base/base.yml
@@ -83,6 +83,8 @@ builds:
- _: #@ template.replace(new_build("rhel-8"))
image_family: build-rhel-8
source_image_family: rhel-8
+ params:
+ CMAKE_CONFIGURE_FLAGS: "-DUSE_IPO=NO"
- _: #@ template.replace(new_build("ubuntu-16.04"))
image_family: build-ubuntu-16-04
diff --git a/cmake/CXXFlags.cmake b/cmake/CXXFlags.cmake
new file mode 100644
index 0000000..b4441ca
--- /dev/null
+++ b/cmake/CXXFlags.cmake
@@ -0,0 +1,159 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+include(CheckLinkerFlag)
+
+set(CHECK_FEATURE "Undefined Behavior Sanitizer")
+message(CHECK_START ${CHECK_FEATURE})
+
+list(APPEND CMAKE_MESSAGE_INDENT " ")
+check_cxx_compiler_flag(-fsanitize=undefined CXX_HAS_SANITIZE_UNDEFINED_FLAG)
+unset(CXX_SANITIZE_UNDEFINED_FLAG)
+if (CXX_HAS_SANITIZE_UNDEFINED_FLAG)
+ set(CXX_SANITIZE_UNDEFINED_FLAG -fsanitize=undefined)
+endif()
+
+check_linker_flag(CXX -fsanitize=undefined
CXX_LINKER_HAS_SANITIZE_UNDEFINED_FLAG)
+unset(CXX_LINKER_SANITIZE_UNDEFINED_FLAG)
+if (CXX_LINKER_HAS_SANITIZE_UNDEFINED_FLAG)
+ set(CXX_LINKER_SANITIZE_UNDEFINED_FLAG -fsanitize=undefined)
+endif()
+list(POP_BACK CMAKE_MESSAGE_INDENT)
+
+if (CXX_HAS_SANITIZE_UNDEFINED_FLAG)
+ option(USE_SANITIZE_UNDEFINED "Use ${CHECK_FEATURE}" FALSE)
+ if (USE_SANITIZE_UNDEFINED)
+ message(CHECK_PASS "Enabled")
+ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_SANITIZE_UNDEFINED_FLAG}")
+ set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS}
${CXX_LINKER_SANITIZE_UNDEFINED_FLAG}")
+ set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS}
${CXX_LINKER_SANITIZE_UNDEFINED_FLAG}")
+ else()
+ message(CHECK_FAIL "Disabled")
+ endif()
+else()
+ if (USE_SANITIZE_UNDEFINED)
+ message(FATAL_ERROR "${CHECK_FEATURE} enabled but not supported.")
+ else()
+ message(CHECK_FAIL "Unsupported")
+ endif()
+endif()
+
+
+set(CHECK_FEATURE "Address Sanitizer")
+message(CHECK_START ${CHECK_FEATURE})
+
+list(APPEND CMAKE_MESSAGE_INDENT " ")
+check_linker_flag(CXX -fsanitize=address CXX_LINKER_HAS_SANITIZE_ADDRESS_FLAG)
+unset(CXX_LINKER_SANITIZE_ADDRESS_FLAG)
+if (CXX_LINKER_HAS_SANITIZE_ADDRESS_FLAG)
+ set(CXX_LINKER_SANITIZE_ADDRESS_FLAG -fsanitize=address)
+endif()
+
+if (CXX_LINKER_HAS_SANITIZE_ADDRESS_FLAG)
+ list(APPEND CMAKE_REQUIRED_LINK_OPTIONS -fsanitize=address)
+endif()
+check_cxx_compiler_flag(-fsanitize=address CXX_HAS_SANITIZE_ADDRESS_FLAG)
+if (CXX_LINKER_HAS_SANITIZE_ADDRESS_FLAG)
+ list(POP_BACK CMAKE_REQUIRED_LINK_OPTIONS)
+endif()
+unset(CXX_SANITIZE_ADDRESS_FLAG)
+if (CXX_HAS_SANITIZE_ADDRESS_FLAG)
+ set(CXX_SANITIZE_ADDRESS_FLAG -fsanitize=address)
+endif()
+
+check_linker_flag(CXX -fno-omit-frame-pointer
CXX_HAS_NO_OMIT_FRAME_POINTER_FLAG)
+unset(CXX_NO_OMIT_FRAME_POINTER_FLAG)
+if (CXX_HAS_NO_OMIT_FRAME_POINTER_FLAG)
+ set(CXX_NO_OMIT_FRAME_POINTER_FLAG -fno-omit-frame-pointer)
+endif()
+
+list(POP_BACK CMAKE_MESSAGE_INDENT)
+
+if (CXX_HAS_SANITIZE_ADDRESS_FLAG)
+ option(USE_SANITIZE_ADDRESS "Use ${CHECK_FEATURE}" FALSE)
+ if (USE_SANITIZE_ADDRESS)
+ message(CHECK_PASS "Enabled")
+ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_SANITIZE_ADDRESS_FLAG}
${CXX_NO_OMIT_FRAME_POINTER_FLAG}")
+ set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS}
${CXX_LINKER_SANITIZE_ADDRESS_FLAG}")
+ set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS}
${CXX_LINKER_SANITIZE_ADDRESS_FLAG}")
+ else()
+ message(CHECK_FAIL "Disabled")
+ endif()
+else()
+ if (USE_SANITIZE_ADDRESS)
+ message(FATAL_ERROR "${CHECK_FEATURE} enabled but not supported.")
+ else()
+ message(CHECK_FAIL "Unsupported")
+ endif()
+endif()
+
+
+set(CHECK_FEATURE "Sanitizer errors fatal.")
+message(CHECK_START ${CHECK_FEATURE})
+
+list(APPEND CMAKE_MESSAGE_INDENT " ")
+check_cxx_compiler_flag(-fno-sanitize-recover CXX_HAS_NO_SANITIZE_RECOVER_FLAG)
+unset(CXX_NO_SANITIZE_RECOVER_FLAG)
+if (CXX_HAS_NO_SANITIZE_RECOVER_FLAG)
+ set(CXX_NO_SANITIZE_RECOVER_FLAG -fno-sanitize-recover)
+endif()
+list(POP_BACK CMAKE_MESSAGE_INDENT)
+
+if (CXX_NO_SANITIZE_RECOVER_FLAG)
+ option(USE_SANITIZE_FATAL "Use ${CHECK_FEATURE}"
${CXX_HAS_NO_SANITIZE_RECOVER_FLAG})
+ if (USE_SANITIZE_FATAL)
+ message(CHECK_PASS "Enabled")
+ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_NO_SANITIZE_RECOVER_FLAG}")
+ else()
+ message(CHECK_FAIL "Disabled")
+ endif()
+else()
+ if (USE_SANITIZE_FATAL)
+ message(FATAL_ERROR "${CHECK_FEATURE} enabled but not supported.")
+ else()
+ message(CHECK_FAIL "Unsupported")
+ endif()
+endif()
+
+
+set(CHECK_FEATURE "Interprocedural or link time optimizations (IPO/LTO)")
+message(CHECK_START ${CHECK_FEATURE})
+
+list(APPEND CMAKE_MESSAGE_INDENT " ")
+include(CheckIPOSupported)
+if (NOT DEFINED CXX_HAS_IPO_SUPPORT)
+ check_ipo_supported(RESULT CXX_HAS_IPO_SUPPORT LANGUAGES CXX)
+ set(CXX_HAS_IPO_SUPPORT ${CXX_HAS_IPO_SUPPORT} CACHE INTERNAL "Test
check_ipo_supported" FORCE)
+endif()
+list(POP_BACK CMAKE_MESSAGE_INDENT)
+
+if(CXX_HAS_IPO_SUPPORT)
+ option(USE_IPO "Use ${CHECK_FEATURE}" ${CXX_HAS_IPO_SUPPORT})
+ if (USE_IPO)
+ message(CHECK_PASS "Enabled")
+ else()
+ message(CHECK_FAIL "Disabled")
+ endif()
+ set(CMAKE_INTERPROCEDURAL_OPTIMIZATION_RELEASE ${USE_IPO})
+ set(CMAKE_INTERPROCEDURAL_OPTIMIZATION_RELWITHDEBINFO ${USE_IPO})
+else()
+ set(CMAKE_INTERPROCEDURAL_OPTIMIZATION_RELEASE FALSE)
+ set(CMAKE_INTERPROCEDURAL_OPTIMIZATION_RELWITHDEBINFO FALSE)
+ if (USE_IPO)
+ message(FATAL_ERROR "${CHECK_FEATURE} enabled but not supported.")
+ else()
+ message(CHECK_FAIL "Unsupported")
+ endif()
+endif()
