[tsan] Fix signals and setjmp/longjmp on OS X

[kubamracek]

Summary

1. There's a few wrongly defined things in tsan_interceptors.cc,
2. a typo in tsan_rtl_amd64.S which calls setjmp instead of sigsetjmp in the interceptor, and
3. on OS X, accessing an mprotected page results in a SIGBUS (and not SIGSEGV).

compiler-rt/trunk/lib/tsan/rtl/tsan_interceptors.cc

 #endif
   union {
     sighandler_t sa_handler;
     sigactionhandler_t sa_sigaction;
   };
 #if SANITIZER_FREEBSD
   int sa_flags;
   __sanitizer_sigset_t sa_mask;
+#elif SANITIZER_MAC
+  __sanitizer_sigset_t sa_mask;
+  int sa_flags;
 #else
   __sanitizer_sigset_t sa_mask;
 #ifndef __mips__
   int sa_flags;
 #endif
   void (*sa_restorer)();
 #endif
 };
 
 const sighandler_t SIG_DFL = (sighandler_t)0;
 const sighandler_t SIG_IGN = (sighandler_t)1;
 const sighandler_t SIG_ERR = (sighandler_t)-1;
-#if SANITIZER_FREEBSD
+#if SANITIZER_FREEBSD || SANITIZER_MAC
 const int SA_SIGINFO = 0x40;
 const int SIG_SETMASK = 3;
 #elif defined(__mips__)
 const int SA_SIGINFO = 8;
 const int SIG_SETMASK = 3;
 #else
 const int SA_SIGINFO = 4;
 const int SIG_SETMASK = 2;
TSAN_INTERCEPTOR(int, sigaction, int sig, sigaction_t *act, sigaction_t *old) {
   // Can't use internal_memcpy, because it copies byte-by-byte,
   // and signal handler reads the sa_handler concurrently. It it can read
   // some bytes from old value and some bytes from new value.
   // Use volatile to prevent insertion of memcpy.
   sigactions[sig].sa_handler = *(volatile sighandler_t*)&act->sa_handler;
   sigactions[sig].sa_flags = *(volatile int*)&act->sa_flags;
   internal_memcpy(&sigactions[sig].sa_mask, &act->sa_mask,
       sizeof(sigactions[sig].sa_mask));
-#if !SANITIZER_FREEBSD
+#if !SANITIZER_FREEBSD && !SANITIZER_MAC
   sigactions[sig].sa_restorer = act->sa_restorer;
 #endif
   sigaction_t newact;
   internal_memcpy(&newact, act, sizeof(newact));
   REAL(sigfillset)(&newact.sa_mask);
   if (act->sa_handler != SIG_IGN && act->sa_handler != SIG_DFL) {
     if (newact.sa_flags & SA_SIGINFO)
       newact.sa_sigaction = rtl_sigaction;

compiler-rt/trunk/lib/tsan/rtl/tsan_rtl_amd64.S

#endif
   CFI_ADJUST_CFA_OFFSET(-8)
   CFI_RESTORE(%rdi)
   // tail jump to libc sigsetjmp
   movl $0, %eax
 #if !defined(__APPLE__)
   movq _ZN14__interception14real_sigsetjmpE@GOTPCREL(%rip), %rdx
   jmp *(%rdx)
 #else
-  jmp ASM_TSAN_SYMBOL(setjmp)
+  jmp ASM_TSAN_SYMBOL(sigsetjmp)
 #endif
   CFI_ENDPROC
 ASM_SIZE(ASM_TSAN_SYMBOL_INTERCEPTOR(sigsetjmp))
 
 #if !defined(__APPLE__)
 .comm _ZN14__interception16real___sigsetjmpE,8,8
 .globl ASM_TSAN_SYMBOL_INTERCEPTOR(__sigsetjmp)
 ASM_TYPE_FUNCTION(ASM_TSAN_SYMBOL_INTERCEPTOR(__sigsetjmp))

compiler-rt/trunk/test/tsan/signal_longjmp.cc

 // RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
 
 // Test case for longjumping out of signal handler:
 // https://code.google.com/p/thread-sanitizer/issues/detail?id=75
 
 // Longjmp assembly has not been implemented for mips64 yet
 // XFAIL: mips64
 
 #include <setjmp.h>
 #include <signal.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <sys/mman.h>
 
+#ifdef __APPLE__
+#define SIGNAL_TO_HANDLE SIGBUS
+#else
+#define SIGNAL_TO_HANDLE SIGSEGV
+#endif
+
 sigjmp_buf fault_jmp;
 volatile int fault_expected;
 
 void sigfault_handler(int sig) {
   if (!fault_expected)
     abort();
 
   /* just return from sighandler to proper place */
int main() {
   struct sigaction act;
   act.sa_handler  = sigfault_handler;
   act.sa_flags    = 0;
   if (sigemptyset(&act.sa_mask)) {
     perror("sigemptyset");
     exit(1);
   }
 
-  if (sigaction(SIGSEGV, &act, NULL)) {
+  if (sigaction(SIGNAL_TO_HANDLE, &act, NULL)) {
     perror("sigaction");
     exit(1);
   }
 
   void *mem = mmap(0, 4096, PROT_NONE, MAP_PRIVATE | MAP_ANON,
       -1, 0);
 
   MUST_FAULT(((volatile int *volatile)mem)[0] = 0);