Inline deprecated functions.

PiperOrigin-RevId: 767700810
Change-Id: I5d767180367330276209042f80c984868cb427b2

Author: ckennelly

tcmalloc/testing/profile_drop_frames_test.cc

@@ -147,7 +147,7 @@ inline ABSL_ATTRIBUTE_ALWAYS_INLINE void* wrap_memalign(size_t size) {
 
 inline ABSL_ATTRIBUTE_ALWAYS_INLINE void* wrap_size_returning_operator_new(
     size_t size) {
-  return tcmalloc_size_returning_operator_new(size).p;
+  return __size_returning_new(size).p;
 }
 
 inline ABSL_ATTRIBUTE_ALWAYS_INLINE void*
@@ -157,9 +157,7 @@ wrap_size_returning_operator_new_nothrow(size_t size) {
 
 inline ABSL_ATTRIBUTE_ALWAYS_INLINE void*
 wrap_size_returning_operator_new_hot_cold(size_t size) {
-  return tcmalloc_size_returning_operator_new_hot_cold(size,
-                                                       tcmalloc::hot_cold_t(0))
-      .p;
+  return __size_returning_new_hot_cold(size, tcmalloc::hot_cold_t(0)).p;
 }
 
 inline ABSL_ATTRIBUTE_ALWAYS_INLINE void*
@@ -171,9 +169,7 @@ wrap_size_returning_operator_new_hot_cold_nothrow(size_t size) {
 
 inline ABSL_ATTRIBUTE_ALWAYS_INLINE void*
 wrap_size_returning_operator_new_aligned(size_t size) {
-  return tcmalloc_size_returning_operator_new_aligned(size,
-                                                      std::align_val_t(64))
-      .p;
+  return __size_returning_new_aligned(size, std::align_val_t(64)).p;
 }
 
 inline ABSL_ATTRIBUTE_ALWAYS_INLINE void*
@@ -185,8 +181,8 @@ wrap_size_returning_operator_new_aligned_nothrow(size_t size) {
 
 inline ABSL_ATTRIBUTE_ALWAYS_INLINE void*
 wrap_size_returning_operator_new_aligned_hot_cold(size_t size) {
-  return tcmalloc_size_returning_operator_new_aligned_hot_cold(
-             size, std::align_val_t(64), tcmalloc::hot_cold_t(0))
+  return __size_returning_new_aligned_hot_cold(size, std::align_val_t(64),
+                                               tcmalloc::hot_cold_t(0))
       .p;
 }
 

tcmalloc/testing/tcmalloc_test.cc

@@ -823,7 +823,7 @@ TEST(TCMallocTest, GetEstimatedAllocatedSizeHotCold) {
           MallocExtension::GetEstimatedAllocatedSize(size, hot_cold);
       ASSERT_GE(rounded, size);
       auto [ptr, allocated_size] =
-          tcmalloc_size_returning_operator_new_hot_cold(size, hot_cold);
+          __size_returning_new_hot_cold(size, hot_cold);
       ASSERT_EQ(rounded, allocated_size);
       free(ptr);
     }
@@ -1004,14 +1004,14 @@ class TcmallocSizedNewTest
         (align_needed << 2) | (hot_cold_needed << 1) | nothrow_needed;
     switch (encoding) {
       case 0b000:
-        sro_new_ = tcmalloc_size_returning_operator_new;
+        sro_new_ = __size_returning_new;
         break;
       case 0b001:
         sro_new_ = tcmalloc_size_returning_operator_new_nothrow;
         break;
       case 0b010:
         sro_new_ = [this](size_t size) {
-          return tcmalloc_size_returning_operator_new_hot_cold(size, hot_cold_);
+          return __size_returning_new_hot_cold(size, hot_cold_);
         };
         break;
       case 0b011:
@@ -1022,7 +1022,7 @@ class TcmallocSizedNewTest
         break;
       case 0b100:
         sro_new_ = [this](size_t size) {
-          return tcmalloc_size_returning_operator_new_aligned(size, align_);
+          return __size_returning_new_aligned(size, align_);
         };
         break;
       case 0b101:
@@ -1033,8 +1033,7 @@ class TcmallocSizedNewTest
         break;
       case 0b110:
         sro_new_ = [this](size_t size) {
-          return tcmalloc_size_returning_operator_new_aligned_hot_cold(
-              size, align_, hot_cold_);
+          return __size_returning_new_aligned_hot_cold(size, align_, hot_cold_);
         };
         break;
       case 0b111:
@@ -1162,7 +1161,7 @@ TEST(SizedDeleteTest, SizedOperatorDelete) {
   enum DeleteSize { kSize, kCapacity, kHalfway };
   for (size_t size = 0; size < kMaxSize; ++size) {
     for (auto delete_size : {kSize, kCapacity, kHalfway}) {
-      sized_ptr_t res = tcmalloc_size_returning_operator_new(size);
+      sized_ptr_t res = __size_returning_new(size);
       switch (delete_size) {
         case kSize:
           ::operator delete(res.p, size);
@@ -1471,7 +1470,7 @@ TEST(HotColdTest, SizeReturningHotColdNew) {
     const size_t requested = absl::LogUniform<size_t>(rng, kSmall, kLarge);
     const uint8_t label = absl::Uniform<uint8_t>(rng, 0, 255);
 
-    auto [ptr, actual] = tcmalloc_size_returning_operator_new_hot_cold(
+    auto [ptr, actual] = __size_returning_new_hot_cold(
         requested, static_cast<hot_cold_t>(label));
     ASSERT_GE(actual, requested);
 
@@ -1619,10 +1618,10 @@ TEST(MallocExtension, SizeReturningNewAndSizedDelete) {
   ScopedGuardedSamplingInterval gs(-1);
 
   for (int i = 0; i < 100; ++i) {
-    tcmalloc::sized_ptr_t sized_ptr = tcmalloc_size_returning_operator_new(i);
+    tcmalloc::sized_ptr_t sized_ptr = __size_returning_new(i);
     ::operator delete(sized_ptr.p, sized_ptr.n);
     for (int j = i, end = sized_ptr.n; j < end; ++j) {
-      sized_ptr = tcmalloc_size_returning_operator_new(i);
+      sized_ptr = __size_returning_new(i);
       EXPECT_EQ(end, sized_ptr.n) << i << "," << j;
       ::operator delete(sized_ptr.p, j);
     }