[asan] Add support for AArch64 ILP32

[zatrazz]

Summary

This patch adds asan support for AArch64 ILP32 abi. ILP32 [1] is a new abi
for AArch64 similar to x32 where AArch64 instruction set are coupled with a
data model where int, long and pointer are 32-bit.

Unfortunately current support is not upstream for all projects. Binutils
and GCC are already covered, but GLIBC [2] and Linux [3] are maintained in
out of tree branches.

Also current LLVM also does not have support for ILP32, so current idea
of this patch is to eventually sync with gcc libsanitizer. In fact runtime
testing were done on gcc.

Main changes for compiler-rt is support the kernel ABI for internal
syscalls. Different than x32, ILP32 tries to leverage 32-bits syscalls
so kernel ABI for 64 bit argument passing (for ftruncate for instance)
are passed using the new Linux generic way for 32 bits (by splitting
high and low in two registers).

So instead of adding more adhoc defines to ILP32 I extende the
SANITIZER_USES_CANONICAL_LINUX_SYSCALLS to represent both 64 bits
argument syscalls (value of 1) and 32 bits (value of 2).

It also fixes an AArch64 issue with upcoming GLIBC 2.27 (the one which
also ILP32 is currently based) with mcontext_t definition (GLIBC now does
not based it on kernel sigcontext_t anymore, but rather redefines it with
slight different members name).

I did a sanity check against AArch64 ILP64 and x86_64 on Linux without
any regressions.

[1] http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.dai0490a/ar01s01.html
[2] https://sourceware.org/git/?p=glibc.git;a=shortlog;h=refs/heads/arm/ilp32
[3] git://git.kernel.org/pub/scm/linux/kernel/git/arm64/linux.git

[zatrazz]

Ping.

[zatrazz]

Ping (x2).

[kubamracek]

Is there a bot that builds for this architecture?

lib/sanitizer_common/sanitizer_platform.h

223

The value of "2" is really weird here. Can we use a separate constant?

[zatrazz]

In D40134#939153, @kubamracek wrote:

Is there a bot that builds for this architecture?

As I described in the message there is some issue with current ABI approach:

1. LLVM does not have support for AArch64 ILP32
2. GLIBC and Linux are maintained in out of tree branches.

So no current buildbot enabled.

lib/sanitizer_common/sanitizer_platform.h

223

I don't see why not, maybe 32 and 64 to represent the underlying wordsize expected?

[zatrazz]

Ping (x3).

[zatrazz]

Ping (x4)

[nsz]

lib/sanitizer_common/sanitizer_linux.cc

1669–1686

this will be fixed in glibc, so the old code works.

lib/sanitizer_common/sanitizer_internal_defs.h

 #if defined(_WIN64)
 // 64-bit Windows uses LLP64 data model.
 typedef unsigned long long uptr;  // NOLINT
 typedef signed   long long sptr;  // NOLINT
 #else
 typedef unsigned long uptr;  // NOLINT
 typedef signed   long sptr;  // NOLINT
 #endif  // defined(_WIN64)
-#if defined(__x86_64__)
-// Since x32 uses ILP32 data model in 64-bit hardware mode, we must use
+#if defined(__x86_64__) || SANITIZER_AARCH64_ILP32
+// Since x32 and ILP32 uses data model in 64-bit hardware mode, we must use
 // 64-bit pointer to unwind stack frame.
 typedef unsigned long long uhwptr;  // NOLINT
 #else
 typedef uptr uhwptr;   // NOLINT
 #endif
 typedef unsigned char u8;
 typedef unsigned short u16;  // NOLINT
 typedef unsigned int u32;

 typedef unsigned error_t;
 #else
 typedef int fd_t;
 typedef int error_t;
 #endif
 typedef int pid_t;
 
 #if SANITIZER_FREEBSD || SANITIZER_NETBSD || SANITIZER_MAC || \
