[MSan] Enable MSAN for loongarch64

[Ami-zhang]

Summary

This patch adds basic memory sanitizer support for loongarch64
with 47-bit VMA, which memory layout is based on x86_64.

The LLVM part of the LoongArch memory sanitizer implementation will
be done separately, which will fix failing tests in check-msan.
These failing tests fail with the following same error: "error in
backend: unsupported architecture".

[XiaodongLoong]

ERROR   git-clang-format returned an non-zero exit code 1

Please format the code. Maybe, you can use the following command:

git diff -U0 --no-color HEAD^ | clang/tools/clang-format/clang-format-diff.py -i -p1

[tangyouling]

Add code format check.

[SixWeining]

compiler-rt/lib/msan/msan.h

192

We fall to this? But not line 208?

compiler-rt/test/msan/mmap.cpp

22–24

These addresses are the same as x86_64 above. Is this expected?

[tangyouling]

compiler-rt/lib/msan/msan.h

192

I will move the contents of line 208 to line 91.

compiler-rt/test/msan/mmap.cpp

22–24

Because the app-{1,2,3} definition of kMemoryLayout is consistent with x86_64, it is the same here.

[tangyouling]

Modify the kMemoryLayout definition position of loongarch64.

[SixWeining]

Seems that missing atest in llvm/test/Instrumentation/MemorySanitizer/.

[vitalybuka]

llvm/lib/Transforms/Instrumentation/MemorySanitizer.cpp

5879 ↗

