[compiler-rt] Add aarch64 syscall optimization support

[zatrazz]

Summary

This patch adds the inline syscall support for aarch64 instead of relying
on the syscall runtime function. I had to use the macro system instead of
template one (as x86_64 does) because I have hit a issue with GCC where
named register through asm were not used in template instanciation
(and it has shown on both GCC 4.8 and GCC 4.9).

[samsonov]

lib/sanitizer_common/sanitizer_linux.cc

102

Please add this file to lib/sanitizer_common/CMakeLists.txt

lib/sanitizer_common/sanitizer_syscall_linux_aarch64.inc

28

Any specific reason for not using u64 for argument types as we do on x86_64?

[zatrazz]

Thanks for the review, I will repost the patch with the recommend changes.

lib/sanitizer_common/sanitizer_linux.cc

102

I will add it.

lib/sanitizer_common/sanitizer_syscall_linux_aarch64.inc

28

Not really, I will change it to u64.

[zatrazz]

Updated patch with recommended changes:

• Add sanitizer_syscall_linux_aarch64.inc to lib/sanitizer_common/CMakeLists.txt
• Use u64 on syscall wrappers

[rengolin]

How did you test this?

lib/sanitizer_common/sanitizer_syscall_linux_aarch64.inc

132

Some comments about this would be welcome.

[zatrazz]

The test is basically run the sanitizers tests and check for regression, since all internal syscalls will use the wrappers instead of normal syscall libc function.

lib/sanitizer_common/sanitizer_syscall_linux_aarch64.inc

132

This is the default return code Linux assumes for syscall failures (you can check on libc projects, like glibc and must, that they use the same return check value).

[rengolin]

lib/sanitizer_common/sanitizer_syscall_linux_aarch64.inc

132

I mean, on the code. :)

[rengolin]

Just add a brief description before internal_iserror() and LGTM. Thanks!

[samsonov]

LGTM

lib/sanitizer_common/CMakeLists.txt

107 ↗

