[tsan] Implement `IsGlobalVar` for Darwin

[ismailp]

Summary

This is one of the oldest patches made for TSan on Darwin.
It could be wrong, and possibly missing some cases.

[dvyukov]

IsGlobalData is used only to detect global mutexes.
We use so-called "linker initialized" mutexes as global vars so that they are not subject to initialization and exit races:
https://code.google.com/p/chromium/codesearch#search/&q=LINKER_INITIALIZED&sq=package:chromium&type=cs
But we failed to fit an additional bit into mutex state to explicitly track such mutexes, so now tsan just conservatively assumes that all mutexes are linked-initialized.

I guess we need only SECT_DATA/SECT_COMMON as a mutex cannot be in a const section.
This can also improve performance for some programs.

Also this all must be #ifndef SANITIZER_GO. In fact, whole IsGlobalVar function is not needed for Go.

[glider]

lib/tsan/rtl/tsan_platform_mac.cc

43

Please keep the list of includes sorted alphabetically.

lib/tsan/rtl/tsan_platform_mac.cc

 #include <sys/syscall.h>
 #include <sys/time.h>
 #include <sys/types.h>
 #include <sys/resource.h>
 #include <sys/stat.h>
 #include <unistd.h>
 #include <errno.h>
 #include <sched.h>
+#include <mach-o/dyld.h>
+#include <dlfcn.h>
+#include <mach-o/loader.h>
+#include <mach-o/getsect.h>
+#include <mach/mach.h>
 
 namespace __tsan {
 
 static void *SignalSafeGetOrAllocate(uptr *dst, uptr size) {
   atomic_uintptr_t *a = (atomic_uintptr_t *)dst;
   void *val = (void *)atomic_load_relaxed(a);
   atomic_signal_fence(memory_order_acquire);  // Turns the previous load into
                                               // acquire wrt signals.
void cur_thread_finalize() {
   uptr thread_identity = (uptr)pthread_self();
   CHECK_NE(thread_identity, main_thread_identity);
   ThreadState **fake_tls = (ThreadState **)MemToShadow(thread_identity);
   internal_munmap(*fake_tls, sizeof(ThreadState));
   *fake_tls = nullptr;
 }
 #endif
 
+static bool IsInSegmentRange(uptr addr, mach_header_64 *mh,
+                             const char *segname, const char *sectname) {
+  const section_64 *sect = getsectbynamefromheader_64(mh, segname, sectname);
+  if (!sect)
+    return false;
+  return addr >= sect->addr && addr < (sect->addr + sect->size);
+}
+
+static bool IsInitedGlobal(uptr addr, mach_header_64 *mh) {
+  return IsInSegmentRange(addr, mh, SEG_DATA, SECT_DATA);
+}
+
+static bool IsUninitedGlobal(uptr addr, mach_header_64 *mh) {
+  return IsInSegmentRange(addr, mh, SEG_DATA, SECT_COMMON);
+}
+
+static bool IsStringLiteral(uptr addr, mach_header_64 *mh) {
+  return IsInSegmentRange(addr, mh, SEG_TEXT, "__cstring");
+}
+
+
+static bool IsInitedConst(uptr addr, mach_header_64 *mh) {
+  return IsInSegmentRange(addr, mh, SEG_TEXT, "__const");
+}
+
+static bool IsByteLiteral(uptr addr, mach_header_64 *mh, unsigned bytes) {
+  CHECK(bytes == 4 || bytes == 8);
+  return IsInSegmentRange(addr, mh, SEG_TEXT,
+                          bytes == 4 ? "__literal4" : "__literal8");
+}
+
 uptr GetShadowMemoryConsumption() {
   return 0;
 }
 
 void FlushShadowMemory() {
 }
 
 void WriteMemoryProfile(char *buf, uptr buf_size, uptr nthread, uptr nlive) {
int call_pthread_cancel_with_cleanup(int(*fn)(void *c, void *m,
   pthread_cleanup_push(cleanup, arg);
   res = fn(c, m, abstime);
   pthread_cleanup_pop(0);
   return res;
 }
 #endif
 
 bool IsGlobalVar(uptr addr) {
+  Dl_info info;
+  if (!dladdr((void*)addr, &info))
     return false;
+  mach_header_64 *mh = reinterpret_cast<mach_header_64*>(info.dli_fbase);
+  return IsUninitedGlobal(addr, mh) || IsInitedGlobal(addr, mh) ||
+      IsStringLiteral(addr, mh) || IsInitedConst(addr, mh) ||
+      IsByteLiteral(addr, mh, 4) || IsByteLiteral(addr, mh, 8);
 }
 
 }  // namespace __tsan
 
 #endif  // SANITIZER_MAC