[RISCV][ASAN] support code for architecture-specific parts of asan

[EccoTheDolphin]

Summary

[9/11] patch series to port ASAN for riscv64

Depends On D87579

[luismarques]

compiler-rt/lib/asan/asan_mapping.h

82

Nit: RISC-V.

86

Nit: missing period before "High"?

compiler-rt/lib/sanitizer_common/sanitizer_linux_libcdep.cpp

310–312

The comment and the value were copied from AArch64, but they are incorrect for RISC-V.
The size of struct pthread that I see when I build glibc on riscv64 Linux is 1936.

compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_posix.h

74–76

Since you copied the size of struct pthread from AArch64 and it was incorrect, I suspect that here the same might have happened... :-)

[eugenis]

compiler-rt/lib/asan/asan_mapping.h

227

missing indent

compiler-rt/lib/crt/crtbegin.c

55

crtbegin change is unrelated, please move it to a different revision

compiler-rt/lib/sanitizer_common/sanitizer_linux.cpp

716

This is a bit too long, please define SANITIZER_RISCV64 (or some other name) in sanitizer_platform.h, similar to SANITIZER_X32.

compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_posix.h

74–76

There is a compile-time test for this in sanitizer_platform_limits_linux.cpp

[EccoTheDolphin]

compiler-rt/lib/sanitizer_common/sanitizer_linux.cpp

716

I assume that this is not just about this file?
If yes, then can we address this as part of this commit without modifications of the diffs before (less than) D87580

compiler-rt/lib/sanitizer_common/sanitizer_linux_libcdep.cpp

310–312

well, actually when I build glibc for RISCV the size I get is 1792 (so the value we use is off by 4 bytes for whatever reason.

I don't remember how exactly this value was calculated originally (but I definitely believe that I've checked it somehow). Moreover, I don't know/remember an effective way to do that :).

This time I did is as follows (I modified nptl sources and re-compiled):

diff --git a/nptl/allocatestack.c b/nptl/allocatestack.c
index 670cb8ffe6..6d50fa76f1 100644
--- a/nptl/allocatestack.c
+++ b/nptl/allocatestack.c
@@ -169,6 +169,9 @@ stack_list_add (list_t *elem, list_t *list)
 static struct pthread *
 get_cached_stack (size_t *sizep, void **memp)
 {
+  int array[sizeof (struct pthread)];
+  __builtin_printf("%d", &array);
+
   size_t size = *sizep;
   struct pthread *result = NULL;
   list_t *entry;

GCC gives me the following error:

warning: format '%d' expects argument of type 'int', but argument 2 has type 'int (*)[1792]'

Hacky? Yes!. But we have the result ).

This is for glibc-2.29.

The target compiler (riscv64-unknown-linux-gnu, 9.2.0) uses the following (default) options:

 '-std=gnu11' '-fgnu89-inline' '-g' '-O2' '-Wall' '-Wwrite-strings' '-Wundef' '-fmerge-all-constants' '-frounding-math' '-fno-stack-protector' '-Wstrict-prototypes' '-Wold-style-definition' '-fmath-errno' '-ftls-model=initial-exec' \
'-march=rv64gc' '-mabi=lp64d

compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_posix.h

74–76

Apparently, these definitions were merged in https://reviews.llvm.org/D66870. (git show 977205b595cd65fbeb4a045daf34990d8e8a5efd, by Sam Elliott <[e-mail]>)

