3 files changed, 92 insertions, 2 deletions
diff --git a/absl/memory/memory.h b/absl/memory/memory.h
index cd818cff4ffa..c43e156682fd 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 <typename ForwardIt>
+void DefaultConstruct(ForwardIt it) {
+  using value_type = typename std::iterator_traits<ForwardIt>::value_type;
+  ::new (static_cast<void*>(std::addressof(*it))) value_type;
+}  // namespace memory_internal
+
+#ifdef ABSL_HAVE_EXCEPTIONS
+template <typename ForwardIt, typename Size>
+void uninitialized_default_construct_n(ForwardIt first, Size size) {
+  for (ForwardIt cur = first; size > 0; static_cast<void>(++cur), --size) {
+    try {
+      absl::memory_internal::DefaultConstruct(cur);
+    } catch (...) {
+      using value_type = typename std::iterator_traits<ForwardIt>::value_type;
+      for (; first != cur; ++first) {
+        first->~value_type();
+      }
+      throw;
+    }
+  }
+}
+#else   // ABSL_HAVE_EXCEPTIONS
+template <typename ForwardIt, typename Size>
+void uninitialized_default_construct_n(ForwardIt first, Size size) {
+  for (; size > 0; static_cast<void>(++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 55e8f36f2feb..fb8b561d59fb 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<testing::TypeSpec::kEverythingThrows>;
+using ThrowerStorage =
+    absl::aligned_storage_t<sizeof(Thrower), alignof(Thrower)>;
+using ThrowerList = std::array<ThrowerStorage, kLength>;
 
 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 dee9b486a30d..8ff1945debe5 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<UnspecifiedAllocator>::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<TestObj>::value, "");
+  static_assert(absl::is_trivially_destructible<TestObj>::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<TestObj>::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