[RISCV][ASAN] mark asan as supported for RISCV and enable tests

[EccoTheDolphin]

Summary

Port address sanitizer to RISCV architecture

This change allows using ASAN on RISCV architecture. The majority of existing
tests are passing. With few exceptions (see below). Tests we run on qemu and
on "HiFive Unleashed" board.

Tests run:

Asan-riscv64-inline-Test  - pass
Asan-riscv64-inline-Noinst-Test  - pass
Asan-riscv64-calls-Noinst-Test  - pass
Asan-riscv64-calls-Test  - pass

Lit tests:

RISCV64LinuxConfig (282 supported, few failures)
RISCV64LinuxDynamicConfig (289 supported, few failures)

Lit failures:

asan_and_llvm_coverage_test.cpp - missing libclang_rt.profile-riscv64.a
deep_stack_uaf.cpp - asan works, but backtrace misses some calls
malloc_context_size.cpp - asan works, but backtrace misses some calls
malloc_delete_mismatch.cpp - asan works, but backtrace misses some calls
plugin_wrong_frame_number_bug.cpp - asan works, but backtrace misses some calls
stack-trace-dlclose.cpp - asan works, but backtrace misses some calls
strndup_oob_test.cpp - asan works, but backtrace misses some calls
static_tls.cpp - "Can't guess glibc version" (under debugging)

These failures are under debugging currently and shall be addressed in a
subsequent commits

[EccoTheDolphin]

uploaded the patch by mistake. Will try to re-upload in a proper way once I figure out how to use the arc tool properly.

[EccoTheDolphin]

Port addres sanititizers to RISCV architecture

This change allows using ASAN on RISCV architecture. The majoirity of existing
tests are passing. With few exceptions (see below). Tests we run on qemu and
on "HiFive Unleashed" board.

Tests run:

Asan-riscv64-inline-Test  - pass
Asan-riscv64-inline-Noinst-Test  - pass
Asan-riscv64-calls-Noinst-Test  - pass
Asan-riscv64-calls-Test  - pass

Lit tests:

RISCV64LinuxConfig (282 supported, few failures)
RISCV64LinuxDynamicConfig (289 supported, few failures)

Lit failures:

asan_and_llvm_coverage_test.cpp - missing libclang_rt.profile-riscv64.a
deep_stack_uaf.cpp - asan works, but backtrace misses some calls
malloc_context_size.cpp - asan works, but backtrace misses some calls
malloc_delete_mismatch.cpp - asan works, but backtrace misses some calls
plugin_wrong_frame_number_bug.cpp - asan works, but backtrace misses some calls
stack-trace-dlclose.cpp - asan works, but backtrace misses some calls
strndup_oob_test.cpp - asan works, but backtrace misses some calls
static_tls.cpp - "Can't guess glibc version" (under debugging)

These failures are under debuggng currently and shall be addressed in a
subsequent commits

[EccoTheDolphin]

[RISCV][ASAN] implementation of internal syscalls wrappers for riscv

[1/11] of commits implementing asan port of RISCV

[EccoTheDolphin]

restore combined diff

[EccoTheDolphin]

restore combined diff

[EccoTheDolphin]

fixup some formatting issues

[EccoTheDolphin]

this huge change is abandoned in favor of a more digestible https://reviews.llvm.org/D87582

compiler-rt/lib/sanitizer_common/CMakeLists.txt

