[sanitizer] Fix build on FreeBSD RISC-V

[arichardson]

Summary

We have to avoid calling renameat2 and clone on FreeBSD.
Additionally, the mcontext structure has different members.

[jrtc27]

compiler-rt/lib/sanitizer_common/sanitizer_linux.cpp

1345

x86_64, i386 and arm currently have this, but aarch64, mips and powerpc64 do not. Should we not just hoist an #if SANITIZER_LINUX out around the whole thing so we don't need N copies of the same thing?

1909

This whole code is overly complex on FreeBSD. On Linux's it's needed because (for whatever reason, probably because it copied MIPS) the exception info isn't available. On FreeBSD you can just inspect gp_sstatus and see if it's a load or store/amo page/access fault, like is done for Arm and AArch64.

[jrtc27]

compiler-rt/lib/sanitizer_common/sanitizer_linux.cpp

1909

... never mind, that's sstatus, not scause. How sad, and what a weird field to expose, there's nothing you can usefully do with it from userspace. Maybe we should break ABI and replace it with gp_scause... nobody should be using it at the moment.

[arichardson]

compiler-rt/lib/sanitizer_common/sanitizer_linux.cpp

1345

I considered adding it around the whole block, but then decided to keep the diff as small as possible instead. Happy to change that though

[luismarques]

LGTM.

compiler-rt/lib/sanitizer_common/sanitizer_linux.cpp

1345

@jrtc27's suggestion makes sense. Please commit an updated patch.

1909

... never mind, that's sstatus, not scause. How sad, and what a weird field to expose, there's nothing you can usefully do with it from userspace. Maybe we should break ABI and replace it with gp_scause... nobody should be using it at the moment.

That would be nice. The current approach is always going to be brittle. Plus, IIRC it's not even being directly unit-tested. Was your suggestion to change the ABI only for FreeBSD, though?

[jrtc27]

compiler-rt/lib/sanitizer_common/sanitizer_linux.cpp

1909

It should be doable on Linux too in the same way that it's done for AArch64 I would imagine, i.e. tacking an extra list of variable length extension structs on the end. They probably won't be so willing to break ABI :) (in FreeBSD breaking ABI is ok if you have good justification and it's not a Tier 1 architecture)

[arichardson]

Use a top-level ifdef

compiler-rt/lib/sanitizer_common/sanitizer_linux.cpp

 #if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
   return internal_syscall(SYSCALL(unlinkat), AT_FDCWD, (uptr)path, 0);
 #else
   return internal_syscall(SYSCALL(unlink), (uptr)path);
 #endif
 }
 
 uptr internal_rename(const char *oldpath, const char *newpath) {
-#if defined(__riscv)
+#if defined(__riscv) && defined(__linux__)
   return internal_syscall(SYSCALL(renameat2), AT_FDCWD, (uptr)oldpath, AT_FDCWD,
                           (uptr)newpath, 0);
 #elif SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
   return internal_syscall(SYSCALL(renameat), AT_FDCWD, (uptr)oldpath, AT_FDCWD,
                           (uptr)newpath);
 #else
   return internal_syscall(SYSCALL(rename), (uptr)oldpath, (uptr)newpath);
 #endif
if (phdr->p_type == PT_LOAD) {
       seg_start = RoundDownTo(seg_start, GetPageSizeCached());
       seg_end = RoundUpTo(seg_end, GetPageSizeCached());
       cb((void *)seg_start, seg_end - seg_start);
     }
   }
 }
 #endif
 
-#if defined(__x86_64__) && SANITIZER_LINUX
+#if SANITIZER_LINUX
+#if defined(__x86_64__)
 // We cannot use glibc's clone wrapper, because it messes with the child
 // task's TLS. It writes the PID and TID of the child task to its thread
 // descriptor, but in our case the child task shares the thread descriptor with
 // the parent (because we don't know how to allocate a new thread
 // descriptor to keep glibc happy). So the stock version of clone(), when
 // used with CLONE_VM, would end up corrupting the parent's thread descriptor.
 uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg,
                     int *parent_tidptr, void *newtls, int *child_tidptr) {
#endif
                          "r"(parent_tidptr),
                          "r"(a3),
                          "r"(a4),
                          "i"(__NR_clone),
                          "i"(__NR_exit)
                        : "memory", "$29" );
   return res;
 }
 #elif SANITIZER_RISCV64
 uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg,
                     int *parent_tidptr, void *newtls, int *child_tidptr) {
   if (!fn || !child_stack)
     return -EINVAL;
 
   CHECK_EQ(0, (uptr)child_stack % 16);
 
   register int res __asm__("a0");
#endif
                "r" (__ptidptr),
                "r" (__newtls),
                "r" (__ctidptr),
                "i" (FRAME_SIZE),
                "i" (FRAME_TOC_SAVE_OFFSET)
              : "cr0", "cr1", "memory", "ctr", "r0", "r27", "r28", "r29");
   return res;
 }
