[TSAN] add support for riscv64

[alexfanqi]

Summary

Implements for sv39 and sv48 VMA layout.

Userspace only has access to the bottom half of vma range. The top half is used by kernel.
There is no dedicated vsyscall or heap segment.
PIE program is allocated to start at TASK_SIZE/3*2. Maximum ASLR is ARCH_MMAP_RND_BITS_MAX+PAGE_SHIFT=24+12=36
Loader, vdso and other libraries are allocated below stack from the top.

Also change RestoreAddr to use 4 bits to accommodate MappingRiscv64_48

[alexfanqi]

fix tsan_rtl_riscv64.S and test failures

remaining test failure:
ThreadSanitizer-riscv64 :: custom_mutex5.cpp
The debuginfo line reported is slightly off.
custom_mutex5.cpp:14 -> 15
custom_mutex5.cpp:22 -> 23

ThreadSanitizer-riscv64 :: mmap_lots.cpp
flaky, the last 1000 sized mmap can get allocated to 0x0000-0x1000

[jrtc27]

compiler-rt/CMakeLists.txt

529

This is only to work around a long-standing bug in GCC's atomics implementation for RISC-V. If you build compiler-rt with Clang you don't need this, and in theory future versions of GCC (possibly trunk already fixes this, I'm not sure of the status of it).

compiler-rt/lib/tsan/rtl/tsan_interface_atomic.cpp

60

?

compiler-rt/lib/tsan/rtl/tsan_platform.h

971

?

compiler-rt/lib/tsan/rtl/tsan_platform_linux.cpp

270–271

Why don't other architectures need the +1?

compiler-rt/lib/tsan/tests/CMakeLists.txt

59

Same as before

compiler-rt/test/tsan/test.h

77

What's this the length of? RVC is optional.

[alexfanqi]

remove libatomic link

[alexfanqi]

compiler-rt/lib/tsan/rtl/tsan_platform.h

971

This is changed for sv48. Tsan compresses the address to 44 bits and uses the top 3 bits (42-44) to uncompress it by comparing with the corresponding bits in the mapping. So the 42-44th bits of each app mapping range must be all different from each other. But 3 bits are not enough to distinguish mappings in this scheme of MappingRiscv64_48, so I increment it to 4 bits. An alternative of this would be reducing app mapping size by half.

compiler-rt/lib/tsan/rtl/tsan_platform_linux.cpp

270–271

I am not too sure about other architectures. Perhaps, because riscv kernel divides vma range further by 2. https://elixir.bootlin.com/linux/latest/source/arch/riscv/include/asm/pgtable.h#L785
By https://docs.kernel.org/riscv/vm-layout.html, botton half is exposed for userspace, top half is for kernel.
The available userspace virtual address size for arm64 with same bit size is exactly double of riscv. For example, 39bit -> 0x4000000000(riscv) vs 0x8000000000(arm64)

compiler-rt/test/tsan/test.h

77

The same length as in GetPreviousInstructionPc. Without it, I got java_race_pc, race_range_pc test failure.

[alexfanqi]

friendly ping?

[hiraditya]

@alexfanqi are you still actively working on this? maybe we can move it to github then.

[alexfanqi]

In D145214#4646676, @hiraditya wrote:

@alexfanqi are you still actively working on this? maybe we can move it to github then.

Yeah, but the patch is already complete and tsan functions well with tests passing on my local qemu system emulation. I am waiting for reviewers to have more feedback or accept this patch.

[hiraditya]

ping: @jrtc27 @asb do you have any pending feedback for this patch?

[hiraditya]

compiler-rt/lib/tsan/rtl/CMakeLists.txt

223

I'm getting error with this line for some reason. Unknown cmake command "add_asm_sources" see: D152102

[hiraditya]

compiler-rt/lib/tsan/rtl/CMakeLists.txt

223

replace add_asm_sources with set and it will work.

[hiraditya]

I tested it on a licheepi board (riscv64 debian) and all the tests modified in this patch have passed. LGTM.

There are other tsan failures but i think it is okay if they can be fixed in subsequent patches.

[alexfanqi]

thanks @hiraditya

[alexfanqi]

In D145214#4650189, @hiraditya wrote:

I tested it on a licheepi board (riscv64 debian) and all the tests modified in this patch have passed. LGTM.

Can you help me land this patch? I used to have commit access, but seems not working atm.

There are other tsan failures but i think it is okay if they can be fixed in subsequent patches.

Do you have a list of these failures? I will try to reproduce on my machine and fix in later patch.

[hiraditya]

In D145214#4650928, @alexfanqi wrote:

In D145214#4650189, @hiraditya wrote:

I tested it on a licheepi board (riscv64 debian) and all the tests modified in this patch have passed. LGTM.

Can you help me land this patch? I used to have commit access, but seems not working atm.

There are other tsan failures but i think it is okay if they can be fixed in subsequent patches.

Do you have a list of these failures? I will try to reproduce on my machine and fix in later patch.

While testing compiler-rt/test/tsan/RISCV64Config only compiler-rt/test/tsan/mmap_lots.cpp failed. I couldn't run all the compiler-rt tests on Licheepi because it is very slow.

[alexfanqi]

While testing compiler-rt/test/tsan/RISCV64Config only compiler-rt/test/tsan/mmap_lots.cpp failed. I couldn't run all the compiler-rt tests on Licheepi because it is very slow

I had this only test failure before. When the upper memory space is fully mapped out, the kernel will try to use the lower memory range starting from 0x00, but kLoAppMem leaves out the initial 0x00-0x1000. I saw other archs did the same, and maybe it won't hurt.

[MaskRay]

compiler-rt/lib/tsan/rtl/tsan_platform.h

971

@dvyukov ^

[vitalybuka]

compiler-rt/lib/tsan/rtl/CMakeLists.txt

5

Maybe this one is not needed after b31bd6d8046d01a66aa92993bacb56b115a67fc5

[MaskRay]

Other than -Wframe-larger-than=656 and const uptr indicator = 0x0f0000000000ull; changes, others looks good to me.
I agree that this should be reviewed by @dvyukov :)

