Changes imported from Abseil "staging" branch:

  - 5923451fb3b082e8bedb800cb676378b0f52d651 Remove internal-only deprecated APIs. by Daniel Katz <katzdm@google.com>
  - c715bf6e5533a9a5d827e806ccd6e8ee68ad2a53 Small fix for comment in span.h by Abseil Team <absl-team@google.com>
  - ef89cc8dac0631b4ad3499d1f0883670b43567df Rename an internal detail to de-conflict with a badly-nam... by Abseil Team <absl-team@google.com>
  - b53761a945ffdab39d5340904ca822571672f11a Remove base/internal/log_severity.cc, which is omitted fr... by Abseil Team <absl-team@google.com>
  - 56685b1852840d3838e24d83849d56644949e9b7 Reimplementing MallocHook such that the C API wraps the C... by Abseil Team <absl-team@google.com>

GitOrigin-RevId: 5923451fb3b082e8bedb800cb676378b0f52d651
Change-Id: I9b854d46b57990c9a10971391d762b280488bcee

6 files changed, 100 insertions, 329 deletions

diff --git a/absl/base/internal/log_severity.cc b/absl/base/internal/log_severity.cc
deleted file mode 100644
index 430ac45848a0..000000000000
--- a/absl/base/internal/log_severity.cc
+++ /dev/null
@@ -1,15 +0,0 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "absl/base/internal/log_severity.h"
diff --git a/absl/base/internal/malloc_extension.cc b/absl/base/internal/malloc_extension.cc
index d48ec5bcf548..5b90653360aa 100644
--- a/absl/base/internal/malloc_extension.cc
+++ b/absl/base/internal/malloc_extension.cc
@@ -20,7 +20,6 @@
 #include <string>
 
 #include "absl/base/dynamic_annotations.h"
-#include "absl/base/internal/malloc_extension_c.h"
 
 namespace absl {
 namespace base_internal {
@@ -155,44 +154,6 @@ void MallocExtension::GetFragmentationProfile(MallocExtensionWriter*) {}
 }  // namespace base_internal
 }  // namespace absl
 
-// These are C shims that work on the current instance.
-
-#define C_SHIM(fn, retval, paramlist, arglist)                           \
-  extern "C" retval MallocExtension_##fn paramlist {                     \
-    return absl::base_internal::MallocExtension::instance()->fn arglist; \
-  }
-
-C_SHIM(VerifyAllMemory, int, (void), ());
-C_SHIM(VerifyNewMemory, int, (const void* p), (p));
-C_SHIM(VerifyArrayNewMemory, int, (const void* p), (p));
-C_SHIM(VerifyMallocMemory, int, (const void* p), (p));
-C_SHIM(
-    MallocMemoryStats, int,
-    (int* blocks, size_t* total,
-     int histogram[absl::base_internal::MallocExtension::kMallocHistogramSize]),
-    (blocks, total, histogram));
-
-C_SHIM(GetStats, void,
-       (char* buffer, int buffer_length), (buffer, buffer_length));
-C_SHIM(GetNumericProperty, int,
-       (const char* property, size_t* value), (property, value));
-C_SHIM(SetNumericProperty, int,
-       (const char* property, size_t value), (property, value));
-
-C_SHIM(MarkThreadIdle, void, (void), ());
-C_SHIM(MarkThreadBusy, void, (void), ());
-C_SHIM(ReleaseFreeMemory, void, (void), ());
-C_SHIM(ReleaseToSystem, void, (size_t num_bytes), (num_bytes));
-C_SHIM(GetEstimatedAllocatedSize, size_t, (size_t size), (size));
-C_SHIM(GetAllocatedSize, size_t, (const void* p), (p));
-
-// Can't use the shim here because of the need to translate the enums.
-extern "C"
-MallocExtension_Ownership MallocExtension_GetOwnership(const void* p) {
-  return static_cast<MallocExtension_Ownership>(
-      absl::base_internal::MallocExtension::instance()->GetOwnership(p));
-}
-
 // Default implementation just returns size. The expectation is that
 // the linked-in malloc implementation might provide an override of
 // this weak function with a better implementation.
diff --git a/absl/base/internal/malloc_extension_test.cc b/absl/base/internal/malloc_extension_test.cc
index 246875a030ef..76605eb19936 100644
--- a/absl/base/internal/malloc_extension_test.cc
+++ b/absl/base/internal/malloc_extension_test.cc
@@ -19,7 +19,6 @@
 
 #include "gtest/gtest.h"
 #include "absl/base/internal/malloc_extension.h"
