[ASAN] Port asan to FreeBSD/mips64.

[bsdjhb]

Summary

FreeBSD/mips64 uses the same shadow offset as MIPS64 on Linux.

[bsdjhb]

The LLVM changes to use the correct shadow offset on FreeBSD/mips64 are in D49939.

lib/sanitizer_common/sanitizer_linux.cc

1249

Rather than adding '&& SANITIZER_LINUX' to the #ifdef for each architecture as they are ported to other systems, we might consider wrapping all of the 'internal_clone' implementations in a single '#if SANITIZER_LINUX'.

lib/sanitizer_common/sanitizer_syscall_generic.inc

46

__syscall is valid for all FreeBSD platforms.

[jrtc27]

lib/asan/asan_mapping.h

220

Is there a reason why you don't just hoist the __mips64 case up to line 215 to come before this, like is done for 32-bit MIPS on line 188?

[krytarowski]

lib/sanitizer_common/sanitizer_syscall_generic.inc

46

NetBSD will switch away from the syscall(2)/__syscall(2) approach and use libc natively. These indirect syscall functions are not portable enough and generate problems for various ABIs.

[bsdjhb]

lib/asan/asan_mapping.h

220

Actually, I meant to ask that as a comment when I posted this in terms of what do folks think is the better approach. Thanks for the reminder.

[vitalybuka]

do we still need this patch?

[vitalybuka]

Just to push from "Ready to Review" list.

[bsdjhb]

Sorry for the delay. This does still need review from folks familiar with sanitizers. I haven't yet rebased it to a more recent tree due to lack of review feedback. If there is interest in reviewing it I can update it to a newer tree and retest (or if there is feedback on the current patches I'm happy to update them).

[krytarowski]

This code is out of sync with HEAD.

lib/asan/asan_mapping.h

 #      define SHADOW_OFFSET __asan_shadow_memory_dynamic_address
 #    endif
 #  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
+#  elif SANITIZER_FREEBSD && !defined(__mips64)
 #    define SHADOW_OFFSET kFreeBSD_ShadowOffset64
 #  elif SANITIZER_NETBSD
 #    define SHADOW_OFFSET kNetBSD_ShadowOffset64
 #  elif SANITIZER_MAC
 #   define SHADOW_OFFSET kDefaultShadowOffset64
 #  elif defined(__mips64)
 #   define SHADOW_OFFSET kMIPS64_ShadowOffset64
 #  elif SANITIZER_WINDOWS64

lib/sanitizer_common/sanitizer_linux.cc

 #if SANITIZER_NETBSD
 #include <lwp.h>
 #endif
 
 // For mips64, syscall(__NR_stat) fills the buffer in the 'struct kernel_stat'
 // format. Struct kernel_stat is defined as 'struct stat' in asm/stat.h. To
 // access stat from asm/stat.h, without conflicting with definition in
 // sys/stat.h, we use this trick.
-#if defined(__mips64)
+#if defined(__mips64) && SANITIZER_LINUX
 #include <asm/unistd.h>
 #include <sys/types.h>
 #define stat kernel_stat
 #include <asm/stat.h>
 #undef stat
 #endif
 
 #include <dlfcn.h>
static void stat64_to_stat(struct stat64 *in, struct stat *out) {
   out->st_blksize = in->st_blksize;
   out->st_blocks = in->st_blocks;
   out->st_atime = in->st_atime;
   out->st_mtime = in->st_mtime;
   out->st_ctime = in->st_ctime;
 }
 #endif
 
-#if defined(__mips64)
+#if defined(__mips64) && SANITIZER_LINUX
 // Undefine compatibility macros from <sys/stat.h>
 // so that they would not clash with the kernel_stat
 // st_[a|m|c]time fields
 #undef st_atime
 #undef st_mtime
 #undef st_ctime
 #if defined(SANITIZER_ANDROID)
 // Bionic sys/stat.h defines additional macros
