[lsan] Add lsan support for loongarch64

[tangyouling]

Summary

This patch enabled lsan for loongarch64 with 47-bit VMA layout.

Depends on D139619

[tangyouling]

$ cat memory-leak.c 
#include <stdlib.h>
void *p;
int main() {
  p = malloc(7);
  p = 0; // The memory is leaked here.
  return 0;
}

$ ./build/bin/clang -fsanitize=address -g memory-leak.c ; ASAN_OPTIONS=detect_leaks=1 ./a.out

=================================================================
==636379==ERROR: LeakSanitizer: detected memory leaks

Direct leak of 7 byte(s) in 1 object(s) allocated from:
    #0 0x555557bac158 in __interceptor_malloc /home/loongson/llvm-work/llvm-project-test3/llvm-project1/compiler-rt/lib/asan/asan_malloc_linux.cpp:69:3
    #1 0x555557beb03c in main /home/loongson/llvm-work/llvm-project-test3/llvm-project1/memory-leak.c:4:7
    #2 0x7ffff23b1678  (/usr/lib64/libc.so.6+0x25678)

SUMMARY: AddressSanitizer: 7 byte(s) leaked in 1 allocation(s).

$ ./build/bin/clang -fsanitize=leak -g memory-leak.c && ./a.out

=================================================================
==636372==ERROR: LeakSanitizer: detected memory leaks

Direct leak of 7 byte(s) in 1 object(s) allocated from:
    #0 0x555556a5a94c in __interceptor_malloc /home/loongson/llvm-work/llvm-project-test3/llvm-project1/compiler-rt/lib/lsan/lsan_interceptors.cpp:75:3
    #1 0x555556a5db0c in main /home/loongson/llvm-work/llvm-project-test3/llvm-project1/memory-leak.c:4:7
    #2 0x7ffff11c5678  (/usr/lib64/libc.so.6+0x25678)

SUMMARY: LeakSanitizer: 7 byte(s) leaked in 1 allocation(s).

$ make check-lsan
Testing Time: 38.19s
  Unsupported      : 13
  Passed           : 93
  Expectedly Failed:  2

4 warning(s) in tests
Built target check-lsan

[xen0n]

compiler-rt/lib/lsan/lsan_common.cpp

281

Since our VM layout is actually flexible, would it be better to document this, like "Support only the most common VM layout on LoongArch that allows 47 bits of user-space VMA"? Exact wording could be optimized, I'm only describing the gist here.

compiler-rt/test/asan/TestCases/Linux/leak_check_segv.cpp

4 ↗