[hiraditya]

Another test that failed:
compiler-rt/test/tsan/signal_thread.cpp

[dvyukov]

compiler-rt/lib/tsan/rtl/CMakeLists.txt

5

Yes, is this needed? What function does have larger frame?
If we increase the limit, other arches will slowly slinetly degrade too.

[hiraditya]

compiler-rt/lib/tsan/rtl/CMakeLists.txt

5

yeah probably not needed anymore. but if we need this we can just change this only for RISC-V?

[jrtc27]

compiler-rt/lib/tsan/rtl/CMakeLists.txt

5

I would rather diagnose and fix whatever makes RISC-V code generation less efficient

[hiraditya]

compiler-rt/lib/tsan/rtl/CMakeLists.txt

5

without this change we have one less failure. so i'll discard the changes to -Wframe-larger-than=656 and commit the patch.

[haowei]

Hi,

I believe you forgot to add tsan_rtl_riscv64.S to your patch when you land it. We are seeing build errors on our bots with following messages:

-- Configuring done (12.3s)
CMake Error at /b/s/w/ir/x/w/llvm-llvm-project/compiler-rt/cmake/Modules/AddCompilerRT.cmake:357 (add_library):
  Cannot find source file:

    tsan_rtl_riscv64.S
Call Stack (most recent call first):
  /b/s/w/ir/x/w/llvm-llvm-project/compiler-rt/lib/tsan/rtl/CMakeLists.txt:244 (add_compiler_rt_runtime)


CMake Error at /b/s/w/ir/x/w/llvm-llvm-project/compiler-rt/cmake/Modules/AddCompilerRT.cmake:357 (add_library):
  No SOURCES given to target: clang_rt.tsan-riscv64
Call Stack (most recent call first):
  /b/s/w/ir/x/w/llvm-llvm-project/compiler-rt/lib/tsan/rtl/CMakeLists.txt:244 (add_compiler_rt_runtime)


CMake Error at /b/s/w/ir/x/w/llvm-llvm-project/compiler-rt/cmake/Modules/AddCompilerRT.cmake:357 (add_library):
  No SOURCES given to target: clang_rt.tsan-dynamic-riscv64
Call Stack (most recent call first):
  /b/s/w/ir/x/w/llvm-llvm-project/compiler-rt/lib/tsan/rtl/CMakeLists.txt:268 (add_compiler_rt_runtime)


