Port LSan to ARM Linux

[m.ostapenko]

Summary

This patch provides initial LSan support for ARM Linux (TLS is not yet supported).

Compiler-rt doesn't support cross-compilation, so we just ran numerous (for about 10) LSan tests manually on target board.
All tests have successfully passed (all leaks were detected and backtraces were correct).

Tested on arm-linux-gnueabi.

[kcc]

As noted in https://code.google.com/p/address-sanitizer/issues/detail?id=294#c3,
lsan's job is much harder on 32-bit arch than on a 64-bit arch.
Beware that on a 32-bit arch false negatives (missing a leak) are much more probable

Do you have any plans on setting a public build bot for asan on ARM?

lsan/lsan_allocator.cc

49

instead of duplicating this struct here, please move it out of ifdef and use FIRST_32_SECOND_64(54, 22)

Also, why do you think 22 bits is enough?

58

#endif // SANITIZER_WORDSIZE

60

A comment explaining 3UL<<27 would be nice. I know 32-bit systems that can allocate more.

lsan/lsan_common.cc

251

can you use if() instead of #ifdef?
E.g. simply disable lags()->use_tls on arm?

[kcc]

Some bedtime reading on 32-bit leak detection:
https://code.google.com/p/valgrind-variant/wiki/LeakCheckingOn32bits

[m.ostapenko]

Cancelled.

lsan/lsan_allocator.cc

 #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 {
 
-static const uptr kMaxAllowedMallocSize = 8UL << 30;
+#if SANITIZER_WORDSIZE == 64
 static const uptr kAllocatorSpace = 0x600000000000ULL;
 static const uptr kAllocatorSize  =  0x40000000000ULL;  // 4T.
-
+typedef DefaultSizeClassMap SizeClassMap;
 struct ChunkMetadata {
   bool allocated : 8;  // Must be first.
   ChunkTag tag : 2;
   uptr requested_size : 54;
   u32 stack_trace_id;
 };
 
 typedef SizeClassAllocator64<kAllocatorSpace, kAllocatorSize,
-        sizeof(ChunkMetadata), DefaultSizeClassMap> PrimaryAllocator;
+        sizeof(ChunkMetadata), SizeClassMap> PrimaryAllocator;
+
+#elif SANITIZER_WORDSIZE == 32
+static const u64 kAddressSpaceSize = 1ULL << 32;
+typedef CompactSizeClassMap SizeClassMap;
+static const uptr kRegionSizeLog = 20;
+static const uptr kFlatByteMapSize = kAddressSpaceSize >> kRegionSizeLog;
+struct ChunkMetadata {
+  bool allocated : 8;  // Must be first.
+  ChunkTag tag : 2;
+  uptr requested_size : 22;
+  u32 stack_trace_id;
+};
+
+typedef SizeClassAllocator32<0, kAddressSpaceSize, sizeof(ChunkMetadata),
+  SizeClassMap, kRegionSizeLog,
+  FlatByteMap<kFlatByteMapSize> >
+  PrimaryAllocator;
+
+#endif
+
+static const uptr kMaxAllowedMallocSize = FIRST_32_SECOND_64(3UL << 27, 8UL << 30);
+
 typedef SizeClassAllocatorLocalCache<PrimaryAllocator> AllocatorCache;
 typedef LargeMmapAllocator<> SecondaryAllocator;
 typedef CombinedAllocator<PrimaryAllocator, AllocatorCache,
           SecondaryAllocator> Allocator;
 
 static Allocator allocator;
 static THREADLOCAL AllocatorCache cache;
 

lsan/lsan_common.h

 #define LSAN_COMMON_H
 
 #include "sanitizer_common/sanitizer_allocator.h"
 #include "sanitizer_common/sanitizer_common.h"
 #include "sanitizer_common/sanitizer_internal_defs.h"
 #include "sanitizer_common/sanitizer_platform.h"
 #include "sanitizer_common/sanitizer_symbolizer.h"
 
