Rollforward of fix to no-op changes for internal experiment PiperOrigin-RevId: 928693285 Change-Id: I59d49a9a880be28d0a2d5cd2272a0438865cc0e0
diff --git a/CMake/AbseilDll.cmake b/CMake/AbseilDll.cmake index b603864..c285038 100644 --- a/CMake/AbseilDll.cmake +++ b/CMake/AbseilDll.cmake
@@ -22,6 +22,7 @@ "base/internal/dynamic_annotations.h" "base/internal/endian.h" "base/internal/errno_saver.h" + "base/internal/hardening.cc" "base/internal/hardening.h" "base/internal/hide_ptr.h" "base/internal/iterator_traits.h"
diff --git a/absl/base/BUILD.bazel b/absl/base/BUILD.bazel index abbf099..53bac42 100644 --- a/absl/base/BUILD.bazel +++ b/absl/base/BUILD.bazel
@@ -80,6 +80,7 @@ cc_library( name = "hardening", + srcs = ["internal/hardening.cc"], hdrs = [ "internal/hardening.h", ],
diff --git a/absl/base/CMakeLists.txt b/absl/base/CMakeLists.txt index f3875b0..8d5cf66 100644 --- a/absl/base/CMakeLists.txt +++ b/absl/base/CMakeLists.txt
@@ -61,6 +61,8 @@ hardening HDRS "internal/hardening.h" + SRCS + "internal/hardening.cc" DEPS absl::config absl::core_headers
diff --git a/absl/base/internal/hardening.cc b/absl/base/internal/hardening.cc new file mode 100644 index 0000000..9b11b99 --- /dev/null +++ b/absl/base/internal/hardening.cc
@@ -0,0 +1,34 @@ +// +// Copyright 2026 The Abseil Authors. +// +// Licensed 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 +// +// https://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 "absl/base/internal/hardening.h" + +#include <atomic> + +#include "absl/base/config.h" +#include "absl/base/macros.h" + +namespace absl { +ABSL_NAMESPACE_BEGIN + +namespace base_internal { + +void SetAbslHardeningEnabled([[maybe_unused]] bool enabled) { +} + +} // namespace base_internal + +ABSL_NAMESPACE_END +} // namespace absl
diff --git a/absl/base/internal/hardening.h b/absl/base/internal/hardening.h index 188c8f3..fc86621 100644 --- a/absl/base/internal/hardening.h +++ b/absl/base/internal/hardening.h
@@ -32,6 +32,8 @@ namespace base_internal { +void SetAbslHardeningEnabled(bool enabled); + // `HardeningAssert` performs runtime checks when Abseil Hardening is enabled, // even if `NDEBUG` is defined. //
diff --git a/absl/base/internal/hardening_test.cc b/absl/base/internal/hardening_test.cc index cffa87c..f819331 100644 --- a/absl/base/internal/hardening_test.cc +++ b/absl/base/internal/hardening_test.cc
@@ -42,14 +42,28 @@ return hardened; } -TEST(HardeningTest, HardeningAssertSlow) { +class HardeningTest : public testing::Test { + public: + ~HardeningTest() override { + absl::base_internal::SetAbslHardeningEnabled(true); + } +}; + +class HardeningDeathTest : public testing::Test { + public: + ~HardeningDeathTest() override { + absl::base_internal::SetAbslHardeningEnabled(true); + } +}; + +TEST_F(HardeningTest, HardeningAssertSlow) { absl::base_internal::HardeningAssertSlow(true); if (!IsHardenedSlow()) { absl::base_internal::HardeningAssertSlow(false); } } -TEST(HardeningDeathTest, HardeningAssertSlow) { +TEST_F(HardeningDeathTest, HardeningAssertSlow) { #if GTEST_HAS_DEATH_TEST if (IsHardenedSlow()) { // The underlying mechanism of termination varies, and may include SIGILL @@ -59,107 +73,114 @@ #endif } -TEST(HardeningTest, HardeningAssertGT) { +TEST_F(HardeningTest, HardeningAssertGT) { absl::base_internal::HardeningAssertGT(1, 0); } -TEST(HardeningDeathTest, HardeningAssertGT) { +TEST_F(HardeningDeathTest, HardeningAssertGT) { #if GTEST_HAS_DEATH_TEST if (IsHardened()) { // The underlying mechanism of termination varies, and may include SIGILL // or SIGABRT. + absl::base_internal::SetAbslHardeningEnabled(true); EXPECT_DEATH(absl::base_internal::HardeningAssertGT(1, 1), ""); EXPECT_DEATH(absl::base_internal::HardeningAssertGT(0, 1), ""); } #endif } -TEST(HardeningTest, HardeningAssertGE) { +TEST_F(HardeningTest, HardeningAssertGE) { absl::base_internal::HardeningAssertGE(1, 0); absl::base_internal::HardeningAssertGE(1, 1); } -TEST(HardeningDeathTest, HardeningAssertGE) { +TEST_F(HardeningDeathTest, HardeningAssertGE) { #if GTEST_HAS_DEATH_TEST if (IsHardened()) { // The underlying mechanism of termination varies, and may include SIGILL // or SIGABRT. + absl::base_internal::SetAbslHardeningEnabled(true); EXPECT_DEATH(absl::base_internal::HardeningAssertGE(0, 1), ""); } #endif } -TEST(HardeningTest, HardeningAssertLT) { +TEST_F(HardeningTest, HardeningAssertLT) { absl::base_internal::HardeningAssertLT(0, 1); } -TEST(HardeningDeathTest, HardeningAssertLT) { +TEST_F(HardeningDeathTest, HardeningAssertLT) { #if GTEST_HAS_DEATH_TEST if (IsHardened()) { // The underlying mechanism of termination varies, and may include SIGILL // or SIGABRT. + absl::base_internal::SetAbslHardeningEnabled(true); EXPECT_DEATH(absl::base_internal::HardeningAssertLT(1, 1), ""); EXPECT_DEATH(absl::base_internal::HardeningAssertLT(1, 0), ""); } #endif } -TEST(HardeningTest, HardeningAssertLE) { +TEST_F(HardeningTest, HardeningAssertLE) { absl::base_internal::HardeningAssertLE(0, 1); absl::base_internal::HardeningAssertLE(1, 1); } -TEST(HardeningDeathTest, HardeningAssertLE) { +TEST_F(HardeningDeathTest, HardeningAssertLE) { #if GTEST_HAS_DEATH_TEST if (IsHardened()) { // The underlying mechanism of termination varies, and may include SIGILL // or SIGABRT. + absl::base_internal::SetAbslHardeningEnabled(true); EXPECT_DEATH(absl::base_internal::HardeningAssertLE(1, 0), ""); } #endif } -TEST(HardeningTest, HardeningAssertInBounds) { +TEST_F(HardeningTest, HardeningAssertInBounds) { absl::base_internal::HardeningAssertInBounds(0, 10); } -TEST(HardeningDeathTest, HardeningAssertInBounds) { +TEST_F(HardeningDeathTest, HardeningAssertInBounds) { #if GTEST_HAS_DEATH_TEST if (IsHardened()) { // The underlying mechanism of termination varies, and may include SIGILL // or SIGABRT. + absl::base_internal::SetAbslHardeningEnabled(true); EXPECT_DEATH(absl::base_internal::HardeningAssertInBounds(10, 10), ""); } #endif } -TEST(HardeningTest, HardeningAssertNonEmpty) { +TEST_F(HardeningTest, HardeningAssertNonEmpty) { std::vector<int> v = {1}; absl::base_internal::HardeningAssertNonEmpty(v); } -TEST(HardeningDeathTest, HardeningAssertNonEmpty) { +TEST_F(HardeningDeathTest, HardeningAssertNonEmpty) { #if GTEST_HAS_DEATH_TEST if (IsHardened()) { // The underlying mechanism of termination varies, and may include SIGILL // or SIGABRT. std::vector<int> v = {}; + absl::base_internal::SetAbslHardeningEnabled(true); EXPECT_DEATH(absl::base_internal::HardeningAssertNonEmpty(v), ""); } #endif } -TEST(HardeningTest, HardeningAssertNonNull) { +TEST_F(HardeningTest, HardeningAssertNonNull) { int x = 1; absl::base_internal::HardeningAssertNonNull(&x); } -TEST(HardeningDeathTest, HardeningAssertNonNull) { +TEST_F(HardeningDeathTest, HardeningAssertNonNull) { #if GTEST_HAS_DEATH_TEST if (IsHardened()) { // The underlying mechanism of termination varies, and may include SIGILL // or SIGABRT. int *x = nullptr; + absl::base_internal::SetAbslHardeningEnabled(true); EXPECT_DEATH(absl::base_internal::HardeningAssertNonNull(x), ""); } #endif
diff --git a/absl/base/macros.h b/absl/base/macros.h index f57643a..bfb6402 100644 --- a/absl/base/macros.h +++ b/absl/base/macros.h
@@ -28,6 +28,7 @@ #ifndef ABSL_BASE_MACROS_H_ #define ABSL_BASE_MACROS_H_ +#include <atomic> #include <cassert> #include <cstddef> @@ -157,12 +158,12 @@ // See `ABSL_OPTION_HARDENED` in `absl/base/options.h` for more information on // hardened mode. #if (ABSL_OPTION_HARDENED == 1 || ABSL_OPTION_HARDENED == 2) && defined(NDEBUG) -#define ABSL_HARDENING_ASSERT(expr) \ - do { \ - if (!ABSL_PREDICT_TRUE((expr))) { \ - ABSL_INTERNAL_HARDENING_ABORT(); \ - } \ - } while (false) + #define ABSL_HARDENING_ASSERT(expr) \ + do { \ + if (!ABSL_PREDICT_TRUE((expr))) { \ + ABSL_INTERNAL_HARDENING_ABORT(); \ + } \ + } while (false) #else #define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr) #endif