CMake Generate step failed.  Build files cannot be regenerated correctly.
[5508/5672](1) Completed 'runtimes-i386-unknown-linux-gnu'
FAILED: runtimes/runtimes-riscv64-unknown-linux-gnu-stamps/runtimes-riscv64-unknown-linux-gnu-configure /b/s/w/ir/x/w/llvm_build/runtimes/runtimes-riscv64-unknown-linux-gnu-stamps/runtimes-riscv64-unknown-linux-gnu-configure 
cd /b/s/w/ir/x/w/llvm_build/runtimes/runtimes-riscv64-unknown-linux-gnu-bins && /b/s/w/ir/x/w/cipd_tool/fuchsia/third_party/cmake/72c014f0086372a2bab7ed771e2ed942d6122d94331d19c95566bb25d2f962ff/bin/cmake --no-warn-unused-cli -DCMAKE_C_COMPILER=/b/s/w/ir/x/w/llvm_build/./bin/clang -DCMAKE_CXX_COMPILER=/b/s/w/ir/x/w/llvm_build/./bin/clang++ -DCMAKE_ASM_COMPILER=/b/s/w/ir/x/w/llvm_build/./bin/clang -DCMAKE_LINKER=/b/s/w/ir/x/w/llvm_build/./bin/ld.lld -DCMAKE_AR=/b/s/w/ir/x/w/llvm_build/./bin/llvm-ar -DCMAKE_RANLIB=/b/s/w/ir/x/w/llvm_build/./bin/llvm-ranlib -DCMAKE_NM=/b/s/w/ir/x/w/llvm_build/./bin/llvm-nm -DCMAKE_OBJDUMP=/b/s/w/ir/x/w/llvm_build/./bin/llvm-objdump -DCMAKE_OBJCOPY=/b/s/w/ir/x/w/llvm_build/./bin/llvm-objcopy -DCMAKE_STRIP=/b/s/w/ir/x/w/llvm_build/./bin/llvm-strip -DCMAKE_READELF=/b/s/w/ir/x/w/llvm_build/./bin/llvm-readelf -DCMAKE_C_COMPILER_TARGET=riscv64-unknown-linux-gnu -DCMAKE_CXX_COMPILER_TARGET=riscv64-unknown-linux-gnu -DCMAKE_ASM_COMPILER_TARGET=riscv64-unknown-linux-gnu -DCMAKE_INSTALL_PREFIX= -DCMAKE_SYSROOT=/b/s/w/ir/x/w/cipd/linux -DLLVM_BINARY_DIR=/b/s/w/ir/x/w/llvm_build -DLLVM_CONFIG_PATH=/b/s/w/ir/x/w/llvm_build/bin/llvm-config -DLLVM_ENABLE_WERROR=OFF -DLLVM_HOST_TRIPLE=x86_64-unknown-linux-gnu -DLLVM_HAVE_LINK_VERSION_SCRIPT=1 -DLLVM_USE_RELATIVE_PATHS_IN_DEBUG_INFO=OFF -DLLVM_USE_RELATIVE_PATHS_IN_FILES=ON "-DLLVM_LIT_ARGS=--resultdb-output=r.j -v" -DLLVM_SOURCE_PREFIX= -DPACKAGE_VERSION=18.0.0git -DCMAKE_BUILD_TYPE=Release -DCMAKE_MAKE_PROGRAM=/b/s/w/ir/x/w/cipd_tool/fuchsia/third_party/ninja/476febc43233af3534d14a045651a4f365106e894b0998df28fa241d68733c8d/ninja -DCMAKE_EXPORT_COMPILE_COMMANDS=1 -DCOMPILER_RT_BUILD_BUILTINS=OFF -DLLVM_INCLUDE_TESTS=ON -DLLVM_ENABLE_PROJECTS_USED=ON -DLLVM_ENABLE_PER_TARGET_RUNTIME_DIR=ON -DCMAKE_C_COMPILER_WORKS=ON -DCMAKE_CXX_COMPILER_WORKS=ON -DCMAKE_ASM_COMPILER_WORKS=ON -DCOMPILER_RT_DEFAULT_TARGET_ONLY=ON -DLLVM_RUNTIMES_TARGET=riscv64-unknown-linux-gnu -DHAVE_LLVM_LIT=ON -DLLVM_DEFAULT_TARGET_TRIPLE=riscv64-unknown-linux-gnu "-DLLVM_ENABLE_RUNTIMES=compiler-rt;libcxx;libcxxabi;libunwind" -DLLVM_USE_LINKER=lld -DCMAKE_ASM_FLAGS=--target=riscv64-unknown-linux-gnu -DCMAKE_BUILD_TYPE=RelWithDebInfo -DCMAKE_CXX_FLAGS=--target=riscv64-unknown-linux-gnu -DCMAKE_C_FLAGS=--target=riscv64-unknown-linux-gnu -DCMAKE_EXE_LINKER_FLAGS=-fuse-ld=lld -DCMAKE_MODULE_LINKER_FLAGS=-fuse-ld=lld -DCMAKE_SHARED_LINKER_FLAGS=-fuse-ld=lld -DCMAKE_SYSROOT=/b/s/w/ir/x/w/cipd/focal -DCMAKE_SYSTEM_NAME=Linux -DCOMPILER_RT_BUILD_STANDALONE_LIBATOMIC=ON -DCOMPILER_RT_CAN_EXECUTE_TESTS=ON -DCOMPILER_RT_CXX_LIBRARY=libcxx -DCOMPILER_RT_USE_BUILTINS_LIBRARY=ON -DCOMPILER_RT_USE_LLVM_UNWINDER=ON -DLIBCXXABI_ENABLE_SHARED=OFF -DLIBCXXABI_INSTALL_LIBRARY=OFF -DLIBCXXABI_USE_COMPILER_RT=ON -DLIBCXXABI_USE_LLVM_UNWINDER=ON -DLIBCXX_ABI_VERSION=2 -DLIBCXX_ENABLE_SHARED=OFF -DLIBCXX_ENABLE_STATIC_ABI_LIBRARY=ON -DLIBCXX_USE_COMPILER_RT=ON -DLIBUNWIND_ENABLE_SHARED=OFF -DLIBUNWIND_USE_COMPILER_RT=ON -DLLVM_ENABLE_ASSERTIONS=OFF "-DLLVM_ENABLE_RUNTIMES=compiler-rt;libcxx;libcxxabi;libunwind" -DLLVM_TOOLS_DIR=/b/s/w/ir/x/w/llvm_build/bin -DSANITIZER_CXX_ABI=libc++ -DSANITIZER_CXX_ABI_INTREE=ON -DSANITIZER_TEST_CXX=libc++ -DSANITIZER_TEST_CXX_INTREE=ON -GNinja -S /b/s/w/ir/x/w/llvm-llvm-project/llvm/runtimes/../../runtimes -B /b/s/w/ir/x/w/llvm_build/runtimes/runtimes-riscv64-unknown-linux-gnu-bins && /b/s/w/ir/x/w/cipd_tool/fuchsia/third_party/cmake/72c014f0086372a2bab7ed771e2ed942d6122d94331d19c95566bb25d2f962ff/bin/cmake -E touch /b/s/w/ir/x/w/llvm_build/runtimes/runtimes-riscv64-unknown-linux-gnu-stamps/runtimes-riscv64-unknown-linux-gnu-configure
ninja: build stopped: subcommand failed.

Failed build task: https://ci.chromium.org/ui/p/fuchsia/builders/toolchain.ci/clang-linux-x64-rbe/b8767953001421733361/overview
Full stdout/err: https://logs.chromium.org/logs/fuchsia/buildbucket/cr-buildbucket/8767953001421733361/+/u/clang/build/stdout

Could you either add this file or revert your change please. Thanks.

[hiraditya]

@alexfanqi can you please upload the file (tsan_rtl_riscv64.S) with the patch?

[hiraditya]

nvm i found the file in one of the previous commits. https://github.com/llvm/llvm-project/pull/68735 for review.

clang/lib/Driver/ToolChains/Linux.cpp

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