(On Diff #481489)

Why unnecessarily reorder things, especially putting this in front of the standard library includes?

20–21 ↗

(On Diff #481489)

Might be better to split this part of change out of the LoongArch enablement patch after all...

[tangyouling]

compiler-rt/lib/lsan/lsan_common.cpp

281

Since our VM layout is actually flexible, would it be better to document this, like "Support only the most common VM layout on LoongArch that allows 47 bits of user-space VMA"? Exact wording could be optimized, I'm only describing the gist here.

How about "Allow 47-bit user-space VMA at current"?

compiler-rt/test/asan/TestCases/Linux/leak_check_segv.cpp

4 ↗

(On Diff #481489)

Why unnecessarily reorder things, especially putting this in front of the standard library includes?

An automatic adjustment of the format.

20–21 ↗

(On Diff #481489)

Might be better to split this part of change out of the LoongArch enablement patch after all...

OK.

[xen0n]

compiler-rt/lib/lsan/lsan_common.cpp

281

"at present"; if you plan to revisit this later for properly supporting variable VM layouts, omitting the justification is fine to me.

compiler-rt/test/asan/TestCases/Linux/leak_check_segv.cpp

4 ↗

(On Diff #481489)

So you mean you're actually unable to avoid this diff damage?

[tangyouling]

compiler-rt/lib/lsan/lsan_common.cpp

281

Support for variable VM layout has not been planned for some time.

compiler-rt/test/asan/TestCases/Linux/leak_check_segv.cpp

4 ↗

(On Diff #481489)

I will try to avoid this unnecessary auto-formatting.

[tangyouling]

• Separate leak_check_segv.cpp modification.
• Add some comments.

[SixWeining]

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

8

Why we are here? For the same reason as Android mentioned above?

[tangyouling]

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

8

Not for that reason.
Test passed when adding a sleep() in Child(), but not quite sure what the reason is?

 void Child() {
   int child_stack;
+  sleep(1);
   printf("Child: %p\n", &child_stack);

[XiaodongLoong]

Please rebase code for test errors.

[tangyouling]

rebase code.

[SixWeining]

LGTM. Is there any objection?

[MaskRay]

LGTM.

clang/lib/Driver/ToolChains/Linux.cpp

SanitizerMask Linux::getSupportedSanitizers() const {
   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 ||
-      IsRISCV64 || IsSystemZ || IsHexagon)
+      IsRISCV64 || IsSystemZ || IsHexagon || IsLoongArch64)
     Res |= SanitizerKind::Leak;
   if (IsX86_64 || IsMIPS64 || IsAArch64 || IsPowerPC64 || IsSystemZ ||
       IsLoongArch64)
     Res |= SanitizerKind::Thread;
   if (IsX86_64)
     Res |= SanitizerKind::KernelMemory;
   if (IsX86 || IsX86_64)
     Res |= SanitizerKind::Function;

clang/test/Driver/fsanitize.c

 // CHECK-SANL-PPC: unsupported option '-fsanitize=leak' for target 'powerpc-unknown-linux'
 
 // RUN: %clang --target=riscv64-linux-gnu -fsanitize=leak %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-SANL-RISCV64
 // CHECK-SANL-RISCV64: "-fsanitize=leak"
 
 // RUN: %clang --target=riscv64-linux-gnu -fsanitize=address,leak -fno-sanitize=address %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-SANA-SANL-NO-SANA-RISCV64
 // CHECK-SANA-SANL-NO-SANA-RISCV64: "-fsanitize=leak"
 
+// RUN: %clang --target=loongarch64-unknown-linux-gnu -fsanitize=leak %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-SANL-LOONGARCH64
+// CHECK-SANL-LOONGARCH64: "-fsanitize=leak"
+
+// RUN: %clang --target=loongarch64-unknown-linux-gnu -fsanitize=address,leak -fno-sanitize=address %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-SANA-SANL-NO-SANA-LOONGARCH64
+// CHECK-SANA-SANL-NO-SANA-LOONGARCH64: "-fsanitize=leak"
+
 // RUN: %clang --target=x86_64-linux-gnu -fsanitize=memory %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-MSAN
 // CHECK-MSAN: "-fno-assume-sane-operator-new"
 // RUN: %clang --target=x86_64-linux-gnu -fsanitize=address %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-ASAN
 // CHECK-ASAN: "-fno-assume-sane-operator-new"
 
 // RUN: %clang --target=x86_64-linux-gnu -fsanitize=zzz %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-DIAG1
 // CHECK-DIAG1: unsupported argument 'zzz' to option '-fsanitize='
 // CHECK-DIAG1-NOT: unsupported argument 'zzz' to option '-fsanitize='

compiler-rt/cmake/Modules/AllSupportedArchDefs.cmake

else()
   set(ALL_FUZZER_SUPPORTED_ARCH ${X86_64} ${ARM64})
 endif()
 
 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})
+      ${PPC64} ${S390X} ${RISCV64} ${HEXAGON} ${LOONGARCH64})
 endif()
 set(ALL_MSAN_SUPPORTED_ARCH ${X86_64} ${MIPS64} ${ARM64} ${PPC64} ${S390X})
 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}

compiler-rt/lib/lsan/lsan_common.h

 #elif (SANITIZER_LINUX || SANITIZER_APPLE) && (SANITIZER_WORDSIZE == 64) && \
     (defined(__x86_64__) || defined(__mips64) || defined(__aarch64__) ||  \
      defined(__powerpc64__) || defined(__s390x__))
 #  define CAN_SANITIZE_LEAKS 1
 #elif defined(__i386__) && (SANITIZER_LINUX || SANITIZER_APPLE)
 #  define CAN_SANITIZE_LEAKS 1
 #elif defined(__arm__) && SANITIZER_LINUX
 #  define CAN_SANITIZE_LEAKS 1
+#elif SANITIZER_LOONGARCH64 && SANITIZER_LINUX
+#  define CAN_SANITIZE_LEAKS 1
 #elif SANITIZER_RISCV64 && SANITIZER_LINUX
 #  define CAN_SANITIZE_LEAKS 1
 #elif SANITIZER_NETBSD || SANITIZER_FUCHSIA
 #  define CAN_SANITIZE_LEAKS 1
 #else
 #  define CAN_SANITIZE_LEAKS 0
 #endif
 

compiler-rt/lib/lsan/lsan_common.cpp

 #  if defined(__x86_64__)
   // Accept only canonical form user-space addresses.
   return ((p >> 47) == 0);
 #  elif defined(__mips64)
   return ((p >> 40) == 0);
 #  elif defined(__aarch64__)
   // Accept up to 48 bit VMA.
   return ((p >> 48) == 0);
+#  elif defined(__loongarch_lp64)
+  // Allow 47-bit user-space VMA at current.
+  return ((p >> 47) == 0);
 #  else
   return true;
 #  endif
 }
 
 // Scans the memory range, looking for byte patterns that point into allocator
 // chunks. Marks those chunks with |tag| and adds them to |frontier|.
 // There are two usage modes for this function: finding reachable chunks

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

 config.available_features.add("asan-" + config.bits + "-bits")
 
 # Fast unwinder doesn't work with Thumb
 if not config.arm_thumb:
   config.available_features.add('fast-unwinder-works')
 
 # Turn on leak detection on 64-bit Linux.
 leak_detection_android = config.android and 'android-thread-properties-api' in config.available_features and (config.target_arch in ['x86_64', 'i386', 'i686', 'aarch64'])
-leak_detection_linux = (config.host_os == 'Linux') and (not config.android) and (config.target_arch in ['x86_64', 'i386', 'riscv64'])
+leak_detection_linux = (config.host_os == 'Linux') and (not config.android) and (config.target_arch in ['x86_64', 'i386', 'riscv64', 'loongarch64'])
 leak_detection_mac = (config.host_os == 'Darwin') and (config.apple_platform == 'osx')
 leak_detection_netbsd = (config.host_os == 'NetBSD') and (config.target_arch in ['x86_64', 'i386'])
 if leak_detection_android or leak_detection_linux or leak_detection_mac or leak_detection_netbsd:
   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)
 

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

 // 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: %env_lsan_opts= %run %t 2>&1
 // RUN: %env_lsan_opts= not %run %t foo 2>&1 | FileCheck %s
 // Missing 'getcontext' and 'makecontext' on Android.
