[compiler-rt] Implement AddressSanitizer suppressions

[kubamracek]

Summary

This patch adds a issue suppression mechanism into ASan, reusing most of the functionality from TSan and sanitizer_common. Based on recent discussions, being able to suppress reports coming from interceptors sounds like a good idea, especially to be able to keep using libraries that you don't have source code of. Reports coming from memory access instrumentation are not affected. This patch also depends on the refactorings from http://reviews.llvm.org/D6276.

What this patch does is that it introduces 3 new types of suppressions, while keeping the suppression file format the same as TSan (described at https://code.google.com/p/thread-sanitizer/wiki/Suppressions). The new types:

• asan_interceptor:strcpy … will ignore any reports from the strcpy interceptor, no matter what function calls it
• asan_function:myfunction … will ignore any report where the function named myfunction is somewhere in the stack trace
• asan_library:mylibrary … will ignore any report where module named mylibrary is somewhere in the stack trace

There’s no way to specify more than one frame, the suppressions match any frame in the call stack (except asan_interceptor, which only takes a look at the first frame in the call stack, which is the current interceptor). Also note that the asan_library suppression type doesn’t require the symbolizer to work.

The suppression file is set with the suppressions=/path/to/file option in ASAN_OPTIONS, the same way we allow this for TSan.

The patch contains a generic test case and a Darwin-specific testcase.

Related discussions:

• https://code.google.com/p/address-sanitizer/issues/detail?id=356
• https://groups.google.com/d/topic/address-sanitizer/M6jmTnYbRRY/discussion

[samsonov]

1. asan_interceptor: It would be really unfortunate to symbolize a stack trace to learn the name of the interceptor. I mean, ACCESS_MEMORY_RANGE is called inside the interceptor, you should just now the interceptor name at this point. For example, try hacking COMMON_INTERCEPTOR_ENTER to save the name of the interceptor in context. Then you can pass this context down to ASAN_READ_RANGE and eventually to ACCESS_MEMORY_RANGE, and check if the interceptor name is blacklisted there.
2. asan_library. Have you looked at the neat LibIgnore class that TSan interceptors use to suppress reports from libraries? I don't see why you can't reuse called_from_lib suppression kind for your purposes as well.
3. asan_function: Hm, this one seems to require symbolization. Is this suppression kind absolutely necessary? Or blacklisting interceptror and/or library would be enough for your immediate purposes?

lib/asan/asan_interceptors.cc

54–64

Please don't. Symbolizing stack trace make take a long time and may not succeed. Also, you don't pass unwinded stack down, which means that you'd have to unwind it once again in __asan_report_error.

[glider]

I agree with Alexey.
As we discussed previously, suppressions should not be used to suppress errors in instrumented code (just because it's not possible to recover after calling a noreturn version of __asan_report_error).
Therefore we shouldn't allow "asan_function", and "asan_library" should only ignore reports in the interceptors (I suggest to rename it accordingly).

[kubamracek]

I totally agree that asan_interceptor shouldn't take a stack trace or symbolize anything, and also that we should not use suppressions for instrumented code. We only want suppressions to be used for code that you can't easily modify and recompile, like system or 3rd party libraries, which are always un-instrumented. You're right that the naming of the suppression types should be improved to make it clear that it only affects interceptors.

However, I think having just asan_interceptor and called_from_lib (which only matches the library of the immediate caller) is too coarse-grained. For example, the http://crbug.com/162461 (OpenCL overflow on Mac) was being suppressed by disabling all memcmp, memcpy, memmove, memset interceptors and that disables much more checks than it's necessary and prevents discovery of other bugs. Being able to suppress with just asan_interceptor and called_from_lib sounds like having the same issue: Disabling memcpy interceptor is way too much, just as skipping all checks for the OpenCL library. Also, called_from_lib is only checking the immediate caller, which in a lot of cases could be a general system library, like CoreFoundation, and ignoring this whole library is again an overkill.

I'm not looking for a temporary solution to suppress a specific bug. I'd like to have a generic mechanism that users can use when they hit a bug in code they don't own, while minimizing the impact on detection of other bugs. I know that we want to force users to *fix* bugs instead of suppressing them, but we already have things like replace_intrin=0 or replace_str=0.

I understand the performance concerns and possibly a huge impact of doing symbolication just to be able to match suppressions, but note that I'm not suggesting doing any additional work for the common case, I'm only talking about situations where we were about to crash the program anyway. If I understand correctly, LibIgnore is specially optimized, because TSan uses it for *every* interceptor call, not just when it detects a race. For suppressions that take place just before a report is printed, TSan also symbolizes the stack(s) and then look for suppressions in these.

It also doesn't sound to me that we're *degrading* performance, since again we're only talking about situations where ASan would currently crash the program.

[samsonov]

I agree that disabling the interceptor (e.g. memset) for everyone might be too coarse-grained, as you won't sanitize memset in actual code you're testing.

I don't see why disabling all reports from system/third-party library is coarse-grained. Suppose you run your code and see a bug in function foo() from OpenCL, which is a precompiled library you can't fix. You suppress foo(), rerun the code and see a bug in function bar() in OpenCL. Hm. If you can't fix OpenCL anyway, isn't it better to suppress all reports from it completely? However, you're right that called_from_lib may not work for us: some precompiled third_party library might call a code from CoreFoundation, that would call memset() on invalid arguments.

Now, speaking of symbolization. I'm not worried about performance slowdown - sure, the application won't do anything interesting after printing an error report. I'm worried about the wall time needed for printing the report. I *have* seen many cases where ASan wasn't able to finish printing a report because application was killed earlier, and in many cases things got worse because of the expensive symbolization. For your use case we'd have to bite the bullet, but I'd like to reduce the harm:

1. leave the ability to disable specific interceptor by name, with no symbolization necessary. This would probably be "okay" for many users.
2. symbolize the stack trace in the interceptor *only* if user has provided a suppression. In this way, we won't have to symbolize the stack trace in the default workflow.

[kubamracek]

Suppose you run your code and see a bug in function foo() from OpenCL, which is a precompiled library you can't fix. You suppress foo(), rerun the code and see a bug in function bar() in OpenCL. Hm. If you can't fix OpenCL anyway, isn't it better to suppress all reports from it completely?

That absolutely makes sense, but only if we allow suppressions by function name as well, which I was under the impression you were suggesting to remove.

I *have* seen many cases where ASan wasn't able to finish printing a report because application was killed earlier

I see. Do we have an example of that? Or a testcase? Does by any chance the fact that we're doing the suppression only for interceptors make it less likely?

• leave the ability to disable specific interceptor by name, with no symbolization necessary
• symbolize the stack trace in the interceptor *only* if user has provided a suppression

That makes sense, I'll post an updated patch.

[samsonov]

In D6280#7, @kubabrecka wrote:

Suppose you run your code and see a bug in function foo() from OpenCL, which is a precompiled library you can't fix. You suppress foo(), rerun the code and see a bug in function bar() in OpenCL. Hm. If you can't fix OpenCL anyway, isn't it better to suppress all reports from it completely?

That absolutely makes sense, but only if we allow suppressions by function name as well, which I was under the impression you were suggesting to remove.

I *have* seen many cases where ASan wasn't able to finish printing a report because application was killed earlier

I see. Do we have an example of that? Or a testcase? Does by any chance the fact that we're doing the suppression only for interceptors make it less likely?

Unfortunately no, if we could reproduce this with a simple test case, we would improve the runtime somehow. Also, in our internal ASan setup we use in-process symbolizer (that is, not launch llvm-symbolizer binary and communicate with it via pipe). Symbolizer code (it is essentially a DWARF parser from llvm/lib/DebugInfo) does a lot of work, and a lot of allocations.

• leave the ability to disable specific interceptor by name, with no symbolization necessary
• symbolize the stack trace in the interceptor *only* if user has provided a suppression

That makes sense, I'll post an updated patch.

Great, thank you!

[kubamracek]

Second take on AddressSanitizer issue suppressions.

This time:

• The suppression types are renamed to interceptor_name, interceptor_via_function and interceptor_via_library to make it clear that they only affect interceptors.
• We provide the interceptor name in the AsanInterceptorContext, similarly to TSan's context.
• For interceptor_name suppression type we don't take the stacktrace and don't symbolize.
• For the other two suppression types, we only symbolicate the stack when there is such a suppression present in the suppression file.

There's quite a few changes related to passing the AsanInterceptorContext from all the interceptors, like adding void *ctx to ASan-specific interceptors and passing that to ASAN_READ_RANGE and ASAN_WRITE_RANGE. For __asan_memcpy and related, which are called from instrumented code, I set the context pointer to be NULL, thus ignoring suppressions. I moved the implementation of them to macros, so I didn't need to change the API and so they don't create any additional stack frames.

I didn't reuse LibIgnore and the called_from_lib suppressions, because they only look at the immediate caller, which I don't think is enough for ASan suppressions.

Also, this time I didn't worry about refactoring SymbolizeStack from TSan, but after we agree on how the suppressions should be implemented, I'd be happy to do the proper refactoring so I don't have to repeat the symbolication logic in IsSuppressed.

Added a few more tests, including a test that checks that reports from instrumented code cannot be suppressed.

[samsonov]

First part of comments is about SuppressionContext() extension. I think this should go in as a separate change, before we use this functionality in ASan suppressions.

lib/sanitizer_common/sanitizer_suppressions.h

47

Now you can add fast path to SuppressionContext::Match() - if there are no suppressions for a given type, just return false.

49

I'd prefer this to be named HasSuppressonType().

60

I'm slightly worried about default initialization for the array. We try to avoid compiler from inserting memset() into runtime code. Consider zero-initializating the array with the call to internal_memset (it makes sense to move ctor to .cc file in this case).

62

bool has_suppresson_type_[SuppressionTypeCount];

lib/sanitizer_common/tests/sanitizer_suppressions_test.cc

84

Please add unit test for the new public method (SuppressionContext::HasSuppressionType).

[samsonov]

lib/asan/asan_interceptors.cc

142

Why do you need to pass VA_ARGS here?

173

s/0/nullptr here and in another similar places.

401

Probably, ASAN_MEMSET_IMPL ?

411

You don't need trailing semicolon here (and in other places), as you use this macro as

ASAN_MEMSET_CTX(...);

426

ditto

lib/asan/asan_suppressions.cc

34

static

63

Please wait till I pass the review and land http://reviews.llvm.org/D6394 - it should make the code easier.

66

GET_STACK_TRACE_FATAL_HERE (we should respect what user told us in common_flags()->fast_unwind_on_fatal.

Also, it seems like the wrong place to fetch the stack trace. The fact that

`IsSuppressed("my_interceptor");`

*unwinds the stack trace* is very surprising and something that is totally unexpected from function declaration. We also have "rule of thumb" in
asan_stack.h: unwind the stack as early as possible. I'd rather split "IsSuppressed" into two methods - suppress by interceptor name, and suppress by stack trace fetched from interceptor. That would compilcate the ACCESS_MEMORY_RANGE macro, but would hopefully make the logic more clear.

There's also an alternative. Instead of calling __asan_report_error directly from that macro, you may introduce

MaybeReportInterceptorError()

or smth. like this. There you can unwind the stack trace (once), then either match suppression and bail out (if there are active suppression), or
proceed to producing an error report and reporting this very same stack trace at hand.

69

You can do the following: first fetch the module name/offset for PC and see if it's suppressed (by SuppressionInterceptorViaLibrary), then symbolize the PC and see if it's suppressed by SuppressionInterceptorViaFunction (you don't need symbolization to fetch the module name). See lsan_common.cc.

84

You don't really want to report this every time. I can imaging library function doing invalid strlen() call (e.g. on the same data) hundreds of times.

lib/asan/asan_suppressions.h

24

See below - you might want to split this to "suppressed by interceptor name" and "suppressed by stack trace".

[kubamracek]

In D6280#11, @samsonov wrote:

First part of comments is about SuppressionContext() extension. I think this should go in as a separate change, before we use this functionality in ASan suppressions.

Uploaded in a separate patch: http://reviews.llvm.org/D6443

[kubamracek]

Addressing review comments. Moved the sanitizer_suppressions changes into a separate patch (http://reviews.llvm.org/D6443), also used the not-yet-committed Symbolizer::SymbolizePC refactoring (http://reviews.llvm.org/D6394).

The suppression method is now split into two, so we're taking the stackshot in the actual interceptors (and not inside the suppression mechanism) and passing it to the second method. Let me know if you feel the other alternative (something like MaybeReportInterceptorError()) would be a better solution. I also removed the reporting about matched suppressions. Do you think we should keep it and have it print only under verbosity>=1?

Thanks for the review!

[samsonov]

lib/asan/asan_interceptors.cc

60

Please fix this so that you wouldn't need to unwind the stack trace if suppressions of relevant kinds are missing.

129

Consider moving this decl above, as it's used above in ACCESS_MEMORY_RANGE macro.

lib/asan/asan_suppressions.cc

19

Do you really need all these headers?

25

Consider checking this flag in Is<..>Suppressed() functions.

[kubamracek]

Addressing review comments.

[samsonov]

Looks good, I'm mostly happy with the code itself, moving to comments about the test cases.

lib/asan/asan_suppressions.cc

43

Please run the patch through clang-format

56

I think you can define this variable outside of for-loop.

62

Collapse these two if's into a single one with &&

72

Note that function_name can be nullptr here. It's okay, and SuppressionContext::Match() will work correctly and return false, though. Leaving this up to you.

lib/asan/asan_suppressions.h

26

const StackTrace *stack

test/asan/TestCases/Darwin/suppressions-darwin.cc

7

Isn't %tmp expanded to /some/path/to/filemp ? Consider using %t.supp instead, so that file (if we go look for it in the test directory) has a sane name (here and below)

15

Use

ASAN_OPTIONS=suppressions=%t.supp:symbolize=false

instead. Also, you may want to check that suppress-by-interceptor-name also works w/o symbolizer.

22

use 80 cols for this line

23

Do you need to free() the buffer here?

29

This CHECK-IGNORE-NOT piece should go before CHECK-IGNORE above (here and below)

test/asan/TestCases/suppressions-function.cc

3

Can you test it on higher optimization levels? Suppression functionality should work there.

test/asan/TestCases/suppressions-instrumented-code.cc

2

Wait, how do you enforce that? By assuming that memset() in user code will be turned into __asan_memset() call? In fact, I see little harm in suppressing reports from memset() from instrumented code if the user explicitly added interceptor_name:memset to suppression file. After all, this would work for another interceptors (like strcpy), won't it?

4

Also add memcpy/memmove here.

[kubamracek]

Addressing review comments.

// Check that reports from instrumented code cannot be suppressed.

Wait, how do you enforce that? By assuming that memset() in user code will be
turned into __asan_memset() call? In fact, I see little harm in suppressing
reports from memset() from instrumented code if the user explicitly added
interceptor_name:memset to suppression file. After all, this would work for
another interceptors (like strcpy), won't it?

I meant memset/memcpy/memmove only. Since these can easily be inlined, the suppression will not work reliably on them, and so it sounds like a good idea to just disallow suppressions for these functions (when used from instrumented code).

[earthdok]

lib/sanitizer_common/sanitizer_suppressions.cc

28

My $.02: we have "called_from_lib" and "interceptor_via_library". We also have "interceptor_via_function" here and "fun" in the blacklist syntax. Maybe use "lib" and "fun" everywhere for consistency?

[samsonov]

In D6280#21, @kubabrecka wrote:

Addressing review comments.

// Check that reports from instrumented code cannot be suppressed.

Wait, how do you enforce that? By assuming that memset() in user code will be
turned into __asan_memset() call? In fact, I see little harm in suppressing
reports from memset() from instrumented code if the user explicitly added
interceptor_name:memset to suppression file. After all, this would work for
another interceptors (like strcpy), won't it?

I meant memset/memcpy/memmove only. Since these can easily be inlined, the suppression will not work reliably on them, and so it sounds like a good idea to just disallow suppressions for these functions (when used from instrumented code).

But wait, how do you *enforce* that suppressions don't kick in if these functions are called from instrumented code? IIRC if the user writes memset() and we build it with Clang, it may or may not be turned into intrinsic and replaced with __asan_memfoo().

earthdok@: I really have no preference here. If you feel strong about consistency and sticking with abbreviated name - feel free to enforce it :)

test/asan/TestCases/suppressions-function.cc

9

just -O0 and -O3

[kubamracek]

In D6280#25, @samsonov wrote:

But wait, how do you *enforce* that suppressions don't kick in if these functions are called from instrumented code? IIRC if the user writes memset() and we build it with Clang, it may or may not be turned into intrinsic and replaced with __asan_memfoo().

Oh, I see what you mean. I thought it was about intrinsic vs. inlined, but it's about intrinsic vs. regular function call. Ok, I think I'll change the test case to just check for direct memory accesses.

lib/sanitizer_common/sanitizer_suppressions.cc

28

I don't necessarily disagree, but I'd like to point out that they work differently:

• interceptor_via_library ... suppresses interceptors only and matches library anywhere on the stack
• interceptor_via_function ... suppresses interceptors only and matches a function name anywhere on the stack
• called_from_lib ... also interceptors only, but only checks the topmost frame on the stack

Also, we should keep the "interceptor" in the name to indicate that these suppressions work only on interceptors, and not instrumented code (other suppression types work even on instrumented code).

[samsonov]

In D6280#26, @kubabrecka wrote:

In D6280#25, @samsonov wrote:

But wait, how do you *enforce* that suppressions don't kick in if these functions are called from instrumented code? IIRC if the user writes memset() and we build it with Clang, it may or may not be turned into intrinsic and replaced with __asan_memfoo().

Oh, I see what you mean. I thought it was about intrinsic vs. inlined, but it's about intrinsic vs. regular function call. Ok, I think I'll change the test case to just check for direct memory accesses.

FWIW, I'd just delete this test case.

[earthdok]

lib/sanitizer_common/sanitizer_suppressions.cc

28

Sorry, I could have been clearer. I suggest to name them "interceptor_via_lib" and "interceptor_via_fun" (not simply "lib" and "fun").

[kubamracek]

Addressing comments.

[kubamracek]

Sorry, I could have been clearer. I suggest to name them "interceptor_via_lib" and "interceptor_via_fun" (not simply "lib" and "fun").

I see, that makes sense. Renaming to "interceptor_via_lib" and "interceptor_via_fun".

[samsonov]

LGTM. Please watch the bots after the commit. Thank you for working on this and for surviving the nitpicky review!

[kubamracek]

I have tried this patch on Linux and I've seen this test failure:

FAIL: AddressSanitizer64 :: TestCases/strncpy-overflow.cc (1 of 1)
...
/tmp/llvm/projects/compiler-rt/test/asan/TestCases/strncpy-overflow.cc:20:12: error: expected string not found in input
// CHECK: {{ #1 0x.* in main .*strncpy-overflow.cc:}}[[@LINE-4]]

The reason for that is that the printed stack trace looks like this:

#0 0x44caf2 in strncpy /tmp/llvm/projects/compiler-rt/lib/asan/asan_interceptors.cc:637
#1 0x44cd31 in strncpy /tmp/llvm/projects/compiler-rt/lib/asan/asan_interceptors.cc:637
#2 0x4cdfdb in main (/tmp/llvm-cmake-debug/projects/compiler-rt/test/asan/64bitConfig/TestCases/Output/strncpy-overflow.cc.tmp+0x4cdfdb)
#3 0x7f05b89eee64  (/lib64/libc.so.6+0x24e64)
#4 0x417b08 in _start (/tmp/llvm-cmake-debug/projects/compiler-rt/test/asan/64bitConfig/TestCases/Output/strncpy-overflow.cc.tmp+0x417b08)

The doubled strncpy is the issue. To fix that, I moved the GET_CURRENT_PC_BP_SP line in ACCESS_MEMORY_RANGE right to the call to __asan_report_error.

[kubamracek]

I'm also seeing another test failure for LSan suppressions when ASan is used together with LSan:

FAIL: LeakSanitizer-AddressSanitizer :: TestCases/suppressions_file.cc (1 of 1)
...
/tmp/llvm/projects/compiler-rt/test/lsan/TestCases/suppressions_file.cc:24:11: error: expected string not found in input
// CHECK: Suppressions used:
          ^
<stdin>:1:1: note: scanning from here
Test alloc: 0x61700000fc80.
^
<stdin>:9:73: note: possible intended match here
 #1 0x4cc625 in main /tmp/llvm/projects/compiler-rt/test/lsan/TestCases/suppressions_file.cc:20:13

It looks like that in ASan+LSan, we only have one "suppressions" flag, and once the SuppressionContext is initialized, it only reads the common_flags()->suppressions once. Should we support having suppressions work for both LSan and ASan at the same time? I.e. running

ASAN_OPTIONS=suppressions=file1 LSAN_OPTIONS=suppressions=file2 ./a.out

In that case we should probably remove the "suppressions" flag from common_flags and have it separately in ASan, LSan, TSan.

Alexey, what do you think?

[samsonov]

In D6280#36, @kubabrecka wrote:

I have tried this patch on Linux and I've seen this test failure:

FAIL: AddressSanitizer64 :: TestCases/strncpy-overflow.cc (1 of 1)
...
/tmp/llvm/projects/compiler-rt/test/asan/TestCases/strncpy-overflow.cc:20:12: error: expected string not found in input
// CHECK: {{ #1 0x.* in main .*strncpy-overflow.cc:}}[[@LINE-4]]

The reason for that is that the printed stack trace looks like this:

#0 0x44caf2 in strncpy /tmp/llvm/projects/compiler-rt/lib/asan/asan_interceptors.cc:637
#1 0x44cd31 in strncpy /tmp/llvm/projects/compiler-rt/lib/asan/asan_interceptors.cc:637
#2 0x4cdfdb in main (/tmp/llvm-cmake-debug/projects/compiler-rt/test/asan/64bitConfig/TestCases/Output/strncpy-overflow.cc.tmp+0x4cdfdb)
#3 0x7f05b89eee64  (/lib64/libc.so.6+0x24e64)
#4 0x417b08 in _start (/tmp/llvm-cmake-debug/projects/compiler-rt/test/asan/64bitConfig/TestCases/Output/strncpy-overflow.cc.tmp+0x417b08)

The doubled strncpy is the issue. To fix that, I moved the GET_CURRENT_PC_BP_SP line in ACCESS_MEMORY_RANGE right to the call to __asan_report_error.

This change is fine. I've applied and tested this patch, and uncovered another nasty problem with this test case:

LeakSanitizer-AddressSanitizer :: TestCases/suppressions_file.cc

Here's the problem: if you use LSan+ASan we still want to match suppressions specified in LSAN_OPTIONS. But after you change we have the following behavior:

1. __asan_init is called, it parses ASAN_OPTIONS (common_flags()->suppressions is empty)
2. __asan_init calls SuppressionContext::Init(), and SuppressionContext singleton is initialized to be empty
3. __lsan::InitCommonLsan() parses LSAN_OPTIONS (common_flags()->suppressions now points to LSan suppression file).
4. __lsan::InitCommonLsan() calls SuppressionContext::Init(), but it's already initialized, so we do nothing.

Now, this immediate problem can be "fixed" by moving the call to InitializeSuppressions() at the bottom, right before we print "AddressSanitizer Init done" string.
I think that we should probably do that and land your patch. But the situation is terrible - our initialization code is complicated and fragile. Currently ASan can be
(and is) combined with both LSan and UBSan, each of them have their own init logic, and can use XSAN_OPTIONS to setup and override common flags. Sigh.
I think we should put some thought into it and redesign that part soon.

[kubamracek]

Moving the ASan suppression initialization after all other initializations (namely lsan's init to avoid overriding its suppression setting).

[samsonov]

OK, let's proceed. Hope I'd be able to fix initialization mayhem soon.

[kubamracek]

Landed in r223508. Thanks for review!

[kubamracek]

The Android buildbot was failing (http://lab.llvm.org:8011/builders/sanitizer-x86_64-linux/builds/14431), because the tests can't find the suppression files on the device. Marked them as XFAIL: android in r223540.

lib/asan/CMakeLists.txt

set(ASAN_SOURCES
   asan_malloc_mac.cc
   asan_malloc_win.cc
   asan_poisoning.cc
   asan_posix.cc
   asan_report.cc
   asan_rtl.cc
   asan_stack.cc
   asan_stats.cc
+  asan_suppressions.cc
   asan_thread.cc
   asan_win.cc)
 
 set(ASAN_CXX_SOURCES
   asan_new_delete.cc)
 
 set(ASAN_PREINIT_SOURCES
   asan_preinit.cc)

lib/asan/asan_interceptors.cc

 
 #include "asan_allocator.h"
 #include "asan_internal.h"
 #include "asan_mapping.h"
 #include "asan_poisoning.h"
 #include "asan_report.h"
 #include "asan_stack.h"
 #include "asan_stats.h"
+#include "asan_suppressions.h"
 #include "sanitizer_common/sanitizer_libc.h"
 
 namespace __asan {
 
 // Return true if we can quickly decide that the region is unpoisoned.
 static inline bool QuickCheckForUnpoisonedRegion(uptr beg, uptr size) {
   if (size == 0) return true;
   if (size <= 32)
     return !AddressIsPoisoned(beg) &&
            !AddressIsPoisoned(beg + size - 1) &&
            !AddressIsPoisoned(beg + size / 2);
   return false;
 }
 
 // We implement ACCESS_MEMORY_RANGE, ASAN_READ_RANGE,
 // and ASAN_WRITE_RANGE as macro instead of function so
 // that no extra frames are created, and stack trace contains
 // relevant information only.
 // We check all shadow bytes.
-#define ACCESS_MEMORY_RANGE(offset, size, isWrite) do {                 \
+#define ACCESS_MEMORY_RANGE(ctx, offset, size, isWrite) do {            \
     uptr __offset = (uptr)(offset);                                     \
     uptr __size = (uptr)(size);                                         \
     uptr __bad = 0;                                                     \
     if (__offset > __offset + __size) {                                 \
       GET_STACK_TRACE_FATAL_HERE;                                       \
       ReportStringFunctionSizeOverflow(__offset, __size, &stack);       \
     }                                                                   \
     if (!QuickCheckForUnpoisonedRegion(__offset, __size) &&             \
         (__bad = __asan_region_is_poisoned(__offset, __size))) {        \
       GET_CURRENT_PC_BP_SP;                                             \
-      __asan_report_error(pc, bp, sp, __bad, isWrite, __size);          \
+      AsanInterceptorContext *_ctx = (AsanInterceptorContext *)ctx;     \
+      bool suppressed = false;                                          \
+      if (_ctx) {                                                       \
+        suppressed = IsInterceptorSuppressed(_ctx->interceptor_name);   \
+        if (!suppressed) {                                              \
+          GET_STACK_TRACE_FATAL_HERE;                                   \
+          suppressed = IsStackTraceSuppressed(&stack);                  \
+        }                                                               \
+      }                                                                 \
+      if (!suppressed)                                                  \
+        __asan_report_error(pc, bp, sp, __bad, isWrite, __size);        \
     }                                                                   \
   } while (0)
 
-#define ASAN_READ_RANGE(offset, size) ACCESS_MEMORY_RANGE(offset, size, false)
-#define ASAN_WRITE_RANGE(offset, size) ACCESS_MEMORY_RANGE(offset, size, true)
+#define ASAN_READ_RANGE(ctx, offset, size) \
+  ACCESS_MEMORY_RANGE(ctx, offset, size, false)
+#define ASAN_WRITE_RANGE(ctx, offset, size) \
+  ACCESS_MEMORY_RANGE(ctx, offset, size, true)
 
 // Behavior of functions like "memcpy" or "strcpy" is undefined
 // if memory intervals overlap. We report error in this case.
 // Macro is used to avoid creation of new frames.
 static inline bool RangesOverlap(const char *offset1, uptr length1,
                                  const char *offset2, uptr length2) {
   return !((offset1 + length1 <= offset2) || (offset2 + length2 <= offset1));
 }
do {                                                                   \
     if ((!INTERCEPT_FUNCTION(name) || !REAL(name)))                      \
       VReport(1, "AddressSanitizer: failed to intercept '" #name "'\n"); \
   } while (0)
 #else
 // OS X interceptors don't need to be initialized with INTERCEPT_FUNCTION.
 #define ASAN_INTERCEPT_FUNC(name)
 #endif  // SANITIZER_MAC
 
+struct AsanInterceptorContext {
+  const char *interceptor_name;
+};
+
+#define ASAN_INTERCEPTOR_ENTER(ctx, func)                                      \
+  AsanInterceptorContext _ctx = {#func};                                       \
+  ctx = (void *)&_ctx;                                                         \
+  (void) ctx;                                                                  \
+
 #define COMMON_INTERCEPT_FUNCTION(name) ASAN_INTERCEPT_FUNC(name)
 #define COMMON_INTERCEPTOR_WRITE_RANGE(ctx, ptr, size) \
-  ASAN_WRITE_RANGE(ptr, size)
-#define COMMON_INTERCEPTOR_READ_RANGE(ctx, ptr, size) ASAN_READ_RANGE(ptr, size)
+  ASAN_WRITE_RANGE(ctx, ptr, size)
+#define COMMON_INTERCEPTOR_READ_RANGE(ctx, ptr, size) \
+  ASAN_READ_RANGE(ctx, ptr, size)
 #define COMMON_INTERCEPTOR_ENTER(ctx, func, ...)                               \
   do {                                                                         \
     if (asan_init_is_running)                                                  \
       return REAL(func)(__VA_ARGS__);                                          \
-    ctx = 0;                                                                   \
-    (void) ctx;                                                                \
+    ASAN_INTERCEPTOR_ENTER(ctx, func);                                         \
     if (SANITIZER_MAC && UNLIKELY(!asan_inited))                               \
       return REAL(func)(__VA_ARGS__);                                          \
     ENSURE_ASAN_INITED();                                                      \
   } while (false)
 #define COMMON_INTERCEPTOR_FD_ACQUIRE(ctx, fd) \
   do {                                         \
   } while (false)
 #define COMMON_INTERCEPTOR_FD_RELEASE(ctx, fd) \

 // can be slow.
 #define COMMON_INTERCEPTOR_SET_PTHREAD_NAME(ctx, thread, name) \
   do {                                                         \
   } while (false)
 #define COMMON_INTERCEPTOR_BLOCK_REAL(name) REAL(name)
 #define COMMON_INTERCEPTOR_ON_EXIT(ctx) OnExit()
 #define COMMON_INTERCEPTOR_LIBRARY_LOADED(filename, res) CovUpdateMapping()
 #define COMMON_INTERCEPTOR_LIBRARY_UNLOADED() CovUpdateMapping()
 #define COMMON_INTERCEPTOR_NOTHING_IS_INITIALIZED (!asan_inited)
 #include "sanitizer_common/sanitizer_common_interceptors.inc"
 
-#define COMMON_SYSCALL_PRE_READ_RANGE(p, s) ASAN_READ_RANGE(p, s)
-#define COMMON_SYSCALL_PRE_WRITE_RANGE(p, s) ASAN_WRITE_RANGE(p, s)
+// Syscall interceptors don't have contexts, we don't support suppressions
+// for them.
+#define COMMON_SYSCALL_PRE_READ_RANGE(p, s) ASAN_READ_RANGE(nullptr, p, s)
+#define COMMON_SYSCALL_PRE_WRITE_RANGE(p, s) ASAN_WRITE_RANGE(nullptr, p, s)
 #define COMMON_SYSCALL_POST_READ_RANGE(p, s) \
   do {                                       \
     (void)(p);                               \
     (void)(s);                               \
   } while (false)
 #define COMMON_SYSCALL_POST_WRITE_RANGE(p, s) \
   do {                                        \
     (void)(p);                                \

 }
 #endif
 
 static inline int CharCmp(unsigned char c1, unsigned char c2) {
   return (c1 == c2) ? 0 : (c1 < c2) ? -1 : 1;
 }
 
 INTERCEPTOR(int, memcmp, const void *a1, const void *a2, uptr size) {
+  void *ctx;
+  ASAN_INTERCEPTOR_ENTER(ctx, memcmp);
   if (UNLIKELY(!asan_inited)) return internal_memcmp(a1, a2, size);
   ENSURE_ASAN_INITED();
   if (flags()->replace_intrin) {
     if (flags()->strict_memcmp) {
       // Check the entire regions even if the first bytes of the buffers are
       // different.
-      ASAN_READ_RANGE(a1, size);
-      ASAN_READ_RANGE(a2, size);
+      ASAN_READ_RANGE(ctx, a1, size);
+      ASAN_READ_RANGE(ctx, a2, size);
       // Fallthrough to REAL(memcmp) below.
     } else {
       unsigned char c1 = 0, c2 = 0;
       const unsigned char *s1 = (const unsigned char*)a1;
       const unsigned char *s2 = (const unsigned char*)a2;
       uptr i;
       for (i = 0; i < size; i++) {
         c1 = s1[i];
         c2 = s2[i];
         if (c1 != c2) break;
       }
-      ASAN_READ_RANGE(s1, Min(i + 1, size));
-      ASAN_READ_RANGE(s2, Min(i + 1, size));
+      ASAN_READ_RANGE(ctx, s1, Min(i + 1, size));
+      ASAN_READ_RANGE(ctx, s2, Min(i + 1, size));
       return CharCmp(c1, c2);
     }
   }
   return REAL(memcmp(a1, a2, size));
 }
 
-void *__asan_memcpy(void *to, const void *from, uptr size) {
-  if (UNLIKELY(!asan_inited)) return internal_memcpy(to, from, size);
-  // memcpy is called during __asan_init() from the internals
-  // of printf(...).
-  if (asan_init_is_running) {
-    return REAL(memcpy)(to, from, size);
-  }
-  ENSURE_ASAN_INITED();
-  if (flags()->replace_intrin) {
-    if (to != from) {
-      // We do not treat memcpy with to==from as a bug.
-      // See http://llvm.org/bugs/show_bug.cgi?id=11763.
-      CHECK_RANGES_OVERLAP("memcpy", to, size, from, size);
-    }
-    ASAN_READ_RANGE(from, size);
-    ASAN_WRITE_RANGE(to, size);
-  }
-  return REAL(memcpy)(to, from, size);
+// memcpy is called during __asan_init() from the internals of printf(...).
+#define ASAN_MEMCPY_IMPL(ctx, to, from, size) do {                             \
+    if (UNLIKELY(!asan_inited)) return internal_memcpy(to, from, size);        \
+    if (asan_init_is_running) {                                                \
+      return REAL(memcpy)(to, from, size);                                     \
+    }                                                                          \
+    ENSURE_ASAN_INITED();                                                      \
+    if (flags()->replace_intrin) {                                             \
+      if (to != from) {                                                        \
+        CHECK_RANGES_OVERLAP("memcpy", to, size, from, size);                  \
+      }                                                                        \
+      ASAN_READ_RANGE(ctx, from, size);                                        \
+      ASAN_WRITE_RANGE(ctx, to, size);                                         \
+    }                                                                          \
+    return REAL(memcpy)(to, from, size);                                       \
+  } while (0)
+
+
+void *__asan_memcpy(void *to, const void *from, uptr size) {
+  ASAN_MEMCPY_IMPL(nullptr, to, from, size);
 }
 
-void *__asan_memset(void *block, int c, uptr size) {
-  if (UNLIKELY(!asan_inited)) return internal_memset(block, c, size);
-  // memset is called inside Printf.
-  if (asan_init_is_running) {
-    return REAL(memset)(block, c, size);
-  }
-  ENSURE_ASAN_INITED();
-  if (flags()->replace_intrin) {
-    ASAN_WRITE_RANGE(block, size);
-  }
-  return REAL(memset)(block, c, size);
+#define ASAN_MEMSET_IMPL(ctx, block, c, size) do {                             \
+    if (UNLIKELY(!asan_inited)) return internal_memset(block, c, size);        \
+    if (asan_init_is_running) {                                                \
+      return REAL(memset)(block, c, size);                                     \
+    }                                                                          \
+    ENSURE_ASAN_INITED();                                                      \
+    if (flags()->replace_intrin) {                                             \
+      ASAN_WRITE_RANGE(ctx, block, size);                                      \
+    }                                                                          \
+    return REAL(memset)(block, c, size);                                       \
+  } while (0)
+
+void *__asan_memset(void *block, int c, uptr size) {
+  ASAN_MEMSET_IMPL(nullptr, block, c, size);
 }
 
+#define ASAN_MEMMOVE_IMPL(ctx, to, from, size) do {                            \
+    if (UNLIKELY(!asan_inited))                                                \
+      return internal_memmove(to, from, size);                                 \
+    ENSURE_ASAN_INITED();                                                      \
+    if (flags()->replace_intrin) {                                             \
+      ASAN_READ_RANGE(ctx, from, size);                                        \
+      ASAN_WRITE_RANGE(ctx, to, size);                                         \
+    }                                                                          \
+    return internal_memmove(to, from, size);                                   \
+  } while (0)
+
 void *__asan_memmove(void *to, const void *from, uptr size) {
-  if (UNLIKELY(!asan_inited))
-    return internal_memmove(to, from, size);
-  ENSURE_ASAN_INITED();
-  if (flags()->replace_intrin) {
-    ASAN_READ_RANGE(from, size);
-    ASAN_WRITE_RANGE(to, size);
-  }
-  return internal_memmove(to, from, size);
+  ASAN_MEMMOVE_IMPL(nullptr, to, from, size);
 }
 
 INTERCEPTOR(void*, memmove, void *to, const void *from, uptr size) {
-  return __asan_memmove(to, from, size);
+  void *ctx;
+  ASAN_INTERCEPTOR_ENTER(ctx, memmove);
+  ASAN_MEMMOVE_IMPL(ctx, to, from, size);
 }
 
 INTERCEPTOR(void*, memcpy, void *to, const void *from, uptr size) {
+  void *ctx;
+  ASAN_INTERCEPTOR_ENTER(ctx, memcpy);
 #if !SANITIZER_MAC
-  return __asan_memcpy(to, from, size);
+  ASAN_MEMCPY_IMPL(ctx, to, from, size);
 #else
   // At least on 10.7 and 10.8 both memcpy() and memmove() are being replaced
   // with WRAP(memcpy). As a result, false positives are reported for memmove()
   // calls. If we just disable error reporting with
   // ASAN_OPTIONS=replace_intrin=0, memmove() is still replaced with
   // internal_memcpy(), which may lead to crashes, see
   // http://llvm.org/bugs/show_bug.cgi?id=16362.
-  return __asan_memmove(to, from, size);
+  ASAN_MEMMOVE_IMPL(ctx, to, from, size);
 #endif  // !SANITIZER_MAC
 }
 
 INTERCEPTOR(void*, memset, void *block, int c, uptr size) {
-  return __asan_memset(block, c, size);
+  void *ctx;
+  ASAN_INTERCEPTOR_ENTER(ctx, memset);
+  ASAN_MEMSET_IMPL(ctx, block, c, size);
 }
 
 INTERCEPTOR(char*, strchr, const char *str, int c) {
+  void *ctx;
+  ASAN_INTERCEPTOR_ENTER(ctx, strchr);
   if (UNLIKELY(!asan_inited)) return internal_strchr(str, c);
   // strchr is called inside create_purgeable_zone() when MallocGuardEdges=1 is
   // used.
   if (asan_init_is_running) {
     return REAL(strchr)(str, c);
   }
   ENSURE_ASAN_INITED();
   char *result = REAL(strchr)(str, c);
   if (flags()->replace_str) {
     uptr bytes_read = (result ? result - str : REAL(strlen)(str)) + 1;
-    ASAN_READ_RANGE(str, bytes_read);
+    ASAN_READ_RANGE(ctx, str, bytes_read);
   }
   return result;
 }
 
 #if ASAN_INTERCEPT_INDEX
 # if ASAN_USE_ALIAS_ATTRIBUTE_FOR_INDEX
 INTERCEPTOR(char*, index, const char *string, int c)
   ALIAS(WRAPPER_NAME(strchr));
 # else
 #  if SANITIZER_MAC
 DECLARE_REAL(char*, index, const char *string, int c)
 OVERRIDE_FUNCTION(index, strchr);
 #  else
 DEFINE_REAL(char*, index, const char *string, int c)
 #  endif
 # endif
 #endif  // ASAN_INTERCEPT_INDEX
 
 // For both strcat() and strncat() we need to check the validity of |to|
 // argument irrespective of the |from| length.
 INTERCEPTOR(char*, strcat, char *to, const char *from) {  // NOLINT
+  void *ctx;
+  ASAN_INTERCEPTOR_ENTER(ctx, strcat);  // NOLINT
   ENSURE_ASAN_INITED();
   if (flags()->replace_str) {
     uptr from_length = REAL(strlen)(from);
-    ASAN_READ_RANGE(from, from_length + 1);
+    ASAN_READ_RANGE(ctx, from, from_length + 1);
     uptr to_length = REAL(strlen)(to);
-    ASAN_READ_RANGE(to, to_length);
-    ASAN_WRITE_RANGE(to + to_length, from_length + 1);
+    ASAN_READ_RANGE(ctx, to, to_length);
+    ASAN_WRITE_RANGE(ctx, to + to_length, from_length + 1);
     // If the copying actually happens, the |from| string should not overlap
     // with the resulting string starting at |to|, which has a length of
     // to_length + from_length + 1.
     if (from_length > 0) {
       CHECK_RANGES_OVERLAP("strcat", to, from_length + to_length + 1,
                            from, from_length + 1);
     }
   }
   return REAL(strcat)(to, from);  // NOLINT
 }
 
 INTERCEPTOR(char*, strncat, char *to, const char *from, uptr size) {
+  void *ctx;
+  ASAN_INTERCEPTOR_ENTER(ctx, strncat);
   ENSURE_ASAN_INITED();
   if (flags()->replace_str) {
     uptr from_length = MaybeRealStrnlen(from, size);
     uptr copy_length = Min(size, from_length + 1);
-    ASAN_READ_RANGE(from, copy_length);
+    ASAN_READ_RANGE(ctx, from, copy_length);
     uptr to_length = REAL(strlen)(to);
-    ASAN_READ_RANGE(to, to_length);
-    ASAN_WRITE_RANGE(to + to_length, from_length + 1);
+    ASAN_READ_RANGE(ctx, to, to_length);
+    ASAN_WRITE_RANGE(ctx, to + to_length, from_length + 1);
     if (from_length > 0) {
       CHECK_RANGES_OVERLAP("strncat", to, to_length + copy_length + 1,
                            from, copy_length);
     }
   }
   return REAL(strncat)(to, from, size);
 }
 
 INTERCEPTOR(char*, strcpy, char *to, const char *from) {  // NOLINT
+  void *ctx;
+  ASAN_INTERCEPTOR_ENTER(ctx, strcpy);  // NOLINT
 #if SANITIZER_MAC
   if (UNLIKELY(!asan_inited)) return REAL(strcpy)(to, from);  // NOLINT
 #endif
   // strcpy is called from malloc_default_purgeable_zone()
   // in __asan::ReplaceSystemAlloc() on Mac.
   if (asan_init_is_running) {
     return REAL(strcpy)(to, from);  // NOLINT
   }
   ENSURE_ASAN_INITED();
   if (flags()->replace_str) {
     uptr from_size = REAL(strlen)(from) + 1;
     CHECK_RANGES_OVERLAP("strcpy", to, from_size, from, from_size);
-    ASAN_READ_RANGE(from, from_size);
-    ASAN_WRITE_RANGE(to, from_size);
+    ASAN_READ_RANGE(ctx, from, from_size);
+    ASAN_WRITE_RANGE(ctx, to, from_size);
   }
   return REAL(strcpy)(to, from);  // NOLINT
 }
 
 #if ASAN_INTERCEPT_STRDUP
 INTERCEPTOR(char*, strdup, const char *s) {
+  void *ctx;
+  ASAN_INTERCEPTOR_ENTER(ctx, strdup);
   if (UNLIKELY(!asan_inited)) return internal_strdup(s);
   ENSURE_ASAN_INITED();
   uptr length = REAL(strlen)(s);
   if (flags()->replace_str) {
-    ASAN_READ_RANGE(s, length + 1);
+    ASAN_READ_RANGE(ctx, s, length + 1);
   }
   GET_STACK_TRACE_MALLOC;
   void *new_mem = asan_malloc(length + 1, &stack);
   REAL(memcpy)(new_mem, s, length + 1);
   return reinterpret_cast<char*>(new_mem);
 }
 #endif
 
 INTERCEPTOR(SIZE_T, strlen, const char *s) {
+  void *ctx;
+  ASAN_INTERCEPTOR_ENTER(ctx, strlen);
   if (UNLIKELY(!asan_inited)) return internal_strlen(s);
   // strlen is called from malloc_default_purgeable_zone()
   // in __asan::ReplaceSystemAlloc() on Mac.
   if (asan_init_is_running) {
     return REAL(strlen)(s);
   }
   ENSURE_ASAN_INITED();
   SIZE_T length = REAL(strlen)(s);
   if (flags()->replace_str) {
-    ASAN_READ_RANGE(s, length + 1);
+    ASAN_READ_RANGE(ctx, s, length + 1);
   }
   return length;
 }
 
 INTERCEPTOR(SIZE_T, wcslen, const wchar_t *s) {
+  void *ctx;
+  ASAN_INTERCEPTOR_ENTER(ctx, wcslen);
   SIZE_T length = REAL(wcslen)(s);
   if (!asan_init_is_running) {
     ENSURE_ASAN_INITED();
-    ASAN_READ_RANGE(s, (length + 1) * sizeof(wchar_t));
+    ASAN_READ_RANGE(ctx, s, (length + 1) * sizeof(wchar_t));
   }
   return length;
 }
 
 INTERCEPTOR(char*, strncpy, char *to, const char *from, uptr size) {
+  void *ctx;
+  ASAN_INTERCEPTOR_ENTER(ctx, strncpy);
   ENSURE_ASAN_INITED();
   if (flags()->replace_str) {
     uptr from_size = Min(size, MaybeRealStrnlen(from, size) + 1);
     CHECK_RANGES_OVERLAP("strncpy", to, from_size, from, from_size);
-    ASAN_READ_RANGE(from, from_size);
-    ASAN_WRITE_RANGE(to, size);
+    ASAN_READ_RANGE(ctx, from, from_size);
+    ASAN_WRITE_RANGE(ctx, to, size);
   }
   return REAL(strncpy)(to, from, size);
 }
 
 #if ASAN_INTERCEPT_STRNLEN
 INTERCEPTOR(uptr, strnlen, const char *s, uptr maxlen) {
+  void *ctx;
+  ASAN_INTERCEPTOR_ENTER(ctx, strnlen);
   ENSURE_ASAN_INITED();
   uptr length = REAL(strnlen)(s, maxlen);
   if (flags()->replace_str) {
-    ASAN_READ_RANGE(s, Min(length + 1, maxlen));
+    ASAN_READ_RANGE(ctx, s, Min(length + 1, maxlen));
   }
   return length;
 }
 #endif  // ASAN_INTERCEPT_STRNLEN
 
 static inline bool IsValidStrtolBase(int base) {
   return (base == 0) || (2 <= base && base <= 36);
 }
 
 static inline void FixRealStrtolEndptr(const char *nptr, char **endptr) {
   CHECK(endptr);
   if (nptr == *endptr) {
     // No digits were found at strtol call, we need to find out the last
     // symbol accessed by strtoll on our own.
     // We get this symbol by skipping leading blanks and optional +/- sign.
     while (IsSpace(*nptr)) nptr++;
     if (*nptr == '+' || *nptr == '-') nptr++;
     *endptr = const_cast<char *>(nptr);
   }
   CHECK(*endptr >= nptr);
 }
 
 INTERCEPTOR(long, strtol, const char *nptr,  // NOLINT
             char **endptr, int base) {
+  void *ctx;
+  ASAN_INTERCEPTOR_ENTER(ctx, strtol);
   ENSURE_ASAN_INITED();
   if (!flags()->replace_str) {
     return REAL(strtol)(nptr, endptr, base);
   }
   char *real_endptr;
   long result = REAL(strtol)(nptr, &real_endptr, base);  // NOLINT
   if (endptr != 0) {
     *endptr = real_endptr;
   }
   if (IsValidStrtolBase(base)) {
     FixRealStrtolEndptr(nptr, &real_endptr);
-    ASAN_READ_RANGE(nptr, (real_endptr - nptr) + 1);
+    ASAN_READ_RANGE(ctx, nptr, (real_endptr - nptr) + 1);
   }
   return result;
 }
 
 INTERCEPTOR(int, atoi, const char *nptr) {
+  void *ctx;
+  ASAN_INTERCEPTOR_ENTER(ctx, atoi);
 #if SANITIZER_MAC
   if (UNLIKELY(!asan_inited)) return REAL(atoi)(nptr);
 #endif
   ENSURE_ASAN_INITED();
   if (!flags()->replace_str) {
     return REAL(atoi)(nptr);
   }
   char *real_endptr;
   // "man atoi" tells that behavior of atoi(nptr) is the same as
   // strtol(nptr, 0, 10), i.e. it sets errno to ERANGE if the
   // parsed integer can't be stored in *long* type (even if it's
   // different from int). So, we just imitate this behavior.
   int result = REAL(strtol)(nptr, &real_endptr, 10);
   FixRealStrtolEndptr(nptr, &real_endptr);
-  ASAN_READ_RANGE(nptr, (real_endptr - nptr) + 1);
+  ASAN_READ_RANGE(ctx, nptr, (real_endptr - nptr) + 1);
   return result;
 }
 
 INTERCEPTOR(long, atol, const char *nptr) {  // NOLINT
+  void *ctx;
+  ASAN_INTERCEPTOR_ENTER(ctx, atol);
 #if SANITIZER_MAC
   if (UNLIKELY(!asan_inited)) return REAL(atol)(nptr);
 #endif
   ENSURE_ASAN_INITED();
   if (!flags()->replace_str) {
     return REAL(atol)(nptr);
   }
   char *real_endptr;
   long result = REAL(strtol)(nptr, &real_endptr, 10);  // NOLINT
   FixRealStrtolEndptr(nptr, &real_endptr);
-  ASAN_READ_RANGE(nptr, (real_endptr - nptr) + 1);
+  ASAN_READ_RANGE(ctx, nptr, (real_endptr - nptr) + 1);
   return result;
 }
 
 #if ASAN_INTERCEPT_ATOLL_AND_STRTOLL
 INTERCEPTOR(long long, strtoll, const char *nptr,  // NOLINT
             char **endptr, int base) {
+  void *ctx;
+  ASAN_INTERCEPTOR_ENTER(ctx, strtoll);
   ENSURE_ASAN_INITED();
   if (!flags()->replace_str) {
     return REAL(strtoll)(nptr, endptr, base);
   }
   char *real_endptr;
   long long result = REAL(strtoll)(nptr, &real_endptr, base);  // NOLINT
   if (endptr != 0) {
     *endptr = real_endptr;
   }
   // If base has unsupported value, strtoll can exit with EINVAL
   // without reading any characters. So do additional checks only
   // if base is valid.
   if (IsValidStrtolBase(base)) {
     FixRealStrtolEndptr(nptr, &real_endptr);
-    ASAN_READ_RANGE(nptr, (real_endptr - nptr) + 1);
+    ASAN_READ_RANGE(ctx, nptr, (real_endptr - nptr) + 1);
   }
   return result;
 }
 
 INTERCEPTOR(long long, atoll, const char *nptr) {  // NOLINT
+  void *ctx;
+  ASAN_INTERCEPTOR_ENTER(ctx, atoll);
   ENSURE_ASAN_INITED();
   if (!flags()->replace_str) {
     return REAL(atoll)(nptr);
   }
   char *real_endptr;
   long long result = REAL(strtoll)(nptr, &real_endptr, 10);  // NOLINT
   FixRealStrtolEndptr(nptr, &real_endptr);
-  ASAN_READ_RANGE(nptr, (real_endptr - nptr) + 1);
+  ASAN_READ_RANGE(ctx, nptr, (real_endptr - nptr) + 1);
   return result;
 }
 #endif  // ASAN_INTERCEPT_ATOLL_AND_STRTOLL
 
 static void AtCxaAtexit(void *unused) {
   (void)unused;
   StopInitOrderChecking();
 }

lib/asan/asan_rtl.cc

 #include "asan_interceptors.h"
 #include "asan_interface_internal.h"
 #include "asan_internal.h"
 #include "asan_mapping.h"
 #include "asan_poisoning.h"
 #include "asan_report.h"
 #include "asan_stack.h"
 #include "asan_stats.h"
+#include "asan_suppressions.h"
 #include "asan_thread.h"
 #include "sanitizer_common/sanitizer_atomic.h"
 #include "sanitizer_common/sanitizer_flags.h"
 #include "sanitizer_common/sanitizer_libc.h"
 #include "sanitizer_common/sanitizer_symbolizer.h"
 #include "lsan/lsan_common.h"
 
 int __asan_option_detect_stack_use_after_return;  // Global interface symbol.
static void AsanInitInternal() {
   // Re-exec ourselves if we need to set additional env or command line args.
   MaybeReexec();
 
   // Setup internal allocator callback.
   SetLowLevelAllocateCallback(OnLowLevelAllocate);
 
   InitializeAsanInterceptors();
 
+  InitializeSuppressions();
+
   // Enable system log ("adb logcat") on Android.
   // Doing this before interceptors are initialized crashes in:
   // AsanInitInternal -> android_log_write -> __interceptor_strcmp
   AndroidLogInit();
 
   ReplaceSystemMalloc();
 
   uptr shadow_start = kLowShadowBeg;

lib/asan/asan_suppressions.h

+//===-- asan_suppressions.h -------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+// ASan-private header for asan_suppressions.cc.
+//===----------------------------------------------------------------------===//
+#ifndef ASAN_SUPPRESSIONS_H
+#define ASAN_SUPPRESSIONS_H
+
+#include "asan_internal.h"
+#include "sanitizer_common/sanitizer_suppressions.h"
+
+namespace __asan {
+
+void InitializeSuppressions();
+bool IsInterceptorSuppressed(const char *interceptor_name);
+bool IsStackTraceSuppressed(StackTrace *stack);
+
+}  // namespace __asan
+
+#endif  // ASAN_SUPPRESSIONS_H

lib/asan/asan_suppressions.cc

+//===-- asan_suppressions.cc ----------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+// Issue suppression and suppression-related functions.
+//===----------------------------------------------------------------------===//
+
+#include "asan_suppressions.h"
+
+#include "asan_stack.h"
+#include "sanitizer_common/sanitizer_common.h"
+#include "sanitizer_common/sanitizer_placement_new.h"
+#include "sanitizer_common/sanitizer_stacktrace.h"
+#include "sanitizer_common/sanitizer_symbolizer.h"
+
+namespace __asan {
+
+static bool suppressions_inited = false;
+
+void InitializeSuppressions() {
+  CHECK(!suppressions_inited);
+  SuppressionContext::InitIfNecessary();
+  suppressions_inited = true;
+}
+
+bool IsInterceptorSuppressed(const char *interceptor_name) {
+  SuppressionContext *ctx = SuppressionContext::Get();
+  Suppression *s;
+  // Match "interceptor_name" suppressions.
+  return ctx->Match(interceptor_name, SuppressionInterceptorName, &s);
+}
+
+bool IsStackTraceSuppressed(StackTrace *stack) {
+  SuppressionContext *ctx = SuppressionContext::Get();
+  if (!ctx->HasSuppressionType(SuppressionInterceptorViaFunction)
+    && !ctx->HasSuppressionType(SuppressionInterceptorViaLibrary))
+    return false;
+
+  Suppression *s;
+  for (uptr i = 0; i < stack->size && stack->trace[i]; i++) {
+    uptr addr = stack->trace[i];
+    Symbolizer *symbolizer = Symbolizer::GetOrInit();
+
+    if (ctx->HasSuppressionType(SuppressionInterceptorViaLibrary)) {
+      const char *module_name;
+      uptr module_offset;
+      if (symbolizer->GetModuleNameAndOffsetForPC(addr, &module_name,
+                                                  &module_offset)) {
+        // Match "interceptor_via_library" suppressions.
+        if (ctx->Match(module_name, SuppressionInterceptorViaLibrary, &s))
+          return true;
+      }
+    }
+
+    if (ctx->HasSuppressionType(SuppressionInterceptorViaFunction)) {
+      SymbolizedFrame *frames = symbolizer->SymbolizePC(addr);
+      for (SymbolizedFrame *cur = frames; cur; cur = cur->next) {
+        const char *function_name = cur->info.function;
+        // Match "interceptor_via_function" suppressions.
+        if (ctx->Match(function_name, SuppressionInterceptorViaFunction, &s)) {
+          frames->ClearAll();
+          return true;
+        }
+      }
+      frames->ClearAll();
+    }
+  }
+  return false;
+}
+
+}  // namespace __asan

lib/sanitizer_common/sanitizer_suppressions.h

enum SuppressionType {
   SuppressionRace,
   SuppressionMutex,
   SuppressionThread,
   SuppressionSignal,
   SuppressionLeak,
   SuppressionLib,
   SuppressionDeadlock,
   SuppressionVptrCheck,
+  SuppressionInterceptorName,
+  SuppressionInterceptorViaFunction,
+  SuppressionInterceptorViaLibrary,
   SuppressionTypeCount
 };
 
 struct Suppression {
   SuppressionType type;
   char *templ;
   unsigned hit_count;
   uptr weight;
 };
 
 class SuppressionContext {
  public:
   void Parse(const char *str);
   bool Match(const char* str, SuppressionType type, Suppression **s);
   uptr SuppressionCount() const;
   const Suppression *SuppressionAt(uptr i) const;
   void GetMatched(InternalMmapVector<Suppression *> *matched);
 
   // Create a SuppressionContext singleton if it hasn't been created earlier.
   // Not thread safe. Must be called early during initialization (but after
   // runtime flags are parsed).
   static void InitIfNecessary();
   // Returns a SuppressionContext singleton.
   static SuppressionContext *Get();
 
  private:
   SuppressionContext() : suppressions_(1), can_parse_(true) {}
   InternalMmapVector<Suppression> suppressions_;
   bool can_parse_;
 
   friend class SuppressionContextTest;
 };
 
 const char *SuppressionTypeString(SuppressionType t);
 
 bool TemplateMatch(char *templ, const char *str);
 
 }  // namespace __sanitizer
 
 #endif  // SANITIZER_SUPPRESSIONS_H

lib/sanitizer_common/sanitizer_suppressions.cc

 #include "sanitizer_flags.h"
 #include "sanitizer_libc.h"
 #include "sanitizer_placement_new.h"
 
 namespace __sanitizer {
 
 static const char *const kTypeStrings[SuppressionTypeCount] = {
     "none", "race",            "mutex",    "thread",    "signal",
-    "leak", "called_from_lib", "deadlock", "vptr_check"};
+    "leak", "called_from_lib", "deadlock", "vptr_check",
+    "interceptor_name", "interceptor_via_function", "interceptor_via_library"};
 
 bool TemplateMatch(char *templ, const char *str) {
   if (str == 0 || str[0] == 0)
     return false;
   bool start = false;
   if (templ && templ[0] == '^') {
     start = true;
     templ++;
   }

lib/sanitizer_common/tests/sanitizer_suppressions_test.cc

TEST(Suppressions, TypeStrings) {
   CHECK(!internal_strcmp(SuppressionTypeString(SuppressionSignal), "signal"));
   CHECK(!internal_strcmp(SuppressionTypeString(SuppressionLeak), "leak"));
   CHECK(!internal_strcmp(SuppressionTypeString(SuppressionLib),
                          "called_from_lib"));
   CHECK(
       !internal_strcmp(SuppressionTypeString(SuppressionDeadlock), "deadlock"));
   CHECK(!internal_strcmp(SuppressionTypeString(SuppressionVptrCheck),
                          "vptr_check"));
+  CHECK(!internal_strcmp(SuppressionTypeString(
+    SuppressionInterceptorName), "interceptor_name"));
+  CHECK(!internal_strcmp(SuppressionTypeString(
+    SuppressionInterceptorViaFunction), "interceptor_via_function"));
+  CHECK(!internal_strcmp(SuppressionTypeString(
+    SuppressionInterceptorViaLibrary), "interceptor_via_library"));
   // Ensure this test is up-to-date when suppression types are added.
-  CHECK_EQ(9, SuppressionTypeCount);
+  CHECK_EQ(12, SuppressionTypeCount);
 }
 
 class SuppressionContextTest : public ::testing::Test {
  public:
   virtual void SetUp() { ctx_ = new(placeholder_) SuppressionContext; }
   virtual void TearDown() { ctx_->~SuppressionContext(); }
 
  protected:
   InternalMmapVector<Suppression> *Suppressions() {
     return &ctx_->suppressions_;
   }

test/asan/TestCases/Darwin/suppressions-darwin.cc

+// Check that without suppressions, we catch the issue.
+// RUN: %clangxx_asan -O0 %s -o %t -framework Foundation
+// RUN: not %run %t 2>&1 | FileCheck --check-prefix=CHECK-CRASH %s
+
+// Check that suppressing the interceptor by name works.
+// RUN: echo "interceptor_name:memmove" > %tmp
+// RUN: ASAN_OPTIONS=suppressions=%tmp %run %t 2>&1 | FileCheck --check-prefix=CHECK-IGNORE %s
+
+// Check that suppressing all reports from a library works.
+// RUN: echo "interceptor_via_library:CoreFoundation" > %tmp
+// RUN: ASAN_OPTIONS=suppressions=%tmp %run %t 2>&1 | FileCheck --check-prefix=CHECK-IGNORE %s
+
+// Check that suppressing library works even without the symbolizer.
+// RUN: ASAN_OPTIONS=suppressions=%tmp ASAN_SYMBOLIZER_PATH=/dev/null %run %t 2>&1 | FileCheck --check-prefix=CHECK-IGNORE %s
+
+#include <CoreFoundation/CoreFoundation.h>
+
+int main() {
+  char *a = (char *)malloc(6);
+  strcpy(a, "hello");
+  CFStringRef str = CFStringCreateWithBytes(kCFAllocatorDefault, (unsigned char *)a, 10, kCFStringEncodingUTF8, FALSE); // BOOM
+  fprintf(stderr, "Ignored.\n");
+}
+
+// CHECK-CRASH: AddressSanitizer: heap-buffer-overflow
+// CHECK-CRASH-NOT: Ignored.
+// CHECK-IGNORE: Ignored.
+// CHECK-IGNORE-NOT: AddressSanitizer: heap-buffer-overflow

test/asan/TestCases/suppressions-function.cc

+// Check that without suppressions, we catch the issue.
+// RUN: %clangxx_asan -O0 %s -o %t
+// RUN: not %run %t 2>&1 | FileCheck --check-prefix=CHECK-CRASH %s
+
+// RUN: echo "interceptor_via_function:crash_function" > %tmp
+// RUN: ASAN_OPTIONS=suppressions=%tmp %run %t 2>&1 | FileCheck --check-prefix=CHECK-IGNORE %s
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+void crash_function() {
+  char *a = (char *)malloc(6);
+  free(a);
+  size_t len = strlen(a); // BOOM
+  fprintf(stderr, "strlen ignored, len = %zu\n", len);
+}
+
+int main() {
+  crash_function();
+}
+
+// CHECK-CRASH: AddressSanitizer: heap-use-after-free
+// CHECK-CRASH-NOT: strlen ignored
+// CHECK-IGNORE: strlen ignored
+// CHECK-IGNORE-NOT: AddressSanitizer: heap-use-after-free

test/asan/TestCases/suppressions-instrumented-code.cc

+// Check that reports from instrumented code cannot be suppressed.
+// RUN: %clangxx_asan -O0 %s -o %t
+// RUN: echo "interceptor_name:memset" > %tmp
+// RUN: echo "interceptor_via_function:main" >> %tmp
+// RUN: echo "interceptor_via_library:%t" >> %tmp
+// RUN: ASAN_OPTIONS=suppressions=%tmp not %run %t 1 2>&1 | FileCheck %s
+// RUN: ASAN_OPTIONS=suppressions=%tmp not %run %t 2 2>&1 | FileCheck %s
+// RUN: ASAN_OPTIONS=suppressions=%tmp not %run %t 3 2>&1 | FileCheck %s
+// RUN: ASAN_OPTIONS=suppressions=%tmp not %run %t 4 2>&1 | FileCheck %s
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int main(int argc, char *argv[]) {
+  char *a = (char *)malloc(6);
+  free(a);
+  switch (argv[1][0]) {
+    case '1':
+      a[0] = 'A'; // BOOM
+      break;
+    case '2':
+      memset(a, 'A', 6); // BOOM
+      break;
+    case '3':
+      memcpy(a, a, 6); // BOOM
+      break;
+    case '4':
+      memmove(a, a, 6); // BOOM
+      break;
+  }
+  fprintf(stderr, "ignored\n");
+}
+
+// CHECK: AddressSanitizer: heap-use-after-free
+// CHECK-NOT: ignored

test/asan/TestCases/suppressions-interceptor.cc

+// Check that without suppressions, we catch the issue.
+// RUN: %clangxx_asan -O0 %s -o %t
+// RUN: not %run %t 2>&1 | FileCheck --check-prefix=CHECK-CRASH %s
+
+// RUN: echo "interceptor_name:strlen" > %tmp
+// RUN: ASAN_OPTIONS=suppressions=%tmp %run %t 2>&1 | FileCheck --check-prefix=CHECK-IGNORE %s
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int main() {
+  char *a = (char *)malloc(6);
+  free(a);
+  size_t len = strlen(a); // BOOM
+  fprintf(stderr, "strlen ignored, len = %zu\n", len);
+}
+
+// CHECK-CRASH: AddressSanitizer: heap-use-after-free
+// CHECK-CRASH-NOT: strlen ignored
+// CHECK-IGNORE: strlen ignored
+// CHECK-IGNORE-NOT: AddressSanitizer: heap-use-after-free

test/asan/TestCases/suppressions-library.cc

+// RUN: %clangxx_asan -O0 -DSHARED_LIB %s -fPIC -shared -o %t-so.so
+// RUN: %clangxx_asan -O0 %s %t-so.so -o %t
+
+// Check that without suppressions, we catch the issue.
+// RUN: not %run %t 2>&1 | FileCheck --check-prefix=CHECK-CRASH %s
+
+// RUN: echo "interceptor_via_library:%t-so.so" > %tmp
+// RUN: ASAN_OPTIONS=suppressions=%tmp %run %t 2>&1 | FileCheck --check-prefix=CHECK-IGNORE %s
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#if !defined(SHARED_LIB)
+
+void crash_function();
+
+int main(int argc, char *argv[]) {
+  crash_function();
+  return 0;
+}
+
+#else  // SHARED_LIB
+
+void crash_function() {
+  char *a = (char *)malloc(6);
+  free(a);
+  size_t len = strlen(a); // BOOM
+  fprintf(stderr, "strlen ignored, %zu\n", len);
+}
+
+#endif  // SHARED_LIB
+
+// CHECK-CRASH: AddressSanitizer: heap-use-after-free
+// CHECK-CRASH-NOT: strlen ignored
+// CHECK-IGNORE: strlen ignored
+// CHECK-IGNORE-NOT: AddressSanitizer: heap-use-after-free