-    (SANITIZER_LINUX && defined(__x86_64__))
+    (SANITIZER_LINUX && (defined(__x86_64__) || SANITIZER_AARCH64_ILP32))
 typedef u64 OFF_T;
 #else
 typedef uptr OFF_T;
 #endif
 typedef u64  OFF64_T;
 
 #if (SANITIZER_WORDSIZE == 64) || SANITIZER_MAC
 typedef uptr operator_new_size_type;
 #else
-# if defined(__s390__) && !defined(__s390x__)
-// Special case: 31-bit s390 has unsigned long as size_t.
+# if (defined(__s390__) && !defined(__s390x__)) || SANITIZER_AARCH64_ILP32
+// Special case: 31-bit s390 and aarch64 ilp32 have unsigned long as size_t.
 typedef unsigned long operator_new_size_type;
 # else
 typedef u32 operator_new_size_type;
 # endif
 #endif
 
 #if SANITIZER_MAC
 // On Darwin, thread IDs are 64-bit even on 32-bit systems.

lib/sanitizer_common/sanitizer_linux.cc

 #endif  // SANITIZER_LINUX
 
 // Are we using 32-bit or 64-bit Linux syscalls?
 // x32 (which defines __x86_64__) has SANITIZER_WORDSIZE == 32
 // but it still needs to use 64-bit syscalls.
 #if SANITIZER_LINUX && (defined(__x86_64__) || defined(__powerpc64__) || \
     SANITIZER_WORDSIZE == 64)
 # define SANITIZER_LINUX_USES_64BIT_SYSCALLS 1
+# define SYSCALL_LL64(val) (val)
 #else
 # define SANITIZER_LINUX_USES_64BIT_SYSCALLS 0
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+#  define SYSCALL_LL64(val) \
+  (long) ((OFF64_T)(val) & 0xffffffff), (long) ((OFF64_T)(val) >> 32)
+# else
+#  define SYSCALL_LL64(val) \
+  (long) ((OFF64_T)val >> 32), (long) ((OFF64_T)(val) & 0xffffffff)
+# endif
 #endif
 
 #if defined(__x86_64__) || SANITIZER_MIPS64
 extern "C" {
 extern void internal_sigreturn();
 }
 #endif
 
