[compiler-rt] Fix checks for Android.

[danalbert]

Summary

ANDROID is a define that comes from the toolchain when building
for Android targets. ANDROID has a different meaning. ANDROID is
defined for _every_ Android build, including those done for host
modules. For host modules, we want to build the regular Linux
sanitizers and builtins, not the one for Android devices. This hasn't
been a problem until now because we only just started building the
sanitizers for the host.

[eugenis]

LGTM, thanks!

[danalbert]

Submitted as r220203.

lib/asan/tests/asan_test.cc

#if !defined(_WIN32)
       // with quarantine size set to 1.
       free(Ident(malloc(Ident(1 << 27))));  // Try to drain the quarantine.
 #endif
     }
   }
 }
 
 // No valloc on Windows or Android.
-#if !defined(_WIN32) && !defined(ANDROID) && !defined(__ANDROID__)
+#if !defined(_WIN32) && !defined(__ANDROID__)
 TEST(AddressSanitizer, VallocTest) {
   void *a = valloc(100);
   EXPECT_EQ(0U, (uintptr_t)a % kPageSize);
   free(a);
 }
 #endif
 
 #if SANITIZER_TEST_HAS_PVALLOC
char* MallocAndMemsetString(size_t size, char ch) {
   memset(s, ch, size);
   return s;
 }
 
 char* MallocAndMemsetString(size_t size) {
   return MallocAndMemsetString(size, 'z');
 }
 
-#if defined(__linux__) && !defined(ANDROID) && !defined(__ANDROID__)
+#if defined(__linux__) && !defined(__ANDROID__)
 #define READ_TEST(READ_N_BYTES)                                          \
   char *x = new char[10];                                                \
   int fd = open("/proc/self/stat", O_RDONLY);                            \
   ASSERT_GT(fd, 0);                                                      \
   EXPECT_DEATH(READ_N_BYTES,                                             \
                ASAN_PCRE_DOTALL                                          \
                "AddressSanitizer: heap-buffer-overflow"                  \
                ".* is located 0 bytes to the right of 10-byte region");  \
   close(fd);                                                             \
   delete [] x;                                                           \
 
 TEST(AddressSanitizer, pread) {
   READ_TEST(pread(fd, x, 15, 0));
 }
 
 TEST(AddressSanitizer, pread64) {
   READ_TEST(pread64(fd, x, 15, 0));
 }
 
 TEST(AddressSanitizer, read) {
   READ_TEST(read(fd, x, 15));
 }
-#endif  // defined(__linux__) && !defined(ANDROID) && !defined(__ANDROID__)
+#endif  // defined(__linux__) && !defined(__ANDROID__)
 
 // This test case fails
 // Clang optimizes memcpy/memset calls which lead to unaligned access
 TEST(AddressSanitizer, DISABLED_MemIntrinsicUnalignedAccessTest) {
   int size = Ident(4096);
   char *s = Ident((char*)malloc(size));
   EXPECT_DEATH(memset(s + size - 1, 0, 2), RightOOBWriteMessage(0));
   free(s);

 }
 
 // The new/delete/etc mismatch checks don't work on Android,
 //   as calls to new/delete go through malloc/free.
 // OS X support is tracked here:
 //   https://code.google.com/p/address-sanitizer/issues/detail?id=131
 // Windows support is tracked here:
 //   https://code.google.com/p/address-sanitizer/issues/detail?id=309
