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
36extern 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
49extern "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 <unistd.h>
72#include <util.h>
73
74namespace __sanitizer {
75
76#include "sanitizer_syscall_generic.inc"
77
78// ---------------------- sanitizer_libc.h
79uptr internal_mmap(void *addr, size_t length, int prot, int flags,
80                   int fd, u64 offset) {
81  if (fd == -1) fd = VM_MAKE_TAG(VM_MEMORY_ANALYSIS_TOOL);
82  return (uptr)mmap(addr, length, prot, flags, fd, offset);
83}
84
85uptr internal_munmap(void *addr, uptr length) {
86  return munmap(addr, length);
87}
88
89int internal_mprotect(void *addr, uptr length, int prot) {
90  return mprotect(addr, length, prot);
91}
92
93uptr internal_close(fd_t fd) {
94  return close(fd);
95}
96
97uptr internal_open(const char *filename, int flags) {
98  return open(filename, flags);
99}
100
101uptr internal_open(const char *filename, int flags, u32 mode) {
102  return open(filename, flags, mode);
103}
104
105uptr internal_read(fd_t fd, void *buf, uptr count) {
106  return read(fd, buf, count);
107}
108
109uptr internal_write(fd_t fd, const void *buf, uptr count) {
110  return write(fd, buf, count);
111}
112
113uptr internal_stat(const char *path, void *buf) {
114  return stat(path, (struct stat *)buf);
115}
116
117uptr internal_lstat(const char *path, void *buf) {
118  return lstat(path, (struct stat *)buf);
119}
120
121uptr internal_fstat(fd_t fd, void *buf) {
122  return fstat(fd, (struct stat *)buf);
123}
124
125uptr internal_filesize(fd_t fd) {
126  struct stat st;
127  if (internal_fstat(fd, &st))
128    return -1;
129  return (uptr)st.st_size;
130}
131
132uptr internal_dup2(int oldfd, int newfd) {
133  return dup2(oldfd, newfd);
134}
135
136uptr internal_readlink(const char *path, char *buf, uptr bufsize) {
137  return readlink(path, buf, bufsize);
138}
139
140uptr internal_unlink(const char *path) {
141  return unlink(path);
142}
143
144uptr internal_sched_yield() {
145  return sched_yield();
146}
147
148void internal__exit(int exitcode) {
149  _exit(exitcode);
150}
151
152uptr internal_getpid() {
153  return getpid();
154}
155
156int internal_sigaction(int signum, const void *act, void *oldact) {
157  return sigaction(signum,
158                   (struct sigaction *)act, (struct sigaction *)oldact);
159}
160
161void internal_sigfillset(__sanitizer_sigset_t *set) { sigfillset(set); }
162
163uptr internal_sigprocmask(int how, __sanitizer_sigset_t *set,
164                          __sanitizer_sigset_t *oldset) {
165  return sigprocmask(how, set, oldset);
166}
167
168// Doesn't call pthread_atfork() handlers.
169extern "C" pid_t __fork(void);
170
171int internal_fork() {
172  return __fork();
173}
174
175int internal_forkpty(int *amaster) {
176  int master, slave;
177  if (openpty(&master, &slave, nullptr, nullptr, nullptr) == -1) return -1;
178  int pid = __fork();
179  if (pid == -1) {
180    close(master);
181    close(slave);
182    return -1;
183  }
184  if (pid == 0) {
185    close(master);
186    CHECK_EQ(login_tty(slave), 0);
187  } else {
188    *amaster = master;
189    close(slave);
190  }
191  return pid;
192}
193
194uptr internal_rename(const char *oldpath, const char *newpath) {
195  return rename(oldpath, newpath);
196}
197
198uptr internal_ftruncate(fd_t fd, uptr size) {
199  return ftruncate(fd, size);
200}
201
202// ----------------- sanitizer_common.h
203bool FileExists(const char *filename) {
204  struct stat st;
205  if (stat(filename, &st))
206    return false;
207  // Sanity check: filename is a regular file.
208  return S_ISREG(st.st_mode);
209}
210
211uptr GetTid() {
212  return reinterpret_cast<uptr>(pthread_self());
213}
214
215void GetThreadStackTopAndBottom(bool at_initialization, uptr *stack_top,
216                                uptr *stack_bottom) {
217  CHECK(stack_top);
218  CHECK(stack_bottom);
219  uptr stacksize = pthread_get_stacksize_np(pthread_self());
220  // pthread_get_stacksize_np() returns an incorrect stack size for the main
221  // thread on Mavericks. See
222  // https://github.com/google/sanitizers/issues/261
223  if ((GetMacosVersion() >= MACOS_VERSION_MAVERICKS) && at_initialization &&
224      stacksize == (1 << 19))  {
225    struct rlimit rl;
226    CHECK_EQ(getrlimit(RLIMIT_STACK, &rl), 0);
227    // Most often rl.rlim_cur will be the desired 8M.
228    if (rl.rlim_cur < kMaxThreadStackSize) {
229      stacksize = rl.rlim_cur;
230    } else {
231      stacksize = kMaxThreadStackSize;
232    }
233  }
234  void *stackaddr = pthread_get_stackaddr_np(pthread_self());
235  *stack_top = (uptr)stackaddr;
236  *stack_bottom = *stack_top - stacksize;
237}
238
239char **GetEnviron() {
240#if !SANITIZER_IOS
241  char ***env_ptr = _NSGetEnviron();
242  if (!env_ptr) {
243    Report("_NSGetEnviron() returned NULL. Please make sure __asan_init() is "
244           "called after libSystem_initializer().\n");
245    CHECK(env_ptr);
246  }
247  char **environ = *env_ptr;
248#endif
249  CHECK(environ);
250  return environ;
251}
252
253const char *GetEnv(const char *name) {
254  char **env = GetEnviron();
255  uptr name_len = internal_strlen(name);
256  while (*env != 0) {
257    uptr len = internal_strlen(*env);
258    if (len > name_len) {
259      const char *p = *env;
260      if (!internal_memcmp(p, name, name_len) &&
261          p[name_len] == '=') {  // Match.
262        return *env + name_len + 1;  // String starting after =.
263      }
264    }
265    env++;
266  }
267  return 0;
268}
269
270uptr ReadBinaryName(/*out*/char *buf, uptr buf_len) {
271  CHECK_LE(kMaxPathLength, buf_len);
272
273  // On OS X the executable path is saved to the stack by dyld. Reading it
274  // from there is much faster than calling dladdr, especially for large
275  // binaries with symbols.
276  InternalScopedString exe_path(kMaxPathLength);
277  uint32_t size = exe_path.size();
278  if (_NSGetExecutablePath(exe_path.data(), &size) == 0 &&
279      realpath(exe_path.data(), buf) != 0) {
280    return internal_strlen(buf);
281  }
282  return 0;
283}
284
285uptr ReadLongProcessName(/*out*/char *buf, uptr buf_len) {
286  return ReadBinaryName(buf, buf_len);
287}
288
289void ReExec() {
290  UNIMPLEMENTED();
291}
292
293uptr GetPageSize() {
294  return sysconf(_SC_PAGESIZE);
295}
296
297BlockingMutex::BlockingMutex() {
298  internal_memset(this, 0, sizeof(*this));
299}
300
301void BlockingMutex::Lock() {
302  CHECK(sizeof(OSSpinLock) <= sizeof(opaque_storage_));
303  CHECK_EQ(OS_SPINLOCK_INIT, 0);
304  CHECK_NE(owner_, (uptr)pthread_self());
305  OSSpinLockLock((OSSpinLock*)&opaque_storage_);
306  CHECK(!owner_);
307  owner_ = (uptr)pthread_self();
308}
309
310void BlockingMutex::Unlock() {
311  CHECK(owner_ == (uptr)pthread_self());
312  owner_ = 0;
313  OSSpinLockUnlock((OSSpinLock*)&opaque_storage_);
314}
315
316void BlockingMutex::CheckLocked() {
317  CHECK_EQ((uptr)pthread_self(), owner_);
318}
319
320u64 NanoTime() {
321  return 0;
322}
323
324uptr GetTlsSize() {
325  return 0;
326}
327
328void InitTlsSize() {
329}
330
331void GetThreadStackAndTls(bool main, uptr *stk_addr, uptr *stk_size,
332                          uptr *tls_addr, uptr *tls_size) {
333#ifndef SANITIZER_GO
334  uptr stack_top, stack_bottom;
335  GetThreadStackTopAndBottom(main, &stack_top, &stack_bottom);
336  *stk_addr = stack_bottom;
337  *stk_size = stack_top - stack_bottom;
338  *tls_addr = 0;
339  *tls_size = 0;
340#else
341  *stk_addr = 0;
342  *stk_size = 0;
343  *tls_addr = 0;
344  *tls_size = 0;
345#endif
346}
347
348uptr GetListOfModules(LoadedModule *modules, uptr max_modules,
349                      string_predicate_t filter) {
350  MemoryMappingLayout memory_mapping(false);
351  return memory_mapping.DumpListOfModules(modules, max_modules, filter);
352}
353
354bool IsDeadlySignal(int signum) {
355  return (signum == SIGSEGV || signum == SIGBUS) && common_flags()->handle_segv;
356}
357
358MacosVersion cached_macos_version = MACOS_VERSION_UNINITIALIZED;
359
360MacosVersion GetMacosVersionInternal() {
361  int mib[2] = { CTL_KERN, KERN_OSRELEASE };
362  char version[100];
363  uptr len = 0, maxlen = sizeof(version) / sizeof(version[0]);
364  for (uptr i = 0; i < maxlen; i++) version[i] = '\0';
365  // Get the version length.
366  CHECK_NE(sysctl(mib, 2, 0, &len, 0, 0), -1);
367  CHECK_LT(len, maxlen);
368  CHECK_NE(sysctl(mib, 2, version, &len, 0, 0), -1);
369  switch (version[0]) {
370    case '9': return MACOS_VERSION_LEOPARD;
371    case '1': {
372      switch (version[1]) {
373        case '0': return MACOS_VERSION_SNOW_LEOPARD;
374        case '1': return MACOS_VERSION_LION;
375        case '2': return MACOS_VERSION_MOUNTAIN_LION;
376        case '3': return MACOS_VERSION_MAVERICKS;
377        case '4': return MACOS_VERSION_YOSEMITE;
378        default:
379          if (IsDigit(version[1]))
380            return MACOS_VERSION_UNKNOWN_NEWER;
381          else
382            return MACOS_VERSION_UNKNOWN;
383      }
384    }
385    default: return MACOS_VERSION_UNKNOWN;
386  }
387}
388
389MacosVersion GetMacosVersion() {
390  atomic_uint32_t *cache =
391      reinterpret_cast<atomic_uint32_t*>(&cached_macos_version);
392  MacosVersion result =
393      static_cast<MacosVersion>(atomic_load(cache, memory_order_acquire));
394  if (result == MACOS_VERSION_UNINITIALIZED) {
395    result = GetMacosVersionInternal();
396    atomic_store(cache, result, memory_order_release);
397  }
398  return result;
399}
400
401uptr GetRSS() {
402  struct task_basic_info info;
403  unsigned count = TASK_BASIC_INFO_COUNT;
404  kern_return_t result =
405      task_info(mach_task_self(), TASK_BASIC_INFO, (task_info_t)&info, &count);
406  if (UNLIKELY(result != KERN_SUCCESS)) {
407    Report("Cannot get task info. Error: %d\n", result);
408    Die();
409  }
410  return info.resident_size;
411}
412
413void *internal_start_thread(void(*func)(void *arg), void *arg) {
414  // Start the thread with signals blocked, otherwise it can steal user signals.
415  __sanitizer_sigset_t set, old;
416  internal_sigfillset(&set);
417  internal_sigprocmask(SIG_SETMASK, &set, &old);
418  pthread_t th;
419  pthread_create(&th, 0, (void*(*)(void *arg))func, arg);
420  internal_sigprocmask(SIG_SETMASK, &old, 0);
421  return th;
422}
423
424void internal_join_thread(void *th) { pthread_join((pthread_t)th, 0); }
425
426static BlockingMutex syslog_lock(LINKER_INITIALIZED);
427
428void WriteOneLineToSyslog(const char *s) {
429  syslog_lock.CheckLocked();
430  asl_log(nullptr, nullptr, ASL_LEVEL_ERR, "%s", s);
431}
432
433void LogFullErrorReport(const char *buffer) {
434  // Log with os_trace. This will make it into the crash log.
435#if SANITIZER_OS_TRACE
436  if (GetMacosVersion() >= MACOS_VERSION_YOSEMITE) {
437    // os_trace requires the message (format parameter) to be a string literal.
438    if (internal_strncmp(SanitizerToolName, "AddressSanitizer",
439                         sizeof("AddressSanitizer") - 1) == 0)
440      os_trace("Address Sanitizer reported a failure.");
441    else if (internal_strncmp(SanitizerToolName, "UndefinedBehaviorSanitizer",
442                              sizeof("UndefinedBehaviorSanitizer") - 1) == 0)
443      os_trace("Undefined Behavior Sanitizer reported a failure.");
444    else if (internal_strncmp(SanitizerToolName, "ThreadSanitizer",
445                              sizeof("ThreadSanitizer") - 1) == 0)
446      os_trace("Thread Sanitizer reported a failure.");
447    else
448      os_trace("Sanitizer tool reported a failure.");
449
450    if (common_flags()->log_to_syslog)
451      os_trace("Consult syslog for more information.");
452  }
453#endif
454
455  // Log to syslog.
456  // The logging on OS X may call pthread_create so we need the threading
457  // environment to be fully initialized. Also, this should never be called when
458  // holding the thread registry lock since that may result in a deadlock. If
459  // the reporting thread holds the thread registry mutex, and asl_log waits
460  // for GCD to dispatch a new thread, the process will deadlock, because the
461  // pthread_create wrapper needs to acquire the lock as well.
462  BlockingMutexLock l(&syslog_lock);
463  if (common_flags()->log_to_syslog)
464    WriteToSyslog(buffer);
465
466  // Log to CrashLog.
467  if (common_flags()->abort_on_error)
468    CRSetCrashLogMessage(buffer);
469}
470
471void GetPcSpBp(void *context, uptr *pc, uptr *sp, uptr *bp) {
472  ucontext_t *ucontext = (ucontext_t*)context;
473# if defined(__aarch64__)
474  *pc = ucontext->uc_mcontext->__ss.__pc;
475#   if defined(__IPHONE_8_0) && __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_8_0
476  *bp = ucontext->uc_mcontext->__ss.__fp;
477#   else
478  *bp = ucontext->uc_mcontext->__ss.__lr;
479#   endif
480  *sp = ucontext->uc_mcontext->__ss.__sp;
481# elif defined(__x86_64__)
482  *pc = ucontext->uc_mcontext->__ss.__rip;
483  *bp = ucontext->uc_mcontext->__ss.__rbp;
484  *sp = ucontext->uc_mcontext->__ss.__rsp;
485# elif defined(__arm__)
486  *pc = ucontext->uc_mcontext->__ss.__pc;
487  *bp = ucontext->uc_mcontext->__ss.__r[7];
488  *sp = ucontext->uc_mcontext->__ss.__sp;
489# elif defined(__i386__)
490  *pc = ucontext->uc_mcontext->__ss.__eip;
491  *bp = ucontext->uc_mcontext->__ss.__ebp;
492  *sp = ucontext->uc_mcontext->__ss.__esp;
493# else
494# error "Unknown architecture"
495# endif
496}
497
498static const char kDyldInsertLibraries[] = "DYLD_INSERT_LIBRARIES";
499LowLevelAllocator allocator_for_env;
500
501// Change the value of the env var |name|, leaking the original value.
502// If |name_value| is NULL, the variable is deleted from the environment,
503// otherwise the corresponding "NAME=value" string is replaced with
504// |name_value|.
505void LeakyResetEnv(const char *name, const char *name_value) {
506  char **env = GetEnviron();
507  uptr name_len = internal_strlen(name);
508  while (*env != 0) {
509    uptr len = internal_strlen(*env);
510    if (len > name_len) {
511      const char *p = *env;
512      if (!internal_memcmp(p, name, name_len) && p[name_len] == '=') {
513        // Match.
514        if (name_value) {
515          // Replace the old value with the new one.
516          *env = const_cast<char*>(name_value);
517        } else {
518          // Shift the subsequent pointers back.
519          char **del = env;
520          do {
521            del[0] = del[1];
522          } while (*del++);
523        }
524      }
525    }
526    env++;
527  }
528}
529
530static bool reexec_disabled = false;
531
532void DisableReexec() {
533  reexec_disabled = true;
534}
535
536extern "C" double dyldVersionNumber;
537static const double kMinDyldVersionWithAutoInterposition = 360.0;
538
539bool DyldNeedsEnvVariable() {
540  // If running on OS X 10.11+ or iOS 9.0+, dyld will interpose even if
541  // DYLD_INSERT_LIBRARIES is not set. However, checking OS version via
542  // GetMacosVersion() doesn't work for the simulator. Let's instead check
543  // `dyldVersionNumber`, which is exported by dyld, against a known version
544  // number from the first OS release where this appeared.
545  return dyldVersionNumber < kMinDyldVersionWithAutoInterposition;
546}
547
548void MaybeReexec() {
549  if (reexec_disabled) return;
550
551  // Make sure the dynamic runtime library is preloaded so that the
552  // wrappers work. If it is not, set DYLD_INSERT_LIBRARIES and re-exec
553  // ourselves.
554  Dl_info info;
555  CHECK(dladdr((void*)((uptr)&__sanitizer_report_error_summary), &info));
556  char *dyld_insert_libraries =
557      const_cast<char*>(GetEnv(kDyldInsertLibraries));
558  uptr old_env_len = dyld_insert_libraries ?
559      internal_strlen(dyld_insert_libraries) : 0;
560  uptr fname_len = internal_strlen(info.dli_fname);
561  const char *dylib_name = StripModuleName(info.dli_fname);
562  uptr dylib_name_len = internal_strlen(dylib_name);
563
564  bool lib_is_in_env = dyld_insert_libraries &&
565                       internal_strstr(dyld_insert_libraries, dylib_name);
566  if (DyldNeedsEnvVariable() && !lib_is_in_env) {
567    // DYLD_INSERT_LIBRARIES is not set or does not contain the runtime
568    // library.
569    InternalScopedString program_name(1024);
570    uint32_t buf_size = program_name.size();
571    _NSGetExecutablePath(program_name.data(), &buf_size);
572    char *new_env = const_cast<char*>(info.dli_fname);
573    if (dyld_insert_libraries) {
574      // Append the runtime dylib name to the existing value of
575      // DYLD_INSERT_LIBRARIES.
576      new_env = (char*)allocator_for_env.Allocate(old_env_len + fname_len + 2);
577      internal_strncpy(new_env, dyld_insert_libraries, old_env_len);
578      new_env[old_env_len] = ':';
579      // Copy fname_len and add a trailing zero.
580      internal_strncpy(new_env + old_env_len + 1, info.dli_fname,
581                       fname_len + 1);
582      // Ok to use setenv() since the wrappers don't depend on the value of
583      // asan_inited.
584      setenv(kDyldInsertLibraries, new_env, /*overwrite*/1);
585    } else {
586      // Set DYLD_INSERT_LIBRARIES equal to the runtime dylib name.
587      setenv(kDyldInsertLibraries, info.dli_fname, /*overwrite*/0);
588    }
589    VReport(1, "exec()-ing the program with\n");
590    VReport(1, "%s=%s\n", kDyldInsertLibraries, new_env);
591    VReport(1, "to enable wrappers.\n");
592    execv(program_name.data(), *_NSGetArgv());
593
594    // We get here only if execv() failed.
595    Report("ERROR: The process is launched without DYLD_INSERT_LIBRARIES, "
596           "which is required for the sanitizer to work. We tried to set the "
597           "environment variable and re-execute itself, but execv() failed, "
598           "possibly because of sandbox restrictions. Make sure to launch the "
599           "executable with:\n%s=%s\n", kDyldInsertLibraries, new_env);
600    CHECK("execv failed" && 0);
601  }
602
603  if (!lib_is_in_env)
604    return;
605
606  // DYLD_INSERT_LIBRARIES is set and contains the runtime library. Let's remove
607  // the dylib from the environment variable, because interceptors are installed
608  // and we don't want our children to inherit the variable.
609
610  uptr env_name_len = internal_strlen(kDyldInsertLibraries);
611  // Allocate memory to hold the previous env var name, its value, the '='
612  // sign and the '\0' char.
613  char *new_env = (char*)allocator_for_env.Allocate(
614      old_env_len + 2 + env_name_len);
615  CHECK(new_env);
616  internal_memset(new_env, '\0', old_env_len + 2 + env_name_len);
617  internal_strncpy(new_env, kDyldInsertLibraries, env_name_len);
618  new_env[env_name_len] = '=';
619  char *new_env_pos = new_env + env_name_len + 1;
620
621  // Iterate over colon-separated pieces of |dyld_insert_libraries|.
622  char *piece_start = dyld_insert_libraries;
623  char *piece_end = NULL;
624  char *old_env_end = dyld_insert_libraries + old_env_len;
625  do {
626    if (piece_start[0] == ':') piece_start++;
627    piece_end = internal_strchr(piece_start, ':');
628    if (!piece_end) piece_end = dyld_insert_libraries + old_env_len;
629    if ((uptr)(piece_start - dyld_insert_libraries) > old_env_len) break;
630    uptr piece_len = piece_end - piece_start;
631
632    char *filename_start =
633        (char *)internal_memrchr(piece_start, '/', piece_len);
634    uptr filename_len = piece_len;
635    if (filename_start) {
636      filename_start += 1;
637      filename_len = piece_len - (filename_start - piece_start);
638    } else {
639      filename_start = piece_start;
640    }
641
642    // If the current piece isn't the runtime library name,
643    // append it to new_env.
644    if ((dylib_name_len != filename_len) ||
645        (internal_memcmp(filename_start, dylib_name, dylib_name_len) != 0)) {
646      if (new_env_pos != new_env + env_name_len + 1) {
647        new_env_pos[0] = ':';
648        new_env_pos++;
649      }
650      internal_strncpy(new_env_pos, piece_start, piece_len);
651      new_env_pos += piece_len;
652    }
653    // Move on to the next piece.
654    piece_start = piece_end;
655  } while (piece_start < old_env_end);
656
657  // Can't use setenv() here, because it requires the allocator to be
658  // initialized.
659  // FIXME: instead of filtering DYLD_INSERT_LIBRARIES here, do it in
660  // a separate function called after InitializeAllocator().
661  if (new_env_pos == new_env + env_name_len + 1) new_env = NULL;
662  LeakyResetEnv(kDyldInsertLibraries, new_env);
663}
664
665}  // namespace __sanitizer
666
667#endif  // SANITIZER_MAC
668