(On Diff #32599)

Please sort the file names.

lib/sanitizer_common/sanitizer_linux.cc

 #else
 # define SANITIZER_LINUX_USES_64BIT_SYSCALLS 0
 #endif
 
 namespace __sanitizer {
 
 #if SANITIZER_LINUX && defined(__x86_64__)
 #include "sanitizer_syscall_linux_x86_64.inc"
+#elif SANITIZER_LINUX && defined(__aarch64__)
+#include "sanitizer_syscall_linux_aarch64.inc"
 #else
 #include "sanitizer_syscall_generic.inc"
 #endif
 
 // --------------- sanitizer_libc.h
 uptr internal_mmap(void *addr, uptr length, int prot, int flags, int fd,
                    OFF_T offset) {
 #if SANITIZER_FREEBSD || SANITIZER_LINUX_USES_64BIT_SYSCALLS

lib/sanitizer_common/sanitizer_syscall_linux_aarch64.inc

+//===-- sanitizer_syscall_linux_aarch64.inc --------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Implementations of internal_syscall and internal_iserror for Linux/aarch64.
+//
+//===----------------------------------------------------------------------===//
+
+#define SYSCALL(name) __NR_ ## name
+
+static uptr __internal_syscall(u64 nr) {
+  register long x8 asm("x8") = nr;
+  register long x0 asm("x0");
+  asm volatile("svc 0"
+               : "=r"(x0)
+               : "r"(x8)
+               : "memory", "cc");
+  return x0;
+}
+#define __internal_syscall0(n) \
+  (__internal_syscall)(n)
+
+static uptr __internal_syscall(u64 nr, long arg1) {
+  register long x8 asm("x8") = nr;
+  register long x0 asm("x0") = arg1;
+  asm volatile("svc 0"
+               : "=r"(x0)
+               : "r"(x8), "0"(x0)
+               : "memory", "cc");
+  return x0;
+}
+#define __internal_syscall1(n, a1) \
+  (__internal_syscall)(n, (long)(a1))
+
+static uptr __internal_syscall(u64 nr, long arg1, long arg2) {
+  register long x8 asm("x8") = nr;
+  register long x0 asm("x0") = arg1;
+  register long x1 asm("x1") = arg2;
+  asm volatile("svc 0"
+               : "=r"(x0)
+               : "r"(x8), "0"(x0), "r"(x1)
+               : "memory", "cc");
+  return x0;
+}
+#define __internal_syscall2(n, a1, a2) \
+  (__internal_syscall)(n, (long)(a1), (long)(a2))
+
+static uptr __internal_syscall(u64 nr, long arg1, long arg2, long arg3) {
+  register long x8 asm("x8") = nr;
+  register long x0 asm("x0") = arg1;
+  register long x1 asm("x1") = arg2;
+  register long x2 asm("x2") = arg3;
+  asm volatile("svc 0"
+               : "=r"(x0)
+               : "r"(x8), "0"(x0), "r"(x1), "r"(x2)
+               : "memory", "cc");
+  return x0;
+}
+#define __internal_syscall3(n, a1, a2, a3) \
+  (__internal_syscall)(n, (long)(a1), (long)(a2), (long)(a3))
+
+static uptr __internal_syscall(u64 nr, long arg1, long arg2, long arg3,
+                               long arg4) {
+  register long x8 asm("x8") = nr;
+  register long x0 asm("x0") = arg1;
+  register long x1 asm("x1") = arg2;
+  register long x2 asm("x2") = arg3;
+  register long x3 asm("x3") = arg4;
+  asm volatile("svc 0"
+               : "=r"(x0)
+               : "r"(x8), "0"(x0), "r"(x1), "r"(x2), "r"(x3)
+               : "memory", "cc");
+  return x0;
+}
+#define __internal_syscall4(n, a1, a2, a3, a4) \
+  (__internal_syscall)(n, (long)(a1), (long)(a2), (long)(a3), (long)(a4))
+
+static uptr __internal_syscall(u64 nr, long arg1, long arg2, long arg3,
+                               long arg4, long arg5) {
+  register long x8 asm("x8") = nr;
+  register long x0 asm("x0") = arg1;
+  register long x1 asm("x1") = arg2;
+  register long x2 asm("x2") = arg3;
+  register long x3 asm("x3") = arg4;
+  register long x4 asm("x4") = arg5;
+  asm volatile("svc 0"
+               : "=r"(x0)
+               : "r"(x8), "0"(x0), "r"(x1), "r"(x2), "r"(x3), "r"(x4)
+               : "memory", "cc");
+  return x0;
+}
+#define __internal_syscall5(n, a1, a2, a3, a4, a5) \
+  (__internal_syscall)(n, (long)(a1), (long)(a2), (long)(a3), (long)(a4), \
+                       (long)(a5))
+
+static uptr __internal_syscall(u64 nr, long arg1, long arg2, long arg3,
+                               long arg4, long arg5, long arg6) {
+  register long x8 asm("x8") = nr;
+  register long x0 asm("x0") = arg1;
+  register long x1 asm("x1") = arg2;
+  register long x2 asm("x2") = arg3;
+  register long x3 asm("x3") = arg4;
+  register long x4 asm("x4") = arg5;
+  register long x5 asm("x5") = arg6;
+  asm volatile("svc 0"
+               : "=r"(x0)
+               : "r"(x8), "0"(x0), "r"(x1), "r"(x2), "r"(x3), "r"(x4), "r"(x5)
+               : "memory", "cc");
+  return x0;
+}
+#define __internal_syscall6(n, a1, a2, a3, a4, a5, a6) \
+  (__internal_syscall)(n, (long)(a1), (long)(a2), (long)(a3), (long)(a4), \
+                       (long)(a5), (long)(a6))
+
+#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__)
+
+
+bool internal_iserror(uptr retval, int *rverrno) {
+  if (retval >= (uptr)-4095) {
+    if (rverrno)
+      *rverrno = -retval;
+    return true;
+  }
+  return false;
+}