[TSan] Improve handling of stack pointer mangling in {set,long}jmp, pt.9

[yln]

Summary

Remove now-obsolete InitializeGuardPtr from assembly code. This is
the final commit of this refactoring.

[yln]

Landed these cleanup changes in smaller chunks on my own.

compiler-rt/lib/tsan/rtl/tsan_platform_linux.cc

 # undef sa_sigaction
 #endif
 
 #if SANITIZER_FREEBSD
 extern "C" void *__libc_stack_end;
 void *__libc_stack_end = 0;
 #endif
 
-#if SANITIZER_LINUX && defined(__aarch64__)
-__tsan::uptr InitializeGuardPtr() __attribute__((visibility("hidden")));
-extern "C" __tsan::uptr _tsan_pointer_chk_guard;
-#endif
-
 namespace __tsan {
 
 #if SANITIZER_LINUX && defined(__aarch64__) && !SANITIZER_GO
 static void InitializeLongjmpXorKey();
 static uptr longjmp_xor_key;
 #endif
 
 #ifdef TSAN_RUNTIME_VMA
#if SANITIZER_LINUX && defined(__aarch64__)
     int old_personality = personality(0xffffffff);
     if (old_personality != -1 && (old_personality & ADDR_NO_RANDOMIZE) == 0) {
       VReport(1, "WARNING: Program is run with randomized virtual address "
               "space, which wouldn't work with ThreadSanitizer.\n"
               "Re-execing with fixed virtual address space.\n");
       CHECK_NE(personality(old_personality | ADDR_NO_RANDOMIZE), -1);
       reexec = true;
     }
-    // Initialize the guard pointer used in {sig}{set,long}jump.
-    longjmp_xor_key = InitializeGuardPtr();
-    uptr old_value = longjmp_xor_key;
+    // Initialize the xor key used in {sig}{set,long}jump.
     InitializeLongjmpXorKey();
-    CHECK_EQ(longjmp_xor_key, old_value);
-    // If the above check fails for you, please contact me ([e-mail])
-    // and let me know the values of the two differing keys.  Please also set a
-    // breakpoint on `InitializeGuardPtr` and `InitializeLongjmpXorKey` and tell
-    // me the stack pointer (SP) values that go into the XOR operation (where we
-    // derive the key):
-    //
-    //   InitializeLongjmpXorKey:
-    //     uptr sp = (uptr)__builtin_frame_address(0);
-    //
-    //   InitializeGuardPtr (in tsan_rtl_aarch64.S):
-    //       mov  x0, sp
-    //       ...
-    //       eor  x0, x0, x1
-    //
-    // Then feel free to comment out the call to `InitializeLongjmpXorKey`.
 #endif
     if (reexec)
       ReExec();
   }
 
   CheckAndProtect();
   InitTlsSize();
 #endif  // !SANITIZER_GO
