[Sanitizers] Add support for RISC-V 64-bit

[schwab]

Summary

This has been tested with gcc trunk on openSUSE Tumbleweed on the HiFive Unleashed.

[luismarques]

compiler-rt/cmake/config-ix.cmake

259

Although 32-bit support for Linux on RISC-V has lagged, you can build and boot a 32-bit kernel and it will eventually be more mainstream. Is the reason for not adding RISCV32 here that it was only tested on the HiFive Unleashed? It's possible to get prebuilt 32-bit disk images (and patches to build them yourself) that can be tested with, for instance, QEMU. See for instance [1]. Also, I don't know how problematic it would be to add RISCV32 to the list without testing.
[1] https://bellard.org/tinyemu/buildroot.html (Download section, etc.)

[schwab]

compiler-rt/cmake/config-ix.cmake

259

The riscv32 ABI isn't finalized yet.

[lenary]

I have two comments/queries below.

I don't feel it's an issue that this doesn't support RISC-V 32, though the patch title and summary should be updated to reflect this, and a build requesting risc-v 32 should hard error.

compiler-rt/lib/sanitizer_common/sanitizer_linux.cpp

411

What's the justification here? I'm not familiar with the sanitizer syscall interface, but it would be good to have a comment explaining why risc-v is the only architecture that doesn't use rename or renameat.

compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_posix.h

98

Please can you confirm that this will cause build errors if __riscv_xlen is 32 (like it will in sanitizer_platform_limits_posix.cpp)?

[schwab]

compiler-rt/lib/sanitizer_common/sanitizer_linux.cpp

411

renameat is obsolete, renameat2 is the new generic default.

compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_posix.h

98

A definition of struct_kernel_stat_sz and struct_kernel_stat64_sz is required. That's how you find out that this needs porting.

[schwab]

Rediff

[lenary]

@schwab Sorry there's been a delay reviewing this. I think it's probably fallen down the crack between "people who are familiar with RISC-V", and "people who are familiar with the sanitizers".

On the RISC-V side, I think @luismarques is your guy, so I've named him as a reviewer. Please also find someone from the sanitizers team who can review this work.

[luismarques]

LGTM.

[asb]

@schwab - do you need someone to commit this for you?

[schwab]

I don't have commit privileges.

[lenary]

I had to revert this in rL375136. Due to some build failures. I need to investigate exactly what the issue is.

[schwab]

What was the error?

[lenary]

In D66870#1714154, @schwab wrote:

What was the error?

I now think it was unrelated, but I'm not sure. I now have a setup where I can build the sanitizers, I think, so I'm just about to test the patch myself before pushing to the builders.

[lenary]

Buildbot failure links:

• http://lab.llvm.org:8011/builders/clang-ppc64be-linux/builds/39592
• http://lab.llvm.org:8011/builders/clang-ppc64be-linux-lnt/builds/31938
• http://lab.llvm.org:8011/builders/clang-ppc64be-linux-multistage/builds/21206

[lenary]

I think I've found the error. Comment inline

compiler-rt/lib/sanitizer_common/sanitizer_linux.cpp

1980

