[asan] Use dynamic shadow on 32-bit Android.

[eugenis]

Summary

The following kernel change has moved ET_DYN base to 0x4000000 on arm32:
https://marc.info/?l=linux-kernel&m=149825162606848&w=2

Switch to dynamic shadow base to avoid such conflicts in the future.

In my limited testing, this is causing 1.3% binary size increase, and
from 1% to 6% CPU overhead, depending on the benchmark.

[eugenis]

Reserve shadow range in ifunc.

[eugenis]

.

[pcc]

compiler-rt/lib/sanitizer_common/sanitizer_linux.cc

970 ↗

(On Diff #121805)

Is the ifunc_safe change necessary? If common_flags() is inlined, I would expect the access to go through common_flags_dont_use, which you have marked as hidden. You might want to make common_flags() hidden as well, in case it doesn't get inlined.

[vitalybuka]

compiler-rt/lib/asan/asan_linux.cc

105

why do you need to *8 here?

[eugenis]

compiler-rt/lib/sanitizer_common/sanitizer_linux.cc

970 ↗

(On Diff #121805)

unfortunately it does into GetKernelAreaSize(), because common_flags()->full_address_space is statically initialized to false. And that is not ifunc-safe.

[eugenis]

compiler-rt/lib/asan/asan_linux.cc

105

I had the same question a while ago :)
Because shadow gap start is calculated as shadow(shadow_start), and needs to be page-aligned, so shadow-start needs to be 8 page aligned.

[pcc]

compiler-rt/lib/sanitizer_common/sanitizer_linux.cc

970 ↗

(On Diff #121805)

Oh, right.

I have a mild preference for there to be a separate function that is ifunc-safe (maybe rename this function to GetMaxUserVirtualAddress and then have the ifunc-safe one be GetMaxVirtualAddress), but up to you.

[eugenis]

It turns out that clang is exceptionally bad at accessing external variables in PIC code on ARM:
https://bugs.llvm.org/show_bug.cgi?id=35221

This translates to 20% code size regression, and 15% CPU.
I think I'll hold off on this change, and look at the codegen issue in the meantime.

[eugenis]

Lets go ahead with this, but keep using "legacy" dynamic shadow instrumentation.
Performance numbers of that mode aren't that bad and it solves the kernel compatibility issue.
By switching the runtime library to ifunc early, the future switch of instrumentation will not be an ABI break.

Speaking of ABI, I'm bumping the asan_version_mismatch thing on 32-bit android only. It looks a bit ugly,
but I think that not disturbing other platforms users is worth it.

[eugenis]

ping

[pcc]

Can you add a test that uses the -asan-with-ifunc flag?

LGTM with that.

[eugenis]

Add a test.

[pcc]

LGTM

compiler-rt/lib/asan/asan_linux.cc

 bool IsSystemHeapAddress (uptr addr) { return false; }
 
 void *AsanDoesNotSupportStaticLinkage() {
   // This will fail to link with -static.
   return &_DYNAMIC;  // defined in link.h
 }
 
 uptr FindDynamicShadowStart() {
-  UNREACHABLE("FindDynamicShadowStart is not available");
-  return 0;
+  uptr granularity = GetMmapGranularity();
+  uptr alignment = granularity * 8;
+  uptr left_padding = granularity;
+  uptr shadow_size = kHighShadowEnd + left_padding;
+  uptr map_size = shadow_size + alignment;
+
+  uptr map_start = (uptr)MmapNoAccess(map_size);
+  CHECK_NE(map_start, ~(uptr)0);
+
+  uptr shadow_start = RoundUpTo(map_start, alignment);
+  UnmapOrDie((void *)map_start, map_size);
+  // MmapNoAccess does not touch TotalMmap, but UnmapOrDie decreases it.
+  // Compensate.
+  IncreaseTotalMmap(map_size);
+
+  return shadow_start;
 }
 
 void AsanApplyToGlobals(globals_op_fptr op, const void *needle) {
   UNIMPLEMENTED();
 }
 
 #if SANITIZER_ANDROID
 // FIXME: should we do anything for Android?
 void AsanCheckDynamicRTPrereqs() {}
 void AsanCheckIncompatibleRT() {}
 #else
 static int FindFirstDSOCallback(struct dl_phdr_info *info, size_t size,
                                 void *data) {

compiler-rt/lib/asan/asan_mapping.h

 static const u64 kWindowsShadowOffset32 = 3ULL << 28;  // 0x30000000
 
 #define SHADOW_SCALE kDefaultShadowScale
 
 #if SANITIZER_FUCHSIA
 #  define SHADOW_OFFSET (0)
 #elif SANITIZER_WORDSIZE == 32
 #  if SANITIZER_ANDROID
-#    define SHADOW_OFFSET (0)
+#    define SHADOW_OFFSET __asan_shadow_memory_dynamic_address
 #  elif defined(__mips__)
 #    define SHADOW_OFFSET kMIPS32_ShadowOffset32
 #  elif SANITIZER_FREEBSD
 #    define SHADOW_OFFSET kFreeBSD_ShadowOffset32
 #  elif SANITIZER_WINDOWS
 #    define SHADOW_OFFSET kWindowsShadowOffset32
 #  elif SANITIZER_IOS
 #    if SANITIZER_IOSSIM

llvm/lib/Transforms/Instrumentation/AddressSanitizer.cpp

bool IsMIPS64 = TargetTriple.getArch() == Triple::mips64 ||
                   TargetTriple.getArch() == Triple::mips64el;
   bool IsAArch64 = TargetTriple.getArch() == Triple::aarch64;
   bool IsWindows = TargetTriple.isOSWindows();
   bool IsFuchsia = TargetTriple.isOSFuchsia();
 
   ShadowMapping Mapping;
 
   if (LongSize == 32) {
-    // Android is always PIE, which means that the beginning of the address
-    // space is always available.
     if (IsAndroid)
-      Mapping.Offset = 0;
+      Mapping.Offset = kDynamicShadowSentinel;
     else if (IsMIPS32)
       Mapping.Offset = kMIPS32_ShadowOffset32;
     else if (IsFreeBSD)
       Mapping.Offset = kFreeBSD_ShadowOffset32;
     else if (IsIOS)
       // If we're targeting iOS and x86, the binary is built for iOS simulator.
       Mapping.Offset = IsX86 ? kIOSSimShadowOffset32 : kIOSShadowOffset32;
     else if (IsWindows)