libsanitizer/asan/asan_interceptors.cc

   1 //===-- asan_interceptors.cc ----------------------------------------------===//
   2 //
   3 // This file is distributed under the University of Illinois Open Source
   4 // License. See LICENSE.TXT for details.
   5 //
   6 //===----------------------------------------------------------------------===//
   7 //
   8 // This file is a part of AddressSanitizer, an address sanity checker.
   9 //
  10 // Intercept various libc functions.
  11 //===----------------------------------------------------------------------===//
  12 #include "asan_interceptors.h"
  13
  14 #include "asan_allocator.h"
  15 #include "asan_intercepted_functions.h"
  16 #include "asan_internal.h"
  17 #include "asan_mapping.h"
  18 #include "asan_report.h"
  19 #include "asan_stack.h"
  20 #include "asan_stats.h"
  21 #include "asan_thread_registry.h"
  22 #include "interception/interception.h"
  23 #include "sanitizer/asan_interface.h"
  24 #include "sanitizer_common/sanitizer_libc.h"
  25
  26 namespace __asan {
  27
  28 // Instruments read/write access to a single byte in memory.
  29 // On error calls __asan_report_error, which aborts the program.
  30 #define ACCESS_ADDRESS(address, isWrite)   do {         \
  31   if (!AddrIsInMem(address) || AddressIsPoisoned(address)) {                \
  32     GET_CURRENT_PC_BP_SP;                               \
  33     __asan_report_error(pc, bp, sp, address, isWrite, /* access_size */ 1); \
  34   } \
  35 } while (0)
  36
  37 // We implement ACCESS_MEMORY_RANGE, ASAN_READ_RANGE,
  38 // and ASAN_WRITE_RANGE as macro instead of function so
  39 // that no extra frames are created, and stack trace contains
  40 // relevant information only.
  41
  42 // Instruments read/write access to a memory range.
  43 // More complex implementation is possible, for now just
  44 // checking the first and the last byte of a range.
  45 #define ACCESS_MEMORY_RANGE(offset, size, isWrite) do { \
  46   if (size > 0) { \
  47     uptr ptr = (uptr)(offset); \
  48     ACCESS_ADDRESS(ptr, isWrite); \
  49     ACCESS_ADDRESS(ptr + (size) - 1, isWrite); \
  50   } \
  51 } while (0)
  52
  53 #define ASAN_READ_RANGE(offset, size) do { \
  54   ACCESS_MEMORY_RANGE(offset, size, false); \
  55 } while (0)
  56
  57 #define ASAN_WRITE_RANGE(offset, size) do { \
  58   ACCESS_MEMORY_RANGE(offset, size, true); \
  59 } while (0)
  60
  61 // Behavior of functions like "memcpy" or "strcpy" is undefined
  62 // if memory intervals overlap. We report error in this case.
  63 // Macro is used to avoid creation of new frames.
  64 static inline bool RangesOverlap(const char *offset1, uptr length1,
  65                                  const char *offset2, uptr length2) {
  66   return !((offset1 + length1 <= offset2) || (offset2 + length2 <= offset1));
  67 }
  68 #define CHECK_RANGES_OVERLAP(name, _offset1, length1, _offset2, length2) do { \
  69   const char *offset1 = (const char*)_offset1; \
  70   const char *offset2 = (const char*)_offset2; \
  71   if (RangesOverlap(offset1, length1, offset2, length2)) { \
  72     GET_STACK_TRACE_HERE(kStackTraceMax); \
  73     ReportStringFunctionMemoryRangesOverlap(name, offset1, length1, \
  74                                             offset2, length2, &stack); \
  75   } \
  76 } while (0)
  77
  78 #define ENSURE_ASAN_INITED() do { \
  79   CHECK(!asan_init_is_running); \
  80   if (!asan_inited) { \
  81     __asan_init(); \
  82   } \
  83 } while (0)
  84
  85 static inline uptr MaybeRealStrnlen(const char *s, uptr maxlen) {
  86 #if ASAN_INTERCEPT_STRNLEN
  87   if (REAL(strnlen) != 0) {
  88     return REAL(strnlen)(s, maxlen);
  89   }
  90 #endif
  91   return internal_strnlen(s, maxlen);
  92 }
  93
  94 }  // namespace __asan
  95
  96 // ---------------------- Wrappers ---------------- {{{1
  97 using namespace __asan;  // NOLINT
  98
  99 static thread_return_t THREAD_CALLING_CONV asan_thread_start(void *arg) {
 100   AsanThread *t = (AsanThread*)arg;
 101   asanThreadRegistry().SetCurrent(t);
 102   return t->ThreadStart();
 103 }
 104
 105 #if ASAN_INTERCEPT_PTHREAD_CREATE
 106 INTERCEPTOR(int, pthread_create, void *thread,
 107     void *attr, void *(*start_routine)(void*), void *arg) {
 108   GET_STACK_TRACE_HERE(kStackTraceMax);
 109   u32 current_tid = asanThreadRegistry().GetCurrentTidOrInvalid();
 110   AsanThread *t = AsanThread::Create(current_tid, start_routine, arg, &stack);
 111   asanThreadRegistry().RegisterThread(t);
 112   return REAL(pthread_create)(thread, attr, asan_thread_start, t);
 113 }
 114 #endif  // ASAN_INTERCEPT_PTHREAD_CREATE
 115
 116 #if ASAN_INTERCEPT_SIGNAL_AND_SIGACTION
 117 INTERCEPTOR(void*, signal, int signum, void *handler) {
 118   if (!AsanInterceptsSignal(signum)) {
 119     return REAL(signal)(signum, handler);
 120   }
 121   return 0;
 122 }
 123
 124 INTERCEPTOR(int, sigaction, int signum, const struct sigaction *act,
 125                             struct sigaction *oldact) {
 126   if (!AsanInterceptsSignal(signum)) {
 127     return REAL(sigaction)(signum, act, oldact);
 128   }
 129   return 0;
 130 }
 131 #elif ASAN_POSIX
 132 // We need to have defined REAL(sigaction) on posix systems.
 133 DEFINE_REAL(int, sigaction, int signum, const struct sigaction *act,
 134     struct sigaction *oldact);
 135 #endif  // ASAN_INTERCEPT_SIGNAL_AND_SIGACTION
 136
 137 INTERCEPTOR(void, longjmp, void *env, int val) {
 138   __asan_handle_no_return();
 139   REAL(longjmp)(env, val);
 140 }
 141
 142 #if ASAN_INTERCEPT__LONGJMP
 143 INTERCEPTOR(void, _longjmp, void *env, int val) {
 144   __asan_handle_no_return();
 145   REAL(_longjmp)(env, val);
 146 }
 147 #endif
 148
 149 #if ASAN_INTERCEPT_SIGLONGJMP
 150 INTERCEPTOR(void, siglongjmp, void *env, int val) {
 151   __asan_handle_no_return();
 152   REAL(siglongjmp)(env, val);
 153 }
 154 #endif
 155
 156 #if ASAN_INTERCEPT___CXA_THROW
 157 INTERCEPTOR(void, __cxa_throw, void *a, void *b, void *c) {
 158   CHECK(REAL(__cxa_throw));
 159   __asan_handle_no_return();
 160   REAL(__cxa_throw)(a, b, c);
 161 }
 162 #endif
 163
 164 // intercept mlock and friends.
 165 // Since asan maps 16T of RAM, mlock is completely unfriendly to asan.
 166 // All functions return 0 (success).
 167 static void MlockIsUnsupported() {
 168   static bool printed = 0;
 169   if (printed) return;
 170   printed = true;
 171   Printf("INFO: AddressSanitizer ignores mlock/mlockall/munlock/munlockall\n");
 172 }
 173
 174 extern "C" {
 175 INTERCEPTOR(int, mlock, const void *addr, uptr len) {
 176   MlockIsUnsupported();
 177   return 0;
 178 }
 179
 180 INTERCEPTOR(int, munlock, const void *addr, uptr len) {
 181   MlockIsUnsupported();
 182   return 0;
 183 }
 184
 185 INTERCEPTOR(int, mlockall, int flags) {
 186   MlockIsUnsupported();
 187   return 0;
 188 }
 189
 190 INTERCEPTOR(int, munlockall, void) {
 191   MlockIsUnsupported();
 192   return 0;
 193 }
 194 }  // extern "C"
 195
 196 static inline int CharCmp(unsigned char c1, unsigned char c2) {
 197   return (c1 == c2) ? 0 : (c1 < c2) ? -1 : 1;
 198 }
 199
 200 static inline int CharCaseCmp(unsigned char c1, unsigned char c2) {
 201   int c1_low = ToLower(c1);
 202   int c2_low = ToLower(c2);
 203   return c1_low - c2_low;
 204 }
 205
 206 INTERCEPTOR(int, memcmp, const void *a1, const void *a2, uptr size) {
 207   if (!asan_inited) return internal_memcmp(a1, a2, size);
 208   ENSURE_ASAN_INITED();
 209   unsigned char c1 = 0, c2 = 0;
 210   const unsigned char *s1 = (const unsigned char*)a1;
 211   const unsigned char *s2 = (const unsigned char*)a2;
 212   uptr i;
 213   for (i = 0; i < size; i++) {
 214     c1 = s1[i];
 215     c2 = s2[i];
 216     if (c1 != c2) break;
 217   }
 218   ASAN_READ_RANGE(s1, Min(i + 1, size));
 219   ASAN_READ_RANGE(s2, Min(i + 1, size));
 220   return CharCmp(c1, c2);
 221 }
 222
 223 INTERCEPTOR(void*, memcpy, void *to, const void *from, uptr size) {
 224   if (!asan_inited) return internal_memcpy(to, from, size);
 225   // memcpy is called during __asan_init() from the internals
 226   // of printf(...).
 227   if (asan_init_is_running) {
 228     return REAL(memcpy)(to, from, size);
 229   }
 230   ENSURE_ASAN_INITED();
 231   if (flags()->replace_intrin) {
 232     if (to != from) {
 233       // We do not treat memcpy with to==from as a bug.
 234       // See http://llvm.org/bugs/show_bug.cgi?id=11763.
 235       CHECK_RANGES_OVERLAP("memcpy", to, size, from, size);
 236     }
 237     ASAN_WRITE_RANGE(from, size);
 238     ASAN_READ_RANGE(to, size);
 239   }
 240   return REAL(memcpy)(to, from, size);
 241 }
 242
 243 INTERCEPTOR(void*, memmove, void *to, const void *from, uptr size) {
 244 #if MAC_INTERPOSE_FUNCTIONS
 245   if (!asan_inited) return REAL(memmove)(to, from, size);
 246 #endif
 247   if (asan_init_is_running) {
 248     return REAL(memmove)(to, from, size);
 249   }
 250   ENSURE_ASAN_INITED();
 251   if (flags()->replace_intrin) {
 252     ASAN_WRITE_RANGE(from, size);
 253     ASAN_READ_RANGE(to, size);
 254   }
 255   return REAL(memmove)(to, from, size);
 256 }
 257
 258 INTERCEPTOR(void*, memset, void *block, int c, uptr size) {
 259   if (!asan_inited) return internal_memset(block, c, size);
 260   // memset is called inside Printf.
 261   if (asan_init_is_running) {
 262     return REAL(memset)(block, c, size);
 263   }
 264   ENSURE_ASAN_INITED();
 265   if (flags()->replace_intrin) {
 266     ASAN_WRITE_RANGE(block, size);
 267   }
 268   return REAL(memset)(block, c, size);
 269 }
 270
 271 INTERCEPTOR(char*, strchr, const char *str, int c) {
 272   if (!asan_inited) return internal_strchr(str, c);
 273   // strchr is called inside create_purgeable_zone() when MallocGuardEdges=1 is
 274   // used.
 275   if (asan_init_is_running) {
 276     return REAL(strchr)(str, c);
 277   }
 278   ENSURE_ASAN_INITED();
 279   char *result = REAL(strchr)(str, c);
 280   if (flags()->replace_str) {
 281     uptr bytes_read = (result ? result - str : REAL(strlen)(str)) + 1;
 282     ASAN_READ_RANGE(str, bytes_read);
 283   }
 284   return result;
 285 }
 286
 287 #if ASAN_INTERCEPT_INDEX
 288 # if ASAN_USE_ALIAS_ATTRIBUTE_FOR_INDEX
 289 INTERCEPTOR(char*, index, const char *string, int c)
 290   ALIAS(WRAPPER_NAME(strchr));
 291 # else
 292 DEFINE_REAL(char*, index, const char *string, int c)
 293 # endif
 294 #endif  // ASAN_INTERCEPT_INDEX
 295
 296 // For both strcat() and strncat() we need to check the validity of |to|
 297 // argument irrespective of the |from| length.
 298 INTERCEPTOR(char*, strcat, char *to, const char *from) {  // NOLINT
 299   ENSURE_ASAN_INITED();
 300   if (flags()->replace_str) {
 301     uptr from_length = REAL(strlen)(from);
 302     ASAN_READ_RANGE(from, from_length + 1);
 303     uptr to_length = REAL(strlen)(to);
 304     ASAN_READ_RANGE(to, to_length);
 305     ASAN_WRITE_RANGE(to + to_length, from_length + 1);
 306     // If the copying actually happens, the |from| string should not overlap
 307     // with the resulting string starting at |to|, which has a length of
 308     // to_length + from_length + 1.
 309     if (from_length > 0) {
 310       CHECK_RANGES_OVERLAP("strcat", to, from_length + to_length + 1,
 311                            from, from_length + 1);
 312     }
 313   }
 314   return REAL(strcat)(to, from);  // NOLINT
 315 }
 316
 317 INTERCEPTOR(char*, strncat, char *to, const char *from, uptr size) {
 318   ENSURE_ASAN_INITED();
 319   if (flags()->replace_str) {
 320     uptr from_length = MaybeRealStrnlen(from, size);
 321     uptr copy_length = Min(size, from_length + 1);
 322     ASAN_READ_RANGE(from, copy_length);
 323     uptr to_length = REAL(strlen)(to);
 324     ASAN_READ_RANGE(to, to_length);
 325     ASAN_WRITE_RANGE(to + to_length, from_length + 1);
 326     if (from_length > 0) {
 327       CHECK_RANGES_OVERLAP("strncat", to, to_length + copy_length + 1,
 328                            from, copy_length);
 329     }
 330   }
 331   return REAL(strncat)(to, from, size);
 332 }
 333
 334 INTERCEPTOR(int, strcmp, const char *s1, const char *s2) {
 335   if (!asan_inited) return internal_strcmp(s1, s2);
 336   if (asan_init_is_running) {
 337     return REAL(strcmp)(s1, s2);
 338   }
 339   ENSURE_ASAN_INITED();
 340   unsigned char c1, c2;
 341   uptr i;
 342   for (i = 0; ; i++) {
 343     c1 = (unsigned char)s1[i];
 344     c2 = (unsigned char)s2[i];
 345     if (c1 != c2 || c1 == '\0') break;
 346   }
 347   ASAN_READ_RANGE(s1, i + 1);
 348   ASAN_READ_RANGE(s2, i + 1);
 349   return CharCmp(c1, c2);
 350 }
 351
 352 INTERCEPTOR(char*, strcpy, char *to, const char *from) {  // NOLINT
 353 #if MAC_INTERPOSE_FUNCTIONS
 354   if (!asan_inited) return REAL(strcpy)(to, from);  // NOLINT
 355 #endif
 356   // strcpy is called from malloc_default_purgeable_zone()
 357   // in __asan::ReplaceSystemAlloc() on Mac.
 358   if (asan_init_is_running) {
 359     return REAL(strcpy)(to, from);  // NOLINT
 360   }
 361   ENSURE_ASAN_INITED();
 362   if (flags()->replace_str) {
 363     uptr from_size = REAL(strlen)(from) + 1;
 364     CHECK_RANGES_OVERLAP("strcpy", to, from_size, from, from_size);
 365     ASAN_READ_RANGE(from, from_size);
 366     ASAN_WRITE_RANGE(to, from_size);
 367   }
 368   return REAL(strcpy)(to, from);  // NOLINT
 369 }
 370
 371 #if ASAN_INTERCEPT_STRDUP
 372 INTERCEPTOR(char*, strdup, const char *s) {
 373   if (!asan_inited) return internal_strdup(s);
 374   ENSURE_ASAN_INITED();
 375   if (flags()->replace_str) {
 376     uptr length = REAL(strlen)(s);
 377     ASAN_READ_RANGE(s, length + 1);
 378   }
 379   return REAL(strdup)(s);
 380 }
 381 #endif
 382
 383 INTERCEPTOR(uptr, strlen, const char *s) {
 384   if (!asan_inited) return internal_strlen(s);
 385   // strlen is called from malloc_default_purgeable_zone()
 386   // in __asan::ReplaceSystemAlloc() on Mac.
 387   if (asan_init_is_running) {
 388     return REAL(strlen)(s);
 389   }
 390   ENSURE_ASAN_INITED();
 391   uptr length = REAL(strlen)(s);
 392   if (flags()->replace_str) {
 393     ASAN_READ_RANGE(s, length + 1);
 394   }
 395   return length;
 396 }
 397
 398 #if ASAN_INTERCEPT_STRCASECMP_AND_STRNCASECMP
 399 INTERCEPTOR(int, strcasecmp, const char *s1, const char *s2) {
 400   ENSURE_ASAN_INITED();
 401   unsigned char c1, c2;
 402   uptr i;
 403   for (i = 0; ; i++) {
 404     c1 = (unsigned char)s1[i];
 405     c2 = (unsigned char)s2[i];
 406     if (CharCaseCmp(c1, c2) != 0 || c1 == '\0') break;
 407   }
 408   ASAN_READ_RANGE(s1, i + 1);
 409   ASAN_READ_RANGE(s2, i + 1);
 410   return CharCaseCmp(c1, c2);
 411 }
 412
 413 INTERCEPTOR(int, strncasecmp, const char *s1, const char *s2, uptr n) {
 414   ENSURE_ASAN_INITED();
 415   unsigned char c1 = 0, c2 = 0;
 416   uptr i;
 417   for (i = 0; i < n; i++) {
 418     c1 = (unsigned char)s1[i];
 419     c2 = (unsigned char)s2[i];
 420     if (CharCaseCmp(c1, c2) != 0 || c1 == '\0') break;
 421   }
 422   ASAN_READ_RANGE(s1, Min(i + 1, n));
 423   ASAN_READ_RANGE(s2, Min(i + 1, n));
 424   return CharCaseCmp(c1, c2);
 425 }
 426 #endif  // ASAN_INTERCEPT_STRCASECMP_AND_STRNCASECMP
 427
 428 INTERCEPTOR(int, strncmp, const char *s1, const char *s2, uptr size) {
 429   if (!asan_inited) return internal_strncmp(s1, s2, size);
 430   // strncmp is called from malloc_default_purgeable_zone()
 431   // in __asan::ReplaceSystemAlloc() on Mac.
 432   if (asan_init_is_running) {
 433     return REAL(strncmp)(s1, s2, size);
 434   }
 435   ENSURE_ASAN_INITED();
 436   unsigned char c1 = 0, c2 = 0;
 437   uptr i;
 438   for (i = 0; i < size; i++) {
 439     c1 = (unsigned char)s1[i];
 440     c2 = (unsigned char)s2[i];
 441     if (c1 != c2 || c1 == '\0') break;
 442   }
 443   ASAN_READ_RANGE(s1, Min(i + 1, size));
 444   ASAN_READ_RANGE(s2, Min(i + 1, size));
 445   return CharCmp(c1, c2);
 446 }
 447
 448 INTERCEPTOR(char*, strncpy, char *to, const char *from, uptr size) {
 449   ENSURE_ASAN_INITED();
 450   if (flags()->replace_str) {
 451     uptr from_size = Min(size, MaybeRealStrnlen(from, size) + 1);
 452     CHECK_RANGES_OVERLAP("strncpy", to, from_size, from, from_size);
 453     ASAN_READ_RANGE(from, from_size);
 454     ASAN_WRITE_RANGE(to, size);
 455   }
 456   return REAL(strncpy)(to, from, size);
 457 }
 458
 459 #if ASAN_INTERCEPT_STRNLEN
 460 INTERCEPTOR(uptr, strnlen, const char *s, uptr maxlen) {
 461   ENSURE_ASAN_INITED();
 462   uptr length = REAL(strnlen)(s, maxlen);
 463   if (flags()->replace_str) {
 464     ASAN_READ_RANGE(s, Min(length + 1, maxlen));
 465   }
 466   return length;
 467 }
 468 #endif  // ASAN_INTERCEPT_STRNLEN
 469
 470 static inline bool IsValidStrtolBase(int base) {
 471   return (base == 0) || (2 <= base && base <= 36);
 472 }
 473
 474 static inline void FixRealStrtolEndptr(const char *nptr, char **endptr) {
 475   CHECK(endptr != 0);
 476   if (nptr == *endptr) {
 477     // No digits were found at strtol call, we need to find out the last
 478     // symbol accessed by strtoll on our own.
 479     // We get this symbol by skipping leading blanks and optional +/- sign.
 480     while (IsSpace(*nptr)) nptr++;
 481     if (*nptr == '+' || *nptr == '-') nptr++;
 482     *endptr = (char*)nptr;
 483   }
 484   CHECK(*endptr >= nptr);
 485 }
 486
 487 INTERCEPTOR(long, strtol, const char *nptr,  // NOLINT
 488             char **endptr, int base) {
 489   ENSURE_ASAN_INITED();
 490   if (!flags()->replace_str) {
 491     return REAL(strtol)(nptr, endptr, base);
 492   }
 493   char *real_endptr;
 494   long result = REAL(strtol)(nptr, &real_endptr, base);  // NOLINT
 495   if (endptr != 0) {
 496     *endptr = real_endptr;
 497   }
 498   if (IsValidStrtolBase(base)) {
 499     FixRealStrtolEndptr(nptr, &real_endptr);
 500     ASAN_READ_RANGE(nptr, (real_endptr - nptr) + 1);
 501   }
 502   return result;
 503 }
 504
 505 INTERCEPTOR(int, atoi, const char *nptr) {
 506 #if MAC_INTERPOSE_FUNCTIONS
 507   if (!asan_inited) return REAL(atoi)(nptr);
 508 #endif
 509   ENSURE_ASAN_INITED();
 510   if (!flags()->replace_str) {
 511     return REAL(atoi)(nptr);
 512   }
 513   char *real_endptr;
 514   // "man atoi" tells that behavior of atoi(nptr) is the same as
 515   // strtol(nptr, 0, 10), i.e. it sets errno to ERANGE if the
 516   // parsed integer can't be stored in *long* type (even if it's
 517   // different from int). So, we just imitate this behavior.
 518   int result = REAL(strtol)(nptr, &real_endptr, 10);
 519   FixRealStrtolEndptr(nptr, &real_endptr);
 520   ASAN_READ_RANGE(nptr, (real_endptr - nptr) + 1);
 521   return result;
 522 }
 523
 524 INTERCEPTOR(long, atol, const char *nptr) {  // NOLINT
 525 #if MAC_INTERPOSE_FUNCTIONS
 526   if (!asan_inited) return REAL(atol)(nptr);
 527 #endif
 528   ENSURE_ASAN_INITED();
 529   if (!flags()->replace_str) {
 530     return REAL(atol)(nptr);
 531   }
 532   char *real_endptr;
 533   long result = REAL(strtol)(nptr, &real_endptr, 10);  // NOLINT
 534   FixRealStrtolEndptr(nptr, &real_endptr);
 535   ASAN_READ_RANGE(nptr, (real_endptr - nptr) + 1);
 536   return result;
 537 }
 538
 539 #if ASAN_INTERCEPT_ATOLL_AND_STRTOLL
 540 INTERCEPTOR(long long, strtoll, const char *nptr,  // NOLINT
 541             char **endptr, int base) {
 542   ENSURE_ASAN_INITED();
 543   if (!flags()->replace_str) {
 544     return REAL(strtoll)(nptr, endptr, base);
 545   }
 546   char *real_endptr;
 547   long long result = REAL(strtoll)(nptr, &real_endptr, base);  // NOLINT
 548   if (endptr != 0) {
 549     *endptr = real_endptr;
 550   }
 551   // If base has unsupported value, strtoll can exit with EINVAL
 552   // without reading any characters. So do additional checks only
 553   // if base is valid.
 554   if (IsValidStrtolBase(base)) {
 555     FixRealStrtolEndptr(nptr, &real_endptr);
 556     ASAN_READ_RANGE(nptr, (real_endptr - nptr) + 1);
 557   }
 558   return result;
 559 }
 560
 561 INTERCEPTOR(long long, atoll, const char *nptr) {  // NOLINT
 562   ENSURE_ASAN_INITED();
 563   if (!flags()->replace_str) {
 564     return REAL(atoll)(nptr);
 565   }
 566   char *real_endptr;
 567   long long result = REAL(strtoll)(nptr, &real_endptr, 10);  // NOLINT
 568   FixRealStrtolEndptr(nptr, &real_endptr);
 569   ASAN_READ_RANGE(nptr, (real_endptr - nptr) + 1);
 570   return result;
 571 }
 572 #endif  // ASAN_INTERCEPT_ATOLL_AND_STRTOLL
 573
 574 #define ASAN_INTERCEPT_FUNC(name) do { \
 575       if (!INTERCEPT_FUNCTION(name) && flags()->verbosity > 0) \
 576         Report("AddressSanitizer: failed to intercept '" #name "'\n"); \
 577     } while (0)
 578
 579 #if defined(_WIN32)
 580 INTERCEPTOR_WINAPI(DWORD, CreateThread,
 581                    void* security, uptr stack_size,
 582                    DWORD (__stdcall *start_routine)(void*), void* arg,
 583                    DWORD flags, void* tid) {
 584   GET_STACK_TRACE_HERE(kStackTraceMax);
 585   u32 current_tid = asanThreadRegistry().GetCurrentTidOrInvalid();
 586   AsanThread *t = AsanThread::Create(current_tid, start_routine, arg, &stack);
 587   asanThreadRegistry().RegisterThread(t);
 588   return REAL(CreateThread)(security, stack_size,
 589                             asan_thread_start, t, flags, tid);
 590 }
 591
 592 namespace __asan {
 593 void InitializeWindowsInterceptors() {
 594   ASAN_INTERCEPT_FUNC(CreateThread);
 595 }
 596
 597 }  // namespace __asan
 598 #endif
 599
 600 // ---------------------- InitializeAsanInterceptors ---------------- {{{1
 601 namespace __asan {
 602 void InitializeAsanInterceptors() {
 603   static bool was_called_once;
 604   CHECK(was_called_once == false);
 605   was_called_once = true;
 606 #if MAC_INTERPOSE_FUNCTIONS
 607   return;
 608 #endif
 609   // Intercept mem* functions.
 610   ASAN_INTERCEPT_FUNC(memcmp);
 611   ASAN_INTERCEPT_FUNC(memmove);
 612   ASAN_INTERCEPT_FUNC(memset);
 613   if (PLATFORM_HAS_DIFFERENT_MEMCPY_AND_MEMMOVE) {
 614     ASAN_INTERCEPT_FUNC(memcpy);
 615   } else {
 616 #if !MAC_INTERPOSE_FUNCTIONS
 617     // If we're using dynamic interceptors on Mac, these two are just plain
 618     // functions.
 619     internal_memcpy(&REAL(memcpy), &REAL(memmove), sizeof(REAL(memmove)));
 620 #endif
 621   }
 622
 623   // Intercept str* functions.
 624   ASAN_INTERCEPT_FUNC(strcat);  // NOLINT
 625   ASAN_INTERCEPT_FUNC(strchr);
 626   ASAN_INTERCEPT_FUNC(strcmp);
 627   ASAN_INTERCEPT_FUNC(strcpy);  // NOLINT
 628   ASAN_INTERCEPT_FUNC(strlen);
 629   ASAN_INTERCEPT_FUNC(strncat);
 630   ASAN_INTERCEPT_FUNC(strncmp);
 631   ASAN_INTERCEPT_FUNC(strncpy);
 632 #if ASAN_INTERCEPT_STRCASECMP_AND_STRNCASECMP
 633   ASAN_INTERCEPT_FUNC(strcasecmp);
 634   ASAN_INTERCEPT_FUNC(strncasecmp);
 635 #endif
 636 #if ASAN_INTERCEPT_STRDUP
 637   ASAN_INTERCEPT_FUNC(strdup);
 638 #endif
 639 #if ASAN_INTERCEPT_STRNLEN
 640   ASAN_INTERCEPT_FUNC(strnlen);
 641 #endif
 642 #if ASAN_INTERCEPT_INDEX
 643 # if ASAN_USE_ALIAS_ATTRIBUTE_FOR_INDEX
 644   ASAN_INTERCEPT_FUNC(index);
 645 # else
 646   CHECK(OVERRIDE_FUNCTION(index, WRAP(strchr)));
 647 # endif
 648 #endif
 649
 650   ASAN_INTERCEPT_FUNC(atoi);
 651   ASAN_INTERCEPT_FUNC(atol);
 652   ASAN_INTERCEPT_FUNC(strtol);
 653 #if ASAN_INTERCEPT_ATOLL_AND_STRTOLL
 654   ASAN_INTERCEPT_FUNC(atoll);
 655   ASAN_INTERCEPT_FUNC(strtoll);
 656 #endif
 657
 658 #if ASAN_INTERCEPT_MLOCKX
 659   // Intercept mlock/munlock.
 660   ASAN_INTERCEPT_FUNC(mlock);
 661   ASAN_INTERCEPT_FUNC(munlock);
 662   ASAN_INTERCEPT_FUNC(mlockall);
 663   ASAN_INTERCEPT_FUNC(munlockall);
 664 #endif
 665
 666   // Intecept signal- and jump-related functions.
 667   ASAN_INTERCEPT_FUNC(longjmp);
 668 #if ASAN_INTERCEPT_SIGNAL_AND_SIGACTION
 669   ASAN_INTERCEPT_FUNC(sigaction);
 670   ASAN_INTERCEPT_FUNC(signal);
 671 #endif
 672 #if ASAN_INTERCEPT__LONGJMP
 673   ASAN_INTERCEPT_FUNC(_longjmp);
 674 #endif
 675 #if ASAN_INTERCEPT_SIGLONGJMP
 676   ASAN_INTERCEPT_FUNC(siglongjmp);
 677 #endif
 678
 679   // Intercept exception handling functions.
 680 #if ASAN_INTERCEPT___CXA_THROW
 681   INTERCEPT_FUNCTION(__cxa_throw);
 682 #endif
 683
 684   // Intercept threading-related functions
 685 #if ASAN_INTERCEPT_PTHREAD_CREATE
 686   ASAN_INTERCEPT_FUNC(pthread_create);
 687 #endif
 688
 689   // Some Windows-specific interceptors.
 690 #if defined(_WIN32)
 691   InitializeWindowsInterceptors();
 692 #endif
 693
 694   // Some Mac-specific interceptors.
 695 #if defined(__APPLE__)
 696   InitializeMacInterceptors();
 697 #endif
 698
 699   if (flags()->verbosity > 0) {
 700     Report("AddressSanitizer: libc interceptors initialized\n");
 701   }
 702 }
 703
 704 }  // namespace __asan