[NFC] Extract InitializePlatformCommonFlags

[vitalybuka]

Summary

And move some Android specifi declarations from headers

[oontvoo]

compiler-rt/lib/sanitizer_common/sanitizer_linux.h

156–164

IMO, keeping them in one place is easier to maintain than scattering them to the .cpp files.
We've already put a few android-specific things here anyways.

[oontvoo]

The init-common-flag change LGTM, though.

[vitalybuka]

compiler-rt/lib/sanitizer_common/sanitizer_linux.h

156–164

The are kind of unrelated and we need to try to move __libc_iterate_dynamic_tls into platform specific file, probably sanitizer_linux_libcdep.cpp anyway

[oontvoo]

compiler-rt/lib/sanitizer_common/sanitizer_linux.h

156–164

Can we make *_libcdep.h to dump these weak-decls?
(that should also fix the FIXME you've put in lsan_common.cpp?)

compiler-rt/lib/lsan/lsan_common.cpp

 
 #if SANITIZER_FUCHSIA
 
 // Fuchsia handles all threads together with its own callback.
 static void ProcessThreads(SuspendedThreadsList const &, Frontier *) {}
 
 #else
 
+#if SANITIZER_ANDROID
+// FIXME: Move this out into *libcdep.cpp
+extern "C" SANITIZER_WEAK_ATTRIBUTE void __libc_iterate_dynamic_tls(
+    pid_t, void (*cb)(void *, void *, uptr, void *), void *);
+#endif
+
 // Scans thread data (stacks and TLS) for heap pointers.
 static void ProcessThreads(SuspendedThreadsList const &suspended_threads,
                            Frontier *frontier) {
   InternalMmapVector<uptr> registers;
   for (uptr i = 0; i < suspended_threads.ThreadCount(); i++) {
     tid_t os_id = static_cast<tid_t>(suspended_threads.GetThreadID(i));
     LOG_THREADS("Processing thread %d.\n", os_id);
     uptr stack_begin, stack_end, tls_begin, tls_end, cache_begin, cache_end;

compiler-rt/lib/sanitizer_common/sanitizer_flags.h

 void RegisterCommonFlags(FlagParser *parser,
                          CommonFlags *cf = &common_flags_dont_use);
 void RegisterIncludeFlags(FlagParser *parser, CommonFlags *cf);
 
 // Should be called after parsing all flags. Sets up common flag values
 // and perform initializations common to all sanitizers (e.g. setting
 // verbosity).
 void InitializeCommonFlags(CommonFlags *cf = &common_flags_dont_use);
+
+// Platform specific flags initialization.
+void InitializePlatformCommonFlags(CommonFlags *cf);
+
 }  // namespace __sanitizer
 
 #endif  // SANITIZER_FLAGS_H

compiler-rt/lib/sanitizer_common/sanitizer_flags.cpp

#undef COMMON_FLAG
   RegisterIncludeFlags(parser, cf);
 }
 
 void InitializeCommonFlags(CommonFlags *cf) {
   // need to record coverage to generate coverage report.
   cf->coverage |= cf->html_cov_report;
   SetVerbosity(cf->verbosity);
 
-#if SANITIZER_ANDROID
-  if (!HAS_ANDROID_THREAD_PROPERTIES_API)
-    cf->detect_leaks = false;
-#endif
+  InitializePlatformCommonFlags(cf);
 }
 
 }  // namespace __sanitizer

compiler-rt/lib/sanitizer_common/sanitizer_linux.h

 // 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 = 6;
 
 ALWAYS_INLINE uptr *get_android_tls_ptr() {
   return reinterpret_cast<uptr *>(&__get_tls()[TLS_SLOT_SANITIZER]);
 }
 
-// Bionic provides this API since S.
-extern "C" SANITIZER_WEAK_ATTRIBUTE void __libc_get_static_tls_bounds(void **,
-                                                                      void **);
-extern "C" SANITIZER_WEAK_ATTRIBUTE void __libc_iterate_dynamic_tls(
-    pid_t, void (*cb)(void *, void *, uptr, void *), void *);
-
-#define HAS_ANDROID_THREAD_PROPERTIES_API (&__libc_iterate_dynamic_tls != 0)
-
-#else
-#define HAS_ANDROID_THREAD_PROPERTIES_API (0)
 #endif  // SANITIZER_ANDROID
 
 }  // namespace __sanitizer
 
 #endif
 #endif  // SANITIZER_LINUX_H

compiler-rt/lib/sanitizer_common/sanitizer_linux_libcdep.cpp

if (hdr->p_type == PT_TLS && info->dlpi_tls_modid == 1) {
       *(uptr*)data = hdr->p_memsz;
       break;
     }
   }
   return 0;
 }
 #endif  // SANITIZER_NETBSD
 
+#if SANITIZER_ANDROID
+// Bionic provides this API since S.
+extern "C" SANITIZER_WEAK_ATTRIBUTE void __libc_get_static_tls_bounds(void **,
+                                                                      void **);
+#endif
+
 #if !SANITIZER_GO
 static void GetTls(uptr *addr, uptr *size) {
 #if SANITIZER_ANDROID
-  if (HAS_ANDROID_THREAD_PROPERTIES_API) {
+  if (&__libc_get_static_tls_bounds) {
     void *start_addr;
     void *end_addr;
     __libc_get_static_tls_bounds(&start_addr, &end_addr);
     *addr = reinterpret_cast<uptr>(start_addr);
     *size =
         reinterpret_cast<uptr>(end_addr) - reinterpret_cast<uptr>(start_addr);
   } else {
     *addr = 0;
uptr MapDynamicShadow(uptr shadow_size_bytes, uptr shadow_scale,
   const uptr shadow_start = RoundUpTo(map_start + left_padding, alignment);
 
   UnmapFromTo(map_start, shadow_start - left_padding);
   UnmapFromTo(shadow_start + shadow_size, map_start + map_size);
 
   return shadow_start;
 }
 
+void InitializePlatformCommonFlags(CommonFlags *cf) {
+#if SANITIZER_ANDROID
+  if (&__libc_get_static_tls_bounds == nullptr)
+    cf->detect_leaks = false;
+#endif
+}
+
 } // namespace __sanitizer
 
 #endif

compiler-rt/lib/sanitizer_common/sanitizer_mac.cpp

bool GetRandom(void *buffer, uptr length, bool blocking) {
   REAL(arc4random_buf)(buffer, length);
   return true;
 }
 
 u32 GetNumberOfCPUs() {
   return (u32)sysconf(_SC_NPROCESSORS_ONLN);
 }
 
+void InitializePlatformCommonFlags(CommonFlags *cf) {}
+
 }  // namespace __sanitizer
 
 #endif  // SANITIZER_MAC

compiler-rt/lib/sanitizer_common/sanitizer_win.cpp

if (common_flags()->log_to_syslog) {
     } while (filename_length >= filename.size());
     TraceLoggingWrite(g_asan_provider, "AsanReportEvent",
                       TraceLoggingValue(filename.begin(), "ExecutableName"),
                       TraceLoggingValue(buffer, "AsanReportContents"));
   }
 }
 #endif // SANITIZER_WIN_TRACE
 
+void InitializePlatformCommonFlags(CommonFlags *cf) {}
+
 }  // namespace __sanitizer
 
 #endif  // _WIN32