Stop intercepting mallinfo and mallopt on FreeBSD

[dim]

Summary

In https://bugs.freebsd.org/215125 I was notified that some configure
scripts attempt to test for the Linux-specific mallinfo and mallopt
functions by compiling and linking small programs which references the
functions, and observing whether that results in errors.

On FreeBSD there are neither mallinfo nor mallopt functions, so
normally these tests would fail, but when sanitizers are enabled, they
incorrectly succeed, because the sanitizers define interceptors for
these functions.

Fix this by not intercepting mallinfo and mallopt for FreeBSD, in
all of the sanitizers.

[kcc]

Please add a test.
I wonder if it's possible to have fewer ifdefs?

lib/asan/asan_malloc_linux.cc

117 ↗

(On Diff #81002)

Not like this.
Please add
#define SANITIZER_INTERCEPT_MALLOPT_AND_MALLINFO (!SANITIZER_FREEBSD)
to lib/sanitizer_common/sanitizer_platform_interceptors.h
then use it here.

[dim]

In D27654#620145, @kcc wrote:

Please add a test.

Hm, what kind of test did you have in mind? It is not useful to test for mallinfo() or mallopt() on FreeBSD, since they never existed in the first place.

I wonder if it's possible to have fewer ifdefs?

I don't think so, because the symbols should not be defined at all by the sanitizer on FreeBSD. If we just add empty wrappers, those will still be picked up by the linker.

Basically the #if statements would now refer to SANITIZER_INTERCEPT_MALLOPT_AND_MALLINFO.

[kcc]

a test would be FreeBSD-specific and it would verify that mallinfo/mallopt are not present.

also, please add coments after #ifdef

#ifdef // SANITIZER_INTERCEPT_MALLOPT_AND_MALLINFO

[dim]

First round of changes, no specific test yet, only the adding of
SANITIZER_INTERCEPT_MALLOPT_AND_MALLINFO.

[dim]

Rebase.

[dim]

Add a very simple XFAIL testcase for FreeBSD. I am unsure on how to
test for 'negative' results, ocurring on specific OSes, so this is the
only thing I could come up with. The test case should link fine on
Linux, as far as I can see. Suggestions for improvements welcome! :)

[dim]

@kcc is this OK now? I'd like to commit a similar fix to FreeBSD's copy of compiler-rt, but I'd rather use the same one as submitted here. :)

[dim]

Ping.

[kcc]

test/asan/TestCases/mallinfo-mallopt.cpp

4 ↗