uptr internal_write(fd_t fd, const void *buf, uptr count) {
   return res;
 }
 
 uptr internal_ftruncate(fd_t fd, uptr size) {
   sptr res;
 #if SANITIZER_NETBSD
   HANDLE_EINTR(res, internal_syscall64(SYSCALL(ftruncate), fd, 0, (s64)size));
 #else
+# if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS == 2
+  HANDLE_EINTR(res, (sptr)internal_syscall(SYSCALL(ftruncate64), fd,
+               SYSCALL_LL64((OFF_T)size)));
+# else
   HANDLE_EINTR(res, (sptr)internal_syscall(SYSCALL(ftruncate), fd,
                (OFF_T)size));
-#endif
+# endif
+#endif
   return res;
 }
 
 #if !SANITIZER_LINUX_USES_64BIT_SYSCALLS && SANITIZER_LINUX
 static void stat64_to_stat(struct stat64 *in, struct stat *out) {
   internal_memset(out, 0, sizeof(*out));
   out->st_dev = in->st_dev;
   out->st_ino = in->st_ino;

 #endif
 }
 #endif
 
 uptr internal_stat(const char *path, void *buf) {
 #if SANITIZER_FREEBSD || SANITIZER_NETBSD
   return internal_syscall_ptr(SYSCALL(fstatat), AT_FDCWD, (uptr)path,
                           (uptr)buf, 0);
-#elif SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
+#elif SANITIZER_USES_CANONICAL_LINUX_SYSCALLS == 1
   return internal_syscall(SYSCALL(newfstatat), AT_FDCWD, (uptr)path,
                           (uptr)buf, 0);
+#elif SANITIZER_USES_CANONICAL_LINUX_SYSCALLS == 2
+  return internal_syscall(SYSCALL(fstatat64), AT_FDCWD, (uptr)path,
+                          (uptr)buf, 0);
 #elif SANITIZER_LINUX_USES_64BIT_SYSCALLS
 # if defined(__mips64)
   // For mips64, stat syscall fills buffer in the format of kernel_stat
   struct kernel_stat kbuf;
   int res = internal_syscall(SYSCALL(stat), path, &kbuf);
   kernel_stat_to_stat(&kbuf, (struct stat *)buf);
   return res;
 # else
   return internal_syscall(SYSCALL(stat), (uptr)path, (uptr)buf);
 # endif
 #else
   struct stat64 buf64;
   int res = internal_syscall(SYSCALL(stat64), path, &buf64);
   stat64_to_stat(&buf64, (struct stat *)buf);
   return res;
 #endif
 }
 
 uptr internal_lstat(const char *path, void *buf) {
 #if SANITIZER_NETBSD
   return internal_syscall_ptr(SYSCALL(lstat), path, buf);
 #elif SANITIZER_FREEBSD
   return internal_syscall(SYSCALL(fstatat), AT_FDCWD, (uptr)path,
                           (uptr)buf, AT_SYMLINK_NOFOLLOW);
-#elif SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
+#elif SANITIZER_USES_CANONICAL_LINUX_SYSCALLS == 1
   return internal_syscall(SYSCALL(newfstatat), AT_FDCWD, (uptr)path,
                          (uptr)buf, AT_SYMLINK_NOFOLLOW);
+#elif SANITIZER_USES_CANONICAL_LINUX_SYSCALLS == 2
+  return internal_syscall(SYSCALL(fstatat64), AT_FDCWD, (uptr)path,
+                          (uptr)buf, AT_SYMLINK_NOFOLLOW);
 #elif SANITIZER_LINUX_USES_64BIT_SYSCALLS
 # if SANITIZER_MIPS64
   // For mips64, lstat syscall fills buffer in the format of kernel_stat
   struct kernel_stat kbuf;
   int res = internal_syscall(SYSCALL(lstat), path, &kbuf);
   kernel_stat_to_stat(&kbuf, (struct stat *)buf);
   return res;
 # else

 #if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
   return internal_syscall(SYSCALL(unlinkat), AT_FDCWD, (uptr)path, 0);
 #else
   return internal_syscall_ptr(SYSCALL(unlink), (uptr)path);
 #endif
 }
 
 uptr internal_rename(const char *oldpath, const char *newpath) {
-#if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
+#if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS == 1
   return internal_syscall(SYSCALL(renameat), AT_FDCWD, (uptr)oldpath, AT_FDCWD,
                           (uptr)newpath);
+#elif SANITIZER_USES_CANONICAL_LINUX_SYSCALLS == 2
+  return internal_syscall(SYSCALL(renameat2), AT_FDCWD, (uptr)oldpath, AT_FDCWD,
+                          (uptr)newpath, 0);
 #else
   return internal_syscall_ptr(SYSCALL(rename), (uptr)oldpath, (uptr)newpath);
 #endif
 }
 
 uptr internal_sched_yield() {
   return internal_syscall(SYSCALL(sched_yield));
 }
uptr internal_execve(const char *filename, char *const argv[],
                      char *const envp[]) {
   return internal_syscall_ptr(SYSCALL(execve), (uptr)filename, (uptr)argv,
                           (uptr)envp);
 }
 
 // ----------------- sanitizer_common.h
 bool FileExists(const char *filename) {
   struct stat st;
-#if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
+#if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS == 1
   if (internal_syscall(SYSCALL(newfstatat), AT_FDCWD, filename, &st, 0))
+#elif SANITIZER_USES_CANONICAL_LINUX_SYSCALLS == 2
+  if (internal_syscall(SYSCALL(fstatat64), AT_FDCWD, filename, &st, 0))
 #else
   if (internal_stat(filename, &st))
 #endif
     return false;
   // Sanity check: filename is a regular file.
   return S_ISREG(st.st_mode);
 }
 
