contrib/compiler-rt/lib/sanitizer_common/sanitizer_mac.cc

   1 //===-- sanitizer_mac.cc --------------------------------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file is shared between various sanitizers' runtime libraries and
  11 // implements OSX-specific functions.
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "sanitizer_platform.h"
  15 #if SANITIZER_MAC
  16 #include "sanitizer_mac.h"
  17
  18 // Use 64-bit inodes in file operations. ASan does not support OS X 10.5, so
  19 // the clients will most certainly use 64-bit ones as well.
  20 #ifndef _DARWIN_USE_64_BIT_INODE
  21 #define _DARWIN_USE_64_BIT_INODE 1
  22 #endif
  23 #include <stdio.h>
  24
  25 #include "sanitizer_common.h"
  26 #include "sanitizer_flags.h"
  27 #include "sanitizer_internal_defs.h"
  28 #include "sanitizer_libc.h"
  29 #include "sanitizer_placement_new.h"
  30 #include "sanitizer_platform_limits_posix.h"
  31 #include "sanitizer_procmaps.h"
  32
  33 #if !SANITIZER_IOS
  34 #include <crt_externs.h>  // for _NSGetEnviron
  35 #else
  36 extern char **environ;
  37 #endif
  38
  39 #if defined(__has_include) && __has_include(<os/trace.h>)
  40 #define SANITIZER_OS_TRACE 1
  41 #include <os/trace.h>
  42 #else
  43 #define SANITIZER_OS_TRACE 0
  44 #endif
  45
  46 #if !SANITIZER_IOS
  47 #include <crt_externs.h>  // for _NSGetArgv and _NSGetEnviron
  48 #else
  49 extern "C" {
  50   extern char ***_NSGetArgv(void);
  51 }
  52 #endif
  53
  54 #include <asl.h>
  55 #include <dlfcn.h>  // for dladdr()
  56 #include <errno.h>
  57 #include <fcntl.h>
  58 #include <libkern/OSAtomic.h>
  59 #include <mach-o/dyld.h>
  60 #include <mach/mach.h>
  61 #include <mach/vm_statistics.h>
  62 #include <pthread.h>
  63 #include <sched.h>
  64 #include <signal.h>
  65 #include <stdlib.h>
  66 #include <sys/mman.h>
  67 #include <sys/resource.h>
  68 #include <sys/stat.h>
  69 #include <sys/sysctl.h>
  70 #include <sys/types.h>
  71 #include <sys/wait.h>
  72 #include <unistd.h>
  73 #include <util.h>
  74
  75 // From <crt_externs.h>, but we don't have that file on iOS.
  76 extern "C" {
  77   extern char ***_NSGetArgv(void);
  78   extern char ***_NSGetEnviron(void);
  79 }
  80
  81 // From <mach/mach_vm.h>, but we don't have that file on iOS.
  82 extern "C" {
  83   extern kern_return_t mach_vm_region_recurse(
  84     vm_map_t target_task,
  85     mach_vm_address_t *address,
  86     mach_vm_size_t *size,
  87     natural_t *nesting_depth,
  88     vm_region_recurse_info_t info,
  89     mach_msg_type_number_t *infoCnt);
  90 }
  91
  92 namespace __sanitizer {
  93
  94 #include "sanitizer_syscall_generic.inc"
  95
  96 // Direct syscalls, don't call libmalloc hooks (but not available on 10.6).
  97 extern "C" void *__mmap(void *addr, size_t len, int prot, int flags, int fildes,
  98                         off_t off) SANITIZER_WEAK_ATTRIBUTE;
  99 extern "C" int __munmap(void *, size_t) SANITIZER_WEAK_ATTRIBUTE;
 100
 101 // ---------------------- sanitizer_libc.h
 102 uptr internal_mmap(void *addr, size_t length, int prot, int flags,
 103                    int fd, u64 offset) {
 104   if (fd == -1) fd = VM_MAKE_TAG(VM_MEMORY_ANALYSIS_TOOL);
 105   if (&__mmap) return (uptr)__mmap(addr, length, prot, flags, fd, offset);
 106   return (uptr)mmap(addr, length, prot, flags, fd, offset);
 107 }
 108
 109 uptr internal_munmap(void *addr, uptr length) {
 110   if (&__munmap) return __munmap(addr, length);
 111   return munmap(addr, length);
 112 }
 113
 114 int internal_mprotect(void *addr, uptr length, int prot) {
 115   return mprotect(addr, length, prot);
 116 }
 117
 118 uptr internal_close(fd_t fd) {
 119   return close(fd);
 120 }
 121
 122 uptr internal_open(const char *filename, int flags) {
 123   return open(filename, flags);
 124 }
 125
 126 uptr internal_open(const char *filename, int flags, u32 mode) {
 127   return open(filename, flags, mode);
 128 }
 129
 130 uptr internal_read(fd_t fd, void *buf, uptr count) {
 131   return read(fd, buf, count);
 132 }
 133
 134 uptr internal_write(fd_t fd, const void *buf, uptr count) {
 135   return write(fd, buf, count);
 136 }
 137
 138 uptr internal_stat(const char *path, void *buf) {
 139   return stat(path, (struct stat *)buf);
 140 }
 141
 142 uptr internal_lstat(const char *path, void *buf) {
 143   return lstat(path, (struct stat *)buf);
 144 }
 145
 146 uptr internal_fstat(fd_t fd, void *buf) {
 147   return fstat(fd, (struct stat *)buf);
 148 }
 149
 150 uptr internal_filesize(fd_t fd) {
 151   struct stat st;
 152   if (internal_fstat(fd, &st))
 153     return -1;
 154   return (uptr)st.st_size;
 155 }
 156
 157 uptr internal_dup2(int oldfd, int newfd) {
 158   return dup2(oldfd, newfd);
 159 }
 160
 161 uptr internal_readlink(const char *path, char *buf, uptr bufsize) {
 162   return readlink(path, buf, bufsize);
 163 }
 164
 165 uptr internal_unlink(const char *path) {
 166   return unlink(path);
 167 }
 168
 169 uptr internal_sched_yield() {
 170   return sched_yield();
 171 }
 172
 173 void internal__exit(int exitcode) {
 174   _exit(exitcode);
 175 }
 176
 177 unsigned int internal_sleep(unsigned int seconds) {
 178   return sleep(seconds);
 179 }
 180
 181 uptr internal_getpid() {
 182   return getpid();
 183 }
 184
 185 int internal_sigaction(int signum, const void *act, void *oldact) {
 186   return sigaction(signum,
 187                    (struct sigaction *)act, (struct sigaction *)oldact);
 188 }
 189
 190 void internal_sigfillset(__sanitizer_sigset_t *set) { sigfillset(set); }
 191
 192 uptr internal_sigprocmask(int how, __sanitizer_sigset_t *set,
 193                           __sanitizer_sigset_t *oldset) {
 194   return sigprocmask(how, set, oldset);
 195 }
 196
 197 // Doesn't call pthread_atfork() handlers (but not available on 10.6).
 198 extern "C" pid_t __fork(void) SANITIZER_WEAK_ATTRIBUTE;
 199
 200 int internal_fork() {
 201   if (&__fork)
 202     return __fork();
 203   return fork();
 204 }
 205
 206 int internal_forkpty(int *amaster) {
 207   int master, slave;
 208   if (openpty(&master, &slave, nullptr, nullptr, nullptr) == -1) return -1;
 209   int pid = internal_fork();
 210   if (pid == -1) {
 211     close(master);
 212     close(slave);
 213     return -1;
 214   }
 215   if (pid == 0) {
 216     close(master);
 217     if (login_tty(slave) != 0) {
 218       // We already forked, there's not much we can do.  Let's quit.
 219       Report("login_tty failed (errno %d)\n", errno);
 220       internal__exit(1);
 221     }
 222   } else {
 223     *amaster = master;
 224     close(slave);
 225   }
 226   return pid;
 227 }
 228
 229 uptr internal_rename(const char *oldpath, const char *newpath) {
 230   return rename(oldpath, newpath);
 231 }
 232
 233 uptr internal_ftruncate(fd_t fd, uptr size) {
 234   return ftruncate(fd, size);
 235 }
 236
 237 uptr internal_execve(const char *filename, char *const argv[],
 238                      char *const envp[]) {
 239   return execve(filename, argv, envp);
 240 }
 241
 242 uptr internal_waitpid(int pid, int *status, int options) {
 243   return waitpid(pid, status, options);
 244 }
 245
 246 // ----------------- sanitizer_common.h
 247 bool FileExists(const char *filename) {
 248   struct stat st;
 249   if (stat(filename, &st))
 250     return false;
 251   // Sanity check: filename is a regular file.
 252   return S_ISREG(st.st_mode);
 253 }
 254
 255 tid_t GetTid() {
 256   tid_t tid;
 257   pthread_threadid_np(nullptr, &tid);
 258   return tid;
 259 }
 260
 261 void GetThreadStackTopAndBottom(bool at_initialization, uptr *stack_top,
 262                                 uptr *stack_bottom) {
 263   CHECK(stack_top);
 264   CHECK(stack_bottom);
 265   uptr stacksize = pthread_get_stacksize_np(pthread_self());
 266   // pthread_get_stacksize_np() returns an incorrect stack size for the main
 267   // thread on Mavericks. See
 268   // https://github.com/google/sanitizers/issues/261
 269   if ((GetMacosVersion() >= MACOS_VERSION_MAVERICKS) && at_initialization &&
 270       stacksize == (1 << 19))  {
 271     struct rlimit rl;
 272     CHECK_EQ(getrlimit(RLIMIT_STACK, &rl), 0);
 273     // Most often rl.rlim_cur will be the desired 8M.
 274     if (rl.rlim_cur < kMaxThreadStackSize) {
 275       stacksize = rl.rlim_cur;
 276     } else {
 277       stacksize = kMaxThreadStackSize;
 278     }
 279   }
 280   void *stackaddr = pthread_get_stackaddr_np(pthread_self());
 281   *stack_top = (uptr)stackaddr;
 282   *stack_bottom = *stack_top - stacksize;
 283 }
 284
 285 char **GetEnviron() {
 286 #if !SANITIZER_IOS
 287   char ***env_ptr = _NSGetEnviron();
 288   if (!env_ptr) {
 289     Report("_NSGetEnviron() returned NULL. Please make sure __asan_init() is "
 290            "called after libSystem_initializer().\n");
 291     CHECK(env_ptr);
 292   }
 293   char **environ = *env_ptr;
 294 #endif
 295   CHECK(environ);
 296   return environ;
 297 }
 298
 299 const char *GetEnv(const char *name) {
 300   char **env = GetEnviron();
 301   uptr name_len = internal_strlen(name);
 302   while (*env != 0) {
 303     uptr len = internal_strlen(*env);
 304     if (len > name_len) {
 305       const char *p = *env;
 306       if (!internal_memcmp(p, name, name_len) &&
 307           p[name_len] == '=') {  // Match.
 308         return *env + name_len + 1;  // String starting after =.
 309       }
 310     }
 311     env++;
 312   }
 313   return 0;
 314 }
 315
 316 uptr ReadBinaryName(/*out*/char *buf, uptr buf_len) {
 317   CHECK_LE(kMaxPathLength, buf_len);
 318
 319   // On OS X the executable path is saved to the stack by dyld. Reading it
 320   // from there is much faster than calling dladdr, especially for large
 321   // binaries with symbols.
 322   InternalScopedString exe_path(kMaxPathLength);
 323   uint32_t size = exe_path.size();
 324   if (_NSGetExecutablePath(exe_path.data(), &size) == 0 &&
 325       realpath(exe_path.data(), buf) != 0) {
 326     return internal_strlen(buf);
 327   }
 328   return 0;
 329 }
 330
 331 uptr ReadLongProcessName(/*out*/char *buf, uptr buf_len) {
 332   return ReadBinaryName(buf, buf_len);
 333 }
 334
 335 void ReExec() {
 336   UNIMPLEMENTED();
 337 }
 338
 339 uptr GetPageSize() {
 340   return sysconf(_SC_PAGESIZE);
 341 }
 342
 343 BlockingMutex::BlockingMutex() {
 344   internal_memset(this, 0, sizeof(*this));
 345 }
 346
 347 void BlockingMutex::Lock() {
 348   CHECK(sizeof(OSSpinLock) <= sizeof(opaque_storage_));
 349   CHECK_EQ(OS_SPINLOCK_INIT, 0);
 350   CHECK_EQ(owner_, 0);
 351   OSSpinLockLock((OSSpinLock*)&opaque_storage_);
 352 }
 353
 354 void BlockingMutex::Unlock() {
 355   OSSpinLockUnlock((OSSpinLock*)&opaque_storage_);
 356 }
 357
 358 void BlockingMutex::CheckLocked() {
 359   CHECK_NE(*(OSSpinLock*)&opaque_storage_, 0);
 360 }
 361
 362 u64 NanoTime() {
 363   return 0;
 364 }
 365
 366 uptr GetTlsSize() {
 367   return 0;
 368 }
 369
 370 void InitTlsSize() {
 371 }
 372
 373 uptr TlsBaseAddr() {
 374   uptr segbase = 0;
 375 #if defined(__x86_64__)
 376   asm("movq %%gs:0,%0" : "=r"(segbase));
 377 #elif defined(__i386__)
 378   asm("movl %%gs:0,%0" : "=r"(segbase));
 379 #endif
 380   return segbase;
 381 }
 382
 383 // The size of the tls on darwin does not appear to be well documented,
 384 // however the vm memory map suggests that it is 1024 uptrs in size,
 385 // with a size of 0x2000 bytes on x86_64 and 0x1000 bytes on i386.
 386 uptr TlsSize() {
 387 #if defined(__x86_64__) || defined(__i386__)
 388   return 1024 * sizeof(uptr);
 389 #else
 390   return 0;
 391 #endif
 392 }
 393
 394 void GetThreadStackAndTls(bool main, uptr *stk_addr, uptr *stk_size,
 395                           uptr *tls_addr, uptr *tls_size) {
 396 #if !SANITIZER_GO
 397   uptr stack_top, stack_bottom;
 398   GetThreadStackTopAndBottom(main, &stack_top, &stack_bottom);
 399   *stk_addr = stack_bottom;
 400   *stk_size = stack_top - stack_bottom;
 401   *tls_addr = TlsBaseAddr();
 402   *tls_size = TlsSize();
 403 #else
 404   *stk_addr = 0;
 405   *stk_size = 0;
 406   *tls_addr = 0;
 407   *tls_size = 0;
 408 #endif
 409 }
 410
 411 void ListOfModules::init() {
 412   clear();
 413   MemoryMappingLayout memory_mapping(false);
 414   memory_mapping.DumpListOfModules(&modules_);
 415 }
 416
 417 HandleSignalMode GetHandleSignalMode(int signum) {
 418   // Handling fatal signals on watchOS and tvOS devices is disallowed.
 419   if ((SANITIZER_WATCHOS || SANITIZER_TVOS) && !(SANITIZER_IOSSIM))
 420     return kHandleSignalNo;
 421   switch (signum) {
 422     case SIGABRT:
 423       return common_flags()->handle_abort;
 424     case SIGILL:
 425       return common_flags()->handle_sigill;
 426     case SIGFPE:
 427       return common_flags()->handle_sigfpe;
 428     case SIGSEGV:
 429       return common_flags()->handle_segv;
 430     case SIGBUS:
 431       return common_flags()->handle_sigbus;
 432   }
 433   return kHandleSignalNo;
 434 }
 435
 436 MacosVersion cached_macos_version = MACOS_VERSION_UNINITIALIZED;
 437
 438 MacosVersion GetMacosVersionInternal() {
 439   int mib[2] = { CTL_KERN, KERN_OSRELEASE };
 440   char version[100];
 441   uptr len = 0, maxlen = sizeof(version) / sizeof(version[0]);
 442   for (uptr i = 0; i < maxlen; i++) version[i] = '\0';
 443   // Get the version length.
 444   CHECK_NE(sysctl(mib, 2, 0, &len, 0, 0), -1);
 445   CHECK_LT(len, maxlen);
 446   CHECK_NE(sysctl(mib, 2, version, &len, 0, 0), -1);
 447   switch (version[0]) {
 448     case '9': return MACOS_VERSION_LEOPARD;
 449     case '1': {
 450       switch (version[1]) {
 451         case '0': return MACOS_VERSION_SNOW_LEOPARD;
 452         case '1': return MACOS_VERSION_LION;
 453         case '2': return MACOS_VERSION_MOUNTAIN_LION;
 454         case '3': return MACOS_VERSION_MAVERICKS;
 455         case '4': return MACOS_VERSION_YOSEMITE;
 456         default:
 457           if (IsDigit(version[1]))
 458             return MACOS_VERSION_UNKNOWN_NEWER;
 459           else
 460             return MACOS_VERSION_UNKNOWN;
 461       }
 462     }
 463     default: return MACOS_VERSION_UNKNOWN;
 464   }
 465 }
 466
 467 MacosVersion GetMacosVersion() {
 468   atomic_uint32_t *cache =
 469       reinterpret_cast<atomic_uint32_t*>(&cached_macos_version);
 470   MacosVersion result =
 471       static_cast<MacosVersion>(atomic_load(cache, memory_order_acquire));
 472   if (result == MACOS_VERSION_UNINITIALIZED) {
 473     result = GetMacosVersionInternal();
 474     atomic_store(cache, result, memory_order_release);
 475   }
 476   return result;
 477 }
 478
 479 bool PlatformHasDifferentMemcpyAndMemmove() {
 480   // On OS X 10.7 memcpy() and memmove() are both resolved
 481   // into memmove$VARIANT$sse42.
 482   // See also https://github.com/google/sanitizers/issues/34.
 483   // TODO(glider): need to check dynamically that memcpy() and memmove() are
 484   // actually the same function.
 485   return GetMacosVersion() == MACOS_VERSION_SNOW_LEOPARD;
 486 }
 487
 488 uptr GetRSS() {
 489   struct task_basic_info info;
 490   unsigned count = TASK_BASIC_INFO_COUNT;
 491   kern_return_t result =
 492       task_info(mach_task_self(), TASK_BASIC_INFO, (task_info_t)&info, &count);
 493   if (UNLIKELY(result != KERN_SUCCESS)) {
 494     Report("Cannot get task info. Error: %d\n", result);
 495     Die();
 496   }
 497   return info.resident_size;
 498 }
 499
 500 void *internal_start_thread(void(*func)(void *arg), void *arg) {
 501   // Start the thread with signals blocked, otherwise it can steal user signals.
 502   __sanitizer_sigset_t set, old;
 503   internal_sigfillset(&set);
 504   internal_sigprocmask(SIG_SETMASK, &set, &old);
 505   pthread_t th;
 506   pthread_create(&th, 0, (void*(*)(void *arg))func, arg);
 507   internal_sigprocmask(SIG_SETMASK, &old, 0);
 508   return th;
 509 }
 510
 511 void internal_join_thread(void *th) { pthread_join((pthread_t)th, 0); }
 512
 513 #if !SANITIZER_GO
 514 static BlockingMutex syslog_lock(LINKER_INITIALIZED);
 515 #endif
 516
 517 void WriteOneLineToSyslog(const char *s) {
 518 #if !SANITIZER_GO
 519   syslog_lock.CheckLocked();
 520   asl_log(nullptr, nullptr, ASL_LEVEL_ERR, "%s", s);
 521 #endif
 522 }
 523
 524 void LogMessageOnPrintf(const char *str) {
 525   // Log all printf output to CrashLog.
 526   if (common_flags()->abort_on_error)
 527     CRAppendCrashLogMessage(str);
 528 }
 529
 530 void LogFullErrorReport(const char *buffer) {
 531 #if !SANITIZER_GO
 532   // Log with os_trace. This will make it into the crash log.
 533 #if SANITIZER_OS_TRACE
 534   if (GetMacosVersion() >= MACOS_VERSION_YOSEMITE) {
 535     // os_trace requires the message (format parameter) to be a string literal.
 536     if (internal_strncmp(SanitizerToolName, "AddressSanitizer",
 537                          sizeof("AddressSanitizer") - 1) == 0)
 538       os_trace("Address Sanitizer reported a failure.");
 539     else if (internal_strncmp(SanitizerToolName, "UndefinedBehaviorSanitizer",
 540                               sizeof("UndefinedBehaviorSanitizer") - 1) == 0)
 541       os_trace("Undefined Behavior Sanitizer reported a failure.");
 542     else if (internal_strncmp(SanitizerToolName, "ThreadSanitizer",
 543                               sizeof("ThreadSanitizer") - 1) == 0)
 544       os_trace("Thread Sanitizer reported a failure.");
 545     else
 546       os_trace("Sanitizer tool reported a failure.");
 547
 548     if (common_flags()->log_to_syslog)
 549       os_trace("Consult syslog for more information.");
 550   }
 551 #endif
 552
 553   // Log to syslog.
 554   // The logging on OS X may call pthread_create so we need the threading
 555   // environment to be fully initialized. Also, this should never be called when
 556   // holding the thread registry lock since that may result in a deadlock. If
 557   // the reporting thread holds the thread registry mutex, and asl_log waits
 558   // for GCD to dispatch a new thread, the process will deadlock, because the
 559   // pthread_create wrapper needs to acquire the lock as well.
 560   BlockingMutexLock l(&syslog_lock);
 561   if (common_flags()->log_to_syslog)
 562     WriteToSyslog(buffer);
 563
 564   // The report is added to CrashLog as part of logging all of Printf output.
 565 #endif
 566 }
 567
 568 SignalContext::WriteFlag SignalContext::GetWriteFlag(void *context) {
 569 #if defined(__x86_64__) || defined(__i386__)
 570   ucontext_t *ucontext = static_cast<ucontext_t*>(context);
 571   return ucontext->uc_mcontext->__es.__err & 2 /*T_PF_WRITE*/ ? WRITE : READ;
 572 #else
 573   return UNKNOWN;
 574 #endif
 575 }
 576
 577 void GetPcSpBp(void *context, uptr *pc, uptr *sp, uptr *bp) {
 578   ucontext_t *ucontext = (ucontext_t*)context;
 579 # if defined(__aarch64__)
 580   *pc = ucontext->uc_mcontext->__ss.__pc;
 581 #   if defined(__IPHONE_8_0) && __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_8_0
 582   *bp = ucontext->uc_mcontext->__ss.__fp;
 583 #   else
 584   *bp = ucontext->uc_mcontext->__ss.__lr;
 585 #   endif
 586   *sp = ucontext->uc_mcontext->__ss.__sp;
 587 # elif defined(__x86_64__)
 588   *pc = ucontext->uc_mcontext->__ss.__rip;
 589   *bp = ucontext->uc_mcontext->__ss.__rbp;
 590   *sp = ucontext->uc_mcontext->__ss.__rsp;
 591 # elif defined(__arm__)
 592   *pc = ucontext->uc_mcontext->__ss.__pc;
 593   *bp = ucontext->uc_mcontext->__ss.__r[7];
 594   *sp = ucontext->uc_mcontext->__ss.__sp;
 595 # elif defined(__i386__)
 596   *pc = ucontext->uc_mcontext->__ss.__eip;
 597   *bp = ucontext->uc_mcontext->__ss.__ebp;
 598   *sp = ucontext->uc_mcontext->__ss.__esp;
 599 # else
 600 # error "Unknown architecture"
 601 # endif
 602 }
 603
 604 #if !SANITIZER_GO
 605 static const char kDyldInsertLibraries[] = "DYLD_INSERT_LIBRARIES";
 606 LowLevelAllocator allocator_for_env;
 607
 608 // Change the value of the env var |name|, leaking the original value.
 609 // If |name_value| is NULL, the variable is deleted from the environment,
 610 // otherwise the corresponding "NAME=value" string is replaced with
 611 // |name_value|.
 612 void LeakyResetEnv(const char *name, const char *name_value) {
 613   char **env = GetEnviron();
 614   uptr name_len = internal_strlen(name);
 615   while (*env != 0) {
 616     uptr len = internal_strlen(*env);
 617     if (len > name_len) {
 618       const char *p = *env;
 619       if (!internal_memcmp(p, name, name_len) && p[name_len] == '=') {
 620         // Match.
 621         if (name_value) {
 622           // Replace the old value with the new one.
 623           *env = const_cast<char*>(name_value);
 624         } else {
 625           // Shift the subsequent pointers back.
 626           char **del = env;
 627           do {
 628             del[0] = del[1];
 629           } while (*del++);
 630         }
 631       }
 632     }
 633     env++;
 634   }
 635 }
 636
 637 SANITIZER_WEAK_CXX_DEFAULT_IMPL
 638 bool ReexecDisabled() {
 639   return false;
 640 }
 641
 642 extern "C" SANITIZER_WEAK_ATTRIBUTE double dyldVersionNumber;
 643 static const double kMinDyldVersionWithAutoInterposition = 360.0;
 644
 645 bool DyldNeedsEnvVariable() {
 646   // Although sanitizer support was added to LLVM on OS X 10.7+, GCC users
 647   // still may want use them on older systems. On older Darwin platforms, dyld
 648   // doesn't export dyldVersionNumber symbol and we simply return true.
 649   if (!&dyldVersionNumber) return true;
 650   // If running on OS X 10.11+ or iOS 9.0+, dyld will interpose even if
 651   // DYLD_INSERT_LIBRARIES is not set. However, checking OS version via
 652   // GetMacosVersion() doesn't work for the simulator. Let's instead check
 653   // `dyldVersionNumber`, which is exported by dyld, against a known version
 654   // number from the first OS release where this appeared.
 655   return dyldVersionNumber < kMinDyldVersionWithAutoInterposition;
 656 }
 657
 658 void MaybeReexec() {
 659   if (ReexecDisabled()) return;
 660
 661   // Make sure the dynamic runtime library is preloaded so that the
 662   // wrappers work. If it is not, set DYLD_INSERT_LIBRARIES and re-exec
 663   // ourselves.
 664   Dl_info info;
 665   RAW_CHECK(dladdr((void*)((uptr)&__sanitizer_report_error_summary), &info));
 666   char *dyld_insert_libraries =
 667       const_cast<char*>(GetEnv(kDyldInsertLibraries));
 668   uptr old_env_len = dyld_insert_libraries ?
 669       internal_strlen(dyld_insert_libraries) : 0;
 670   uptr fname_len = internal_strlen(info.dli_fname);
 671   const char *dylib_name = StripModuleName(info.dli_fname);
 672   uptr dylib_name_len = internal_strlen(dylib_name);
 673
 674   bool lib_is_in_env = dyld_insert_libraries &&
 675                        internal_strstr(dyld_insert_libraries, dylib_name);
 676   if (DyldNeedsEnvVariable() && !lib_is_in_env) {
 677     // DYLD_INSERT_LIBRARIES is not set or does not contain the runtime
 678     // library.
 679     InternalScopedString program_name(1024);
 680     uint32_t buf_size = program_name.size();
 681     _NSGetExecutablePath(program_name.data(), &buf_size);
 682     char *new_env = const_cast<char*>(info.dli_fname);
 683     if (dyld_insert_libraries) {
 684       // Append the runtime dylib name to the existing value of
 685       // DYLD_INSERT_LIBRARIES.
 686       new_env = (char*)allocator_for_env.Allocate(old_env_len + fname_len + 2);
 687       internal_strncpy(new_env, dyld_insert_libraries, old_env_len);
 688       new_env[old_env_len] = ':';
 689       // Copy fname_len and add a trailing zero.
 690       internal_strncpy(new_env + old_env_len + 1, info.dli_fname,
 691                        fname_len + 1);
 692       // Ok to use setenv() since the wrappers don't depend on the value of
 693       // asan_inited.
 694       setenv(kDyldInsertLibraries, new_env, /*overwrite*/1);
 695     } else {
 696       // Set DYLD_INSERT_LIBRARIES equal to the runtime dylib name.
 697       setenv(kDyldInsertLibraries, info.dli_fname, /*overwrite*/0);
 698     }
 699     VReport(1, "exec()-ing the program with\n");
 700     VReport(1, "%s=%s\n", kDyldInsertLibraries, new_env);
 701     VReport(1, "to enable wrappers.\n");
 702     execv(program_name.data(), *_NSGetArgv());
 703
 704     // We get here only if execv() failed.
 705     Report("ERROR: The process is launched without DYLD_INSERT_LIBRARIES, "
 706            "which is required for the sanitizer to work. We tried to set the "
 707            "environment variable and re-execute itself, but execv() failed, "
 708            "possibly because of sandbox restrictions. Make sure to launch the "
 709            "executable with:\n%s=%s\n", kDyldInsertLibraries, new_env);
 710     RAW_CHECK("execv failed" && 0);
 711   }
 712
 713   // Verify that interceptors really work.  We'll use dlsym to locate
 714   // "pthread_create", if interceptors are working, it should really point to
 715   // "wrap_pthread_create" within our own dylib.
 716   Dl_info info_pthread_create;
 717   void *dlopen_addr = dlsym(RTLD_DEFAULT, "pthread_create");
 718   RAW_CHECK(dladdr(dlopen_addr, &info_pthread_create));
 719   if (internal_strcmp(info.dli_fname, info_pthread_create.dli_fname) != 0) {
 720     Report(
 721         "ERROR: Interceptors are not working. This may be because %s is "
 722         "loaded too late (e.g. via dlopen). Please launch the executable "
 723         "with:\n%s=%s\n",
 724         SanitizerToolName, kDyldInsertLibraries, info.dli_fname);
 725     RAW_CHECK("interceptors not installed" && 0);
 726   }
 727
 728   if (!lib_is_in_env)
 729     return;
 730
 731   // DYLD_INSERT_LIBRARIES is set and contains the runtime library. Let's remove
 732   // the dylib from the environment variable, because interceptors are installed
 733   // and we don't want our children to inherit the variable.
 734
 735   uptr env_name_len = internal_strlen(kDyldInsertLibraries);
 736   // Allocate memory to hold the previous env var name, its value, the '='
 737   // sign and the '\0' char.
 738   char *new_env = (char*)allocator_for_env.Allocate(
 739       old_env_len + 2 + env_name_len);
 740   RAW_CHECK(new_env);
 741   internal_memset(new_env, '\0', old_env_len + 2 + env_name_len);
 742   internal_strncpy(new_env, kDyldInsertLibraries, env_name_len);
 743   new_env[env_name_len] = '=';
 744   char *new_env_pos = new_env + env_name_len + 1;
 745
 746   // Iterate over colon-separated pieces of |dyld_insert_libraries|.
 747   char *piece_start = dyld_insert_libraries;
 748   char *piece_end = NULL;
 749   char *old_env_end = dyld_insert_libraries + old_env_len;
 750   do {
 751     if (piece_start[0] == ':') piece_start++;
 752     piece_end = internal_strchr(piece_start, ':');
 753     if (!piece_end) piece_end = dyld_insert_libraries + old_env_len;
 754     if ((uptr)(piece_start - dyld_insert_libraries) > old_env_len) break;
 755     uptr piece_len = piece_end - piece_start;
 756
 757     char *filename_start =
 758         (char *)internal_memrchr(piece_start, '/', piece_len);
 759     uptr filename_len = piece_len;
 760     if (filename_start) {
 761       filename_start += 1;
 762       filename_len = piece_len - (filename_start - piece_start);
 763     } else {
 764       filename_start = piece_start;
 765     }
 766
 767     // If the current piece isn't the runtime library name,
 768     // append it to new_env.
 769     if ((dylib_name_len != filename_len) ||
 770         (internal_memcmp(filename_start, dylib_name, dylib_name_len) != 0)) {
 771       if (new_env_pos != new_env + env_name_len + 1) {
 772         new_env_pos[0] = ':';
 773         new_env_pos++;
 774       }
 775       internal_strncpy(new_env_pos, piece_start, piece_len);
 776       new_env_pos += piece_len;
 777     }
 778     // Move on to the next piece.
 779     piece_start = piece_end;
 780   } while (piece_start < old_env_end);
 781
 782   // Can't use setenv() here, because it requires the allocator to be
 783   // initialized.
 784   // FIXME: instead of filtering DYLD_INSERT_LIBRARIES here, do it in
 785   // a separate function called after InitializeAllocator().
 786   if (new_env_pos == new_env + env_name_len + 1) new_env = NULL;
 787   LeakyResetEnv(kDyldInsertLibraries, new_env);
 788 }
 789 #endif  // SANITIZER_GO
 790
 791 char **GetArgv() {
 792   return *_NSGetArgv();
 793 }
 794
 795 uptr FindAvailableMemoryRange(uptr shadow_size,
 796                               uptr alignment,
 797                               uptr left_padding) {
 798   typedef vm_region_submap_short_info_data_64_t RegionInfo;
 799   enum { kRegionInfoSize = VM_REGION_SUBMAP_SHORT_INFO_COUNT_64 };
 800   // Start searching for available memory region past PAGEZERO, which is
 801   // 4KB on 32-bit and 4GB on 64-bit.
 802   mach_vm_address_t start_address =
 803     (SANITIZER_WORDSIZE == 32) ? 0x000000001000 : 0x000100000000;
 804
 805   mach_vm_address_t address = start_address;
 806   mach_vm_address_t free_begin = start_address;
 807   kern_return_t kr = KERN_SUCCESS;
 808   while (kr == KERN_SUCCESS) {
 809     mach_vm_size_t vmsize = 0;
 810     natural_t depth = 0;
 811     RegionInfo vminfo;
 812     mach_msg_type_number_t count = kRegionInfoSize;
 813     kr = mach_vm_region_recurse(mach_task_self(), &address, &vmsize, &depth,
 814                                 (vm_region_info_t)&vminfo, &count);
 815     if (free_begin != address) {
 816       // We found a free region [free_begin..address-1].
 817       uptr shadow_address = RoundUpTo((uptr)free_begin + left_padding,
 818                                       alignment);
 819       if (shadow_address + shadow_size < (uptr)address) {
 820         return shadow_address;
 821       }
 822     }
 823     // Move to the next region.
 824     address += vmsize;
 825     free_begin = address;
 826   }
 827
 828   // We looked at all free regions and could not find one large enough.
 829   return 0;
 830 }
 831
 832 // FIXME implement on this platform.
 833 void GetMemoryProfile(fill_profile_f cb, uptr *stats, uptr stats_size) { }
 834
 835 void SignalContext::DumpAllRegisters(void *context) {
 836   Report("Register values:\n");
 837
 838   ucontext_t *ucontext = (ucontext_t*)context;
 839 # define DUMPREG64(r) \
 840     Printf("%s = 0x%016llx  ", #r, ucontext->uc_mcontext->__ss.__ ## r);
 841 # define DUMPREG32(r) \
 842     Printf("%s = 0x%08x  ", #r, ucontext->uc_mcontext->__ss.__ ## r);
 843 # define DUMPREG_(r)   Printf(" "); DUMPREG(r);
 844 # define DUMPREG__(r)  Printf("  "); DUMPREG(r);
 845 # define DUMPREG___(r) Printf("   "); DUMPREG(r);
 846
 847 # if defined(__x86_64__)
 848 #  define DUMPREG(r) DUMPREG64(r)
 849   DUMPREG(rax); DUMPREG(rbx); DUMPREG(rcx); DUMPREG(rdx); Printf("\n");
 850   DUMPREG(rdi); DUMPREG(rsi); DUMPREG(rbp); DUMPREG(rsp); Printf("\n");
 851   DUMPREG_(r8); DUMPREG_(r9); DUMPREG(r10); DUMPREG(r11); Printf("\n");
 852   DUMPREG(r12); DUMPREG(r13); DUMPREG(r14); DUMPREG(r15); Printf("\n");
 853 # elif defined(__i386__)
 854 #  define DUMPREG(r) DUMPREG32(r)
 855   DUMPREG(eax); DUMPREG(ebx); DUMPREG(ecx); DUMPREG(edx); Printf("\n");
 856   DUMPREG(edi); DUMPREG(esi); DUMPREG(ebp); DUMPREG(esp); Printf("\n");
 857 # elif defined(__aarch64__)
 858 #  define DUMPREG(r) DUMPREG64(r)
 859   DUMPREG_(x[0]); DUMPREG_(x[1]); DUMPREG_(x[2]); DUMPREG_(x[3]); Printf("\n");
 860   DUMPREG_(x[4]); DUMPREG_(x[5]); DUMPREG_(x[6]); DUMPREG_(x[7]); Printf("\n");
 861   DUMPREG_(x[8]); DUMPREG_(x[9]); DUMPREG(x[10]); DUMPREG(x[11]); Printf("\n");
 862   DUMPREG(x[12]); DUMPREG(x[13]); DUMPREG(x[14]); DUMPREG(x[15]); Printf("\n");
 863   DUMPREG(x[16]); DUMPREG(x[17]); DUMPREG(x[18]); DUMPREG(x[19]); Printf("\n");
 864   DUMPREG(x[20]); DUMPREG(x[21]); DUMPREG(x[22]); DUMPREG(x[23]); Printf("\n");
 865   DUMPREG(x[24]); DUMPREG(x[25]); DUMPREG(x[26]); DUMPREG(x[27]); Printf("\n");
 866   DUMPREG(x[28]); DUMPREG___(fp); DUMPREG___(lr); DUMPREG___(sp); Printf("\n");
 867 # elif defined(__arm__)
 868 #  define DUMPREG(r) DUMPREG32(r)
 869   DUMPREG_(r[0]); DUMPREG_(r[1]); DUMPREG_(r[2]); DUMPREG_(r[3]); Printf("\n");
 870   DUMPREG_(r[4]); DUMPREG_(r[5]); DUMPREG_(r[6]); DUMPREG_(r[7]); Printf("\n");
 871   DUMPREG_(r[8]); DUMPREG_(r[9]); DUMPREG(r[10]); DUMPREG(r[11]); Printf("\n");
 872   DUMPREG(r[12]); DUMPREG___(sp); DUMPREG___(lr); DUMPREG___(pc); Printf("\n");
 873 # else
 874 # error "Unknown architecture"
 875 # endif
 876
 877 # undef DUMPREG64
 878 # undef DUMPREG32
 879 # undef DUMPREG_
 880 # undef DUMPREG__
 881 # undef DUMPREG___
 882 # undef DUMPREG
 883 }
 884
 885 static inline bool CompareBaseAddress(const LoadedModule &a,
 886                                       const LoadedModule &b) {
 887   return a.base_address() < b.base_address();
 888 }
 889
 890 void FormatUUID(char *out, uptr size, const u8 *uuid) {
 891   internal_snprintf(out, size,
 892                     "<%02X%02X%02X%02X-%02X%02X-%02X%02X-%02X%02X-"
 893                     "%02X%02X%02X%02X%02X%02X>",
 894                     uuid[0], uuid[1], uuid[2], uuid[3], uuid[4], uuid[5],
 895                     uuid[6], uuid[7], uuid[8], uuid[9], uuid[10], uuid[11],
 896                     uuid[12], uuid[13], uuid[14], uuid[15]);
 897 }
 898
 899 void PrintModuleMap() {
 900   Printf("Process module map:\n");
 901   MemoryMappingLayout memory_mapping(false);
 902   InternalMmapVector<LoadedModule> modules(/*initial_capacity*/ 128);
 903   memory_mapping.DumpListOfModules(&modules);
 904   InternalSort(&modules, modules.size(), CompareBaseAddress);
 905   for (uptr i = 0; i < modules.size(); ++i) {
 906     char uuid_str[128];
 907     FormatUUID(uuid_str, sizeof(uuid_str), modules[i].uuid());
 908     Printf("0x%zx-0x%zx %s (%s) %s\n", modules[i].base_address(),
 909            modules[i].max_executable_address(), modules[i].full_name(),
 910            ModuleArchToString(modules[i].arch()), uuid_str);
 911   }
 912   Printf("End of module map.\n");
 913 }
 914
 915 void CheckNoDeepBind(const char *filename, int flag) {
 916   // Do nothing.
 917 }
 918
 919 }  // namespace __sanitizer
 920
 921 #endif  // SANITIZER_MAC