[MSan] Enable for SystemZ

[iii]

Summary

This patch adds runtime support, adjusts tests and enables MSan.

Like for ASan and UBSan, compile the tests with -mbackchain.

[eugenis]

LGTM with 2 comments.

VarArgHelper implementation looks reasonable, but I did not review it in-depth.

compiler-rt/lib/msan/msan_interceptors.cpp

978 ↗

(On Diff #251060)

Please upload this as a separate change.
I think there should be () around rounded_length - 1, otherwise this will trigger UB when the mapping ends at max(uintptr_t).

compiler-rt/lib/sanitizer_common/sanitizer_linux_s390.cpp

128 ↗

(On Diff #251060)

Another option is to provide internal_uname() implemented via raw system call. Just FYI.

[iii]

compiler-rt/lib/msan/msan_interceptors.cpp

978 ↗

(On Diff #251060)

I've uploaded this with the () fix as https://reviews.llvm.org/D76426.

compiler-rt/lib/sanitizer_common/sanitizer_linux_s390.cpp

128 ↗

(On Diff #251060)

Which way is the preferred one?

I chose to use libc version, because I don't need to worry about the calling sequence.

[eugenis]

compiler-rt/lib/sanitizer_common/sanitizer_linux_s390.cpp

128 ↗

(On Diff #251060)

oh, I think a better way is to use DECLARE_REAL and then call REAL(uname) if you know that this function is intercepted.

[iii]

compiler-rt/lib/sanitizer_common/sanitizer_linux_s390.cpp

128 ↗

(On Diff #251060)

Ah, that's another problem here: this code is common for all sanitizers, but only msan intercepts uname, so right now I don't think I can tell whether uname is intercepted.

Would it make sense to move uname interceptor to sanitizer_common_interceptors.inc, or is this an overkill?

[eugenis]

compiler-rt/lib/sanitizer_common/sanitizer_linux_s390.cpp

128 ↗

(On Diff #251060)

Yes, absolutely! ASan and TSan can catch races and addressability issues on the utsname argument.

[vitalybuka]

compiler-rt/lib/sanitizer_common/sanitizer_linux_s390.cpp

128 ↗

(On Diff #251060)

in a separate patch, I guess.

[iii]

compiler-rt/lib/sanitizer_common/sanitizer_linux_s390.cpp

128 ↗

(On Diff #251060)

Seems like this isn't going to work either: ubsan does not use sanitizer_common_interceptors.inc, but still links with sanitizer_linux_s390.cpp. Because of this, attempting to use REAL(uname) leads to a linker error.

[eugenis]

compiler-rt/lib/sanitizer_common/sanitizer_linux_s390.cpp

128 ↗

(On Diff #251060)

Then I guess I'm fine with this.
Vitaly?

[vitalybuka]

compiler-rt/lib/sanitizer_common/sanitizer_linux_s390.cpp

128 ↗

(On Diff #251060)

I am fine with this.

However I would recommend separate compiler-rt and Instrumentation changes
Both needed for s390, but they are independent

llvm/lib/Transforms/Instrumentation/MemorySanitizer.cpp

4907 ↗

(On Diff #251060)

I guess it's better to have some test for the new Target?

[iii]

Split out mmap (already landed), uname and instrumentation
changes.

Therefore, following changes need to land first:

• https://reviews.llvm.org/D76578 (uname)
• https://reviews.llvm.org/D76624 (instrumentation)

[eugenis]

LGTM

[iii]

Instead of checking only top frame, compile tests with
-mbackchain, like we already do for ASan and UBSan.

[iii]

@eugenis I slightly improved the tests - could you have another look please?

[eugenis]

LGTM

compiler-rt/cmake/config-ix.cmake

 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})
 endif()
-set(ALL_MSAN_SUPPORTED_ARCH ${X86_64} ${MIPS64} ${ARM64} ${PPC64})
+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})
 set(ALL_SAFESTACK_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM64} ${MIPS32} ${MIPS64})
 set(ALL_CFI_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64} ${MIPS64})

compiler-rt/lib/msan/msan.h

 //   High: 3000 0000 0000 - 3fff ffff ffff  ->  0000 0000 0000 - 0fff ffff ffff
 //   High: 4000 0000 0000 - 4fff ffff ffff  ->  0000 0000 0000 - 0fff ffff ffff
 //   High: 7000 0000 0000 - 7fff ffff ffff  ->  0000 0000 0000 - 0fff ffff ffff
 #define LINEARIZE_MEM(mem) \
   (((uptr)(mem) & ~0xE00000000000ULL) ^ 0x100000000000ULL)
 #define MEM_TO_SHADOW(mem) (LINEARIZE_MEM((mem)) + 0x080000000000ULL)
 #define SHADOW_TO_ORIGIN(shadow) (((uptr)(shadow)) + 0x140000000000ULL)
 
+#elif SANITIZER_LINUX && SANITIZER_S390_64
+const MappingDesc kMemoryLayout[] = {
+    {0x000000000000ULL, 0x040000000000ULL, MappingDesc::APP, "low memory"},
+    {0x040000000000ULL, 0x080000000000ULL, MappingDesc::INVALID, "invalid"},
+    {0x080000000000ULL, 0x180000000000ULL, MappingDesc::SHADOW, "shadow"},
+    {0x180000000000ULL, 0x1C0000000000ULL, MappingDesc::INVALID, "invalid"},
+    {0x1C0000000000ULL, 0x2C0000000000ULL, MappingDesc::ORIGIN, "origin"},
+    {0x2C0000000000ULL, 0x440000000000ULL, MappingDesc::INVALID, "invalid"},
+    {0x440000000000ULL, 0x500000000000ULL, MappingDesc::APP, "high memory"}};
+
+#define MEM_TO_SHADOW(mem) \
+  ((((uptr)(mem)) & ~0xC00000000000ULL) + 0x080000000000ULL)
+#define SHADOW_TO_ORIGIN(shadow) (((uptr)(shadow)) + 0x140000000000ULL)
+
 #elif SANITIZER_FREEBSD && SANITIZER_WORDSIZE == 64
 
 // Low memory: main binary, MAP_32BIT mappings and modules
 // High memory: heap, modules and main thread stack
 const MappingDesc kMemoryLayout[] = {
     {0x000000000000ULL, 0x010000000000ULL, MappingDesc::APP, "low memory"},
     {0x010000000000ULL, 0x100000000000ULL, MappingDesc::INVALID, "invalid"},
     {0x100000000000ULL, 0x310000000000ULL, MappingDesc::SHADOW, "shadow"},

compiler-rt/lib/msan/msan_allocator.cpp

struct AP64 {  // Allocator64 parameters. Deliberately using a short name.
   static const uptr kMetadataSize = sizeof(Metadata);
   typedef DefaultSizeClassMap SizeClassMap;
   typedef MsanMapUnmapCallback MapUnmapCallback;
   static const uptr kFlags = 0;
   using AddressSpaceView = LocalAddressSpaceView;
 };
 
 typedef SizeClassAllocator64<AP64> PrimaryAllocator;
+#elif defined(__s390x__)
+static const uptr kMaxAllowedMallocSize = 2UL << 30;  // 2G
+
+struct AP64 {  // Allocator64 parameters. Deliberately using a short name.
+  static const uptr kSpaceBeg = 0x440000000000;
+  static const uptr kSpaceSize = 0x020000000000;  // 2T.
+  static const uptr kMetadataSize = sizeof(Metadata);
+  typedef DefaultSizeClassMap SizeClassMap;
+  typedef MsanMapUnmapCallback MapUnmapCallback;
+  static const uptr kFlags = 0;
+  using AddressSpaceView = LocalAddressSpaceView;
+};
+
+typedef SizeClassAllocator64<AP64> PrimaryAllocator;
 #elif defined(__aarch64__)
 static const uptr kMaxAllowedMallocSize = 2UL << 30;  // 2G
 
 struct AP32 {
   static const uptr kSpaceBeg = 0;
   static const u64 kSpaceSize = SANITIZER_MMAP_RANGE_SIZE;
   static const uptr kMetadataSize = sizeof(Metadata);
   typedef __sanitizer::CompactSizeClassMap SizeClassMap;

compiler-rt/test/msan/backtrace.cpp

 // RUN: %clangxx_msan -O0 %s -o %t && %run %t
 
 #include <assert.h>
 #include <execinfo.h>
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 
 __attribute__((noinline))
 void f() {
   void *buf[10];
   int sz = backtrace(buf, sizeof(buf) / sizeof(*buf));
   assert(sz > 0);
   for (int i = 0; i < sz; ++i)
-    if (!buf[i])
+    if (!buf[i]) {
+#if defined(__s390x__)
+      // backtrace() may return a bogus trailing NULL on s390x.
+      if (i == sz - 1)
+        continue;
+#endif
       exit(1);
+    }
   char **s = backtrace_symbols(buf, sz);
   assert(s != 0);
   for (int i = 0; i < sz; ++i)
     printf("%d\n", (int)strlen(s[i]));
 }
 
 int main(void) {
   f();
   return 0;
 }

compiler-rt/test/msan/lit.cfg.py

clang_msan_cflags = (["-fsanitize=memory",
                       "-mno-omit-leaf-frame-pointer",
                       "-fno-omit-frame-pointer",
                       "-fno-optimize-sibling-calls"] +
                       [config.target_cflags] +
                       config.debug_info_flags)
 # Some Msan tests leverage backtrace() which requires libexecinfo on FreeBSD.
 if config.host_os == 'FreeBSD':
   clang_msan_cflags += ["-lexecinfo", "-fPIC"]
+# On SystemZ we need -mbackchain to make the fast unwinder work.
+if config.target_arch == 's390x':
+  clang_msan_cflags.append("-mbackchain")
 clang_msan_cxxflags = config.cxx_mode_flags + clang_msan_cflags
 
 # Flags for KMSAN invocation. This is C-only, we're not interested in C++.
 clang_kmsan_cflags = (["-fsanitize=kernel-memory"] +
                       [config.target_cflags] +
                       config.debug_info_flags)
 
 def build_invocation(compile_flags):

compiler-rt/test/msan/mmap.cpp

return (addr >= 0x000000000000ULL && addr < 0x010000000000ULL) ||
          (addr >= 0x510000000000ULL && addr < 0x600000000000ULL) ||
          (addr >= 0x700000000000ULL && addr < 0x800000000000ULL);
 #elif defined(__mips64)
   return (addr >= 0x0000000000ULL && addr <= 0x0200000000ULL) ||
          (addr >= 0xa200000000ULL && addr <= 0xc000000000ULL) ||
          addr >= 0xe200000000ULL;
 #elif defined(__powerpc64__)
   return addr < 0x000100000000ULL || addr >= 0x300000000000ULL;
+#elif defined(__s390x__)
+  return addr < 0x040000000000ULL ||
+         (addr >= 0x440000000000ULL && addr < 0x500000000000);
 #elif defined(__aarch64__)
 
   struct AddrMapping {
     uintptr_t start;
     uintptr_t end;
   } mappings[] = {
     {0x05000000000ULL, 0x06000000000ULL},
     {0x07000000000ULL, 0x08000000000ULL},

compiler-rt/test/msan/mmap_below_shadow.cpp

#elif defined(__x86_64__)
   uintptr_t hint = 0x4f0000000000ULL;
   const uintptr_t app_start = 0x600000000000ULL;
 #elif defined (__mips64)
   uintptr_t hint = 0x4f00000000ULL;
   const uintptr_t app_start = 0x6000000000ULL;
 #elif defined (__powerpc64__)
   uintptr_t hint = 0x2f0000000000ULL;
   const uintptr_t app_start = 0x300000000000ULL;
+#elif defined(__s390x__)
+  uintptr_t hint = 0x07f000000000ULL;
+  const uintptr_t app_start = 0x020000000000ULL;
 #elif defined (__aarch64__)
   uintptr_t hint = 0x4f0000000ULL;
   const uintptr_t app_start = 0x7000000000ULL;
 #endif
   uintptr_t p = (uintptr_t)mmap(
       (void *)hint, 4096, PROT_WRITE,
       MAP_PRIVATE | MAP_ANONYMOUS | (FIXED ? MAP_FIXED : 0), -1, 0);
   if (FIXED)
     assert(p == (uintptr_t)-1 && errno == EINVAL);
   else
     assert(p >= app_start);
   return 0;
 }

compiler-rt/test/msan/param_tls_limit.cpp

 // ParamTLS has limited size. Everything that does not fit is considered fully
 // initialized.
 
 // RUN: %clangxx_msan -O0 %s -o %t && %run %t
 // RUN: %clangxx_msan -fsanitize-memory-track-origins -O0 %s -o %t && %run %t
 // RUN: %clangxx_msan -fsanitize-memory-track-origins=2 -O0 %s -o %t && %run %t
 //
 // AArch64 fails with:
 // void f801(S<801>): Assertion `__msan_test_shadow(&s, sizeof(s)) == -1' failed
 // XFAIL: aarch64
+// When passing huge structs by value, SystemZ uses pointers, therefore this
+// test in its present form is unfortunately not applicable.
+// ABI says: "A struct or union of any other size <snip>. Replace such an
+// argument by a pointer to the object, or to a copy where necessary to enforce
+// call-by-value semantics."
+// XFAIL: s390x
 
 #include <sanitizer/msan_interface.h>
 #include <assert.h>
 
 // This test assumes that ParamTLS size is 800 bytes.
 
 // This test passes poisoned values through function argument list.
 // In case of overflow, argument is unpoisoned.

compiler-rt/test/msan/strlen_of_shadow.cpp

 #if defined(__x86_64__)
   return (char *)((uintptr_t)p ^ 0x500000000000ULL);
 #elif defined (__mips64)
   return (char *)((uintptr_t)p ^ 0x8000000000ULL);
 #elif defined(__powerpc64__)
 #define LINEARIZE_MEM(mem) \
   (((uintptr_t)(mem) & ~0x200000000000ULL) ^ 0x100000000000ULL)
   return (char *)(LINEARIZE_MEM(p) + 0x080000000000ULL);
+#elif defined(__s390x__)
+  return (char *)(((uintptr_t)p & ~0xC00000000000ULL) + 0x080000000000ULL);
 #elif defined(__aarch64__)
   return (char *)((uintptr_t)p ^ 0x6000000000ULL);
 #endif
 }
 
 int main(void) {
   const char *s = "abcdef";
   assert(strlen(s) == 6);
   assert(strlen(mem_to_shadow(s)) == 0);
 
   char *t = new char[42];
   t[41] = 0;
   assert(strlen(mem_to_shadow(t)) == 41);
   return 0;
 }