Port asan to FreeBSD AArch64

[andrew]

Summary

Add the compiler-rt support for running AddressSanitizer on FreeBSD on AArch64. FreeBSD only uses a 48-bit address space on arm64. It also currently lacks a method for exposing the esr register to a signal handler.

The esr issue is expected to be fixed soon, however until then there is no way to query it.

[andrew]

The llvm bits are in D32175

[andrew]

Is there any feedback on this?

[dim]

Unfortunately it does not yet compile on FreeBSD 12/arm64, as there is a problem with the system header <machine/pmap.h>:

In file included from /home/dim/src/llvm-trunk/projects/compiler-rt/lib/sanitizer_common/sanitizer_linux.cc:66:
In file included from /usr/include/vm/pmap.h:90:
/usr/include/machine/pmap.h:57:28: error: unknown type name 'vm_page_t'
void pmap_page_set_memattr(vm_page_t m, vm_memattr_t ma);
                           ^
/usr/include/machine/pmap.h:57:41: error: unknown type name 'vm_memattr_t'
void pmap_page_set_memattr(vm_page_t m, vm_memattr_t ma);
                                        ^
/usr/include/machine/pmap.h:66:2: error: unknown type name 'vm_memattr_t'
        vm_memattr_t            pv_memattr;
        ^
3 errors generated.

I've now tried commenting out the inclusion of <vm/pmap.h>, to side-step the issue. It's still building...

[dim]

It turns out I added the <vm/pmap.h> inclusion in rL263157, but it and the two other headers are not needed anymore, as the following diff at least makes it compile:

--- lib/sanitizer_common/sanitizer_linux.cc     (revision 303869)
+++ lib/sanitizer_common/sanitizer_linux.cc     (working copy)
@@ -60,10 +60,7 @@
 #include <unistd.h>

 #if SANITIZER_FREEBSD
-#include <sys/exec.h>
 #include <sys/sysctl.h>