I'm getting compiler errors around these accesses. My sysroot thinks that __gregs isn't a field in this struct, it thinks the field is gregs (It's pointing to /opt/riscv-gcc-toolchain/sysroot/usr/include/bits/sigcontext.h:28:17 as the declaration for the gregs field.

I think this is the version of that file on github: https://github.com/riscv/riscv-glibc/blob/06983fe/sysdeps/unix/sysv/linux/riscv/bits/sigcontext.h#L27 (that git version matches the one used by https://github.com/riscv/riscv-gnu-toolchain)

[schwab]

In D66870#1714162, @lenary wrote:

Buildbot failure links:

• http://lab.llvm.org:8011/builders/clang-ppc64be-linux/builds/39592
• http://lab.llvm.org:8011/builders/clang-ppc64be-linux-lnt/builds/31938
• http://lab.llvm.org:8011/builders/clang-ppc64be-linux-multistage/builds/21206

These are all OOM errors.

[schwab]

compiler-rt/lib/sanitizer_common/sanitizer_linux.cpp

1980

Don't use the obsolete riscv-glibc. The official glibc sources are on sourceware.org.

[lenary]

Ok, It took several days of fighting crosstool-ng, but I finally have a riscv64-unknown-linux-gnu toolchain with glibc 2.30.

I'm happy this builds. I'm going to re-land the patch now. Sorry for the delay.

[• jas-onleo]

Hello，Can you tell me the resaon why it wasn't support for risc-v before ? Why not add the support for rv32 this time?

[luismarques]

In D66870#1885778, @jas-onleo wrote:

Hello，Can you tell me the resaon why it wasn't support for risc-v before ? Why not add the support for rv32 this time?

Just not one had yet put the work to explicitly support it, and be sure that was being done properly --- no deeper reason than that. Regarding riscv32, these is the sanitizer support for Linux, and Linux's RV32 support is being worked on. In particular, there are ABI issues that should be resolved now to avoid the year 2038 problem, and not cause breaking changes to address that at a later point.

compiler-rt/cmake/config-ix.cmake

 set(WASM64 wasm64)
 
 if(APPLE)
   set(ARM64 arm64)
   set(ARM32 armv7 armv7s armv7k)
   set(X86_64 x86_64 x86_64h)
 endif()
 
-set(ALL_SANITIZER_COMMON_SUPPORTED_ARCH ${X86} ${X86_64} ${PPC64}
+set(ALL_SANITIZER_COMMON_SUPPORTED_ARCH ${X86} ${X86_64} ${PPC64} ${RISCV64}
     ${ARM32} ${ARM64} ${MIPS32} ${MIPS64} ${S390X} ${SPARC} ${SPARCV9})
 set(ALL_ASAN_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64}
     ${MIPS32} ${MIPS64} ${PPC64} ${S390X} ${SPARC} ${SPARCV9})
 set(ALL_CRT_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64})
 set(ALL_DFSAN_SUPPORTED_ARCH ${X86_64} ${MIPS64} ${ARM64})
 
 if(ANDROID)
   set(OS_NAME "Android")

 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_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}
+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})
 set(ALL_SCUDO_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64} ${MIPS32} ${MIPS64} ${PPC64})
 set(ALL_SCUDO_STANDALONE_SUPPORTED_ARCH ${X86} ${X86_64})
 if(APPLE)
 set(ALL_XRAY_SUPPORTED_ARCH ${X86_64})
 else()

