[lsan] Enable LSan for arm Linux

[m.ostapenko]

Summary

This patch follows https://reviews.llvm.org/D28609 and enables LSan for arm.

[ygribov]

lib/sanitizer_common/sanitizer_linux_libcdep.cc

187

Misleading indent.

test/lsan/TestCases/swapcontext.cc

7

Deserves an explanation.

[m.ostapenko]

test/lsan/TestCases/swapcontext.cc

7

The point here is that this test fails on arm with SIGBUS due to child_stack is unaligned:

bash-3.2# LSAN_OPTIONS=log_pointers=1 /build/llvm/projects/compiler-rt/test/lsan/ARMLsanConfig/TestCases/Output/swapcontext.cc.tmp fooChild stack: 0x7e9ee5f3
Bus error

I can align it manually or use malloc/aligned_alloc instead of new[] to avoid the issue.

[m.ostapenko]

Updating according to Yura's nits.

[rengolin]

This comment was removed by rengolin.

[rengolin]

You seem to be enabling it on soft and hard float. Did you test on both environments? What type of hardware did you test this?

lib/sanitizer_common/sanitizer_linux.cc

1269

This sequence doesn't coincide with the order of parameters above, and can lead to unexpected results.

Why do you need to reserve the registers in this code at all?

[ygribov]

lib/sanitizer_common/sanitizer_linux.cc

1269

Why should it? The sole purpose of register annotations is to pass arguments to swi call below.

[rengolin]

lib/sanitizer_common/sanitizer_linux.cc

1269

Right, I just realised the compiler will do the necessary moves.

This code is really opaque, can you add some comments like the ones above?

1284

If this is ARMv4T and no interwork, this will fail, as blx was introduced in ARMv5.

Check compiler-rt/lib/builtins/assembly.h for more info on the multiple ways to return.

[ygribov]

lib/sanitizer_common/sanitizer_linux.cc

1269

Note that that's how it's done for other cores, including AArch64. All comments is given for x86 internal_clone implementation above (it basically says that this hairy code is inspired by Glibc clone implementation).

[m.ostapenko]

Updating with a little bit more comments.

[m.ostapenko]

In D29586#668050, @rengolin wrote:

You seem to be enabling it on soft and hard float. Did you test on both environments? What type of hardware did you test this?

I've tested the patch on two configurations:

1. Linaro Ubuntu 14.04 (Trusty) on Arndale board. It's a hard float system, right?
2. I've built a softfp sysroot and tested the patch there on the same Arndale board (just chrooted to new root).

[m.ostapenko]

lib/sanitizer_common/sanitizer_linux.cc

1269

Yeah, the reason we have all that stuff is explained in x86_64 port. Anyway, I've added several comments to inline asm to improve readability. Looks better now?

1284

Ah, OK, thanks. Fixed now.

[zatrazz]

lib/sanitizer_common/sanitizer_linux.cc

1315

I think you could simplify to just:

#ifdef ARCH_HAS_BX
# ifdef ARCH_HAS_BLX
#  define BLX(R)        "blx "  #R
# else
#  define BLX(R)        "mov     lr, pc; bx" #R
# endif
#else
# define BLX(R)         "mov     lr, pc; mov pc," #R
#endif

And then on inline assembly just call BLX(ip).

lib/sanitizer_common/sanitizer_linux_libcdep.cc

249

This is not what I am seeing on my environment:

2.25 - 1216
2.24 - 1216
2.23 - 1216
2.22 - 1120
2.21 - 1120
2.20 - 1120

The 2.22 to 2.23 change (cause by 3e2ee6f0e3471ce commit) removed HAVE_FORCED_UNWIND and thus 'struct pthread' adds a 'struct _Unwind_Exception' regardless if architecture defined or not HAVE_FORCED_UNWIND.

[m.ostapenko]

lib/sanitizer_common/sanitizer_linux_libcdep.cc

202

I don't really like this change . Perhaps we can create some white list of terminator symbols, or just drop the check?

249

Oh, my bad, should be fixed.

[m.ostapenko]

In D29586#668769, @m.ostapenko wrote:

In D29586#668050, @rengolin wrote:

You seem to be enabling it on soft and hard float. Did you test on both environments? What type of hardware did you test this?

I've tested the patch on two configurations:

1. Linaro Ubuntu 14.04 (Trusty) on Arndale board. It's a hard float system, right?

Oh, things become more complicated... I see many test failures with host GCC 4.8 because fast unwinder failed to get backtraces for mallocs. This happens because __interceptor_malloc, compiled by GCC 4.8, didn't properly save frame pointer register:

