[compile-rt] Reduce #ifdef noise for ptrauth

[yln]

Summary

Create a sanitizer_ptrauth.h header that #includes <ptrauth> when
available and defines just the required macros as "no ops"
otherwise. This should avoid the need for excessive #ifdef'ing.

Follow-up to and discussed in: https://reviews.llvm.org/D79132

[delcypher]

@yln I did a quick investigation to see if we could do this without macros. Unfortunately this turns out to be really tricky. Below is a rough sketch that almost works. Due to the way the ptrauth calls are implemented Clang enforces that the key and string passed to ptrauth_string_discriminator be literals.
For the key we can use templates to make this work but the string literal proves to be difficult because string literals aren't allowed as template arguments.

#if __has_feature(ptrauth_calls)
#include <ptrauth.h>
#endif

namespace __sanitizer {

struct ptrauth {
  template <int key, typename T>
  static __attribute__((always_inline)) T *strip(T *ptr) {
#if __has_feature(ptrauth_calls)
    return ptrauth_strip(ptr, key);
#else
    return ptr;
#endif
  }

  template <int key, typename T, typename ExtraDataTy>
  static __attribute__((always_inline)) T *auth_data(T *ptr,
                                                     ExtraDataTy extra_data) {
#if __has_feature(ptrauth_calls)
    return ptrauth_auth_data(ptr, key, extra_data);
#else
    return ptr;
#endif
  }

  // FIXME: C++ doesn't allow string literals as template arguments.
  template <const char* const str>
  static __attribute__((always_inline)) size_t
  string_discrminator() {
#if __has_feature(ptrauth_calls)
    return ptrauth_string_discriminator(str);
#else
    return 0;
#endif
  }
};
} // namespace __sanitizer

int main(int argc, char **argv) {
  int a;
  int *a_ptr = &a; 
  char **v = __sanitizer::ptrauth::strip<0>(argv);
  int *a_ptr_cpy = __sanitizer::ptrauth::auth_data<0>(a_ptr, 0); 
  size_t x = __sanitizer::ptrauth::string_discrminator<"foo">(); // FIXME: Doesn't work.
  return 0;
}

Unless you see a way around the string literal problem I think we might have to go with the current patch that uses macros which pains me.

compiler-rt/lib/sanitizer_common/sanitizer_ptrauth.h

19

This also goes against our coding convention of having macros be upper case. Unfortunately I don't see a good way around this.

[yln]

I think we should mirror what <ptrauth.h> does. I just copied the "nop macros" from the end of the header for the APIs we use.

[delcypher]

In D79540#2027555, @yln wrote:

I think we should mirror what <ptrauth.h> does. I just copied the "nop macros" from the end of the header for the APIs we use.

Okay let's do that for now.

compiler-rt/lib/sanitizer_common/CMakeLists.txt

set(SANITIZER_IMPL_HEADERS
   sanitizer_platform.h
   sanitizer_platform_interceptors.h
   sanitizer_platform_limits_netbsd.h
   sanitizer_platform_limits_openbsd.h
   sanitizer_platform_limits_posix.h
   sanitizer_platform_limits_solaris.h
   sanitizer_posix.h
   sanitizer_procmaps.h
+  sanitizer_ptrauth.h
   sanitizer_quarantine.h
   sanitizer_report_decorator.h
   sanitizer_ring_buffer.h
   sanitizer_rtems.h
   sanitizer_signal_interceptors.inc
   sanitizer_stackdepot.h
   sanitizer_stackdepotbase.h
   sanitizer_stacktrace.h

compiler-rt/lib/sanitizer_common/sanitizer_mac.cpp

 #include "sanitizer_common.h"
 #include "sanitizer_file.h"
 #include "sanitizer_flags.h"
 #include "sanitizer_internal_defs.h"
 #include "sanitizer_libc.h"
 #include "sanitizer_placement_new.h"
 #include "sanitizer_platform_limits_posix.h"
 #include "sanitizer_procmaps.h"
+#include "sanitizer_ptrauth.h"
 
 #if !SANITIZER_IOS
 #include <crt_externs.h>  // for _NSGetEnviron
 #else
 extern char **environ;
 #endif
 
 #if defined(__has_include) && __has_include(<os/trace.h>)

 }
 
 bool SignalContext::IsTrueFaultingAddress() const {
   auto si = static_cast<const siginfo_t *>(siginfo);
   // "Real" SIGSEGV codes (e.g., SEGV_MAPERR, SEGV_MAPERR) are non-zero.
   return si->si_signo == SIGSEGV && si->si_code != 0;
 }
 