(On Diff #485334)

it looks like exact copy of VarArgMIPS64Helper
why not "new VarArgMIPS64Helper"?

[tangyouling]

In D140528#4047132, @SixWeining wrote:

Seems that missing atest in llvm/test/Instrumentation/MemorySanitizer/.

Yes, need to add corresponding test for vararg.

[vitalybuka]

I assume work in progress

[tangyouling]

The patch will continue to be updated by @Ami-zhang

[Ami-zhang]

llvm/lib/Transforms/Instrumentation/MemorySanitizer.cpp

5879 ↗

(On Diff #485334)

Yes, VarArgLoongArch64Helper is here based on Mips.
I will verify whether there is any difference in the implementations regarding vararg between the two ABI later, and then add VarArgHelper for LoongArch in a separate patch.

[Ami-zhang]

Remove vararg implementation, and add it in a separate patch later.

[Ami-zhang]

Test results are as follows:

$ ninja check-msan
Testing Time: 72.08s
  Unsupported      :   9
  Passed           : 154
  Expectedly Failed:   3

[xen0n]

llvm/lib/Transforms/Instrumentation/MemorySanitizer.cpp

5879 ↗

(On Diff #485334)

In reality LoongArch's ABI is much more similar to that of RISCV than Mips. You may want to double-check that.

[vitalybuka]

llvm/lib/Transforms/Instrumentation/MemorySanitizer.cpp

437 ↗

(On Diff #527711)

can you please move this file into a separate patch and add some tests

e.g. autogenerated like this:
llvm/utils/update_test_checks.py --opt-binary ../out/bin/opt llvm-project/llvm/test/Instrumentation/MemorySanitizer/AArch64/vararg.ll --check-globals

[Ami-zhang]

llvm/lib/Transforms/Instrumentation/MemorySanitizer.cpp

437 ↗

(On Diff #527711)

Ok, I have moved it into another patch.

Without LLVM part of the LoongArch memory sanitizer implementation, there are many failing tests with "error in backend: unsupported architecture" in check-msan. And with that implementation, the tests all pass.

Currently, VarArgHelper implementation on LoongArch isn't supported yet, which will be done separately later. But we will add a test for VarArgNoOpHelper in llvm/test/Instrumentation/MemorySanitizer/LoongArch, which is based on the X86 one.

[Ami-zhang]

move MemorySanitizer.cpp file into another patch D152692

[Ami-zhang]

Ping
@vitalybuka I've updated this. Could you please take the time to review it again? Thank you!

[MaskRay]

compiler-rt/lib/msan/msan_allocator.cpp

86

namespace-scope const is automatically internal linkage, so you can omit static

[Ami-zhang]

compiler-rt/lib/msan/msan_allocator.cpp

86

Ok, I have omitted static in the namespace-scope const.

[Ami-zhang]

Omit static in the namespace-scope const.

compiler-rt/cmake/Modules/AllSupportedArchDefs.cmake

 
 set(ALL_GWP_ASAN_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${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}
       ${PPC64} ${S390X} ${RISCV64} ${HEXAGON} ${LOONGARCH64})
 endif()
-set(ALL_MSAN_SUPPORTED_ARCH ${X86_64} ${MIPS64} ${ARM64} ${PPC64} ${S390X})
+set(ALL_MSAN_SUPPORTED_ARCH ${X86_64} ${MIPS64} ${ARM64} ${PPC64} ${S390X}
+    ${LOONGARCH64})
 set(ALL_HWASAN_SUPPORTED_ARCH ${X86_64} ${ARM64} ${RISCV64})
 set(ALL_MEMPROF_SUPPORTED_ARCH ${X86_64})
 set(ALL_PROFILE_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64} ${PPC32} ${PPC64}
     ${MIPS32} ${MIPS64} ${S390X} ${SPARC} ${SPARCV9} ${HEXAGON}
     ${RISCV32} ${RISCV64})
 set(ALL_TSAN_SUPPORTED_ARCH ${X86_64} ${MIPS64} ${ARM64} ${PPC64} ${S390X}
     ${LOONGARCH64})
 set(ALL_UBSAN_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64} ${RISCV64}

compiler-rt/lib/msan/msan.h

const MappingDesc kMemoryLayout[] = {
     {0X0B00000000000, 0X0C00000000000, MappingDesc::SHADOW, "shadow-10-13"},
     {0X0C00000000000, 0X0D00000000000, MappingDesc::INVALID, "invalid"},
     {0X0D00000000000, 0X0E00000000000, MappingDesc::ORIGIN, "origin-10-13"},
     {0X0E00000000000, 0X1000000000000, MappingDesc::APP, "app-15"},
 };
 # define MEM_TO_SHADOW(mem) ((uptr)mem ^ 0xB00000000000ULL)
 # define SHADOW_TO_ORIGIN(shadow) (((uptr)(shadow)) + 0x200000000000ULL)
 
+#elif SANITIZER_LINUX && SANITIZER_LOONGARCH64
+// LoongArch64 maps:
+// - 0x000000000000-0x010000000000: Program own segments
+// - 0x555500000000-0x555600000000: PIE program segments
+// - 0x7fff00000000-0x7fffffffffff: libraries segments.
+const MappingDesc kMemoryLayout[] = {
+    {0x000000000000ULL, 0x010000000000ULL, MappingDesc::APP, "app-1"},
+    {0x010000000000ULL, 0x100000000000ULL, MappingDesc::SHADOW, "shadow-2"},
+    {0x100000000000ULL, 0x110000000000ULL, MappingDesc::INVALID, "invalid"},
+    {0x110000000000ULL, 0x200000000000ULL, MappingDesc::ORIGIN, "origin-2"},
+    {0x200000000000ULL, 0x300000000000ULL, MappingDesc::SHADOW, "shadow-3"},
+    {0x300000000000ULL, 0x400000000000ULL, MappingDesc::ORIGIN, "origin-3"},
+    {0x400000000000ULL, 0x500000000000ULL, MappingDesc::INVALID, "invalid"},
+    {0x500000000000ULL, 0x510000000000ULL, MappingDesc::SHADOW, "shadow-1"},
+    {0x510000000000ULL, 0x600000000000ULL, MappingDesc::APP, "app-2"},
+    {0x600000000000ULL, 0x610000000000ULL, MappingDesc::ORIGIN, "origin-1"},
+    {0x610000000000ULL, 0x700000000000ULL, MappingDesc::INVALID, "invalid"},
+    {0x700000000000ULL, 0x800000000000ULL, MappingDesc::APP, "app-3"}};
+#  define MEM_TO_SHADOW(mem) (((uptr)(mem)) ^ 0x500000000000ULL)
+#  define SHADOW_TO_ORIGIN(shadow) (((uptr)(shadow)) + 0x100000000000ULL)
+
 #elif SANITIZER_LINUX && SANITIZER_PPC64
 const MappingDesc kMemoryLayout[] = {
     {0x000000000000ULL, 0x000200000000ULL, MappingDesc::APP, "low memory"},
     {0x000200000000ULL, 0x080000000000ULL, MappingDesc::INVALID, "invalid"},
     {0x080000000000ULL, 0x180200000000ULL, MappingDesc::SHADOW, "shadow"},
     {0x180200000000ULL, 0x1C0000000000ULL, MappingDesc::INVALID, "invalid"},
     {0x1C0000000000ULL, 0x2C0200000000ULL, MappingDesc::ORIGIN, "origin"},
     {0x2C0200000000ULL, 0x300000000000ULL, MappingDesc::INVALID, "invalid"},

 // Maps low and high app ranges to contiguous space with zero base:
 //   Low:  0000 0000 0000 - 00ff ffff ffff  ->  2000 0000 0000 - 20ff ffff ffff
 //   High: 6000 0000 0000 - 7fff ffff ffff  ->  0000 0000 0000 - 1fff ffff ffff
 #define LINEARIZE_MEM(mem) \
   (((uptr)(mem) & ~0xc00000000000ULL) ^ 0x200000000000ULL)
 #define MEM_TO_SHADOW(mem) (LINEARIZE_MEM((mem)) + 0x100000000000ULL)
 #define SHADOW_TO_ORIGIN(shadow) (((uptr)(shadow)) + 0x280000000000)
 
 #elif SANITIZER_NETBSD || (SANITIZER_LINUX && SANITIZER_WORDSIZE == 64)
 
 // All of the following configurations are supported.
 // ASLR disabled: main executable and DSOs at 0x555550000000
 // PIE and ASLR: main executable and DSOs at 0x7f0000000000
 // non-PIE: main executable below 0x100000000, DSOs at 0x7f0000000000
 // Heap at 0x700000000000.
 const MappingDesc kMemoryLayout[] = {
     {0x000000000000ULL, 0x010000000000ULL, MappingDesc::APP, "app-1"},

compiler-rt/lib/msan/msan_allocator.cpp

struct AP64 {  // Allocator64 parameters. Deliberately using a short name.
   typedef DefaultSizeClassMap SizeClassMap;
   typedef MsanMapUnmapCallback MapUnmapCallback;
   static const uptr kFlags = 0;
   using AddressSpaceView = LocalAddressSpaceView;
 };
 
 typedef SizeClassAllocator64<AP64> PrimaryAllocator;
 
+#elif defined(__loongarch_lp64)
+const uptr kAllocatorSpace = 0x700000000000ULL;
+const uptr kMaxAllowedMallocSize = 8UL << 30;
+
+struct AP64 {  // Allocator64 parameters. Deliberately using a short name.
+  static const uptr kSpaceBeg = kAllocatorSpace;
+  static const uptr kSpaceSize = 0x40000000000;  // 4T.
+  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(__powerpc64__)
 static const uptr kMaxAllowedMallocSize = 2UL << 30;  // 2G
 
 struct AP64 {  // Allocator64 parameters. Deliberately using a short name.
   static const uptr kSpaceBeg = 0x300000000000;
   static const uptr kSpaceSize = 0x020000000000;  // 2T.
   static const uptr kMetadataSize = sizeof(Metadata);
   typedef DefaultSizeClassMap SizeClassMap;

compiler-rt/lib/msan/tests/msan_test.cpp

 // directory.  Only use string routines that we intercept so far to do this.
 static void GetPathToLoadable(char *buf, size_t sz) {
   char program_path[kMaxPathLength];
   GetProgramPath(program_path, sizeof(program_path));
 
   const char *last_slash = strrchr(program_path, '/');
   ASSERT_NE(nullptr, last_slash);
   size_t dir_len = (size_t)(last_slash - program_path);
-#if defined(__x86_64__)
+#  if defined(__x86_64__)
   static const char basename[] = "libmsan_loadable.x86_64.so";
-#elif defined(__MIPSEB__) || defined(MIPSEB)
+#  elif defined(__MIPSEB__) || defined(MIPSEB)
   static const char basename[] = "libmsan_loadable.mips64.so";
-#elif defined(__mips64)
+#  elif defined(__mips64)
   static const char basename[] = "libmsan_loadable.mips64el.so";
-#elif defined(__aarch64__)
+#  elif defined(__aarch64__)
   static const char basename[] = "libmsan_loadable.aarch64.so";
-#elif defined(__powerpc64__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+#  elif defined(__loongarch_lp64)
+  static const char basename[] = "libmsan_loadable.loongarch64.so";
+#  elif defined(__powerpc64__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
   static const char basename[] = "libmsan_loadable.powerpc64.so";
-#elif defined(__powerpc64__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+#  elif defined(__powerpc64__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
   static const char basename[] = "libmsan_loadable.powerpc64le.so";
-#endif
+#  endif
   int res = snprintf(buf, sz, "%.*s/%s",
                      (int)dir_len, program_path, basename);
   ASSERT_GE(res, 0);
   ASSERT_LT((size_t)res, sz);
 }
 
 TEST(MemorySanitizer, dl_iterate_phdr) {
   char path[kMaxPathLength];

compiler-rt/test/msan/mmap.cpp

 bool AddrIsApp(void *p) {
   uintptr_t addr = (uintptr_t)p;
 #if defined(__FreeBSD__) && defined(__x86_64__)
   return addr < 0x010000000000ULL || addr >= 0x600000000000ULL;
 #elif defined(__x86_64__)
   return (addr >= 0x000000000000ULL && addr < 0x010000000000ULL) ||
          (addr >= 0x510000000000ULL && addr < 0x600000000000ULL) ||
          (addr >= 0x700000000000ULL && addr < 0x800000000000ULL);
+#elif defined(__loongarch_lp64)
+  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 ||

compiler-rt/test/msan/mmap_below_shadow.cpp

 int main(void) {
   // Hint address just below shadow.
 #if defined(__FreeBSD__) && defined(__x86_64__)
   uintptr_t hint = 0x0f0000000000ULL;
   const uintptr_t app_start = 0x000000000000ULL;
 #elif defined(__x86_64__)
   uintptr_t hint = 0x4f0000000000ULL;
   const uintptr_t app_start = 0x600000000000ULL;
+#elif defined(__loongarch_lp64)
+  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;

compiler-rt/test/msan/param_tls_limit.cpp

 // ParamTLS has limited size. Everything that does not fit is considered fully
 // initialized.
 
 // RUN: %clangxx_msan -fno-sanitize-memory-param-retval -O0 %s -o %t && %run %t
 // RUN: %clangxx_msan -fno-sanitize-memory-param-retval -fsanitize-memory-track-origins -O0 %s -o %t && %run %t
 // RUN: %clangxx_msan -fno-sanitize-memory-param-retval -fsanitize-memory-track-origins=2 -O0 %s -o %t && %run %t
 //
-// AArch64 fails with:
+// AArch64 and LoongArch64 fail with:
 // void f801(S<801>): Assertion `__msan_test_shadow(&s, sizeof(s)) == -1' failed
-// XFAIL: target=aarch64{{.*}}
+// XFAIL: target={{(aarch64|loongarch64).*}}
 // 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: target=s390x{{.*}}
 
 #include <sanitizer/msan_interface.h>

compiler-rt/test/msan/signal_stress_test.cpp

 // RUN: %clangxx_msan -fno-sanitize-memory-param-retval -std=c++11 -O0 %s -o %t && %run %t
 //
 // Test that va_arg shadow from a signal handler does not leak outside.
 
 // Reported deadly signal due to stack-overflow
 // XFAIL: target={{.*netbsd.*}}
 
+// VarArg implementation on LoongArch isn't supported yet.
+// UNSUPPORTED: target=loongarch{{.*}}
+
 #include <signal.h>
 #include <stdarg.h>
 #include <sanitizer/msan_interface.h>
 #include <assert.h>
 #include <sys/time.h>
 #include <stdio.h>
 
 const int kSigCnt = 200;

compiler-rt/test/msan/strlen_of_shadow.cpp

 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include "test.h"
 
 const char *mem_to_shadow(const char *p) {
 #if defined(__x86_64__)
   return (char *)((uintptr_t)p ^ 0x500000000000ULL);
+#elif defined(__loongarch_lp64)
+  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);

compiler-rt/test/msan/vararg.cpp

 // RUN: FileCheck %s --check-prefixes=CHECK,CHECK-ORIGIN < %t.out
 
 // RUN: %clangxx_msan -fno-sanitize-memory-param-retval -fsanitize-memory-track-origins=2 -O3 %s -o %t && \
 // RUN:     not %run %t overflow >%t.out 2>&1
 // RUN: FileCheck %s --check-prefixes=CHECK,CHECK-ORIGIN < %t.out
 
 // Check that shadow and origin are passed through va_args.
 
-// Copying origins on AArch64, MIPS and PowerPC isn't supported yet.
-// XFAIL: target={{(aarch64|mips|powerpc64).*}}
+// Copying origins on AArch64, LoongArch64, MIPS and PowerPC isn't supported yet.
+// XFAIL: target={{(aarch64|loongarch64|mips|powerpc64).*}}
 
 #include <stdarg.h>
 #include <string.h>
 
 __attribute__((noinline))
 int sum(int n, ...) {
   va_list args;
   int i, sum = 0, arg;