[scudo][standalone] Clean-up of Android specific compilation.

[cferris]

Summary

It is possible to build with ANDROID defined, but without
bionic. However, all of the code under the SCUDO_ANDROID
assumes that it is being compiled for android with bionic.
Make this explicit by changing SCUDO_ANDROID to SCUDO_ANDROID_BIONIC
and set it only if it is really building for bionic.

In addition, use bionic headers for some values rather than redefining
them.

Verified that this builds properly on aosp master.

[cryptoad]

We might have to discuss this.
I either compile Android binaries by compiling it with the Scudo sources, or I compile the platform with Scudo replacing jemalloc in Android.
Both work with -D_BIONIC=1 for the Bionic version, which can probably be replaced by BIONIC.
So I am not sure why compiling it on Android but not part of Bionic didn't work for you, I can give you the compilation command lines I used tomorrow.

[cferris]

This isn't quite right for the way people expect this to compile, so abandon this change.

compiler-rt/lib/scudo/standalone/allocator_config.h

 
 struct FuchsiaConfig {
   // 1GB Regions
   typedef SizeClassAllocator64<DefaultSizeClassMap, 30U> Primary;
   template <class A>
   using TSDRegistryT = TSDRegistrySharedT<A, 8U>; // Shared, max 8 TSDs.
 };
 
-#if SCUDO_ANDROID
+#if SCUDO_ANDROID_BIONIC
 typedef AndroidConfig Config;
 #elif SCUDO_FUCHSIA
 typedef FuchsiaConfig Config;
 #else
 typedef DefaultConfig Config;
 #endif
 
 } // namespace scudo
 
 #endif // SCUDO_ALLOCATOR_CONFIG_H_

compiler-rt/lib/scudo/standalone/common.h

 }
 
 // Platform specific functions.
 
 extern uptr PageSizeCached;
 uptr getPageSizeSlow();
 INLINE uptr getPageSizeCached() {
   // Bionic uses a hardcoded value.
-  if (SCUDO_ANDROID)
+  if (SCUDO_ANDROID_BIONIC)
     return 4096U;
   if (LIKELY(PageSizeCached))
     return PageSizeCached;
   return getPageSizeSlow();
 }
 
 u32 getNumberOfCPUs();
 

compiler-rt/lib/scudo/standalone/linux.h

 
 #if SCUDO_LINUX
 
 namespace scudo {
 
 // MapPlatformData is unused on Linux, define it as a minimally sized structure.
 struct MapPlatformData {};
 
-#if SCUDO_ANDROID
+#if SCUDO_ANDROID_BIONIC
 
 #if defined(__aarch64__)
 #define __get_tls()                                                            \
   ({                                                                           \
     void **__v;                                                                \
     __asm__("mrs %0, tpidr_el0" : "=r"(__v));                                  \
     __v;                                                                       \
   })
({                                                                           \
     void **__v;                                                                \
     __asm__("mov %%fs:0, %0" : "=r"(__v));                                     \
     __v;                                                                       \
   })
 #else
 #error "Unsupported architecture."
 #endif
 
-// The Android Bionic team has allocated a TLS slot for sanitizers starting
-// with Q, given that Android currently doesn't support ELF TLS. It is used to
-// store sanitizer thread specific data.
-static const int TLS_SLOT_SANITIZER = 8; // TODO(kostyak): 6 for Q!!
+// To get the TLS_SLOT_SANITIZER define from bionic headers.
+#include <private/bionic_asm_tls.h>
 
 ALWAYS_INLINE uptr *getAndroidTlsPtr() {
   return reinterpret_cast<uptr *>(&__get_tls()[TLS_SLOT_SANITIZER]);
 }
 
-#endif // SCUDO_ANDROID
+#endif // SCUDO_ANDROID_BIONIC
 
 } // namespace scudo
 
 #endif // SCUDO_LINUX
 
 #endif // SCUDO_LINUX_H_

compiler-rt/lib/scudo/standalone/linux.cpp

 #include <string.h>
 #include <sys/mman.h>
 #include <sys/stat.h>
 #include <sys/syscall.h>
 #include <sys/time.h>
 #include <time.h>
 #include <unistd.h>
 
-#if SCUDO_ANDROID
+#if SCUDO_ANDROID_BIONIC
 #include <sys/prctl.h>