-#if SANITIZER_LINUX && defined(__x86_64__)
+#if SANITIZER_LINUX && (defined(__x86_64__) || defined(__arm__))
 #define CAN_SANITIZE_LEAKS 1
 #else
 #define CAN_SANITIZE_LEAKS 0
 #endif
 
 namespace __lsan {
 
 // Chunk tags.

lsan/lsan_common.cc

if (flags()->use_stacks) {
       } else {
         // Shrink the stack range to ignore out-of-scope values.
         stack_begin = sp;
       }
       ScanRangeForPointers(stack_begin, stack_end, frontier, "STACK",
                            kReachable);
       ForEachExtraStackRange(os_id, ForEachExtraStackRangeCb, frontier);
     }
-
+// TODO: implement for arm.
+#if defined(__x86_64__)
     if (flags()->use_tls) {
       LOG_THREADS("TLS at %p-%p.\n", tls_begin, tls_end);
       if (cache_begin == cache_end) {
         ScanRangeForPointers(tls_begin, tls_end, frontier, "TLS", kReachable);
       } else {
         // Because LSan should not be loaded with dlopen(), we can assume
         // that allocator cache will be part of static TLS image.
         CHECK_LE(tls_begin, cache_begin);
         CHECK_GE(tls_end, cache_end);
         if (tls_begin < cache_begin)
           ScanRangeForPointers(tls_begin, cache_begin, frontier, "TLS",
                                kReachable);
         if (tls_end > cache_end)
           ScanRangeForPointers(cache_end, tls_end, frontier, "TLS", kReachable);
       }
     }