(On Diff #81888)

hm. is freebsd the only platform where this will fail?
What about other non-linux OSes?

[joerg]

I'm not sure if any platform beside glibc supports mallinfo/mallopt.

[dim]

test/asan/TestCases/mallinfo-mallopt.cpp

4 ↗

(On Diff #81888)

Indeed, probably better to make this test succeed on Linux only. Is there any way to express XFAIL: !linux ?

[dim]

Rebased again.

[dim]

I'd like to commit this now so it ends up in 4.0.0. Any other suggestions?

[joerg]

test/asan/TestCases/mallinfo-mallopt.cpp

7 ↗

(On Diff #83560)

Can you make those proper protypes?

4 ↗

(On Diff #81888)

My suggestion would be to do conditionalize the main function, i.e.

#if __glibc__
  mallinfo();
  mallopt();
#else
  void non_existant_function(void);
  non_existant_function();
#endif

and just check for linking error on all platforms.

[dim]

test/asan/TestCases/mallinfo-mallopt.cpp

7 ↗

(On Diff #83560)

This is not what autoconf is doing, which was the original inspiration for this change. Autoconf always uses function declarations without any parameters, and I was mimicking what they are doing.

4 ↗

(On Diff #81888)

Actually, the error we're checking for is that mallinfo() and mallopt() are *not* incorrectly intercepted. So we have to specifically attempt to link these functions in, and see if those don't cause any error, and if they don't, there is a regression.

[joerg]

test/asan/TestCases/mallinfo-mallopt.cpp

7 ↗

(On Diff #83560)

Yeah, but that part is one of the design flaws in autoconf. I guess the problem is that declaring mallinfo correctly would need the content of the struct, so that's kind of not possible in a good way without depending on the header.

4 ↗

(On Diff #81888)

Sorry, inverted condition. I meant '#if !glibc'. That should make it clearer. My point is to link against something explicitly undefined for glibc and just make sure that it always fails that way.

[dim]

test/asan/TestCases/mallinfo-mallopt.cpp

7 ↗

(On Diff #83560)

Indeed, I find autoconf's style ugly too, but this avoids having to include any headers.

4 ↗

(On Diff #81888)

Ah yes, I see what you mean.

[dim]

test/asan/TestCases/mallinfo-mallopt.cpp

4 ↗

(On Diff #81888)

Hm, though glibc is only defined by including one of the glibc headers, I assume? I'll have to look it up on a Linux system.

[dim]

• Test that mallinfo() and mallopt() cause link failures on non-glibc platforms
• Use nonexistent function names on glibc platforms, to also cause link failures
• XFAIL on all platforms
• Use proper prototypes

[dim]

• Stop intercepting more functions that don't exist on FreeBSD/Mac: cfree, memalign, pvalloc
• Use macros similar to TSan for InitializeInterceptors to reduce #ifdef soup
• Handle all not-to-be intercepted functions with individual compile/link invocations

[joerg]

Test case looks good now. Should the *.h definitions use GLIBC or at least LINUX_NOT_ANDROID too?

[dim]

In D27654#645143, @joerg wrote:

Test case looks good now. Should the *.h definitions use GLIBC or at least LINUX_NOT_ANDROID too?

You mean in sanitizer_platform_interceptors.h? I am unsure what Android supports, so I want to leave that to somebody else with knowledge of that platform. The definitions I added just try to follow the style in the rest of sanitizer_platform_interceptors.h.

Additionally, I think __GLIBC__ is only defined when you include certain glibc headers, and I think sanitizer_platform_interceptors.h wants to avoid including any standard headers.

[dim]

Ping? I'd really like to get this into 4.0.0, if at all possible. @hans I think there is still time enough now, right?

[kcc]

LGTM, assuming tests pass on other platforms (please check at least one other platform, then watch the bots after commit)

[dim]

It's pretty weird, on Ubuntu, the lsan changes make exactly one lsan test case fail, with:

FAIL: LeakSanitizer-Standalone-x86_64 :: TestCases/use_tls_dynamic.cc (30686 of 31782)
******************** TEST 'LeakSanitizer-Standalone-x86_64 :: TestCases/use_tls_dynamic.cc' FAILED ********************
Script:
--
LSAN_BASE="report_objects=1:use_stacks=0:use_registers=0:use_ld_allocations=0"
/home/ubuntu/obj/llvm-293332-trunk-linux4-x86_64-ninja-rel-1/./bin/clang --driver-mode=g++ -O0 -m64 -gline-tables-only /home/ubuntu/src/llvm/trunk/projects/compiler-rt/test/lsan/TestCases/use_tls_dynamic.cc -DBUILD_DSO -fPIC -shared -o /home/ubuntu/obj/llvm-293332-trunk-linux4-x86_64-ninja-rel-1/projects/compiler-rt/test/lsan/X86_64LsanConfig/TestCases/Output/use_tls_dynamic.cc.tmp-so.so
/home/ubuntu/obj/llvm-293332-trunk-linux4-x86_64-ninja-rel-1/./bin/clang --driver-mode=g++ -O0 -m64 -gline-tables-only -fsanitize=leak -I/home/ubuntu/src/llvm/trunk/projects/compiler-rt/test/lsan/../ /home/ubuntu/src/llvm/trunk/projects/compiler-rt/test/lsan/TestCases/use_tls_dynamic.cc -o /home/ubuntu/obj/llvm-293332-trunk-linux4-x86_64-ninja-rel-1/projects/compiler-rt/test/lsan/X86_64LsanConfig/TestCases/Output/use_tls_dynamic.cc.tmp
LSAN_OPTIONS=$LSAN_BASE:"use_tls=0" not  /home/ubuntu/obj/llvm-293332-trunk-linux4-x86_64-ninja-rel-1/projects/compiler-rt/test/lsan/X86_64LsanConfig/TestCases/Output/use_tls_dynamic.cc.tmp 2>&1 | FileCheck /home/ubuntu/src/llvm/trunk/projects/compiler-rt/test/lsan/TestCases/use_tls_dynamic.cc
LSAN_OPTIONS=$LSAN_BASE:"use_tls=1"  /home/ubuntu/obj/llvm-293332-trunk-linux4-x86_64-ninja-rel-1/projects/compiler-rt/test/lsan/X86_64LsanConfig/TestCases/Output/use_tls_dynamic.cc.tmp 2>&1
LSAN_OPTIONS=""  /home/ubuntu/obj/llvm-293332-trunk-linux4-x86_64-ninja-rel-1/projects/compiler-rt/test/lsan/X86_64LsanConfig/TestCases/Output/use_tls_dynamic.cc.tmp 2>&1
--
Exit Code: 23

Command Output (stdout):
--
Test alloc: 0x61a000000600

=================================================================
==7609==ERROR: LeakSanitizer: detected memory leaks

Direct leak of 1337 byte(s) in 1 object(s) allocated from:
    #0 0x424445 in __interceptor_malloc /home/ubuntu/src/llvm/trunk/projects/compiler-rt/lib/lsan/lsan_interceptors.cc:55:3
    #1 0x425db5 in main /home/ubuntu/src/llvm/trunk/projects/compiler-rt/test/lsan/TestCases/use_tls_dynamic.cc:26:13
    #2 0x7f8d7020182f in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x2082f)

Objects leaked above:
0x61a000000600 (1337 bytes)

SUMMARY: LeakSanitizer: 1337 byte(s) leaked in 1 allocation(s).

--

I'm not completely clear on what is going wrong here... Maybe some interceptors get incorrectly disabled on Linux? And this causes a leak?

[dim]

Updated to include sanitizer_platform_interceptors.h in lsan_interceptors.cc, so it correctly picks up the SANITIZER_INTERCEPT_xxx defines.

Tested on FreeBSD and Ubuntu.

[kcc]

LGTM, please watch the bots

[hans]

In D27654#659137, @dim wrote:

Ping? I'd really like to get this into 4.0.0, if at all possible. @hans I think there is still time enough now, right?

Yes. I see this just landed. Let me know when it's been exercised by the bots again.

[eugenis]

This broke windows: http://lab.llvm.org:8011/builders/sanitizer-windows/builds/5305

[dim]

In D27654#659353, @eugenis wrote:

This broke windows: http://lab.llvm.org:8011/builders/sanitizer-windows/builds/5305

Ugh, apparently not does not work on Windows, or at least not the way I would expect it to:

FAIL: AddressSanitizer-i386-windows :: TestCases/malloc-no-intercept.c (502 of 562)
******************** TEST 'AddressSanitizer-i386-windows :: TestCases/malloc-no-intercept.c' FAILED ********************
Script:
--
not   C:/b/slave/sanitizer-windows/build/./bin/clang.exe -fsanitize=address -mno-omit-leaf-frame-pointer -fno-omit-frame-pointer -fno-optimize-sibling-calls -gline-tables-only -gcodeview  -fms-compatibility-version=19.00.24215.1 -Dtestfunc=mallinfo C:\b\slave\sanitizer-windows\llvm\projects\compiler-rt\test\asan\TestCases\malloc-no-intercept.c -o C:\b\slave\sanitizer-windows\build\projects\compiler-rt\test\asan\I386WindowsConfig\TestCases\Output\malloc-no-intercept.c.tmp
not   C:/b/slave/sanitizer-windows/build/./bin/clang.exe -fsanitize=address -mno-omit-leaf-frame-pointer -fno-omit-frame-pointer -fno-optimize-sibling-calls -gline-tables-only -gcodeview  -fms-compatibility-version=19.00.24215.1 -Dtestfunc=mallopt  C:\b\slave\sanitizer-windows\llvm\projects\compiler-rt\test\asan\TestCases\malloc-no-intercept.c -o C:\b\slave\sanitizer-windows\build\projects\compiler-rt\test\asan\I386WindowsConfig\TestCases\Output\malloc-no-intercept.c.tmp
not   C:/b/slave/sanitizer-windows/build/./bin/clang.exe -fsanitize=address -mno-omit-leaf-frame-pointer -fno-omit-frame-pointer -fno-optimize-sibling-calls -gline-tables-only -gcodeview  -fms-compatibility-version=19.00.24215.1 -Dtestfunc=memalign C:\b\slave\sanitizer-windows\llvm\projects\compiler-rt\test\asan\TestCases\malloc-no-intercept.c -o C:\b\slave\sanitizer-windows\build\projects\compiler-rt\test\asan\I386WindowsConfig\TestCases\Output\malloc-no-intercept.c.tmp
not   C:/b/slave/sanitizer-windows/build/./bin/clang.exe -fsanitize=address -mno-omit-leaf-frame-pointer -fno-omit-frame-pointer -fno-optimize-sibling-calls -gline-tables-only -gcodeview  -fms-compatibility-version=19.00.24215.1 -Dtestfunc=pvalloc  C:\b\slave\sanitizer-windows\llvm\projects\compiler-rt\test\asan\TestCases\malloc-no-intercept.c -o C:\b\slave\sanitizer-windows\build\projects\compiler-rt\test\asan\I386WindowsConfig\TestCases\Output\malloc-no-intercept.c.tmp
not   C:/b/slave/sanitizer-windows/build/./bin/clang.exe -fsanitize=address -mno-omit-leaf-frame-pointer -fno-omit-frame-pointer -fno-optimize-sibling-calls -gline-tables-only -gcodeview  -fms-compatibility-version=19.00.24215.1 -Dtestfunc=cfree    C:\b\slave\sanitizer-windows\llvm\projects\compiler-rt\test\asan\TestCases\malloc-no-intercept.c -o C:\b\slave\sanitizer-windows\build\projects\compiler-rt\test\asan\I386WindowsConfig\TestCases\Output\malloc-no-intercept.c.tmp
--
Exit Code: 1

Command Output (stdout):
--
$ "not" "C:/b/slave/sanitizer-windows/build/./bin/clang.exe" "-fsanitize=address" "-mno-omit-leaf-frame-pointer" "-fno-omit-frame-pointer" "-fno-optimize-sibling-calls" "-gline-tables-only" "-gcodeview" "-fms-compatibility-version=19.00.24215.1" "-Dtestfunc=mallinfo" "C:\b\slave\sanitizer-windows\llvm\projects\compiler-rt\test\asan\TestCases\malloc-no-intercept.c" "-o" "C:\b\slave\sanitizer-windows\build\projects\compiler-rt\test\asan\I386WindowsConfig\TestCases\Output\malloc-no-intercept.c.tmp"
# command output:
   Creating library C:\b\slave\sanitizer-windows\build\projects\compiler-rt\test\asan\I386WindowsConfig\TestCases\Output\malloc-no-intercept.c.lib and object C:\b\slave\sanitizer-windows\build\projects\compiler-rt\test\asan\I386WindowsConfig\TestCases\Output\malloc-no-intercept.c.exp

malloc-no-intercept-f1349f.o : error LNK2019: unresolved external symbol _mallinfo referenced in function _main

C:\b\slave\sanitizer-windows\build\projects\compiler-rt\test\asan\I386WindowsConfig\TestCases\Output\malloc-no-intercept.c.tmp : fatal error LNK1120: 1 unresolved externals


# command stderr:
clang.exe: error: linker command failed with exit code 1120 (use -v to see invocation)

E.g the test cases are *supposed* to fail to to link, and in this case link failure means the test succeeded. @hans, any clue on this? Or should I just XFAIL this test on Windows?

[dim]

Trying to fix the test case for Windows.

Apparently lib/asan/asan_malloc_win.cc has always had a wrapper
cfree() implementation, added by @timurrr. ASan should not intercept
or provide that function, otherwise configuration tools such as cmake or
autoconf can incorrectly detect that cfree is valid and supported.

Let's just get rid of the wrapper. I think this will fix the build bots
for Windows.

[dim]

Adding timurrrr since he originally added the cfree wrapper.

[timurrrr]

Sorry, it's been a long time since I've worked on this code and I don't remember anything.
Reid, please review or help find a better reviewer.

[timurrrr]

Also be careful if you proceed with removing the cfree wrapper as it may have unexpected consequences on Windows.

[dim]

In D27654#660158, @timurrrr wrote:

Also be careful if you proceed with removing the cfree wrapper as it may have unexpected consequences on Windows.

Interesting. Since I'm not that familiar with Windows development anymore, what kind of things could go wrong? If it's too much hassle I can simply undo the removal, and get rid of the cfree test for Windows.

[rnk]

In D27654#660232, @dim wrote:

In D27654#660158, @timurrrr wrote:

Also be careful if you proceed with removing the cfree wrapper as it may have unexpected consequences on Windows.

Interesting. Since I'm not that familiar with Windows development anymore, what kind of things could go wrong? If it's too much hassle I can simply undo the removal, and get rid of the cfree test for Windows.

The implementation of winasan cfree just aborts. I'd delete it and see if the bots like it.

[dim]

In D27654#660686, @rnk wrote:

In D27654#660232, @dim wrote:

In D27654#660158, @timurrrr wrote:

Also be careful if you proceed with removing the cfree wrapper as it may have unexpected consequences on Windows.

Interesting. Since I'm not that familiar with Windows development anymore, what kind of things could go wrong? If it's too much hassle I can simply undo the removal, and get rid of the cfree test for Windows.

The implementation of winasan cfree just aborts. I'd delete it and see if the bots like it.

Yes, I did just that in the last update of this diff. I hope that nobody minds if I break the bots twice :)

compiler-rt/trunk/lib/asan/asan_malloc_linux.cc

 
 INTERCEPTOR(void, free, void *ptr) {
   GET_STACK_TRACE_FREE;
   if (UNLIKELY(IsInDlsymAllocPool(ptr)))
     return;
   asan_free(ptr, &stack, FROM_MALLOC);
 }
 
+#if SANITIZER_INTERCEPT_CFREE
 INTERCEPTOR(void, cfree, void *ptr) {
   GET_STACK_TRACE_FREE;
   if (UNLIKELY(IsInDlsymAllocPool(ptr)))
     return;
   asan_free(ptr, &stack, FROM_MALLOC);
 }
+#endif // SANITIZER_INTERCEPT_CFREE
 
 INTERCEPTOR(void*, malloc, uptr size) {
   if (UNLIKELY(!asan_inited))
     // Hack: dlsym calls malloc before REAL(malloc) is retrieved from dlsym.
     return AllocateFromLocalPool(size);
   GET_STACK_TRACE_MALLOC;
   return asan_malloc(size, &stack);
 }
if (UNLIKELY(!asan_inited)) {
       new_ptr = asan_malloc(copy_size, &stack);
     }
     internal_memcpy(new_ptr, ptr, copy_size);
     return new_ptr;
   }
   return asan_realloc(ptr, size, &stack);
 }
 
+#if SANITIZER_INTERCEPT_MEMALIGN
 INTERCEPTOR(void*, memalign, uptr boundary, uptr size) {
   GET_STACK_TRACE_MALLOC;
   return asan_memalign(boundary, size, &stack, FROM_MALLOC);
 }
 
-INTERCEPTOR(void*, aligned_alloc, uptr boundary, uptr size) {
-  GET_STACK_TRACE_MALLOC;
-  return asan_memalign(boundary, size, &stack, FROM_MALLOC);
-}
-
 INTERCEPTOR(void*, __libc_memalign, uptr boundary, uptr size) {
   GET_STACK_TRACE_MALLOC;
   void *res = asan_memalign(boundary, size, &stack, FROM_MALLOC);
   DTLS_on_libc_memalign(res, size);
   return res;
 }
+#endif // SANITIZER_INTERCEPT_MEMALIGN
+
+INTERCEPTOR(void*, aligned_alloc, uptr boundary, uptr size) {
+  GET_STACK_TRACE_MALLOC;
+  return asan_memalign(boundary, size, &stack, FROM_MALLOC);
+}
 
 INTERCEPTOR(uptr, malloc_usable_size, void *ptr) {
   GET_CURRENT_PC_BP_SP;
   (void)sp;
   return asan_malloc_usable_size(ptr, pc, bp);
 }
 
+#if SANITIZER_INTERCEPT_MALLOPT_AND_MALLINFO
 // We avoid including malloc.h for portability reasons.
 // man mallinfo says the fields are "long", but the implementation uses int.
 // It doesn't matter much -- we just need to make sure that the libc's mallinfo
 // is not called.
 struct fake_mallinfo {
   int x[10];
 };
 
 INTERCEPTOR(struct fake_mallinfo, mallinfo, void) {
   struct fake_mallinfo res;
   REAL(memset)(&res, 0, sizeof(res));
   return res;
 }
 
 INTERCEPTOR(int, mallopt, int cmd, int value) {
   return -1;
 }
+#endif // SANITIZER_INTERCEPT_MALLOPT_AND_MALLINFO
 
 INTERCEPTOR(int, posix_memalign, void **memptr, uptr alignment, uptr size) {
   GET_STACK_TRACE_MALLOC;
   // Printf("posix_memalign: %zx %zu\n", alignment, size);
   return asan_posix_memalign(memptr, alignment, size, &stack);
 }
 
 INTERCEPTOR(void*, valloc, uptr size) {
   GET_STACK_TRACE_MALLOC;
   return asan_valloc(size, &stack);
 }
 
+#if SANITIZER_INTERCEPT_PVALLOC
 INTERCEPTOR(void*, pvalloc, uptr size) {
   GET_STACK_TRACE_MALLOC;
   return asan_pvalloc(size, &stack);
 }
+#endif // SANITIZER_INTERCEPT_PVALLOC
 
 INTERCEPTOR(void, malloc_stats, void) {
   __asan_print_accumulated_stats();
 }
 
 #if SANITIZER_ANDROID
 // Format of __libc_malloc_dispatch has changed in Android L.
 // While we are moving towards a solution that does not depend on bionic

compiler-rt/trunk/lib/lsan/lsan_interceptors.cc

 
 #include "interception/interception.h"
 #include "sanitizer_common/sanitizer_allocator.h"
 #include "sanitizer_common/sanitizer_atomic.h"
 #include "sanitizer_common/sanitizer_common.h"
 #include "sanitizer_common/sanitizer_flags.h"
 #include "sanitizer_common/sanitizer_internal_defs.h"
 #include "sanitizer_common/sanitizer_linux.h"
+#include "sanitizer_common/sanitizer_platform_interceptors.h"
 #include "sanitizer_common/sanitizer_platform_limits_posix.h"
 #include "sanitizer_common/sanitizer_tls_get_addr.h"
 #include "lsan.h"
 #include "lsan_allocator.h"
 #include "lsan_common.h"
 #include "lsan_thread.h"
 
 using namespace __lsan;

 }
 
 INTERCEPTOR(void*, realloc, void *q, uptr size) {
   ENSURE_LSAN_INITED;
   GET_STACK_TRACE_MALLOC;
   return Reallocate(stack, q, size, 1);
 }
 
+#if SANITIZER_INTERCEPT_MEMALIGN
 INTERCEPTOR(void*, memalign, uptr alignment, uptr size) {
   ENSURE_LSAN_INITED;
   GET_STACK_TRACE_MALLOC;
   return Allocate(stack, size, alignment, kAlwaysClearMemory);
 }
+#define LSAN_MAYBE_INTERCEPT_MEMALIGN INTERCEPT_FUNCTION(memalign)
+
+INTERCEPTOR(void *, __libc_memalign, uptr alignment, uptr size) {
+  ENSURE_LSAN_INITED;
+  GET_STACK_TRACE_MALLOC;
+  void *res = Allocate(stack, size, alignment, kAlwaysClearMemory);
+  DTLS_on_libc_memalign(res, size);
+  return res;
+}
+#define LSAN_MAYBE_INTERCEPT___LIBC_MEMALIGN INTERCEPT_FUNCTION(__libc_memalign)
+#else
+#define LSAN_MAYBE_INTERCEPT_MEMALIGN
+#define LSAN_MAYBE_INTERCEPT___LIBC_MEMALIGN
+#endif // SANITIZER_INTERCEPT_MEMALIGN
 
 INTERCEPTOR(void*, aligned_alloc, uptr alignment, uptr size) {
   ENSURE_LSAN_INITED;
   GET_STACK_TRACE_MALLOC;
   return Allocate(stack, size, alignment, kAlwaysClearMemory);
 }
 
 INTERCEPTOR(int, posix_memalign, void **memptr, uptr alignment, uptr size) {
   ENSURE_LSAN_INITED;
   GET_STACK_TRACE_MALLOC;
   *memptr = Allocate(stack, size, alignment, kAlwaysClearMemory);
   // FIXME: Return ENOMEM if user requested more than max alloc size.
   return 0;
 }
 
-INTERCEPTOR(void *, __libc_memalign, uptr alignment, uptr size) {
-  ENSURE_LSAN_INITED;
-  GET_STACK_TRACE_MALLOC;
-  void *res = Allocate(stack, size, alignment, kAlwaysClearMemory);
-  DTLS_on_libc_memalign(res, size);
-  return res;
-}
-
 INTERCEPTOR(void*, valloc, uptr size) {
   ENSURE_LSAN_INITED;
   GET_STACK_TRACE_MALLOC;
   if (size == 0)
     size = GetPageSizeCached();
   return Allocate(stack, size, GetPageSizeCached(), kAlwaysClearMemory);
 }
 
 INTERCEPTOR(uptr, malloc_usable_size, void *ptr) {
   ENSURE_LSAN_INITED;
   return GetMallocUsableSize(ptr);
 }
 
+#if SANITIZER_INTERCEPT_MALLOPT_AND_MALLINFO
 struct fake_mallinfo {
   int x[10];
 };
 
 INTERCEPTOR(struct fake_mallinfo, mallinfo, void) {
   struct fake_mallinfo res;
   internal_memset(&res, 0, sizeof(res));
   return res;
 }
+#define LSAN_MAYBE_INTERCEPT_MALLINFO INTERCEPT_FUNCTION(mallinfo)
 
 INTERCEPTOR(int, mallopt, int cmd, int value) {
   return -1;
 }
+#define LSAN_MAYBE_INTERCEPT_MALLOPT INTERCEPT_FUNCTION(mallopt)
+#else
+#define LSAN_MAYBE_INTERCEPT_MALLINFO
+#define LSAN_MAYBE_INTERCEPT_MALLOPT
+#endif // SANITIZER_INTERCEPT_MALLOPT_AND_MALLINFO
 
+#if SANITIZER_INTERCEPT_PVALLOC
 INTERCEPTOR(void*, pvalloc, uptr size) {
   ENSURE_LSAN_INITED;
   GET_STACK_TRACE_MALLOC;
   uptr PageSize = GetPageSizeCached();
   size = RoundUpTo(size, PageSize);
   if (size == 0) {
     // pvalloc(0) should allocate one page.
     size = PageSize;
   }
   return Allocate(stack, size, GetPageSizeCached(), kAlwaysClearMemory);
 }
+#define LSAN_MAYBE_INTERCEPT_PVALLOC INTERCEPT_FUNCTION(pvalloc)
+#else
+#define LSAN_MAYBE_INTERCEPT_PVALLOC
+#endif // SANITIZER_INTERCEPT_PVALLOC
 
+#if SANITIZER_INTERCEPT_CFREE
 INTERCEPTOR(void, cfree, void *p) ALIAS(WRAPPER_NAME(free));
+#define LSAN_MAYBE_INTERCEPT_CFREE INTERCEPT_FUNCTION(cfree)
+#else
+#define LSAN_MAYBE_INTERCEPT_CFREE
+#endif // SANITIZER_INTERCEPT_CFREE
 
 #define OPERATOR_NEW_BODY                              \
   ENSURE_LSAN_INITED;                                  \
   GET_STACK_TRACE_MALLOC;                              \
   return Allocate(stack, size, 1, kAlwaysClearMemory);
 
 INTERCEPTOR_ATTRIBUTE
 void *operator new(uptr size) { OPERATOR_NEW_BODY; }
INTERCEPTOR(int, pthread_join, void *th, void **ret) {
   return res;
 }
 
 namespace __lsan {
 
 void InitializeInterceptors() {
   INTERCEPT_FUNCTION(malloc);
   INTERCEPT_FUNCTION(free);
-  INTERCEPT_FUNCTION(cfree);
+  LSAN_MAYBE_INTERCEPT_CFREE;
   INTERCEPT_FUNCTION(calloc);
   INTERCEPT_FUNCTION(realloc);
-  INTERCEPT_FUNCTION(memalign);
+  LSAN_MAYBE_INTERCEPT_MEMALIGN;
+  LSAN_MAYBE_INTERCEPT___LIBC_MEMALIGN;
+  INTERCEPT_FUNCTION(aligned_alloc);
   INTERCEPT_FUNCTION(posix_memalign);
-  INTERCEPT_FUNCTION(__libc_memalign);
   INTERCEPT_FUNCTION(valloc);
-  INTERCEPT_FUNCTION(pvalloc);
+  LSAN_MAYBE_INTERCEPT_PVALLOC;
   INTERCEPT_FUNCTION(malloc_usable_size);
-  INTERCEPT_FUNCTION(mallinfo);
-  INTERCEPT_FUNCTION(mallopt);
+  LSAN_MAYBE_INTERCEPT_MALLINFO;
+  LSAN_MAYBE_INTERCEPT_MALLOPT;
   INTERCEPT_FUNCTION(pthread_create);
   INTERCEPT_FUNCTION(pthread_join);
 
   if (pthread_key_create(&g_thread_finalize_key, &thread_finalize)) {
     Report("LeakSanitizer: failed to create thread key.\n");
     Die();
   }
 }
 
 } // namespace __lsan

compiler-rt/trunk/lib/sanitizer_common/sanitizer_platform_interceptors.h

 #define SANITIZER_INTERCEPT___XSTAT !SANITIZER_INTERCEPT_STAT && SI_NOT_WINDOWS
 #define SANITIZER_INTERCEPT___XSTAT64 SI_LINUX_NOT_ANDROID
 #define SANITIZER_INTERCEPT___LXSTAT SANITIZER_INTERCEPT___XSTAT
 #define SANITIZER_INTERCEPT___LXSTAT64 SI_LINUX_NOT_ANDROID
 
 #define SANITIZER_INTERCEPT_UTMP SI_NOT_WINDOWS && !SI_MAC && !SI_FREEBSD
 #define SANITIZER_INTERCEPT_UTMPX SI_LINUX_NOT_ANDROID || SI_MAC || SI_FREEBSD
 
+#define SANITIZER_INTERCEPT_MALLOPT_AND_MALLINFO (!SI_FREEBSD && !SI_MAC)
+#define SANITIZER_INTERCEPT_MEMALIGN (!SI_FREEBSD && !SI_MAC)
+#define SANITIZER_INTERCEPT_PVALLOC (!SI_FREEBSD && !SI_MAC)
+#define SANITIZER_INTERCEPT_CFREE (!SI_FREEBSD && !SI_MAC)
+
 #endif  // #ifndef SANITIZER_PLATFORM_INTERCEPTORS_H

compiler-rt/trunk/lib/sanitizer_common/tests/sanitizer_allocator_testlib.cc

void *realloc(void *p, size_t size) {
   }
   p = allocator.Reallocate(&cache, p, size, 8);
   if (p) {
     SANITIZER_MALLOC_HOOK(p, size);
   }
   return p;
 }
 
+#if SANITIZER_INTERCEPT_MEMALIGN
 void *memalign(size_t alignment, size_t size) {
   if (UNLIKELY(!thread_inited))
     thread_init();
   void *p = allocator.Allocate(&cache, size, alignment);
   SANITIZER_MALLOC_HOOK(p, size);
   return p;
 }
+#endif // SANITIZER_INTERCEPT_MEMALIGN
 
 int posix_memalign(void **memptr, size_t alignment, size_t size) {
   if (UNLIKELY(!thread_inited))
     thread_init();
   *memptr = allocator.Allocate(&cache, size, alignment);
   SANITIZER_MALLOC_HOOK(*memptr, size);
   return 0;
 }
 
 void *valloc(size_t size) {
   if (UNLIKELY(!thread_inited))
     thread_init();
   if (size == 0)
     size = GetPageSizeCached();
   void *p = allocator.Allocate(&cache, size, GetPageSizeCached());
   SANITIZER_MALLOC_HOOK(p, size);
   return p;
 }
 
+#if SANITIZER_INTERCEPT_CFREE
 void cfree(void *p) ALIAS("free");
+#endif // SANITIZER_INTERCEPT_CFREE
+#if SANITIZER_INTERCEPT_PVALLOC
 void *pvalloc(size_t size) ALIAS("valloc");
+#endif // SANITIZER_INTERCEPT_PVALLOC
+#if SANITIZER_INTERCEPT_MEMALIGN
 void *__libc_memalign(size_t alignment, size_t size) ALIAS("memalign");
+#endif // SANITIZER_INTERCEPT_MEMALIGN
 
 void malloc_usable_size() {
 }
 
+#if SANITIZER_INTERCEPT_MALLOPT_AND_MALLINFO
 void mallinfo() {
 }
 
 void mallopt() {
 }
+#endif // SANITIZER_INTERCEPT_MALLOPT_AND_MALLINFO
 }  // extern "C"
 
 namespace std {
   struct nothrow_t;
 }
 
 void *operator new(size_t size) ALIAS("malloc");
 void *operator new[](size_t size) ALIAS("malloc");
 void *operator new(size_t size, std::nothrow_t const&) ALIAS("malloc");
 void *operator new[](size_t size, std::nothrow_t const&) ALIAS("malloc");
 void operator delete(void *ptr) throw() ALIAS("free");
 void operator delete[](void *ptr) throw() ALIAS("free");
 void operator delete(void *ptr, std::nothrow_t const&) ALIAS("free");
 void operator delete[](void *ptr, std::nothrow_t const&) ALIAS("free");

compiler-rt/trunk/test/asan/TestCases/malloc-no-intercept.c

+// Test that on non-glibc platforms, a number of malloc-related functions are
+// not intercepted.
+
+// RUN: not %clang_asan -Dtestfunc=mallinfo %s -o %t
+// RUN: not %clang_asan -Dtestfunc=mallopt  %s -o %t
+// RUN: not %clang_asan -Dtestfunc=memalign %s -o %t
+// RUN: not %clang_asan -Dtestfunc=pvalloc  %s -o %t
+// RUN: not %clang_asan -Dtestfunc=cfree    %s -o %t
+
+#include <stdlib.h>
+
+// For glibc, cause link failures by referencing a nonexistent function.
+#ifdef __GLIBC__
+#undef testfunc
+#define testfunc nonexistent_function
+#endif
+
+void testfunc(void);
+
+int main(void)
+{
+  testfunc();
+  return 0;
+}