[LSan] Enable for SystemZ

[iii]

Summary

Add runtime support, adjust the tests and enable LSan.

[iii]

Rebased.

[uweigand]

This all looks good to me.

[MaskRay]

compiler-rt/lib/lsan/lsan_allocator.h

76

Why is 0x40000000000ULL used?

Does 0x50000000000ULL or 0x60000000000ULL work as well?

[jonpa]

Update clang/docs/LeakSanitizer.rst (Supported Platforms).

[iii]

That's where the mappings normally end. Example:

$ cat /proc/self/maps
2aa00000000-2aa00002000 r--p 00000000 5e:01 668061                       /usr/bin/cat
2aa00002000-2aa00006000 r-xp 00002000 5e:01 668061                       /usr/bin/cat
2aa00006000-2aa00008000 r--p 00006000 5e:01 668061                       /usr/bin/cat
2aa00008000-2aa00009000 r--p 00007000 5e:01 668061                       /usr/bin/cat
2aa00009000-2aa0000a000 rw-p 00008000 5e:01 668061                       /usr/bin/cat
2aa0000a000-2aa0002b000 rw-p 00000000 00:00 0                            [heap]
3fff7500000-3fff7557000 r--p 00000000 5e:01 926342                       /usr/lib/locale/C.utf8/LC_CTYPE
3fff7580000-3fff7581000 r--p 00000000 5e:01 658596                       /usr/lib/locale/en_US.utf8/LC_NUMERIC
3fff7600000-3fff7878000 r--p 00000000 5e:01 658592                       /usr/lib/locale/en_US.utf8/LC_COLLATE
3fff7880000-3fff7881000 r--p 00000000 5e:01 786499                       /usr/lib/locale/en_US.utf8/LC_TIME
3fff7900000-3fff7901000 r--p 00000000 5e:01 786497                       /usr/lib/locale/en_US.utf8/LC_MONETARY
3fff7980000-3fff7981000 r--p 00000000 5e:01 658594                       /usr/lib/locale/en_US.utf8/LC_MESSAGES/SYS_LC_MESSAGES
3fff7a00000-3fff7a01000 r--p 00000000 5e:01 658611                       /usr/lib/locale/en_US.utf8/LC_PAPER
3fff7a80000-3fff7a81000 r--p 00000000 5e:01 658595                       /usr/lib/locale/en_US.utf8/LC_NAME
3fff7b00000-3fff7b01000 r--p 00000000 5e:01 786493                       /usr/lib/locale/en_US.utf8/LC_ADDRESS
3fff7b80000-3fff7b81000 r--p 00000000 5e:01 786498                       /usr/lib/locale/en_US.utf8/LC_TELEPHONE
3fff7c00000-3fff7c34000 r--p 00000000 5e:01 655337                       /usr/lib64/libc.so.6
3fff7c34000-3fff7d6e000 r-xp 00034000 5e:01 655337                       /usr/lib64/libc.so.6
3fff7d6e000-3fff7dc5000 r--p 0016e000 5e:01 655337                       /usr/lib64/libc.so.6
3fff7dc5000-3fff7dc6000 ---p 001c5000 5e:01 655337                       /usr/lib64/libc.so.6
3fff7dc6000-3fff7dca000 r--p 001c5000 5e:01 655337                       /usr/lib64/libc.so.6
3fff7dca000-3fff7dcc000 rw-p 001c9000 5e:01 655337                       /usr/lib64/libc.so.6
3fff7dcc000-3fff7dd4000 rw-p 00000000 00:00 0 
3fff7e00000-3fff7e01000 r--p 00000000 5e:01 786496                       /usr/lib/locale/en_US.utf8/LC_MEASUREMENT
3fff7e80000-3fff7e87000 r--s 00000000 5e:01 654146                       /usr/lib64/gconv/gconv-modules.cache
3fff7f00000-3fff7f01000 r--p 00000000 5e:01 786495                       /usr/lib/locale/en_US.utf8/LC_IDENTIFICATION
3fff7f80000-3fff7f82000 r--p 00000000 5e:01 655334                       /usr/lib/ld64.so.1
3fff7f82000-3fff7fa2000 r-xp 00002000 5e:01 655334                       /usr/lib/ld64.so.1
3fff7fa2000-3fff7fad000 r--p 00022000 5e:01 655334                       /usr/lib/ld64.so.1
3fff7fad000-3fff7faf000 r--p 0002c000 5e:01 655334                       /usr/lib/ld64.so.1
3fff7faf000-3fff7fb1000 rw-p 0002e000 5e:01 655334                       /usr/lib/ld64.so.1
3fff7fd3000-3fff7ffb000 rw-p 00000000 00:00 0 
3fffffda000-3ffffffb000 rw-p 00000000 00:00 0                            [stack]
3ffffffc000-3ffffffe000 r--p 00000000 00:00 0                            [vvar]
3ffffffe000-40000000000 r-xp 00000000 00:00 0                            [vdso]