-// Definitions of prctl arguments to set a vma name in Android kernels.
-#define ANDROID_PR_SET_VMA 0x53564d41
-#define ANDROID_PR_SET_VMA_ANON_NAME 0
 #endif
 
 namespace scudo {
 
 uptr getPageSize() { return static_cast<uptr>(sysconf(_SC_PAGESIZE)); }
 
 void NORETURN die() { abort(); }
 
if (Addr) {
     MmapFlags |= MAP_FIXED;
   }
   void *P = mmap(Addr, Size, MmapProt, MmapFlags, -1, 0);
   if (P == MAP_FAILED) {
     if (!(Flags & MAP_ALLOWNOMEM) || errno != ENOMEM)
       dieOnMapUnmapError(errno == ENOMEM);
     return nullptr;
   }
-#if SCUDO_ANDROID
+#if SCUDO_ANDROID_BIONIC
   if (!(Flags & MAP_NOACCESS))
-    prctl(ANDROID_PR_SET_VMA, ANDROID_PR_SET_VMA_ANON_NAME, P, Size, Name);
+    prctl(PR_SET_VMA, PR_SET_VMA_ANON_NAME, P, Size, Name);
 #endif
   return P;
 }
 
 void unmap(void *Addr, uptr Size, UNUSED uptr Flags,
            UNUSED MapPlatformData *Data) {
   if (munmap(Addr, Size) != 0)
     dieOnMapUnmapError();

compiler-rt/lib/scudo/standalone/platform.h

 
 #if defined(__linux__)
 #define SCUDO_LINUX 1
 #else
 #define SCUDO_LINUX 0
 #endif
 
 #if defined(__ANDROID__)
-#define SCUDO_ANDROID 1
+// Include this to get the __BIONIC__ define.
+#include <sys/cdefs.h>
+
+#if defined(__BIONIC__)
+#define SCUDO_ANDROID_BIONIC 1
+#else
+#define SCUDO_ANDROID_BIONIC 0
+#endif
+
 #else
-#define SCUDO_ANDROID 0
+#define SCUDO_ANDROID_BIONIC 0
 #endif
 
 #if defined(__Fuchsia__)
 #define SCUDO_FUCHSIA 1
 #else
 #define SCUDO_FUCHSIA 0
 #endif
 

compiler-rt/lib/scudo/standalone/tsd_shared.h

ALWAYS_INLINE TSD<Allocator> *getTSDAndLock(bool *UnlockRequired) {
     if (TSD->tryLock())
       return TSD;
     // If that fails, go down the slow path.
     return getTSDAndLockSlow(TSD);
   }
 
 private:
   ALWAYS_INLINE void setCurrentTSD(TSD<Allocator> *CurrentTSD) {
-#if SCUDO_ANDROID
+#if SCUDO_ANDROID_BIONIC
     *getAndroidTlsPtr() = reinterpret_cast<uptr>(CurrentTSD);
 #elif SCUDO_LINUX
     ThreadTSD = CurrentTSD;
 #else
     CHECK_EQ(
         pthread_setspecific(PThreadKey, reinterpret_cast<void *>(CurrentTSD)),
         0);
 #endif
   }
 
   ALWAYS_INLINE TSD<Allocator> *getCurrentTSD() {
-#if SCUDO_ANDROID
+#if SCUDO_ANDROID_BIONIC
     return reinterpret_cast<TSD<Allocator> *>(*getAndroidTlsPtr());
 #elif SCUDO_LINUX
     return ThreadTSD;
 #else
     return reinterpret_cast<TSD<Allocator> *>(pthread_getspecific(PThreadKey));
 #endif
   }
 
#endif
   pthread_key_t PThreadKey;
   atomic_u32 CurrentIndex;
   u32 NumberOfTSDs;
   TSD<Allocator> *TSDs;
   u32 NumberOfCoPrimes;
   u32 CoPrimes[MaxTSDCount];
   bool Initialized;
   HybridMutex Mutex;
-#if SCUDO_LINUX && !SCUDO_ANDROID
+#if SCUDO_LINUX && !SCUDO_ANDROID_BIONIC
   static THREADLOCAL TSD<Allocator> *ThreadTSD;
 #endif
 };
 
-#if SCUDO_LINUX && !SCUDO_ANDROID
+#if SCUDO_LINUX && !SCUDO_ANDROID_BIONIC
 template <class Allocator, u32 MaxTSDCount>
 THREADLOCAL TSD<Allocator>
     *TSDRegistrySharedT<Allocator, MaxTSDCount>::ThreadTSD;
 #endif
 
 } // namespace scudo
 
 #endif // SCUDO_TSD_SHARED_H_

compiler-rt/lib/scudo/standalone/wrappers_c.h

 //===-- wrappers_c.h --------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SCUDO_WRAPPERS_C_H_
 #define SCUDO_WRAPPERS_C_H_
 
 #include "platform.h"
 #include "stats.h"
 
 // Bionic's struct mallinfo consists of size_t (mallinfo(3) uses int).
-#if SCUDO_ANDROID
+#if SCUDO_ANDROID_BIONIC
 typedef size_t __scudo_mallinfo_data_t;
 #else
 typedef int __scudo_mallinfo_data_t;
 #endif
 
 struct __scudo_mallinfo {
   __scudo_mallinfo_data_t arena;
   __scudo_mallinfo_data_t ordblks;

compiler-rt/lib/scudo/standalone/wrappers_c.cpp

 //===-- wrappers_c.cpp ------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "platform.h"
 
 // Skip this compilation unit if compiled as part of Bionic.
-#if !SCUDO_ANDROID || !_BIONIC
+#if !SCUDO_ANDROID_BIONIC
 
 #include "allocator_config.h"
 #include "wrappers_c.h"
 #include "wrappers_c_checks.h"
 
 #include <stdint.h>
 #include <stdio.h>
 

 #include "wrappers_c.inc"
 #undef SCUDO_ALLOCATOR
 #undef SCUDO_PREFIX
 
 INTERFACE void __scudo_print_stats(void) { Allocator.printStats(); }
 
 } // extern "C"
 