#else
   stat64_to_stat(&buf64, (struct stat *)buf);
   return res;
 #endif
 }
 
 uptr internal_fstat(fd_t fd, void *buf) {
 #if SANITIZER_FREEBSD || SANITIZER_NETBSD || SANITIZER_OPENBSD ||              \
     SANITIZER_LINUX_USES_64BIT_SYSCALLS
-#if SANITIZER_MIPS64 && !SANITIZER_NETBSD && !SANITIZER_OPENBSD
+#if SANITIZER_MIPS64 && SANITIZER_LINUX_USES_64BIT_SYSCALLS
   // For mips64, fstat syscall fills buffer in the format of kernel_stat
   struct kernel_stat kbuf;
   int res = internal_syscall(SYSCALL(fstat), fd, &kbuf);
   kernel_stat_to_stat(&kbuf, (struct stat *)buf);
   return res;
 # else
   return internal_syscall_ptr(SYSCALL(fstat), fd, (uptr)buf);
 # endif
__asm__ __volatile__(
                          "S"(child_stack),
                          "D"(flags),
                          "d"(parent_tidptr),
                          "r"(r8),
                          "r"(r10)
                        : "rsp", "memory", "r11", "rcx");
   return res;
 }
-#elif defined(__mips__)
+#elif defined(__mips__) && 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
   uptr err = ucontext->uc_mcontext.gregs[REG_ERR];
 #endif // SANITIZER_FREEBSD
   return err & PF_WRITE ? WRITE : READ;
 #elif defined(__mips__)
   uint32_t *exception_source;
   uint32_t faulty_instruction;
   uint32_t op_code;
 
+# if SANITIZER_FREEBSD
+  exception_source = (uint32_t *)ucontext->uc_mcontext.mc_pc;
+# else
   exception_source = (uint32_t *)ucontext->uc_mcontext.pc;
+# endif
   faulty_instruction = (uint32_t)(*exception_source);
 
   op_code = (faulty_instruction >> 26) & 0x3f;
 
   // FIXME: Add support for FPU, microMIPS, DSP, MSA memory instructions.
   switch (op_code) {
     case 0x28:  // sb
     case 0x29:  // sh
# endif
   *bp = stk_ptr[15];
 # else
   *pc = ucontext->uc_mcontext.gregs[REG_PC];
   *sp = ucontext->uc_mcontext.gregs[REG_O6];
   stk_ptr = (uptr *) *sp;
   *bp = stk_ptr[15];
 # endif
 #elif defined(__mips__)
+# if SANITIZER_FREEBSD
+  ucontext_t *ucontext = (ucontext_t*)context;
+  *pc = ucontext->uc_mcontext.mc_pc;
+  *bp = ucontext->uc_mcontext.mc_regs[30];
+  *sp = ucontext->uc_mcontext.mc_regs[29];
+# else
   ucontext_t *ucontext = (ucontext_t*)context;
   *pc = ucontext->uc_mcontext.pc;
   *bp = ucontext->uc_mcontext.gregs[30];
   *sp = ucontext->uc_mcontext.gregs[29];
+# endif
 #elif defined(__s390__)
   ucontext_t *ucontext = (ucontext_t*)context;
 # if defined(__s390x__)
   *pc = ucontext->uc_mcontext.psw.addr;
 # else
   *pc = ucontext->uc_mcontext.psw.addr & 0x7fffffff;
 # endif
   *bp = ucontext->uc_mcontext.gregs[11];

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(__mips64__)
+  // MIPS uses TLS variant I. The thread pointer (in hardware register $29)
+  // points to the end of the TCB + 0x7000.  The TCB contains two pointers,
+  // one to the dtv and the second to the struct pthread.
+  const uptr kTlsTcbOffset = 0x7000;
+  const uptr kTlsTcbSize = sizeof(void *) * 2;
+  uptr thread_pointer;
+  asm volatile(".set push;\
+                .set mips64r2;\
+                rdhwr %0,$29;\
+                .set pop" : "=r" (thread_pointer));
+  segbase = (void **)(thread_pointer - kTlsTcbOffset - kTlsTcbSize);
 # else
 #  error "unsupported CPU arch"
 # endif
   return segbase;
 }
 
 uptr ThreadSelf() {
+#if defined(__mips__)
+  return (uptr)ThreadSelfSegbase()[1];
+#else
   return (uptr)ThreadSelfSegbase()[2];
+#endif
 }
 #endif  // SANITIZER_FREEBSD
 
 #if SANITIZER_NETBSD
 static struct tls_tcb * ThreadSelfTlsTcb() {
   struct tls_tcb * tcb;
 # ifdef __HAVE___LWP_GETTCB_FAST
   tcb = (struct tls_tcb *)__lwp_gettcb_fast();
 # elif defined(__HAVE___LWP_GETPRIVATE_FAST)
   tcb = (struct tls_tcb *)__lwp_getprivate_fast();
 # endif
   return tcb;
 }
 
 uptr ThreadSelf() {
   return (uptr)ThreadSelfTlsTcb()->tcb_pthread;
 }