A higher address should work as well. I will test 0x50000000000ULL and 0x60000000000ULL and let you know the result.

[iii]

I guess the intention is dropping the special case? The following patch passes regtests:

--- a/compiler-rt/lib/lsan/lsan_allocator.h
+++ b/compiler-rt/lib/lsan/lsan_allocator.h
@@ -68,9 +68,6 @@ using PrimaryAllocator = PrimaryAllocatorASVT<LocalAddressSpaceView>;
 # if SANITIZER_FUCHSIA || defined(__powerpc64__)
 const uptr kAllocatorSpace = ~(uptr)0;
 const uptr kAllocatorSize  =  0x40000000000ULL;  // 4T.
-#elif defined(__s390x__)
-const uptr kAllocatorSpace = 0x40000000000ULL;
-const uptr kAllocatorSize = 0x40000000000ULL;  // 4T.
 # else
 const uptr kAllocatorSpace = 0x600000000000ULL;
 const uptr kAllocatorSize  = 0x40000000000ULL;  // 4T.

0x50000000000ULL worked as well.

[MaskRay]

In D78644#4268685, @iii wrote:

I guess the intention is dropping the special case? The following patch passes regtests:

--- a/compiler-rt/lib/lsan/lsan_allocator.h
+++ b/compiler-rt/lib/lsan/lsan_allocator.h
@@ -68,9 +68,6 @@ using PrimaryAllocator = PrimaryAllocatorASVT<LocalAddressSpaceView>;
 # if SANITIZER_FUCHSIA || defined(__powerpc64__)
 const uptr kAllocatorSpace = ~(uptr)0;
 const uptr kAllocatorSize  =  0x40000000000ULL;  // 4T.
-#elif defined(__s390x__)
-const uptr kAllocatorSpace = 0x40000000000ULL;
-const uptr kAllocatorSize = 0x40000000000ULL;  // 4T.
 # else
 const uptr kAllocatorSpace = 0x600000000000ULL;
 const uptr kAllocatorSize  = 0x40000000000ULL;  // 4T.

0x50000000000ULL worked as well.

Thank you! I will try removing the special case in D148193

clang/lib/Driver/ToolChains/Linux.cpp