-// UNSUPPORTED: target={{(arm|aarch64|powerpc64).*}},android
+// UNSUPPORTED: target={{(arm|aarch64|loongarch64|powerpc64).*}},android
 
 #include "sanitizer_common/sanitizer_ucontext.h"
 #include <stdio.h>
 #include <unistd.h>
 
 const int kStackSize = 1 << 20;
 
 void Child() {

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

 #elif defined(__aarch64__)
   // x9-10 are used. x11-12 are probably used.
   // So we pick x13 to be safe and x14 as a backup.
   // (x13 known to be used on Ubuntu Focal)
   asm("mov x13, %0\n"
       "mov x14, %0"
       :
       : "r"(p));
+#elif defined(__loongarch_lp64)
+  asm("move $s8, %0" : : "r"(p));
 #elif defined(__powerpc__)
   asm("mr 30, %0"
       :
       : "r"(p));
 #elif defined(__s390x__)
   asm("lgr %%r10, %0"
       :
       : "r"(p));

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
-# Android{aarch64, x86, x86_64}, x86-64 Linux, PowerPC64 Linux, arm Linux, mips64 Linux, s390x Linux and x86_64 Darwin.
+# Android{aarch64, x86, x86_64}, x86-64 Linux, PowerPC64 Linux, arm Linux, mips64 Linux, s390x Linux, loongarch64 Linux and x86_64 Darwin.
 supported_android = config.android and config.target_arch in ['x86_64', 'i386', 'aarch64'] and 'android-thread-properties-api' in config.available_features
-supported_linux = (not config.android) and config.host_os == 'Linux' and config.host_arch in ['aarch64', 'x86_64', 'ppc64', 'ppc64le', 'mips64', 'riscv64', 'arm', 'armhf', 'armv7l', 's390x']
+supported_linux = (not config.android) and config.host_os == 'Linux' and config.host_arch in ['aarch64', 'x86_64', 'ppc64', 'ppc64le', 'mips64', 'riscv64', 'arm', 'armhf', 'armv7l', 's390x', 'loongarch64']
 supported_darwin = config.host_os == 'Darwin' and config.target_arch in ['x86_64']
 supported_netbsd = config.host_os == 'NetBSD' and config.target_arch in ['x86_64', 'i386']
 if not (supported_android or 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']