[asan] Fallback to non-ifunc dynamic shadow on android<22.

[eugenis]

Summary

Android < 22 does not support ifunc.

[eugenis]

Changed condition to <21.

API 21 is known to be broken with ASan, but it's OK to target it as the minimum API level, and it means the ifunc is supported.

[pcc]

LGTM

compiler-rt/trunk/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
 }
 
 #if ASAN_PREMAP_SHADOW
-uptr FindDynamicShadowStart() {
+uptr FindPremappedShadowStart() {
   uptr granularity = GetMmapGranularity();
   uptr shadow_start = reinterpret_cast<uptr>(&__asan_shadow);
   uptr shadow_size = PremapShadowSize();
   UnmapOrDie((void *)(shadow_start - granularity), shadow_size + granularity);
   // MmapNoAccess does not touch TotalMmap, but UnmapOrDie decreases it.
   // Compensate.
   IncreaseTotalMmap(shadow_size + granularity);
   return shadow_start;
 }
-#else
+#endif
+
 uptr FindDynamicShadowStart() {
+#if ASAN_PREMAP_SHADOW
+  if (!PremapShadowFailed())
+    return FindPremappedShadowStart();
+#endif
+
   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;
 }
-#endif
 
 void AsanApplyToGlobals(globals_op_fptr op, const void *needle) {
   UNIMPLEMENTED();
 }
 
 #if SANITIZER_ANDROID
 // FIXME: should we do anything for Android?
 void AsanCheckDynamicRTPrereqs() {}

compiler-rt/trunk/lib/asan/asan_premap_shadow.h

 
 #ifndef ASAN_PREMAP_SHADOW_H
 #define ASAN_PREMAP_SHADOW_H
 
 #if ASAN_PREMAP_SHADOW
 namespace __asan {
 // Conservative upper limit.
 uptr PremapShadowSize();
+bool PremapShadowFailed();
 }
 #endif
 
 extern "C" INTERFACE_ATTRIBUTE void __asan_shadow();
+extern "C" decltype(__asan_shadow)* __asan_premap_shadow();
 
 #endif // ASAN_PREMAP_SHADOW_H

compiler-rt/trunk/lib/asan/asan_premap_shadow.cc

uptr PremapShadow() {
   uptr shadow_end = shadow_start + shadow_size;
   internal_munmap(reinterpret_cast<void *>(map_start),
                   shadow_start - left_padding - map_start);
   internal_munmap(reinterpret_cast<void *>(shadow_end),
                   map_start + map_size - shadow_end);
   return shadow_start;
 }
 
+bool PremapShadowFailed() {
+  uptr shadow = reinterpret_cast<uptr>(&__asan_shadow);
+  uptr resolver = reinterpret_cast<uptr>(&__asan_premap_shadow);
+  // shadow == resolver is how Android KitKat and older handles ifunc.
+  // shadow == 0 just in case.
+  if (shadow == 0 || shadow == resolver)
+    return true;
+  return false;
+}
 } // namespace __asan
 
 extern "C" {
 decltype(__asan_shadow)* __asan_premap_shadow() {
   // The resolver may be called multiple times. Map the shadow just once.
   static uptr premapped_shadow = 0;
   if (!premapped_shadow) premapped_shadow = __asan::PremapShadow();
   return reinterpret_cast<decltype(__asan_shadow)*>(premapped_shadow);

llvm/trunk/lib/Transforms/Instrumentation/AddressSanitizer.cpp

static ShadowMapping getShadowMapping(Triple &TargetTriple, int LongSize,
   // OR-ing shadow offset if more efficient (at least on x86) if the offset
   // is a power of two, but on ppc64 we have to use add since the shadow
   // offset is not necessary 1/8-th of the address space.  On SystemZ,
   // we could OR the constant in a single instruction, but it's more
   // efficient to load it once and use indexed addressing.
   Mapping.OrShadowOffset = !IsAArch64 && !IsPPC64 && !IsSystemZ && !IsPS4CPU &&
                            !(Mapping.Offset & (Mapping.Offset - 1)) &&
                            Mapping.Offset != kDynamicShadowSentinel;
-  Mapping.InGlobal = ClWithIfunc && IsAndroid && IsArmOrThumb;
+  bool IsAndroidWithIfuncSupport =
+      IsAndroid && !TargetTriple.isAndroidVersionLT(21);
+  Mapping.InGlobal = ClWithIfunc && IsAndroidWithIfuncSupport && IsArmOrThumb;
 
   return Mapping;
 }
 
 static size_t RedzoneSizeForScale(int MappingScale) {
   // Redzone used for stack and globals is at least 32 bytes.
   // For scales 6 and 7, the redzone has to be 64 and 128 bytes respectively.
   return std::max(32U, 1U << MappingScale);

llvm/trunk/test/Instrumentation/AddressSanitizer/with-ifunc.ll

 ; Test -asan-with-ifunc flag.
 ;
 ; RUN: opt -asan -asan-module -S -asan-with-ifunc=0 < %s | \
 ; RUN:     FileCheck %s --check-prefixes=CHECK,CHECK-NOIFUNC
 ; RUN: opt -asan -asan-module -S -asan-with-ifunc=1 -asan-with-ifunc-suppress-remat=0 < %s | \
 ; RUN:     FileCheck %s --check-prefixes=CHECK,CHECK-IFUNC
 ; RUN: opt -asan -asan-module -S -asan-with-ifunc=1 -asan-with-ifunc-suppress-remat=1 < %s | \
 ; RUN:     FileCheck %s --check-prefixes=CHECK,CHECK-IFUNC-NOREMAT
 
+; Pre-Lollipop Android does not support ifunc.
+; RUN: opt -asan -asan-module -S -asan-with-ifunc=1 -asan-with-ifunc-suppress-remat=0 -mtriple=armv7-linux-android20 < %s | \
+; RUN:     FileCheck %s --check-prefixes=CHECK,CHECK-NOIFUNC
+; RUN: opt -asan -asan-module -S -asan-with-ifunc=1 -asan-with-ifunc-suppress-remat=0 -mtriple=armv7-linux-android < %s | \
+; RUN:     FileCheck %s --check-prefixes=CHECK,CHECK-NOIFUNC
+; RUN: opt -asan -asan-module -S -asan-with-ifunc=1 -asan-with-ifunc-suppress-remat=0 -mtriple=armv7-linux-android21 < %s | \
+; RUN:     FileCheck %s --check-prefixes=CHECK,CHECK-IFUNC
+
 target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
-target triple = "armv7--linux-android"
+target triple = "armv7--linux-android22"
 
 ; CHECK-IFUNC: @__asan_shadow = external global [0 x i8]
 ; CHECK-NOIFUNC: @__asan_shadow_memory_dynamic_address = external global i32
 
 define i32 @test_load(i32* %a) sanitize_address {
 ; First instrumentation in the function must be to load the dynamic shadow
 ; address into a local variable.
 ; CHECK-LABEL: @test_load