-#elif defined(__i386__) && SANITIZER_LINUX
+#elif defined(__i386__)
 uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg,
                     int *parent_tidptr, void *newtls, int *child_tidptr) {
   int res;
   if (!fn || !child_stack)
     return -EINVAL;
   CHECK_EQ(0, (uptr)child_stack % 16);
   child_stack = (char *)child_stack - 7 * sizeof(unsigned int);
   ((unsigned int *)child_stack)[0] = (uptr)flags;
__asm__ __volatile__(
 
                         "test    %%eax,%%eax\n"
                         "jnz    1f\n"
 
                         /* terminate the stack frame */
                         "xorl   %%ebp,%%ebp\n"
                         /* Call FN. */
                         "call    *%%ebx\n"
 #ifdef PIC
                         "call    here\n"
                         "here:\n"
                         "popl    %%ebx\n"
                         "addl    $_GLOBAL_OFFSET_TABLE_+[.-here], %%ebx\n"
 #endif
                         /* Call exit */
                         "movl    %%eax, %%ebx\n"
                         "movl    %2, %%eax\n"
                         "int     $0x80\n"
                         "1:\n"
                        : "=a" (res)
                        : "a"(SYSCALL(clone)), "i"(SYSCALL(exit)),
                          "c"(child_stack),
                          "d"(parent_tidptr),
                          "S"(newtls),
                          "D"(child_tidptr)
                        : "memory");
   return res;
 }
-#elif defined(__arm__) && SANITIZER_LINUX
+#elif defined(__arm__)
 uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg,
                     int *parent_tidptr, void *newtls, int *child_tidptr) {
   unsigned int res;
   if (!fn || !child_stack)
     return -EINVAL;
   child_stack = (char *)child_stack - 2 * sizeof(unsigned int);
   ((unsigned int *)child_stack)[0] = (uptr)fn;
   ((unsigned int *)child_stack)[1] = (uptr)arg;
   register int r0 __asm__("r0") = flags;
   register void *r1 __asm__("r1") = child_stack;
   register int *r2 __asm__("r2") = parent_tidptr;
   register void *r3 __asm__("r3") = newtls;
   register int *r4 __asm__("r4") = child_tidptr;
   register int r7 __asm__("r7") = __NR_clone;
 
 #if __ARM_ARCH > 4 || defined (__ARM_ARCH_4T__)
 # define ARCH_HAS_BX
 #endif
 #if __ARM_ARCH > 4
 # define ARCH_HAS_BLX
 #endif
 
 #ifdef ARCH_HAS_BX
 # ifdef ARCH_HAS_BLX
__asm__ __volatile__(
                        "1:\n"
                        "mov %0, r0\n"
                        : "=r"(res)
                        : "r"(r0), "r"(r1), "r"(r2), "r"(r3), "r"(r4), "r"(r7),
                          "i"(__NR_exit)
                        : "memory");
   return res;
 }