compiler-rt/CMakeLists.txt

 # Set common link flags.
 # TODO: We should consider using the same model as libc++, that is use either
 # -nostdlib++ and --unwindlib=none if supported, or -nodefaultlibs otherwise.
 append_list_if(C_SUPPORTS_NODEFAULTLIBS_FLAG -nodefaultlibs SANITIZER_COMMON_LINK_FLAGS)
 append_list_if(COMPILER_RT_HAS_Z_TEXT -Wl,-z,text SANITIZER_COMMON_LINK_FLAGS)
 
 # Only necessary for 32-bit SPARC.  Solaris 11.2+ ld uses -z ignore/-z record
 # natively, but supports --as-needed/--no-as-needed for GNU ld compatibility.
-if("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "sparc")
+if("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "sparc|riscv")
   list(APPEND SANITIZER_COMMON_LINK_LIBS -Wl,--as-needed atomic -Wl,--no-as-needed)
 endif()
 
 if (COMPILER_RT_USE_BUILTINS_LIBRARY)
   string(REPLACE "-Wl,-z,defs" "" CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS}")
 else()
   if (ANDROID)
     append_list_if(COMPILER_RT_HAS_GCC_LIB gcc SANITIZER_COMMON_LINK_LIBS)

compiler-rt/cmake/Modules/AllSupportedArchDefs.cmake

 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}
-    ${LOONGARCH64})
+    ${LOONGARCH64} ${RISCV64})
 set(ALL_UBSAN_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64} ${RISCV64}
     ${MIPS32} ${MIPS64} ${PPC64} ${S390X} ${SPARC} ${SPARCV9} ${HEXAGON}
     ${LOONGARCH64})
 set(ALL_SAFESTACK_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM64} ${MIPS32} ${MIPS64}
     ${HEXAGON} ${LOONGARCH64})
 set(ALL_CFI_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64} ${MIPS64}
     ${HEXAGON})
 set(ALL_SCUDO_STANDALONE_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64}

compiler-rt/lib/tsan/rtl/CMakeLists.txt

 include_directories(../..)
 
 set(TSAN_RTL_CFLAGS ${TSAN_CFLAGS})
 append_list_if(COMPILER_RT_HAS_MSSE4_2_FLAG -msse4.2 TSAN_RTL_CFLAGS)
-append_list_if(SANITIZER_LIMIT_FRAME_SIZE -Wframe-larger-than=530
+append_list_if(SANITIZER_LIMIT_FRAME_SIZE -Wframe-larger-than=656
                TSAN_RTL_CFLAGS)
 append_list_if(COMPILER_RT_HAS_WGLOBAL_CONSTRUCTORS_FLAG -Wglobal-constructors
                TSAN_RTL_CFLAGS)
 append_list_if(COMPILER_RT_INTERCEPT_LIBDISPATCH ${COMPILER_RT_LIBDISPATCH_CFLAGS}
                TSAN_RTL_CFLAGS)
 
 set(TSAN_RTL_DYNAMIC_CFLAGS ${TSAN_RTL_CFLAGS})
 list(REMOVE_ITEM TSAN_RTL_DYNAMIC_CFLAGS -fPIE)
VERBATIM)
     elseif(arch MATCHES "loongarch64")
       add_asm_sources(TSAN_ASM_SOURCES
         tsan_rtl_loongarch64.S
         )
     elseif(arch MATCHES "mips64|mips64le")
       add_asm_sources(TSAN_ASM_SOURCES
         tsan_rtl_mips64.S
         )
+    elseif(arch MATCHES "riscv64")
+      add_asm_sources(TSAN_ASM_SOURCES
+        tsan_rtl_riscv64.S
+        )
     elseif(arch MATCHES "s390x")
       add_asm_sources(TSAN_ASM_SOURCES
         tsan_rtl_s390x.S
         )
       # Check for Go runtime.
       set(BUILDGO_SCRIPT ${CMAKE_CURRENT_SOURCE_DIR}/../go/buildgo.sh)
       add_custom_target(GotsanRuntimeCheck
   COMMAND env "CC=${CMAKE_C_COMPILER} ${CMAKE_C_COMPILER_ARG1}"

compiler-rt/lib/tsan/rtl/tsan_interceptors_posix.cpp

 
 #if defined(__x86_64__) || defined(__mips__) || SANITIZER_PPC64V1 || \
     defined(__s390x__)
 #define PTHREAD_ABI_BASE  "GLIBC_2.3.2"
 #elif defined(__aarch64__) || SANITIZER_PPC64V2
 #define PTHREAD_ABI_BASE  "GLIBC_2.17"
 #elif SANITIZER_LOONGARCH64
 #define PTHREAD_ABI_BASE  "GLIBC_2.36"
+#elif SANITIZER_RISCV64
+#define PTHREAD_ABI_BASE  "GLIBC_2.27"
 #endif
 
 extern "C" int pthread_attr_init(void *attr);
 extern "C" int pthread_attr_destroy(void *attr);
 DECLARE_REAL(int, pthread_attr_getdetachstate, void *, void *)
 extern "C" int pthread_attr_setstacksize(void *attr, uptr stacksize);
 extern "C" int pthread_atfork(void (*prepare)(void), void (*parent)(void),
                               void (*child)(void));

compiler-rt/lib/tsan/rtl/tsan_interface_atomic.cpp

return mo == mo_consume || mo == mo_acquire
       || mo == mo_acq_rel || mo == mo_seq_cst;
 }
 
 static bool IsAcqRelOrder(morder mo) {
   return mo == mo_acq_rel || mo == mo_seq_cst;
 }
 
 template<typename T> T func_xchg(volatile T *v, T op) {
-  T res = __sync_lock_test_and_set(v, op);
+  T res = __atomic_test_and_set(v, op);
   // __sync_lock_test_and_set does not contain full barrier.
   __sync_synchronize();
   return res;
 }
 
 template<typename T> T func_add(volatile T *v, T op) {
   return __sync_fetch_and_add(v, op);
 }

