Add iOS/watchOS/tvOS support for ASan (llvm part)

[zaks.anna]

Summary

Set the shadow region on iOS/watchOS/tvOS.

This change along with the corresponding changes in clang and compiler-rt completes ASan support for iOS/watchOS/tvOS.

[samsonov]

lib/Transforms/Instrumentation/AddressSanitizer.cpp

70

Please group all IOS constants together.

365

Looks like the order becomes important here. Maybe:

else if (IsIOS)
  Mapping.Offset = IsX86 ? kIOSSimShadowOffset32 : kIOSShadowOffset32;

here and below? And a comment describing the rationale behind this (I guess, it's just an heuristic, right?)

[zaks.anna]

lib/Transforms/Instrumentation/AddressSanitizer.cpp

365

(I guess, it's just an heuristic, right?)

What do you mean? We are setting the location of the shadow on the device and the simulator (IsIOS and IsX86 -> simulator). The simulator has the host's VM layout. The device has a very different (and restricted) VM layout.

[samsonov]

lib/Transforms/Instrumentation/AddressSanitizer.cpp

365

Right, I mean that if we're building for iOS and target x86, you "assume" you're building for ios simulator, but this assumption is not explicitly deducible from the code.

[zaks.anna]

Address all Samsonov's review comments.

[samsonov]

LGTM

lib/Transforms/Instrumentation/AddressSanitizer.cpp

 using namespace llvm;
 
 #define DEBUG_TYPE "asan"
 
 static const uint64_t kDefaultShadowScale = 3;
 static const uint64_t kDefaultShadowOffset32 = 1ULL << 29;
 static const uint64_t kIOSShadowOffset32 = 1ULL << 30;
 static const uint64_t kDefaultShadowOffset64 = 1ULL << 44;
+static const uint64_t kIOSShadowOffset64 = 0x120200000;
+static const uint64_t kIOSSimShadowOffset32 = 1ULL << 30;
+static const uint64_t kIOSSimShadowOffset64 = kDefaultShadowOffset64;
 static const uint64_t kSmallX86_64ShadowOffset = 0x7FFF8000;  // < 2G.
 static const uint64_t kLinuxKasan_ShadowOffset64 = 0xdffffc0000000000;
 static const uint64_t kPPC64_ShadowOffset64 = 1ULL << 41;
 static const uint64_t kMIPS32_ShadowOffset32 = 0x0aaa0000;
 static const uint64_t kMIPS64_ShadowOffset64 = 1ULL << 37;
 static const uint64_t kAArch64_ShadowOffset64 = 1ULL << 36;
 static const uint64_t kFreeBSD_ShadowOffset32 = 1ULL << 30;
 static const uint64_t kFreeBSD_ShadowOffset64 = 1ULL << 46;
struct ShadowMapping {
   int Scale;
   uint64_t Offset;
   bool OrShadowOffset;
 };
 
 static ShadowMapping getShadowMapping(Triple &TargetTriple, int LongSize,
                                       bool IsKasan) {
   bool IsAndroid = TargetTriple.isAndroid();
-  bool IsIOS = TargetTriple.isiOS();
+  bool IsIOS = TargetTriple.isiOS() || TargetTriple.isWatchOS();
   bool IsFreeBSD = TargetTriple.isOSFreeBSD();
   bool IsLinux = TargetTriple.isOSLinux();
   bool IsPPC64 = TargetTriple.getArch() == llvm::Triple::ppc64 ||
                  TargetTriple.getArch() == llvm::Triple::ppc64le;
+  bool IsX86 = TargetTriple.getArch() == llvm::Triple::x86;
   bool IsX86_64 = TargetTriple.getArch() == llvm::Triple::x86_64;
   bool IsMIPS32 = TargetTriple.getArch() == llvm::Triple::mips ||
                   TargetTriple.getArch() == llvm::Triple::mipsel;
   bool IsMIPS64 = TargetTriple.getArch() == llvm::Triple::mips64 ||
                   TargetTriple.getArch() == llvm::Triple::mips64el;
   bool IsAArch64 = TargetTriple.getArch() == llvm::Triple::aarch64;
   bool IsWindows = TargetTriple.isOSWindows();
 
   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;
     else if (IsMIPS32)
       Mapping.Offset = kMIPS32_ShadowOffset32;
     else if (IsFreeBSD)
       Mapping.Offset = kFreeBSD_ShadowOffset32;
+    else if (IsIOS && IsX86)
+      Mapping.Offset = kIOSSimShadowOffset32;
     else if (IsIOS)
       Mapping.Offset = kIOSShadowOffset32;
     else if (IsWindows)
       Mapping.Offset = kWindowsShadowOffset32;
     else
       Mapping.Offset = kDefaultShadowOffset32;
   } else {  // LongSize == 64
     if (IsPPC64)
       Mapping.Offset = kPPC64_ShadowOffset64;
     else if (IsFreeBSD)
       Mapping.Offset = kFreeBSD_ShadowOffset64;
     else if (IsLinux && IsX86_64) {
       if (IsKasan)
         Mapping.Offset = kLinuxKasan_ShadowOffset64;
       else
         Mapping.Offset = kSmallX86_64ShadowOffset;
     } else if (IsMIPS64)
       Mapping.Offset = kMIPS64_ShadowOffset64;
+    else if (IsIOS && IsX86_64)
+      Mapping.Offset = kIOSSimShadowOffset64;
+    else if (IsIOS)
+      Mapping.Offset = kIOSShadowOffset64;
     else if (IsAArch64)
       Mapping.Offset = kAArch64_ShadowOffset64;
     else
       Mapping.Offset = kDefaultShadowOffset64;
   }
 
   Mapping.Scale = kDefaultShadowScale;
   if (ClMappingScale) {