-#if __has_feature(ptrauth_calls)
-# include <ptrauth.h>
-#else
-# define ptrauth_strip(value, key) (value)
-#endif
-
 #if defined(__aarch64__) && defined(arm_thread_state64_get_sp)
   #define AARCH64_GET_REG(r) \
     (uptr)ptrauth_strip(     \
         (void *)arm_thread_state64_get_##r(ucontext->uc_mcontext->__ss), 0)
 #else
   #define AARCH64_GET_REG(r) ucontext->uc_mcontext->__ss.__##r
 #endif
 

compiler-rt/lib/sanitizer_common/sanitizer_ptrauth.h

+//===-- sanitizer_ptrauth.h -------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SANITIZER_PTRAUTH_H
+#define SANITIZER_PTRAUTH_H
+
+#if __has_feature(ptrauth_calls)
+#include <ptrauth.h>
+#else
+// Copied from <ptrauth.h>
+#define ptrauth_strip(__value, __key) __value
+#define ptrauth_auth_data(__value, __old_key, __old_data) __value
+#define ptrauth_string_discriminator(__string) ((int)0)
+#endif
+
+#endif // SANITIZER_PTRAUTH_H

compiler-rt/lib/tsan/rtl/tsan_platform_mac.cpp

 #include "sanitizer_common/sanitizer_platform.h"
 #if SANITIZER_MAC
 
 #include "sanitizer_common/sanitizer_atomic.h"
 #include "sanitizer_common/sanitizer_common.h"
 #include "sanitizer_common/sanitizer_libc.h"
 #include "sanitizer_common/sanitizer_posix.h"
 #include "sanitizer_common/sanitizer_procmaps.h"
+#include "sanitizer_common/sanitizer_ptrauth.h"
 #include "sanitizer_common/sanitizer_stackdepot.h"
 #include "tsan_platform.h"
 #include "tsan_rtl.h"
 #include "tsan_flags.h"
 
 #include <mach/mach.h>
 #include <pthread.h>
 #include <signal.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdarg.h>
 #include <sys/mman.h>
 #include <sys/syscall.h>
 #include <sys/time.h>
 #include <sys/types.h>
 #include <sys/resource.h>
 #include <sys/stat.h>
 #include <unistd.h>
 #include <errno.h>
 #include <sched.h>
 
-#if __has_feature(ptrauth_calls)
-#include <ptrauth.h>
-#endif
-
 namespace __tsan {
 
 #if !SANITIZER_GO
 static void *SignalSafeGetOrAllocate(uptr *dst, uptr size) {
   atomic_uintptr_t *a = (atomic_uintptr_t *)dst;
   void *val = (void *)atomic_load_relaxed(a);
   atomic_signal_fence(memory_order_acquire);  // Turns the previous load into
                                               // acquire wrt signals.
# define LONG_JMP_SP_ENV_SLOT \
     ((GetMacosVersion() >= MACOS_VERSION_MOJAVE) ? 12 : 13)
 #else
 # define LONG_JMP_SP_ENV_SLOT 2
 #endif
 
 uptr ExtractLongJmpSp(uptr *env) {
   uptr mangled_sp = env[LONG_JMP_SP_ENV_SLOT];
   uptr sp = mangled_sp ^ longjmp_xor_key;
-#if __has_feature(ptrauth_calls)
   sp = (uptr)ptrauth_auth_data((void *)sp, ptrauth_key_asdb,
                                ptrauth_string_discriminator("sp"));
-#endif
   return sp;
 }
 
 #if !SANITIZER_GO
 void ImitateTlsWrite(ThreadState *thr, uptr tls_addr, uptr tls_size) {
   // The pointer to the ThreadState object is stored in the shadow memory
   // of the tls.
   uptr tls_end = tls_addr + tls_size;

compiler-rt/lib/ubsan/ubsan_type_hash_itanium.cpp

 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_common/sanitizer_platform.h"
 #include "ubsan_platform.h"
 #if CAN_SANITIZE_UB && !SANITIZER_WINDOWS
 #include "ubsan_type_hash.h"
 
 #include "sanitizer_common/sanitizer_common.h"
-
-#if __has_feature(ptrauth_calls)
-#include <ptrauth.h>
-#endif
+#include "sanitizer_common/sanitizer_ptrauth.h"
 
 // The following are intended to be binary compatible with the definitions
 // given in the Itanium ABI. We make no attempt to be ODR-compatible with
 // those definitions, since existing ABI implementations aren't.
 
 namespace std {
   class type_info {
   public:
struct VtablePrefix {
   /// The offset from the vptr to the start of the most-derived object.
   /// This will only be greater than zero in some virtual base class vtables
   /// used during object con-/destruction, and will usually be exactly zero.
   sptr Offset;
   /// The type_info object describing the most-derived class type.
   std::type_info *TypeInfo;
 };
 VtablePrefix *getVtablePrefix(void *Vtable) {
-#if __has_feature(ptrauth_calls)
   Vtable = ptrauth_auth_data(Vtable, ptrauth_key_cxx_vtable_pointer, 0);
-#endif
   VtablePrefix *Vptr = reinterpret_cast<VtablePrefix*>(Vtable);
   VtablePrefix *Prefix = Vptr - 1;
   if (!IsAccessibleMemoryRange((uptr)Prefix, sizeof(VtablePrefix)))
     return nullptr;
   if (!Prefix->TypeInfo)
     // This can't possibly be a valid vtable.
     return nullptr;
   return Prefix;