compiler-rt/lib/tsan/rtl/tsan_platform.h

struct MappingPPC64_47 {
   static const uptr kShadowXor = 0x020000000000ull;
   static const uptr kShadowAdd = 0x000000000000ull;
   static const uptr kVdsoBeg       = 0x7800000000000000ull;
   static const uptr kMidAppMemBeg = 0;
   static const uptr kMidAppMemEnd = 0;
 };
 
 /*
+C/C++ on linux/riscv64 (39-bit VMA)
+0000 0010 00 - 0200 0000 00: main binary                      ( 8 GB)
+0200 0000 00 - 1000 0000 00: -
[phone] - 4000 0000 00: shadow memory                    (64 GB)
[phone] - 4800 0000 00: metainfo                         (16 GB)
[phone] - 5500 0000 00: -
[phone] - 5a00 0000 00: main binary (PIE)                (~8 GB)
[phone] - 7c00 0000 00: -
+7d00 0000 00 - 7fff ffff ff: libraries and main thread stack  ( 8 GB)
+
+mmap by default allocates from top downwards
+VDSO sits below loader and above dynamic libraries, within HiApp region.
+Heap starts after program region whose position depends on pie or non-pie.
+Disable tracking them since their locations are not fixed.
+*/
+struct MappingRiscv64_39 {
+  static const uptr kLoAppMemBeg   = 0x0000001000ull;
+  static const uptr kLoAppMemEnd   = 0x0200000000ull;
+  static const uptr kShadowBeg     = 0x1000000000ull;
+  static const uptr kShadowEnd     = 0x2000000000ull;
+  static const uptr kMetaShadowBeg = 0x2000000000ull;
+  static const uptr kMetaShadowEnd = 0x2400000000ull;
+  static const uptr kMidAppMemBeg  = 0x2aaaaaa000ull;
+  static const uptr kMidAppMemEnd  = 0x2c00000000ull;
+  static const uptr kHeapMemBeg    = 0x2c00000000ull;
+  static const uptr kHeapMemEnd    = 0x2c00000000ull;
+  static const uptr kHiAppMemBeg   = 0x3c00000000ull;
+  static const uptr kHiAppMemEnd   = 0x3fffffffffull;
+  static const uptr kShadowMsk     = 0x3800000000ull;
+  static const uptr kShadowXor     = 0x0800000000ull;
+  static const uptr kShadowAdd     = 0x0000000000ull;
+  static const uptr kVdsoBeg       = 0x4000000000ull;
+};
+
+/*
+C/C++ on linux/riscv64 (48-bit VMA)
+0000 0000 1000 - 0500 0000 0000: main binary                      ( 5 TB)
+0500 0000 0000 - 2000 0000 0000: -
[phone] - 4000 0000 0000: shadow memory                    (32 TB)
[phone] - 4800 0000 0000: metainfo                         ( 8 TB)
[phone] - 5555 5555 5000: -
[phone] - 5a00 0000 0000: main binary (PIE)                (~5 TB)
+5a00 0000 0000 - 7a00 0000 0000: -
+7a00 0000 0000 - 7fff ffff ffff: libraries and main thread stack  ( 5 TB)
+*/
+struct MappingRiscv64_48 {
+  static const uptr kLoAppMemBeg   = 0x000000001000ull;
+  static const uptr kLoAppMemEnd   = 0x050000000000ull;
+  static const uptr kShadowBeg     = 0x200000000000ull;
+  static const uptr kShadowEnd     = 0x400000000000ull;
+  static const uptr kMetaShadowBeg = 0x400000000000ull;
+  static const uptr kMetaShadowEnd = 0x480000000000ull;
+  static const uptr kMidAppMemBeg  = 0x555555555000ull;
+  static const uptr kMidAppMemEnd  = 0x5a0000000000ull;
+  static const uptr kHeapMemBeg    = 0x5a0000000000ull;
+  static const uptr kHeapMemEnd    = 0x5a0000000000ull;
+  static const uptr kHiAppMemBeg   = 0x7a0000000000ull;
+  static const uptr kHiAppMemEnd   = 0x7fffffffffffull;
+  static const uptr kShadowMsk     = 0x700000000000ull;
+  static const uptr kShadowXor     = 0x100000000000ull;
+  static const uptr kShadowAdd     = 0x000000000000ull;
+  static const uptr kVdsoBeg       = 0x800000000000ull;
+};
+
+/*
 C/C++ on linux/s390x
 While the kernel provides a 64-bit address space, we have to restrict ourselves
 to 48 bits due to how e.g. SyncVar::GetId() works.
 0000 0000 1000 - 0e00 0000 0000: binary, modules, stacks - 14 TiB
 0e00 0000 0000 - 2000 0000 0000: -
 2000 0000 0000 - 4000 0000 0000: shadow - 32TiB (2 * app)
 4000 0000 0000 - 9000 0000 0000: -
 9000 0000 0000 - 9800 0000 0000: metainfo - 8TiB (0.5 * app)
case 44:
       return Func::template Apply<MappingPPC64_44>(arg);
     case 46:
       return Func::template Apply<MappingPPC64_46>(arg);
     case 47:
       return Func::template Apply<MappingPPC64_47>(arg);
   }
 #  elif defined(__mips64)
   return Func::template Apply<MappingMips64_40>(arg);
+#  elif SANITIZER_RISCV64
+  switch (vmaSize) {
+    case 39:
+      return Func::template Apply<MappingRiscv64_39>(arg);
+    case 48:
+      return Func::template Apply<MappingRiscv64_48>(arg);
+  }
 #  elif defined(__s390x__)
   return Func::template Apply<MappingS390x>(arg);
 #  else
 #    error "unsupported platform"
 #  endif
 #endif
   Die();
 }
 
 template <typename Func>
 void ForEachMapping() {
   Func::template Apply<Mapping48AddressSpace>();
   Func::template Apply<MappingMips64_40>();
   Func::template Apply<MappingAppleAarch64>();
   Func::template Apply<MappingAarch64_39>();
   Func::template Apply<MappingAarch64_42>();
   Func::template Apply<MappingAarch64_48>();
   Func::template Apply<MappingLoongArch64_47>();
   Func::template Apply<MappingPPC64_44>();
   Func::template Apply<MappingPPC64_46>();
   Func::template Apply<MappingPPC64_47>();
+  Func::template Apply<MappingRiscv64_39>();
+  Func::template Apply<MappingRiscv64_48>();
   Func::template Apply<MappingS390x>();
   Func::template Apply<MappingGo48>();
   Func::template Apply<MappingGoWindows>();
   Func::template Apply<MappingGoPPC64_46>();
   Func::template Apply<MappingGoPPC64_47>();
   Func::template Apply<MappingGoAarch64>();
   Func::template Apply<MappingGoMips64_47>();
   Func::template Apply<MappingGoS390x>();
static Result Apply(uptr addr) {
     // 3 bits of the compressed addr match that of the app range. If yes, we
     // assume that the compressed address come from that range and restore the
     // missing top bits to match the app range address.
     const uptr ranges[] = {
         Mapping::kLoAppMemBeg,  Mapping::kLoAppMemEnd, Mapping::kMidAppMemBeg,
         Mapping::kMidAppMemEnd, Mapping::kHiAppMemBeg, Mapping::kHiAppMemEnd,
         Mapping::kHeapMemBeg,   Mapping::kHeapMemEnd,
     };
-    const uptr indicator = 0x0e0000000000ull;
+    const uptr indicator = 0x0f0000000000ull;
     const uptr ind_lsb = 1ull << LeastSignificantSetBitIndex(indicator);
     for (uptr i = 0; i < ARRAY_SIZE(ranges); i += 2) {
       uptr beg = ranges[i];
       uptr end = ranges[i + 1];
       if (beg == end)
         continue;
       for (uptr p = beg; p < end; p = RoundDown(p + ind_lsb, ind_lsb)) {
         if ((addr & indicator) == (p & indicator))

compiler-rt/lib/tsan/rtl/tsan_platform_linux.cpp

# if !SANITIZER_GO
   }
 # else
   if (vmaSize != 47) {
     Printf("FATAL: ThreadSanitizer: unsupported VMA range\n");
     Printf("FATAL: Found %zd - Supported 47\n", vmaSize);
     Die();
   }
 # endif
+#elif SANITIZER_RISCV64
+  // the bottom half of vma is allocated for userspace
+  vmaSize = vmaSize + 1;
+# if !SANITIZER_GO
+  if (vmaSize != 39 && vmaSize != 48) {
+    Printf("FATAL: ThreadSanitizer: unsupported VMA range\n");
+    Printf("FATAL: Found %zd - Supported 39 and 48\n", vmaSize);
+    Die();
+  }
+# endif
 #endif
 }
 
 void InitializePlatform() {
   DisableCoreDumperIfNecessary();
 
   // Go maps shadow memory lazily and works fine with limited address space.
   // Unlimited stack is not a problem as well, because the executable
#elif defined(__powerpc64__)
   // Reverse of:
   //   ld   r4, -28696(r13)
   //   xor  r4, r3, r4
   uptr xor_key;
   asm("ld  %0, -28696(%%r13)" : "=r" (xor_key));
   return mangled_sp ^ xor_key;
 #elif defined(__mips__)
   return mangled_sp;
+#elif SANITIZER_RISCV64
+  return mangled_sp;
 #elif defined(__s390x__)
   // tcbhead_t.stack_guard
   uptr xor_key = ((uptr *)__builtin_thread_pointer())[5];
   return mangled_sp ^ xor_key;
 #else
   #error "Unknown platform"
 #endif
 }

 # endif
 #elif SANITIZER_LINUX
 # ifdef __aarch64__
 #  define LONG_JMP_SP_ENV_SLOT 13
 # elif defined(__loongarch__)
 #  define LONG_JMP_SP_ENV_SLOT 1
 # elif defined(__mips64)
 #  define LONG_JMP_SP_ENV_SLOT 1
+# elif SANITIZER_RISCV64
+#  define LONG_JMP_SP_ENV_SLOT 13
 # elif defined(__s390x__)
 #  define LONG_JMP_SP_ENV_SLOT 9
 # else
 #  define LONG_JMP_SP_ENV_SLOT 6
 # endif
 #endif
 
 uptr ExtractLongJmpSp(uptr *env) {

compiler-rt/lib/tsan/rtl/tsan_rtl.h

 # error "ThreadSanitizer is supported only on 64-bit platforms"
 #endif
 
 namespace __tsan {
 
 #if !SANITIZER_GO
 struct MapUnmapCallback;
 #if defined(__mips64) || defined(__aarch64__) || defined(__loongarch__) || \
-    defined(__powerpc__)
+    defined(__powerpc__) || SANITIZER_RISCV64
 
 struct AP32 {
   static const uptr kSpaceBeg = 0;
   static const u64 kSpaceSize = SANITIZER_MMAP_RANGE_SIZE;
   static const uptr kMetadataSize = 0;
   typedef __sanitizer::CompactSizeClassMap SizeClassMap;
   static const uptr kRegionSizeLog = 20;
   using AddressSpaceView = LocalAddressSpaceView;

compiler-rt/lib/tsan/rtl/tsan_rtl_riscv64.S

+#include "sanitizer_common/sanitizer_asm.h"
+
+.section .text
+
+.comm _ZN14__interception11real_setjmpE,8,8
+.globl ASM_SYMBOL_INTERCEPTOR(setjmp)
+ASM_TYPE_FUNCTION(ASM_SYMBOL_INTERCEPTOR(setjmp))
+ASM_SYMBOL_INTERCEPTOR(setjmp):
+  CFI_STARTPROC
+
+  // Save frame pointer and return address register
+  addi sp, sp, -32
+  sd ra, 24(sp)
+  sd s0, 16(sp)
+  CFI_DEF_CFA_OFFSET (32)
+  CFI_OFFSET (1, -8)
+  CFI_OFFSET (8, -16)
+
+  // Adjust the SP for previous frame
+  addi s0, sp, 32
+  CFI_DEF_CFA_REGISTER (8)
+
+  // Save env parameter
+  sd a0, 8(sp)
+  CFI_OFFSET (10, -24)
+
+  // Obtain SP, first argument to `void __tsan_setjmp(uptr sp)`
+  addi  a0, s0, 0
+
+  // call tsan interceptor
+  call ASM_SYMBOL(__tsan_setjmp)
+
+  // Restore env parameter
+  ld a0, 8(sp)
+  CFI_RESTORE (10)
+
+  // Restore frame/link register
+  ld s0, 16(sp)
+  ld ra, 24(sp)
+  addi sp, sp, 32
+  CFI_RESTORE (8)
+  CFI_RESTORE (1)
+  CFI_DEF_CFA (2, 0)
+
+  // tail jump to libc setjmp
+  la t1, _ZN14__interception11real_setjmpE
+  ld t1, 0(t1)
+  jr t1
+
+  CFI_ENDPROC
+ASM_SIZE(ASM_SYMBOL_INTERCEPTOR(setjmp))
+
+.comm _ZN14__interception12real__setjmpE,8,8
+.globl ASM_SYMBOL_INTERCEPTOR(_setjmp)
+ASM_TYPE_FUNCTION(ASM_SYMBOL_INTERCEPTOR(_setjmp))
+ASM_SYMBOL_INTERCEPTOR(_setjmp):
+  CFI_STARTPROC
+
+  // Save frame pointer and return address register
+  addi sp, sp, -32
+  sd ra, 24(sp)
+  sd s0, 16(sp)
+  CFI_DEF_CFA_OFFSET (32)
+  CFI_OFFSET (1, -8)
+  CFI_OFFSET (8, -16)
+
+  // Adjust the SP for previous frame
+  addi s0, sp, 32
+  CFI_DEF_CFA_REGISTER (8)
+
+  // Save env parameter
+  sd a0, 8(sp)
+  CFI_OFFSET (10, -24)
+
+  // Obtain SP, first argument to `void __tsan_setjmp(uptr sp)`
+  addi  a0, s0, 0
+
+  // call tsan interceptor
+  call ASM_SYMBOL(__tsan_setjmp)
+
+  // Restore env parameter
+  ld a0, 8(sp)
+  CFI_RESTORE (10)
+
+  // Restore frame/link register
+  ld s0, 16(sp)
+  ld ra, 24(sp)
+  addi sp, sp, 32
+  CFI_RESTORE (8)
+  CFI_RESTORE (1)
+  CFI_DEF_CFA (2, 0)
+
+  // tail jump to libc setjmp
+  la t1, _ZN14__interception12real__setjmpE
+  ld t1, 0(t1)
+  jr t1
+
+  CFI_ENDPROC
+ASM_SIZE(ASM_SYMBOL_INTERCEPTOR(_setjmp))
+
+.comm _ZN14__interception14real_sigsetjmpE,8,8
+.globl ASM_SYMBOL_INTERCEPTOR(sigsetjmp)
+ASM_TYPE_FUNCTION(ASM_SYMBOL_INTERCEPTOR(sigsetjmp))
+ASM_SYMBOL_INTERCEPTOR(sigsetjmp):
+  CFI_STARTPROC
+
+  // Save frame pointer and return address register
+  addi sp, sp, -32
+  sd ra, 24(sp)
+  sd s0, 16(sp)
+  CFI_DEF_CFA_OFFSET (32)
+  CFI_OFFSET (1, -8)
+  CFI_OFFSET (8, -16)
+
+  // Adjust the SP for previous frame
+  addi s0, sp, 32
+  CFI_DEF_CFA_REGISTER (8)
+
+  // Save env parameter
+  sd a0, 8(sp)
+  sd a1, 0(sp)
+  CFI_OFFSET (10, -24)
+  CFI_OFFSET (11, -32)
+
+  // Obtain SP, first argument to `void __tsan_setjmp(uptr sp)`
+  addi  a0, s0, 0
+
+  // call tsan interceptor
+  call      ASM_SYMBOL(__tsan_setjmp)
+
+  // Restore env parameter
+  ld a0, 8(sp)
+  ld a1, 0(sp)
+  CFI_RESTORE (10)
+  CFI_RESTORE (11)
+
+  // Restore frame/link register
+  ld s0, 16(sp)
+  ld ra, 24(sp)
+  addi sp, sp, 32
+  CFI_RESTORE (8)
+  CFI_RESTORE (1)
+  CFI_DEF_CFA (2, 0)
+
+  // tail jump to libc setjmp
+  la t1, _ZN14__interception14real_sigsetjmpE
+  ld t1, 0(t1)
+  jr t1
+
+  CFI_ENDPROC
+ASM_SIZE(ASM_SYMBOL_INTERCEPTOR(sigsetjmp))
+
+.comm _ZN14__interception16real___sigsetjmpE,8,8
+.globl ASM_SYMBOL_INTERCEPTOR(__sigsetjmp)
+ASM_TYPE_FUNCTION(ASM_SYMBOL_INTERCEPTOR(__sigsetjmp))
+ASM_SYMBOL_INTERCEPTOR(__sigsetjmp):
+  CFI_STARTPROC
+
+  // Save frame pointer and return address register
+  addi sp, sp, -32
+  sd ra, 24(sp)
+  sd s0, 16(sp)
+  CFI_DEF_CFA_OFFSET (32)
+  CFI_OFFSET (1, -8)
+  CFI_OFFSET (8, -16)
+
+  // Adjust the SP for previous frame
+  addi s0, sp, 32
+  CFI_DEF_CFA_REGISTER (8)
+
+  // Save env parameter
+  sd a0, 8(sp)
+  sd a1, 0(sp)
+  CFI_OFFSET (10, -24)
+  CFI_OFFSET (11, -32)
+
+  // Obtain SP, first argument to `void __tsan_setjmp(uptr sp)`
+  addi  a0, s0, 0
+
+  // call tsan interceptor
+  call      ASM_SYMBOL(__tsan_setjmp)
+
+  // Restore env parameter
+  ld a0, 8(sp)
+  ld a1, 0(sp)
+  CFI_RESTORE (10)
+  CFI_RESTORE (11)
+
+  // Restore frame/link register
+  ld s0, 16(sp)
+  ld ra, 24(sp)
+  addi sp, sp, 32
+  CFI_RESTORE (8)
+  CFI_RESTORE (1)
+  CFI_DEF_CFA (2, 0)
+
+  // tail jump to libc setjmp
+  la t1, _ZN14__interception16real___sigsetjmpE
+  ld t1, 0(t1)
+  jr t1
+
+  CFI_ENDPROC
+ASM_SIZE(ASM_SYMBOL_INTERCEPTOR(__sigsetjmp))

compiler-rt/lib/tsan/tests/CMakeLists.txt

if(APPLE)
   list(APPEND TSAN_UNITTEST_CFLAGS ${DARWIN_osx_CFLAGS})
 
   list(APPEND TSAN_UNITTEST_LINK_FLAGS ${DARWIN_osx_LINK_FLAGS})
   add_weak_symbols("ubsan" TSAN_UNITTEST_LINK_FLAGS)
   add_weak_symbols("sanitizer_common" TSAN_UNITTEST_LINK_FLAGS)
 else()
   list(APPEND TSAN_UNITTEST_LINK_FLAGS -fsanitize=thread)
   list(APPEND TSAN_UNITTEST_LINK_FLAGS -lm)
+  if("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "riscv")
+    list(APPEND TSAN_UNITTEST_LINK_FLAGS -latomic)
+  endif()
   list(APPEND TSAN_UNITTEST_LINK_FLAGS ${COMPILER_RT_TEST_LIBDISPATCH_CFLAGS})
 endif()
 
 set(TSAN_RTL_HEADERS)
 foreach (header ${TSAN_HEADERS})
   list(APPEND TSAN_RTL_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/../${header})
 endforeach()
 

compiler-rt/test/tsan/map32bit.cpp

 // RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t 2>&1 | FileCheck %s
 #include "test.h"
 #include <stdint.h>
 #include <errno.h>
 #include <sys/mman.h>
 
 // Test for issue:
 // https://github.com/google/sanitizers/issues/412
 
 // MAP_32BIT flag for mmap is supported only for x86_64.
 // XFAIL: target=mips{{.*}}
 // XFAIL: target=aarch64{{.*}}
 // XFAIL: target=powerpc64{{.*}}
 // XFAIL: target=s390x{{.*}}
 // XFAIL: target=loongarch64{{.*}}
+// XFAIL: target=riscv64{{.*}}
 
 // MAP_32BIT doesn't exist on OS X and NetBSD.
 // UNSUPPORTED: darwin,target={{.*netbsd.*}}
 
 void *Thread(void *ptr) {
   *(int*)ptr = 42;
   barrier_wait(&barrier);
   return 0;

compiler-rt/test/tsan/mmap_large.cpp

 // that, it was never implemented.  So just define it to zero.
 #undef  MAP_NORESERVE
 #define MAP_NORESERVE 0
 #endif
 
 int main() {
 #ifdef __x86_64__
   const size_t kLog2Size = 39;
-#elif defined(__mips64) || defined(__aarch64__) || defined(__loongarch_lp64)
+#elif defined(__mips64) || defined(__aarch64__) || \
+    defined(__loongarch_lp64) || (defined(__riscv) && __riscv_xlen == 64)
   const size_t kLog2Size = 32;
 #elif defined(__powerpc64__)
   const size_t kLog2Size = 39;
 #elif defined(__s390x__)
   const size_t kLog2Size = 43;
 #endif
   const uintptr_t kLocation = 0x40ULL << kLog2Size;
   void *p = mmap(

compiler-rt/test/tsan/test.h

 }
 #endif
 
 //The const kPCInc must be in sync with StackTrace::GetPreviousInstructionPc
 #if defined(__s390__) || defined(__i386__) || defined(__x86_64__)
 const int kPCInc = 1;
 #elif defined(__sparc__) || defined(__mips__)
 const int kPCInc = 8;
+#elif defined(__riscv) && __riscv_xlen == 64
+const int kPCInc = 2;
 #else
 const int kPCInc = 4;
 #endif
 
 #ifdef __cplusplus
 extern "C" {
 #endif