Add iOS/watchOS/tvOS support for ASan (compiler-rt part)

[zaks.anna]

Summary

This change along with the corresponding changes in clang (http://reviews.llvm.org/D15624) and llvm (http://reviews.llvm.org/D15625) completes ASan support for iOS/watchOS/tvOS.

(Many parts of this were conributed by Kuba Brecka and the build system was rewritten by Chris Bieneman.)

[samsonov]

cmake/config-ix.cmake

199

This doesn't seem right: this whole code path is not executed on Apple platforms.

308

Are you sure you're ready to enable it by default? Maybe remove "experimental" then?

452

I would really like to see this generalized somehow.

lib/asan/asan_internal.h

36

Let's define ASAN_LOW_MEMORY in a single place

#ifndef ASAN_LOW_MEMORY
#if SANITIZER_OS
#  define ASAN_LOW_MEMORY 1
#elseif SANITIZER_WORDSIZE == 32
#  define ASAN_LOW_MEMORY 1
...

lib/asan/asan_mapping.h

150

See how we deal with SANITIZER_IOS/SANITIZER_IOSSIM above - maybe do the same?

lib/sanitizer_common/sanitizer_mac.cc

361

This is wrong - of course SIGSEGV is deadly, we just don't need to handle it.

lib/sanitizer_common/sanitizer_platform.h

46

You need to make sure SANITIZER_TVOS is *always* defined to 0 or 1. Same with SANITIZER_WATCHOS.

[zaks.anna]

lib/asan/asan_mapping.h

150

I think this way of writing it is less error prone. SANITIZER_IOS is set for both the simulator and the device. If the order of elifs above is reversed, the logic would break. I think it's better to rewrite the code above to make it more explicit.

lib/sanitizer_common/sanitizer_mac.cc

361

How about we rename the function into "IsHandledDeadlySignal". It already only returns true if common_flags()->handle_segv.

[zaks.anna]

Addressed most of Alexey's comments. Chris B. will address the build system refactoring piece.

[beanz]

Anna,

Can you please split out the CMake changes into a separate patch from the other changes? In general I think having more smaller self-contained patches will make it easier to review.

More comments inline.

Thanks,
-Chris

cmake/config-ix.cmake

308–311

I think at this point we can have iOS be on and not experimental, but can we do that as a separate patch?

tvOS and watchOS should be experimental and Off by default. There are some issues we'll need to discuss and work out to get that working in open source. Having options will be an important step for us to make it work, but the options need to be off to start with.

452

I probably won't have time to look at this until January, but I'll help Anna rework this. I think we can set some values up front and turn the logic into a loop.

[zaks.anna]

Chris B. is going to submit a patch for the cmake changes and I will rebase on top of it after that is excepted.

[zaks.anna]

Chris Bieneman has refactored and landed the cmake changes in r257544. Rebased the patch on top of that commit.

[samsonov]

Looks pretty good.

cmake/config-ix.cmake

308–310

Please submit this small change (switching the default) as a separate commit, so that it would be easy revert if iOS build won't work on some setups.

lib/asan/asan_internal.h

45

# if SANITIZER_IOS || (SANITIZER_WORDSIZE == 32)

lib/asan/asan_mapping.h

148–155

Please restore the indentation.

150

Makes sense, let's fix 32-bit variant accordingly then.

165

Do you need to remove these now?

lib/sanitizer_common/sanitizer_mac.cc

361

Please make it a plain if() instead of #if?

lib/sanitizer_common/sanitizer_platform.h

55

Suggestion: write this as

1. if TARGET_OS_IPHONE && TARGET_OS_WATCH
2. define SANITIZER_WATCHOS 1
3. else
4. define SANITIZER_WATCHOS 0
5. endif

and the same for SANITIZER_TVOS, to minimize the places we define this macro at.

[zaks.anna]

Address all comments from Samson's latest review.

[samsonov]

LGTM (one small nit below). Thank you!

lib/sanitizer_common/sanitizer_mac.cc

369

remove else

[zaks.anna]

Committed in r259451

cmake/Modules/CompilerRTDarwinUtils.cmake

function(darwin_test_archs os valid_archs)
   set(os_linker_flags)
   foreach(flag ${DARWIN_${os}_LINKFLAGS})
     set(os_linker_flags "${os_linker_flags} ${flag}")
   endforeach()
 
   # The simple program will build for x86_64h on the simulator because it is 
   # compatible with x86_64 libraries (mostly), but since x86_64h isn't actually
   # a valid or useful architecture for the iOS simulator we should drop it.
-  if(${os} STREQUAL "iossim")
+  if(${os} MATCHES "^(iossim|tvossim|watchossim)$")
     list(REMOVE_ITEM archs "x86_64h")
   endif()
 
   set(working_archs)
   foreach(arch ${archs})
     
     set(arch_linker_flags "-arch ${arch} ${os_linker_flags}")
     try_compile(CAN_TARGET_${os}_${arch} ${CMAKE_BINARY_DIR} ${SIMPLE_CPP}

cmake/config-ix.cmake

if(NOT MSVC)
       test_target_arch(i386 __i386__ "-m32")
     else()
       if (CMAKE_SIZEOF_VOID_P EQUAL 4)
         test_target_arch(i386 "" "")
       else()
         test_target_arch(x86_64 "" "")
       endif()
     endif()
+
+    execute_process(
+      COMMAND xcodebuild -version -sdk iphoneos Path
+      OUTPUT_VARIABLE IOS_SDK_DIR
+      OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
+    test_target_arch(arm64 "-arch arm64 -isysroot ${IOS_SDK_DIR}")
+    test_target_arch(armv7 "-arch armv7 -isysroot ${IOS_SDK_DIR}")
   elseif("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "powerpc")
     TEST_BIG_ENDIAN(HOST_IS_BIG_ENDIAN)
     if(HOST_IS_BIG_ENDIAN)
       test_target_arch(powerpc64 "" "-m64")
     else()
       test_target_arch(powerpc64le "" "-m64")
     endif()
   elseif("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "mipsel|mips64el")

 set(X86 i386 i686)
 set(X86_64 x86_64)
 set(MIPS32 mips mipsel)
 set(MIPS64 mips64 mips64el)
 set(PPC64 powerpc64 powerpc64le)
 
 if(APPLE)
   set(ARM64 arm64)
-  set(ARM32 armv7 armv7s)
+  set(ARM32 armv7 armv7s armv7k)
   set(X86_64 x86_64 x86_64h)
 endif()
 
 set(ALL_BUILTIN_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64}
     ${MIPS32} ${MIPS64})
 set(ALL_SANITIZER_COMMON_SUPPORTED_ARCH ${X86} ${X86_64} ${PPC64}
     ${ARM32} ${ARM64} ${MIPS32} ${MIPS64})
 set(ALL_ASAN_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64}
if(APPLE)
   if(NOT EXISTS /usr/include)
     execute_process(COMMAND xcodebuild -version -sdk macosx Path
        OUTPUT_VARIABLE OSX_SYSROOT
        ERROR_QUIET
        OUTPUT_STRIP_TRAILING_WHITESPACE)
     set(OSX_SYSROOT_FLAG "-isysroot${OSX_SYSROOT}")
   endif()
 
-  option(COMPILER_RT_ENABLE_IOS "Enable building for iOS - Experimental" Off)
+  option(COMPILER_RT_ENABLE_IOS "Enable building for iOS - Experimental" On)
+  option(COMPILER_RT_ENABLE_TVOS "Enable building for AppleTVOS - Experimental" On)
+  option(COMPILER_RT_ENABLE_WATCHOS "Enable building for AppleWatchOS - Experimental" On)
 
   find_darwin_sdk_dir(DARWIN_osx_SYSROOT macosx)
   find_darwin_sdk_dir(DARWIN_iossim_SYSROOT iphonesimulator)
   find_darwin_sdk_dir(DARWIN_ios_SYSROOT iphoneos)
+  find_darwin_sdk_dir(DARWIN_tvossim_SYSROOT appletvsimulator)
+  find_darwin_sdk_dir(DARWIN_tvos_SYSROOT appletvos)
+  find_darwin_sdk_dir(DARWIN_watchossim_SYSROOT watchsimulator)
+  find_darwin_sdk_dir(DARWIN_watchos_SYSROOT watchos)
 
   # Note: In order to target x86_64h on OS X the minimum deployment target must
   # be 10.8 or higher.
   set(SANITIZER_COMMON_SUPPORTED_OS osx)
   set(BUILTIN_SUPPORTED_OS osx)
   set(PROFILE_SUPPORTED_OS osx)
   set(TSAN_SUPPORTED_OS osx)
   if(NOT SANITIZER_MIN_OSX_VERSION)
if(DARWIN_ios_SYSROOT AND COMPILER_RT_ENABLE_IOS)
         list(APPEND BUILTIN_SUPPORTED_OS ios)
         list(APPEND PROFILE_SUPPORTED_OS ios)
       endif()
       foreach(arch ${DARWIN_ios_ARCHS})
         list(APPEND COMPILER_RT_SUPPORTED_ARCH ${arch})
         set(CAN_TARGET_${arch} 1)
       endforeach()
     endif()
+
+    if(COMPILER_RT_ENABLE_TVOS)
+      if(DARWIN_tvossim_SYSROOT)
+        set(DARWIN_tvossim_CFLAGS
+          ${DARWIN_COMMON_CFLAGS}
+          -mtvos-simulator-version-min=9.0
+          -isysroot ${DARWIN_tvossim_SYSROOT})
+        set(DARWIN_tvossim_LINKFLAGS
+          ${DARWIN_COMMON_LINKFLAGS}
+          -mtvos-simulator-version-min=9.0
+          -isysroot ${DARWIN_tvossim_SYSROOT})
+        set(DARWIN_tvossim_BUILTIN_MIN_VER 9.0)
+        set(DARWIN_tvossim_BUILTIN_MIN_VER_FLAG
+          -mtvos-simulator-version-min=${DARWIN_tvossim_BUILTIN_MIN_VER})
+
+        set(DARWIN_tvossim_SKIP_CC_KEXT On)
+        darwin_test_archs(tvossim
+          DARWIN_tvossim_ARCHS
+          ${toolchain_arches})
+        if(DARWIN_tvossim_ARCHS)
+          list(APPEND SANITIZER_COMMON_SUPPORTED_OS tvossim)
+        endif()
+        message(STATUS "TVOS Simulator supported arches: ${DARWIN_tvossim_ARCHS}")
+        foreach(arch ${DARWIN_tvossim_ARCHS})
+          list(APPEND COMPILER_RT_SUPPORTED_ARCH ${arch})
+          set(CAN_TARGET_${arch} 1)
+        endforeach()
+      endif()
+
+      if(DARWIN_tvos_SYSROOT)
+        set(DARWIN_tvos_CFLAGS
+          ${DARWIN_COMMON_CFLAGS}
+          -mtvos-version-min=9.0
+          -isysroot ${DARWIN_tvos_SYSROOT})
+        set(DARWIN_tvos_LINKFLAGS
+          ${DARWIN_COMMON_LINKFLAGS}
+          -mtvos-version-min=9.0
+          -isysroot ${DARWIN_tvos_SYSROOT})
+        set(DARWIN_tvos_BUILTIN_MIN_VER 9.0)
+        set(DARWIN_tvos_BUILTIN_MIN_VER_FLAG
+          -mtvos-version-min=${DARWIN_tvos_BUILTIN_MIN_VER})
+
+        darwin_test_archs(tvos
+          DARWIN_tvos_ARCHS
+          ${toolchain_arches})
+        if(DARWIN_tvos_ARCHS)
+          list(REMOVE_ITEM DARWIN_tvos_ARCHS armv7s)
+          list(APPEND SANITIZER_COMMON_SUPPORTED_OS tvos)
+          list(APPEND BUILTIN_SUPPORTED_OS tvos)
+          list(APPEND PROFILE_SUPPORTED_OS tvos)
+          list(APPEND BUILTIN_SUPPORTED_OS tvossim)
+          list(APPEND PROFILE_SUPPORTED_OS tvossim)
+        endif()
+        message(STATUS "AppleTV supported arches: ${DARWIN_tvos_ARCHS}")
+        foreach(arch ${DARWIN_tvos_ARCHS})
+          list(APPEND COMPILER_RT_SUPPORTED_ARCH ${arch})
+          set(CAN_TARGET_${arch} 1)
+        endforeach()
+      endif()
+    endif()
+
+    if(COMPILER_RT_ENABLE_WATCHOS)
+      if(DARWIN_watchossim_SYSROOT)
+        set(DARWIN_watchossim_CFLAGS
+          ${DARWIN_COMMON_CFLAGS}
+          -mwatchos-simulator-version-min=1.0
+          -isysroot ${DARWIN_watchossim_SYSROOT})
+        set(DARWIN_watchossim_LINKFLAGS
+          ${DARWIN_COMMON_LINKFLAGS}
+          -mwatchos-simulator-version-min=1.0
+          -isysroot ${DARWIN_watchossim_SYSROOT})
+        set(DARWIN_watchossim_BUILTIN_MIN_VER 1.0)
+        set(DARWIN_watchossim_BUILTIN_MIN_VER_FLAG
+          -mwatchos-simulator-version-min=${DARWIN_watchossim_BUILTIN_MIN_VER})
+
+        set(DARWIN_watchossim_SKIP_CC_KEXT On)
+        darwin_test_archs(watchossim
+          DARWIN_watchossim_ARCHS
+          ${toolchain_arches})
+        if(DARWIN_watchossim_ARCHS)
+          list(APPEND SANITIZER_COMMON_SUPPORTED_OS watchossim)
+        endif()
+        message(STATUS "Apple Watch Simulator supported arches: ${DARWIN_watchossim_ARCHS}")
+        foreach(arch ${DARWIN_watchossim_ARCHS})
+          list(APPEND COMPILER_RT_SUPPORTED_ARCH ${arch})
+          set(CAN_TARGET_${arch} 1)
+        endforeach()
+      endif()
+
+      if(DARWIN_watchos_SYSROOT)
+        set(DARWIN_watchos_CFLAGS
+          ${DARWIN_COMMON_CFLAGS}
+          -mwatchos-version-min=1.0
+          -isysroot ${DARWIN_watchos_SYSROOT})
+        set(DARWIN_watchos_LINKFLAGS
+          ${DARWIN_COMMON_LINKFLAGS}
+          -mwatchos-version-min=1.0
+          -isysroot ${DARWIN_watchos_SYSROOT})
+        set(DARWIN_watchos_BUILTIN_MIN_VER 1.0)
+        set(DARWIN_watchos_BUILTIN_MIN_VER_FLAG
+          -mwatchos-version-min=${DARWIN_watchos_BUILTIN_MIN_VER})
+
+        darwin_test_archs(watchos
+          DARWIN_watchos_ARCHS
+          ${toolchain_arches})
+        if(DARWIN_watchos_ARCHS)
+          list(APPEND SANITIZER_COMMON_SUPPORTED_OS watchos)
+          list(APPEND BUILTIN_SUPPORTED_OS watchos)
+          list(APPEND PROFILE_SUPPORTED_OS watchos)
+          list(APPEND BUILTIN_SUPPORTED_OS watchossim)
+          list(APPEND PROFILE_SUPPORTED_OS watchossim)
+        endif()
+        message(STATUS "watchOS supported arches: ${DARWIN_watchos_ARCHS}")
+        foreach(arch ${DARWIN_watchos_ARCHS})
+          list(APPEND COMPILER_RT_SUPPORTED_ARCH ${arch})
+          set(CAN_TARGET_${arch} 1)
+        endforeach()
+      endif()
+    endif()
   endif()
 
   # for list_union
   include(CompilerRTUtils)
 
   list_union(BUILTIN_SUPPORTED_ARCH ALL_BUILTIN_SUPPORTED_ARCH toolchain_arches)
 
   list_union(SANITIZER_COMMON_SUPPORTED_ARCH

lib/asan/asan_internal.h

 
 // Build-time configuration options.
 
 // If set, asan will intercept C++ exception api call(s).
 #ifndef ASAN_HAS_EXCEPTIONS
 # define ASAN_HAS_EXCEPTIONS 1
 #endif
 
+#ifndef ASAN_LOW_MEMORY
+#if SANITIZER_IOS
+#  define ASAN_LOW_MEMORY 1
+#endif
+#endif
+
 // If set, values like allocator chunk size, as well as defaults for some flags
 // will be changed towards less memory overhead.
 #ifndef ASAN_LOW_MEMORY
 #if SANITIZER_WORDSIZE == 32
 #  define ASAN_LOW_MEMORY 1
 #else
 #  define ASAN_LOW_MEMORY 0
 # endif
 #endif
 
 #ifndef ASAN_DYNAMIC
 # ifdef PIC

lib/asan/asan_mac.cc

 #include <pthread.h>
 #include <stdlib.h>  // for free()
 #include <sys/mman.h>
 #include <sys/resource.h>
 #include <sys/sysctl.h>
 #include <sys/ucontext.h>
 #include <unistd.h>
 
+// from <crt_externs.h>, but we don't have that file on iOS
+extern "C" {
+  extern char ***_NSGetArgv(void);
+  extern char ***_NSGetEnviron(void);
+}
+
 namespace __asan {
 
 void InitializePlatformInterceptors() {}
 
 bool PlatformHasDifferentMemcpyAndMemmove() {
   // On OS X 10.7 memcpy() and memmove() are both resolved
   // into memmove$VARIANT$sse42.
   // See also https://github.com/google/sanitizers/issues/34.

lib/asan/asan_mapping.h

 // || `[0x30000000, 0x35ffffff]` || LowShadow  ||
 // || `[0x00000000, 0x2fffffff]` || LowMem     ||
 
 static const u64 kDefaultShadowScale = 3;
 static const u64 kDefaultShadowOffset32 = 1ULL << 29;  // 0x20000000
 static const u64 kDefaultShadowOffset64 = 1ULL << 44;
 static const u64 kDefaultShort64bitShadowOffset = 0x7FFF8000;  // < 2G.
 static const u64 kIosShadowOffset32 = 1ULL << 30;  // 0x40000000
-static const u64 kIosShadowOffset64 = 0x130000000;
+static const u64 kIosShadowOffset64 = 0x120200000;
 static const u64 kIosSimShadowOffset32 = 1ULL << 30;
 static const u64 kIosSimShadowOffset64 = kDefaultShadowOffset64;
 static const u64 kAArch64_ShadowOffset64 = 1ULL << 36;
 static const u64 kMIPS32_ShadowOffset32 = 0x0aaa0000;
 static const u64 kMIPS64_ShadowOffset64 = 1ULL << 37;
 static const u64 kPPC64_ShadowOffset64 = 1ULL << 41;
 static const u64 kFreeBSD_ShadowOffset32 = 1ULL << 30;  // 0x40000000
 static const u64 kFreeBSD_ShadowOffset64 = 1ULL << 46;  // 0x400000000000

 #    define SHADOW_OFFSET kWindowsShadowOffset32
 #  elif SANITIZER_IOSSIM
 #    define SHADOW_OFFSET kIosSimShadowOffset32
 #  elif SANITIZER_IOS
 #    define SHADOW_OFFSET kIosShadowOffset32
 #  else
 #    define SHADOW_OFFSET kDefaultShadowOffset32
 #  endif
-#else
-#  if defined(__aarch64__)
+# else
+#  if SANITIZER_IOS
+#    if SANITIZER_IOSSIM
+#      define SHADOW_OFFSET kIosSimShadowOffset64
+#    else
+#      define SHADOW_OFFSET kIosShadowOffset64
+#    endif
+#  elif defined(__aarch64__)
 #    define SHADOW_OFFSET kAArch64_ShadowOffset64
 #  elif defined(__powerpc64__)
 #    define SHADOW_OFFSET kPPC64_ShadowOffset64
 #  elif SANITIZER_FREEBSD
 #    define SHADOW_OFFSET kFreeBSD_ShadowOffset64
 #  elif SANITIZER_MAC
 #   define SHADOW_OFFSET kDefaultShadowOffset64
 #  elif defined(__mips64)
 #   define SHADOW_OFFSET kMIPS64_ShadowOffset64
 #  elif SANITIZER_IOSSIM
 #    define SHADOW_OFFSET kIosSimShadowOffset64
 #  elif SANITIZER_IOS
 #    define SHADOW_OFFSET kIosShadowOffset64
 #  else
 #   define SHADOW_OFFSET kDefaultShort64bitShadowOffset
 #  endif
 #endif
 

lib/builtins/CMakeLists.txt

set(aarch64_SOURCES
   multc3.c
   trunctfdf2.c
   trunctfsf2.c
   ${GENERIC_SOURCES})
 
 set(armhf_SOURCES ${arm_SOURCES})
 set(armv7_SOURCES ${arm_SOURCES})
 set(armv7s_SOURCES ${arm_SOURCES})
+set(armv7k_SOURCES ${arm_SOURCES})
 set(arm64_SOURCES ${aarch64_SOURCES})
 
 # macho_embedded archs
 set(armv6m_SOURCES ${GENERIC_SOURCES})
 set(armv7m_SOURCES ${arm_SOURCES})
 set(armv7em_SOURCES ${arm_SOURCES})
 
 set(mips_SOURCES ${GENERIC_SOURCES})

lib/sanitizer_common/sanitizer_common_interceptors_ioctl.inc

#define _(rq, tp, sz)                                    \
   }
 
   _(FIOASYNC, READ, sizeof(int));
   _(FIOCLEX, NONE, 0);
   _(FIOGETOWN, WRITE, sizeof(int));
   _(FIONBIO, READ, sizeof(int));
   _(FIONCLEX, NONE, 0);
   _(FIOSETOWN, READ, sizeof(int));
-  _(SIOCADDMULTI, READ, struct_ifreq_sz);
   _(SIOCATMARK, WRITE, sizeof(int));
-  _(SIOCDELMULTI, READ, struct_ifreq_sz);
-  _(SIOCGIFADDR, WRITE, struct_ifreq_sz);
-  _(SIOCGIFBRDADDR, WRITE, struct_ifreq_sz);
   _(SIOCGIFCONF, CUSTOM, 0);
-  _(SIOCGIFDSTADDR, WRITE, struct_ifreq_sz);
-  _(SIOCGIFFLAGS, WRITE, struct_ifreq_sz);
-  _(SIOCGIFMETRIC, WRITE, struct_ifreq_sz);
-  _(SIOCGIFMTU, WRITE, struct_ifreq_sz);
-  _(SIOCGIFNETMASK, WRITE, struct_ifreq_sz);
   _(SIOCGPGRP, WRITE, sizeof(int));
-  _(SIOCSIFADDR, READ, struct_ifreq_sz);
-  _(SIOCSIFBRDADDR, READ, struct_ifreq_sz);
-  _(SIOCSIFDSTADDR, READ, struct_ifreq_sz);
-  _(SIOCSIFFLAGS, READ, struct_ifreq_sz);
-  _(SIOCSIFMETRIC, READ, struct_ifreq_sz);
-  _(SIOCSIFMTU, READ, struct_ifreq_sz);
-  _(SIOCSIFNETMASK, READ, struct_ifreq_sz);
   _(SIOCSPGRP, READ, sizeof(int));
   _(TIOCCONS, NONE, 0);
   _(TIOCEXCL, NONE, 0);
   _(TIOCGETD, WRITE, sizeof(int));
   _(TIOCGPGRP, WRITE, pid_t_sz);
   _(TIOCGWINSZ, WRITE, struct_winsize_sz);
   _(TIOCMBIC, READ, sizeof(int));
   _(TIOCMBIS, READ, sizeof(int));
   _(TIOCMGET, WRITE, sizeof(int));
   _(TIOCMSET, READ, sizeof(int));
   _(TIOCNOTTY, NONE, 0);
   _(TIOCNXCL, NONE, 0);
   _(TIOCOUTQ, WRITE, sizeof(int));
   _(TIOCPKT, READ, sizeof(int));
   _(TIOCSCTTY, NONE, 0);
   _(TIOCSETD, READ, sizeof(int));
   _(TIOCSPGRP, READ, pid_t_sz);
   _(TIOCSTI, READ, sizeof(char));
   _(TIOCSWINSZ, READ, struct_winsize_sz);
 
+#if !SANITIZER_IOS
+  _(SIOCADDMULTI, READ, struct_ifreq_sz);
+  _(SIOCDELMULTI, READ, struct_ifreq_sz);
+  _(SIOCGIFADDR, WRITE, struct_ifreq_sz);
+  _(SIOCGIFBRDADDR, WRITE, struct_ifreq_sz);
+  _(SIOCGIFDSTADDR, WRITE, struct_ifreq_sz);
+  _(SIOCGIFFLAGS, WRITE, struct_ifreq_sz);
+  _(SIOCGIFMETRIC, WRITE, struct_ifreq_sz);
+  _(SIOCGIFMTU, WRITE, struct_ifreq_sz);
+  _(SIOCGIFNETMASK, WRITE, struct_ifreq_sz);
+  _(SIOCSIFADDR, READ, struct_ifreq_sz);
+  _(SIOCSIFBRDADDR, READ, struct_ifreq_sz);
+  _(SIOCSIFDSTADDR, READ, struct_ifreq_sz);
+  _(SIOCSIFFLAGS, READ, struct_ifreq_sz);
+  _(SIOCSIFMETRIC, READ, struct_ifreq_sz);
+  _(SIOCSIFMTU, READ, struct_ifreq_sz);
+  _(SIOCSIFNETMASK, READ, struct_ifreq_sz);
+#endif
+
 #if (SANITIZER_LINUX && !SANITIZER_ANDROID)
   _(SIOCGETSGCNT, WRITE, struct_sioc_sg_req_sz);
   _(SIOCGETVIFCNT, WRITE, struct_sioc_vif_req_sz);
 #endif
 
 #if SANITIZER_LINUX
   // Conflicting request ids.
   // _(CDROMAUDIOBUFSIZ, NONE, 0);

lib/sanitizer_common/sanitizer_mac.cc

 #include <sys/mman.h>
 #include <sys/resource.h>
 #include <sys/stat.h>
 #include <sys/sysctl.h>
 #include <sys/types.h>
 #include <unistd.h>
 #include <util.h>
 
+// from <crt_externs.h>, but we don't have that file on iOS
+extern "C" {
+  extern char ***_NSGetArgv(void);
+  extern char ***_NSGetEnviron(void);
+}
+
 namespace __sanitizer {
 
 #include "sanitizer_syscall_generic.inc"
 
 // ---------------------- sanitizer_libc.h
 uptr internal_mmap(void *addr, size_t length, int prot, int flags,
                    int fd, u64 offset) {
   if (fd == -1) fd = VM_MAKE_TAG(VM_MEMORY_ANALYSIS_TOOL);

 
 uptr GetListOfModules(LoadedModule *modules, uptr max_modules,
                       string_predicate_t filter) {
   MemoryMappingLayout memory_mapping(false);
   return memory_mapping.DumpListOfModules(modules, max_modules, filter);
 }
 
 bool IsDeadlySignal(int signum) {
+#if (SANITIZER_WATCHOS || SANITIZER_TVOS) && !SANITIZER_IOSSIM
+  // Handling fatal signals on watchOS and tvOS devices is disallowed.
+  return false;
+#else
   return (signum == SIGSEGV || signum == SIGBUS) && common_flags()->handle_segv;
+#endif
 }
 
 MacosVersion cached_macos_version = MACOS_VERSION_UNINITIALIZED;
 
 MacosVersion GetMacosVersionInternal() {
   int mib[2] = { CTL_KERN, KERN_OSRELEASE };
   char version[100];
   uptr len = 0, maxlen = sizeof(version) / sizeof(version[0]);
   for (uptr i = 0; i < maxlen; i++) version[i] = '\0';
   // Get the version length.
   CHECK_NE(sysctl(mib, 2, 0, &len, 0, 0), -1);

lib/sanitizer_common/sanitizer_platform.h

 # define SANITIZER_FREEBSD 0
 #endif
 
 #if defined(__APPLE__)
 # define SANITIZER_MAC     1
 # include <TargetConditionals.h>
 # if TARGET_OS_IPHONE
 #  define SANITIZER_IOS    1
+#  if TARGET_OS_WATCH
+#   define SANITIZER_WATCHOS 1
+#  else
+#   define SANITIZER_WATCHOS 0
+#  endif
+#  if TARGET_OS_TV
+#   define SANITIZER_TVOS 1
+#  else
+#   define SANITIZER_TVOS 0
+#  endif
 # else
 #  define SANITIZER_IOS    0
 # endif
 # if TARGET_IPHONE_SIMULATOR
 #  define SANITIZER_IOSSIM 1
 # else
 #  define SANITIZER_IOSSIM 0
 # endif
 #else
 # define SANITIZER_MAC     0
 # define SANITIZER_IOS     0
 # define SANITIZER_IOSSIM  0
 #endif
 
 #if defined(_WIN32)
 # define SANITIZER_WINDOWS 1

lib/sanitizer_common/sanitizer_posix.cc

 #else
   return 0;
 #endif  // SANITIZER_LINUX && !SANITIZER_X32
 }
 #endif  // SANITIZER_WORDSIZE == 32
 
 uptr GetMaxVirtualAddress() {
 #if SANITIZER_WORDSIZE == 64
-# if defined(__powerpc64__) || defined(__aarch64__)
+# if defined(__aarch64__) && SANITIZER_IOS && !SANITIZER_IOSSIM
+  // Ideally, we would derive the upper bound from MACH_VM_MAX_ADDRESS. The
+  // upper bound can change depending on the device.
+  return 0x200000000 - 1;
+# elif defined(__powerpc64__) || defined(__aarch64__)
   // On PowerPC64 we have two different address space layouts: 44- and 46-bit.
   // We somehow need to figure out which one we are using now and choose
   // one of 0x00000fffffffffffUL and 0x00003fffffffffffUL.
   // Note that with 'ulimit -s unlimited' the stack is moved away from the top
   // of the address space, so simply checking the stack address is not enough.
   // This should (does) work for both PowerPC64 Endian modes.
   // Similarly, aarch64 has multiple address space layouts: 39, 42 and 47-bit.
   return (1ULL << (MostSignificantSetBitIndex(GET_CURRENT_FRAME()) + 1)) - 1;

lib/sanitizer_common/sanitizer_symbolizer_libcdep.cc

private:
   void GetArgV(const char *path_to_binary,
                const char *(&argv)[kArgVMax]) const override {
 #if defined(__x86_64h__)
     const char* const kSymbolizerArch = "--default-arch=x86_64h";
 #elif defined(__x86_64__)
     const char* const kSymbolizerArch = "--default-arch=x86_64";
 #elif defined(__i386__)
     const char* const kSymbolizerArch = "--default-arch=i386";
+#elif defined(__aarch64__)
+    const char* const kSymbolizerArch = "--default-arch=arm64";
+#elif defined(__arm__)
+    const char* const kSymbolizerArch = "--default-arch=arm";
 #elif defined(__powerpc64__) && defined(__BIG_ENDIAN__)
     const char* const kSymbolizerArch = "--default-arch=powerpc64";
 #elif defined(__powerpc64__) && defined(__LITTLE_ENDIAN__)
     const char* const kSymbolizerArch = "--default-arch=powerpc64le";
 #else
     const char* const kSymbolizerArch = "--default-arch=unknown";
 #endif