|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
References
projects/compiler-rt/lib/asan/asan_allocator.cpp 535 REAL(memset)(res, fl.malloc_fill_byte, fill_size);
582 REAL(memset)((void *)scribble_start, fl.free_fill_byte, size_to_fill);
665 CHECK_NE(REAL(memcpy), nullptr);
669 REAL(memcpy)(new_ptr, old_ptr, memcpy_size);
685 REAL(memset)(ptr, 0, nmemb * size);
projects/compiler-rt/lib/asan/asan_fake_stack.cpp 279 REAL(memset)(reinterpret_cast<void*>(MemToShadow(top)), 0,
projects/compiler-rt/lib/asan/asan_interceptors.cpp 57 if (REAL(strnlen)) {
58 return REAL(strnlen)(s, maxlen);
217 REAL(pthread_attr_getdetachstate)(attr, &detached);
230 result = REAL(pthread_create)(thread, attr, asan_thread_start, ¶m);
289 int res = REAL(swapcontext)(oucp, ucp);
307 REAL(longjmp)(env, val);
313 REAL(_longjmp)(env, val);
320 REAL(__longjmp_chk)(env, val);
327 REAL(siglongjmp)(env, val);
333 CHECK(REAL(__cxa_throw));
335 REAL(__cxa_throw)(a, b, c);
341 CHECK(REAL(__cxa_rethrow_primary_exception));
343 REAL(__cxa_rethrow_primary_exception)(a);
350 CHECK(REAL(_Unwind_RaiseException));
352 return REAL(_Unwind_RaiseException)(object);
386 uptr from_length = REAL(strlen)(from);
388 uptr to_length = REAL(strlen)(to);
399 return REAL(strcat)(to, from);
410 uptr to_length = REAL(strlen)(to);
418 return REAL(strncat)(to, from, size);
431 return REAL(strcpy)(to, from);
435 uptr from_size = REAL(strlen)(from) + 1;
440 return REAL(strcpy)(to, from);
448 uptr length = REAL(strlen)(s);
454 REAL(memcpy)(new_mem, s, length + 1);
464 uptr length = REAL(strlen)(s);
470 REAL(memcpy)(new_mem, s, length + 1);
485 return REAL(strncpy)(to, from, size);
493 return REAL(strtol)(nptr, endptr, base);
496 long result = REAL(strtol)(nptr, &real_endptr, base);
509 return REAL(atoi)(nptr);
516 int result = REAL(strtol)(nptr, &real_endptr, 10);
530 return REAL(atol)(nptr);
533 long result = REAL(strtol)(nptr, &real_endptr, 10);
545 return REAL(strtoll)(nptr, endptr, base);
548 long long result = REAL(strtoll)(nptr, &real_endptr, base);
558 return REAL(atoll)(nptr);
561 long long result = REAL(strtoll)(nptr, &real_endptr, 10);
585 int res = REAL(__cxa_atexit)(func, arg, dso_handle);
586 REAL(__cxa_atexit)(AtCxaAtexit, nullptr, nullptr);
projects/compiler-rt/lib/asan/asan_malloc_linux.cpp 58 REAL(memset)(prev_mem, 0, last_dlsym_alloc_size_in_words * kWordSize);
214 REAL(memset)(&res, 0, sizeof(res));
projects/compiler-rt/lib/asan/asan_poisoning.cpp 39 CHECK(REAL(memset));
140 REAL(memset)(beg.chunk, kAsanUserPoisonedMemoryMagic, end.chunk - beg.chunk);
171 REAL(memset)(beg.chunk, 0, end.chunk - beg.chunk);
321 REAL(memset)((void *)addr, 0, size);
325 REAL(memset)((void *)addr, 0xf1, size);
329 REAL(memset)((void *)addr, 0xf2, size);
333 REAL(memset)((void *)addr, 0xf3, size);
337 REAL(memset)((void *)addr, 0xf5, size);
341 REAL(memset)((void *)addr, 0xf8, size);
projects/compiler-rt/lib/asan/asan_poisoning.h 58 REAL(memset)((void*)shadow_beg, value, shadow_end - shadow_beg);
65 REAL(memset)((void *)shadow_beg, 0, shadow_end - shadow_beg);
68 REAL(memset)((void *)shadow_beg, 0, page_beg - shadow_beg);
71 REAL(memset)((void *)page_end, 0, shadow_end - page_end);
projects/compiler-rt/lib/asan/asan_stats.cpp 28 CHECK(REAL(memset));
29 REAL(memset)(this, 0, sizeof(AsanStats));
projects/compiler-rt/lib/cfi/cfi.cpp 426 void *handle = REAL(dlopen)(filename, flag);
434 int res = REAL(dlclose)(handle);
projects/compiler-rt/lib/dfsan/dfsan_interceptors.cpp 22 void *res = REAL(mmap)(addr, length, prot, flags, fd, offset);
30 void *res = REAL(mmap64)(addr, length, prot, flags, fd, offset);
projects/compiler-rt/lib/hwasan/hwasan_interceptors.cpp 212 int res = REAL(pthread_create)(UntagPtr(th), UntagPtr(attr),
234 int pid = REAL(fork)();
projects/compiler-rt/lib/lsan/lsan_interceptors.cpp 390 return REAL(strerror)(errnum);
448 res = REAL(pthread_create)(th, attr, __lsan_thread_start_func, &p);
466 int res = REAL(pthread_join)(th, ret);
474 REAL(_exit)(status);
projects/compiler-rt/lib/msan/msan_interceptors.cpp 136 SIZE_T res = REAL(fread_unlocked)(ptr, size, nmemb, file);
157 void *res = REAL(memccpy)(dest, src, c, n);
259 REAL(memset)(sret, 0, sizeof(*sret));
288 SIZE_T n = REAL(strlen)(src);
290 char *res = REAL(strcpy)(dest, src);
298 SIZE_T copy_size = REAL(strnlen)(src, n);
301 char *res = REAL(strncpy)(dest, src, n);
311 SIZE_T n = REAL(strlen)(src);
313 char *res = REAL(stpcpy)(dest, src);
327 SIZE_T n = REAL(strlen)(src);
329 char *res = REAL(strdup)(src);
338 SIZE_T n = REAL(strlen)(src);
340 char *res = REAL(__strdup)(src);
352 char *res = REAL(gcvt)(number, ndigit, buf);
353 SIZE_T n = REAL(strlen)(buf);
365 SIZE_T src_size = REAL(strlen)(src);
366 SIZE_T dest_size = REAL(strlen)(dest);
369 char *res = REAL(strcat)(dest, src);
377 SIZE_T dest_size = REAL(strlen)(dest);
378 SIZE_T copy_size = REAL(strnlen)(src, n);
380 char *res = REAL(strncat)(dest, src, n);
473 int res = REAL(vswprintf)(str, size, format, ap);
541 int res = REAL(mbtowc)(dest, src, n);
549 SIZE_T res = REAL(mbrtowc)(dest, src, n, ps);
558 wchar_t *res = REAL(wmemcpy)(dest, src, n);
567 wchar_t *res = REAL(wmempcpy)(dest, src, n);
579 wchar_t *res = REAL(wmemset)(s, c, n);
587 wchar_t *res = REAL(wmemmove)(dest, src, n);
594 int res = REAL(wcscmp)(s1, s2);
600 int res = REAL(gettimeofday)(tv, tz);
611 char *res = REAL(fcvt)(x, a, b, c);
614 if (res) __msan_unpoison(res, REAL(strlen)(res) + 1);
624 return REAL(getenv)(name);
626 char *res = REAL(getenv)(name);
627 if (res) __msan_unpoison(res, REAL(strlen)(res) + 1);
637 __msan_unpoison(*envp, REAL(strlen)(*envp) + 1);
646 int res = REAL(setenv)(name, value, overwrite);
653 int res = REAL(putenv)(string);
674 int res = REAL(__fxstat)(magic, fd, buf);
687 int res = REAL(__fxstat64)(magic, fd, buf);
709 int res = REAL(__fxstatat)(magic, fd, pathname, buf, flags);
720 int res = REAL(__fxstatat64)(magic, fd, pathname, buf, flags);
731 return REAL(pipe)(pipefd);
733 int res = REAL(pipe)(pipefd);
741 int res = REAL(pipe2)(pipefd, flags);
749 int res = REAL(socketpair)(domain, type, protocol, sv);
758 char *res = REAL(fgets_unlocked)(s, size, stream);
760 __msan_unpoison(s, REAL(strlen)(s) + 1);
787 if (msan_init_is_running) return REAL(getrlimit64)(resource, rlim);
789 int res = REAL(getrlimit64)(resource, rlim);
797 return REAL(prlimit)(pid, resource, new_rlimit, old_rlimit);
800 int res = REAL(prlimit)(pid, resource, new_rlimit, old_rlimit);
808 return REAL(prlimit64)(pid, resource, new_rlimit, old_rlimit);
811 int res = REAL(prlimit64)(pid, resource, new_rlimit, old_rlimit);
843 int res = REAL(uname)(utsname);
853 int res = REAL(gethostname)(name, len);
855 SIZE_T real_len = REAL(strnlen)(name, len);
867 int res = REAL(epoll_wait)(epfd, events, maxevents, timeout);
882 int res = REAL(epoll_pwait)(epfd, events, maxevents, timeout, sigmask);
971 int res = REAL(getrusage)(who, usage);
1052 int res = REAL(pthread_create)(th, attr, MsanThreadStartFunc, t);
1064 if (msan_init_is_running) return REAL(pthread_key_create)(key, dtor);
1066 int res = REAL(pthread_key_create)(key, dtor);
1079 int res = REAL(pthread_join)(th, retval);
1090 REAL(tzset)(fake);
1092 __msan_unpoison(tzname[0], REAL(strlen)(tzname[0]) + 1);
1094 __msan_unpoison(tzname[1], REAL(strlen)(tzname[1]) + 1);
1148 if (msan_init_is_running) return REAL(__cxa_atexit)(func, arg, dso_handle);
1156 return REAL(__cxa_atexit)((void (*)(void *a))func, 0, 0);
1173 res = REAL(__cxa_atexit)((void (*)(void *a))MSanAtExitWrapper, 0, 0);
1178 res = REAL(__cxa_atexit)(MSanCxaAtExitWrapper, r, dso);
1196 int pid = REAL(fork)();
1208 int res = REAL(openpty)(aparent, aworker, name, termp, winp);
1227 int res = REAL(forkpty)(aparent, name, termp, winp);
1385 REAL(memcpy)(pnew_act, act, sizeof(__sanitizer_sigaction));
1395 res = REAL(SIGACTION_SYMNAME)(signo, pnew_act, oldact);
1403 res = REAL(SIGACTION_SYMNAME)(signo, act, oldact);
1446 int res = REAL(dladdr)(addr, info);
1450 __msan_unpoison(info->dli_fname, REAL(strlen)(info->dli_fname) + 1);
1452 __msan_unpoison(info->dli_sname, REAL(strlen)(info->dli_sname) + 1);
1460 char *res = REAL(dlerror)(fake);
1461 if (res) __msan_unpoison(res, REAL(strlen)(res) + 1);
1479 __msan_unpoison(info->dlpi_name, REAL(strlen)(info->dlpi_name) + 1);
1488 void *p = REAL(shmat)(shmid, shmaddr, shmflg);
1491 int res = REAL(shmctl)(shmid, shmctl_ipc_stat, &ds);
1505 int res = REAL(dl_iterate_phdr)(msan_dl_iterate_phdr_cb, (void *)&cbdata);
1512 wchar_t *res = REAL(wcschr)(s, wc, ps);
1520 wchar_t *res = REAL(wcscpy)(dest, src);
1521 CopyShadowAndOrigin(dest, src, sizeof(wchar_t) * (REAL(wcslen)(src) + 1),
1529 SIZE_T copy_size = REAL(wcsnlen)(src, n);
1531 wchar_t *res = REAL(wcsncpy)(dest, src, n);
1557 REAL(memset)(a, 0, size);
1564 return REAL(memcpy)(dest, src, n);
1567 void *res = REAL(memcpy)(dest, src, n);
1574 if (msan_init_is_running) return REAL(memset)(s, c, n);
1576 void *res = REAL(memset)(s, c, n);
1583 if (msan_init_is_running) return REAL(memmove)(dest, src, n);
1586 void *res = REAL(memmove)(dest, src, n);
1593 __msan_unpoison(s, REAL(strlen)(s) + 1);
projects/compiler-rt/lib/msan/msan_poisoning.cpp 91 REAL(memcpy)((void *)MEM_TO_ORIGIN(beg), (void *)MEM_TO_ORIGIN(s),
102 REAL(memmove)((void *)MEM_TO_SHADOW((uptr)dst),
111 REAL(memcpy)((void *)MEM_TO_SHADOW((uptr)dst),
117 REAL(memcpy)(dst, src, size);
127 REAL(memset)((void *)shadow_beg, value, shadow_end - shadow_beg);
133 REAL(memset)((void *)shadow_beg, 0, shadow_end - shadow_beg);
136 REAL(memset)((void *)shadow_beg, 0, page_beg - shadow_beg);
139 REAL(memset)((void *)page_end, 0, shadow_end - page_end);
projects/compiler-rt/lib/safestack/safestack.cpp 241 return REAL(pthread_create)(thread, attr, thread_start, tinfo);
projects/compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors.inc 368 SIZE_T result = REAL(strlen)(s);
382 SIZE_T length = REAL(strnlen)(s, maxlen);
417 char *domain = REAL(textdomain)(domainname);
419 COMMON_INTERCEPTOR_INITIALIZE_RANGE(domain, REAL(strlen)(domain) + 1);
557 uptr len1 = REAL(strlen)(s1);
558 uptr len2 = REAL(strlen)(s2);
574 char *r = REAL(strstr)(s1, s2);
595 char *r = REAL(strcasestr)(s1, s2);
614 return REAL(strtok)(str, delimiters);
622 COMMON_INTERCEPTOR_READ_RANGE(ctx, str, REAL(strlen)(str) + 1);
625 REAL(strlen)(delimiters) + 1);
626 return REAL(strtok)(str, delimiters);
637 char *result = REAL(strtok)(str, delimiters);
639 COMMON_INTERCEPTOR_READ_RANGE(ctx, result, REAL(strlen)(result) + 1);
643 COMMON_INTERCEPTOR_READ_RANGE(ctx, str, REAL(strlen)(str) + 1);
663 void *r = REAL(memmem)(s1, len1, s2, len2);
684 char *result = REAL(strchr)(s, c);
688 (result ? result - s : REAL(strlen)(s)) + 1);
701 char *result = REAL(strchrnul)(s, c);
719 COMMON_INTERCEPTOR_READ_RANGE(ctx, s, REAL(strlen)(s) + 1);
720 return REAL(strrchr)(s, c);
731 SIZE_T r = REAL(strspn)(s1, s2);
733 COMMON_INTERCEPTOR_READ_RANGE(ctx, s2, REAL(strlen)(s2) + 1);
742 SIZE_T r = REAL(strcspn)(s1, s2);
744 COMMON_INTERCEPTOR_READ_RANGE(ctx, s2, REAL(strlen)(s2) + 1);
761 char *r = REAL(strpbrk)(s1, s2);
763 COMMON_INTERCEPTOR_READ_RANGE(ctx, s2, REAL(strlen)(s2) + 1);
765 r ? r - s1 + 1 : REAL(strlen)(s1) + 1);
871 return MemcmpInterceptorCommon(ctx, REAL(memcmp), a1, a2, size);
885 return MemcmpInterceptorCommon(ctx, REAL(bcmp), a1, a2, size);
907 void *res = REAL(memchr)(s, c, n);
924 return REAL(memrchr)(s, c, n);
938 double res = REAL(frexp)(x, exp);
954 float res = REAL(frexpf)(x, exp);
965 long double res = REAL(frexpl)(x, exp);
1006 SSIZE_T res = REAL(read)(fd, ptr, count);
1024 SIZE_T res = REAL(fread)(ptr, size, nmemb, file);
1041 SSIZE_T res = REAL(pread)(fd, ptr, count, offset);
1059 SSIZE_T res = REAL(pread64)(fd, ptr, count, offset);
1075 SSIZE_T res = REAL(readv)(fd, iov, iovcnt);
1091 SSIZE_T res = REAL(preadv)(fd, iov, iovcnt, offset);
1107 SSIZE_T res = REAL(preadv64)(fd, iov, iovcnt, offset);
1123 SSIZE_T res = REAL(write)(fd, ptr, count);
1138 SIZE_T res = REAL(fwrite)(p, size, nmemb, file);
1153 SSIZE_T res = REAL(pwrite)(fd, ptr, count, offset);
1169 SSIZE_T res = REAL(pwrite64)(fd, ptr, count, offset);
1185 SSIZE_T res = REAL(writev)(fd, iov, iovcnt);
1201 SSIZE_T res = REAL(pwritev)(fd, iov, iovcnt, offset);
1217 SSIZE_T res = REAL(pwritev64)(fd, iov, iovcnt, offset);
1234 char *res = REAL(fgets)(s, size, file);
1236 COMMON_INTERCEPTOR_WRITE_RANGE(ctx, s, REAL(strlen)(s) + 1);
1250 COMMON_INTERCEPTOR_READ_RANGE(ctx, s, REAL(strlen)(s) + 1);
1252 return REAL(fputs)(s, file);
1265 COMMON_INTERCEPTOR_READ_RANGE(ctx, s, REAL(strlen)(s) + 1);
1267 return REAL(puts)(s);
1280 int res = REAL(prctl(option, arg2, arg3, arg4, arg5));
1299 unsigned long res = REAL(time)(&local_t);
1319 REAL(strlen(tm->tm_zone)) + 1);
1326 __sanitizer_tm *res = REAL(localtime)(timep);
1336 __sanitizer_tm *res = REAL(localtime_r)(timep, result);
1346 __sanitizer_tm *res = REAL(gmtime)(timep);
1356 __sanitizer_tm *res = REAL(gmtime_r)(timep, result);
1369 char *res = REAL(ctime)(timep);
1372 COMMON_INTERCEPTOR_WRITE_RANGE(ctx, res, REAL(strlen)(res) + 1);
1382 char *res = REAL(ctime_r)(timep, result);
1385 COMMON_INTERCEPTOR_WRITE_RANGE(ctx, res, REAL(strlen)(res) + 1);
1395 char *res = REAL(asctime)(tm);
1398 COMMON_INTERCEPTOR_WRITE_RANGE(ctx, res, REAL(strlen)(res) + 1);
1408 char *res = REAL(asctime_r)(tm, result);
1411 COMMON_INTERCEPTOR_WRITE_RANGE(ctx, res, REAL(strlen)(res) + 1);
1425 long res = REAL(mktime)(tm);
1448 COMMON_INTERCEPTOR_READ_RANGE(ctx, format, REAL(strlen)(format) + 1);
1452 char *res = REAL(strptime)(s, format, tm);
1819 if (!common_flags()->handle_ioctl) return REAL(ioctl)(d, request, arg);
1836 int res = REAL(ioctl)(d, request, arg);
1854 REAL(strlen)(pwd->pw_name) + 1);
1857 REAL(strlen)(pwd->pw_passwd) + 1);
1861 REAL(strlen)(pwd->pw_gecos) + 1);
1870 REAL(strlen)(pwd->pw_dir) + 1);
1873 REAL(strlen)(pwd->pw_shell) + 1);
1882 REAL(strlen)(grp->gr_name) + 1);
1885 REAL(strlen)(grp->gr_passwd) + 1);
1888 COMMON_INTERCEPTOR_WRITE_RANGE(ctx, *p, REAL(strlen)(*p) + 1);
1901 COMMON_INTERCEPTOR_READ_RANGE(ctx, name, REAL(strlen)(name) + 1);
1902 __sanitizer_passwd *res = REAL(getpwnam)(name);
1909 __sanitizer_passwd *res = REAL(getpwuid)(uid);
1916 COMMON_INTERCEPTOR_READ_RANGE(ctx, name, REAL(strlen)(name) + 1);
1917 __sanitizer_group *res = REAL(getgrnam)(name);
1924 __sanitizer_group *res = REAL(getgrgid)(gid);
1942 COMMON_INTERCEPTOR_READ_RANGE(ctx, name, REAL(strlen)(name) + 1);
1946 int res = REAL(getpwnam_r)(name, pwd, buf, buflen, result);
1959 int res = REAL(getpwuid_r)(uid, pwd, buf, buflen, result);
1969 COMMON_INTERCEPTOR_READ_RANGE(ctx, name, REAL(strlen)(name) + 1);
1973 int res = REAL(getgrnam_r)(name, grp, buf, buflen, result);
1986 int res = REAL(getgrgid_r)(gid, grp, buf, buflen, result);
2005 __sanitizer_passwd *res = REAL(getpwent)(dummy);
2012 __sanitizer_group *res = REAL(getgrent)(dummy);
2027 __sanitizer_passwd *res = REAL(fgetpwent)(fp);
2034 __sanitizer_group *res = REAL(fgetgrent)(fp);
2053 int res = REAL(getpwent_r)(pwbuf, buf, buflen, pwbufp);
2066 int res = REAL(getgrent_r)(pwbuf, buf, buflen, pwbufp);
2087 int res = REAL(fgetpwent_r)(fp, pwbuf, buf, buflen, pwbufp);
2107 int res = REAL(fgetgrent_r)(fp, pwbuf, buf, buflen, pwbufp);
2126 REAL(setpwent)(dummy);
2131 REAL(endpwent)(dummy);
2136 REAL(setgrent)(dummy);
2141 REAL(endgrent)(dummy);
2159 int res = REAL(clock_getres)(clk_id, tp);
2171 int res = REAL(clock_gettime)(clk_id, tp);
2182 return REAL(clock_gettime)(clk_id, tp);
2190 return REAL(clock_settime)(clk_id, tp);
2207 int res = REAL(getitimer)(which, curr_value);
2232 int res = REAL(setitimer)(which, new_value, old_value);
2254 COMMON_INTERCEPTOR_WRITE_RANGE(ctx, p, REAL(strlen)(p) + 1);
2284 COMMON_INTERCEPTOR_INITIALIZE_RANGE(s, REAL(strlen)(s) + 1);
2290 COMMON_INTERCEPTOR_INITIALIZE_RANGE(s, REAL(strlen)(s) + 1);
2296 COMMON_INTERCEPTOR_INITIALIZE_RANGE(s, REAL(strlen)(s) + 1);
2321 int res = REAL(glob)(pattern, flags, errfunc, pglob);
2357 int res = REAL(glob64)(pattern, flags, errfunc, pglob);
2385 int res = REAL(wait)(status);
2403 int res = REAL(waitid)(idtype, id, infop, options);
2414 int res = REAL(waitpid)(pid, status, options);
2425 int res = REAL(wait3)(status, options, rusage);
2454 int res = REAL(wait4)(pid, status, options, rusage);
2483 char *res = REAL(inet_ntop)(af, src, dst, size);
2484 if (res) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, res, REAL(strlen)(res) + 1);
2495 int res = REAL(inet_pton)(af, src, dst);
2513 if (cp) COMMON_INTERCEPTOR_READ_RANGE(ctx, cp, REAL(strlen)(cp) + 1);
2517 int res = REAL(inet_aton)(cp, dst);
2536 int res = REAL(pthread_getschedparam)(thread, policy, param);
2555 if (node) COMMON_INTERCEPTOR_READ_RANGE(ctx, node, REAL(strlen)(node) + 1);
2557 COMMON_INTERCEPTOR_READ_RANGE(ctx, service, REAL(strlen)(service) + 1);
2563 int res = REAL(getaddrinfo)(node, service, hints, out);
2573 REAL(strlen)(p->ai_canonname) + 1);
2596 REAL(getnameinfo)(sockaddr, salen, host, hostlen, serv, servlen, flags);
2599 COMMON_INTERCEPTOR_WRITE_RANGE(ctx, host, REAL(strlen)(host) + 1);
2601 COMMON_INTERCEPTOR_WRITE_RANGE(ctx, serv, REAL(strlen)(serv) + 1);
2619 int res = REAL(getsockname)(sock_fd, addr, addrlen);
2634 COMMON_INTERCEPTOR_WRITE_RANGE(ctx, h->h_name, REAL(strlen)(h->h_name) + 1);
2637 COMMON_INTERCEPTOR_WRITE_RANGE(ctx, *p, REAL(strlen)(*p) + 1);
2656 struct __sanitizer_hostent *res = REAL(gethostbyname)(name);
2666 struct __sanitizer_hostent *res = REAL(gethostbyaddr)(addr, len, type);
2674 struct __sanitizer_hostent *res = REAL(gethostent)(fake);
2690 struct __sanitizer_hostent *res = REAL(gethostbyname2)(name, af);
2709 int res = REAL(gethostbyname_r)(name, ret, buf, buflen, result, h_errnop);
2732 int res = REAL(gethostent_r)(ret, buf, buflen, result, h_errnop);
2758 int res = REAL(gethostbyaddr_r)(addr, len, type, ret, buf, buflen, result,
2785 REAL(gethostbyname2_r)(name, af, ret, buf, buflen, result, h_errnop);
2810 int res = REAL(getsockopt)(sockfd, level, optname, optval, optlen);
2829 int fd2 = REAL(accept)(fd, addr, addrlen);
2854 int fd2 = REAL(accept4)(fd, addr, addrlen, f);
2898 double res = REAL(modf)(x, iptr);
2910 float res = REAL(modff)(x, iptr);
2922 long double res = REAL(modfl)(x, iptr);
2959 SSIZE_T res = REAL(recvmsg)(fd, msg, flags);
2980 int res = REAL(recvmmsg)(fd, msgvec, vlen, flags, timeout);
3058 SSIZE_T res = REAL(sendmsg)(fd, msg, flags);
3077 int res = REAL(sendmmsg)(fd, msgvec, vlen, flags);
3102 int res = REAL(getpeername)(sockfd, addr, addrlen);
3119 int res = REAL(sysinfo)(info);
3133 COMMON_INTERCEPTOR_READ_RANGE(ctx, path, REAL(strlen)(path) + 1);
3134 __sanitizer_dirent *res = REAL(opendir)(path);
3146 __sanitizer_dirent *res = REAL(readdir)(dirp);
3158 int res = REAL(readdir_r)(dirp, entry, result);
3182 __sanitizer_dirent64 *res = REAL(readdir64)(dirp);
3194 int res = REAL(readdir64_r)(dirp, entry, result);
3242 uptr res = REAL(ptrace)(request, pid, addr, data);
3288 COMMON_INTERCEPTOR_READ_RANGE(ctx, locale, REAL(strlen)(locale) + 1);
3289 char *res = REAL(setlocale)(category, locale);
3291 COMMON_INTERCEPTOR_WRITE_RANGE(ctx, res, REAL(strlen)(res) + 1);
3309 char *res = REAL(getcwd)(buf, size);
3310 if (res) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, res, REAL(strlen)(res) + 1);
3325 char *res = REAL(get_current_dir_name)(fake);
3326 if (res) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, res, REAL(strlen)(res) + 1);
3375 INTMAX_T res = REAL(strtoimax)(nptr, &real_endptr, base);
3387 UINTMAX_T res = REAL(strtoumax)(nptr, &real_endptr, base);
3406 SIZE_T res = REAL(mbstowcs)(dest, src, len);
3423 SIZE_T res = REAL(mbsrtowcs)(dest, src, len, ps);
3453 SIZE_T res = REAL(mbsnrtowcs)(dest, src, nms, len, ps);
3473 SIZE_T res = REAL(wcstombs)(dest, src, len);
3490 SIZE_T res = REAL(wcsrtombs)(dest, src, len, ps);
3518 SIZE_T res = REAL(wcsnrtombs)(dest, src, nms, len, ps);
3539 return REAL(wcrtomb)(dest, src, ps);
3542 SIZE_T res = REAL(wcrtomb)(local_dest, src, ps);
3546 REAL(memcpy)(dest, local_dest, res);
3561 return REAL(wctomb)(dest, src);
3564 int res = REAL(wctomb)(local_dest, src);
3568 REAL(memcpy)(dest, local_dest, res);
3585 int res = REAL(tcgetattr)(fd, termios_p);
3600 if (path) COMMON_INTERCEPTOR_READ_RANGE(ctx, path, REAL(strlen)(path) + 1);
3610 char *res = REAL(realpath)(path, resolved_path);
3612 if (res) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, res, REAL(strlen)(res) + 1);
3624 if (path) COMMON_INTERCEPTOR_READ_RANGE(ctx, path, REAL(strlen)(path) + 1);
3625 char *res = REAL(canonicalize_file_name)(path);
3626 if (res) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, res, REAL(strlen)(res) + 1);
3642 SIZE_T res = REAL(confstr)(name, buf, len);
3659 int res = REAL(sched_getaffinity)(pid, cpusetsize, mask);
3672 int res = REAL(sched_getparam)(pid, param);
3686 char *res = REAL(strerror)(errnum);
3687 if (res) COMMON_INTERCEPTOR_INITIALIZE_RANGE(res, REAL(strlen)(res) + 1);
3727 char *res = REAL(strerror_r)(errnum, buf, buflen);
3729 COMMON_INTERCEPTOR_WRITE_RANGE(ctx, res, REAL(strlen)(res) + 1);
3731 COMMON_INTERCEPTOR_INITIALIZE_RANGE(res, REAL(strlen)(res) + 1);
3748 int res = REAL(__xpg_strerror_r)(errnum, buf, buflen);
3751 COMMON_INTERCEPTOR_WRITE_RANGE(ctx, buf, REAL(strlen)(buf) + 1);
3787 if (dirp) COMMON_INTERCEPTOR_READ_RANGE(ctx, dirp, REAL(strlen)(dirp) + 1);
3793 int res = REAL(scandir)(dirp, namelist,
3840 if (dirp) COMMON_INTERCEPTOR_READ_RANGE(ctx, dirp, REAL(strlen)(dirp) + 1);
3847 REAL(scandir64)(dirp, namelist,
3873 int res = REAL(getgroups)(size, lst);
3936 if (s) COMMON_INTERCEPTOR_READ_RANGE(ctx, s, REAL(strlen)(s) + 1);
3940 int res = REAL(wordexp)(s, p, flags);
3948 if (w) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, w, REAL(strlen)(w) + 1);
3966 int res = REAL(sigwait)(set, sig);
3983 int res = REAL(sigwaitinfo)(set, info);
4002 int res = REAL(sigtimedwait)(set, info, timeout);
4018 int res = REAL(sigemptyset)(set);
4029 int res = REAL(sigfillset)(set);
4047 int res = REAL(sigpending)(set);
4065 int res = REAL(sigprocmask)(how, set, oldset);
4084 int res = REAL(pthread_sigmask)(how, set, oldset);
4101 int res = REAL(backtrace)(buffer, size);
4115 char **res = REAL(backtrace_symbols)(buffer, size);
4119 COMMON_INTERCEPTOR_WRITE_RANGE(ctx, res[i], REAL(strlen(res[i])) + 1);
4138 REAL(_exit)(status);
4150 int res = REAL(pthread_mutex_lock)(m);
4164 int res = REAL(pthread_mutex_unlock)(m);
4221 REAL(strlen)(mnt->mnt_fsname) + 1);
4224 REAL(strlen)(mnt->mnt_dir) + 1);
4227 REAL(strlen)(mnt->mnt_type) + 1);
4230 REAL(strlen)(mnt->mnt_opts) + 1);
4238 __sanitizer_mntent *res = REAL(getmntent)(fp);
4252 __sanitizer_mntent *res = REAL(getmntent_r)(fp, mntbuf, buf, buflen);
4265 if (path) COMMON_INTERCEPTOR_READ_RANGE(ctx, path, REAL(strlen)(path) + 1);
4269 int res = REAL(statfs)(path, buf);
4279 int res = REAL(fstatfs)(fd, buf);
4294 if (path) COMMON_INTERCEPTOR_READ_RANGE(ctx, path, REAL(strlen)(path) + 1);
4298 int res = REAL(statfs64)(path, buf);
4308 int res = REAL(fstatfs64)(fd, buf);
4323 if (path) COMMON_INTERCEPTOR_READ_RANGE(ctx, path, REAL(strlen)(path) + 1);
4327 int res = REAL(statvfs)(path, buf);
4338 int res = REAL(fstatvfs)(fd, buf);
4357 if (path) COMMON_INTERCEPTOR_READ_RANGE(ctx, path, REAL(strlen)(path) + 1);
4361 int res = REAL(statvfs64)(path, buf);
4371 int res = REAL(fstatvfs64)(fd, buf);
4386 if (user) COMMON_INTERCEPTOR_READ_RANGE(ctx, user, REAL(strlen)(user) + 1);
4387 int res = REAL(initgroups)(user, group);
4400 char *res = REAL(ether_ntoa)(addr);
4401 if (res) COMMON_INTERCEPTOR_INITIALIZE_RANGE(res, REAL(strlen)(res) + 1);
4407 if (buf) COMMON_INTERCEPTOR_READ_RANGE(ctx, buf, REAL(strlen)(buf) + 1);
4408 __sanitizer_ether_addr *res = REAL(ether_aton)(buf);
4427 int res = REAL(ether_ntohost)(hostname, addr);
4429 COMMON_INTERCEPTOR_WRITE_RANGE(ctx, hostname, REAL(strlen)(hostname) + 1);
4436 COMMON_INTERCEPTOR_READ_RANGE(ctx, hostname, REAL(strlen)(hostname) + 1);
4440 int res = REAL(ether_hostton)(hostname, addr);
4448 if (line) COMMON_INTERCEPTOR_READ_RANGE(ctx, line, REAL(strlen)(line) + 1);
4452 int res = REAL(ether_line)(line, addr, hostname);
4456 COMMON_INTERCEPTOR_WRITE_RANGE(ctx, hostname, REAL(strlen)(hostname) + 1);
4476 char *res = REAL(ether_ntoa_r)(addr, buf);
4477 if (res) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, res, REAL(strlen)(res) + 1);
4484 if (buf) COMMON_INTERCEPTOR_READ_RANGE(ctx, buf, REAL(strlen)(buf) + 1);
4488 __sanitizer_ether_addr *res = REAL(ether_aton_r)(buf, addr);
4506 int res = REAL(shmctl)(shmid, cmd, buf);
4531 int res = REAL(random_r)(buf, result);
4582 int res = REAL(pthread_attr_getstack)(attr, addr, size);
4596 return REAL(pthread_attr_getstack)(attr, addr, size);
4640 int res = REAL(pthread_attr_getaffinity_np)(attr, cpusetsize, cpuset);
4744 char *res = REAL(tmpnam)(s);
4750 COMMON_INTERCEPTOR_WRITE_RANGE(ctx, s, REAL(strlen)(s) + 1);
4752 COMMON_INTERCEPTOR_INITIALIZE_RANGE(res, REAL(strlen)(res) + 1);
4768 char *res = REAL(tmpnam_r)(s);
4769 if (res && s) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, s, REAL(strlen)(s) + 1);
4781 char *res = REAL(ttyname)(fd);
4783 COMMON_INTERCEPTOR_INITIALIZE_RANGE(res, REAL(strlen)(res) + 1);
4795 int res = REAL(ttyname_r)(fd, name, namesize);
4797 COMMON_INTERCEPTOR_WRITE_RANGE(ctx, name, REAL(strlen)(name) + 1);
4809 if (dir) COMMON_INTERCEPTOR_READ_RANGE(ctx, dir, REAL(strlen)(dir) + 1);
4810 if (pfx) COMMON_INTERCEPTOR_READ_RANGE(ctx, pfx, REAL(strlen)(pfx) + 1);
4811 char *res = REAL(tempnam)(dir, pfx);
4812 if (res) COMMON_INTERCEPTOR_INITIALIZE_RANGE(res, REAL(strlen)(res) + 1);
4826 return REAL(pthread_setname_np)(thread, name);
4848 int res = REAL(pthread_getname_np)(thread, name, len);
4865 REAL(sincos)(x, sin, cos);
4875 REAL(sincosf)(x, sin, cos);
4885 REAL(sincosl)(x, sin, cos);
4904 double res = REAL(remquo)(x, y, quo);
4914 float res = REAL(remquof)(x, y, quo);
4932 long double res = REAL(remquol)(x, y, quo);
4947 double res = REAL(lgamma)(x);
4954 float res = REAL(lgammaf)(x);
4969 long double res = REAL(lgammal)(x);
4986 double res = REAL(lgamma_r)(x, signp);
4996 float res = REAL(lgammaf_r)(x, signp);
5014 long double res = REAL(lgammal_r)(x, signp);
5030 int res = REAL(drand48_r)(buffer, result);
5040 int res = REAL(lrand48_r)(buffer, result);
5056 return REAL(rand_r)(seedp);
5070 SSIZE_T res = REAL(getline)(lineptr, n, stream);
5129 SIZE_T res = REAL(iconv)(cd, inbuf, inbytesleft, outbuf, outbytesleft);
5148 __sanitizer_clock_t res = REAL(times)(tms);
5170 void *res = REAL(__tls_get_addr)(arg);
5264 if (path) COMMON_INTERCEPTOR_READ_RANGE(ctx, path, REAL(strlen)(path) + 1);
5268 SSIZE_T res = REAL(listxattr)(path, list, size);
5277 if (path) COMMON_INTERCEPTOR_READ_RANGE(ctx, path, REAL(strlen)(path) + 1);
5281 SSIZE_T res = REAL(llistxattr)(path, list, size);
5291 SSIZE_T res = REAL(flistxattr)(fd, list, size);
5308 if (path) COMMON_INTERCEPTOR_READ_RANGE(ctx, path, REAL(strlen)(path) + 1);
5309 if (name) COMMON_INTERCEPTOR_READ_RANGE(ctx, name, REAL(strlen)(name) + 1);
5313 SSIZE_T res = REAL(getxattr)(path, name, value, size);
5321 if (path) COMMON_INTERCEPTOR_READ_RANGE(ctx, path, REAL(strlen)(path) + 1);
5322 if (name) COMMON_INTERCEPTOR_READ_RANGE(ctx, name, REAL(strlen)(name) + 1);
5326 SSIZE_T res = REAL(lgetxattr)(path, name, value, size);
5334 if (name) COMMON_INTERCEPTOR_READ_RANGE(ctx, name, REAL(strlen)(name) + 1);
5338 SSIZE_T res = REAL(fgetxattr)(fd, name, value, size);
5357 int res = REAL(getresuid)(ruid, euid, suid);
5371 int res = REAL(getresgid)(rgid, egid, sgid);
5396 int res = REAL(getifaddrs)(ifap);
5404 REAL(strlen)(p->ifa_name) + 1);
5432 char *res = REAL(if_indextoname)(ifindex, ifname);
5434 COMMON_INTERCEPTOR_WRITE_RANGE(ctx, ifname, REAL(strlen)(ifname) + 1);
5441 COMMON_INTERCEPTOR_READ_RANGE(ctx, ifname, REAL(strlen)(ifname) + 1);
5442 return REAL(if_nametoindex)(ifname);
5460 int res = REAL(capget)(hdrp, datap);
5475 return REAL(capset)(hdrp, datap);
5590 int res = REAL(ftime)(tp);
5608 REAL(xdrmem_create)(xdrs, addr, size, op);
5623 REAL(xdrstdio_create)(xdrs, file, op);
5684 int res = REAL(xdr_bytes)(xdrs, p, sizep, maxsize);
5699 COMMON_INTERCEPTOR_READ_RANGE(ctx, *p, REAL(strlen)(*p) + 1);
5704 int res = REAL(xdr_string)(xdrs, p, maxsize);
5708 COMMON_INTERCEPTOR_WRITE_RANGE(ctx, *p, REAL(strlen)(*p) + 1);
5756 void *res = REAL(tsearch)(key, rootp, compar);
5789 int res = REAL(__uflow)(fp);
5796 int res = REAL(__underflow)(fp);
5803 int res = REAL(__overflow)(fp, ch);
5810 int res = REAL(__wuflow)(fp);
5817 int res = REAL(__wunderflow)(fp);
5824 int res = REAL(__woverflow)(fp, ch);
5843 if (path) COMMON_INTERCEPTOR_READ_RANGE(ctx, path, REAL(strlen)(path) + 1);
5844 COMMON_INTERCEPTOR_READ_RANGE(ctx, mode, REAL(strlen)(mode) + 1);
5845 __sanitizer_FILE *res = REAL(fopen)(path, mode);
5853 COMMON_INTERCEPTOR_READ_RANGE(ctx, mode, REAL(strlen)(mode) + 1);
5854 __sanitizer_FILE *res = REAL(fdopen)(fd, mode);
5862 if (path) COMMON_INTERCEPTOR_READ_RANGE(ctx, path, REAL(strlen)(path) + 1);
5863 COMMON_INTERCEPTOR_READ_RANGE(ctx, mode, REAL(strlen)(mode) + 1);
5865 __sanitizer_FILE *res = REAL(freopen)(path, mode, fp);
5882 COMMON_INTERCEPTOR_READ_RANGE(ctx, path, REAL(strlen)(path) + 1);
5883 COMMON_INTERCEPTOR_READ_RANGE(ctx, mode, REAL(strlen)(mode) + 1);
5884 __sanitizer_FILE *res = REAL(fopen64)(path, mode);
5893 if (path) COMMON_INTERCEPTOR_READ_RANGE(ctx, path, REAL(strlen)(path) + 1);
5894 COMMON_INTERCEPTOR_READ_RANGE(ctx, mode, REAL(strlen)(mode) + 1);
5896 __sanitizer_FILE *res = REAL(freopen64)(path, mode, fp);
5915 __sanitizer_FILE *res = REAL(open_memstream)(ptr, sizeloc);
5929 __sanitizer_FILE *res = REAL(open_wmemstream)(ptr, sizeloc);
5946 __sanitizer_FILE *res = REAL(fmemopen)(buf, size, mode);
5972 int res = REAL(_obstack_begin_1)(obstack, sz, align, alloc_fn, free_fn);
5981 int res = REAL(_obstack_begin)(obstack, sz, align, alloc_fn, free_fn);
5988 REAL(_obstack_newchunk)(obstack, length);
6005 int res = REAL(fflush)(fp);
6024 int res = REAL(fclose)(fp);
6042 void *res = REAL(dlopen)(filename, flag);
6051 int res = REAL(dlclose)(handle);
6068 COMMON_INTERCEPTOR_READ_RANGE(ctx, prompt, REAL(strlen)(prompt)+1);
6069 char *res = REAL(getpass)(prompt);
6070 if (res) COMMON_INTERCEPTOR_INITIALIZE_RANGE(res, REAL(strlen)(res)+1);
6086 int res = REAL(timerfd_settime)(fd, flags, new_value, old_value);
6095 int res = REAL(timerfd_gettime)(fd, curr_value);
6195 REAL(fopencookie)(wrapped_cookie, mode, {wrapped_read, wrapped_write,
6213 REAL(memset)(s, 0, sizeof(*s));
6214 int res = REAL(sem_init)(s, pshared, value);
6221 int res = REAL(sem_destroy)(s);
6260 int res = REAL(sem_post)(s);
6267 int res = REAL(sem_getvalue)(s, sval);
6290 int res = REAL(pthread_setcancelstate)(state, oldstate);
6299 int res = REAL(pthread_setcanceltype)(type, oldtype);
6315 int res = REAL(mincore)(addr, length, vec);
6335 SSIZE_T res = REAL(process_vm_readv)(pid, local_iov, liovcnt, remote_iov,
6348 SSIZE_T res = REAL(process_vm_writev)(pid, local_iov, liovcnt, remote_iov,
6365 char *res = REAL(ctermid)(s);
6367 COMMON_INTERCEPTOR_INITIALIZE_RANGE(res, REAL(strlen)(res) + 1);
6396 SSIZE_T res = REAL(recv)(fd, buf, len, flags);
6413 SSIZE_T res = REAL(recvfrom)(fd, buf, len, flags, srcaddr, addrlen);
6437 SSIZE_T res = REAL(send)(fd, buf, len, flags);
6452 SSIZE_T res = REAL(sendto)(fd, buf, len, flags, dstaddr, addrlen);
6469 int res = REAL(eventfd_read)(fd, value);
6483 int res = REAL(eventfd_write)(fd, value);
6531 int res = REAL(__xstat)(version, path, buf);
6547 int res = REAL(__xstat64)(version, path, buf);
6563 int res = REAL(__lxstat)(version, path, buf);
6579 int res = REAL(__lxstat64)(version, path, buf);
6595 void *res = REAL(getutent)(dummy);
6603 void *res = REAL(getutid)(ut);
6611 void *res = REAL(getutline)(ut);
6628 void *res = REAL(getutxent)(dummy);
6636 void *res = REAL(getutxid)(ut);
6644 void *res = REAL(getutxline)(ut);
6654 void *res = REAL(pututxline)(ut);
6672 int res = REAL(getloadavg)(loadavg, nelem);
6700 SIZE_T res = REAL(wcslen)(s);
6708 SIZE_T res = REAL(wcsnlen)(s, n);
6720 SIZE_T src_size = REAL(wcslen)(src);
6721 SIZE_T dst_size = REAL(wcslen)(dst);
6726 return REAL(wcscat)(dst, src);
6732 SIZE_T src_size = REAL(wcsnlen)(src, n);
6733 SIZE_T dst_size = REAL(wcslen)(dst);
6739 return REAL(wcsncat)(dst, src, n);
6752 SIZE_T len = REAL(wcslen)(s);
6754 wchar_t *result = REAL(wcsdup)(s);
6766 static SIZE_T RealStrLen(const char *str) { return REAL(strlen)(str); }
6768 static SIZE_T RealStrLen(const wchar_t *str) { return REAL(wcslen)(str); }
6989 COMMON_INTERCEPTOR_READ_RANGE(ctx, path, REAL(strlen)(path) + 1);
6990 SSIZE_T res = REAL(readlink)(path, buf, bufsiz);
7006 COMMON_INTERCEPTOR_READ_RANGE(ctx, path, REAL(strlen)(path) + 1);
7007 SSIZE_T res = REAL(readlinkat)(dirfd, path, buf, bufsiz);
7024 COMMON_INTERCEPTOR_READ_RANGE(ctx, pathname, REAL(strlen)(pathname) + 1);
7032 int res = REAL(name_to_handle_at)(dirfd, pathname, handle, mount_id, flags);
7069 return REAL(open_by_handle_at)(mount_fd, handle, flags);
7131 return REAL(mprotect)(addr, sz, prot);
7438 int ret = REAL(setvbuf)(stream, buf, mode, size);
7449 REAL(setbuf)(stream, buf);
7460 REAL(setbuffer)(stream, buf, mode);
7471 REAL(setlinebuf)(stream);
7502 COMMON_INTERCEPTOR_READ_RANGE(ctx, pattern, REAL(strlen)(pattern) + 1);
7503 int res = REAL(regcomp)(preg, pattern, cflags);
7515 COMMON_INTERCEPTOR_READ_RANGE(ctx, string, REAL(strlen)(string) + 1);
7516 int res = REAL(regexec)(preg, string, nmatch, pmatch, eflags);
7527 SIZE_T res = REAL(regerror)(errcode, preg, errbuf, errbuf_size);
7529 COMMON_INTERCEPTOR_WRITE_RANGE(ctx, errbuf, REAL(strlen)(errbuf) + 1);
7537 REAL(regfree)(preg);
9233 COMMON_INTERCEPTOR_READ_RANGE(ctx, command, REAL(strlen)(command) + 1);
9235 COMMON_INTERCEPTOR_READ_RANGE(ctx, type, REAL(strlen)(type) + 1);
9236 __sanitizer_FILE *res = REAL(popen)(command, type);
9287 int res = REAL(pclose)(fp);
9497 char *res = REAL(getusershell)();
9499 COMMON_INTERCEPTOR_WRITE_RANGE(ctx, res, REAL(strlen)(res) + 1);
9565 SSIZE_T n = REAL(getrandom)(buf, buflen, flags);
9582 char *res = REAL(crypt)(key, salt);
9598 char *res = REAL(crypt_r)(key, salt, data);
projects/compiler-rt/lib/sanitizer_common/sanitizer_signal_interceptors.inc 63 return REAL(sigaction_symname)(signum, (const __sanitizer_sigaction *)act,
projects/compiler-rt/lib/tsan/dd/dd_interceptors.cpp 45 return REAL(pthread_mutex_destroy)(m);
51 int res = REAL(pthread_mutex_lock)(m);
58 int res = REAL(pthread_mutex_trylock)(m);
67 return REAL(pthread_mutex_unlock)(m);
72 int res = REAL(pthread_spin_destroy)(m);
80 int res = REAL(pthread_spin_lock)(m);
87 int res = REAL(pthread_spin_trylock)(m);
96 return REAL(pthread_spin_unlock)(m);
102 return REAL(pthread_rwlock_destroy)(m);
108 int res = REAL(pthread_rwlock_rdlock)(m);
115 int res = REAL(pthread_rwlock_tryrdlock)(m);
124 int res = REAL(pthread_rwlock_timedrdlock)(m, abstime);
133 int res = REAL(pthread_rwlock_wrlock)(m);
140 int res = REAL(pthread_rwlock_trywrlock)(m);
149 int res = REAL(pthread_rwlock_timedwrlock)(m, abstime);
158 return REAL(pthread_rwlock_unlock)(m);
179 return REAL(pthread_cond_init)(cond, a);
187 int res = REAL(pthread_cond_wait)(cond, m);
198 int res = REAL(pthread_cond_timedwait)(cond, m, abstime);
206 return REAL(pthread_cond_signal)(cond);
212 return REAL(pthread_cond_broadcast)(cond);
218 int res = REAL(pthread_cond_destroy)(cond);
227 return REAL(realpath)(path, resolved_path);
232 return REAL(read)(fd, ptr, count);
237 return REAL(pread)(fd, ptr, count, offset);
projects/compiler-rt/lib/tsan/rtl/tsan_interceptors_posix.cpp 435 res = REAL(__cxa_atexit)((void (*)(void *a))at_exit_wrapper, 0, 0);
441 res = REAL(__cxa_atexit)(cxa_at_exit_wrapper, ctx, dso);
468 int res = REAL(on_exit)(on_exit_wrapper, ctx);
624 REAL(longjmp_symname)(env, val);
632 REAL(siglongjmp_symname)(env, val);
732 return REAL(strcpy)(dst, src);
740 return REAL(strncpy)(dst, src, n);
746 return REAL(strdup)(str);
781 int res = REAL(munmap)(addr, sz);
983 REAL(pthread_attr_getdetachstate)(attr, &detached);
995 res = REAL(pthread_create)(th, attr, __tsan_thread_start_func, &p);
1034 int res = REAL(pthread_detach)(th);
1048 REAL(pthread_exit)(retval);
1056 int res = REAL(pthread_tryjoin_np)(th, ret);
1144 return REAL(pthread_cond_init)(cond, a);
1170 return cond_wait(thr, pc, &si, (int (*)(void *c, void *m, void *abstime))REAL(
1178 return cond_wait(thr, pc, &si, REAL(pthread_cond_timedwait), cond, m,
1196 return REAL(pthread_cond_signal)(cond);
1203 return REAL(pthread_cond_broadcast)(cond);
1210 int res = REAL(pthread_cond_destroy)(cond);
1221 int res = REAL(pthread_mutex_init)(m, a);
1226 if (REAL(pthread_mutexattr_gettype)(a, &type) == 0)
1238 int res = REAL(pthread_mutex_destroy)(m);
1247 int res = REAL(pthread_mutex_trylock)(m);
1258 int res = REAL(pthread_mutex_timedlock)(m, abstime);
1269 int res = REAL(pthread_spin_init)(m, pshared);
1278 int res = REAL(pthread_spin_destroy)(m);
1288 int res = REAL(pthread_spin_lock)(m);
1297 int res = REAL(pthread_spin_trylock)(m);
1307 int res = REAL(pthread_spin_unlock)(m);
1314 int res = REAL(pthread_rwlock_init)(m, a);
1323 int res = REAL(pthread_rwlock_destroy)(m);
1333 int res = REAL(pthread_rwlock_rdlock)(m);
1342 int res = REAL(pthread_rwlock_tryrdlock)(m);
1352 int res = REAL(pthread_rwlock_timedrdlock)(m, abstime);
1363 int res = REAL(pthread_rwlock_wrlock)(m);
1372 int res = REAL(pthread_rwlock_trywrlock)(m);
1382 int res = REAL(pthread_rwlock_timedwrlock)(m, abstime);
1393 int res = REAL(pthread_rwlock_unlock)(m);
1401 int res = REAL(pthread_barrier_init)(b, a, count);
1408 int res = REAL(pthread_barrier_destroy)(b);
1416 int res = REAL(pthread_barrier_wait)(b);
1462 return REAL(__fxstat)(version, fd, buf);
1479 return REAL(__fxstat)(0, fd, buf);
1488 return REAL(__fxstat64)(version, fd, buf);
1500 return REAL(__fxstat64)(0, fd, buf);
1510 int fd = REAL(open)(name, flags, mode);
1520 int fd = REAL(open64)(name, flags, mode);
1533 int fd = REAL(creat)(name, mode);
1543 int fd = REAL(creat64)(name, mode);
1555 int newfd = REAL(dup)(oldfd);
1563 int newfd2 = REAL(dup2)(oldfd, newfd);
1572 int newfd2 = REAL(dup3)(oldfd, newfd, flags);
1582 int fd = REAL(eventfd)(initval, flags);
1597 fd = REAL(signalfd)(fd, mask, flags);
1610 int fd = REAL(inotify_init)(fake);
1623 int fd = REAL(inotify_init1)(flags);
1635 int fd = REAL(socket)(domain, type, protocol);
1643 int res = REAL(socketpair)(domain, type, protocol, fd);
1652 int res = REAL(connect)(fd, addr, addrlen);
1660 int res = REAL(bind)(fd, addr, addrlen);
1668 int res = REAL(listen)(fd, backlog);
1678 return REAL(close)(fd);
1686 return REAL(__close)(fd);
1703 REAL(__res_iclose)(state, free_addr);
1712 int res = REAL(pipe)(pipefd);
1721 int res = REAL(pipe2)(pipefd, flags);
1731 int res = REAL(unlink)(path);
1737 void *res = REAL(tmpfile)(fake);
1749 void *res = REAL(tmpfile64)(fake);
1765 REAL(fflush)(stdout);
1766 REAL(fflush)(stderr);
1772 REAL(abort)(fake);
1778 int res = REAL(rmdir)(path);
1788 return REAL(closedir)(dirp);
1794 int fd = REAL(epoll_create)(size);
1802 int fd = REAL(epoll_create1)(flags);
1816 int res = REAL(epoll_ctl)(epfd, op, fd, ev);
1857 return REAL(sigsuspend)(mask);
1862 return REAL(sigblock)(mask);
1867 return REAL(sigsetmask)(mask);
1873 return REAL(pthread_sigmask)(how, set, oldset);
1948 int res = REAL(pthread_sigmask)(SIG_SETMASK, &sctx->emptyset, &sctx->oldset);
1958 res = REAL(pthread_sigmask)(SIG_SETMASK, &sctx->oldset, 0);
2035 int res = REAL(raise)(sig);
2049 int res = REAL(kill)(pid, sig);
2065 int res = REAL(pthread_kill)(tid, sig);
2076 return REAL(gettimeofday)(tv, tz);
2086 int res = REAL(getaddrinfo)(node, service, hints, rv);
2093 return REAL(fork)(fake);
2101 pid = REAL(fork)(fake);
2175 int res = REAL(dl_iterate_phdr)(dl_iterate_phdr_cb, &cbdata);
2388 int res = REAL(sigaction)(sig, act, old);
2537 void *res = REAL(__tls_get_addr)(arg);
2616 REAL(memset) = internal_memset;
2617 REAL(memcpy) = internal_memcpy;
2636 InterceptFunction(TSAN_STRING_SETJMP, (uptr*)&REAL(setjmp_symname), 0, 0);
2637 InterceptFunction("_setjmp", (uptr*)&REAL(_setjmp), 0, 0);
2638 InterceptFunction(TSAN_STRING_SIGSETJMP, (uptr*)&REAL(sigsetjmp_symname), 0,
2641 InterceptFunction("__sigsetjmp", (uptr*)&REAL(__sigsetjmp), 0, 0);
2778 REAL(atexit) = (int(*)(void(*)()))unreachable;
2781 if (REAL(__cxa_atexit)(&finalize, 0, 0)) {