[HWASan][NFC] Introduce constants for tag bits and masks.

[morehouse]

Summary

x86_64 aliasing mode will use fewer than 8 bits for tags, so refactor
existing code to remove hard-coded 0xff and 8 values.

Also introduces kAddressUntagMask, which in aliasing mode will only
untag the alias bits and not fixed bits in the tag.

[vitalybuka]

compiler-rt/lib/hwasan/hwasan.h

43

should this be kTagMask for consistency?

[vitalybuka]

compiler-rt/lib/hwasan/hwasan.h

40–48

If we keep this as constexpr, we likely will not be able to control these at runtime.
As-is it does not matter, but we may have to move it into flags later.

[morehouse]

• Add clarifying comments.

compiler-rt/lib/hwasan/hwasan.h

40–48

Yes. For now I prefer to keep it simple. We can make it a flag in a later change.

43

I think it's best to keep the current naming. Added some comments for clarity.

[vitalybuka]

compiler-rt/lib/hwasan/hwasan.h

47

Sorry, I asked about the following

[morehouse]

compiler-rt/lib/hwasan/hwasan.h

47

That works for the current implementation, but it won't work when we introduce x86 aliasing mode.

Then we'll still want to extract all 8 bits when checking the tag in memory, but we only want to mask out 3 bits when untagging the pointer. This is why I left the 0xFF here.

[eugenis]

LGTM

[morehouse]

• Remove kAddressUntagMask. It's unneeded with short tags.
• Add num_bits param to GenerateRandomTag() for use in aliasing mode free().

[morehouse]

@eugenis @vitalybuka I've made some changes to this patch to accommodate changes in the following patches. Please take another look.

[vitalybuka]

LGTM

[eugenis]

LGTM

compiler-rt/lib/hwasan/hwasan.h

 #ifndef HWASAN_REPLACE_OPERATORS_NEW_AND_DELETE
 #define HWASAN_REPLACE_OPERATORS_NEW_AND_DELETE HWASAN_WITH_INTERCEPTORS
 #endif
 
 typedef u8 tag_t;
 
 // TBI (Top Byte Ignore) feature of AArch64: bits [63:56] are ignored in address
 // translation and can be used to store a tag.
-const unsigned kAddressTagShift = 56;
-const uptr kAddressTagMask = 0xFFUL << kAddressTagShift;
+constexpr unsigned kAddressTagShift = 56;
+constexpr unsigned kTagBits = 8;
+
+// Mask for extracting tag bits from the lower 8 bits.
+constexpr uptr kTagMask = (1UL << kTagBits) - 1;
+
+// Masks for extracting and removing tags from full pointers.
+constexpr uptr kAddressTagMask = 0xFFUL << kAddressTagShift;
+constexpr uptr kAddressUntagMask = ~(kTagMask << kAddressTagShift);
 
 // Minimal alignment of the shadow base address. Determines the space available
 // for threads and stack histories. This is an ABI constant.
 const unsigned kShadowBaseAlignment = 32;
 
 const unsigned kRecordAddrBaseTagShift = 3;
 const unsigned kRecordFPShift = 48;
 const unsigned kRecordFPLShift = 4;
 const unsigned kRecordFPModulus = 1 << (64 - kRecordFPShift + kRecordFPLShift);
 
 static inline tag_t GetTagFromPointer(uptr p) {
   return p >> kAddressTagShift;
 }
 
 static inline uptr UntagAddr(uptr tagged_addr) {
-  return tagged_addr & ~kAddressTagMask;
+  return tagged_addr & kAddressUntagMask;
 }
 
 static inline void *UntagPtr(const void *tagged_ptr) {
   return reinterpret_cast<void *>(
       UntagAddr(reinterpret_cast<uptr>(tagged_ptr)));
 }
 
 static inline uptr AddTagToPointer(uptr p, tag_t tag) {
-  return (p & ~kAddressTagMask) | ((uptr)tag << kAddressTagShift);
+  return (p & kAddressUntagMask) | ((uptr)tag << kAddressTagShift);
 }
 
 namespace __hwasan {
 
 extern int hwasan_inited;
 extern bool hwasan_init_is_running;
 extern int hwasan_report_count;
 

compiler-rt/lib/hwasan/hwasan_checks.h

asm volatile(
       "D"(p), "S"(size));
 #else
   __builtin_trap();
 #endif
   // __builtin_unreachable();
 }
 
 __attribute__((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) {
-  uptr ptr_raw = p & ~kAddressTagMask;
+  uptr ptr_raw = p & kAddressUntagMask;
   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,
                                                                       uptr sz) {
   if (sz == 0)
     return;
   tag_t ptr_tag = GetTagFromPointer(p);
-  uptr ptr_raw = p & ~kAddressTagMask;
+  uptr ptr_raw = p & kAddressUntagMask;
   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)
     if (UNLIKELY(ptr_tag != *t)) {
       SigTrap<0x20 * (EA == ErrorAction::Recover) +
               0x10 * (AT == AccessType::Store) + 0xf>(p, sz);
       if (EA == ErrorAction::Abort)
         __builtin_unreachable();
     }
   uptr end = p + sz;
   uptr tail_sz = end & 0xf;

compiler-rt/lib/hwasan/hwasan_thread.cpp

 tag_t Thread::GenerateRandomTag() {
   if (tagging_disabled_) return 0;
   tag_t tag;
   do {
     if (flags()->random_tags) {
       if (!random_buffer_)
         random_buffer_ = random_state_ = xorshift(random_state_);
       CHECK(random_buffer_);
-      tag = random_buffer_ & 0xFF;
-      random_buffer_ >>= 8;
+      tag = random_buffer_ & kTagMask;
+      random_buffer_ >>= kTagBits;
     } else {
-      tag = random_state_ = (random_state_ + 1) & 0xFF;
+      tag = random_state_ = (random_state_ + 1) & kTagMask;
     }
   } while (!tag);
   return tag;
 }
 
 } // namespace __hwasan