[compiler-rt] Simplify ALIAS() attribute macro

[melver]

Summary

Most uses of ALIAS() are in conjunction with WRAPPER_NAME().

Simplify the code and just make ALIAS() turn its argument into a string
(similar to Linux kernel's __alias macro). This in turn allows removing
WRAPPER_NAME().

NFC.

compiler-rt/lib/asan/asan_interceptors.cpp

INTERCEPTOR(_Unwind_Reason_Code, _Unwind_SjLj_RaiseException,
   __asan_handle_no_return();
   return REAL(_Unwind_SjLj_RaiseException)(object);
 }
 #endif
 
 #if ASAN_INTERCEPT_INDEX
 # if ASAN_USE_ALIAS_ATTRIBUTE_FOR_INDEX
 INTERCEPTOR(char*, index, const char *string, int c)
-  ALIAS(WRAPPER_NAME(strchr));
+  ALIAS(WRAP(strchr));
 # else
 #  if SANITIZER_APPLE
 DECLARE_REAL(char*, index, const char *string, int c)
 OVERRIDE_FUNCTION(index, strchr);
 #  else
 DEFINE_REAL(char*, index, const char *string, int c)
 #  endif
 # endif

compiler-rt/lib/hwasan/hwasan_allocation_functions.cpp

 
 }  // extern "C"
 
 #if HWASAN_WITH_INTERCEPTORS || SANITIZER_FUCHSIA
 #if SANITIZER_FUCHSIA
 // Fuchsia does not use WRAP/wrappers used for the interceptor infrastructure.
 #  define INTERCEPTOR_ALIAS(RET, FN, ARGS...)                                 \
     extern "C" SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE RET FN( \
-        ARGS) ALIAS("__sanitizer_" #FN)
+        ARGS) ALIAS(__sanitizer_##FN)
 #else
 #  define INTERCEPTOR_ALIAS(RET, FN, ARGS...)                                 \
     extern "C" SANITIZER_INTERFACE_ATTRIBUTE RET WRAP(FN)(ARGS)               \
-        ALIAS("__sanitizer_" #FN);                                            \
+        ALIAS(__sanitizer_##FN);                                              \
     extern "C" SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE RET FN( \
-        ARGS) ALIAS("__sanitizer_" #FN)
+        ARGS) ALIAS(__sanitizer_##FN)
 #endif
 
 INTERCEPTOR_ALIAS(int, posix_memalign, void **memptr, SIZE_T alignment,
                   SIZE_T size);
 INTERCEPTOR_ALIAS(void *, aligned_alloc, SIZE_T alignment, SIZE_T size);
 INTERCEPTOR_ALIAS(void *, __libc_memalign, SIZE_T alignment, SIZE_T size);
 INTERCEPTOR_ALIAS(void *, valloc, SIZE_T size);
 INTERCEPTOR_ALIAS(void, free, void *ptr);

compiler-rt/lib/interception/interception.h

 #define INTERPOSER_2(func_name, wrapper_name) __attribute__((used)) \
 const interpose_substitution substitution_##func_name[] \
     __attribute__((section("__DATA, __interpose"))) = { \
     { reinterpret_cast<const uptr>(wrapper_name), \
       reinterpret_cast<const uptr>(func_name) } \
 }
 
 # define WRAP(x) wrap_##x
-# define WRAPPER_NAME(x) "wrap_"#x
 # define INTERCEPTOR_ATTRIBUTE
 # define DECLARE_WRAPPER(ret_type, func, ...)
 
 #elif SANITIZER_WINDOWS
 # define WRAP(x) __asan_wrap_##x
-# define WRAPPER_NAME(x) "__asan_wrap_"#x
 # define INTERCEPTOR_ATTRIBUTE __declspec(dllexport)
 # define DECLARE_WRAPPER(ret_type, func, ...) \
     extern "C" ret_type func(__VA_ARGS__);
 # define DECLARE_WRAPPER_WINAPI(ret_type, func, ...) \
     extern "C" __declspec(dllimport) ret_type __stdcall func(__VA_ARGS__);
 #elif SANITIZER_FREEBSD || SANITIZER_NETBSD
 # define WRAP(x) __interceptor_ ## x
-# define WRAPPER_NAME(x) "__interceptor_" #x
 # define INTERCEPTOR_ATTRIBUTE __attribute__((visibility("default")))
 // FreeBSD's dynamic linker (incompliantly) gives non-weak symbols higher
 // priority than weak ones so weak aliases won't work for indirect calls
 // in position-independent (-fPIC / -fPIE) mode.
 # define DECLARE_WRAPPER(ret_type, func, ...) \
      extern "C" ret_type func(__VA_ARGS__) \
      __attribute__((alias("__interceptor_" #func), visibility("default")));
 #elif !SANITIZER_FUCHSIA
 # define WRAP(x) __interceptor_ ## x
-# define WRAPPER_NAME(x) "__interceptor_" #x
 # define INTERCEPTOR_ATTRIBUTE __attribute__((visibility("default")))
 # define DECLARE_WRAPPER(ret_type, func, ...) \
     extern "C" ret_type func(__VA_ARGS__) \
     __attribute__((weak, alias("__interceptor_" #func), visibility("default")));
 #endif
 
 #if SANITIZER_FUCHSIA
 // There is no general interception at all on Fuchsia.

compiler-rt/lib/lsan/lsan_interceptors.cpp

INTERCEPTOR(void*, pvalloc, uptr size) {
   return lsan_pvalloc(size, stack);
 }
 #define LSAN_MAYBE_INTERCEPT_PVALLOC INTERCEPT_FUNCTION(pvalloc)
 #else
 #define LSAN_MAYBE_INTERCEPT_PVALLOC
 #endif // SANITIZER_INTERCEPT_PVALLOC
 
 #if SANITIZER_INTERCEPT_CFREE
-INTERCEPTOR(void, cfree, void *p) ALIAS(WRAPPER_NAME(free));
+INTERCEPTOR(void, cfree, void *p) ALIAS(WRAP(free));
 #define LSAN_MAYBE_INTERCEPT_CFREE INTERCEPT_FUNCTION(cfree)
 #else
 #define LSAN_MAYBE_INTERCEPT_CFREE
 #endif // SANITIZER_INTERCEPT_CFREE
 
 #if SANITIZER_INTERCEPT_MCHECK_MPROBE
 INTERCEPTOR(int, mcheck, void (*abortfunc)(int mstatus)) {
   return 0;

compiler-rt/lib/memprof/memprof_interceptors.cpp

 
 INTERCEPTOR(int, pthread_join, void *t, void **arg) {
   return real_pthread_join(t, arg);
 }
 
 DEFINE_REAL_PTHREAD_FUNCTIONS
 
 INTERCEPTOR(char *, index, const char *string, int c)
-ALIAS(WRAPPER_NAME(strchr));
+ALIAS(WRAP(strchr));
 
 // For both strcat() and strncat() we need to check the validity of |to|
 // argument irrespective of the |from| length.
 INTERCEPTOR(char *, strcat, char *to, const char *from) {
   void *ctx;
   MEMPROF_INTERCEPTOR_ENTER(ctx, strcat);
   ENSURE_MEMPROF_INITED();
   uptr from_length = internal_strlen(from);

compiler-rt/lib/msan/msan_interceptors.cpp

INTERCEPTOR(int, pthread_key_create, __sanitizer_pthread_key_t *key,
   if (!res && key)
     __msan_unpoison(key, sizeof(*key));
   return res;
 }
 
 #if SANITIZER_NETBSD
 INTERCEPTOR(int, __libc_thr_keycreate, __sanitizer_pthread_key_t *m,
             void (*dtor)(void *value))
-ALIAS(WRAPPER_NAME(pthread_key_create));
+ALIAS(WRAP(pthread_key_create));
 #endif
 
 INTERCEPTOR(int, pthread_join, void *thread, void **retval) {
   ENSURE_MSAN_INITED();
   int res = REAL(pthread_join)(thread, retval);
   if (!res && retval)
     __msan_unpoison(retval, sizeof(*retval));
   return res;

compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors.inc

 }
 #define INIT__EXIT COMMON_INTERCEPT_FUNCTION(_exit);
 #else
 #define INIT__EXIT
 #endif
 
 #if SANITIZER_INTERCEPT___LIBC_MUTEX
 INTERCEPTOR(int, __libc_thr_setcancelstate, int state, int *oldstate)
-ALIAS(WRAPPER_NAME(pthread_setcancelstate));
+ALIAS(WRAP(pthread_setcancelstate));
 
 #define INIT___LIBC_THR_SETCANCELSTATE \
   COMMON_INTERCEPT_FUNCTION(__libc_thr_setcancelstate)
 #else
 #define INIT___LIBC_THR_SETCANCELSTATE
 #endif
 
 #if SANITIZER_INTERCEPT_GETMNTENT || SANITIZER_INTERCEPT_GETMNTENT_R

compiler-rt/lib/sanitizer_common/sanitizer_internal_defs.h

 # define NORETURN __declspec(noreturn)
 # define THREADLOCAL   __declspec(thread)
 # define LIKELY(x) (x)
 # define UNLIKELY(x) (x)
 # define PREFETCH(x) /* _mm_prefetch(x, _MM_HINT_NTA) */ (void)0
 # define WARN_UNUSED_RESULT
 #else  // _MSC_VER
 # define ALWAYS_INLINE inline __attribute__((always_inline))
-# define ALIAS(x) __attribute__((alias(x)))
+# define ALIAS(x) __attribute__((alias(SANITIZER_STRINGIFY(x))))
 // Please only use the ALIGNED macro before the type.
 // Using ALIGNED after the variable declaration is not portable!
 # define ALIGNED(x) __attribute__((aligned(x)))
 # define FORMAT(f, a)  __attribute__((format(printf, f, a)))
 # define NOINLINE __attribute__((noinline))
 # define NORETURN  __attribute__((noreturn))
 # define THREADLOCAL   __thread
 # define LIKELY(x)     __builtin_expect(!!(x), 1)

compiler-rt/lib/sanitizer_common/sanitizer_win_dll_thunk.h

 // We can't define our own version of strlen etc. because that would lead to
 // link-time or even type mismatch errors.  Instead, we can declare a function
 // just to be able to get its address.  Me may miss the first few calls to the
 // functions since it can be called before __dll_thunk_init, but that would lead
 // to false negatives in the startup code before user's global initializers,
 // which isn't a big deal.
 #define INTERCEPT_LIBRARY_FUNCTION(name)                                       \
   extern "C" void name();                                                      \
-  INTERCEPT_OR_DIE(WRAPPER_NAME(name), name)
+  INTERCEPT_OR_DIE(STRINGIFY(WRAP(name)), name)
 
 // Use these macros for functions that could be called before __dll_thunk_init()
 // is executed and don't lead to errors if defined (free, malloc, etc).
 #define INTERCEPT_WRAP_V_V(name)                                               \
   extern "C" void name() {                                                     \
     typedef decltype(name) *fntype;                                            \
     static fntype fn = (fntype)__sanitizer::dllThunkGetRealAddrOrDie(#name);   \
     fn();                                                                      \

compiler-rt/lib/sanitizer_common/tests/sanitizer_allocator_testlib.cpp

void *valloc(size_t size) {
   if (size == 0)
     size = GetPageSizeCached();
   void *p = allocator.Allocate(&cache, size, GetPageSizeCached());
   SANITIZER_MALLOC_HOOK(p, size);
   return p;
 }
 
 #if SANITIZER_INTERCEPT_CFREE
-void cfree(void *p) ALIAS("free");
+void cfree(void *p) ALIAS(free);
 #endif // SANITIZER_INTERCEPT_CFREE
 #if SANITIZER_INTERCEPT_PVALLOC
-void *pvalloc(size_t size) ALIAS("valloc");
+void *pvalloc(size_t size) ALIAS(valloc);
 #endif // SANITIZER_INTERCEPT_PVALLOC
 #if SANITIZER_INTERCEPT_MEMALIGN
-void *__libc_memalign(size_t alignment, size_t size) ALIAS("memalign");
+void *__libc_memalign(size_t alignment, size_t size) ALIAS(memalign);
 #endif // SANITIZER_INTERCEPT_MEMALIGN
 
 void malloc_usable_size() {
 }
 
 #if SANITIZER_INTERCEPT_MALLOPT_AND_MALLINFO
 void mallinfo() {
 }
 
 void mallopt() {
 }
 #endif // SANITIZER_INTERCEPT_MALLOPT_AND_MALLINFO
 }  // extern "C"
 
 namespace std {
   struct nothrow_t;
 }
 
-void *operator new(size_t size) ALIAS("malloc");
-void *operator new[](size_t size) ALIAS("malloc");
-void *operator new(size_t size, std::nothrow_t const&) ALIAS("malloc");
-void *operator new[](size_t size, std::nothrow_t const&) ALIAS("malloc");
-void operator delete(void *ptr) throw() ALIAS("free");
-void operator delete[](void *ptr) throw() ALIAS("free");
-void operator delete(void *ptr, std::nothrow_t const&) ALIAS("free");
-void operator delete[](void *ptr, std::nothrow_t const&) ALIAS("free");
+void *operator new(size_t size) ALIAS(malloc);
+void *operator new[](size_t size) ALIAS(malloc);
+void *operator new(size_t size, std::nothrow_t const&) ALIAS(malloc);
+void *operator new[](size_t size, std::nothrow_t const&) ALIAS(malloc);
+void operator delete(void *ptr) throw() ALIAS(free);
+void operator delete[](void *ptr) throw() ALIAS(free);
+void operator delete(void *ptr, std::nothrow_t const&) ALIAS(free);
+void operator delete[](void *ptr, std::nothrow_t const&) ALIAS(free);

compiler-rt/lib/tsan/rtl/tsan_interceptors.h

 #define SCOPED_TSAN_INTERCEPTOR_USER_CALLBACK_END() \
     si.EnableIgnores();
 
 #define TSAN_INTERCEPTOR(ret, func, ...) INTERCEPTOR(ret, func, __VA_ARGS__)
 
 #if SANITIZER_FREEBSD
 #  define TSAN_INTERCEPTOR_FREEBSD_ALIAS(ret, func, ...) \
     TSAN_INTERCEPTOR(ret, _pthread_##func, __VA_ARGS__)  \
-    ALIAS(WRAPPER_NAME(pthread_##func));
+    ALIAS(WRAP(pthread_##func));
 #else
 #  define TSAN_INTERCEPTOR_FREEBSD_ALIAS(ret, func, ...)
 #endif
 
 #if SANITIZER_NETBSD
 # define TSAN_INTERCEPTOR_NETBSD_ALIAS(ret, func, ...) \
   TSAN_INTERCEPTOR(ret, __libc_##func, __VA_ARGS__) \
-  ALIAS(WRAPPER_NAME(pthread_##func));
+  ALIAS(WRAP(pthread_##func));
 # define TSAN_INTERCEPTOR_NETBSD_ALIAS_THR(ret, func, ...) \
   TSAN_INTERCEPTOR(ret, __libc_thr_##func, __VA_ARGS__) \
-  ALIAS(WRAPPER_NAME(pthread_##func));
+  ALIAS(WRAP(pthread_##func));
 # define TSAN_INTERCEPTOR_NETBSD_ALIAS_THR2(ret, func, func2, ...) \
   TSAN_INTERCEPTOR(ret, __libc_thr_##func, __VA_ARGS__) \
-  ALIAS(WRAPPER_NAME(pthread_##func2));
+  ALIAS(WRAP(pthread_##func2));
 #else
 # define TSAN_INTERCEPTOR_NETBSD_ALIAS(ret, func, ...)
 # define TSAN_INTERCEPTOR_NETBSD_ALIAS_THR(ret, func, ...)
 # define TSAN_INTERCEPTOR_NETBSD_ALIAS_THR2(ret, func, func2, ...)
 #endif
 
 #endif  // TSAN_INTERCEPTORS_H