[compiler-rt][hwasan] Refactor kAliasRegionStart usage

[leonardchan]

Summary

This patch contains thre3 changes:

• Add GetAliasRegionStart which will dispatch to either 0 or kAliasRegionStart depending on if aliasing mode is enabled.
• Wrap instances of kAliasRegionStart so it's not emitted when aliasing mode is disabled.
• Move kAliasRegionStart out of hwasan_linux.cpp so other platforms can reuse it if other platforms want to define a non-zero alias start.

For now, aliasing mode is not supported on fuchsia, so this takes care of "not using what we don't use" while making it easier to use if we do support it in the future.

[vitalybuka]

compiler-rt/lib/hwasan/hwasan_mapping.h

51–53

can you hide this completly in cpp file and move GetAliasRegionStart into cpp as well?
This function rarely used, I don't think it's important to keep it inline

[leonardchan]

compiler-rt/lib/hwasan/hwasan_mapping.h

51–53

Something like this? I was hoping to prevent emitting an alias-related symbol when aliasing mode is disabled with the static inline similar to D104275.

[vitalybuka]

compiler-rt/lib/hwasan/hwasan_allocator.cpp

44

why here and not in linux where it's used?
I assumed you can make it in linux file
static uptr kAliasRegionStart;

compiler-rt/lib/hwasan/hwasan_linux.cpp

74–75

please clang format

[vitalybuka]

As is I like "Diff 1" better then "Diff 2"

[leonardchan]

compiler-rt/lib/hwasan/hwasan_allocator.cpp

44

GetAliasRegionStart would still need to reference kAliasRegionStart in aliasing mode, so if it's in the linux file, then either GetAliasRegionStart is also defined there or we can define it elsewhere but kAliasRegionStart would still need to be extern in hwasan_mapping.h.

I believe the first case would mean GetAliasRegionStart would need to be re-implemented for other platforms, but I think it would be cleaner if we can just re-use GetAliasRegionStart (which can return 0) in non-aliasing mode. Currently, supporting a new platform requires defining kAliasRegionStart, but I think it would be cleaner if platforms that didn't use aliasing just don't need to define it at all.

[vitalybuka]

either way LGTM

compiler-rt/lib/hwasan/hwasan_allocator.cpp

44

GetAliasRegionStart

85

can we just return here and remove corresponding stuff from linux file?
constexpr uptr kAliasRegionOffset = 1ULL << (kTaggableRegionCheckShift - 1);
return __hwasan_shadow_memory_dynamic_address + kAliasRegionOffset;

[vitalybuka]

compiler-rt/lib/hwasan/hwasan_allocator.cpp

44

ignore this one

compiler-rt/lib/hwasan/hwasan_allocator.cpp

enum RightAlignMode {
   kRightAlignNever,
   kRightAlignSometimes,
   kRightAlignAlways
 };
 
 // Initialized in HwasanAllocatorInit, an never changed.
 static ALIGNED(16) u8 tail_magic[kShadowAlignment - 1];
 
 bool HwasanChunkView::IsAllocated() const {
   return metadata_ && metadata_->alloc_context_id &&
          metadata_->get_requested_size();
 }
 
 // Aligns the 'addr' right to the granule boundary.
 static uptr AlignRight(uptr addr, uptr requested_size) {
   uptr tail_size = requested_size % kShadowAlignment;
   if (!tail_size) return addr;

 bool HwasanChunkView::FromSmallHeap() const {
   return allocator.FromPrimary(reinterpret_cast<void *>(block_));
 }
 
 void GetAllocatorStats(AllocatorStatCounters s) {
   allocator.GetStats(s);
 }
 
+uptr GetAliasRegionStart() {
+#if defined(HWASAN_ALIASING_MODE)
+  constexpr uptr kAliasRegionOffset = 1ULL << (kTaggableRegionCheckShift - 1);
+  uptr AliasRegionStart =
+      __hwasan_shadow_memory_dynamic_address + kAliasRegionOffset;
+
+  CHECK_EQ(AliasRegionStart >> kTaggableRegionCheckShift,
+           __hwasan_shadow_memory_dynamic_address >> kTaggableRegionCheckShift);
+  CHECK_EQ(
+      (AliasRegionStart + kAliasRegionOffset - 1) >> kTaggableRegionCheckShift,
+      __hwasan_shadow_memory_dynamic_address >> kTaggableRegionCheckShift);
+  return AliasRegionStart;
+#else
+  return 0;
+#endif
+}
+
 void HwasanAllocatorInit() {
   atomic_store_relaxed(&hwasan_allocator_tagging_enabled,
                        !flags()->disable_allocator_tagging);
   SetAllocatorMayReturnNull(common_flags()->allocator_may_return_null);
   allocator.Init(common_flags()->allocator_release_to_os_interval_ms,
-                 kAliasRegionStart);
+                 GetAliasRegionStart());
   for (uptr i = 0; i < sizeof(tail_magic); i++)
     tail_magic[i] = GetCurrentThread()->GenerateRandomTag();
 }
 
 void AllocatorSwallowThreadLocalCache(AllocatorCache *cache) {
   allocator.SwallowCache(cache);
 }
 

