[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

1344

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?

1907

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

1907

... 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

1344

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

1344

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

1907

... 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

1907

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
#endif
                          "r"(parent_tidptr),
                          "r"(a3),
                          "r"(a4),
                          "i"(__NR_clone),
                          "i"(__NR_exit)
                        : "memory", "$29" );
   return res;
 }
-#elif SANITIZER_RISCV64
+#elif SANITIZER_RISCV64 && SANITIZER_LINUX
 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");
__asm__ __volatile__(
       "1:\n"
 
       : "=r"(res)
       : "0"(__flags), "r"(__stack), "r"(__ptid), "r"(__tls), "r"(__ctid),
         "r"(__fn), "r"(__arg), "r"(nr_clone), "i"(__NR_exit)
       : "memory");
   return res;
 }
 #elif defined(__aarch64__)
 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;
__asm__ __volatile__(
                        : "=r" (res)
                        : "i"(-EINVAL),
                          "r"(__fn), "r"(__stack), "r"(__flags), "r"(__arg),
                          "r"(__ptid), "r"(__tls), "r"(__ctid),
                          "i"(__NR_clone), "i"(__NR_exit)
                        : "x30", "memory");
   return res;
 }
 #elif defined(__powerpc64__)
 uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg,
                    int *parent_tidptr, void *newtls, int *child_tidptr) {
   long long res;
 // Stack frame structure.
 #if SANITIZER_PPC64V1
 //   Back chain == 0        (SP + 112)
 // Frame (112 bytes):
 //   Parameter save area    (SP + 48), 8 doublewords
 //   TOC save area          (SP + 40)
 //   Link editor doubleword (SP + 32)
 //   Compiler doubleword    (SP + 24)
 //   LR save area           (SP + 16)
 //   CR save area           (SP + 8)
 //   Back chain             (SP + 0)
 # define FRAME_SIZE 112
 # define FRAME_TOC_SAVE_OFFSET 40
 #elif SANITIZER_PPC64V2
 //   Back chain == 0        (SP + 32)
 // Frame (32 bytes):
 //   TOC save area          (SP + 24)
 //   LR save area           (SP + 16)
 //   CR save area           (SP + 8)
 //   Back chain             (SP + 0)
 # define FRAME_SIZE 32
 # define FRAME_TOC_SAVE_OFFSET 24
 #else
 # error "Unsupported PPC64 ABI"
 #endif
   if (!fn || !child_stack)
     return -EINVAL;
   CHECK_EQ(0, (uptr)child_stack % 16);
 
__asm__ __volatile__(
            "bne-   cr1, 1f\n\t"
 
            /* Set up stack frame */
            "li    29, 0\n\t"
            "stdu  29, -8(1)\n\t"
            "stdu  1, -%12(1)\n\t"
            /* Do the function call */
            "std   2, %13(1)\n\t"
 #if SANITIZER_PPC64V1
            "ld    0, 0(28)\n\t"
            "ld    2, 8(28)\n\t"
            "mtctr 0\n\t"
 #elif SANITIZER_PPC64V2
            "mr    12, 28\n\t"
            "mtctr 12\n\t"
 #else
 # error "Unsupported PPC64 ABI"
 #endif
            "mr    3, 27\n\t"
            "bctrl\n\t"
            "ld    2, %13(1)\n\t"
 
            /* Call _exit(r3) */
            "li 0, %4\n\t"
#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
 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
 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
 
 #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() {