SanitizerMask Linux::getSupportedSanitizers() const {
   const bool IsPowerPC64 = getTriple().getArch() == llvm::Triple::ppc64 ||
                            getTriple().getArch() == llvm::Triple::ppc64le;
   const bool IsAArch64 = getTriple().getArch() == llvm::Triple::aarch64 ||
                          getTriple().getArch() == llvm::Triple::aarch64_be;
   const bool IsArmArch = getTriple().getArch() == llvm::Triple::arm ||
                          getTriple().getArch() == llvm::Triple::thumb ||
                          getTriple().getArch() == llvm::Triple::armeb ||
                          getTriple().getArch() == llvm::Triple::thumbeb;
+  const bool IsSystemZ = getTriple().getArch() == llvm::Triple::systemz;
   SanitizerMask Res = ToolChain::getSupportedSanitizers();
   Res |= SanitizerKind::Address;
   Res |= SanitizerKind::PointerCompare;
   Res |= SanitizerKind::PointerSubtract;
   Res |= SanitizerKind::Fuzzer;
   Res |= SanitizerKind::FuzzerNoLink;
   Res |= SanitizerKind::KernelAddress;
   Res |= SanitizerKind::Memory;
   Res |= SanitizerKind::Vptr;
   Res |= SanitizerKind::SafeStack;
   if (IsX86_64 || IsMIPS64 || IsAArch64)
     Res |= SanitizerKind::DataFlow;
-  if (IsX86_64 || IsMIPS64 || IsAArch64 || IsX86 || IsArmArch || IsPowerPC64)
+  if (IsX86_64 || IsMIPS64 || IsAArch64 || IsX86 || IsArmArch || IsPowerPC64 ||
+      IsSystemZ)
     Res |= SanitizerKind::Leak;
   if (IsX86_64 || IsMIPS64 || IsAArch64 || IsPowerPC64)
     Res |= SanitizerKind::Thread;
   if (IsX86_64)
     Res |= SanitizerKind::KernelMemory;
   if (IsX86 || IsX86_64)
     Res |= SanitizerKind::Function;
   if (IsX86_64 || IsMIPS64 || IsAArch64 || IsX86 || IsMIPS || IsArmArch ||

compiler-rt/cmake/config-ix.cmake

 else()
   set(ALL_FUZZER_SUPPORTED_ARCH ${X86_64} ${ARM64})
 endif()
 
 set(ALL_GWP_ASAN_SUPPORTED_ARCH ${X86} ${X86_64})
 if(APPLE)
   set(ALL_LSAN_SUPPORTED_ARCH ${X86} ${X86_64} ${MIPS64} ${ARM64})
 else()
-  set(ALL_LSAN_SUPPORTED_ARCH ${X86} ${X86_64} ${MIPS64} ${ARM64} ${ARM32} ${PPC64})
+  set(ALL_LSAN_SUPPORTED_ARCH ${X86} ${X86_64} ${MIPS64} ${ARM64} ${ARM32} ${PPC64} ${S390X})
 endif()
 set(ALL_MSAN_SUPPORTED_ARCH ${X86_64} ${MIPS64} ${ARM64} ${PPC64} ${S390X})
 set(ALL_HWASAN_SUPPORTED_ARCH ${X86_64} ${ARM64})
 set(ALL_PROFILE_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64} ${PPC64}
     ${MIPS32} ${MIPS64} ${S390X} ${SPARC} ${SPARCV9})
 set(ALL_TSAN_SUPPORTED_ARCH ${X86_64} ${MIPS64} ${ARM64} ${PPC64})
 set(ALL_UBSAN_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64} ${RISCV64}
     ${MIPS32} ${MIPS64} ${PPC64} ${S390X} ${SPARC} ${SPARCV9})

compiler-rt/lib/lsan/lsan_allocator.h

struct AP32 {
   static const uptr kRegionSizeLog = 20;
   using AddressSpaceView = AddressSpaceViewTy;
   typedef NoOpMapUnmapCallback MapUnmapCallback;
   static const uptr kFlags = 0;
 };
 template <typename AddressSpaceView>
 using PrimaryAllocatorASVT = SizeClassAllocator32<AP32<AddressSpaceView>>;
 using PrimaryAllocator = PrimaryAllocatorASVT<LocalAddressSpaceView>;
-#elif defined(__x86_64__) || defined(__powerpc64__)
+#elif defined(__x86_64__) || defined(__powerpc64__) || defined(__s390x__)
 # if SANITIZER_FUCHSIA
 const uptr kAllocatorSpace = ~(uptr)0;
 const uptr kAllocatorSize  =  0x40000000000ULL;  // 4T.
 # elif defined(__powerpc64__)
 const uptr kAllocatorSpace = 0xa0000000000ULL;
 const uptr kAllocatorSize  = 0x20000000000ULL;  // 2T.