+#endif  // SANITIZER_NETBSD
 
+#if SANITIZER_NETBSD || (SANITIZER_FREEBSD && defined(__mips__))
 int GetSizeFromHdr(struct dl_phdr_info *info, size_t size, void *data) {
   const Elf_Phdr *hdr = info->dlpi_phdr;
   const Elf_Phdr *last_hdr = hdr + info->dlpi_phnum;
 
   for (; hdr != last_hdr; ++hdr) {
     if (hdr->p_type == PT_TLS && info->dlpi_tls_modid == 1) {
       *(uptr*)data = hdr->p_memsz;
       break;
     }
   }
   return 0;
 }
-#endif  // SANITIZER_NETBSD
+#endif  // SANITIZER_NETBSD || (SANITIZER_FREEBSD && defined(__mips__))
 
 #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__)
   *addr = ThreadSelf();
   *size = GetTlsSize();
 # else
   *addr = 0;
   *size = 0;
 # endif
 #elif SANITIZER_FREEBSD
   void** segbase = ThreadSelfSegbase();
   *addr = 0;
   *size = 0;
   if (segbase != 0) {
+# if defined(__mips__)
+    // Variant I
+    //
+    // dtv = segbase[0];
+    // dtv[2] = base of TLS block of the main program
+    void **dtv = (void**) segbase[0];
+    if ((uptr) dtv[1] >= 2) {
+      // Find size (p_memsz) of TLS block of the main program.
+      dl_iterate_phdr(GetSizeFromHdr, size);
+
+      if (*size != 0)
+        *addr = (uptr) dtv[2];
+    }
+# else
+    // Variant II
+    //
     // tcbalign = 16
     // tls_size = round(tls_static_space, tcbalign);
     // dtv = segbase[1];
     // dtv[2] = segbase - tls_static_space;
     void **dtv = (void**) segbase[1];
     *addr = (uptr) dtv[2];
     *size = (*addr == 0) ? 0 : ((uptr) segbase[0] - (uptr) dtv[2]);
+# endif
   }
 #elif SANITIZER_NETBSD
   struct tls_tcb * const tcb = ThreadSelfTlsTcb();
   *addr = 0;
   *size = 0;
   if (tcb != 0) {
     // Find size (p_memsz) of dlpi_tls_modid 1 (TLS block of the main program).
     // ld.elf_so hardcodes the index 1.

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

 # define SYS_sigprocmask SYS___sigprocmask14
 # define SYS_nanosleep SYS___nanosleep50
 # define SYS_clock_gettime SYS___clock_gettime50
 # if SANITIZER_WORDSIZE == 64
 #  define internal_syscall_ptr  __syscall
 # else
 #  define internal_syscall_ptr  syscall
 # endif
-#elif defined(__x86_64__) && (SANITIZER_FREEBSD || SANITIZER_MAC)
+#elif SANITIZER_FREEBSD || (defined(__x86_64__) && SANITIZER_MAC)
 # define internal_syscall __syscall
 # define internal_syscall64 __syscall
 # define internal_syscall_ptr __syscall
 # else
 # define internal_syscall syscall
 # define internal_syscall64 syscall
 # define internal_syscall_ptr syscall
 #endif