for (; cmsg; cmsg = CMSG_NXTHDR(msg, cmsg)) {
     }
   }
   return res;
 }
 
 // Reverse operation of libc stack pointer mangling
 static uptr UnmangleLongJmpSp(uptr mangled_sp) {
 #if defined(__x86_64__)
-# if SANITIZER_FREEBSD || SANITIZER_NETBSD
-  return mangled_sp;
-# else  // Linux
+# if SANITIZER_LINUX
   // Reverse of:
   //   xor  %fs:0x30, %rsi
   //   rol  $0x11, %rsi
   uptr sp;
   asm("ror  $0x11,     %0 \n"
       "xor  %%fs:0x30, %0 \n"
       : "=r" (sp)
       : "0" (mangled_sp));
   return sp;
+# else
+  return mangled_sp;
 # endif
 #elif defined(__aarch64__)
 # if SANITIZER_LINUX
   return mangled_sp ^ longjmp_xor_key;
 # else
   return mangled_sp;
 # endif
 #elif defined(__powerpc64__)

compiler-rt/lib/tsan/rtl/tsan_rtl_aarch64.S

 // The content of this file is AArch64-only:
 #if defined(__aarch64__)
 
 #include "sanitizer_common/sanitizer_asm.h"
 
-#if !defined(__APPLE__)
-.section .bss
-.type __tsan_pointer_chk_guard, %object
-ASM_SIZE(ASM_SYMBOL_INTERCEPTOR(__tsan_pointer_chk_guard))
-__tsan_pointer_chk_guard:
-.zero 8
-#endif
-
 #if defined(__APPLE__)
 .align  2
 
 .section  __DATA,__nl_symbol_ptr,non_lazy_symbol_pointers
 .long _setjmp$non_lazy_ptr
 _setjmp$non_lazy_ptr:
 .indirect_symbol _setjmp
 .long 0

 
 #if !defined(__APPLE__)
 .section .text
 #else
 .section __TEXT,__text
 .align 3
 #endif
 
-#if !defined(__APPLE__)
-// GLIBC mangles the function pointers in jmp_buf (used in {set,long}*jmp
-// functions) by XORing them with a random guard pointer.  For AArch64 it is a
-// global variable rather than a TCB one (as for x86_64/powerpc) and althought
-// its value is exported by the loader, it lies within a private GLIBC
-// namespace (meaning it should be only used by GLIBC itself and the ABI is
-// not stable). So InitializeGuardPtr obtains the pointer guard value by
-// issuing a setjmp and checking the resulting pointers values against the
-// original ones.
-ASM_HIDDEN(_Z18InitializeGuardPtrv)
-.global _Z18InitializeGuardPtrv
-ASM_TYPE_FUNCTION(ASM_SYMBOL_INTERCEPTOR(_Z18InitializeGuardPtrv))
-_Z18InitializeGuardPtrv:
-  CFI_STARTPROC
-  // Allocates a jmp_buf for the setjmp call.
-  stp  x29, x30, [sp, -336]!
-  CFI_DEF_CFA_OFFSET (336)
-  CFI_OFFSET (29, -336)
-  CFI_OFFSET (30, -328)
-  add x29, sp, 0
-  CFI_DEF_CFA_REGISTER (29)
-  add x0, x29, 24
-
-  // Call libc setjmp that mangle the stack pointer value
-  adrp  x1, :got:_ZN14__interception12real__setjmpE
-  ldr   x1, [x1, #:got_lo12:_ZN14__interception12real__setjmpE]
-  ldr   x1, [x1]
-  blr   x1
-
-  // glibc setjmp mangles both the frame pointer (FP, pc+4 on blr) and the
-  // stack pointer (SP). FP will be placed on ((uintptr*)jmp_buf)[11] and
-  // SP at ((uintptr*)jmp_buf)[13].
-  // The mangle operation is just 'value' xor 'pointer guard value' and
-  // if we know the original value (SP) and the expected one, we can derive
-  // the guard pointer value.
-  mov x0, sp
-
-  // Loads the mangled SP pointer.
-  ldr x1, [x29, 128]
-  eor x0, x0, x1
-  adrp  x2, __tsan_pointer_chk_guard
-  str x0, [x2, #:lo12:__tsan_pointer_chk_guard]
-  ldp x29, x30, [sp], 336
-  CFI_RESTORE (30)
-  CFI_RESTORE (19)
-  CFI_DEF_CFA (31, 0)
-  ret
-  CFI_ENDPROC
-ASM_SIZE(ASM_SYMBOL_INTERCEPTOR(_Z18InitializeGuardPtrv))
-#endif
-
 ASM_HIDDEN(__tsan_setjmp)
 .comm _ZN14__interception11real_setjmpE,8,8
 .globl ASM_SYMBOL_INTERCEPTOR(setjmp)
 ASM_TYPE_FUNCTION(ASM_SYMBOL_INTERCEPTOR(setjmp))
 ASM_SYMBOL_INTERCEPTOR(setjmp):
   CFI_STARTPROC
 
   // save env parameters for function call