+#endif
   }
 }
 
 static void ProcessRootRegion(Frontier *frontier, uptr root_begin,
                               uptr root_end) {
   MemoryMappingLayout proc_maps(/*cache_enabled*/true);
   uptr begin, end, prot;
   while (proc_maps.Next(&begin, &end,

lsan/lsan_interceptors.cc

 #include "sanitizer_common/sanitizer_flags.h"
 #include "sanitizer_common/sanitizer_interception.h"
 #include "sanitizer_common/sanitizer_internal_defs.h"
 #include "sanitizer_common/sanitizer_linux.h"
 #include "sanitizer_common/sanitizer_platform_limits_posix.h"
 #include "lsan.h"
 #include "lsan_allocator.h"
 #include "lsan_thread.h"
+#include <stddef.h>
 
 using namespace __lsan;
 
 extern "C" {
 int pthread_attr_init(void *attr);
 int pthread_attr_destroy(void *attr);
 int pthread_attr_getdetachstate(void *attr, int *v);
 int pthread_key_create(unsigned *key, void (*destructor)(void* v));

 INTERCEPTOR(void, cfree, void *p) ALIAS(WRAPPER_NAME(free));
 
 #define OPERATOR_NEW_BODY                              \
   ENSURE_LSAN_INITED;                                  \
   GET_STACK_TRACE;                                     \
   return Allocate(stack, size, 1, kAlwaysClearMemory);
 
 INTERCEPTOR_ATTRIBUTE
-void *operator new(uptr size) { OPERATOR_NEW_BODY; }
+void *operator new(size_t size) { OPERATOR_NEW_BODY; }
 INTERCEPTOR_ATTRIBUTE
-void *operator new[](uptr size) { OPERATOR_NEW_BODY; }
+void *operator new[](size_t size) { OPERATOR_NEW_BODY; }
 INTERCEPTOR_ATTRIBUTE
-void *operator new(uptr size, std::nothrow_t const&) { OPERATOR_NEW_BODY; }
+void *operator new(size_t size, std::nothrow_t const&) { OPERATOR_NEW_BODY; }
 INTERCEPTOR_ATTRIBUTE
-void *operator new[](uptr size, std::nothrow_t const&) { OPERATOR_NEW_BODY; }
+void *operator new[](size_t size, std::nothrow_t const&) { OPERATOR_NEW_BODY; }
 
 #define OPERATOR_DELETE_BODY \
   ENSURE_LSAN_INITED;        \
   Deallocate(ptr);
 
 INTERCEPTOR_ATTRIBUTE
 void operator delete(void *ptr) throw() { OPERATOR_DELETE_BODY; }
 INTERCEPTOR_ATTRIBUTE

sanitizer_common/sanitizer_linux.h

 // Linux-only syscalls.
 #if SANITIZER_LINUX
 uptr internal_prctl(int option, uptr arg2, uptr arg3, uptr arg4, uptr arg5);
 // Used only by sanitizer_stoptheworld. Signal handlers that are actually used
 // (like the process-wide error reporting SEGV handler) must use
 // internal_sigaction instead.
 int internal_sigaction_norestorer(int signum, const void *act, void *oldact);
 void internal_sigdelset(__sanitizer_sigset_t *set, int signum);
-#if defined(__x86_64__)
+#if defined(__x86_64__) || 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:

sanitizer_common/sanitizer_linux.cc

__asm__ __volatile__(
                          "S"(child_stack),
                          "D"(flags),
                          "d"(parent_tidptr),
                          "r"(r8),
                          "r"(r10)
                        : "rsp", "memory", "r11", "rcx");
   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;
+  __asm__ __volatile__(
+                       "push    {r4, r7}\n"
+                       "swi 0x0\n"
+                       "cmp r0, #0\n"
+                       "bne 1f\n"
+                       "ldr r0, [sp, #4]\n"
+#if defined(__ARM_ARCH_4T__) && defined(__THUMB_INTERWORK__)
+                       "ldr     ip, [sp], #8\n"
+                       "mov lr, pc\n"
+                       "bx      ip\n"
+#else
+                       "ldr     lr, [sp], #8\n"
+                       "blx lr\n"
+#endif
+                       "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
 // This thing is not, strictly speaking, async signal safe, but it does not seem
 // to cause any issues. Alternative is writing to log devices directly, but
 // their location and message format might change in the future, so we'd really
 // like to avoid that.
 void AndroidLogWrite(const char *buffer) {

sanitizer_common/sanitizer_platform_limits_posix.h

 
 #if SANITIZER_MAC
   typedef unsigned long __sanitizer_pthread_key_t;
 #else
   typedef unsigned __sanitizer_pthread_key_t;
 #endif
 
 #if SANITIZER_LINUX && !SANITIZER_ANDROID
+#if defined(__x86_64__) || defined(__i386__)
+  const unsigned xdr_ops_fn_num = 10;
+#elif defined(__arm__)
+  const unsigned xdr_ops_fn_num = 9;
+#endif
   struct __sanitizer_XDR {
     int x_op;
     struct xdr_ops {
-      uptr fns[10];
+      uptr fns[xdr_ops_fn_num];
     } *x_ops;
     uptr x_public;
     uptr x_private;
     uptr x_base;
     unsigned x_handy;
   };
 
   const int __sanitizer_XDR_ENCODE = 0;

sanitizer_common/sanitizer_stoptheworld_linux_libcdep.cc

 //===-- sanitizer_stoptheworld_linux_libcdep.cc ---------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // See sanitizer_stoptheworld.h for details.
 // This implementation was inspired by Markus Gutschke's linuxthreads.cc.
 //
 //===----------------------------------------------------------------------===//
 
 
 #include "sanitizer_platform.h"
-#if SANITIZER_LINUX && defined(__x86_64__)
+#if SANITIZER_LINUX && (defined(__x86_64__) || defined(__arm__))
 
 #include "sanitizer_stoptheworld.h"
 
 #include "sanitizer_platform_limits_posix.h"
 
 #include <errno.h>
 #include <sched.h> // for CLONE_* definitions
 #include <stddef.h>
int SuspendedThreadsList::GetRegistersAndSP(uptr index,
   return 0;
 }
 
 uptr SuspendedThreadsList::RegisterCount() {
   return sizeof(regs_struct) / sizeof(uptr);
 }
 }  // namespace __sanitizer
 
-#endif  // SANITIZER_LINUX && defined(__x86_64__)
+#endif  // SANITIZER_LINUX && (defined(__x86_64__) || defined(__arm__))