-#include "absl/base/internal/malloc_extension_c.h"
 
 namespace absl {
 namespace base_internal {
@@ -35,15 +34,12 @@ TEST(MallocExtension, MallocExtension) {
   } else {
     ASSERT_TRUE(MallocExtension::instance()->GetNumericProperty(
         "generic.current_allocated_bytes", &cxx_bytes_used));
-    ASSERT_TRUE(MallocExtension_GetNumericProperty(
-        "generic.current_allocated_bytes", &c_bytes_used));
 #ifndef MEMORY_SANITIZER
     EXPECT_GT(cxx_bytes_used, 1000);
     EXPECT_GT(c_bytes_used, 1000);
 #endif
 
     EXPECT_TRUE(MallocExtension::instance()->VerifyAllMemory());
-    EXPECT_TRUE(MallocExtension_VerifyAllMemory());
 
     EXPECT_EQ(MallocExtension::kOwned,
               MallocExtension::instance()->GetOwnership(a));
@@ -65,30 +61,11 @@ TEST(MallocExtension, MallocExtension) {
                 MallocExtension::instance()->GetEstimatedAllocatedSize(i));
       free(p);
     }
-
-    // Check the c-shim version too.
-    EXPECT_EQ(MallocExtension_kOwned, MallocExtension_GetOwnership(a));
-    EXPECT_EQ(MallocExtension_kNotOwned,
-              MallocExtension_GetOwnership(&cxx_bytes_used));
-    EXPECT_EQ(MallocExtension_kNotOwned, MallocExtension_GetOwnership(nullptr));
-    EXPECT_GE(MallocExtension_GetAllocatedSize(a), 1000);
-    EXPECT_LE(MallocExtension_GetAllocatedSize(a), 5000);
-    EXPECT_GE(MallocExtension_GetEstimatedAllocatedSize(1000), 1000);
   }
 
   free(a);
 }
 
-// Verify that the .cc file and .h file have the same enum values.
-TEST(GetOwnership, EnumValuesEqualForCAndCXX) {
-  EXPECT_EQ(static_cast<int>(MallocExtension::kUnknownOwnership),
-            static_cast<int>(MallocExtension_kUnknownOwnership));
-  EXPECT_EQ(static_cast<int>(MallocExtension::kOwned),
-            static_cast<int>(MallocExtension_kOwned));
-  EXPECT_EQ(static_cast<int>(MallocExtension::kNotOwned),
-            static_cast<int>(MallocExtension_kNotOwned));
-}
-
 TEST(nallocx, SaneBehavior) {
   for (size_t size = 0; size < 64 * 1024; ++size) {
     size_t alloc_size = nallocx(size, 0);
diff --git a/absl/base/internal/malloc_hook.cc b/absl/base/internal/malloc_hook.cc
index 52531c680148..780e8fe3296c 100644
--- a/absl/base/internal/malloc_hook.cc
+++ b/absl/base/internal/malloc_hook.cc
@@ -215,139 +215,101 @@ HookList<MallocHook::MunmapReplacement> munmap_replacement_ = INIT_HOOK_LIST;
 #undef INIT_HOOK_LIST_WITH_VALUE
 #undef INIT_HOOK_LIST
 
-}  // namespace base_internal
-}  // namespace absl
+bool MallocHook::AddNewHook(NewHook hook) { return new_hooks_.Add(hook); }
 
-// These are available as C bindings as well as C++, hence their
-// definition outside the MallocHook class.
-extern "C"
-int MallocHook_AddNewHook(MallocHook_NewHook hook) {
-  return absl::base_internal::new_hooks_.Add(hook);
-}
-
-extern "C"
-int MallocHook_RemoveNewHook(MallocHook_NewHook hook) {
-  return absl::base_internal::new_hooks_.Remove(hook);
-}
+bool MallocHook::RemoveNewHook(NewHook hook) { return new_hooks_.Remove(hook); }
 