00000000 <__interceptor_malloc>:
   0:   e92d 47f0       stmdb   sp!, {r4, r5, r6, r7, r8, r9, sl, lr}
   4:   f5ad 6d85       sub.w   sp, sp, #1064   ; 0x428
   8:   4d29            ldr     r5, [pc, #164]  ; (b0 <__interceptor_malloc+0xb0>)
   a:   4b2a            ldr     r3, [pc, #168]  ; (b4 <__interceptor_malloc+0xb4>)
   c:   af04            add     r7, sp, #16
   e:   447d            add     r5, pc

But if compile with clang (3.3, 3.5 or trunk) or GCC 4.9, the fp is saved properly:

00000000 <__interceptor_malloc>:
   0:   e92d4ff0        push    {r4, r5, r6, r7, r8, r9, sl, fp, lr}
   4:   e28db01c        add     fp, sp, #28
   8:   e24dd024        sub     sp, sp, #36     ; 0x24
   c:   e24ddb01        sub     sp, sp, #1024   ; 0x400
  10:   e1a08000        mov     r8, r0

So, it seems that LSan's operability depends on what compiler is used to build it :(.

[zatrazz]

In D29586#672157, @m.ostapenko wrote:

In D29586#668769, @m.ostapenko wrote:

In D29586#668050, @rengolin wrote:

You seem to be enabling it on soft and hard float. Did you test on both environments? What type of hardware did you test this?

I've tested the patch on two configurations:

1. Linaro Ubuntu 14.04 (Trusty) on Arndale board. It's a hard float system, right?

Oh, things become more complicated... I see many test failures with host GCC 4.8 because fast unwinder failed to get backtraces for mallocs. This happens because __interceptor_malloc, compiled by GCC 4.8, didn't properly save frame pointer register:

00000000 <__interceptor_malloc>:
   0:   e92d 47f0       stmdb   sp!, {r4, r5, r6, r7, r8, r9, sl, lr}
   4:   f5ad 6d85       sub.w   sp, sp, #1064   ; 0x428
   8:   4d29            ldr     r5, [pc, #164]  ; (b0 <__interceptor_malloc+0xb0>)
   a:   4b2a            ldr     r3, [pc, #168]  ; (b4 <__interceptor_malloc+0xb4>)
   c:   af04            add     r7, sp, #16
   e:   447d            add     r5, pc

But if compile with clang (3.3, 3.5 or trunk) or GCC 4.9, the fp is saved properly:

00000000 <__interceptor_malloc>:
   0:   e92d4ff0        push    {r4, r5, r6, r7, r8, r9, sl, fp, lr}
   4:   e28db01c        add     fp, sp, #28
   8:   e24dd024        sub     sp, sp, #36     ; 0x24
   c:   e24ddb01        sub     sp, sp, #1024   ; 0x400
  10:   e1a08000        mov     r8, r0

So, it seems that LSan's operability depends on what compiler is used to build it :(.

It is a know issue [1] [2] and in fact it a little more complicated, it depends on the flags used as well:
if you mix thumb and arm code fast unwinder won't work. I am not sure which option would be better,
but I am afraid to get a reliable stacktrack on arm (with mixed objects and function built with different compilers)
we will need to use a external unwinder (maybe libunwinder). But it will have the side-effect of making
backtrace way slower.

[1] https://llvm.org/bugs/show_bug.cgi?id=22741
[2] https://llvm.org/bugs/show_bug.cgi?id=18505

[m.ostapenko]

In D29586#672380, @zatrazz wrote:

In D29586#672157, @m.ostapenko wrote:

In D29586#668769, @m.ostapenko wrote:

In D29586#668050, @rengolin wrote:

You seem to be enabling it on soft and hard float. Did you test on both environments? What type of hardware did you test this?

I've tested the patch on two configurations:

1. Linaro Ubuntu 14.04 (Trusty) on Arndale board. It's a hard float system, right?

Oh, things become more complicated... I see many test failures with host GCC 4.8 because fast unwinder failed to get backtraces for mallocs. This happens because __interceptor_malloc, compiled by GCC 4.8, didn't properly save frame pointer register:

00000000 <__interceptor_malloc>:
   0:   e92d 47f0       stmdb   sp!, {r4, r5, r6, r7, r8, r9, sl, lr}
   4:   f5ad 6d85       sub.w   sp, sp, #1064   ; 0x428
   8:   4d29            ldr     r5, [pc, #164]  ; (b0 <__interceptor_malloc+0xb0>)
   a:   4b2a            ldr     r3, [pc, #168]  ; (b4 <__interceptor_malloc+0xb4>)
   c:   af04            add     r7, sp, #16
   e:   447d            add     r5, pc

But if compile with clang (3.3, 3.5 or trunk) or GCC 4.9, the fp is saved properly:

00000000 <__interceptor_malloc>:
   0:   e92d4ff0        push    {r4, r5, r6, r7, r8, r9, sl, fp, lr}
   4:   e28db01c        add     fp, sp, #28
   8:   e24dd024        sub     sp, sp, #36     ; 0x24
   c:   e24ddb01        sub     sp, sp, #1024   ; 0x400
  10:   e1a08000        mov     r8, r0

So, it seems that LSan's operability depends on what compiler is used to build it :(.

It is a know issue [1] [2] and in fact it a little more complicated, it depends on the flags used as well:
if you mix thumb and arm code fast unwinder won't work. I am not sure which option would be better,
but I am afraid to get a reliable stacktrack on arm (with mixed objects and function built with different compilers)
we will need to use a external unwinder (maybe libunwinder). But it will have the side-effect of making
backtrace way slower.

[1] https://llvm.org/bugs/show_bug.cgi?id=22741
[2] https://llvm.org/bugs/show_bug.cgi?id=18505

Right, but I thought it affects only Thumb (that might be mixed with arm) but it seems that even arm mode is affected depending on GCC version. This complicates enabling tests on arm targets, but still, It would be nice to have LSan available on arm.

[zatrazz]

In D29586#672507, @m.ostapenko wrote:

In D29586#672380, @zatrazz wrote:

In D29586#672157, @m.ostapenko wrote:

So, it seems that LSan's operability depends on what compiler is used to build it :(.

It is a know issue [1] [2] and in fact it a little more complicated, it depends on the flags used as well:
if you mix thumb and arm code fast unwinder won't work. I am not sure which option would be better,
but I am afraid to get a reliable stacktrack on arm (with mixed objects and function built with different compilers)
we will need to use a external unwinder (maybe libunwinder). But it will have the side-effect of making
backtrace way slower.

[1] https://llvm.org/bugs/show_bug.cgi?id=22741
[2] https://llvm.org/bugs/show_bug.cgi?id=18505

Right, but I thought it affects only Thumb (that might be mixed with arm) but it seems that even arm mode is affected depending on GCC version. This complicates enabling tests on arm targets, but still, It would be nice to have LSan available on arm.

My only concern is what kind of information user will see when potentially use with different libraries and systems.
We can constrain testing on a working environment, but it does not help when real usercase won't get meaningful
stacktraces.

Other projects usually rely on dwarf CFI for get arm stacktraces (valgrind, glibc) and I think we might need to actually
use it or rely on external libraries for arm (libunwind, etc.). Valgrind even tries to add some instructions scanning
to get around the thumb issues (coregrind/m_stacktrace.c) but it even states that it results in bad output.

One option would be to enable lsan as is and try to improve sanitizer stacktrace on arm
(lib/sanitizer_common/sanitizer_stacktrace.cc).

[m.ostapenko]

In D29586#675262, @zatrazz wrote:

In D29586#672507, @m.ostapenko wrote:

In D29586#672380, @zatrazz wrote:

In D29586#672157, @m.ostapenko wrote:

So, it seems that LSan's operability depends on what compiler is used to build it :(.

It is a know issue [1] [2] and in fact it a little more complicated, it depends on the flags used as well:
if you mix thumb and arm code fast unwinder won't work. I am not sure which option would be better,
but I am afraid to get a reliable stacktrack on arm (with mixed objects and function built with different compilers)
we will need to use a external unwinder (maybe libunwinder). But it will have the side-effect of making
backtrace way slower.

[1] https://llvm.org/bugs/show_bug.cgi?id=22741
[2] https://llvm.org/bugs/show_bug.cgi?id=18505

Right, but I thought it affects only Thumb (that might be mixed with arm) but it seems that even arm mode is affected depending on GCC version. This complicates enabling tests on arm targets, but still, It would be nice to have LSan available on arm.

My only concern is what kind of information user will see when potentially use with different libraries and systems.
We can constrain testing on a working environment, but it does not help when real usercase won't get meaningful
stacktraces.

Yeah, users will need to compile all their code with -marm -fno-omit-frame-pointer to get stacktraces (ASan would benefit from this too) or use slow unwinder with small context (e.g. 5) but this would significantly slow down application under test.

Other projects usually rely on dwarf CFI for get arm stacktraces (valgrind, glibc) and I think we might need to actually
use it or rely on external libraries for arm (libunwind, etc.). Valgrind even tries to add some instructions scanning
to get around the thumb issues (coregrind/m_stacktrace.c) but it even states that it results in bad output.

One option would be to enable lsan as is and try to improve sanitizer stacktrace on arm
(lib/sanitizer_common/sanitizer_stacktrace.cc).

Perhaps we can enable slow unwinder for LSan tests on ARM (compile with -funwind-tables and run with 'fast_unwind_on_malloc=false')? This would make almost all tests pass except few ones (e.g. use_tls_pthread_specific_dynamic.cc) where slow unwinder might be unable to get caller PC (e.g. from libpthread.so).

[m.ostapenko]

Updating. I've enabled slow unwinder for LSan tests on ARM to make them pass regardless of arm/thumb mode and compiler that was used to build LSan runtime.

[kcc]

In D29586#677564, @m.ostapenko wrote:

Updating. I've enabled slow unwinder for LSan tests on ARM to make them pass regardless of arm/thumb mode and compiler that was used to build LSan runtime.

That's pretty bad.
Yes, the tests will pass, but the tool will be utterly useless in real life. Slow unwinder is just too slow.
And setting fast_unwind_on_malloc=false in the test config means we are not testing what the users are going to use.

[m.ostapenko]

In D29586#679101, @kcc wrote:

In D29586#677564, @m.ostapenko wrote:

Updating. I've enabled slow unwinder for LSan tests on ARM to make them pass regardless of arm/thumb mode and compiler that was used to build LSan runtime.

That's pretty bad.
Yes, the tests will pass, but the tool will be utterly useless in real life. Slow unwinder is just too slow.
And setting fast_unwind_on_malloc=false in the test config means we are not testing what the users are going to use.

I agree. ARM ABI is pretty bad -- in thumb mode we can't use fast unwinder because of known reasons, but I really don't know how can we reliably run LSAN tests on Arm without enabling slow unwinder. In any case, I cannot push these changes -- you are the code owner after all, but even with slow unwinder we got pretty fine results on our distributiive. Is there any way how we can enable LSAN for Arm?

[ygribov]

One option is to force libasan and tests to compile to ARM (via -marm switch) which is known to work. I think common understanding is that fast unwinder is unfixable in Thumb mode.

lib/sanitizer_common/sanitizer_linux_libcdep.cc

202

Or just !isalpha(*end)?

[ygribov]

BTW how is the situation different from Asan? Fast unwinder should have _exactly_ same problems there but I guess just decided to live with them.

[m.ostapenko]

In D29586#679736, @ygribov wrote:

BTW how is the situation different from Asan? Fast unwinder should have _exactly_ same problems there but I guess just decided to live with them.

As far as I can see, ASan tests that rely on fast unwinder are just disabled on ARM (e.g. use-after-free.cc) via REQUIRES: stable-runtime.

[m.ostapenko]

In D29586#679711, @ygribov wrote:

One option is to force libasan and tests to compile to ARM (via -marm switch) which is known to work. I think common understanding is that fast unwinder is unfixable in Thumb mode.

I'm afraid this isn't enough, consider two following cases:

1. If LSan itself is compiled with Thumb fast unwinder would be unable to leave first frame.
2. Likewise, if LSan is compiled with GCC 4.8, fast unwinder would be unable to leave first frame due to __interceptor_malloc's frame doesn't contain saved fp (see objdump output several comments above).

[m.ostapenko]

Disabling slow unwinder in tests.
Still, if compile LSan with thumb, the whole LSan testsuite would fail. Can we somehow disable it on thumb targets? E.g. check for '-mthumb' flag into lit configs and enable/disable tests accordingly?

[ygribov]

E.g. check for '-mthumb' flag into lit configs and enable/disable tests accordingly?

Something like REQUIRES: fast-unwinder-works.

[m.ostapenko]

Rebased. I've also disabled LSan tests on Thumb targets filtering them out by presence of -mthumb flag.

[m.ostapenko]

Gentle ping. Is there any chance that LSan for ARM will be accepted?

[kcc]

Aleksey is looking at lsan now, hopefully he can help review this.

[m.ostapenko]

Rebased. Gentle reminder.

[m.ostapenko]

Rebased. Ping.

[alekseyshl]

I have no further comments and defer lgtm to folks who know something about the unwinder stuff.

lib/lsan/lsan_common.h

151

IsItaniumABIArrayCookie

162

IsARMABIArrayCookie

lib/sanitizer_common/sanitizer_linux.cc

1265

Isn't stack 4 bytes aligned on arm32?

1293

Why do we push them to stack? Aren't all the params for swi passed in registers?

[m.ostapenko]

Updating according to Aleksey's comments.

[eugenis]

Going back to the issue with interceptor_malloc not saving FP when built with GCC. In clang a function using builtin_frame_address(0) automatically gets a proper frame pointer. As far as I can see, arm-gcc in the android ndk (version 4.9) behaves the same way on a simple test case. Is that some new optimization where a frame address is computed on the fly?

lib/sanitizer_common/sanitizer_linux_libcdep.cc

202

what exactly are we trying to avoid here? Something like 1.2abc ?
This is where is comes from: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=60038

test/lsan/TestCases/swapcontext.cc

28

should it not be 16 for x86_64?

[m.ostapenko]

In D29586#718621, @eugenis wrote:

Going back to the issue with interceptor_malloc not saving FP when built with GCC. In clang a function using builtin_frame_address(0) automatically gets a proper frame pointer. As far as I can see, arm-gcc in the android ndk (version 4.9) behaves the same way on a simple test case. Is that some new optimization where a frame address is computed on the fly?

No, I just missed that GCC 4.8 emits thumb code by default on my Linaro Ubuntu 14.04 (configured with --with-mode=thumb switch). Passing -marm resolves the issue.

lib/sanitizer_common/sanitizer_linux_libcdep.cc

202

Yeah, just filter out "strange" Glibc configurations.

test/lsan/TestCases/swapcontext.cc

28

Yeah, x86_64 needs 16 here (not sure why did this work on my x86_64 box, perhaps my machine we OK with unaligned access).

[eugenis]

LGTM with the aligned(16) change

test/lsan/TestCases/swapcontext.cc

28

This only matters for some sse instructions which can appear out of thin air, like an inlined memcpy of a stack-allocated buffer. I guess it did not happen in you case. Still, better be safe.

[thakis]

This breaks bootstrap builds. I put the error message in the revert commit description: http://lists.llvm.org/pipermail/llvm-commits/Week-of-Mon-20170410/444101.html

[m.ostapenko]

In D29586#723623, @thakis wrote:

This breaks bootstrap builds. I put the error message in the revert commit description: http://lists.llvm.org/pipermail/llvm-commits/Week-of-Mon-20170410/444101.html

Yeeks, sorry about this. The problem seems to be here (missing space between bx and #R):

#  define BLX(R) "mov lr, pc; bx" #R "\n"

I'll re-land the patch with this fix.

cmake/config-ix.cmake

if(APPLE)
   set(X86_64 x86_64 x86_64h)
 endif()
 
 set(ALL_SANITIZER_COMMON_SUPPORTED_ARCH ${X86} ${X86_64} ${PPC64}
     ${ARM32} ${ARM64} ${MIPS32} ${MIPS64} ${S390X})
 set(ALL_ASAN_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64}
     ${MIPS32} ${MIPS64} ${PPC64} ${S390X})
 set(ALL_DFSAN_SUPPORTED_ARCH ${X86_64} ${MIPS64} ${ARM64})
+
+if(APPLE)
   set(ALL_LSAN_SUPPORTED_ARCH ${X86} ${X86_64} ${MIPS64} ${ARM64})
+else()
+  set(ALL_LSAN_SUPPORTED_ARCH ${X86} ${X86_64} ${MIPS64} ${ARM64} ${ARM32})
+endif()
 set(ALL_MSAN_SUPPORTED_ARCH ${X86_64} ${MIPS64} ${ARM64} ${PPC64})
 set(ALL_PROFILE_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64} ${PPC64}
     ${MIPS32} ${MIPS64} ${S390X})
 set(ALL_TSAN_SUPPORTED_ARCH ${X86_64} ${MIPS64} ${ARM64} ${PPC64})
 set(ALL_UBSAN_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64}
     ${MIPS32} ${MIPS64} ${PPC64} ${S390X})
 set(ALL_SAFESTACK_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM64} ${MIPS32} ${MIPS64})
 set(ALL_CFI_SUPPORTED_ARCH ${X86} ${X86_64} ${MIPS64})

lib/asan/tests/asan_test.cc

void *ThreadStackReuseFunc1(void *unused) {
   return 0;
 }
 
 void *ThreadStackReuseFunc2(void *unused) {
   TouchStackFunc();
   return 0;
 }
 
+#if !defined(__thumb__)
 TEST(AddressSanitizer, ThreadStackReuseTest) {
   pthread_t t;
   PTHREAD_CREATE(&t, 0, ThreadStackReuseFunc1, 0);
   PTHREAD_JOIN(t, 0);
   PTHREAD_CREATE(&t, 0, ThreadStackReuseFunc2, 0);
   PTHREAD_JOIN(t, 0);
 }
+#endif
 
 #if defined(__SSE2__)
 #include <emmintrin.h>
 TEST(AddressSanitizer, Store128Test) {
   char *a = Ident((char*)malloc(Ident(12)));
   char *p = a;
   if (((uintptr_t)a % 16) != 0)
     p = a + 8;
TEST(AddressSanitizer, ThreadedStressStackReuseTest) {
   for (int i = 0; i < kNumThreads; i++) {
     PTHREAD_CREATE(&t[i], 0, (void* (*)(void *x))LotsOfStackReuse, 0);
   }
   for (int i = 0; i < kNumThreads; i++) {
     PTHREAD_JOIN(t[i], 0);
   }
 }
 
+// pthread_exit tries to perform unwinding stuff that leads to dlopen'ing
+// libgcc_s.so. dlopen in its turn calls malloc to store "libgcc_s.so" string
+// that confuses LSan on Thumb because it fails to understand that this
+// allocation happens in dynamic linker and should be ignored.
+#if !defined(__thumb__)
 static void *PthreadExit(void *a) {
   pthread_exit(0);
   return 0;
 }
 
 TEST(AddressSanitizer, PthreadExitTest) {
   pthread_t t;
   for (int i = 0; i < 1000; i++) {
     PTHREAD_CREATE(&t, 0, PthreadExit, 0);
     PTHREAD_JOIN(t, 0);
   }
 }
+#endif
 
 // FIXME: Why does clang-cl define __EXCEPTIONS?
 #if defined(__EXCEPTIONS) && !defined(_WIN32)
 NOINLINE static void StackReuseAndException() {
   int large_stack[1000];
   Ident(large_stack);
   ASAN_THROW(1);
 }

lib/lsan/lsan_allocator.h

#if SANITIZER_WORDSIZE == 64
   uptr requested_size : 54;
 #else
   uptr requested_size : 32;
   uptr padding : 22;
 #endif
   u32 stack_trace_id;
 };
 
-#if defined(__mips64) || defined(__aarch64__) || defined(__i386__)
+#if defined(__mips64) || defined(__aarch64__) || defined(__i386__) || \
+    defined(__arm__)
 static const uptr kRegionSizeLog = 20;
 static const uptr kNumRegions = SANITIZER_MMAP_RANGE_SIZE >> kRegionSizeLog;
 typedef TwoLevelByteMap<(kNumRegions >> 12), 1 << 12> ByteMap;
 typedef CompactSizeClassMap SizeClassMap;
 typedef SizeClassAllocator32<0, SANITIZER_MMAP_RANGE_SIZE,
     sizeof(ChunkMetadata), SizeClassMap, kRegionSizeLog, ByteMap>
     PrimaryAllocator;
 #elif defined(__x86_64__)

lib/lsan/lsan_allocator.cc

 #include "sanitizer_common/sanitizer_internal_defs.h"
 #include "sanitizer_common/sanitizer_stackdepot.h"
 #include "sanitizer_common/sanitizer_stacktrace.h"
 #include "lsan_common.h"
 
 extern "C" void *memset(void *ptr, int value, uptr num);
 
 namespace __lsan {
-#if defined(__i386__)
+#if defined(__i386__) || defined(__arm__)
 static const uptr kMaxAllowedMallocSize = 1UL << 30;
 #elif defined(__mips64) || defined(__aarch64__)
 static const uptr kMaxAllowedMallocSize = 4UL << 30;
 #else
 static const uptr kMaxAllowedMallocSize = 8UL << 30;
 #endif
 typedef LargeMmapAllocator<> SecondaryAllocator;
 typedef CombinedAllocator<PrimaryAllocator, AllocatorCache,

lib/lsan/lsan_common.h

 // ratio on large leaks. But we still want to have it for some 32 bit arches
 // (e.g. x86), see https://github.com/google/sanitizers/issues/403.
 // To enable LeakSanitizer on new architecture, one need to implement
 // internal_clone function as well as (probably) adjust TLS machinery for
 // new architecture inside sanitizer library.
 #if (SANITIZER_LINUX && !SANITIZER_ANDROID) && (SANITIZER_WORDSIZE == 64) && \
     (defined(__x86_64__) || defined(__mips64) || defined(__aarch64__))
 #define CAN_SANITIZE_LEAKS 1
-#elif SANITIZER_LINUX && !SANITIZER_ANDROID && defined(__i386__)
+#elif SANITIZER_LINUX && !SANITIZER_ANDROID \
+     && (defined(__i386__) || defined(__arm__))
 #define CAN_SANITIZE_LEAKS 1
 #elif CAN_SANITIZE_LEAKS_MAC && (defined(__x86_64__) ||  defined(__mips64) || \
       defined(__aarch64__) || defined(__i386__))
 #define CAN_SANITIZE_LEAKS 1
 #else
 #define CAN_SANITIZE_LEAKS 0
 #endif
 

 void EnableInThisThread();
 // Can be used to ignore memory allocated by an intercepted
 // function.
 struct ScopedInterceptorDisabler {
   ScopedInterceptorDisabler() { DisableInThisThread(); }
   ~ScopedInterceptorDisabler() { EnableInThisThread(); }
 };
 
-// Special case for "new T[0]" where T is a type with DTOR.
-// new T[0] will allocate one word for the array size (0) and store a pointer
-// to the end of allocated chunk.
-inline bool IsSpecialCaseOfOperatorNew0(uptr chunk_beg, uptr chunk_size,
-                                        uptr addr) {
+// According to Itanium C++ ABI array cookie is a one word containing
+// size of allocated array.
+static inline bool IsItaniumABICookie(uptr chunk_beg, uptr chunk_size,
   return chunk_size == sizeof(uptr) && chunk_beg + chunk_size == addr &&
          *reinterpret_cast<uptr *>(chunk_beg) == 0;
 }
 
+// According to ARM C++ ABI array cookie consists of two words:
+// struct array_cookie {
+//   std::size_t element_size; // element_size != 0
+//   std::size_t element_count;
+// };
+static inline bool IsARMABICookie(uptr chunk_beg, uptr chunk_size, uptr addr) {
+  return chunk_size == 2 * sizeof(uptr) && chunk_beg + chunk_size == addr &&
+         *reinterpret_cast<uptr *>(chunk_beg + sizeof(uptr)) == 0;
+}
+
+// Special case for "new T[0]" where T is a type with DTOR.
+// new T[0] will allocate a cookie (one or two words) for the array size (0)
+// and store a pointer to the end of allocated chunk. The actual cookie layout
+// varies between platforms according to their C++ ABI implementation.
+inline bool IsSpecialCaseOfOperatorNew0(uptr chunk_beg, uptr chunk_size,
+                                        uptr addr) {
+#if defined(__arm__)
+  return IsARMABICookie(chunk_beg, chunk_size, addr);
+#else
+  return IsItaniumABICookie(chunk_beg, chunk_size, addr);
+#endif
+}
+
 // The following must be implemented in the parent tool.
 
 void ForEachChunk(ForEachChunkCallback callback, void *arg);
 // Returns the address range occupied by the global allocator object.
 void GetAllocatorGlobalRange(uptr *begin, uptr *end);
 // Wrappers for allocator's ForceLock()/ForceUnlock().
 void LockAllocator();
 void UnlockAllocator();

lib/sanitizer_common/sanitizer_linux.h

 // internal_sigaction instead.
 int internal_sigaction_norestorer(int signum, const void *act, void *oldact);
 #if (defined(__x86_64__) || SANITIZER_MIPS64) && !SANITIZER_GO
 // Uses a raw system call to avoid interceptors.
 int internal_sigaction_syscall(int signum, const void *act, void *oldact);
 #endif
 void internal_sigdelset(__sanitizer_sigset_t *set, int signum);
 #if defined(__x86_64__) || defined(__mips__) || defined(__aarch64__) \
-  || defined(__powerpc64__) || defined(__s390__) || defined(__i386__)
+  || defined(__powerpc64__) || defined(__s390__) || defined(__i386__) \
+  || defined(__arm__)
 uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg,
                     int *parent_tidptr, void *newtls, int *child_tidptr);
 #endif
 #endif  // SANITIZER_LINUX
 
 // This class reads thread IDs from /proc/<pid>/task using only syscalls.
 class ThreadLister {
  public:

lib/sanitizer_common/sanitizer_linux.cc

#endif
                        : "a"(SYSCALL(clone)), "i"(SYSCALL(exit)),
                          "c"(child_stack),
                          "d"(parent_tidptr),
                          "S"(newtls),
                          "D"(child_tidptr)
                        : "memory");
   return res;
 }
+#elif defined(__arm__) && SANITIZER_LINUX
+uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg,
+                    int *parent_tidptr, void *newtls, int *child_tidptr) {
+  unsigned int res;
+  if (!fn || !child_stack)
+    return -EINVAL;
+  CHECK_EQ(0, (uptr)child_stack % 16);
+  child_stack = (char *)child_stack - 2 * sizeof(unsigned int);
+  ((unsigned int *)child_stack)[0] = (uptr)fn;
+  ((unsigned int *)child_stack)[1] = (uptr)arg;
+  register int r0 __asm__("r0") = flags;
+  register void *r1 __asm__("r1") = child_stack;
+  register int *r2 __asm__("r2") = parent_tidptr;
+  register void *r3 __asm__("r3") = newtls;
+  register int *r4 __asm__("r4") = child_tidptr;
+  register int r7 __asm__("r7") = __NR_clone;
+
+#if __ARM_ARCH > 4 || defined (__ARM_ARCH_4T__)
+# define ARCH_HAS_BX
+#endif
+#if __ARM_ARCH > 4
+# define ARCH_HAS_BLX
+#endif
+
+#ifdef ARCH_HAS_BX
+# ifdef ARCH_HAS_BLX
+#  define BLX(R) "blx "  #R "\n"
+# else
+#  define BLX(R) "mov lr, pc; bx" #R "\n"
+# endif
+#else
+# define BLX(R)  "mov lr, pc; mov pc," #R "\n"
+#endif
+
+  __asm__ __volatile__("push    {r4, r7}\n"
+
+                       /* Do the system call */
+                       "swi 0x0\n"
+
+                       /* if (%r0 != 0)
+                        *   return %r0;
+                        */
+                       "cmp r0, #0\n"
+                       "bne 1f\n"
+
+                       /* In the child, now. Call "fn(arg)". */
+                       "ldr r0, [sp, #4]\n"
+                       "ldr ip, [sp], #8\n"
+                       BLX(ip)
+                       /* Call _exit(%r0). */
+                       "mov r7, %7\n"
+                       "swi 0x0\n"
+                       "1:\n"
+                       "pop {r4, r7}\n"
+                       "mov %0, r0\n"
+                       : "=r"(res)
+                       : "r"(r0), "r"(r1), "r"(r2), "r"(r3), "r"(r4), "r"(r7),
+                         "i"(__NR_exit)
+                       : "memory");
+  return res;
+}
 #endif  // defined(__x86_64__) && SANITIZER_LINUX
 
 #if SANITIZER_ANDROID
 #if __ANDROID_API__ < 21
 extern "C" __attribute__((weak)) int dl_iterate_phdr(
     int (*)(struct dl_phdr_info *, size_t, void *), void *);
 #endif
 

lib/sanitizer_common/sanitizer_linux_libcdep.cc

if (tls_align < kStackAlign)
     tls_align = kStackAlign;
   g_tls_size = RoundUpTo(tls_size, tls_align);
 }
 #else
 void InitTlsSize() { }
 #endif  // !SANITIZER_FREEBSD && !SANITIZER_ANDROID && !SANITIZER_GO
 
 #if (defined(__x86_64__) || defined(__i386__) || defined(__mips__) \
