allocator: add use_experimental_allocator_shim build flag

third_party/tcmalloc/chromium/src/libc_override.h

 // Copyright (c) 2011, Google Inc.
 // All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
@@ skipping 41 matching lines @@
 #define TCMALLOC_LIBC_OVERRIDE_INL_H_
 
 #include <config.h>
 #ifdef HAVE_FEATURES_H
 #include <features.h>   // for __GLIBC__
 #endif
 #include <gperftools/tcmalloc.h>
 
 static void ReplaceSystemAlloc();  // defined in the .h files below
 
+#if defined(TCMALLOC_DONT_REPLACE_SYSTEM_ALLOC)
+// TCMALLOC_DONT_REPLACE_SYSTEM_ALLOC has the following semantic:
+//  - tcmalloc with all its tc_* (tc_malloc, tc_free) symbols is being built
+//    and linked as usual.
+//  - the default system allocator symbols (malloc, free, operator new) are NOT
+//    overridden. The embedded must take care of routing them to tc_* symbols.
+// This no-op #if block effectively prevents the inclusion of the
+// libc_override_* headers below.
+static void ReplaceSystemAlloc() {}

[Nico, 2016/02/09 20:14:23]

Which files include this? Defining static functions inline without marking them
inline generally isn't a good idea (yes, this file does this already) -- you'll
end up with one copy of the function in every TU including the header. This
should instead be marked inline, not static. (If the header needs to work in
both .c and .cc TUs, a little more work is needed.)

[Primiano Tucci (use gerrit), 2016/02/09 20:34:23]

So I think that the deal is that this header is a special snowflake and is not
really a header. This is meant to be included only once by tcmalloc.cc.
I think the only reason why this is a .h is because if you name it .cc and add
to the build files, it will be treated as a TU and built independently, which
you do NOT want here either, because this file requires to see the *definitions*
of the tc_* symbols from tcmalloc.cc .
In turn, the reason why this file needs to see the definitions is because of the
attribute(alias) black magic used by the includes below (see
override_gcc_and_weak as an example). attribute(alias) can be used only when the
definition is seen in the same TU.

In other words, this is really a part of tcmalloc.cc,
think to this as a C# .partial.cs file
My guess is that the original authors did split out this header for code
readability convenience (for some definition of "convenience" given the black
magic all around here)

+
 // For windows, there are two ways to get tcmalloc.  If we're
 // patching, then src/windows/patch_function.cc will do the necessary
 // overriding here.  Otherwise, we doing the 'redefine' trick, where
 // we remove malloc/new/etc from mscvcrt.dll, and just need to define
 // them now.
-#if defined(_WIN32) && defined(WIN32_DO_PATCHING)
+#elif defined(_WIN32) && defined(WIN32_DO_PATCHING)
 void PatchWindowsFunctions();   // in src/windows/patch_function.cc
 static void ReplaceSystemAlloc() { PatchWindowsFunctions(); }
 
 #elif defined(_WIN32) && !defined(WIN32_DO_PATCHING)
 // "libc_override_redefine.h" is included in the original gperftools.  But,
 // we define allocator functions in Chromium's base/allocator/allocator_shim.cc
 // on Windows.  We don't include libc_override_redefine.h here.
 // ReplaceSystemAlloc() is defined here instead.
 static void ReplaceSystemAlloc() { }
 
 #elif defined(__APPLE__)
 #include "libc_override_osx.h"
 
 #elif defined(__GLIBC__)
 #include "libc_override_glibc.h"
 
 // Not all gcc systems necessarily support weak symbols, but all the
 // ones I know of do, so for now just assume they all do.
 #elif defined(__GNUC__)
 #include "libc_override_gcc_and_weak.h"
 
 #else
 #error Need to add support for your libc/OS here
 
 #endif
 
 #endif  // TCMALLOC_LIBC_OVERRIDE_INL_H_