-extern "C"
-int MallocHook_AddDeleteHook(MallocHook_DeleteHook hook) {
-  return absl::base_internal::delete_hooks_.Add(hook);
+bool MallocHook::AddDeleteHook(DeleteHook hook) {
+  return delete_hooks_.Add(hook);
 }
 
-extern "C"
-int MallocHook_RemoveDeleteHook(MallocHook_DeleteHook hook) {
-  return absl::base_internal::delete_hooks_.Remove(hook);
+bool MallocHook::RemoveDeleteHook(DeleteHook hook) {
+  return delete_hooks_.Remove(hook);
 }
 
-extern "C" int MallocHook_AddSampledNewHook(MallocHook_SampledNewHook hook) {
-  return absl::base_internal::sampled_new_hooks_.Add(hook);
+bool MallocHook::AddSampledNewHook(SampledNewHook hook) {
+  return sampled_new_hooks_.Add(hook);
 }
 
-extern "C" int MallocHook_RemoveSampledNewHook(MallocHook_SampledNewHook hook) {
-  return absl::base_internal::sampled_new_hooks_.Remove(hook);
+bool MallocHook::RemoveSampledNewHook(SampledNewHook hook) {
+  return sampled_new_hooks_.Remove(hook);
 }
 
-extern "C" int MallocHook_AddSampledDeleteHook(
-    MallocHook_SampledDeleteHook hook) {
-  return absl::base_internal::sampled_delete_hooks_.Add(hook);
+bool MallocHook::AddSampledDeleteHook(SampledDeleteHook hook) {
+  return sampled_delete_hooks_.Add(hook);
 }
 
-extern "C" int MallocHook_RemoveSampledDeleteHook(
-    MallocHook_SampledDeleteHook hook) {
-  return absl::base_internal::sampled_delete_hooks_.Remove(hook);
+bool MallocHook::RemoveSampledDeleteHook(SampledDeleteHook hook) {
+  return sampled_delete_hooks_.Remove(hook);
 }
 
-extern "C"
-int MallocHook_AddPreMmapHook(MallocHook_PreMmapHook hook) {
-  return absl::base_internal::premmap_hooks_.Add(hook);
+bool MallocHook::AddPreMmapHook(PreMmapHook hook) {
+  return premmap_hooks_.Add(hook);
 }
 
-extern "C"
-int MallocHook_RemovePreMmapHook(MallocHook_PreMmapHook hook) {
-  return absl::base_internal::premmap_hooks_.Remove(hook);
+bool MallocHook::RemovePreMmapHook(PreMmapHook hook) {
+  return premmap_hooks_.Remove(hook);
 }
 
-extern "C"
-int MallocHook_SetMmapReplacement(MallocHook_MmapReplacement hook) {
+bool MallocHook::SetMmapReplacement(MmapReplacement hook) {
   // NOTE this is a best effort CHECK. Concurrent sets could succeed since
   // this test is outside of the Add spin lock.
-  ABSL_RAW_CHECK(absl::base_internal::mmap_replacement_.empty(),
+  ABSL_RAW_CHECK(mmap_replacement_.empty(),
                  "Only one MMapReplacement is allowed.");
-  return absl::base_internal::mmap_replacement_.Add(hook);
-}
-
-extern "C"
-int MallocHook_RemoveMmapReplacement(MallocHook_MmapReplacement hook) {
-  return absl::base_internal::mmap_replacement_.Remove(hook);
-}
-
-extern "C"
-int MallocHook_AddMmapHook(MallocHook_MmapHook hook) {
-  return absl::base_internal::mmap_hooks_.Add(hook);
+  return mmap_replacement_.Add(hook);
 }
 
-extern "C"
-int MallocHook_RemoveMmapHook(MallocHook_MmapHook hook) {
-  return absl::base_internal::mmap_hooks_.Remove(hook);
+bool MallocHook::RemoveMmapReplacement(MmapReplacement hook) {
+  return mmap_replacement_.Remove(hook);
 }
 
-extern "C"
-int MallocHook_AddMunmapHook(MallocHook_MunmapHook hook) {
-  return absl::base_internal::munmap_hooks_.Add(hook);
-}
+bool MallocHook::AddMmapHook(MmapHook hook) { return mmap_hooks_.Add(hook); }
 
-extern "C"
-int MallocHook_RemoveMunmapHook(MallocHook_MunmapHook hook) {
-  return absl::base_internal::munmap_hooks_.Remove(hook);
+bool MallocHook::RemoveMmapHook(MmapHook hook) {
+  return mmap_hooks_.Remove(hook);
 }
 
-extern "C"
-int MallocHook_SetMunmapReplacement(MallocHook_MunmapReplacement hook) {
+bool MallocHook::SetMunmapReplacement(MunmapReplacement hook) {
   // NOTE this is a best effort CHECK. Concurrent sets could succeed since
   // this test is outside of the Add spin lock.
-  ABSL_RAW_CHECK(absl::base_internal::munmap_replacement_.empty(),
+  ABSL_RAW_CHECK(munmap_replacement_.empty(),
                  "Only one MunmapReplacement is allowed.");
-  return absl::base_internal::munmap_replacement_.Add(hook);
+  return munmap_replacement_.Add(hook);
 }
 
-extern "C"
-int MallocHook_RemoveMunmapReplacement(MallocHook_MunmapReplacement hook) {
-  return absl::base_internal::munmap_replacement_.Remove(hook);
+bool MallocHook::RemoveMunmapReplacement(MunmapReplacement hook) {
+  return munmap_replacement_.Remove(hook);
 }
 
-extern "C"
-int MallocHook_AddMremapHook(MallocHook_MremapHook hook) {
-  return absl::base_internal::mremap_hooks_.Add(hook);
+bool MallocHook::AddMunmapHook(MunmapHook hook) {
+  return munmap_hooks_.Add(hook);
 }
 
-extern "C"
-int MallocHook_RemoveMremapHook(MallocHook_MremapHook hook) {
-  return absl::base_internal::mremap_hooks_.Remove(hook);
+bool MallocHook::RemoveMunmapHook(MunmapHook hook) {
+  return munmap_hooks_.Remove(hook);
 }
 
-extern "C"
-int MallocHook_AddPreSbrkHook(MallocHook_PreSbrkHook hook) {
-  return absl::base_internal::presbrk_hooks_.Add(hook);
+bool MallocHook::AddMremapHook(MremapHook hook) {
+  return mremap_hooks_.Add(hook);
 }
 
-extern "C"
-int MallocHook_RemovePreSbrkHook(MallocHook_PreSbrkHook hook) {
-  return absl::base_internal::presbrk_hooks_.Remove(hook);
+bool MallocHook::RemoveMremapHook(MremapHook hook) {
+  return mremap_hooks_.Remove(hook);
 }
 
-extern "C"
-int MallocHook_AddSbrkHook(MallocHook_SbrkHook hook) {
-  return absl::base_internal::sbrk_hooks_.Add(hook);
+bool MallocHook::AddPreSbrkHook(PreSbrkHook hook) {
+  return presbrk_hooks_.Add(hook);
 }
 
-extern "C"
-int MallocHook_RemoveSbrkHook(MallocHook_SbrkHook hook) {
-  return absl::base_internal::sbrk_hooks_.Remove(hook);
+bool MallocHook::RemovePreSbrkHook(PreSbrkHook hook) {
+  return presbrk_hooks_.Remove(hook);
 }
 
-namespace absl {
-namespace base_internal {
+bool MallocHook::AddSbrkHook(SbrkHook hook) { return sbrk_hooks_.Add(hook); }
+
+bool MallocHook::RemoveSbrkHook(SbrkHook hook) {
+  return sbrk_hooks_.Remove(hook);
+}
 
 // Note: embedding the function calls inside the traversal of HookList would be
 // very confusing, as it is legal for a hook to remove itself and add other
@@ -501,12 +463,11 @@ static void InitializeInHookCaller() {
   ABSL_INIT_ATTRIBUTE_SECTION_VARS(blink_malloc);
 }
 
-// We can improve behavior/compactness of this function
-// if we pass a generic test function (with a generic arg)
-// into the implementations for get_stack_trace_fn instead of the skip_count.
-extern "C" int MallocHook_GetCallerStackTrace(
-    void** result, int max_depth, int skip_count,
-    MallocHook_GetStackTraceFn get_stack_trace_fn) {
+namespace absl {
+namespace base_internal {
+int MallocHook::GetCallerStackTrace(void** result, int max_depth,
+                                    int skip_count,
+                                    GetStackTraceFn get_stack_trace_fn) {
   if (!ABSL_HAVE_ATTRIBUTE_SECTION) {
     // Fall back to get_stack_trace_fn and good old but fragile frame skip
     // counts.
@@ -524,11 +485,11 @@ extern "C" int MallocHook_GetCallerStackTrace(
   absl::call_once(in_hook_caller_once, InitializeInHookCaller);
   // MallocHook caller determination via InHookCaller works, use it:
   static const int kMaxSkip = 32 + 6 + 3;
-    // Constant tuned to do just one get_stack_trace_fn call below in practice
-    // and not get many frames that we don't actually need:
-    // currently max passed max_depth is 32,
-    // max passed/needed skip_count is 6
-    // and 3 is to account for some hook daisy chaining.
+  // Constant tuned to do just one get_stack_trace_fn call below in practice
+  // and not get many frames that we don't actually need:
+  // currently max passed max_depth is 32,
+  // max passed/needed skip_count is 6
+  // and 3 is to account for some hook daisy chaining.
   static const int kStackSize = kMaxSkip + 1;
   void* stack[kStackSize];
   int depth =
@@ -538,11 +499,11 @@ extern "C" int MallocHook_GetCallerStackTrace(
     return 0;
   for (int i = depth - 1; i >= 0; --i) {  // stack[0] is our immediate caller
     if (InHookCaller(stack[i])) {
-      i += 1;  // skip hook caller frame
+      i += 1;      // skip hook caller frame
       depth -= i;  // correct depth
       if (depth > max_depth) depth = max_depth;
       std::copy(stack + i, stack + i + depth, result);
-      if (depth < max_depth  &&  depth + i == kStackSize) {
+      if (depth < max_depth && depth + i == kStackSize) {
         // get frames for the missing depth
         depth += get_stack_trace_fn(result + depth, max_depth - depth,
                                     1 + kStackSize);
@@ -558,6 +519,8 @@ extern "C" int MallocHook_GetCallerStackTrace(
   // all functions in that section must be inside the same library.
   return 0;
 }
+}  // namespace base_internal
+}  // namespace absl
 
 // On systems where we know how, we override mmap/munmap/mremap/sbrk
 // to provide support for calling the related hooks (in addition,
diff --git a/absl/base/internal/malloc_hook.h b/absl/base/internal/malloc_hook.h
index ed5cf2e65dd6..7c1eaddb70ec 100644
--- a/absl/base/internal/malloc_hook.h
+++ b/absl/base/internal/malloc_hook.h
@@ -74,24 +74,16 @@ class MallocHook {
   // Object pointer and size are passed in.
   // It may be passed null pointer if the allocator returned null.
   typedef MallocHook_NewHook NewHook;
-  inline static bool AddNewHook(NewHook hook) {
-    return MallocHook_AddNewHook(hook);
-  }
-  inline static bool RemoveNewHook(NewHook hook) {
-    return MallocHook_RemoveNewHook(hook);
-  }
+  static bool AddNewHook(NewHook hook);
+  static bool RemoveNewHook(NewHook hook);
   inline static void InvokeNewHook(const void* ptr, size_t size);
 
   // The DeleteHook is invoked whenever an object is being deallocated.
   // Object pointer is passed in.
   // It may be passed null pointer if the caller is trying to delete null.
   typedef MallocHook_DeleteHook DeleteHook;
-  inline static bool AddDeleteHook(DeleteHook hook) {
-    return MallocHook_AddDeleteHook(hook);
-  }
-  inline static bool RemoveDeleteHook(DeleteHook hook) {
-    return MallocHook_RemoveDeleteHook(hook);
-  }
+  static bool AddDeleteHook(DeleteHook hook);
+  static bool RemoveDeleteHook(DeleteHook hook);
   inline static void InvokeDeleteHook(const void* ptr);
 
   // The SampledNewHook is invoked for some subset of object allocations
@@ -107,12 +99,8 @@ class MallocHook {
   // call InvokeSampledDeleteHook() with that value.
   typedef MallocHook_SampledNewHook SampledNewHook;
   typedef MallocHook_SampledAlloc SampledAlloc;
-  inline static bool AddSampledNewHook(SampledNewHook hook) {
-    return MallocHook_AddSampledNewHook(hook);
-  }
-  inline static bool RemoveSampledNewHook(SampledNewHook hook) {
-    return MallocHook_RemoveSampledNewHook(hook);
-  }
+  static bool AddSampledNewHook(SampledNewHook hook);
+  static bool RemoveSampledNewHook(SampledNewHook hook);
   inline static void InvokeSampledNewHook(const SampledAlloc* sampled_alloc);
 
   // The SampledDeleteHook is invoked whenever an object previously chosen
@@ -121,12 +109,8 @@ class MallocHook {
   // InvokeSampledNewHook()-- is passed in.
   typedef MallocHook_SampledDeleteHook SampledDeleteHook;
   typedef MallocHook_AllocHandle AllocHandle;
-  inline static bool AddSampledDeleteHook(SampledDeleteHook hook) {
-    return MallocHook_AddSampledDeleteHook(hook);
-  }
-  inline static bool RemoveSampledDeleteHook(SampledDeleteHook hook) {
-    return MallocHook_RemoveSampledDeleteHook(hook);
-  }
+  static bool AddSampledDeleteHook(SampledDeleteHook hook);
+  static bool RemoveSampledDeleteHook(SampledDeleteHook hook);
   inline static void InvokeSampledDeleteHook(AllocHandle handle);
 
   // The PreMmapHook is invoked with mmap's or mmap64's arguments just
@@ -134,12 +118,8 @@ class MallocHook {
   // in memory limited contexts, to catch allocations that will exceed
   // a memory limit, and take outside actions to increase that limit.
   typedef MallocHook_PreMmapHook PreMmapHook;
-  inline static bool AddPreMmapHook(PreMmapHook hook) {
-    return MallocHook_AddPreMmapHook(hook);
-  }
-  inline static bool RemovePreMmapHook(PreMmapHook hook) {
-    return MallocHook_RemovePreMmapHook(hook);
-  }
+  static bool AddPreMmapHook(PreMmapHook hook);
+  static bool RemovePreMmapHook(PreMmapHook hook);
   inline static void InvokePreMmapHook(const void* start,
                                        size_t size,
                                        int protection,
@@ -159,12 +139,8 @@ class MallocHook {
   // you must call RemoveMmapReplacement before calling SetMmapReplacement
   // again.
   typedef MallocHook_MmapReplacement MmapReplacement;
-  inline static bool SetMmapReplacement(MmapReplacement hook) {
-    return MallocHook_SetMmapReplacement(hook);
-  }
-  inline static bool RemoveMmapReplacement(MmapReplacement hook) {
-    return MallocHook_RemoveMmapReplacement(hook);
-  }
+  static bool SetMmapReplacement(MmapReplacement hook);
+  static bool RemoveMmapReplacement(MmapReplacement hook);
   inline static bool InvokeMmapReplacement(const void* start,
                                            size_t size,
                                            int protection,
@@ -178,12 +154,8 @@ class MallocHook {
   // a region of memory has been just mapped.
   // It may be passed MAP_FAILED if the mmap failed.
   typedef MallocHook_MmapHook MmapHook;
-  inline static bool AddMmapHook(MmapHook hook) {
-    return MallocHook_AddMmapHook(hook);
-  }
-  inline static bool RemoveMmapHook(MmapHook hook) {
-    return MallocHook_RemoveMmapHook(hook);
-  }
+  static bool AddMmapHook(MmapHook hook);
+  static bool RemoveMmapHook(MmapHook hook);
   inline static void InvokeMmapHook(const void* result,
                                     const void* start,
                                     size_t size,
@@ -202,12 +174,8 @@ class MallocHook {
   // MunmapReplacement you must call RemoveMunmapReplacement before
   // calling SetMunmapReplacement again.
   typedef MallocHook_MunmapReplacement MunmapReplacement;
-  inline static bool SetMunmapReplacement(MunmapReplacement hook) {
-    return MallocHook_SetMunmapReplacement(hook);
-  }
-  inline static bool RemoveMunmapReplacement(MunmapReplacement hook) {
-    return MallocHook_RemoveMunmapReplacement(hook);
-  }
+  static bool SetMunmapReplacement(MunmapReplacement hook);
+  static bool RemoveMunmapReplacement(MunmapReplacement hook);
   inline static bool InvokeMunmapReplacement(const void* start,
                                              size_t size,
                                              int* result);
@@ -217,23 +185,15 @@ class MallocHook {
   // TODO(maxim): Rename this to PreMunmapHook for consistency with PreMmapHook
   // and PreSbrkHook.
   typedef MallocHook_MunmapHook MunmapHook;
-  inline static bool AddMunmapHook(MunmapHook hook) {
-    return MallocHook_AddMunmapHook(hook);
-  }
-  inline static bool RemoveMunmapHook(MunmapHook hook) {
-    return MallocHook_RemoveMunmapHook(hook);
-  }
+  static bool AddMunmapHook(MunmapHook hook);
+  static bool RemoveMunmapHook(MunmapHook hook);
   inline static void InvokeMunmapHook(const void* start, size_t size);
 
   // The MremapHook is invoked with mremap's return value and arguments
   // whenever a region of memory has been just remapped.
   typedef MallocHook_MremapHook MremapHook;
-  inline static bool AddMremapHook(MremapHook hook) {
-    return MallocHook_AddMremapHook(hook);
-  }
-  inline static bool RemoveMremapHook(MremapHook hook) {
-    return MallocHook_RemoveMremapHook(hook);
-  }
+  static bool AddMremapHook(MremapHook hook);
+  static bool RemoveMremapHook(MremapHook hook);
   inline static void InvokeMremapHook(const void* result,
                                       const void* old_addr,
                                       size_t old_size,
@@ -248,12 +208,8 @@ class MallocHook {
   // to catch allocations that will exceed the limit and take outside
   // actions to increase such a limit.
   typedef MallocHook_PreSbrkHook PreSbrkHook;
-  inline static bool AddPreSbrkHook(PreSbrkHook hook) {
-    return MallocHook_AddPreSbrkHook(hook);
-  }
-  inline static bool RemovePreSbrkHook(PreSbrkHook hook) {
-    return MallocHook_RemovePreSbrkHook(hook);
-  }
+  static bool AddPreSbrkHook(PreSbrkHook hook);
+  static bool RemovePreSbrkHook(PreSbrkHook hook);
   inline static void InvokePreSbrkHook(ptrdiff_t increment);
 
   // The SbrkHook is invoked with sbrk's result and argument whenever sbrk
@@ -261,12 +217,8 @@ class MallocHook {
   // This is because sbrk(0) is often called to get the top of the memory stack,
   // and is not actually a memory-allocation call.
   typedef MallocHook_SbrkHook SbrkHook;
-  inline static bool AddSbrkHook(SbrkHook hook) {
-    return MallocHook_AddSbrkHook(hook);
-  }
-  inline static bool RemoveSbrkHook(SbrkHook hook) {
-    return MallocHook_RemoveSbrkHook(hook);
-  }
+  static bool AddSbrkHook(SbrkHook hook);
+  static bool RemoveSbrkHook(SbrkHook hook);
   inline static void InvokeSbrkHook(const void* result, ptrdiff_t increment);
 
   // Pointer to a absl::GetStackTrace implementation, following the API in
@@ -280,12 +232,8 @@ class MallocHook {
   // is not available.
   // Stack trace is filled into *result up to the size of max_depth.
   // The actual number of stack frames filled is returned.
-  inline static int GetCallerStackTrace(void** result, int max_depth,
-                                        int skip_count,
-                                        GetStackTraceFn get_stack_trace_fn) {
-    return MallocHook_GetCallerStackTrace(result, max_depth, skip_count,
-                                          get_stack_trace_fn);
-  }
+  static int GetCallerStackTrace(void** result, int max_depth, int skip_count,
+                                 GetStackTraceFn get_stack_trace_fn);
 
 #if ABSL_HAVE_MMAP
   // Unhooked versions of mmap() and munmap().   These should be used
diff --git a/absl/base/internal/malloc_hook_c.h b/absl/base/internal/malloc_hook_c.h
index 03b84ca627d2..ed41143a2020 100644
--- a/absl/base/internal/malloc_hook_c.h
+++ b/absl/base/internal/malloc_hook_c.h
@@ -29,28 +29,9 @@
 extern "C" {
 #endif  /* __cplusplus */
 
-/* Get the current stack trace.  Try to skip all routines up to and
- * including the caller of MallocHook::Invoke*.
- * Use "skip_count" (similarly to absl::GetStackTrace from stacktrace.h)
- * as a hint about how many routines to skip if better information
- * is not available.
- */
 typedef int (*MallocHook_GetStackTraceFn)(void**, int, int);
-int MallocHook_GetCallerStackTrace(void** result, int max_depth, int skip_count,
-                                   MallocHook_GetStackTraceFn fn);
-
-/* All the MallocHook_{Add,Remove}*Hook functions below return 1 on success
- * and 0 on failure.
- */
-
 typedef void (*MallocHook_NewHook)(const void* ptr, size_t size);
-int MallocHook_AddNewHook(MallocHook_NewHook hook);
-int MallocHook_RemoveNewHook(MallocHook_NewHook hook);
-
 typedef void (*MallocHook_DeleteHook)(const void* ptr);
-int MallocHook_AddDeleteHook(MallocHook_DeleteHook hook);
-int MallocHook_RemoveDeleteHook(MallocHook_DeleteHook hook);
-
 typedef int64_t MallocHook_AllocHandle;
 typedef struct {
   /* See malloc_hook.h  for documentation for this struct. */
@@ -61,68 +42,24 @@ typedef struct {
 } MallocHook_SampledAlloc;
 typedef void (*MallocHook_SampledNewHook)(
     const MallocHook_SampledAlloc* sampled_alloc);
-int MallocHook_AddSampledNewHook(MallocHook_SampledNewHook hook);
-int MallocHook_RemoveSampledNewHook(MallocHook_SampledNewHook hook);
-
 typedef void (*MallocHook_SampledDeleteHook)(MallocHook_AllocHandle handle);
-int MallocHook_AddSampledDeleteHook(MallocHook_SampledDeleteHook hook);
-int MallocHook_RemoveSampledDeleteHook(MallocHook_SampledDeleteHook hook);
-
-typedef void (*MallocHook_PreMmapHook)(const void *start,
-                                       size_t size,
-                                       int protection,
-                                       int flags,
-                                       int fd,
+typedef void (*MallocHook_PreMmapHook)(const void* start, size_t size,
+                                       int protection, int flags, int fd,
                                        off_t offset);
-int MallocHook_AddPreMmapHook(MallocHook_PreMmapHook hook);
-int MallocHook_RemovePreMmapHook(MallocHook_PreMmapHook hook);
-
-typedef void (*MallocHook_MmapHook)(const void* result,
-                                    const void* start,
-                                    size_t size,
-                                    int protection,
-                                    int flags,
-                                    int fd,
-                                    off_t offset);
-int MallocHook_AddMmapHook(MallocHook_MmapHook hook);
-int MallocHook_RemoveMmapHook(MallocHook_MmapHook hook);
-
-typedef int (*MallocHook_MmapReplacement)(const void* start,
-                                          size_t size,
-                                          int protection,
-                                          int flags,
-                                          int fd,
-                                          off_t offset,
-                                          void** result);
-int MallocHook_SetMmapReplacement(MallocHook_MmapReplacement hook);
-int MallocHook_RemoveMmapReplacement(MallocHook_MmapReplacement hook);
-
+typedef void (*MallocHook_MmapHook)(const void* result, const void* start,
+                                    size_t size, int protection, int flags,
+                                    int fd, off_t offset);
+typedef int (*MallocHook_MmapReplacement)(const void* start, size_t size,
+                                          int protection, int flags, int fd,
+                                          off_t offset, void** result);
 typedef void (*MallocHook_MunmapHook)(const void* start, size_t size);
-int MallocHook_AddMunmapHook(MallocHook_MunmapHook hook);
-int MallocHook_RemoveMunmapHook(MallocHook_MunmapHook hook);
-
-typedef int (*MallocHook_MunmapReplacement)(const void* start,
-                                            size_t size,
+typedef int (*MallocHook_MunmapReplacement)(const void* start, size_t size,
                                             int* result);
-int MallocHook_SetMunmapReplacement(MallocHook_MunmapReplacement hook);
-int MallocHook_RemoveMunmapReplacement(MallocHook_MunmapReplacement hook);
-
-typedef void (*MallocHook_MremapHook)(const void* result,
-                                      const void* old_addr,
-                                      size_t old_size,
-                                      size_t new_size,
-                                      int flags,
-                                      const void* new_addr);
-int MallocHook_AddMremapHook(MallocHook_MremapHook hook);
-int MallocHook_RemoveMremapHook(MallocHook_MremapHook hook);
-
+typedef void (*MallocHook_MremapHook)(const void* result, const void* old_addr,
+                                      size_t old_size, size_t new_size,
+                                      int flags, const void* new_addr);
 typedef void (*MallocHook_PreSbrkHook)(ptrdiff_t increment);
-int MallocHook_AddPreSbrkHook(MallocHook_PreSbrkHook hook);
-int MallocHook_RemovePreSbrkHook(MallocHook_PreSbrkHook hook);
-
 typedef void (*MallocHook_SbrkHook)(const void* result, ptrdiff_t increment);
-int MallocHook_AddSbrkHook(MallocHook_SbrkHook hook);
-int MallocHook_RemoveSbrkHook(MallocHook_SbrkHook hook);
 
 #ifdef __cplusplus
 }  /* extern "C" */