hwasan: use NODEBUG and ALWAYS_INLINE attributes

[marxin]

Summary

Use pre-defined macros instead of attribute syntax.

Btw. may I ask how actively HWASAN is used and developed?

compiler-rt/lib/hwasan/hwasan_checks.h

 #define HWASAN_CHECKS_H
 
 #include "hwasan_allocator.h"
 #include "hwasan_mapping.h"
 #include "sanitizer_common/sanitizer_common.h"
 
 namespace __hwasan {
 template <unsigned X>
-__attribute__((always_inline)) static void SigTrap(uptr p) {
+ALWAYS_INLINE static void SigTrap(uptr p) {
 #if defined(__aarch64__)
   (void)p;
   // 0x900 is added to do not interfere with the kernel use of lower values of
   // brk immediate.
   register uptr x0 asm("x0") = p;
   asm("brk %1\n\t" ::"r"(x0), "n"(0x900 + X));
 #elif defined(__x86_64__)
   // INT3 + NOP DWORD ptr [EAX + X] to pass X to our signal handler, 5 bytes
#else
   // FIXME: not always sigill.
   __builtin_trap();
 #endif
   // __builtin_unreachable();
 }
 
 // Version with access size which is not power of 2
 template <unsigned X>
-__attribute__((always_inline)) static void SigTrap(uptr p, uptr size) {
+ALWAYS_INLINE static void SigTrap(uptr p, uptr size) {
 #if defined(__aarch64__)
   register uptr x0 asm("x0") = p;
   register uptr x1 asm("x1") = size;
   asm("brk %2\n\t" ::"r"(x0), "r"(x1), "n"(0x900 + X));
 #elif defined(__x86_64__)
   // Size is stored in rsi.
   asm volatile(
       "int3\n"
       "nopl %c0(%%rax)\n" ::"n"(0x40 + X),
       "D"(p), "S"(size));
 #else
   __builtin_trap();
 #endif
   // __builtin_unreachable();
 }
 
-__attribute__((always_inline, nodebug)) static bool PossiblyShortTagMatches(
+ALWAYS_INLINE NODEBUG static bool PossiblyShortTagMatches(
     tag_t mem_tag, uptr ptr, uptr sz) {
   tag_t ptr_tag = GetTagFromPointer(ptr);
   if (ptr_tag == mem_tag)
     return true;
   if (mem_tag >= kShadowAlignment)
     return false;
   if ((ptr & (kShadowAlignment - 1)) + sz > mem_tag)
     return false;
 #ifndef __aarch64__
   ptr = UntagAddr(ptr);
 #endif
   return *(u8 *)(ptr | (kShadowAlignment - 1)) == ptr_tag;
 }
 
 enum class ErrorAction { Abort, Recover };
 enum class AccessType { Load, Store };
 
 template <ErrorAction EA, AccessType AT, unsigned LogSize>
-__attribute__((always_inline, nodebug)) static void CheckAddress(uptr p) {
+ALWAYS_INLINE NODEBUG static void CheckAddress(uptr p) {
   if (!InTaggableRegion(p))
     return;
   uptr ptr_raw = p & ~kAddressTagMask;
   tag_t mem_tag = *(tag_t *)MemToShadow(ptr_raw);
   if (UNLIKELY(!PossiblyShortTagMatches(mem_tag, p, 1 << LogSize))) {
     SigTrap<0x20 * (EA == ErrorAction::Recover) +
             0x10 * (AT == AccessType::Store) + LogSize>(p);
     if (EA == ErrorAction::Abort)
       __builtin_unreachable();
   }
 }
 
 template <ErrorAction EA, AccessType AT>
-__attribute__((always_inline, nodebug)) static void CheckAddressSized(uptr p,
+ALWAYS_INLINE NODEBUG static void CheckAddressSized(uptr p,
                                                                       uptr sz) {
   if (sz == 0 || !InTaggableRegion(p))
     return;
   tag_t ptr_tag = GetTagFromPointer(p);
   uptr ptr_raw = p & ~kAddressTagMask;
   tag_t *shadow_first = (tag_t *)MemToShadow(ptr_raw);
   tag_t *shadow_last = (tag_t *)MemToShadow(ptr_raw + sz);
   for (tag_t *t = shadow_first; t < shadow_last; ++t)

compiler-rt/lib/sanitizer_common/sanitizer_internal_defs.h

 #if !defined(_MSC_VER) || defined(__clang__)
 # define UNUSED __attribute__((unused))
 # define USED __attribute__((used))
 #else
 # define UNUSED
 # define USED
 #endif
 
+#if defined(__clang__)
+#define NODEBUG __attribute__((nodebug))
+#else
+#define NODEBUG
+#endif
+
 #if !defined(_MSC_VER) || defined(__clang__) || MSC_PREREQ(1900)
 # define NOEXCEPT noexcept
 #else
 # define NOEXCEPT throw()
 #endif
 
 #if __has_cpp_attribute(clang::fallthrough)
 #  define FALLTHROUGH [[clang::fallthrough]]