compiler-rt/lib/hwasan/hwasan_linux.cpp

static void ProtectGap(uptr addr, uptr size) {
   __sanitizer::ProtectGap(addr, size, kZeroBaseShadowStart,
                           kZeroBaseMaxShadowStart);
 }
 
 uptr kLowMemStart;
 uptr kLowMemEnd;
 uptr kHighMemStart;
 uptr kHighMemEnd;
 
-uptr kAliasRegionStart;  // Always 0 when aliases aren't used.
-
 static void PrintRange(uptr start, uptr end, const char *name) {
   Printf("|| [%p, %p] || %.*s ||\n", (void *)start, (void *)end, 10, name);
 }
 
 static void PrintAddressSpaceLayout() {
   PrintRange(kHighMemStart, kHighMemEnd, "HighMem");
   if (kHighShadowEnd + 1 < kHighMemStart)
     PrintRange(kHighShadowEnd + 1, kHighMemStart - 1, "ShadowGap");
   else
bool InitShadow() {
   // High shadow takes whatever memory is left up there (making sure it is not
   // interfering with low memory in the fixed case).
   kHighShadowEnd = MemToShadow(kHighMemEnd);
   kHighShadowStart = Max(kLowMemEnd, MemToShadow(kHighShadowEnd)) + 1;
 
   // High memory starts where allocated shadow allows.
   kHighMemStart = ShadowToMem(kHighShadowStart);
 
-#  if defined(HWASAN_ALIASING_MODE)
-  constexpr uptr kAliasRegionOffset = 1ULL << (kTaggableRegionCheckShift - 1);
-  kAliasRegionStart =
-      __hwasan_shadow_memory_dynamic_address + kAliasRegionOffset;
-
-  CHECK_EQ(kAliasRegionStart >> kTaggableRegionCheckShift,
-           __hwasan_shadow_memory_dynamic_address >> kTaggableRegionCheckShift);
-  CHECK_EQ(
-      (kAliasRegionStart + kAliasRegionOffset - 1) >> kTaggableRegionCheckShift,
-      __hwasan_shadow_memory_dynamic_address >> kTaggableRegionCheckShift);
-#  endif
-
   // Check the sanity of the defined memory ranges (there might be gaps).
   CHECK_EQ(kHighMemStart % GetMmapGranularity(), 0);
   CHECK_GT(kHighMemStart, kHighShadowEnd);
   CHECK_GT(kHighShadowEnd, kHighShadowStart);
   CHECK_GT(kHighShadowStart, kLowMemEnd);
   CHECK_GT(kLowMemEnd, kLowMemStart);
   CHECK_GT(kLowShadowEnd, kLowShadowStart);
   CHECK_GT(kLowShadowStart, kLowMemEnd);

compiler-rt/lib/hwasan/hwasan_mapping.h

 extern uptr kLowMemEnd;
 extern uptr kLowShadowEnd;
 extern uptr kLowShadowStart;
 extern uptr kHighShadowStart;
 extern uptr kHighShadowEnd;
 extern uptr kHighMemStart;
 extern uptr kHighMemEnd;
 
-extern uptr kAliasRegionStart;
-
 inline uptr GetShadowOffset() {
   return SANITIZER_FUCHSIA ? 0 : __hwasan_shadow_memory_dynamic_address;
 }
 inline uptr MemToShadow(uptr untagged_addr) {
   return (untagged_addr >> kShadowScale) + GetShadowOffset();
 }
 inline uptr ShadowToMem(uptr shadow_addr) {
   return (shadow_addr - GetShadowOffset()) << kShadowScale;
 }
 inline uptr MemToShadowSize(uptr size) {
   return size >> kShadowScale;
 }
 
 bool MemIsApp(uptr p);
 
 inline bool MemIsShadow(uptr p) {
   return (kLowShadowStart <= p && p <= kLowShadowEnd) ||
          (kHighShadowStart <= p && p <= kHighShadowEnd);
 }
 
+uptr GetAliasRegionStart();
+
 }  // namespace __hwasan
 
 #endif  // HWASAN_MAPPING_H