diff --git a/src/google/protobuf/BUILD.bazel b/src/google/protobuf/BUILD.bazel
index b776c81..42388e4 100644
--- a/src/google/protobuf/BUILD.bazel
+++ b/src/google/protobuf/BUILD.bazel
@@ -557,6 +557,7 @@
         "@abseil-cpp//absl/container:layout",
         "@abseil-cpp//absl/log:absl_check",
         "@abseil-cpp//absl/log:absl_log",
+        "@abseil-cpp//absl/meta:type_traits",
         "@abseil-cpp//absl/numeric:bits",
         "@abseil-cpp//absl/synchronization",
         "@abseil-cpp//absl/types:span",
diff --git a/src/google/protobuf/arena.h b/src/google/protobuf/arena.h
index 3ed71de..5884a9a 100644
--- a/src/google/protobuf/arena.h
+++ b/src/google/protobuf/arena.h
@@ -19,6 +19,9 @@
 #include <type_traits>
 #include <utility>
 #include <vector>
+
+#include "absl/base/macros.h"
+#include "absl/meta/type_traits.h"
 #if defined(_MSC_VER) && !defined(_LIBCPP_STD_VER) && !_HAS_EXCEPTIONS
 // Work around bugs in MSVC <typeinfo> header when _HAS_EXCEPTIONS=0.
 #include <exception>
@@ -78,6 +81,12 @@
 class GenericTypeHandler;  // defined in repeated_field.h
 
 template <typename T>
+struct IsRepeatedPtrFieldType;  // defined in repeated_ptr_field.h
+
+template <typename T>
+struct RepeatedPtrFieldArenaRep;  // defined in repeated_ptr_field.h
+
+template <typename T>
 void arena_delete_object(void* PROTOBUF_NONNULL object) {
   delete reinterpret_cast<T*>(object);
 }
@@ -222,7 +231,12 @@
           return static_cast<Type*>(CopyConstruct<Type>(arena, &args...));
         }
       }
-      return CreateArenaCompatible<Type>(arena, std::forward<Args>(args)...);
+      if constexpr (internal::IsRepeatedPtrFieldType<Type>::value) {
+        return CreateRepeatedPtrFieldWithArena<Type>(
+            arena, std::forward<Args>(args)...);
+      } else {
+        return CreateArenaCompatible<Type>(arena, std::forward<Args>(args)...);
+      }
     } else {
       if (ABSL_PREDICT_FALSE(arena == nullptr)) {
         return new T(std::forward<Args>(args)...);
@@ -431,11 +445,24 @@
     static T* PROTOBUF_NONNULL Construct(void* PROTOBUF_NONNULL ptr,
                                          Arena* PROTOBUF_NULLABLE arena,
                                          Args&&... args) {
-      return new (ptr) T(arena, static_cast<Args&&>(args)...);
+      if constexpr (internal::IsRepeatedPtrFieldType<T>::value) {
+        using ArenaRepT = typename internal::RepeatedPtrFieldArenaRep<T>::Type;
+        auto* arena_repr =
+            new (ptr) ArenaRepT(arena, static_cast<Args&&>(args)...);
+        return arena_repr;
+      } else {
+        return new (ptr) T(arena, static_cast<Args&&>(args)...);
+      }
     }
 
     static PROTOBUF_ALWAYS_INLINE T* PROTOBUF_NONNULL New() {
-      return new T(nullptr);
+      // Repeated pointer fields no longer have an arena constructor, so
+      // specialize calling their default constructor.
+      if constexpr (internal::IsRepeatedPtrFieldType<T>::value) {
+        return new T();
+      } else {
+        return new T(nullptr);
+      }
     }
 
     friend class Arena;
@@ -517,6 +544,25 @@
     }
   }
 
+  template <typename T, typename... Args>
+  PROTOBUF_NDEBUG_INLINE static T* PROTOBUF_NONNULL
+  CreateRepeatedPtrFieldWithArena(Arena* PROTOBUF_NULLABLE arena,
+                                  Args&&... args) {
+    static_assert(is_arena_constructable<T>::value,
+                  "Can only construct types that are ArenaConstructable");
+    static_assert(internal::IsRepeatedPtrFieldType<T>::value,
+                  "Can only construct repeated pointer fields with "
+                  "CreateRepeatedPtrFieldWithArena");
+    if (ABSL_PREDICT_FALSE(arena == nullptr)) {
+      return new T(static_cast<Args&&>(args)...);
+    } else {
+      using ArenaRepT = typename internal::RepeatedPtrFieldArenaRep<T>::Type;
+      auto* arena_repr =
+          arena->DoCreateMessage<ArenaRepT>(static_cast<Args&&>(args)...);
+      return arena_repr;
+    }
+  }
+
   // This specialization for no arguments is necessary, because its behavior is
   // slightly different.  When the arena pointer is nullptr, it calls T()
   // instead of T(nullptr).
diff --git a/src/google/protobuf/repeated_ptr_field.h b/src/google/protobuf/repeated_ptr_field.h
index 5bf3aaf..952751f 100644
--- a/src/google/protobuf/repeated_ptr_field.h
+++ b/src/google/protobuf/repeated_ptr_field.h
@@ -586,6 +586,8 @@
   using InternalArenaConstructable_ = void;
   using DestructorSkippable_ = void;
 
+  friend google::protobuf::Arena;
+
   template <typename T>
   friend class Arena::InternalHelper;
 
@@ -953,6 +955,49 @@
 };
 
 
+template <typename T>
+struct IsRepeatedPtrFieldType {
+  static constexpr bool value = false;
+};
+
+template <>
+struct IsRepeatedPtrFieldType<RepeatedPtrFieldBase> {
+  static constexpr bool value = true;
+};
+
+template <typename Element>
+struct IsRepeatedPtrFieldType<RepeatedPtrField<Element>> {
+  static constexpr bool value = true;
+};
+
+// This class maps RepeatedPtrField(Base)? types to the types that we will use
+// to represent them when allocated on an arena. This is necessary because
+// `RepeatedPtrField`s do not own an arena pointer, but can be allocated
+// directly on an arena. In this case, we will use a wrapper class that holds
+// both the arena pointer and the repeated field, and points the repeated field
+// to the arena pointer.
+//
+// Additionally, split repeated pointer fields will use this representation when
+// allocated, regardless of whether they are on an arena or not.
+template <typename T>
+struct RepeatedPtrFieldArenaRep {};
+
+template <>
+struct RepeatedPtrFieldArenaRep<RepeatedPtrFieldBase> {
+  // TODO - With removed arena pointers, we will need a class that
+  // holds both the arena pointer and the repeated field, and points the
+  // repeated to the arena pointer.
+  using Type = RepeatedPtrFieldBase;
+};
+
+template <typename Element>
+struct RepeatedPtrFieldArenaRep<RepeatedPtrField<Element>> {
+  // TODO - With removed arena pointers, we will need a class that
+  // holds both the arena pointer and the repeated field, and points the
+  // repeated to the arena pointer.
+  using Type = RepeatedPtrField<Element>;
+};
+
 }  // namespace internal
 
 // RepeatedPtrField is like RepeatedField, but used for repeated strings or