1 //===-- esan_interceptors.cpp ---------------------------------------------===//
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 a part of EfficiencySanitizer, a family of performance tuners.
11 //
12 // Interception routines for the esan run-time.
13 //===----------------------------------------------------------------------===//
14
15 #include "esan.h"
16 #include "esan_shadow.h"
17 #include "interception/interception.h"
18 #include "sanitizer_common/sanitizer_common.h"
19 #include "sanitizer_common/sanitizer_libc.h"
20 #include "sanitizer_common/sanitizer_linux.h"
21 #include "sanitizer_common/sanitizer_stacktrace.h"
22
23 using namespace __esan; // NOLINT
24
25 #define CUR_PC() (StackTrace::GetCurrentPc())
26
27 //===----------------------------------------------------------------------===//
28 // Interception via sanitizer common interceptors
29 //===----------------------------------------------------------------------===//
30
31 // Get the per-platform defines for what is possible to intercept
32 #include "sanitizer_common/sanitizer_platform_interceptors.h"
33
34 // TODO(bruening): tsan disables several interceptors (getpwent, etc.) claiming
35 // that interception is a perf hit: should we do the same?
36
37 // We have no need to intercept:
38 #undef SANITIZER_INTERCEPT_TLS_GET_ADDR
39
40 // TODO(bruening): the common realpath interceptor assumes malloc is
41 // intercepted! We should try to parametrize that, though we'll
42 // intercept malloc soon ourselves and can then remove this undef.
43 #undef SANITIZER_INTERCEPT_REALPATH
44
45 // We provide our own version:
46 #undef SANITIZER_INTERCEPT_SIGPROCMASK
47
48 #define COMMON_INTERCEPTOR_NOTHING_IS_INITIALIZED (!EsanIsInitialized)
49
50 #define COMMON_INTERCEPT_FUNCTION(name) INTERCEPT_FUNCTION(name)
51 #define COMMON_INTERCEPT_FUNCTION_VER(name, ver) \
52 INTERCEPT_FUNCTION_VER(name, ver)
53
54 // We must initialize during early interceptors, to support tcmalloc.
55 // This means that for some apps we fully initialize prior to
56 // __esan_init() being called.
57 // We currently do not use ctx.
58 #define COMMON_INTERCEPTOR_ENTER(ctx, func, ...) \
59 do { \
60 if (UNLIKELY(COMMON_INTERCEPTOR_NOTHING_IS_INITIALIZED)) { \
61 if (!UNLIKELY(EsanDuringInit)) \
62 initializeLibrary(__esan_which_tool); \
63 return REAL(func)(__VA_ARGS__); \
64 } \
65 ctx = nullptr; \
66 (void)ctx; \
67 } while (false)
68
69 #define COMMON_INTERCEPTOR_ENTER_NOIGNORE(ctx, func, ...) \
70 COMMON_INTERCEPTOR_ENTER(ctx, func, __VA_ARGS__)
71
72 #define COMMON_INTERCEPTOR_WRITE_RANGE(ctx, ptr, size) \
73 processRangeAccess(CUR_PC(), (uptr)ptr, size, true)
74
75 #define COMMON_INTERCEPTOR_READ_RANGE(ctx, ptr, size) \
76 processRangeAccess(CUR_PC(), (uptr)ptr, size, false)
77
78 // This is only called if the app explicitly calls exit(), not on
79 // a normal exit.
80 #define COMMON_INTERCEPTOR_ON_EXIT(ctx) finalizeLibrary()
81
82 #define COMMON_INTERCEPTOR_FILE_OPEN(ctx, file, path) \
83 do { \
84 (void)(ctx); \
85 (void)(file); \
86 (void)(path); \
87 } while (false)
88 #define COMMON_INTERCEPTOR_FILE_CLOSE(ctx, file) \
89 do { \
90 (void)(ctx); \
91 (void)(file); \
92 } while (false)
93 #define COMMON_INTERCEPTOR_LIBRARY_LOADED(filename, handle) \
94 do { \
95 (void)(filename); \
96 (void)(handle); \
97 } while (false)
98 #define COMMON_INTERCEPTOR_LIBRARY_UNLOADED() \
99 do { \
100 } while (false)
101 #define COMMON_INTERCEPTOR_ACQUIRE(ctx, u) \
102 do { \
103 (void)(ctx); \
104 (void)(u); \
105 } while (false)
106 #define COMMON_INTERCEPTOR_RELEASE(ctx, u) \
107 do { \
108 (void)(ctx); \
109 (void)(u); \
110 } while (false)
111 #define COMMON_INTERCEPTOR_DIR_ACQUIRE(ctx, path) \
112 do { \
113 (void)(ctx); \
114 (void)(path); \
115 } while (false)
116 #define COMMON_INTERCEPTOR_FD_ACQUIRE(ctx, fd) \
117 do { \
118 (void)(ctx); \
119 (void)(fd); \
120 } while (false)
121 #define COMMON_INTERCEPTOR_FD_RELEASE(ctx, fd) \
122 do { \
123 (void)(ctx); \
124 (void)(fd); \
125 } while (false)
126 #define COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd) \
127 do { \
128 (void)(ctx); \
129 (void)(fd); \
130 } while (false)
131 #define COMMON_INTERCEPTOR_FD_SOCKET_ACCEPT(ctx, fd, newfd) \
132 do { \
133 (void)(ctx); \
134 (void)(fd); \
135 (void)(newfd); \
136 } while (false)
137 #define COMMON_INTERCEPTOR_SET_THREAD_NAME(ctx, name) \
138 do { \
139 (void)(ctx); \
140 (void)(name); \
141 } while (false)
142 #define COMMON_INTERCEPTOR_SET_PTHREAD_NAME(ctx, thread, name) \
143 do { \
144 (void)(ctx); \
145 (void)(thread); \
146 (void)(name); \
147 } while (false)
148 #define COMMON_INTERCEPTOR_BLOCK_REAL(name) REAL(name)
149 #define COMMON_INTERCEPTOR_MUTEX_LOCK(ctx, m) \
150 do { \
151 (void)(ctx); \
152 (void)(m); \
153 } while (false)
154 #define COMMON_INTERCEPTOR_MUTEX_UNLOCK(ctx, m) \
155 do { \
156 (void)(ctx); \
157 (void)(m); \
158 } while (false)
159 #define COMMON_INTERCEPTOR_MUTEX_REPAIR(ctx, m) \
160 do { \
161 (void)(ctx); \
162 (void)(m); \
163 } while (false)
164 #define COMMON_INTERCEPTOR_HANDLE_RECVMSG(ctx, msg) \
165 do { \
166 (void)(ctx); \
167 (void)(msg); \
168 } while (false)
169 #define COMMON_INTERCEPTOR_USER_CALLBACK_START() \
170 do { \
171 } while (false)
172 #define COMMON_INTERCEPTOR_USER_CALLBACK_END() \
173 do { \
174 } while (false)
175
176 #include "sanitizer_common/sanitizer_common_interceptors.inc"
177
178 //===----------------------------------------------------------------------===//
179 // Syscall interception
180 //===----------------------------------------------------------------------===//
181
182 // We want the caller's PC b/c unlike the other function interceptors these
183 // are separate pre and post functions called around the app's syscall().
184
185 #define COMMON_SYSCALL_PRE_READ_RANGE(ptr, size) \
186 processRangeAccess(GET_CALLER_PC(), (uptr)ptr, size, false)
187
188 #define COMMON_SYSCALL_PRE_WRITE_RANGE(ptr, size) \
189 do { \
190 (void)(ptr); \
191 (void)(size); \
192 } while (false)
193
194 #define COMMON_SYSCALL_POST_READ_RANGE(ptr, size) \
195 do { \
196 (void)(ptr); \
197 (void)(size); \
198 } while (false)
199
200 // The actual amount written is in post, not pre.
201 #define COMMON_SYSCALL_POST_WRITE_RANGE(ptr, size) \
202 processRangeAccess(GET_CALLER_PC(), (uptr)ptr, size, true)
203
204 #define COMMON_SYSCALL_ACQUIRE(addr) \
205 do { \
206 (void)(addr); \
207 } while (false)
208 #define COMMON_SYSCALL_RELEASE(addr) \
209 do { \
210 (void)(addr); \
211 } while (false)
212 #define COMMON_SYSCALL_FD_CLOSE(fd) \
213 do { \
214 (void)(fd); \
215 } while (false)
216 #define COMMON_SYSCALL_FD_ACQUIRE(fd) \
217 do { \
218 (void)(fd); \
219 } while (false)
220 #define COMMON_SYSCALL_FD_RELEASE(fd) \
221 do { \
222 (void)(fd); \
223 } while (false)
224 #define COMMON_SYSCALL_PRE_FORK() \
225 do { \
226 } while (false)
227 #define COMMON_SYSCALL_POST_FORK(res) \
228 do { \
229 (void)(res); \
230 } while (false)
231
232 #include "sanitizer_common/sanitizer_common_syscalls.inc"
233
234 //===----------------------------------------------------------------------===//
235 // Custom interceptors
236 //===----------------------------------------------------------------------===//
237
238 // TODO(bruening): move more of these to the common interception pool as they
239 // are shared with tsan and asan.
240 // While our other files match LLVM style, here we match sanitizer style as we
241 // expect to move these to the common pool.
242
INTERCEPTOR(char *,strcpy,char * dst,const char * src)243 INTERCEPTOR(char *, strcpy, char *dst, const char *src) { // NOLINT
244 void *ctx;
245 COMMON_INTERCEPTOR_ENTER(ctx, strcpy, dst, src);
246 uptr srclen = internal_strlen(src);
247 COMMON_INTERCEPTOR_WRITE_RANGE(ctx, dst, srclen + 1);
248 COMMON_INTERCEPTOR_READ_RANGE(ctx, src, srclen + 1);
249 return REAL(strcpy)(dst, src); // NOLINT
250 }
251
INTERCEPTOR(char *,strncpy,char * dst,char * src,uptr n)252 INTERCEPTOR(char *, strncpy, char *dst, char *src, uptr n) {
253 void *ctx;
254 COMMON_INTERCEPTOR_ENTER(ctx, strncpy, dst, src, n);
255 uptr srclen = internal_strnlen(src, n);
256 uptr copied_size = srclen + 1 > n ? n : srclen + 1;
257 COMMON_INTERCEPTOR_WRITE_RANGE(ctx, dst, copied_size);
258 COMMON_INTERCEPTOR_READ_RANGE(ctx, src, copied_size);
259 return REAL(strncpy)(dst, src, n);
260 }
261
INTERCEPTOR(int,open,const char * name,int flags,int mode)262 INTERCEPTOR(int, open, const char *name, int flags, int mode) {
263 void *ctx;
264 COMMON_INTERCEPTOR_ENTER(ctx, open, name, flags, mode);
265 COMMON_INTERCEPTOR_READ_STRING(ctx, name, 0);
266 return REAL(open)(name, flags, mode);
267 }
268
269 #if SANITIZER_LINUX
INTERCEPTOR(int,open64,const char * name,int flags,int mode)270 INTERCEPTOR(int, open64, const char *name, int flags, int mode) {
271 void *ctx;
272 COMMON_INTERCEPTOR_ENTER(ctx, open64, name, flags, mode);
273 COMMON_INTERCEPTOR_READ_STRING(ctx, name, 0);
274 return REAL(open64)(name, flags, mode);
275 }
276 #define ESAN_MAYBE_INTERCEPT_OPEN64 INTERCEPT_FUNCTION(open64)
277 #else
278 #define ESAN_MAYBE_INTERCEPT_OPEN64
279 #endif
280
INTERCEPTOR(int,creat,const char * name,int mode)281 INTERCEPTOR(int, creat, const char *name, int mode) {
282 void *ctx;
283 COMMON_INTERCEPTOR_ENTER(ctx, creat, name, mode);
284 COMMON_INTERCEPTOR_READ_STRING(ctx, name, 0);
285 return REAL(creat)(name, mode);
286 }
287
288 #if SANITIZER_LINUX
INTERCEPTOR(int,creat64,const char * name,int mode)289 INTERCEPTOR(int, creat64, const char *name, int mode) {
290 void *ctx;
291 COMMON_INTERCEPTOR_ENTER(ctx, creat64, name, mode);
292 COMMON_INTERCEPTOR_READ_STRING(ctx, name, 0);
293 return REAL(creat64)(name, mode);
294 }
295 #define ESAN_MAYBE_INTERCEPT_CREAT64 INTERCEPT_FUNCTION(creat64)
296 #else
297 #define ESAN_MAYBE_INTERCEPT_CREAT64
298 #endif
299
INTERCEPTOR(int,unlink,char * path)300 INTERCEPTOR(int, unlink, char *path) {
301 void *ctx;
302 COMMON_INTERCEPTOR_ENTER(ctx, unlink, path);
303 COMMON_INTERCEPTOR_READ_STRING(ctx, path, 0);
304 return REAL(unlink)(path);
305 }
306
INTERCEPTOR(uptr,fread,void * ptr,uptr size,uptr nmemb,void * f)307 INTERCEPTOR(uptr, fread, void *ptr, uptr size, uptr nmemb, void *f) {
308 void *ctx;
309 COMMON_INTERCEPTOR_ENTER(ctx, fread, ptr, size, nmemb, f);
310 COMMON_INTERCEPTOR_WRITE_RANGE(ctx, ptr, size * nmemb);
311 return REAL(fread)(ptr, size, nmemb, f);
312 }
313
INTERCEPTOR(uptr,fwrite,const void * p,uptr size,uptr nmemb,void * f)314 INTERCEPTOR(uptr, fwrite, const void *p, uptr size, uptr nmemb, void *f) {
315 void *ctx;
316 COMMON_INTERCEPTOR_ENTER(ctx, fwrite, p, size, nmemb, f);
317 COMMON_INTERCEPTOR_READ_RANGE(ctx, p, size * nmemb);
318 return REAL(fwrite)(p, size, nmemb, f);
319 }
320
INTERCEPTOR(int,puts,const char * s)321 INTERCEPTOR(int, puts, const char *s) {
322 void *ctx;
323 COMMON_INTERCEPTOR_ENTER(ctx, puts, s);
324 COMMON_INTERCEPTOR_READ_RANGE(ctx, s, internal_strlen(s));
325 return REAL(puts)(s);
326 }
327
INTERCEPTOR(int,rmdir,char * path)328 INTERCEPTOR(int, rmdir, char *path) {
329 void *ctx;
330 COMMON_INTERCEPTOR_ENTER(ctx, rmdir, path);
331 COMMON_INTERCEPTOR_READ_STRING(ctx, path, 0);
332 return REAL(rmdir)(path);
333 }
334
335 //===----------------------------------------------------------------------===//
336 // Shadow-related interceptors
337 //===----------------------------------------------------------------------===//
338
339 // These are candidates for sharing with all sanitizers if shadow memory
340 // support is also standardized.
341
INTERCEPTOR(void *,mmap,void * addr,SIZE_T sz,int prot,int flags,int fd,OFF_T off)342 INTERCEPTOR(void *, mmap, void *addr, SIZE_T sz, int prot, int flags,
343 int fd, OFF_T off) {
344 if (UNLIKELY(REAL(mmap) == nullptr)) {
345 // With esan init during interceptor init and a static libc preventing
346 // our early-calloc from triggering, we can end up here before our
347 // REAL pointer is set up.
348 return (void *)internal_mmap(addr, sz, prot, flags, fd, off);
349 }
350 void *ctx;
351 COMMON_INTERCEPTOR_ENTER(ctx, mmap, addr, sz, prot, flags, fd, off);
352 if (!fixMmapAddr(&addr, sz, flags))
353 return (void *)-1;
354 void *result = REAL(mmap)(addr, sz, prot, flags, fd, off);
355 return (void *)checkMmapResult((uptr)result, sz);
356 }
357
358 #if SANITIZER_LINUX
INTERCEPTOR(void *,mmap64,void * addr,SIZE_T sz,int prot,int flags,int fd,OFF64_T off)359 INTERCEPTOR(void *, mmap64, void *addr, SIZE_T sz, int prot, int flags,
360 int fd, OFF64_T off) {
361 void *ctx;
362 COMMON_INTERCEPTOR_ENTER(ctx, mmap64, addr, sz, prot, flags, fd, off);
363 if (!fixMmapAddr(&addr, sz, flags))
364 return (void *)-1;
365 void *result = REAL(mmap64)(addr, sz, prot, flags, fd, off);
366 return (void *)checkMmapResult((uptr)result, sz);
367 }
368 #define ESAN_MAYBE_INTERCEPT_MMAP64 INTERCEPT_FUNCTION(mmap64)
369 #else
370 #define ESAN_MAYBE_INTERCEPT_MMAP64
371 #endif
372
373 //===----------------------------------------------------------------------===//
374 // Signal-related interceptors
375 //===----------------------------------------------------------------------===//
376
377 #if SANITIZER_LINUX
378 typedef void (*signal_handler_t)(int);
INTERCEPTOR(signal_handler_t,signal,int signum,signal_handler_t handler)379 INTERCEPTOR(signal_handler_t, signal, int signum, signal_handler_t handler) {
380 void *ctx;
381 COMMON_INTERCEPTOR_ENTER(ctx, signal, signum, handler);
382 signal_handler_t result;
383 if (!processSignal(signum, handler, &result))
384 return result;
385 else
386 return REAL(signal)(signum, handler);
387 }
388 #define ESAN_MAYBE_INTERCEPT_SIGNAL INTERCEPT_FUNCTION(signal)
389 #else
390 #error Platform not supported
391 #define ESAN_MAYBE_INTERCEPT_SIGNAL
392 #endif
393
394 #if SANITIZER_LINUX
DECLARE_REAL(int,sigaction,int signum,const struct sigaction * act,struct sigaction * oldact)395 DECLARE_REAL(int, sigaction, int signum, const struct sigaction *act,
396 struct sigaction *oldact)
397 INTERCEPTOR(int, sigaction, int signum, const struct sigaction *act,
398 struct sigaction *oldact) {
399 void *ctx;
400 COMMON_INTERCEPTOR_ENTER(ctx, sigaction, signum, act, oldact);
401 if (!processSigaction(signum, act, oldact))
402 return 0;
403 else
404 return REAL(sigaction)(signum, act, oldact);
405 }
406
407 // This is required to properly use internal_sigaction.
408 namespace __sanitizer {
real_sigaction(int signum,const void * act,void * oldact)409 int real_sigaction(int signum, const void *act, void *oldact) {
410 if (REAL(sigaction) == nullptr) {
411 // With an instrumented allocator, this is called during interceptor init
412 // and we need a raw syscall solution.
413 return internal_sigaction_syscall(signum, act, oldact);
414 }
415 return REAL(sigaction)(signum, (const struct sigaction *)act,
416 (struct sigaction *)oldact);
417 }
418 } // namespace __sanitizer
419
420 #define ESAN_MAYBE_INTERCEPT_SIGACTION INTERCEPT_FUNCTION(sigaction)
421 #else
422 #error Platform not supported
423 #define ESAN_MAYBE_INTERCEPT_SIGACTION
424 #endif
425
426 #if SANITIZER_LINUX
INTERCEPTOR(int,sigprocmask,int how,__sanitizer_sigset_t * set,__sanitizer_sigset_t * oldset)427 INTERCEPTOR(int, sigprocmask, int how, __sanitizer_sigset_t *set,
428 __sanitizer_sigset_t *oldset) {
429 void *ctx;
430 COMMON_INTERCEPTOR_ENTER(ctx, sigprocmask, how, set, oldset);
431 int res = 0;
432 if (processSigprocmask(how, set, oldset))
433 res = REAL(sigprocmask)(how, set, oldset);
434 if (!res && oldset)
435 COMMON_INTERCEPTOR_WRITE_RANGE(ctx, oldset, sizeof(*oldset));
436 return res;
437 }
438 #define ESAN_MAYBE_INTERCEPT_SIGPROCMASK INTERCEPT_FUNCTION(sigprocmask)
439 #else
440 #define ESAN_MAYBE_INTERCEPT_SIGPROCMASK
441 #endif
442
443 #if !SANITIZER_WINDOWS
INTERCEPTOR(int,pthread_sigmask,int how,__sanitizer_sigset_t * set,__sanitizer_sigset_t * oldset)444 INTERCEPTOR(int, pthread_sigmask, int how, __sanitizer_sigset_t *set,
445 __sanitizer_sigset_t *oldset) {
446 void *ctx;
447 COMMON_INTERCEPTOR_ENTER(ctx, pthread_sigmask, how, set, oldset);
448 int res = 0;
449 if (processSigprocmask(how, set, oldset))
450 res = REAL(sigprocmask)(how, set, oldset);
451 if (!res && oldset)
452 COMMON_INTERCEPTOR_WRITE_RANGE(ctx, oldset, sizeof(*oldset));
453 return res;
454 }
455 #define ESAN_MAYBE_INTERCEPT_PTHREAD_SIGMASK INTERCEPT_FUNCTION(pthread_sigmask)
456 #else
457 #define ESAN_MAYBE_INTERCEPT_PTHREAD_SIGMASK
458 #endif
459
460 //===----------------------------------------------------------------------===//
461 // Malloc interceptors
462 //===----------------------------------------------------------------------===//
463
464 static char early_alloc_buf[128];
465 static bool used_early_alloc_buf;
466
handleEarlyAlloc(uptr size)467 static void *handleEarlyAlloc(uptr size) {
468 // If esan is initialized during an interceptor (which happens with some
469 // tcmalloc implementations that call pthread_mutex_lock), the call from
470 // dlsym to calloc will deadlock. There is only one such calloc (dlsym
471 // allocates a single pthread key), so we work around it by using a
472 // static buffer for the calloc request. The loader currently needs
473 // 32 bytes but we size at 128 to allow for future changes.
474 // This solution will also allow us to deliberately intercept malloc & family
475 // in the future (to perform tool actions on each allocation, without
476 // replacing the allocator), as it also solves the problem of intercepting
477 // calloc when it will itself be called before its REAL pointer is
478 // initialized.
479 CHECK(!used_early_alloc_buf && size < sizeof(early_alloc_buf));
480 // We do not handle multiple threads here. This only happens at process init
481 // time, and while it's possible for a shared library to create early threads
482 // that race here, we consider that to be a corner case extreme enough that
483 // it's not worth the effort to handle.
484 used_early_alloc_buf = true;
485 return (void *)early_alloc_buf;
486 }
487
INTERCEPTOR(void *,calloc,uptr size,uptr n)488 INTERCEPTOR(void*, calloc, uptr size, uptr n) {
489 if (EsanDuringInit && REAL(calloc) == nullptr)
490 return handleEarlyAlloc(size * n);
491 void *ctx;
492 COMMON_INTERCEPTOR_ENTER(ctx, calloc, size, n);
493 void *res = REAL(calloc)(size, n);
494 // The memory is zeroed and thus is all written.
495 COMMON_INTERCEPTOR_WRITE_RANGE(nullptr, (uptr)res, size * n);
496 return res;
497 }
498
INTERCEPTOR(void,free,void * p)499 INTERCEPTOR(void, free, void *p) {
500 void *ctx;
501 COMMON_INTERCEPTOR_ENTER(ctx, free, p);
502 if (p == (void *)early_alloc_buf) {
503 // We expect just a singleton use but we clear this for cleanliness.
504 used_early_alloc_buf = false;
505 return;
506 }
507 REAL(free)(p);
508 }
509
510 namespace __esan {
511
initializeInterceptors()512 void initializeInterceptors() {
513 InitializeCommonInterceptors();
514
515 INTERCEPT_FUNCTION(strcpy); // NOLINT
516 INTERCEPT_FUNCTION(strncpy);
517
518 INTERCEPT_FUNCTION(open);
519 ESAN_MAYBE_INTERCEPT_OPEN64;
520 INTERCEPT_FUNCTION(creat);
521 ESAN_MAYBE_INTERCEPT_CREAT64;
522 INTERCEPT_FUNCTION(unlink);
523 INTERCEPT_FUNCTION(fread);
524 INTERCEPT_FUNCTION(fwrite);
525 INTERCEPT_FUNCTION(puts);
526 INTERCEPT_FUNCTION(rmdir);
527
528 INTERCEPT_FUNCTION(mmap);
529 ESAN_MAYBE_INTERCEPT_MMAP64;
530
531 ESAN_MAYBE_INTERCEPT_SIGNAL;
532 ESAN_MAYBE_INTERCEPT_SIGACTION;
533 ESAN_MAYBE_INTERCEPT_SIGPROCMASK;
534 ESAN_MAYBE_INTERCEPT_PTHREAD_SIGMASK;
535
536 INTERCEPT_FUNCTION(calloc);
537 INTERCEPT_FUNCTION(free);
538
539 // TODO(bruening): intercept routines that other sanitizers intercept that
540 // are not in the common pool or here yet, ideally by adding to the common
541 // pool. Examples include wcslen and bcopy.
542
543 // TODO(bruening): there are many more libc routines that read or write data
544 // structures that no sanitizer is intercepting: sigaction, strtol, etc.
545 }
546
547 } // namespace __esan
548