-#include <vm/vm_param.h>
-#include <vm/pmap.h>
 #include <machine/atomic.h>
 extern "C" {
 // <sys/umtx.h> must be included after <errno.h> and <sys/types.h> on

[dim]

Actually the <sys/exec.h> header is still needed for the ps_string usage later in the file, so the diff becomes:

--- lib/sanitizer_common/sanitizer_linux.cc     (revision 303869)
+++ lib/sanitizer_common/sanitizer_linux.cc     (working copy)
@@ -62,8 +62,6 @@
 #if SANITIZER_FREEBSD
 #include <sys/exec.h>
 #include <sys/sysctl.h>
-#include <vm/vm_param.h>
-#include <vm/pmap.h>
 #include <machine/atomic.h>
 extern "C" {
 // <sys/umtx.h> must be included after <errno.h> and <sys/types.h> on

[dim]

With that last patch, I get the following test results, which are not greatly different from those on x86:

********************
Testing: 0 .. 10.. 20.. 30.. 40.. 50.. 60.. 70.. 80.. 90..
Testing Time: 2319.27s
********************
Failing Tests (27):
    LLVM-Unit :: Support/SupportTests/AllocationTests/MappedMemoryTest.AllocAndRelease/3
    LLVM-Unit :: Support/SupportTests/AllocationTests/MappedMemoryTest.AllocAndRelease/4
    LLVM-Unit :: Support/SupportTests/AllocationTests/MappedMemoryTest.DuplicateNear/3
    LLVM-Unit :: Support/SupportTests/AllocationTests/MappedMemoryTest.DuplicateNear/4
    LLVM-Unit :: Support/SupportTests/AllocationTests/MappedMemoryTest.EnabledWrite/3
    LLVM-Unit :: Support/SupportTests/AllocationTests/MappedMemoryTest.EnabledWrite/4
    LLVM-Unit :: Support/SupportTests/AllocationTests/MappedMemoryTest.MultipleAllocAndRelease/3
    LLVM-Unit :: Support/SupportTests/AllocationTests/MappedMemoryTest.MultipleAllocAndRelease/4
    LLVM-Unit :: Support/SupportTests/AllocationTests/MappedMemoryTest.SuccessiveNear/3
    LLVM-Unit :: Support/SupportTests/AllocationTests/MappedMemoryTest.SuccessiveNear/4
    LLVM-Unit :: Support/SupportTests/AllocationTests/MappedMemoryTest.UnalignedNear/3
    LLVM-Unit :: Support/SupportTests/AllocationTests/MappedMemoryTest.UnalignedNear/4
    LLVM-Unit :: Support/SupportTests/AllocationTests/MappedMemoryTest.ZeroNear/3
    LLVM-Unit :: Support/SupportTests/AllocationTests/MappedMemoryTest.ZeroNear/4
    LLVM-Unit :: Support/SupportTests/AllocationTests/MappedMemoryTest.ZeroSizeNear/3
    LLVM-Unit :: Support/SupportTests/AllocationTests/MappedMemoryTest.ZeroSizeNear/4
    LLVM-Unit :: Support/SupportTests/FileSystemTest.permissions
    AddressSanitizer-aarch64-freebsd :: TestCases/Posix/asan-sigbus.cpp
    AddressSanitizer-aarch64-freebsd :: TestCases/Posix/fread_fwrite.cc
    AddressSanitizer-aarch64-freebsd :: TestCases/Posix/strerror_r_test.cc
    AddressSanitizer-aarch64-freebsd :: TestCases/Posix/waitid.cc
    AddressSanitizer-aarch64-freebsd :: TestCases/throw_invoke_test.cc
    SafeStack :: buffer-copy-vla.c
    SafeStack :: buffer-copy.c
    SafeStack :: init.c
    SafeStack :: pthread-cleanup.c
    SafeStack :: pthread.c

  Expected Passes    : 20117
  Expected Failures  : 54
  Unsupported Tests  : 12556
  Unexpected Failures: 27

2 warning(s) in tests.

[bsdjhb]

lib/sanitizer_common/sanitizer_linux_libcdep.cc

329

aarch64 on FreeBSD uses TLS variant I and the code futher below assumes Variant II used on x86. You might be able to add reuse the variant I code I have in the FreeBSD/mips64 ASAN patch though for this.

[myfreeweb]

Looks like D74765 is the new version of this.

lib/asan/asan_mapping.h

 static const u64 kIosSimShadowOffset64 = kDefaultShadowOffset64;
 static const u64 kAArch64_ShadowOffset64 = 1ULL << 36;
 static const u64 kMIPS32_ShadowOffset32 = 0x0aaa0000;
 static const u64 kMIPS64_ShadowOffset64 = 1ULL << 37;
 static const u64 kPPC64_ShadowOffset64 = 1ULL << 41;
 static const u64 kSystemZ_ShadowOffset64 = 1ULL << 52;
 static const u64 kFreeBSD_ShadowOffset32 = 1ULL << 30;  // 0x40000000
 static const u64 kFreeBSD_ShadowOffset64 = 1ULL << 46;  // 0x400000000000
+static const u64 kFreeBSD_AArch64_ShadowOffset64 = 1ULL << 47; // 0x800000000000
 static const u64 kWindowsShadowOffset32 = 3ULL << 28;  // 0x30000000
 
 #define SHADOW_SCALE kDefaultShadowScale
 
 
 #if SANITIZER_WORDSIZE == 32
 #  if SANITIZER_ANDROID
 #    define SHADOW_OFFSET (0)

 #  endif
 #else
 #  if SANITIZER_IOS
 #    if SANITIZER_IOSSIM
 #      define SHADOW_OFFSET kIosSimShadowOffset64
 #    else
 #      define SHADOW_OFFSET __asan_shadow_memory_dynamic_address
 #    endif
+#  elif defined(__aarch64__) && SANITIZER_FREEBSD
+#    define SHADOW_OFFSET kFreeBSD_AArch64_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

lib/sanitizer_common/sanitizer_linux.cc

#endif
                          "r"(parent_tidptr),
                          "r"(a3),
                          "r"(a4),
                          "i"(__NR_clone),
                          "i"(__NR_exit)
                        : "memory", "$29" );
   return res;
 }
-#elif defined(__aarch64__)
+#elif defined(__aarch64__) && SANITIZER_LINUX
 uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg,
                     int *parent_tidptr, void *newtls, int *child_tidptr) {
   long long res;
   if (!fn || !child_stack)
     return -EINVAL;
   CHECK_EQ(0, (uptr)child_stack % 16);
   child_stack = (char *)child_stack - 2 * sizeof(unsigned long long);
   ((unsigned long long *)child_stack)[0] = (uptr)fn;

 }
 #else
 void *internal_start_thread(void (*func)(void *), void *arg) { return 0; }
 
 void internal_join_thread(void *th) {}
 #endif
 
 #if defined(__aarch64__)