-#if !defined(ANDROID) && !defined(__ANDROID__) && \
+#if !defined(__ANDROID__) && \
     !defined(__APPLE__) && \
     !defined(_WIN32)
 static string MismatchStr(const string &str) {
   return string("AddressSanitizer: alloc-dealloc-mismatch \\(") + str;
 }
 
 TEST(AddressSanitizer, AllocDeallocMismatch) {
   EXPECT_DEATH(free(Ident(new int)),

lib/builtins/clear_cache.c

 
 #if __APPLE__
   #include <libkern/OSCacheControl.h>
 #endif
 #if defined(__NetBSD__) && defined(__arm__)
   #include <machine/sysarch.h>
 #endif
 
-#if defined(ANDROID) && defined(__mips__)
+#if defined(__ANDROID__) && defined(__mips__)
   #include <sys/cachectl.h>
 #endif
 
-#if defined(ANDROID) && defined(__arm__)
+#if defined(__ANDROID__) && defined(__arm__)
   #include <asm/unistd.h>
 #endif
 
 /*
  * The compiler generates calls to __clear_cache() when creating 
  * trampoline functions on the stack for use with nested functions.
  * It is expected to invalidate the instruction cache for the 
  * specified range.
  */
 
 void __clear_cache(void *start, void *end) {
 #if __i386__ || __x86_64__
 /*
  * Intel processors have a unified instruction and data cache
  * so there is nothing to do
  */
 #elif defined(__arm__) && !defined(__APPLE__)
     #if defined(__NetBSD__)
         struct arm_sync_icache_args arg;
 
         arg.addr = (uintptr_t)start;
         arg.len = (uintptr_t)end - (uintptr_t)start;
 
         sysarch(ARM_SYNC_ICACHE, &arg);
-    #elif defined(ANDROID)
+    #elif defined(__ANDROID__)
          const register int start_reg __asm("r0") = (int) (intptr_t) start;
          const register int end_reg __asm("r1") = (int) (intptr_t) end;
          const register int flags __asm("r2") = 0;
          const register int syscall_nr __asm("r7") = __ARM_NR_cacheflush;
         __asm __volatile("svc 0x0" : "=r"(start_reg)
             : "r"(syscall_nr), "r"(start_reg), "r"(end_reg), "r"(flags) : "r0");
          if (start_reg != 0) {
              compilerrt_abort();
          }
     #else
         compilerrt_abort();
     #endif
-#elif defined(ANDROID) && defined(__mips__)
+#elif defined(__ANDROID__) && defined(__mips__)
   const uintptr_t start_int = (uintptr_t) start;
   const uintptr_t end_int = (uintptr_t) end;
   _flush_cache(start, (end_int - start_int), BCACHE);
 #elif defined(__aarch64__) && !defined(__APPLE__)
   uint64_t xstart = (uint64_t)(uintptr_t) start;
   uint64_t xend = (uint64_t)(uintptr_t) end;
 
   // Get Cache Type Info

lib/sanitizer_common/sanitizer_platform.h

 #endif
 
 #if defined(_WIN32)
 # define SANITIZER_WINDOWS 1
 #else
 # define SANITIZER_WINDOWS 0
 #endif
 
-#if defined(__ANDROID__) || defined(ANDROID)
+#if defined(__ANDROID__)
 # define SANITIZER_ANDROID 1
 #else
 # define SANITIZER_ANDROID 0
 #endif
 
 #define SANITIZER_POSIX (SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_MAC)
 
 #if __LP64__ || defined(_WIN64)

lib/sanitizer_common/tests/sanitizer_test_utils.h

 static uint32_t global_seed = 0;
 
 static inline uint32_t my_rand() {
   return my_rand_r(&global_seed);
 }
 
 // Set availability of platform-specific functions.
 
-#if !defined(__APPLE__) && !defined(ANDROID) && !defined(__ANDROID__) && !defined(_WIN32)
+#if !defined(__APPLE__) && !defined(__ANDROID__) && !defined(_WIN32)
 # define SANITIZER_TEST_HAS_POSIX_MEMALIGN 1
 #else
 # define SANITIZER_TEST_HAS_POSIX_MEMALIGN 0
 #endif
 
-#if !defined(__APPLE__) && !defined(__FreeBSD__) && !defined(ANDROID) && \
+#if !defined(__APPLE__) && !defined(__FreeBSD__) && \
     !defined(__ANDROID__) && !defined(_WIN32)
 # define SANITIZER_TEST_HAS_MEMALIGN 1
 # define SANITIZER_TEST_HAS_PVALLOC 1
 # define SANITIZER_TEST_HAS_MALLOC_USABLE_SIZE 1
 #else
 # define SANITIZER_TEST_HAS_MEMALIGN 0
 # define SANITIZER_TEST_HAS_PVALLOC 0
 # define SANITIZER_TEST_HAS_MALLOC_USABLE_SIZE 0