-#endif // !SCUDO_ANDROID || !_BIONIC
+#endif // !SCUDO_ANDROID_BIONIC

compiler-rt/lib/scudo/standalone/wrappers_c.inc

INTERFACE WEAK struct SCUDO_MALLINFO SCUDO_PREFIX(mallinfo)(void) {
   return Info;
 }
 
 INTERFACE WEAK void *SCUDO_PREFIX(malloc)(size_t size) {
   return scudo::setErrnoOnNull(SCUDO_ALLOCATOR.allocate(
       size, scudo::Chunk::Origin::Malloc, SCUDO_MALLOC_ALIGNMENT));
 }
 
-#if SCUDO_ANDROID
+#if SCUDO_ANDROID_BIONIC
 INTERFACE WEAK size_t SCUDO_PREFIX(malloc_usable_size)(const void *ptr) {
 #else
 INTERFACE WEAK size_t SCUDO_PREFIX(malloc_usable_size)(void *ptr) {
 #endif
   return SCUDO_ALLOCATOR.getUsableSize(ptr);
 }
 
 INTERFACE WEAK void *SCUDO_PREFIX(memalign)(size_t alignment, size_t size) {
   // Android rounds up the alignment to a power of two if it isn't one.
-  if (SCUDO_ANDROID) {
+  if (SCUDO_ANDROID_BIONIC) {
     if (UNLIKELY(!alignment)) {
       alignment = 1U;
     } else {
       if (UNLIKELY(!scudo::isPowerOfTwo(alignment)))
         alignment = scudo::roundUpToPowerOfTwo(alignment);
     }
   } else {
     if (UNLIKELY(!scudo::isPowerOfTwo(alignment))) {

 
 INTERFACE WEAK void *SCUDO_PREFIX(valloc)(size_t size) {
   return scudo::setErrnoOnNull(SCUDO_ALLOCATOR.allocate(
       size, scudo::Chunk::Origin::Memalign, scudo::getPageSizeCached()));
 }
 
 // Bionic wants a function named PREFIX_iterate and not PREFIX_malloc_iterate
 // which is somewhat inconsistent with the rest, workaround that.
-#if SCUDO_ANDROID && _BIONIC
+#if SCUDO_ANDROID_BIONIC
 #define SCUDO_ITERATE iterate
 #else
 #define SCUDO_ITERATE malloc_iterate
 #endif
 
 INTERFACE WEAK int SCUDO_PREFIX(SCUDO_ITERATE)(
     uintptr_t base, size_t size,
     void (*callback)(uintptr_t base, size_t size, void *arg), void *arg) {

compiler-rt/lib/scudo/standalone/wrappers_c_bionic.cpp

 //===-- wrappers_c_bionic.cpp -----------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "platform.h"
 
 // This is only used when compiled as part of Bionic.
-#if SCUDO_ANDROID && _BIONIC
+#if SCUDO_ANDROID_BIONIC
 
 #include "allocator_config.h"
 #include "wrappers_c.h"
 #include "wrappers_c_checks.h"
 
 #include <stdint.h>
 #include <stdio.h>
 

 // allocators, which will result in a slight increase in memory footprint.
 INTERFACE void __scudo_print_stats(void) {
   Allocator.printStats();
   SvelteAllocator.printStats();
 }
 
 } // extern "C"
 
-#endif // SCUDO_ANDROID && _BIONIC
+#endif // SCUDO_ANDROID_BIONIC

compiler-rt/lib/scudo/standalone/wrappers_cpp.cpp

 //===-- wrappers_cpp.cpp ----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "platform.h"
 
 // Skip this compilation unit if compiled as part of Bionic.
-#if !SCUDO_ANDROID || !_BIONIC
+#if !SCUDO_ANDROID_BIONIC
 
 #include "allocator_config.h"
 
 #include <stdint.h>
 
 extern scudo::Allocator<scudo::Config> *AllocatorPtr;
 
 namespace std {
AllocatorPtr->deallocate(ptr, scudo::Chunk::Origin::New, size,
                            static_cast<scudo::uptr>(align));
 }
 INTERFACE WEAK void operator delete[](void *ptr, size_t size,
                                       std::align_val_t align) NOEXCEPT {
   AllocatorPtr->deallocate(ptr, scudo::Chunk::Origin::NewArray, size,
                            static_cast<scudo::uptr>(align));
 }
 
-#endif // !SCUDO_ANDROID || !_BIONIC
+#endif // !SCUDO_ANDROID_BIONIC