set(SANITIZER_IMPL_HEADERS
   sanitizer_symbolizer_internal.h
   sanitizer_symbolizer_libbacktrace.h
   sanitizer_symbolizer_mac.h
   sanitizer_symbolizer_rtems.h
   sanitizer_syscall_generic.inc
   sanitizer_syscall_linux_aarch64.inc
   sanitizer_syscall_linux_arm.inc
   sanitizer_syscall_linux_x86_64.inc
+  sanitizer_syscall_linux_riscv64.inc
   sanitizer_syscalls_netbsd.inc
   sanitizer_thread_registry.h
   sanitizer_tls_get_addr.h
   sanitizer_vector.h
   sanitizer_win.h
   sanitizer_win_defs.h
   sanitizer_win_dll_thunk.h
   sanitizer_win_weak_interception.h

compiler-rt/lib/sanitizer_common/sanitizer_syscall_linux_riscv64.inc

+//===-- sanitizer_syscall_linux_aarch64.inc --------------------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Implementations of internal_syscall and internal_iserror for Linux/riscv64.
+//
+//===----------------------------------------------------------------------===//
+
+// About local register variables:
+// https://gcc.gnu.org/onlinedocs/gcc/Local-Register-Variables.html#Local-Register-Variables
+//
+// Kernel ABI...
+// To my surprise I haven't found much information regarding it.
+// Kernel source and internet browsing shows that:
+//  syscall number is passed in a7 (http://man7.org/linux/man-pages/man2/syscall.2.html)
+//  results are return in a0 and a1 (http://man7.org/linux/man-pages/man2/syscall.2.html)
+//  arguments are passed in: a0-a7 (see below)
+//
+//  Regarding the arguments. The only "documentation" I could find is
+//  this comment (!!!) by Bruce Hold on google forums (!!!):
+//    https://groups.google.com/a/groups.riscv.org/forum/#!topic/sw-dev/exbrzM3GZDQ 
+//    Confirmed by inspecting glibc sources.
+//  Great way to document things.
+#define SYSCALL(name) __NR_ ## name
+
+#define INTERNAL_SYSCALL_CLOBBERS "memory"
+
+static uptr __internal_syscall(u64 nr) {
+  long int ecall_result = 0;
+  register long int a7 asm ("a7") = nr;
+  register long int a0 asm ("a0");
+  __asm__ volatile (
+      "ecall\n\t"
+      : "=r" (a0)
+      : "r" (a7)
+      : INTERNAL_SYSCALL_CLOBBERS);
+  ecall_result = a0;
+  return ecall_result;
+}
+#define __internal_syscall0(n) \
+  (__internal_syscall)(n)
+
+static uptr __internal_syscall(u64 nr, u64 arg1) {
+  long int ecall_result = 0;
+  register long int a7 asm ("a7") = nr;
+  register long int a0 asm ("a0") = arg1;
+  __asm__ volatile (
+      "ecall\n\t"
+      : "+r" (a0)
+      : "r" (a7)
+      : INTERNAL_SYSCALL_CLOBBERS);
+  ecall_result = a0;
+  return ecall_result;
+}
+#define __internal_syscall1(n, a1) \
+  (__internal_syscall)(n, (u64)(a1))
+
+static uptr __internal_syscall(u64 nr, u64 arg1, long arg2) {
+  long int ecall_result = 0;
+  register long int a7 asm ("a7") = nr;
+  register long int a0 asm ("a0") = arg1;
+  register long int a1 asm ("a1") = arg2;
+  __asm__ volatile (
+      "ecall\n\t"
+      : "+r" (a0)
+      : "r" (a7), "r" (a1)
+      : INTERNAL_SYSCALL_CLOBBERS);
+  ecall_result = a0;
+  return ecall_result;
+}
+#define __internal_syscall2(n, a1, a2) \
+  (__internal_syscall)(n, (u64)(a1), (long)(a2))
+
+static uptr __internal_syscall(u64 nr, u64 arg1, long arg2, long arg3) {
+  long int ecall_result = 0;
+  register long int a7 asm ("a7") = nr;
+  register long int a0 asm ("a0") = arg1;
+  register long int a1 asm ("a1") = arg2;
+  register long int a2 asm ("a2") = arg3;
+  __asm__ volatile (
+      "ecall\n\t"
+      : "+r" (a0)
+      : "r" (a7), "r" (a1), "r" (a2)
+      : INTERNAL_SYSCALL_CLOBBERS);
+  ecall_result = a0;
+  return ecall_result;
+}
+#define __internal_syscall3(n, a1, a2, a3) \
+  (__internal_syscall)(n, (u64)(a1), (long)(a2), (long)(a3))
+
+static uptr __internal_syscall(u64 nr, u64 arg1, long arg2, long arg3,
+                               u64 arg4) {
+  long int ecall_result = 0;
+  register long int a7 asm ("a7") = nr;
+  register long int a0 asm ("a0") = arg1;
+  register long int a1 asm ("a1") = arg2;
+  register long int a2 asm ("a2") = arg3;
+  register long int a3 asm ("a3") = arg4;
+  __asm__ volatile (
+      "ecall\n\t"
+      : "+r" (a0)
+      : "r" (a7), "r" (a1), "r" (a2), "r" (a3)
+      : INTERNAL_SYSCALL_CLOBBERS);
+  ecall_result = a0;
+  return ecall_result;
+}
+#define __internal_syscall4(n, a1, a2, a3, a4) \
+  (__internal_syscall)(n, (u64)(a1), (long)(a2), (long)(a3), (long)(a4))
+
+static uptr __internal_syscall(u64 nr, u64 arg1, long arg2, long arg3,
+                               u64 arg4, long arg5) {
+  long int ecall_result = 0;
+  register long int a7 asm ("a7") = nr;
+  register long int a0 asm ("a0") = arg1;
+  register long int a1 asm ("a1") = arg2;
+  register long int a2 asm ("a2") = arg3;
+  register long int a3 asm ("a3") = arg4;
+  register long int a4 asm ("a4") = arg5;
+  __asm__ volatile (
+      "ecall\n\t"
+      : "+r" (a0)
+      : "r" (a7), "r" (a1), "r" (a2), "r" (a3), "r" (a4)
+      : INTERNAL_SYSCALL_CLOBBERS);
+  ecall_result = a0;
+  return ecall_result;
+}
+#define __internal_syscall5(n, a1, a2, a3, a4, a5) \
+  (__internal_syscall)(n, (u64)(a1), (long)(a2), (long)(a3), (long)(a4), \
+                       (u64)(a5))
+
+static uptr __internal_syscall(u64 nr, u64 arg1, long arg2, long arg3,
+                               u64 arg4, long arg5, long arg6) {
+  long int ecall_result = 0;
+  register long int a7 asm ("a7") = nr;
+  register long int a0 asm ("a0") = arg1;
+  register long int a1 asm ("a1") = arg2;
+  register long int a2 asm ("a2") = arg3;
+  register long int a3 asm ("a3") = arg4;
+  register long int a4 asm ("a4") = arg5;
+  register long int a5 asm ("a5") = arg6;
+  __asm__ volatile (
+      "ecall\n\t"
+      : "+r" (a0)
+      : "r" (a7), "r" (a1), "r" (a2), "r" (a3), "r" (a4), "r" (a5)
+      : INTERNAL_SYSCALL_CLOBBERS);
+  ecall_result = a0;
+  return ecall_result;
+}
+#define __internal_syscall6(n, a1, a2, a3, a4, a5, a6) \
+  (__internal_syscall)(n, (u64)(a1), (long)(a2), (long)(a3), (long)(a4), \
+                       (u64)(a5), (long)(a6))
+
+static uptr __internal_syscall(u64 nr, u64 arg1, long arg2, long arg3,
+                               u64 arg4, long arg5, long arg6, long arg7) {
+  long int ecall_result = 0;
+  register long int a7 asm ("a7") = nr;
+  register long int a0 asm ("a0") = arg1;
+  register long int a1 asm ("a1") = arg2;
+  register long int a2 asm ("a2") = arg3;
+  register long int a3 asm ("a3") = arg4;
+  register long int a4 asm ("a4") = arg5;
+  register long int a5 asm ("a5") = arg6;
+  register long int a6 asm ("a6") = arg7;
+  __asm__ volatile (
+      "ecall\n\t"
+      : "+r" (a0)
+      : "r" (a7), "r" (a1), "r" (a2), "r" (a3), "r" (a4), "r" (a5), "r" (a6)
+      : INTERNAL_SYSCALL_CLOBBERS);
+  ecall_result = a0;
+  return ecall_result;
+}
+#define __internal_syscall7(n, a1, a2, a3, a4, a5, a6, a7) \
+  (__internal_syscall)(n, (u64)(a1), (long)(a2), (long)(a3), (long)(a4), \
+                       (u64)(a5), (long)(a6), (long)(a7))
+
+#define __SYSCALL_NARGS_X(a1, a2, a3, a4, a5, a6, a7, a8, n, ...) n
+#define __SYSCALL_NARGS(...) \
+  __SYSCALL_NARGS_X(__VA_ARGS__, 7, 6, 5, 4, 3, 2, 1, 0, )
+#define __SYSCALL_CONCAT_X(a, b) a##b
+#define __SYSCALL_CONCAT(a, b) __SYSCALL_CONCAT_X(a, b)
+#define __SYSCALL_DISP(b, ...) \
+  __SYSCALL_CONCAT(b, __SYSCALL_NARGS(__VA_ARGS__))(__VA_ARGS__)
+
+#define internal_syscall(...) __SYSCALL_DISP(__internal_syscall, __VA_ARGS__)
+
+// Helper function used to avoid cobbler errno.
+bool internal_iserror(uptr retval, int *rverrno) {
+  if (retval >= (uptr)-4095) {
+    if (rverrno)
+      *rverrno = -retval;
+    return true;
+  }
+  return false;
+}