The value for struct_kernel_stat_sz is the correct one (I've double checked on qemu). I have doubts about struct_kernel_stat64_sz though since it looks like that this struct is not used on rv64. Linux kernel have the following header:

// from arch/riscv/include/generated/uapi/asm/stat.h
#include <asm-generic/stat.h>

// include/uapi/asm-generic/stat.h
/* This matches struct stat64 in glibc2.1. Only used for 32 bit. */
#if BITS_PER_LONG != 64 || defined(ARCH_WANT_STAT64)
struct stat64 {
...
#endif

So given that this is for rv64 only, probably it would be more correct to define it as 0?

74–76

This test passes, though it does not perform checks for stat64, we have the following there:

#if defined(i386)
COMPILER_CHECK(struct_kernel_stat64_sz == sizeof(struct stat64));
#endif

[EccoTheDolphin]

factored-out crt-related change

[EccoTheDolphin]

corrected indentation to comply with existing code style

[EccoTheDolphin]

compiler-rt/lib/sanitizer_common/sanitizer_linux.cpp

716

Created https://reviews.llvm.org/D87997

[eugenis]

compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_posix.h

74–76

OK, this makes sense.

[eugenis]

compiler-rt/lib/sanitizer_common/sanitizer_linux.cpp

716

I'd prefer if the patches were changed to use the new macro from the start. It would produce cleaner git history.

[EccoTheDolphin]

addressing comments

[EccoTheDolphin]

compiler-rt/lib/sanitizer_common/sanitizer_linux.cpp

716

modified the order of patches. now the patch series starts with https://reviews.llvm.org/D87997, gradually adopting the new define.

[eugenis]

compiler-rt/lib/sanitizer_common/sanitizer_common_syscalls.inc

2302

remove "defined". SANITIZER_* macros are not defined/undefined, they are 1/0.

[EccoTheDolphin]

compiler-rt/lib/sanitizer_common/sanitizer_common_syscalls.inc

2302

remove "defined". SANITIZER_* macros are not defined/undefined, they are 1/0.

Yes. You are correct. Quite an embarrassing error. Will fix.

Actually, one way to fix it would be to avoid defining zero value. However, this will violate the current coding conventions, so I guess it's better to update the patchset once again.

[eugenis]

compiler-rt/lib/sanitizer_common/sanitizer_common_syscalls.inc

2302

Right. This way is shorter and the compiler will complain if you forget to include the header, instead of assuming that the property is false (when the macro is undefined).

[EccoTheDolphin]

addressing review comments

[luismarques]

compiler-rt/lib/sanitizer_common/sanitizer_linux_libcdep.cpp

310–312

well, actually when I build glibc for RISCV the size I get is 1792 (so the value we use is off by 4 bytes for whatever reason.

What do you mean? You have 1772 in the patch, and you got 1792, I'm confused by the "off by 4 bytes" comment.

warning: format '%d' expects argument of type 'int', but argument 2 has type 'int (*)[1792]'

Hacky? Yes!. But we have the result ).

This is for glibc-2.29.

Ha! Hey, whatever works, right? I had used a static assert, but it was with a more recent version of glibc.

[EccoTheDolphin]

compiler-rt/lib/sanitizer_common/sanitizer_linux_libcdep.cpp

310–312

What do you mean? You have 1772 in the patch, and you got 1792, I'm confused by the "off by 4 bytes" comment.

The original version of the patch had 1776.

Ha! Hey, whatever works, right? I had used a static assert, but it was with a more recent version of glibc.

By a more recent version of gcc - you mean 2.30+?
If this is the case - do you have any recommendations how we could handle that? Should I add some kind of #ifdef?

[EccoTheDolphin]

rebasing + addressing formatting issues

[luismarques]

compiler-rt/lib/sanitizer_common/sanitizer_linux_libcdep.cpp

310–312

By a more recent version of gcc - you mean 2.30+?

The earliest version that I can compile in my RISC-V machine (with GCC 10.2.1) is 2.31, which has the same size as you reported (1792). 2.32 has a size of 1936.

If this is the case - do you have any recommendations how we could handle that? Should I add some kind of #ifdef?

You can probably do something similar to the code above: call GetLibcVersion and return a value that depends on the obtained version.

[EccoTheDolphin]

compiler-rt/lib/sanitizer_common/sanitizer_linux_libcdep.cpp

310–312

By a more recent version of gcc - you mean 2.30+?

The earliest version that I can compile in my RISC-V machine (with GCC 10.2.1) is 2.31, which has the same size as you reported (1792). 2.32 has a size of 1936.

Wow! Thanks a lot!

You can probably do something similar to the code above: call GetLibcVersion and return a value that depends on the obtained version.

Will do, thanks.

[EccoTheDolphin]

addressed review comments

[EccoTheDolphin]

compiler-rt/lib/sanitizer_common/sanitizer_linux_libcdep.cpp

310–312

You can probably do something similar to the code above: call GetLibcVersion and return a value that depends on the obtained version.

done. I've double-checked the value for 2.32 - it is 1936 for me too. The versions below 2.29 are marked as untested.

[EccoTheDolphin]

RISCV64 does not use stat64, so the corresponding size constant is set to "0"

[EccoTheDolphin]

@luismarques, this commit diff has a mark that a change was requested... I believe that we've addressed known issues. If you have no further objections or comments could you remove the mark?

[luismarques]

For versions 2.29 -- 2.31 you have val = 1172. Is that actually correct? I thought you had earlier obtained a value of 1772 for 2.29, so maybe that's a typo?
Other than that issue, LGTM. Just be sure to verify/adjust that.

[EccoTheDolphin]

In D87580#2307441, @luismarques wrote:

For versions 2.29 -- 2.31 you have val = 1172. Is that actually correct? I thought you had earlier obtained a value of 1772 for 2.29, so maybe that's a typo?
Other than that issue, LGTM. Just be sure to verify/adjust that.

yes, that's a typo :(. Will fix before committing. Thanks

[EccoTheDolphin]

rebasing + fixed typo

[MaskRay]

The complex ThreadDescriptorSize is only needed by LeakSanitizer for allocations only referenced by thread-specific data keys.
I'll check whether my D98926 sticks, if yes, try alternative solutions (e.g. intercept pthread_setspecific) to make thread-specific data keys less hacky.

Ultimately a lot of complexity of GetTls/ThreadDescriptorSize is because we don't have glibc APIs to get static/dynamic TLS boundaries.
If enough people complain loudly (https://groups.google.com/g/address-sanitizer/c/BfwYD8HMxTM/m/xmAY98RPBwAJ), chime in on https://sourceware.org/bugzilla/show_bug.cgi?id=16291 !
They may prioritize that feature request:)

[joshua-arch1]

It seems that Asan cannot work correctly for RISC-V now.
When I use '-fsanitize=address' to compile the program and then run on Qemu, I get
AddressSanitizer: CHECK failed: sanitizer_allocator_primary32.h:292 "((res)) < ((kNumPossibleRegions))" (0x40016, 0x40000) (tid=80622)

<empty stack>

[luismarques]

In D87580#3466476, @joshua-arch1 wrote:

It seems that Asan cannot work correctly for RISC-V now.
When I use '-fsanitize=address' to compile the program and then run on Qemu, I get
AddressSanitizer: CHECK failed: sanitizer_allocator_primary32.h:292 "((res)) < ((kNumPossibleRegions))" (0x40016, 0x40000) (tid=80622)

<empty stack>

From your description, I assume you're running user-mode QEMU. The ASAN address mappings are system-specific. Running the user-mode QEMU is going to call your host machine's kernel, and the address mappings aren't going to be compatible. So I guess that behavior is to be expected. You should instead run a full riscv64-linux-gnu system under qemu-system-riscv64 to use ASAN with RISC-V.

[joshua-arch1]

In D87580#3466769, @luismarques wrote:

In D87580#3466476, @joshua-arch1 wrote:

It seems that Asan cannot work correctly for RISC-V now.
When I use '-fsanitize=address' to compile the program and then run on Qemu, I get
AddressSanitizer: CHECK failed: sanitizer_allocator_primary32.h:292 "((res)) < ((kNumPossibleRegions))" (0x40016, 0x40000) (tid=80622)

<empty stack>

From your description, I assume you're running user-mode QEMU. The ASAN address mappings are system-specific. Running the user-mode QEMU is going to call your host machine's kernel, and the address mappings aren't going to be compatible. So I guess that behavior is to be expected. You should instead run a full riscv64-linux-gnu system under qemu-system-riscv64 to use ASAN with RISC-V.

Can the problem that ASAN is unable to run in user-mode QEMU be avoided by doing something in QEMU? Maybe we can add some options in QEMU for system-specific address mappings?
Also, if I remove the comparison between 'res' and 'kNumPossibleRegions' (CHECK_GE(res, kNumPossibleRegions)) in sanitizer_allocator_primary32.h, I will get another error:
AddressSanitizer: CHECK failed: sanitizer_allocator_dlsym.h:36 "((internal_allocator()->FromPrimary(ptr))) != (0)" (0x0, 0x0) (tid=100987)

<empty stack>

Is it stil because I did not run system-mode QEMU?

[joshua-arch1]

In D87580#3466769, @luismarques wrote:

In D87580#3466476, @joshua-arch1 wrote:

It seems that Asan cannot work correctly for RISC-V now.
When I use '-fsanitize=address' to compile the program and then run on Qemu, I get
AddressSanitizer: CHECK failed: sanitizer_allocator_primary32.h:292 "((res)) < ((kNumPossibleRegions))" (0x40016, 0x40000) (tid=80622)

<empty stack>

From your description, I assume you're running user-mode QEMU. The ASAN address mappings are system-specific. Running the user-mode QEMU is going to call your host machine's kernel, and the address mappings aren't going to be compatible. So I guess that behavior is to be expected. You should instead run a full riscv64-linux-gnu system under qemu-system-riscv64 to use ASAN with RISC-V.

I'm still wondering what causes the address mappings in ASAN incompatible with QEMU user-mode, since all the mappings are based on virtual memory.

[eugenis]

The mappings are defined such that the address range where the kernel might place the main executable image do not overlap with the shadow region. This can be different in qemu.

[joshua-arch1]

In D87580#3483394, @eugenis wrote:

The mappings are defined such that the address range where the kernel might place the main executable image do not overlap with the shadow region. This can be different in qemu.

Did you mean the kernel can guarantee that the address range of the executable image does not overlap with the asan shadow region, but the qemu user-mode cannot? As far as I know, asan is not kasan, and the kernel does not need to do a lot of things for asan. How can the kernel guarantee addresses do not overlap?

[joshua-arch1]

In D87580#3466769, @luismarques wrote:

In D87580#3466476, @joshua-arch1 wrote:

It seems that Asan cannot work correctly for RISC-V now.
When I use '-fsanitize=address' to compile the program and then run on Qemu, I get
AddressSanitizer: CHECK failed: sanitizer_allocator_primary32.h:292 "((res)) < ((kNumPossibleRegions))" (0x40016, 0x40000) (tid=80622)

<empty stack>

From your description, I assume you're running user-mode QEMU. The ASAN address mappings are system-specific. Running the user-mode QEMU is going to call your host machine's kernel, and the address mappings aren't going to be compatible. So I guess that behavior is to be expected. You should instead run a full riscv64-linux-gnu system under qemu-system-riscv64 to use ASAN with RISC-V.

It seems that ASAN can be used with AArch64 just under user-mode QEMU.

[eugenis]

There is a range of addresses where the kernel may place the main executable. It has been extended once in the past (ASLR). ASan mapping is a compile-time constant, so it must work with any location within that range. I suspect that for QEMU this range may be different.

Anyway, some architectures use dynamic shadow allocation at runtime. IMHO this is a much better solution, even if it costs some CPU cycles (5% or whatever).

[joshua-arch1]

In D87580#3502023, @eugenis wrote:

There is a range of addresses where the kernel may place the main executable. It has been extended once in the past (ASLR). ASan mapping is a compile-time constant, so it must work with any location within that range. I suspect that for QEMU this range may be different.

Anyway, some architectures use dynamic shadow allocation at runtime. IMHO this is a much better solution, even if it costs some CPU cycles (5% or whatever).

I basically know what you meant by saying 'some architectures use dynamic shadow allocation at runtime', but that is not what Asan wants. Asan's advantage is to use compile-time instrumentation with a direct address mapping to shadow memory. I'm still wondering how AArch64 can just be run on user-mode Qemu with Asan compile-time instrumentation. Can we also do anything for RISCV?

[eugenis]

We've had enough problems with fixed mapping that I prefer dynamic shadow address for anything going forward. Also, fixed mapping address becomes an ABI constant, which causes issues with prebuilt libraries.

I'm still wondering how AArch64 can just be run on user-mode Qemu with Asan compile-time instrumentation.

Maybe the chosen shadow address happens to be compatible with qemu? You'll need to study the possible memory layouts to answer this.

[joshua-arch1]

It seems that even if I run on hardware, ASAN cannot work for riscv64. It says

==265==ERROR: AddressSanitizer: SEGV on unknown address 0x00081ffd1560 (pc 0x0000000108a8 bp 0x003fffe8ab70 sp 0x003fffe8aaf0 T0)
==265==The signal is caused by a READ memory access.

[luismarques]

In D87580#3536366, @joshua-arch1 wrote:

==265==ERROR: AddressSanitizer: SEGV on unknown address 0x00081ffd1560 (pc 0x0000000108a8 bp 0x003fffe8ab70 sp 0x003fffe8aaf0 T0)
==265==The signal is caused by a READ memory access.

The current (and original) ASan RISC-V implementation assumes sv39. Linux did not support sv48 when the RISC-V ASan port was merged. Check if you are running with sv48 (cat /proc/cpu). If so, that is to be expected. Of course, adding sv48 support is welcome.

[joshua-arch1]

In D87580#3537757, @luismarques wrote:

In D87580#3536366, @joshua-arch1 wrote:

==265==ERROR: AddressSanitizer: SEGV on unknown address 0x00081ffd1560 (pc 0x0000000108a8 bp 0x003fffe8ab70 sp 0x003fffe8aaf0 T0)
==265==The signal is caused by a READ memory access.

The current (and original) ASan RISC-V implementation assumes sv39. Linux did not support sv48 when the RISC-V ASan port was merged. Check if you are running with sv48 (cat /proc/cpu). If so, that is to be expected. Of course, adding sv48 support is welcome.

I have checked the satp register to convince myself that I was just running with sv39. I also spent a few hours debugging the up-to-date sanitizer code, but got nothing. Has anyone encounted with this error before?

[luismarques]

In D87580#3539755, @joshua-arch1 wrote:

I have checked the satp register to convince myself that I was just running with sv39. I also spent a few hours debugging the up-to-date sanitizer code, but got nothing. Has anyone encounted with this error before?

Thanks for that work. I think I will be able to look into this around the end of this week or the start of the next one.

[luismarques]

In D87580#3545550, @luismarques wrote:

In D87580#3539755, @joshua-arch1 wrote:

I have checked the satp register to convince myself that I was just running with sv39. I also spent a few hours debugging the up-to-date sanitizer code, but got nothing. Has anyone encounted with this error before?

Thanks for that work. I think I will be able to look into this around the end of this week or the start of the next one.

I've checked that indeed things are broken in main but they weren't broken with an older commit. I'll bisect and investigate this. My current RV64 setup is slow so the bisection will take a while.

[joshua-arch1]

This comment was removed by joshua-arch1.

[joshua-arch1]

In D87580#3565488, @luismarques wrote:

In D87580#3545550, @luismarques wrote:

In D87580#3539755, @joshua-arch1 wrote:

I have checked the satp register to convince myself that I was just running with sv39. I also spent a few hours debugging the up-to-date sanitizer code, but got nothing. Has anyone encounted with this error before?

Thanks for that work. I think I will be able to look into this around the end of this week or the start of the next one.

I've checked that indeed things are broken in main but they weren't broken with an older commit. I'll bisect and investigate this. My current RV64 setup is slow so the bisection will take a while.

How is this work going? If you find the commit that led to this failure, maybe I can also help fix it.

[luismarques]

In D87580#3576736, @joshua-arch1 wrote:

How is this work going? If you find the commit that led to this failure, maybe I can also help fix it.

I was going to reply earlier but then I ran into reproducibility issues. Long story short, I had reproduced the failure but during the bisection process it stopped reproducing. I'll provide more details when I can.

[joshua-arch1]

In D87580#3578809, @luismarques wrote:

In D87580#3576736, @joshua-arch1 wrote:

How is this work going? If you find the commit that led to this failure, maybe I can also help fix it.

I was going to reply earlier but then I ran into reproducibility issues. Long story short, I had reproduced the failure but during the bisection process it stopped reproducing. I'll provide more details when I can.

What specific failure are you encounted with currently? For me, I got the deadly signal error (SEGV on unknown address) for all the cases. Is this issue just for riscv or for all the targets? I'm trying to modify the logic between deadly signal error and generic error like heap-use-after-free. I'm not sure whether it is feasible.

[luismarques]

In D87580#3584196, @joshua-arch1 wrote:

What specific failure are you encounted with currently? For me, I got the deadly signal error (SEGV on unknown address) for all the cases. Is this issue just for riscv or for all the targets? I'm trying to modify the logic between deadly signal error and generic error like heap-use-after-free. I'm not sure whether it is feasible.

It varies. A few are SEGV on unknown address, others are failed CHECKs, others are the cases where the sanitizer was supposed to trip but it trips in a different way than the test expected, etc.

The ASan tests seem to fail when I do a check-all but (so far) not when I do check-asan, which explains why running just the ASan tests to bisect the issue was a dead end. Running the sanitizer-common tests (check-sanitizer) seems to reliably reproduce errors, which helps. I haven't yet delved into the errors themselves, I was just running these experiments as a background task. I'll check some possible sources of non-determinism (e.g. ASLR) and then try to actually delve into the failures. If you can share more about your test setup that might help.

[joshua-arch1]

This comment was removed by joshua-arch1.

[joshua-arch1]

This comment was removed by joshua-arch1.

[joshua-arch1]

In D87580#3502023, @eugenis wrote:

There is a range of addresses where the kernel may place the main executable. It has been extended once in the past (ASLR). ASan mapping is a compile-time constant, so it must work with any location within that range. I suspect that for QEMU this range may be different.

Anyway, some architectures use dynamic shadow allocation at runtime. IMHO this is a much better solution, even if it costs some CPU cycles (5% or whatever).

I have been delving into ASLR these days and it will indeed cause the asan shadow memory range to interleave with an existing memory mapping. But I'm still wondering why this conflict only occurs under user-mode qemu rather than system-mode qemu or hardware.

[joshua-arch1]

In D87580#3502023, @eugenis wrote:

There is a range of addresses where the kernel may place the main executable. It has been extended once in the past (ASLR). ASan mapping is a compile-time constant, so it must work with any location within that range. I suspect that for QEMU this range may be different.

Anyway, some architectures use dynamic shadow allocation at runtime. IMHO this is a much better solution, even if it costs some CPU cycles (5% or whatever).

I now understand what the kernel does with the address mapping, but why user-mode qemu is different? What's the difference when qemu is doing an address mapping?

[luismarques]

In D87580#3606865, @joshua-arch1 wrote:

Are you testing on user-QEMU or on hardware? Failed CHEKCS are caused by user-QEMU incompatibility. It will not affect the checker results. As far as I am concerneed, what we expect is to pass all the programs under gcc/testsuite/gcc.dg/asan.

I ran the LLVM sanitizer tests under a variety of configurations, in both qemu-system-riscv64 (Fedora) and a SiFive Unmatched (Ubuntu) PC.
While there were a few failures for the real RISC-V machine, it seems like the system-qemu configuration is where the problems really reproduce.
I also double-checked my previous regression investigation. To make a long story short, I just need to find the time to actually delve into the failing tests and see what the root cause of the issues is because those automated investigations (bisections, etc.) didn't really reveal anything particularly useful.

[joshua-arch1]

Are there any rv32 asan support currently? I know rv32 linux abi is not working, but I don't think it will influence the use of rv32 asan.

[EccoTheDolphin]

In D87580#3933164, @joshua-arch1 wrote:

Are there any rv32 asan support currently? I know rv32 linux abi is not working, but I don't think it will influence the use of rv32 asan.

Hi @joshua-arch1 , no there is no support for rv32. At the time these patches were created rv32 was not even evaluated/considered. I can't say for sure if there are any issues with introducing such support.

[joshua-arch1]

In D87580#3936540, @EccoTheDolphin wrote:

In D87580#3933164, @joshua-arch1 wrote:

Are there any rv32 asan support currently? I know rv32 linux abi is not working, but I don't think it will influence the use of rv32 asan.

Hi @joshua-arch1 , no there is no support for rv32. At the time these patches were created rv32 was not even evaluated/considered. I can't say for sure if there are any issues with introducing such support.

So do you have any plans to support rv32 asan? I suppose porting can be done independant of rv32 linux.

[joshua-arch1]

How can I get the size of struct pthread in sanitizer_linux_libcdep.cpp?

compiler-rt/lib/asan/asan_allocator.h

 const uptr kAllocatorSpace = ~(uptr)0;
 const uptr kAllocatorSize  =  0x20000000000ULL;  // 2T.
 typedef DefaultSizeClassMap SizeClassMap;
 # elif defined(__aarch64__) && SANITIZER_ANDROID
 // Android needs to support 39, 42 and 48 bit VMA.
 const uptr kAllocatorSpace =  ~(uptr)0;
 const uptr kAllocatorSize  =  0x2000000000ULL;  // 128G.
 typedef VeryCompactSizeClassMap SizeClassMap;
+#elif (defined(__riscv) && (__riscv_xlen == 64))
+const uptr kAllocatorSpace = ~(uptr)0;
+const uptr kAllocatorSize = 0x2000000000ULL;  // 128G.
+typedef VeryDenseSizeClassMap SizeClassMap;
 # elif defined(__aarch64__)
 // AArch64/SANITIZER_CAN_USE_ALLOCATOR64 is only for 42-bit VMA
 // so no need to different values for different VMA.
 const uptr kAllocatorSpace =  0x10000000000ULL;
 const uptr kAllocatorSize  =  0x10000000000ULL;  // 3T.
 typedef DefaultSizeClassMap SizeClassMap;
 #elif defined(__sparc__)
 const uptr kAllocatorSpace = ~(uptr)0;

compiler-rt/lib/asan/asan_mapping.h

 //
 // Default Linux/AArch64 (39-bit VMA) mapping:
 // || `[0x2000000000, 0x7fffffffff]` || highmem    ||
 // || `[0x1400000000, 0x1fffffffff]` || highshadow ||
 // || `[0x1200000000, 0x13ffffffff]` || shadowgap  ||
 // || `[0x1000000000, 0x11ffffffff]` || lowshadow  ||
 // || `[0x0000000000, 0x0fffffffff]` || lowmem     ||
 //
+// Riscv has only 38 bits for task size
+// Low mem size is set with kRiscv64_ShadowOffset64 in
+// compiler-rt/lib/asan/asan_allocator.h and in
+// llvm/lib/Transforms/Instrumentation/AddressSanitizer.cpp with
+// kRiscv64_ShadowOffset64 High mem top border is set with
+// GetMaxVirtualAddress() in
+// compiler-rt/lib/sanitizer_common/sanitizer_linux.cpp
+// Default Linux/RISCV64 Sv39/Sv48 mapping:
+// || `[0x000820000000, 0x003fffffffff]` || HighMem    ||
+// || `[0x000124000000, 0x00081fffffff]` || HighShadow ||
+// || `[0x000024000000, 0x000123ffffff]` || ShadowGap  ||
+// || `[0x000020000000, 0x000023ffffff]` || LowShadow  ||
+// || `[0x000000000000, 0x00001fffffff]` || LowMem     ||
+//
 // Default Linux/AArch64 (42-bit VMA) mapping:
 // || `[0x10000000000, 0x3ffffffffff]` || highmem    ||
 // || `[0x0a000000000, 0x0ffffffffff]` || highshadow ||
 // || `[0x09000000000, 0x09fffffffff]` || shadowgap  ||
 // || `[0x08000000000, 0x08fffffffff]` || lowshadow  ||
 // || `[0x00000000000, 0x07fffffffff]` || lowmem     ||
 //
 // Default Linux/S390 mapping:

 static const u64 kDefaultShadowScale = SANITIZER_MYRIAD2 ? 5 : 3;
 #endif
 static const u64 kDefaultShadowSentinel = ~(uptr)0;
 static const u64 kDefaultShadowOffset32 = 1ULL << 29;  // 0x20000000
 static const u64 kDefaultShadowOffset64 = 1ULL << 44;
 static const u64 kDefaultShort64bitShadowOffset =
     0x7FFFFFFF & (~0xFFFULL << kDefaultShadowScale);  // < 2G.
 static const u64 kAArch64_ShadowOffset64 = 1ULL << 36;
+static const u64 kRiscv64_ShadowOffset64 = 0x20000000;
 static const u64 kMIPS32_ShadowOffset32 = 0x0aaa0000;
 static const u64 kMIPS64_ShadowOffset64 = 1ULL << 37;
 static const u64 kPPC64_ShadowOffset64 = 1ULL << 44;
 static const u64 kSystemZ_ShadowOffset64 = 1ULL << 52;
 static const u64 kSPARC64_ShadowOffset64 = 1ULL << 43;  // 0x80000000000
 static const u64 kFreeBSD_ShadowOffset32 = 1ULL << 30;  // 0x40000000
 static const u64 kFreeBSD_ShadowOffset64 = 1ULL << 46;  // 0x400000000000
 static const u64 kNetBSD_ShadowOffset32 = 1ULL << 30;  // 0x40000000

 #  else
 #    define SHADOW_OFFSET kDefaultShadowOffset32
 #  endif
 #else
 #  if SANITIZER_IOS
 #    define SHADOW_OFFSET __asan_shadow_memory_dynamic_address
 #  elif SANITIZER_MAC && defined(__aarch64__)
 #    define SHADOW_OFFSET __asan_shadow_memory_dynamic_address
+#elif (defined(__riscv) && (__riscv_xlen == 64))
+#define SHADOW_OFFSET kRiscv64_ShadowOffset64
 #  elif defined(__aarch64__)
 #    define SHADOW_OFFSET kAArch64_ShadowOffset64
 #  elif defined(__powerpc64__)
 #    define SHADOW_OFFSET kPPC64_ShadowOffset64
 #  elif defined(__s390x__)
 #    define SHADOW_OFFSET kSystemZ_ShadowOffset64
 #  elif SANITIZER_FREEBSD
 #    define SHADOW_OFFSET kFreeBSD_ShadowOffset64

compiler-rt/lib/asan/asan_shadow_setup.cpp

ReserveShadowMemoryRange(GapShadowBeg, GapShadowEnd,
                              "unprotected gap shadow");
     return;
   }
   __sanitizer::ProtectGap(addr, size, kZeroBaseShadowStart,
                           kZeroBaseMaxShadowStart);
 }
 
 static void MaybeReportLinuxPIEBug() {
-#if SANITIZER_LINUX && (defined(__x86_64__) || defined(__aarch64__))
+#if SANITIZER_LINUX && (defined(__x86_64__) || defined(__aarch64__) || \
+                        (defined(__riscv) && (__riscv_xlen == 64)))
   Report("This might be related to ELF_ET_DYN_BASE change in Linux 4.12.\n");
   Report(
       "See https://github.com/google/sanitizers/issues/856 for possible "
       "workarounds.\n");
 #endif
 }
 
 void InitializeShadowMemory() {

compiler-rt/lib/crt/crtbegin.c

 
 #ifdef CRT_HAS_INITFINI_ARRAY
 __attribute__((section(".init_array"),
                used)) static void (*__init)(void) = __do_init;
 #elif defined(__i386__) || defined(__x86_64__)
 __asm__(".pushsection .init,\"ax\",@progbits\n\t"
     "call " __USER_LABEL_PREFIX__ "__do_init\n\t"
     ".popsection");
+#elif defined(__riscv)
+__asm__(".pushsection .init,\"ax\",%progbits\n\t"
+        "call " __USER_LABEL_PREFIX__ "__do_init\n\t"
+        ".popsection");
 #elif defined(__arm__) || defined(__aarch64__)
 __asm__(".pushsection .init,\"ax\",%progbits\n\t"
     "bl " __USER_LABEL_PREFIX__ "__do_init\n\t"
     ".popsection");
 #elif defined(__powerpc__) || defined(__powerpc64__)
 __asm__(".pushsection .init,\"ax\",@progbits\n\t"
     "bl " __USER_LABEL_PREFIX__ "__do_init\n\t"
     "nop\n\t"

 __asm__(".pushsection .fini,\"ax\",%progbits\n\t"
     "bl " __USER_LABEL_PREFIX__ "__do_fini\n\t"
     ".popsection");
 #elif defined(__powerpc__) || defined(__powerpc64__)
 __asm__(".pushsection .fini,\"ax\",@progbits\n\t"
     "bl " __USER_LABEL_PREFIX__ "__do_fini\n\t"
     "nop\n\t"
     ".popsection");
+#elif defined(__riscv)
+__asm__(".pushsection .fini,\"ax\",@progbits\n\t"
+        "call " __USER_LABEL_PREFIX__ "__do_fini\n\t"
+        "nop\n\t"
+        ".popsection");
 #elif defined(__sparc__)
 __asm__(".pushsection .fini,\"ax\",@progbits\n\t"
     "call " __USER_LABEL_PREFIX__ "__do_fini\n\t"
     ".popsection");
 #else
 #error "crtbegin without .init_fini array unimplemented for this architecture"
 #endif  // CRT_HAS_INIT_FINI_ARRAY

compiler-rt/lib/sanitizer_common/sanitizer_common.h

enum ModuleArch {
   kModuleArchUnknown,
   kModuleArchI386,
   kModuleArchX86_64,
   kModuleArchX86_64H,
   kModuleArchARMV6,
   kModuleArchARMV7,
   kModuleArchARMV7S,
   kModuleArchARMV7K,
-  kModuleArchARM64
+  kModuleArchARM64,
+  kModuleArchRISCV64
 };
 
 // Opens the file 'file_name" and reads up to 'max_len' bytes.
 // The resulting buffer is mmaped and stored in '*buff'.
 // Returns true if file was successfully opened and read.
 bool ReadFileToVector(const char *file_name,
                       InternalMmapVectorNoCtor<char> *buff,
                       uptr max_len = 1 << 26, error_t *errno_p = nullptr);
switch (arch) {
     case kModuleArchARMV7:
       return "armv7";
     case kModuleArchARMV7S:
       return "armv7s";
     case kModuleArchARMV7K:
       return "armv7k";
     case kModuleArchARM64:
       return "arm64";
+    case kModuleArchRISCV64:
+      return "riscv64";
   }
   CHECK(0 && "Invalid module arch");
   return "";
 }
 
 const uptr kModuleUUIDSize = 16;
 const uptr kMaxSegName = 16;
 

compiler-rt/lib/sanitizer_common/sanitizer_common_syscalls.inc

struct sanitizer_kernel_sockaddr {
   unsigned short sa_family;
   char sa_data[14];
 };
 
 // Real sigset size is always passed as a syscall argument.
 // Declare it "void" to catch sizeof(kernel_sigset_t).
 typedef void kernel_sigset_t;
 
 static void kernel_write_iovec(const __sanitizer_iovec *iovec,
                         SIZE_T iovlen, SIZE_T maxlen) {
   for (SIZE_T i = 0; i < iovlen && maxlen; ++i) {
     SSIZE_T sz = Min(iovec[i].iov_len, maxlen);
     POST_WRITE(iovec[i].iov_base, sz);
     maxlen -= sz;
   }
 }
 
 // This functions uses POST_READ, because it needs to run after syscall to know
 // the real read range.
 static void kernel_read_iovec(const __sanitizer_iovec *iovec,
                        SIZE_T iovlen, SIZE_T maxlen) {
   POST_READ(iovec, sizeof(*iovec) * iovlen);
   for (SIZE_T i = 0; i < iovlen && maxlen; ++i) {
     SSIZE_T sz = Min(iovec[i].iov_len, maxlen);
     POST_READ(iovec[i].iov_base, sz);
     maxlen -= sz;
   }
 }
 
 PRE_SYSCALL(recvmsg)(long sockfd, sanitizer_kernel_msghdr *msg, long flags) {
   PRE_READ(msg, sizeof(*msg));
 }
 
 POST_SYSCALL(recvmsg)(long res, long sockfd, sanitizer_kernel_msghdr *msg,
                       long flags) {
   if (res >= 0) {
     if (msg) {
       for (unsigned long i = 0; i < msg->msg_iovlen; ++i) {
         POST_WRITE(msg->msg_iov[i].iov_base, msg->msg_iov[i].iov_len);
       }
       POST_WRITE(msg->msg_control, msg->msg_controllen);
     }
   }
 }
 
 PRE_SYSCALL(recvmmsg)(long fd, sanitizer_kernel_mmsghdr *msg, long vlen,
                       long flags, void *timeout) {
   PRE_READ(msg, vlen * sizeof(*msg));
 }
 
 POST_SYSCALL(recvmmsg)(long res, long fd, sanitizer_kernel_mmsghdr *msg,
                        long vlen, long flags, void *timeout) {
   if (res >= 0) {
     if (msg) {
       for (unsigned long i = 0; i < msg->msg_hdr.msg_iovlen; ++i) {
         POST_WRITE(msg->msg_hdr.msg_iov[i].iov_base,
                    msg->msg_hdr.msg_iov[i].iov_len);
       }
       POST_WRITE(msg->msg_hdr.msg_control, msg->msg_hdr.msg_controllen);
       POST_WRITE(&msg->msg_len, sizeof(msg->msg_len));
     }
     if (timeout) POST_WRITE(timeout, struct_timespec_sz);
   }
 }
 
 PRE_SYSCALL(read)(long fd, void *buf, uptr count) {
   if (buf) {
     PRE_WRITE(buf, count);
   }
 }
 
 POST_SYSCALL(read)(long res, long fd, void *buf, uptr count) {
   if (res > 0 && buf) {
     POST_WRITE(buf, res);

 
 PRE_SYSCALL(ni_syscall)() {}
 
 POST_SYSCALL(ni_syscall)(long res) {}
 
 PRE_SYSCALL(ptrace)(long request, long pid, long addr, long data) {
 #if !SANITIZER_ANDROID && \
     (defined(__i386) || defined(__x86_64) || defined(__mips64) || \
-     defined(__powerpc64__) || defined(__aarch64__) || defined(__s390__))
+     defined(__powerpc64__) || defined(__aarch64__) || defined(__s390__) || \
+     (defined(__riscv) && (__riscv_xlen == 64)))
   if (data) {
     if (request == ptrace_setregs) {
       PRE_READ((void *)data, struct_user_regs_struct_sz);
     } else if (request == ptrace_setfpregs) {
       PRE_READ((void *)data, struct_user_fpregs_struct_sz);
     } else if (request == ptrace_setfpxregs) {
       PRE_READ((void *)data, struct_user_fpxregs_struct_sz);
     } else if (request == ptrace_setsiginfo) {
       PRE_READ((void *)data, siginfo_t_sz);
     } else if (request == ptrace_setregset) {
       __sanitizer_iovec *iov = (__sanitizer_iovec *)data;
       PRE_READ(iov->iov_base, iov->iov_len);
     }
   }
 #endif
 }
 
 POST_SYSCALL(ptrace)(long res, long request, long pid, long addr, long data) {
 #if !SANITIZER_ANDROID && \
     (defined(__i386) || defined(__x86_64) || defined(__mips64) || \
-     defined(__powerpc64__) || defined(__aarch64__) || defined(__s390__))
+     defined(__powerpc64__) || defined(__aarch64__) || defined(__s390__) || \
+     (defined(__riscv) && (__riscv_xlen == 64)))
   if (res >= 0 && data) {
     // Note that this is different from the interceptor in
     // sanitizer_common_interceptors.inc.
     // PEEK* requests return resulting values through data pointer.
     if (request == ptrace_getregs) {
       POST_WRITE((void *)data, struct_user_regs_struct_sz);
     } else if (request == ptrace_getfpregs) {
       POST_WRITE((void *)data, struct_user_fpregs_struct_sz);

compiler-rt/lib/sanitizer_common/sanitizer_linux.cpp

 #   define SANITIZER_USE_GETENTROPY 0
 # endif
 #endif // SANITIZER_USE_GETENTROPY
 
 namespace __sanitizer {
 
 #if SANITIZER_LINUX && defined(__x86_64__)
 #include "sanitizer_syscall_linux_x86_64.inc"
+#elif SANITIZER_LINUX && (defined(__riscv) && (__riscv_xlen == 64))
+#include "sanitizer_syscall_linux_riscv64.inc"
 #elif SANITIZER_LINUX && defined(__aarch64__)
 #include "sanitizer_syscall_linux_aarch64.inc"
 #elif SANITIZER_LINUX && defined(__arm__)
 #include "sanitizer_syscall_linux_arm.inc"
 #else
 #include "sanitizer_syscall_generic.inc"
 #endif
 
struct linux_dirent {
   u64 d_ino;  // d_fileno
   u16 d_reclen;
   u16 d_namlen;  // not used
   u8 d_type;     // not used
   char d_name[NAME_MAX + 1];
 };
 #else
 struct linux_dirent {
-#if SANITIZER_X32 || defined(__aarch64__)
+#if SANITIZER_X32 || defined(__aarch64__) || \
+    (defined(__riscv) && (__riscv_xlen == 64))
   u64 d_ino;
   u64 d_off;
 #else
   unsigned long      d_ino;
   unsigned long      d_off;
 #endif
   unsigned short     d_reclen;
-#ifdef __aarch64__
+#if defined(__aarch64__) || (defined(__riscv) && (__riscv_xlen == 64))
   unsigned char      d_type;
 #endif
   char               d_name[256];
 };
 #endif
 
 #if !SANITIZER_SOLARIS && !SANITIZER_NETBSD
 // Syscall wrappers.
# if defined(__powerpc64__) || defined(__aarch64__)
   // On PowerPC64 we have two different address space layouts: 44- and 46-bit.
   // We somehow need to figure out which one we are using now and choose
   // one of 0x00000fffffffffffUL and 0x00003fffffffffffUL.
   // Note that with 'ulimit -s unlimited' the stack is moved away from the top
   // of the address space, so simply checking the stack address is not enough.
   // This should (does) work for both PowerPC64 Endian modes.
   // Similarly, aarch64 has multiple address space layouts: 39, 42 and 47-bit.
   return (1ULL << (MostSignificantSetBitIndex(GET_CURRENT_FRAME()) + 1)) - 1;
+#elif (defined(__riscv) && (__riscv_xlen == 64))
+  return (1ULL << 38) - 1;
 # elif defined(__mips64)
   return (1ULL << 40) - 1;  // 0x000000ffffffffffUL;
 # elif defined(__s390x__)
   return (1ULL << 53) - 1;  // 0x001fffffffffffffUL;
 #elif defined(__sparc__)
   return ~(uptr)0;
 # else
   return (1ULL << 47) - 1;  // 0x00007fffffffffffUL;

compiler-rt/lib/sanitizer_common/sanitizer_linux_libcdep.cpp

if (tls_align < kStackAlign)
     tls_align = kStackAlign;
   g_tls_size = RoundUpTo(tls_size, tls_align);
 }
 #else
 void InitTlsSize() { }
 #endif  // !SANITIZER_FREEBSD && !SANITIZER_ANDROID && !SANITIZER_GO &&
         // !SANITIZER_NETBSD && !SANITIZER_SOLARIS
 
-#if (defined(__x86_64__) || defined(__i386__) || defined(__mips__) ||          \
-     defined(__aarch64__) || defined(__powerpc64__) || defined(__s390__) ||    \
-     defined(__arm__)) &&                                                      \
+#if (defined(__x86_64__) || defined(__i386__) || defined(__mips__) ||       \
+     defined(__aarch64__) || defined(__powerpc64__) || defined(__s390__) || \
+     defined(__arm__) || (defined(__riscv) && (__riscv_xlen == 64))) &&     \
     SANITIZER_LINUX && !SANITIZER_ANDROID
 // sizeof(struct pthread) from glibc.
 static atomic_uintptr_t thread_descriptor_size;
 
 uptr ThreadDescriptorSize() {
   uptr val = atomic_load_relaxed(&thread_descriptor_size);
   if (val)
     return val;
if (GetLibcVersion(&major, &minor, &patch) && major == 2) {
     else if (minor <= 14)
       val = FIRST_32_SECOND_64(1168, 2304);
     else
       val = FIRST_32_SECOND_64(1216, 2304);
   }
 #elif defined(__mips__)
   // TODO(sagarthakur): add more values as per different glibc versions.
   val = FIRST_32_SECOND_64(1152, 1776);
+#elif (defined(__riscv) && (__riscv_xlen == 64))
+  // The sizeof (struct pthread) is the same from GLIBC 2.17 to 2.22.
+  val = 1776;
 #elif defined(__aarch64__)
   // The sizeof (struct pthread) is the same from GLIBC 2.17 to 2.22.
   val = 1776;
 #elif defined(__powerpc64__)
   val = 1776; // from glibc.ppc64le 2.20-8.fc21
 #elif defined(__s390__)
   val = FIRST_32_SECOND_64(1152, 1776); // valid for glibc 2.22
 #endif

 #if !SANITIZER_GO
 static void GetTls(uptr *addr, uptr *size) {
 #if SANITIZER_LINUX && !SANITIZER_ANDROID
 # if defined(__x86_64__) || defined(__i386__) || defined(__s390__)
   *addr = ThreadSelf();
   *size = GetTlsSize();
   *addr -= *size;
   *addr += ThreadDescriptorSize();
-# elif defined(__mips__) || defined(__aarch64__) || defined(__powerpc64__) \
-    || defined(__arm__)
+#elif defined(__mips__) || defined(__aarch64__) || defined(__powerpc64__) || \
+    defined(__arm__) || (defined(__riscv) && (__riscv_xlen == 64))
   *addr = ThreadSelf();
   *size = GetTlsSize();
 # else
   *addr = 0;
   *size = 0;
 # endif
 #elif SANITIZER_FREEBSD
   void** segbase = ThreadSelfSegbase();

 
 #if !SANITIZER_GO
 uptr GetTlsSize() {
 #if SANITIZER_FREEBSD || SANITIZER_ANDROID || SANITIZER_NETBSD ||              \
     SANITIZER_OPENBSD || SANITIZER_SOLARIS
   uptr addr, size;
   GetTls(&addr, &size);
   return size;
-#elif defined(__mips__) || defined(__powerpc64__)
+#elif defined(__mips__) || defined(__powerpc64__) || \
+    (defined(__riscv) && (__riscv_xlen == 64))
   return RoundUpTo(g_tls_size + TlsPreTcbSize(), 16);
 #else
   return g_tls_size;
 #endif
 }
 #endif
 
 void GetThreadStackAndTls(bool main, uptr *stk_addr, uptr *stk_size,

compiler-rt/lib/sanitizer_common/sanitizer_platform.h

 # endif
 #endif
 
 // The range of addresses which can be returned my mmap.
 // FIXME: this value should be different on different platforms.  Larger values
 // will still work but will consume more memory for TwoLevelByteMap.
 #if defined(__mips__)
 # define SANITIZER_MMAP_RANGE_SIZE FIRST_32_SECOND_64(1ULL << 32, 1ULL << 40)
+#elif (defined(__riscv) && (__riscv_xlen == 64))
+#define SANITIZER_MMAP_RANGE_SIZE FIRST_32_SECOND_64(1ULL << 32, 1ULL << 38)
 #elif defined(__aarch64__)
 # if SANITIZER_MAC
 // Darwin iOS/ARM64 has a 36-bit VMA, 64GiB VM
 #  define SANITIZER_MMAP_RANGE_SIZE FIRST_32_SECOND_64(1ULL << 32, 1ULL << 36)
 # else
 #  define SANITIZER_MMAP_RANGE_SIZE FIRST_32_SECOND_64(1ULL << 32, 1ULL << 48)
 # endif
 #elif defined(__sparc__)

compiler-rt/lib/sanitizer_common/sanitizer_platform_interceptors.h

 #define SANITIZER_INTERCEPT_SENDMMSG SI_LINUX
 #define SANITIZER_INTERCEPT_SYSMSG SI_LINUX_NOT_ANDROID
 #define SANITIZER_INTERCEPT_GETPEERNAME SI_POSIX
 #define SANITIZER_INTERCEPT_IOCTL SI_POSIX
 #define SANITIZER_INTERCEPT_INET_ATON SI_POSIX
 #define SANITIZER_INTERCEPT_SYSINFO SI_LINUX
 #define SANITIZER_INTERCEPT_READDIR SI_POSIX
 #define SANITIZER_INTERCEPT_READDIR64 SI_LINUX_NOT_ANDROID || SI_SOLARIS32
-#if SI_LINUX_NOT_ANDROID && \
-  (defined(__i386) || defined(__x86_64) || defined(__mips64) || \
+#if SI_LINUX_NOT_ANDROID &&                                                \
+    (defined(__i386) || defined(__x86_64) || defined(__mips64) ||          \
      defined(__powerpc64__) || defined(__aarch64__) || defined(__arm__) || \
-    defined(__s390__))
+     defined(__s390__) || (defined(__riscv) && (__riscv_xlen == 64)))
 #define SANITIZER_INTERCEPT_PTRACE 1
 #else
 #define SANITIZER_INTERCEPT_PTRACE 0
 #endif
 #define SANITIZER_INTERCEPT_SETLOCALE SI_POSIX
 #define SANITIZER_INTERCEPT_GETCWD SI_POSIX
 #define SANITIZER_INTERCEPT_GET_CURRENT_DIR_NAME SI_LINUX_NOT_ANDROID
 #define SANITIZER_INTERCEPT_STRTOIMAX SI_POSIX

compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_posix.h

 const unsigned struct_kernel_stat_sz = 144;
 const unsigned struct_kernel_stat64_sz = 0;
 #elif defined(__i386__)
 const unsigned struct_kernel_stat_sz = 64;
 const unsigned struct_kernel_stat64_sz = 96;
 #elif defined(__arm__)
 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;
 #elif defined(__aarch64__)
 const unsigned struct_kernel_stat_sz = 128;
 const unsigned struct_kernel_stat64_sz = 104;
 #elif defined(__powerpc__) && !defined(__powerpc64__)
 const unsigned struct_kernel_stat_sz = 72;
 const unsigned struct_kernel_stat64_sz = 104;
 #elif defined(__powerpc64__)
 const unsigned struct_kernel_stat_sz = 144;

 #else
 typedef void __sanitizer_FILE;
 # define SANITIZER_HAS_STRUCT_FILE 0
 #endif
 
 #if SANITIZER_LINUX && !SANITIZER_ANDROID &&                               \
     (defined(__i386) || defined(__x86_64) || defined(__mips64) ||          \
      defined(__powerpc64__) || defined(__aarch64__) || defined(__arm__) || \
-     defined(__s390__))
+     defined(__s390__) || (defined(__riscv) && (__riscv_xlen == 64)))
 extern unsigned struct_user_regs_struct_sz;
 extern unsigned struct_user_fpregs_struct_sz;
 extern unsigned struct_user_fpxregs_struct_sz;
 extern unsigned struct_user_vfpregs_struct_sz;
 
 extern int ptrace_peektext;
 extern int ptrace_peekdata;
 extern int ptrace_peekuser;

compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_posix.cpp

 
 #if SANITIZER_IOS
 #undef IOC_DIRMASK
 #endif
 
 #if SANITIZER_LINUX
 # include <utime.h>
 # include <sys/ptrace.h>
-# if defined(__mips64) || defined(__aarch64__) || defined(__arm__)
+#if defined(__mips64) || defined(__aarch64__) || defined(__arm__) || \
+    (defined(__riscv) && (__riscv_xlen == 64))
 #  include <asm/ptrace.h>
 #  ifdef __arm__
 typedef struct user_fpregs elf_fpregset_t;
 #   define ARM_VFPREGS_SIZE_ASAN (32 * 8 /*fpregs*/ + 4 /*fpscr*/)
 #   if !defined(ARM_VFPREGS_SIZE)
 #     define ARM_VFPREGS_SIZE ARM_VFPREGS_SIZE_ASAN
 #   endif
 #  endif

 unsigned struct_ElfW_Phdr_sz = sizeof(Elf_Phdr);
 #endif
 
 #if SANITIZER_LINUX && !SANITIZER_ANDROID
   int glob_nomatch = GLOB_NOMATCH;
   int glob_altdirfunc = GLOB_ALTDIRFUNC;
 #endif
 
-#if SANITIZER_LINUX && !SANITIZER_ANDROID && \
-    (defined(__i386) || defined(__x86_64) || defined(__mips64) || \
-      defined(__powerpc64__) || defined(__aarch64__) || defined(__arm__) || \
-      defined(__s390__))
+#if SANITIZER_LINUX && !SANITIZER_ANDROID &&                               \
+    (defined(__i386) || defined(__x86_64) || defined(__mips64) ||          \
+     defined(__s390__) || (defined(__riscv) && (__riscv_xlen == 64)))
 #if defined(__mips64) || defined(__powerpc64__) || defined(__arm__)
   unsigned struct_user_regs_struct_sz = sizeof(struct pt_regs);
   unsigned struct_user_fpregs_struct_sz = sizeof(elf_fpregset_t);
+#elif (defined(__riscv) && (__riscv_xlen == 64))
+  unsigned struct_user_regs_struct_sz = sizeof(struct user_regs_struct);
+  unsigned struct_user_fpregs_struct_sz = sizeof(struct __riscv_q_ext_state);
 #elif defined(__aarch64__)
   unsigned struct_user_regs_struct_sz = sizeof(struct user_pt_regs);
   unsigned struct_user_fpregs_struct_sz = sizeof(struct user_fpsimd_state);
 #elif defined(__s390__)
   unsigned struct_user_regs_struct_sz = sizeof(struct _user_regs_struct);
   unsigned struct_user_fpregs_struct_sz = sizeof(struct _user_fpregs_struct);
 #else
   unsigned struct_user_regs_struct_sz = sizeof(struct user_regs_struct);
   unsigned struct_user_fpregs_struct_sz = sizeof(struct user_fpregs_struct);
 #endif // __mips64 || __powerpc64__ || __aarch64__
 #if defined(__x86_64) || defined(__mips64) || defined(__powerpc64__) || \
-    defined(__aarch64__) || defined(__arm__) || defined(__s390__)
+    defined(__aarch64__) || defined(__arm__) || defined(__s390__) ||    \
+    (defined(__riscv) && (__riscv_xlen == 64))
   unsigned struct_user_fpxregs_struct_sz = 0;
 #else
   unsigned struct_user_fpxregs_struct_sz = sizeof(struct user_fpxregs_struct);
 #endif // __x86_64 || __mips64 || __powerpc64__ || __aarch64__ || __arm__
 // || __s390__
 #ifdef __arm__
   unsigned struct_user_vfpregs_struct_sz = ARM_VFPREGS_SIZE;
 #else

compiler-rt/lib/sanitizer_common/sanitizer_stoptheworld_linux_libcdep.cpp

 //===-- sanitizer_stoptheworld_linux_libcdep.cpp --------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // See sanitizer_stoptheworld.h for details.
 // This implementation was inspired by Markus Gutschke's linuxthreads.cc.
 //
 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_platform.h"
 
-#if SANITIZER_LINUX && (defined(__x86_64__) || defined(__mips__) || \
-                        defined(__aarch64__) || defined(__powerpc64__) || \
-                        defined(__s390__) || defined(__i386__) || \
-                        defined(__arm__))
+#if SANITIZER_LINUX &&                                                   \
+    (defined(__x86_64__) || defined(__mips__) || defined(__aarch64__) || \
+     defined(__powerpc64__) || defined(__s390__) || defined(__i386__) || \
+     defined(__arm__) || (defined(__riscv) && (__riscv_xlen == 64)))
 
 #include "sanitizer_stoptheworld.h"
 
 #include "sanitizer_platform_limits_posix.h"
 #include "sanitizer_atomic.h"
 
 #include <errno.h>
 #include <sched.h> // for CLONE_* definitions
 #include <stddef.h>
 #include <sys/prctl.h> // for PR_* definitions
 #include <sys/ptrace.h> // for PTRACE_* definitions
 #include <sys/types.h> // for pid_t
 #include <sys/uio.h> // for iovec
 #include <elf.h> // for NT_PRSTATUS
-#if defined(__aarch64__) && !SANITIZER_ANDROID
+#if (defined(__aarch64__) || (defined(__riscv) && (__riscv_xlen == 64))) && \
+    !SANITIZER_ANDROID
 // GLIBC 2.20+ sys/user does not include asm/ptrace.h
 # include <asm/ptrace.h>
 #endif
 #include <sys/user.h>  // for user_regs_struct
 #if SANITIZER_ANDROID && SANITIZER_MIPS
 # include <asm/reg.h>  // for mips SP register in sys/user.h
 #endif
 #include <sys/wait.h> // for signal-related stuff

 #  define REG_SP regs[EF_REG29]
 # endif
 
 #elif defined(__aarch64__)
 typedef struct user_pt_regs regs_struct;
 #define REG_SP sp
 #define ARCH_IOVEC_FOR_GETREGSET
 
+#elif (defined(__riscv) && (__riscv_xlen == 64))
+typedef struct user_regs_struct regs_struct;
+#define REG_SP sp
+#define ARCH_IOVEC_FOR_GETREGSET
+
 #elif defined(__s390__)
 typedef _user_regs_struct regs_struct;
 #define REG_SP gprs[15]
 #define ARCH_IOVEC_FOR_GETREGSET
 
 #else
 #error "Unsupported architecture"
 #endif // SANITIZER_ANDROID && defined(__arm__)

compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_libcdep.cpp

private:
   void GetArgV(const char *path_to_binary,
                const char *(&argv)[kArgVMax]) const override {
 #if defined(__x86_64h__)
     const char* const kSymbolizerArch = "--default-arch=x86_64h";
 #elif defined(__x86_64__)
     const char* const kSymbolizerArch = "--default-arch=x86_64";
 #elif defined(__i386__)
     const char* const kSymbolizerArch = "--default-arch=i386";
+#elif (defined(__riscv) && (__riscv_xlen == 64))
+    const char *const kSymbolizerArch = "--default-arch=riscv64";
 #elif defined(__aarch64__)
     const char* const kSymbolizerArch = "--default-arch=arm64";
 #elif defined(__arm__)
     const char* const kSymbolizerArch = "--default-arch=arm";
 #elif defined(__powerpc64__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
     const char* const kSymbolizerArch = "--default-arch=powerpc64";
 #elif defined(__powerpc64__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
     const char* const kSymbolizerArch = "--default-arch=powerpc64le";