+# if SANITIZER_FREEBSD
+static bool Aarch64GetESR(ucontext_t *ucontext, u64 *esr) {
+  return false;
+}
+#else
 // Android headers in the older NDK releases miss this definition.
 struct __sanitizer_esr_context {
   struct _aarch64_ctx head;
   uint64_t esr;
 };
 
 static bool Aarch64GetESR(ucontext_t *ucontext, u64 *esr) {
   static const u32 kEsrMagic = 0x45535201;
   u8 *aux = ucontext->uc_mcontext.__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;
   }
   return false;
 }
 #endif
+#endif
 
 SignalContext::WriteFlag SignalContext::GetWriteFlag(void *context) {
   ucontext_t *ucontext = (ucontext_t *)context;
 #if defined(__x86_64__) || defined(__i386__)
   static const uptr PF_WRITE = 1U << 1;
 #if SANITIZER_FREEBSD
   uptr err = ucontext->uc_mcontext.mc_err;
 #else

 
 void GetPcSpBp(void *context, uptr *pc, uptr *sp, uptr *bp) {
 #if defined(__arm__)
   ucontext_t *ucontext = (ucontext_t*)context;
   *pc = ucontext->uc_mcontext.arm_pc;
   *bp = ucontext->uc_mcontext.arm_fp;
   *sp = ucontext->uc_mcontext.arm_sp;
 #elif defined(__aarch64__)
+# if SANITIZER_FREEBSD
+  ucontext_t *ucontext = (ucontext_t*)context;
+  *pc = ucontext->uc_mcontext.mc_gpregs.gp_elr;
+  *bp = ucontext->uc_mcontext.mc_gpregs.gp_x[29];
+  *sp = ucontext->uc_mcontext.mc_gpregs.gp_sp;
+# else
   ucontext_t *ucontext = (ucontext_t*)context;
   *pc = ucontext->uc_mcontext.pc;
   *bp = ucontext->uc_mcontext.regs[29];
   *sp = ucontext->uc_mcontext.sp;
+#endif
 #elif defined(__hppa__)
   ucontext_t *ucontext = (ucontext_t*)context;
   *pc = ucontext->uc_mcontext.sc_iaoq[0];
   /* GCC uses %r3 whenever a frame pointer is needed.  */
   *bp = ucontext->uc_mcontext.sc_gr[3];
   *sp = ucontext->uc_mcontext.sc_gr[30];
 #elif defined(__x86_64__)
 # if SANITIZER_FREEBSD

lib/sanitizer_common/sanitizer_linux_libcdep.cc

 static void **ThreadSelfSegbase() {
   void **segbase = 0;
 # if defined(__i386__)
   // sysarch(I386_GET_GSBASE, segbase);
   __asm __volatile("mov %%gs:0, %0" : "=r" (segbase));
 # elif defined(__x86_64__)
   // sysarch(AMD64_GET_FSBASE, segbase);
   __asm __volatile("movq %%fs:0, %0" : "=r" (segbase));
+# elif defined(__aarch64__)
+  __asm __volatile("mrs %0, tpidr_el0" : "=&r" (segbase));
 # else
 #  error "unsupported CPU arch for FreeBSD platform"
 # endif
   return segbase;
 }
 
 uptr ThreadSelf() {
   return (uptr)ThreadSelfSegbase()[2];

lib/sanitizer_common/sanitizer_platform_limits_posix.cc

 
 #if SANITIZER_FREEBSD || SANITIZER_IOS
 #undef IOC_DIRMASK
 #endif
 
 #if SANITIZER_LINUX || SANITIZER_FREEBSD
 # include <utime.h>
 # include <sys/ptrace.h>
-# if defined(__mips64) || defined(__aarch64__) || defined(__arm__)
+# if SANITIZER_LINUX && (defined(__mips64) || defined(__aarch64__) || \
+     defined(__arm__))
 #  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

lib/sanitizer_common/sanitizer_syscall_generic.inc

 //===----------------------------------------------------------------------===//
 
 #if SANITIZER_FREEBSD || SANITIZER_MAC
 # define SYSCALL(name) SYS_ ## name
 #else
 # define SYSCALL(name) __NR_ ## name
 #endif
 
-#if (SANITIZER_FREEBSD || SANITIZER_MAC) && defined(__x86_64__)
+#if (SANITIZER_FREEBSD || SANITIZER_MAC) && (defined(__x86_64__) || \
+    defined(__aarch64__))
 # define internal_syscall __syscall
 # else
 # define internal_syscall syscall
 #endif
 
 bool internal_iserror(uptr retval, int *rverrno) {
   if (retval == (uptr)-1) {
     if (rverrno)
       *rverrno = errno;
     return true;
   } else {
     return false;
   }
 }