+#elif defined(__s390x__)
+const uptr kAllocatorSpace = 0x40000000000ULL;
+const uptr kAllocatorSize = 0x40000000000ULL;  // 4T.
 # else
 const uptr kAllocatorSpace = 0x600000000000ULL;
 const uptr kAllocatorSize  = 0x40000000000ULL;  // 4T.
 # endif
 template <typename AddressSpaceViewTy>
 struct AP64 {  // Allocator64 parameters. Deliberately using a short name.
   static const uptr kSpaceBeg = kAllocatorSpace;
   static const uptr kSpaceSize = kAllocatorSize;

compiler-rt/lib/lsan/lsan_common.h

 // LeakSanitizer relies on some Glibc's internals (e.g. TLS machinery) on Linux.
 // Also, LSan doesn't like 32 bit architectures
 // because of "small" (4 bytes) pointer size that leads to high false negative
 // 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 a new architecture, one needs to implement the
 // internal_clone function as well as (probably) adjust the TLS machinery for
 // the new architecture inside the sanitizer library.
-#if (SANITIZER_LINUX && !SANITIZER_ANDROID || SANITIZER_MAC) && \
-    (SANITIZER_WORDSIZE == 64) &&                               \
+#if (SANITIZER_LINUX && !SANITIZER_ANDROID || SANITIZER_MAC) &&          \
+    (SANITIZER_WORDSIZE == 64) &&                                        \
     (defined(__x86_64__) || defined(__mips64) || defined(__aarch64__) || \
-     defined(__powerpc64__))
+     defined(__powerpc64__) || defined(__s390x__))
 #define CAN_SANITIZE_LEAKS 1
 #elif defined(__i386__) && \
     (SANITIZER_LINUX && !SANITIZER_ANDROID || SANITIZER_MAC)
 #define CAN_SANITIZE_LEAKS 1
 #elif defined(__arm__) && \
     SANITIZER_LINUX && !SANITIZER_ANDROID
 #define CAN_SANITIZE_LEAKS 1
 #elif SANITIZER_NETBSD || SANITIZER_FUCHSIA

compiler-rt/test/lsan/TestCases/stale_stack_leak.cpp

 // Test that out-of-scope local variables are ignored by LSan.
 // RUN: LSAN_BASE="report_objects=1:use_registers=0:use_stacks=1"
 // RUN: %clangxx_lsan %s -o %t
 // RUN: %env_lsan_opts=$LSAN_BASE not %run %t 2>&1 | FileCheck %s
 // RUN: %env_lsan_opts=$LSAN_BASE":exitcode=0" %run %t 2>&1 | FileCheck --check-prefix=CHECK-sanity %s
 //
 // x86 passes parameters through stack that may lead to false negatives
-// UNSUPPORTED: x86,powerpc64,arm
+// The same applies to s390x register save areas.
+// UNSUPPORTED: x86,powerpc64,arm,s390x
 
 #include <stdio.h>
 #include <stdlib.h>
 #include "sanitizer_common/print_address.h"
 
 void **pp;
 
 // Put pointer far enough on the stack that LSan has space to run in without

compiler-rt/test/lsan/TestCases/use_registers.cpp

asm ( "mov r5, %0"
       :
       : "r" (p)
       );
 #elif defined(__powerpc__)
   asm ( "mr 30, %0"
       :
       : "r" (p)
       );
+#elif defined(__s390x__)
+  asm("lgr %%r10, %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();

compiler-rt/test/lsan/lit.common.cfg.py

 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, PowerPC64 Linux, arm Linux, mips64 Linux, and x86_64 Darwin.
-supported_linux = config.host_os is 'Linux' and config.host_arch in ['x86_64', 'ppc64', 'ppc64le', 'mips64', 'arm', 'armhf', 'armv7l']
+# LeakSanitizer tests are currently supported on x86-64 Linux, PowerPC64 Linux, arm Linux, mips64 Linux, s390x Linux and x86_64 Darwin.
+supported_linux = config.host_os is 'Linux' and config.host_arch in ['x86_64', 'ppc64', 'ppc64le', 'mips64', 'arm', 'armhf', 'armv7l', 's390x']
 supported_darwin = config.host_os is 'Darwin' and config.target_arch is 'x86_64'
 supported_netbsd = config.host_os is 'NetBSD' and config.target_arch in ['x86_64', 'i386']
 if not (supported_linux or supported_darwin or supported_netbsd):
   config.unsupported = True
 
 # Don't support Thumb due to broken fast unwinder
 if re.search('mthumb', config.target_cflags) is not None:
   config.unsupported = True
 
 config.suffixes = ['.c', '.cpp', '.mm']

compiler-rt/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__)
+#if defined(__x86_64__) || defined(__aarch64__) || defined(__powerpc64__) || \
+    defined(__s390x__)
     // 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__) || defined(__arm__)
     fprintf(stderr, "0x%08lx ", (unsigned long) p);
 #elif defined(__mips64)
     fprintf(stderr, "0x%010lx ", (unsigned long) p);
 #endif
   }
   fprintf(stderr, "\n");
 }