#else
   return internal_syscall_ptr(SYSCALL(getdents), fd, (uptr)dirp, count);
 #endif
 }
 
 uptr internal_lseek(fd_t fd, OFF_T offset, int whence) {
 #if SANITIZER_NETBSD
   return internal_syscall64(SYSCALL(lseek), fd, 0, offset, whence);
 #else
+# if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS == 2
+  int64_t res;
+  int rc = internal_syscall(SYSCALL(llseek), fd,
+                                    (long) (((u64)(offset)) >> 32),
+                                    (long) offset, &res, whence);
+  return rc ? rc : res;
+# else
   return internal_syscall(SYSCALL(lseek), fd, offset, whence);
-#endif
+# endif
+#endif
 }
 
 #if SANITIZER_LINUX
 uptr internal_prctl(int option, uptr arg2, uptr arg3, uptr arg4, uptr arg5) {
   return internal_syscall(SYSCALL(prctl), option, arg2, arg3, arg4, arg5);
 }
 #endif
 

 
 #if defined(__aarch64__)
 // Android headers in the older NDK releases miss this definition.
 struct __sanitizer_esr_context {
   struct _aarch64_ctx head;
   uint64_t esr;
 };
 
+// glibc starting at 2.26 does not typedef sigcontext to mcontext_t,
+// but rather defines its own with internal reserved member with
+// different naming.  The mcontext_t definition below is based on
+// Linux UAPI for sicontex_t.
+struct __sanitizer_mcontext_t {
+  unsigned long long int fault_address;
+  unsigned long long int regs[31];
+  unsigned long long int pc;
+  unsigned long long int sp;
+  unsigned long long int pstate;
+  unsigned char reserved[4096] __attribute__ ((__aligned__ (16))); // NOLINT
+};
+
 static bool Aarch64GetESR(ucontext_t *ucontext, u64 *esr) {
   static const u32 kEsrMagic = 0x45535201;
-  u8 *aux = ucontext->uc_mcontext.__reserved;
+  __sanitizer_mcontext_t *mctx = reinterpret_cast<__sanitizer_mcontext_t *>
+    (&ucontext->uc_mcontext);
+  u8 *aux = mctx->reserved;
   while (true) {
     _aarch64_ctx *ctx = (_aarch64_ctx *)aux;
     if (ctx->size == 0) break;
     if (ctx->magic == kEsrMagic) {
       *esr = ((__sanitizer_esr_context *)ctx)->esr;
       return true;
     }
     aux += ctx->size;

lib/sanitizer_common/sanitizer_platform.h

 #endif
 
 #if defined(__arm__)
 # define SANITIZER_ARM 1
 #else
 # define SANITIZER_ARM 0
 #endif
 
+#if defined(__aarch64__) && defined(__ILP32__)
+# define SANITIZER_AARCH64_ILP32 1
+#else
+# define SANITIZER_AARCH64_ILP32 0
+#endif
+
 // By default we allow to use SizeClassAllocator64 on 64-bit platform.
 // But in some cases (e.g. AArch64's 39-bit address space) SizeClassAllocator64
 // does not work well and we need to fallback to SizeClassAllocator32.
 // For such platforms build this code with -DSANITIZER_CAN_USE_ALLOCATOR64=0 or
 // change the definition of SANITIZER_CAN_USE_ALLOCATOR64 here.
 #ifndef SANITIZER_CAN_USE_ALLOCATOR64
 # if (SANITIZER_ANDROID && defined(__aarch64__)) || SANITIZER_FUCHSIA
 #  define SANITIZER_CAN_USE_ALLOCATOR64 1

 #elif defined(__aarch64__)
 # define SANITIZER_MMAP_RANGE_SIZE FIRST_32_SECOND_64(1ULL << 32, 1ULL << 48)
 #else
 # define SANITIZER_MMAP_RANGE_SIZE FIRST_32_SECOND_64(1ULL << 32, 1ULL << 47)
 #endif
 
 // The AArch64 linux port uses the canonical syscall set as mandated by
 // the upstream linux community for all new ports. Other ports may still
-// use legacy syscalls.
+// use legacy syscalls.  Also AArch64 ILP32 uses canonical syscall set
+// 32 bits ports.
 #ifndef SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
 # if defined(__aarch64__) && SANITIZER_LINUX
-# define SANITIZER_USES_CANONICAL_LINUX_SYSCALLS 1
+#  if defined(__ILP32__)
+#   define SANITIZER_USES_CANONICAL_LINUX_SYSCALLS 2
+#  else
+#   define SANITIZER_USES_CANONICAL_LINUX_SYSCALLS 1
+#  endif
 # else
 # define SANITIZER_USES_CANONICAL_LINUX_SYSCALLS 0
 # endif
 #endif
 
 // udi16 syscalls can only be used when the following conditions are
 // met:
 // * target is one of arm32, x86-32, sparc32, sh or m68k

lib/sanitizer_common/sanitizer_platform_limits_posix.h

#if defined(__x86_64__)
   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(__aarch64__)
+#elif defined(__aarch64__) && defined(__ILP32__)
+  const unsigned struct_kernel_stat_sz = 80;
+  const unsigned struct_kernel_stat64_sz = 104;
+#elif defined(__aarch64__) && defined(__LP64__)
   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;
   const unsigned struct_kernel_stat64_sz = 104;
#elif SANITIZER_ANDROID || defined(__x86_64__)
   struct __sanitizer_dirent {
     unsigned long long d_ino;
     unsigned long long d_off;
     unsigned short d_reclen;
     // more fields that we don't care about
   };
 #else
   struct __sanitizer_dirent {
+# if SANITIZER_AARCH64_ILP32
+    unsigned long long d_ino;
+    unsigned long long d_off;
+# else
     uptr d_ino;
     uptr d_off;
+# endif
     unsigned short d_reclen;
     // more fields that we don't care about
   };
 #endif
 
 #if SANITIZER_LINUX && !SANITIZER_ANDROID
   struct __sanitizer_dirent64 {
     unsigned long long d_ino;

 #endif
 
 #if SANITIZER_LINUX
   typedef int __sanitizer_clockid_t;
 #endif
 
 #if SANITIZER_LINUX || SANITIZER_FREEBSD
 #if defined(_LP64) || defined(__x86_64__) || defined(__powerpc__)\
-                   || defined(__mips__)
+                   || defined(__mips__)\
+                   || (defined(__aarch64__) && defined(__ILP32__))
   typedef unsigned __sanitizer___kernel_uid_t;
   typedef unsigned __sanitizer___kernel_gid_t;
 #else
   typedef unsigned short __sanitizer___kernel_uid_t;
   typedef unsigned short __sanitizer___kernel_gid_t;
 #endif
 #if defined(__x86_64__) && !defined(_LP64)
   typedef long long __sanitizer___kernel_off_t;

lib/sanitizer_common/sanitizer_platform_limits_posix.cc

 # else
 CHECK_SIZE_AND_OFFSET(ipc_perm, __key);
 CHECK_SIZE_AND_OFFSET(ipc_perm, __seq);
 # endif
 CHECK_SIZE_AND_OFFSET(ipc_perm, uid);
 CHECK_SIZE_AND_OFFSET(ipc_perm, gid);
 CHECK_SIZE_AND_OFFSET(ipc_perm, cuid);
 CHECK_SIZE_AND_OFFSET(ipc_perm, cgid);
-#if !defined(__aarch64__) || !SANITIZER_LINUX || __GLIBC_PREREQ (2, 21)
+#if !defined(__aarch64__) || !SANITIZER_LINUX || __GLIBC_PREREQ (2, 21) \
+    && !defined(__ILP32__)
 /* On aarch64 glibc 2.20 and earlier provided incorrect mode field.  */
 CHECK_SIZE_AND_OFFSET(ipc_perm, mode);
 #endif
 
 CHECK_TYPE_SIZE(shmid_ds);
 CHECK_SIZE_AND_OFFSET(shmid_ds, shm_perm);
 CHECK_SIZE_AND_OFFSET(shmid_ds, shm_segsz);
 CHECK_SIZE_AND_OFFSET(shmid_ds, shm_atime);