-#endif  // defined(__x86_64__) && SANITIZER_LINUX
+#endif
+#endif  // SANITIZER_LINUX
 
 #if SANITIZER_LINUX
 int internal_uname(struct utsname *buf) {
   return internal_syscall(SYSCALL(uname), buf);
 }
 #endif
 
 #if SANITIZER_ANDROID
 #if __ANDROID_API__ < 21
 extern "C" __attribute__((weak)) int dl_iterate_phdr(
#if defined(__arch64__)
   uptr pc = scontext->sigc_regs.tpc;
 #else
   uptr pc = scontext->si_regs.pc;
 #endif
 #endif
   u32 instr = *(u32 *)pc;
   return (instr >> 21) & 1 ? WRITE: READ;
 #elif defined(__riscv)
+#if SANITIZER_FREEBSD
+  unsigned long pc = ucontext->uc_mcontext.mc_gpregs.gp_sepc;
+#else
   unsigned long pc = ucontext->uc_mcontext.__gregs[REG_PC];
+#endif
   unsigned faulty_instruction = *(uint16_t *)pc;
 
 #if defined(__riscv_compressed)
   if ((faulty_instruction & 0x3) != 0x3) {  // it's a compressed instruction
     // set op_bits to the instruction bits [1, 0, 15, 14, 13]
     unsigned op_bits =
         ((faulty_instruction & 0x3) << 3) | (faulty_instruction >> 13);
     unsigned rd = faulty_instruction & 0xF80;  // bits 7-11, inclusive
     switch (op_bits) {
       case 0b10'010:  // c.lwsp (rd != x0)
 #if __riscv_xlen == 64
       case 0b10'011:  // c.ldsp (rd != x0)
 #endif
         return rd ? SignalContext::READ : SignalContext::UNKNOWN;
       case 0b00'010:  // c.lw
 #if __riscv_flen >= 32 && __riscv_xlen == 32
       case 0b10'011:  // c.flwsp
 #endif
 #if __riscv_flen >= 32 || __riscv_xlen == 64
       case 0b00'011:  // c.flw / c.ld
 #endif
 #if __riscv_flen == 64
       case 0b00'001:  // c.fld
       case 0b10'001:  // c.fldsp
 #endif
         return SignalContext::READ;
       case 0b00'110:  // c.sw
       case 0b10'110:  // c.swsp
 #if __riscv_flen >= 32 || __riscv_xlen == 64
       case 0b00'111:  // c.fsw / c.sd
       case 0b10'111:  // c.fswsp / c.sdsp
 #endif
 #if __riscv_flen == 64
       case 0b00'101:  // c.fsd
       case 0b10'101:  // c.fsdsp
 #endif
         return SignalContext::WRITE;
       default:
         return SignalContext::UNKNOWN;
     }
   }
 #endif
 
   unsigned opcode = faulty_instruction & 0x7f;         // lower 7 bits
   unsigned funct3 = (faulty_instruction >> 12) & 0x7;  // bits 12-14, inclusive
   switch (opcode) {
     case 0b0000011:  // loads
       switch (funct3) {
         case 0b000:  // lb
         case 0b001:  // lh
         case 0b010:  // lw
 #if __riscv_xlen == 64
         case 0b011:  // ld
 #endif
         case 0b100:  // lbu
         case 0b101:  // lhu
           return SignalContext::READ;
         default:
           return SignalContext::UNKNOWN;
       }
     case 0b0100011:  // stores
       switch (funct3) {
         case 0b000:  // sb
         case 0b001:  // sh
         case 0b010:  // sw
 #if __riscv_xlen == 64
         case 0b011:  // sd
 #endif
           return SignalContext::WRITE;
         default:
           return SignalContext::UNKNOWN;
       }
 #if __riscv_flen >= 32
     case 0b0000111:  // floating-point loads
       switch (funct3) {
         case 0b010:  // flw
 #if __riscv_flen == 64
         case 0b011:  // fld
 #endif
           return SignalContext::READ;
         default:
           return SignalContext::UNKNOWN;
       }
     case 0b0100111:  // floating-point stores
       switch (funct3) {
         case 0b010:  // fsw
 #if __riscv_flen == 64
         case 0b011:  // fsd
 #endif
           return SignalContext::WRITE;
         default:
           return SignalContext::UNKNOWN;
       }
 #endif
     default:
       return SignalContext::UNKNOWN;
   }
 #else
   (void)ucontext;
   return UNKNOWN;  // FIXME: Implement.
 #endif
 }
# if defined(__s390x__)
   *pc = ucontext->uc_mcontext.psw.addr;
 # else
   *pc = ucontext->uc_mcontext.psw.addr & 0x7fffffff;
 # endif
   *bp = ucontext->uc_mcontext.gregs[11];
   *sp = ucontext->uc_mcontext.gregs[15];
 #elif defined(__riscv)
   ucontext_t *ucontext = (ucontext_t*)context;
+#if SANITIZER_FREEBSD
+  *pc = ucontext->uc_mcontext.mc_gpregs.gp_sepc;
+  *bp = ucontext->uc_mcontext.mc_gpregs.gp_s[0];
+  *sp = ucontext->uc_mcontext.mc_gpregs.gp_sp;
+#else
   *pc = ucontext->uc_mcontext.__gregs[REG_PC];
   *bp = ucontext->uc_mcontext.__gregs[REG_S0];
   *sp = ucontext->uc_mcontext.__gregs[REG_SP];
+#endif
 #else
 # error "Unsupported arch"
 #endif
 }
 
 void SignalContext::InitPcSpBp() { GetPcSpBp(context, &pc, &sp, &bp); }
 
 void InitializePlatformEarly() {