From 87a4c07856e7dc69958019d47b2f02ae47746ec0 Mon Sep 17 00:00:00 2001 From: Abseil Team Date: Mon, 25 Jun 2018 09:18:19 -0700 Subject: Export of internal Abseil changes. -- 8becce38c862a044db194a9aea1b505796a46d6f by Abseil Team : Updates the FixedArray's constructors to be exception safe by preventing double deletions. Also adds exception safety tests for FixedArray to document/enforce the expected behavior. PiperOrigin-RevId: 201964431 -- 794188b401a602b4be97190fb8738066fe1f9ca5 by Derek Mauro : Fixes for str_format.h documentation. PiperOrigin-RevId: 201951760 -- beae3bdd6eee2cf61101102fddc35ada188f330b by Alex Strelnikov : Add numeric_limits specialization for uint128. Turns out numeric_limits is a case where the consensus is that it is okay to specialize for a user defined type. PiperOrigin-RevId: 201944736 -- b2b3444a52b36878ade1ae8801e69932b05fc4f9 by Shaindel Schwartz : Internal change. PiperOrigin-RevId: 201718662 -- aa924c459922f39caabfc193998c58d0f4981ac0 by Abseil Team : Typo fix. PiperOrigin-RevId: 201692176 -- bbfcaa7b1af331d9b97c92470608240c5c864fbc by Xiaoyi Zhang : Use ABSL_HAVE_ANY/OPTIONAL/VARIANT to conditionally compile out the definition of absl::bad_any_cast, absl::bad_optional_access, absl::bad_variant_access. This would fix the issues where users #include those header directly in C++17 modes. PiperOrigin-RevId: 201683792 GitOrigin-RevId: 8becce38c862a044db194a9aea1b505796a46d6f Change-Id: I60a7ad043136a439d82c374d225a1804016b0509 --- absl/memory/memory.h | 33 ++++++++++++++++++++++ absl/memory/memory_exception_safety_test.cc | 18 ++++++++++-- absl/memory/memory_test.cc | 43 +++++++++++++++++++++++++++++ 3 files changed, 92 insertions(+), 2 deletions(-) (limited to 'absl/memory') diff --git a/absl/memory/memory.h b/absl/memory/memory.h index cd818cf..c43e156 100644 --- a/absl/memory/memory.h +++ b/absl/memory/memory.h @@ -636,6 +636,39 @@ struct default_allocator_is_nothrow : std::true_type {}; struct default_allocator_is_nothrow : std::false_type {}; #endif +namespace memory_internal { +// TODO(b110200014): Implement proper backports +template +void DefaultConstruct(ForwardIt it) { + using value_type = typename std::iterator_traits::value_type; + ::new (static_cast(std::addressof(*it))) value_type; +} // namespace memory_internal + +#ifdef ABSL_HAVE_EXCEPTIONS +template +void uninitialized_default_construct_n(ForwardIt first, Size size) { + for (ForwardIt cur = first; size > 0; static_cast(++cur), --size) { + try { + absl::memory_internal::DefaultConstruct(cur); + } catch (...) { + using value_type = typename std::iterator_traits::value_type; + for (; first != cur; ++first) { + first->~value_type(); + } + throw; + } + } +} +#else // ABSL_HAVE_EXCEPTIONS +template +void uninitialized_default_construct_n(ForwardIt first, Size size) { + for (; size > 0; static_cast(++first), --size) { + absl::memory_internal::DefaultConstruct(first); + } +} +#endif // ABSL_HAVE_EXCEPTIONS +} // namespace memory_internal + } // namespace absl #endif // ABSL_MEMORY_MEMORY_H_ diff --git a/absl/memory/memory_exception_safety_test.cc b/absl/memory/memory_exception_safety_test.cc index 55e8f36..fb8b561 100644 --- a/absl/memory/memory_exception_safety_test.cc +++ b/absl/memory/memory_exception_safety_test.cc @@ -20,11 +20,14 @@ namespace absl { namespace { -using Thrower = ::testing::ThrowingValue<>; +constexpr int kLength = 50; +using Thrower = testing::ThrowingValue; +using ThrowerStorage = + absl::aligned_storage_t; +using ThrowerList = std::array; TEST(MakeUnique, CheckForLeaks) { constexpr int kValue = 321; - constexpr size_t kLength = 10; auto tester = testing::MakeExceptionSafetyTester() .WithInitialValue(Thrower(kValue)) // Ensures make_unique does not modify the input. The real @@ -45,5 +48,16 @@ TEST(MakeUnique, CheckForLeaks) { })); } +TEST(MemoryInternal, UninitDefaultConstructNNonTrivial) { + EXPECT_TRUE(testing::MakeExceptionSafetyTester() + .WithInitialValue(ThrowerList{}) + .WithOperation([&](ThrowerList* list_ptr) { + absl::memory_internal::uninitialized_default_construct_n( + list_ptr->data(), kLength); + }) + .WithInvariants([&](...) { return true; }) + .Test()); +} + } // namespace } // namespace absl diff --git a/absl/memory/memory_test.cc b/absl/memory/memory_test.cc index dee9b48..8ff1945 100644 --- a/absl/memory/memory_test.cc +++ b/absl/memory/memory_test.cc @@ -611,4 +611,47 @@ TEST(AllocatorNoThrowTest, CustomAllocator) { EXPECT_FALSE(absl::allocator_is_nothrow::value); } +TEST(MemoryInternal, UninitDefaultConstructNTrivial) { + constexpr int kInitialValue = 123; + constexpr int kExpectedValue = kInitialValue; // Expect no-op behavior + constexpr int len = 5; + + struct TestObj { + int val; + }; + static_assert(absl::is_trivially_default_constructible::value, ""); + static_assert(absl::is_trivially_destructible::value, ""); + + TestObj objs[len]; + for (auto& obj : objs) { + obj.val = kInitialValue; + } + + absl::memory_internal::uninitialized_default_construct_n(objs, len); + for (auto& obj : objs) { + EXPECT_EQ(obj.val, kExpectedValue); + } +} + +TEST(MemoryInternal, UninitDefaultConstructNNonTrivial) { + constexpr int kInitialValue = 123; + constexpr int kExpectedValue = 0; // Expect value-construction behavior + constexpr int len = 5; + + struct TestObj { + int val{kExpectedValue}; + }; + static_assert(absl::is_trivially_destructible::value, ""); + + TestObj objs[len]; + for (auto& obj : objs) { + obj.val = kInitialValue; + } + + absl::memory_internal::uninitialized_default_construct_n(objs, len); + for (auto& obj : objs) { + EXPECT_EQ(obj.val, kExpectedValue); + } +} + } // namespace -- cgit v1.2.3