compiler-rt/lib/sanitizer_common/sanitizer_linux.cpp

 #if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS || SANITIZER_OPENBSD
   return internal_syscall(SYSCALL(unlinkat), AT_FDCWD, (uptr)path, 0);
 #else
   return internal_syscall(SYSCALL(unlink), (uptr)path);
 #endif
 }
 
 uptr internal_rename(const char *oldpath, const char *newpath) {
-#if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS || SANITIZER_OPENBSD
+#if defined(__riscv)
+  return internal_syscall(SYSCALL(renameat2), AT_FDCWD, (uptr)oldpath, AT_FDCWD,
+                          (uptr)newpath, 0);
+#elif SANITIZER_USES_CANONICAL_LINUX_SYSCALLS || SANITIZER_OPENBSD
   return internal_syscall(SYSCALL(renameat), AT_FDCWD, (uptr)oldpath, AT_FDCWD,
                           (uptr)newpath);
 #else
   return internal_syscall(SYSCALL(rename), (uptr)oldpath, (uptr)newpath);
 #endif
 }
 
 uptr internal_sched_yield() {
#elif defined(__s390__)
   ucontext_t *ucontext = (ucontext_t*)context;
 # if defined(__s390x__)
   *pc = ucontext->uc_mcontext.psw.addr;
 # else
   *pc = ucontext->uc_mcontext.psw.addr & 0x7fffffff;
 # endif
   *bp = ucontext->uc_mcontext.gregs[11];
   *sp = ucontext->uc_mcontext.gregs[15];
+#elif defined(__riscv)
+  ucontext_t *ucontext = (ucontext_t*)context;
+  *pc = ucontext->uc_mcontext.__gregs[REG_PC];
+  *bp = ucontext->uc_mcontext.__gregs[REG_S0];
+  *sp = ucontext->uc_mcontext.__gregs[REG_SP];
 #else
 # error "Unsupported arch"
 #endif
 }
 
 void SignalContext::InitPcSpBp() { GetPcSpBp(context, &pc, &sp, &bp); }
 
 void InitializePlatformEarly() {

compiler-rt/lib/sanitizer_common/sanitizer_platform.h

 // The SPARC64 Linux port implements this to split the VMA space into two
 // non-contiguous halves with a huge hole in the middle.
 #if defined(__sparc__) && SANITIZER_WORDSIZE == 64
 #define SANITIZER_SIGN_EXTENDED_ADDRESSES 1
 #else
 #define SANITIZER_SIGN_EXTENDED_ADDRESSES 0
 #endif
 
-// The AArch64 linux port uses the canonical syscall set as mandated by
-// the upstream linux community for all new ports. Other ports may still
-// use legacy syscalls.
+// The AArch64 and RISC-V linux ports use the canonical syscall set as
+// mandated by the upstream linux community for all new ports. Other ports
+// may still use legacy syscalls.
 #ifndef SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
-# if defined(__aarch64__) && SANITIZER_LINUX
+# if (defined(__aarch64__) || defined(__riscv)) && SANITIZER_LINUX
 # define SANITIZER_USES_CANONICAL_LINUX_SYSCALLS 1
 # else
 # define SANITIZER_USES_CANONICAL_LINUX_SYSCALLS 0
 # endif
 #endif
 
 // udi16 syscalls can only be used when the following conditions are
 // met:

compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_linux.cpp

 namespace __sanitizer {
 #if !SANITIZER_ANDROID
   unsigned struct_statfs64_sz = sizeof(struct statfs64);
 #endif
 }  // namespace __sanitizer
 
 #if !defined(__powerpc64__) && !defined(__x86_64__) && !defined(__aarch64__)\
                             && !defined(__mips__) && !defined(__s390__)\
-                            && !defined(__sparc__)
+                            && !defined(__sparc__) && !defined(__riscv)
 COMPILER_CHECK(struct___old_kernel_stat_sz == sizeof(struct __old_kernel_stat));
 #endif
 
 COMPILER_CHECK(struct_kernel_stat_sz == sizeof(struct stat));
 
 #if defined(__i386__)
 COMPILER_CHECK(struct_kernel_stat64_sz == sizeof(struct stat64));
 #endif

compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_posix.h

 #elif defined(__s390x__)
 const unsigned struct_kernel_stat_sz = 144;
 const unsigned struct_kernel_stat64_sz = 0;
 #elif defined(__sparc__) && defined(__arch64__)
 const unsigned struct___old_kernel_stat_sz = 0;
 const unsigned struct_kernel_stat_sz = 104;
 const unsigned struct_kernel_stat64_sz = 144;
 #elif defined(__sparc__) && !defined(__arch64__)
 const unsigned struct___old_kernel_stat_sz = 0;
 const unsigned struct_kernel_stat_sz = 64;
 const unsigned struct_kernel_stat64_sz = 104;
+#elif defined(__riscv) && __riscv_xlen == 64
+const unsigned struct_kernel_stat_sz = 128;
+const unsigned struct_kernel_stat64_sz = 104;
 #endif
 struct __sanitizer_perf_event_attr {
   unsigned type;
   unsigned size;
   // More fields that vary with the kernel version.
 };
 
 extern unsigned struct_epoll_event_sz;

compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_posix.cpp

#if SANITIZER_LINUX
   unsigned struct_itimerspec_sz = sizeof(struct itimerspec);
 #endif // SANITIZER_LINUX
 
 #if SANITIZER_LINUX && !SANITIZER_ANDROID
   // Use pre-computed size of struct ustat to avoid <sys/ustat.h> which
   // has been removed from glibc 2.28.
 #if defined(__aarch64__) || defined(__s390x__) || defined (__mips64) \
   || defined(__powerpc64__) || defined(__arch64__) || defined(__sparcv9) \
-  || defined(__x86_64__)
+  || defined(__x86_64__) || (defined(__riscv) && __riscv_xlen == 64)
 #define SIZEOF_STRUCT_USTAT 32
 #elif defined(__arm__) || defined(__i386__) || defined(__mips__) \
   || defined(__powerpc__) || defined(__s390__) || defined(__sparc__)
 #define SIZEOF_STRUCT_USTAT 20
 #else
 #error Unknown size of struct ustat
 #endif
   unsigned struct_ustat_sz = SIZEOF_STRUCT_USTAT;