Use __builtin_operator_new to faciliate compiler optimizations of these allocs.

PiperOrigin-RevId: 818685458

Author: ckennelly

src/google/protobuf/arena.h

@@ -760,14 +760,6 @@ class PROTOBUF_EXPORT PROTOBUF_ALIGNAS(8)
 template <typename T>
 PROTOBUF_NOINLINE void* PROTOBUF_NONNULL
 Arena::DefaultConstruct(Arena* PROTOBUF_NULLABLE arena) {
-  auto operator_new = [](size_t size) -> void* {
-#if ABSL_HAVE_BUILTIN(__builtin_operator_new)
-    return __builtin_operator_new(size);
-#else
-    return ::operator new(size);
-#endif
-  };
-
   if constexpr (internal::FieldHasArenaOffset<T>()) {
     if (arena != nullptr) {
       using ArenaRepT = typename internal::FieldArenaRep<T>::Type;
@@ -781,12 +773,12 @@ Arena::DefaultConstruct(Arena* PROTOBUF_NULLABLE arena) {
       // Fields which use arena offsets don't have constructors that take an
       // arena pointer. Since the arena is nullptr, it is safe to default
       // construct the object.
-      return new (operator_new(sizeof(T))) T();
+      return new (internal::Allocate(sizeof(T))) T();
     }
   } else {
     static_assert(is_destructor_skippable<T>::value);
     void* mem = arena != nullptr ? arena->AllocateAligned(sizeof(T))
-                                 : operator_new(sizeof(T));
+                                 : internal::Allocate(sizeof(T));
     if constexpr (internal::HasDeprecatedArenaConstructor<T>()) {
       return new (mem) T(internal::InternalVisibility(), arena);
     } else {
@@ -818,11 +810,7 @@ PROTOBUF_NOINLINE void* PROTOBUF_NONNULL Arena::CopyConstruct(
   if (arena != nullptr) {
     mem = arena->AllocateAligned(sizeof(T));
   } else {
-#if ABSL_HAVE_BUILTIN(__builtin_operator_new)
-    mem = __builtin_operator_new(sizeof(T));
-#else
-    mem = ::operator new(sizeof(T));
-#endif
+    mem = internal::Allocate(sizeof(T));
   }
   return new (mem) T(arena, *typed_from);
 }

src/google/protobuf/descriptor.cc

@@ -2288,7 +2288,7 @@ Type* DescriptorPool::Tables::Allocate() {
 
 void* DescriptorPool::Tables::AllocateBytes(int size) {
   if (size == 0) return nullptr;
-  void* p = ::operator new(size + RoundUpTo<8>(sizeof(int)));
+  void* p = internal::Allocate(size + RoundUpTo<8>(sizeof(int)));
   int* sizep = static_cast<int*>(p);
   misc_allocs_.emplace_back(sizep);
   *sizep = size;
@@ -2305,7 +2305,7 @@ internal::FlatAllocator::Allocation* DescriptorPool::Tables::CreateFlatAlloc(
       typename std::tuple_element<sizeof...(T) - 1, std::tuple<T...>>::type>();
   size_t total_size =
       last_end + RoundUpTo<FlatAlloc::kMaxAlign>(sizeof(FlatAlloc));
-  char* data = static_cast<char*>(::operator new(total_size));
+  char* data = static_cast<char*>(internal::Allocate(total_size));
   auto* res = ::new (data) FlatAlloc(ends);
   flat_allocs_.emplace_back(res);
 

src/google/protobuf/descriptor_database.cc

@@ -600,7 +600,7 @@ bool EncodedDescriptorDatabase::Add(
 
 bool EncodedDescriptorDatabase::AddCopy(
     const void* PROTOBUF_NONNULL encoded_file_descriptor, int size) {
-  void* copy = operator new(size);
+  void* copy = internal::Allocate(size);
   memcpy(copy, encoded_file_descriptor, size);
   files_to_delete_.push_back(copy);
   return Add(copy, size);

src/google/protobuf/dynamic_message.cc

@@ -986,7 +986,7 @@ const Message* DynamicMessageFactory::GetPrototypeNoLock(
   // Construct the reflection object.
 
   // Allocate the prototype fields.
-  void* base = operator new(size);
+  void* base = internal::Allocate(size);
   memset(base, 0, size);
 
   // We have already locked the factory so we should not lock in the constructor

src/google/protobuf/generated_message_reflection.cc

@@ -3067,7 +3067,7 @@ void Reflection::PrepareSplitMessageForWrite(Message* message) const {
   if (*split == default_split) {
     uint32_t size = schema_.SizeofSplit();
     Arena* arena = message->GetArena();
-    *split = (arena == nullptr) ? ::operator new(size)
+    *split = (arena == nullptr) ? internal::Allocate(size)
                                 : arena->AllocateAligned(size);
     memcpy(*split, default_split, size);
   }
@@ -3831,7 +3831,7 @@ const internal::TcParseTableBase* Reflection::CreateTcParseTable() const {
       sizeof(TcParseTableBase::FieldAux) * table_info.aux_entries.size() +
       sizeof(char) * table_info.field_name_data.size();
 
-  void* p = ::operator new(byte_size);
+  void* p = internal::Allocate(byte_size);
   auto* res = ::new (p) TcParseTableBase{
       static_cast<uint16_t>(schema_.HasHasbits() ? schema_.HasBitsOffset() : 0),
       schema_.HasExtensionSet()

src/google/protobuf/generated_message_tctable_lite.cc

@@ -2042,8 +2042,8 @@ void* TcParser::MaybeGetSplitBase(MessageLite* msg, const bool is_split,
       // Allocate split instance when needed.
       uint32_t size = GetSizeofSplit(table);
       Arena* arena = msg->GetArena();
-      split = (arena == nullptr) ? ::operator new(size)
-                                 : arena->AllocateAligned(size);
+      split =
+          (arena == nullptr) ? Allocate(size) : arena->AllocateAligned(size);
       memcpy(split, default_split, size);
     }
     out = split;

src/google/protobuf/map.h

@@ -452,7 +452,7 @@ class PROTOBUF_EXPORT UntypedMapBase {
 
   NodeBase* AllocNode(size_t node_size) {
     return static_cast<NodeBase*>(arena_ == nullptr
-                                      ? ::operator new(node_size)
+                                      ? Allocate(node_size)
                                       : arena_->AllocateAligned(node_size));
   }
 
@@ -476,7 +476,7 @@ class PROTOBUF_EXPORT UntypedMapBase {
     ABSL_DCHECK_EQ(n & (n - 1), 0u);
     NodeBase** result =
         arena_ == nullptr
-            ? static_cast<NodeBase**>(::operator new(n * sizeof(NodeBase*)))
+            ? static_cast<NodeBase**>(Allocate(n * sizeof(NodeBase*)))
             : Arena::CreateArray<NodeBase*>(arena_, n);
     memset(result, 0, n * sizeof(result[0]));
     return result;

src/google/protobuf/message.cc

@@ -245,7 +245,7 @@ void* CreateSplitMessageGeneric(Arena* arena, const void* default_split,
                                 const void* default_message) {
   ABSL_DCHECK_NE(message, default_message);
   void* split =
-      (arena == nullptr) ? ::operator new(size) : arena->AllocateAligned(size);
+      (arena == nullptr) ? Allocate(size) : arena->AllocateAligned(size);
   memcpy(split, default_split, size);
   return split;
 }

src/google/protobuf/message_lite.h

@@ -1450,13 +1450,7 @@ PROTOBUF_ALWAYS_INLINE MessageLite* MessageCreator::New(
   if (arena != nullptr) {
     mem = arena->AllocateAligned(allocation_size_);
   } else {
-#if ABSL_HAVE_BUILTIN(__builtin_operator_new)
-    // Allows the compiler to merge or optimize away the allocation even if it
-    // would violate the observability guarantees of ::operator new.
-    mem = __builtin_operator_new(allocation_size_);
-#else
-    mem = ::operator new(allocation_size_);
-#endif
+    mem = Allocate(allocation_size_);
   }
   return PlacementNew(prototype_for_func, prototype_for_copy, mem, arena);
 }

src/google/protobuf/port.h

@@ -134,6 +134,18 @@ inline void SetAllocateAtLeastHook(AllocateAtLeastHookFn fn, void* context) {}
 
 #endif  // !NDEBUG && ABSL_HAVE_THREAD_LOCAL && __cpp_inline_variables
 
+// Allocates `size` bytes. This wrapper allows memory allocations to be
+// optimized by the compiler since `operator new` is considered observable.
+inline void* Allocate(size_t size) {
+#if ABSL_HAVE_BUILTIN(__builtin_operator_new)
+  // Allows the compiler to merge or optimize away the allocation even if it
+  // would violate the observability guarantees of ::operator new.
+  return __builtin_operator_new(size);
+#else
+  return ::operator new(size);
+#endif
+}
+
 // Allocates at least `size` bytes. This function follows the c++ language
 // proposal from D0901R10 (http://wg21.link/D0901R10) and will be implemented
 // in terms of the new operator new semantics when available. The allocated
@@ -145,7 +157,7 @@ inline SizedPtr AllocateAtLeast(size_t size) {
     return allocate_at_least_hook(size, allocate_at_least_hook_context);
   }
 #endif  // !NDEBUG && ABSL_HAVE_THREAD_LOCAL && __cpp_inline_variables
-  return {::operator new(size), size};
+  return {Allocate(size), size};
 }
 
 inline void SizedDelete(void* p, size_t size) {