-    || defined(__aarch64__) || defined(__powerpc64__) || defined(__s390__)) \
-    && SANITIZER_LINUX && !SANITIZER_ANDROID
+    || defined(__aarch64__) || defined(__powerpc64__) || defined(__s390__) \
+    || defined(__arm__)) && SANITIZER_LINUX && !SANITIZER_ANDROID
 // sizeof(struct pthread) from glibc.
 static atomic_uintptr_t kThreadDescriptorSize;
 
 uptr ThreadDescriptorSize() {
   uptr val = atomic_load(&kThreadDescriptorSize, memory_order_relaxed);
   if (val)
     return val;
-#if defined(__x86_64__) || defined(__i386__)
+#if defined(__x86_64__) || defined(__i386__) || defined(__arm__)
 #ifdef _CS_GNU_LIBC_VERSION
   char buf[64];
   uptr len = confstr(_CS_GNU_LIBC_VERSION, buf, sizeof(buf));
   if (len < sizeof(buf) && internal_strncmp(buf, "glibc 2.", 8) == 0) {
     char *end;
     int minor = internal_simple_strtoll(buf + 8, &end, 10);
-    if (end != buf + 8 && (*end == '\0' || *end == '.')) {
+    if (end != buf + 8 && (*end == '\0' || *end == '.' || *end == '-')) {
       int patch = 0;
       if (*end == '.')
         // strtoll will return 0 if no valid conversion could be performed
         patch = internal_simple_strtoll(end + 1, nullptr, 10);
 
       /* sizeof(struct pthread) values from various glibc versions.  */
       if (SANITIZER_X32)
         val = 1728;  // Assume only one particular version for x32.
+      // For ARM sizeof(struct pthread) changed in Glibc 2.23.
+      else if (SANITIZER_ARM)
+        val = minor <= 22 ? 1120 : 1216;
       else if (minor <= 3)
         val = FIRST_32_SECOND_64(1104, 1696);
       else if (minor == 4)
         val = FIRST_32_SECOND_64(1120, 1728);
       else if (minor == 5)
         val = FIRST_32_SECOND_64(1136, 1728);
       else if (minor <= 9)
         val = FIRST_32_SECOND_64(1136, 1712);
#elif defined(__mips__)
   return val;
 #elif defined(__aarch64__)
   // The sizeof (struct pthread) is the same from GLIBC 2.17 to 2.22.
   val = 1776;
   atomic_store(&kThreadDescriptorSize, val, memory_order_relaxed);
   return val;
 #elif defined(__powerpc64__)
   val = 1776; // from glibc.ppc64le 2.20-8.fc21
   atomic_store(&kThreadDescriptorSize, val, memory_order_relaxed);
   return val;
 #elif defined(__s390__)
   val = FIRST_32_SECOND_64(1152, 1776); // valid for glibc 2.22
   atomic_store(&kThreadDescriptorSize, val, memory_order_relaxed);
 #endif
   return 0;
 }
 
# elif defined(__mips__)
   // TCB and the size of pthread_descr.
   const uptr kTlsTcbOffset = 0x7000;
   uptr thread_pointer;
   asm volatile(".set push;\
                 .set mips64r2;\
                 rdhwr %0,$29;\
                 .set pop" : "=r" (thread_pointer));
   descr_addr = thread_pointer - kTlsTcbOffset - TlsPreTcbSize();
-# elif defined(__aarch64__)
+# elif defined(__aarch64__) || defined(__arm__)
   descr_addr = reinterpret_cast<uptr>(__builtin_thread_pointer()) -
                                       ThreadDescriptorSize();
 # elif defined(__s390__)
   descr_addr = reinterpret_cast<uptr>(__builtin_thread_pointer());
 # elif defined(__powerpc64__)
   // PPC64LE uses TLS variant I. The thread pointer (in GPR 13)
   // points to the end of the TCB + 0x7000. The pthread_descr structure is
   // immediately in front of the TCB. TlsPreTcbSize() includes the size of the

 #if !SANITIZER_GO
 static void GetTls(uptr *addr, uptr *size) {
 #if SANITIZER_LINUX && !SANITIZER_ANDROID
 # if defined(__x86_64__) || defined(__i386__) || defined(__s390__)
   *addr = ThreadSelf();
   *size = GetTlsSize();
   *addr -= *size;
   *addr += ThreadDescriptorSize();
-# elif defined(__mips__) || defined(__aarch64__) || defined(__powerpc64__)
+# elif defined(__mips__) || defined(__aarch64__) || defined(__powerpc64__) \
+    || defined(__arm__)
   *addr = ThreadSelf();
   *size = GetTlsSize();
 # else
   *addr = 0;
   *size = 0;
 # endif
 #elif SANITIZER_FREEBSD
   void** segbase = ThreadSelfSegbase();

lib/sanitizer_common/sanitizer_platform.h

 #else
 # define SANITIZER_PPC 0
 # define SANITIZER_PPC32 0
 # define SANITIZER_PPC64 0
 # define SANITIZER_PPC64V1 0
 # define SANITIZER_PPC64V2 0
 #endif
 
+#if defined(__arm__)
+# define SANITIZER_ARM 1
+#else
+# define SANITIZER_ARM 0
+#endif
+
 // By default we allow to use SizeClassAllocator64 on 64-bit platform.
 // But in some cases (e.g. AArch64's 39-bit address space) SizeClassAllocator64
 // does not work well and we need to fallback to SizeClassAllocator32.
 // For such platforms build this code with -DSANITIZER_CAN_USE_ALLOCATOR64=0 or
 // change the definition of SANITIZER_CAN_USE_ALLOCATOR64 here.
 #ifndef SANITIZER_CAN_USE_ALLOCATOR64
 # if SANITIZER_ANDROID && defined(__aarch64__)
 #  define SANITIZER_CAN_USE_ALLOCATOR64 1

lib/sanitizer_common/sanitizer_stoptheworld_linux_libcdep.cc

 // This implementation was inspired by Markus Gutschke's linuxthreads.cc.
 //
 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_platform.h"
 
 #if SANITIZER_LINUX && (defined(__x86_64__) || defined(__mips__) || \
                         defined(__aarch64__) || defined(__powerpc64__) || \
-                        defined(__s390__) || defined(__i386__))
+                        defined(__s390__) || defined(__i386__) || \
+                        defined(__arm__))
 
 #include "sanitizer_stoptheworld.h"
 
 #include "sanitizer_platform_limits_posix.h"
 #include "sanitizer_atomic.h"
 
 #include <errno.h>
 #include <sched.h> // for CLONE_* definitions

 
 uptr SuspendedThreadsList::RegisterCount() {
   return sizeof(regs_struct) / sizeof(uptr);
 }
 } // namespace __sanitizer
 
 #endif  // SANITIZER_LINUX && (defined(__x86_64__) || defined(__mips__)
         // || defined(__aarch64__) || defined(__powerpc64__)
-        // || defined(__s390__) || defined(__i386__)
+        // || defined(__s390__) || defined(__i386__) || defined(__arm__)

test/asan/TestCases/Linux/clang_gcc_abi.cc

 // RUN: %clangxx_asan -O0 -x c %s -o %t && not %run %t 2>&1 | FileCheck %s
 // RUN: %clangxx_asan -O1 -x c %s -o %t && not %run %t 2>&1 | FileCheck %s
 // RUN: %clangxx_asan -O2 -x c %s -o %t && not %run %t 2>&1 | FileCheck %s
 // RUN: %clangxx_asan -O3 -x c %s -o %t && not %run %t 2>&1 | FileCheck %s
 
-// REQUIRES: arm-target-arch
+// REQUIRES: arm-target-arch, fast-unwinder-works
 // XFAIL: armv7l-unknown-linux-gnueabihf
 
 #include <stdlib.h>
 
 __attribute__((noinline))
 int boom() {
   volatile int three = 3;
   char * volatile s = (char *)malloc(three);

test/asan/lit.cfg

 # -*- Python -*-
 
 import os
 import platform
+import re
 
 import lit.formats
 
 def get_required_attr(config, attr_name):
   attr_value = getattr(config, attr_name, None)
   if attr_value == None:
     lit_config.fatal(
       "No attribute %r in test configuration! You may need to run "

 config.substitutions.append( ("%dynamiclib", '%T/lib%xdynamiclib_namespec.so') )
 config.substitutions.append( ("%xdynamiclib_namespec", '$(basename %t).dynamic') )
 
 # Allow tests to use REQUIRES=stable-runtime.  For use when you cannot use XFAIL
 # because the test hangs. Adding armhf as we now have two modes.
 if config.target_arch != 'arm' and config.target_arch != 'armhf' and config.target_arch != 'aarch64':
   config.available_features.add('stable-runtime')
 
+# Fast unwinder doesn't work with Thumb
+if not re.match('-mthumb', config.target_cflags):
+  config.available_features.add('fast-unwinder-works')
+
 # Turn on leak detection on 64-bit Linux.
 if config.host_os == 'Linux' and (config.target_arch == 'x86_64' or config.target_arch == 'i386'):
   config.available_features.add('leak-detection')
 
 # Set LD_LIBRARY_PATH to pick dynamic runtime up properly.
 push_dynamic_library_lookup_path(config, config.compiler_rt_libdir)
 
 # GCC-ASan uses dynamic runtime by default.

test/lsan/TestCases/large_allocation_leak.cc

 // Test that LargeMmapAllocator's chunks aren't reachable via some internal data structure.
 // RUN: LSAN_BASE="detect_leaks=1:report_objects=1:use_stacks=0:use_registers=0"
 // RUN: %clangxx_lsan %s -o %t
 // RUN: LSAN_OPTIONS=$LSAN_BASE not %run %t 2>&1 | FileCheck %s
 
 // For 32 bit LSan it's pretty likely that large chunks are "reachable" from some
 // internal data structures (e.g. Glibc global data).
-// UNSUPPORTED: x86
+// UNSUPPORTED: x86, arm
 
 #include <stdio.h>
 #include <stdlib.h>
 #include "sanitizer_common/print_address.h"
 
 int main() {
   // maxsize in primary allocator is always less than this (1 << 25).
   void *large_alloc = malloc(33554432);
   print_address("Test alloc: ", 1, large_alloc);
   return 0;
 }
 // CHECK: Test alloc: [[ADDR:0x[0-9,a-f]+]]
 // CHECK: LeakSanitizer: detected memory leaks
 // CHECK: [[ADDR]] (33554432 bytes)
 // CHECK: SUMMARY: {{(Leak|Address)}}Sanitizer:

test/lsan/TestCases/swapcontext.cc

 // We can't unwind stack if we're running coroutines on heap-allocated
 // memory. Make sure we don't report these leaks.
 
 // RUN: %clangxx_lsan %s -o %t
-// RUN: %run %t 2>&1
-// RUN: not %run %t foo 2>&1 | FileCheck %s
+// RUN: LSAN_BASE="detect_leaks=1"
+// RUN: LSAN_OPTIONS=$LSAN_BASE %run %t 2>&1
+// RUN: LSAN_OPTIONS=$LSAN_BASE not %run %t foo 2>&1 | FileCheck %s
+// UNSUPPORTED: arm
 
 #include <stdio.h>
 #if defined(__APPLE__)
 // Note: ucontext.h is deprecated on OSX, so this test may stop working
 // someday. We define _XOPEN_SOURCE to keep using ucontext.h for now.
 #define _XOPEN_SOURCE 1
 #endif
 #include <ucontext.h>
 #include <unistd.h>
 
 const int kStackSize = 1 << 20;
 
 void Child() {
   int child_stack;
   printf("Child: %p\n", &child_stack);
   int *leaked = new int[666];
 }
 
 int main(int argc, char *argv[]) {
-  char stack_memory[kStackSize + 1];
+  char stack_memory[kStackSize + 1] __attribute__((aligned(4)));
   char *heap_memory = new char[kStackSize + 1];
   char *child_stack = (argc > 1) ? stack_memory : heap_memory;
 
   printf("Child stack: %p\n", child_stack);
   ucontext_t orig_context;
   ucontext_t child_context;
   getcontext(&child_context);
   child_context.uc_stack.ss_sp = child_stack;

test/lsan/TestCases/use_registers.cc

asm ( "mov %0, %%r15"
       :
       : "r" (p)
       );
 #elif defined(__mips__)
   asm ( "move $16, %0"
       :
       : "r" (p)
       );
+#elif defined(__arm__)
+  asm ( "mov r5, %0"
+      :
+      : "r" (p)
+      );
 #else
 #error "Test is not supported on this architecture."
 #endif
   print_address("Test alloc: ", 1, p);
   fflush(stderr);
   __sync_fetch_and_xor(sync, 1);
   while (true)
     sched_yield();

test/lsan/lit.common.cfg

 # -*- Python -*-
 
 # Common configuration for running leak detection tests under LSan/ASan.
 
 import os
+import re
 
 import lit.util
 
 def get_required_attr(config, attr_name):
   attr_value = getattr(config, attr_name, None)
   if attr_value == None:
     lit_config.fatal(
       "No attribute %r in test configuration! You may need to run "
def build_invocation(compile_flags):
   return " " + " ".join([config.clang] + compile_flags) + " "
 
 config.substitutions.append( ("%clang ", build_invocation(clang_cflags)) )
 config.substitutions.append( ("%clangxx ", build_invocation(clang_cxxflags)) )
 config.substitutions.append( ("%clang_lsan ", build_invocation(clang_lsan_cflags)) )
 config.substitutions.append( ("%clangxx_lsan ", build_invocation(clang_lsan_cxxflags)) )
 
 # LeakSanitizer tests are currently supported on x86-64 Linux and mips64 Linux only.
-if config.host_os not in ['Linux'] or config.host_arch not in ['x86_64', 'mips64']:
+if config.host_os not in ['Linux'] or config.host_arch not in ['x86_64', 'mips64', 'arm', 'armhf']:
+  config.unsupported = True
+
+# Don't support Thumb due to broken fast unwinder
+if re.match('-mthumb', config.target_cflags):
   config.unsupported = True
 
 config.suffixes = ['.c', '.cc', '.cpp']

test/sanitizer_common/print_address.h

 #include <stdio.h>
 #include <stdarg.h>
 
 void print_address(const char *str, int n, ...) {
   fprintf(stderr, "%s", str);
   va_list ap;
   va_start(ap, n);
   while (n--) {
     void *p = va_arg(ap, void *);
 #if defined(__x86_64__) || defined(__aarch64__) || defined(__powerpc64__)
     // On FreeBSD, the %p conversion specifier works as 0x%x and thus does not
     // match to the format used in the diagnotic message.
     fprintf(stderr, "0x%012lx ", (unsigned long) p);
-#elif defined(__i386__)
+#elif defined(__i386__) || defined(__arm__)
     fprintf(stderr, "0x%8lx ", (unsigned long) p);
 #elif defined(__mips64)
     fprintf(stderr, "0x%010lx ", (unsigned long) p);
 #endif
   }
   fprintf(stderr, "\n");
 }