llvm-project

1
//===-- asan_suppressions.cpp ---------------------------------------------===//
2
//
3
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4
// See https://llvm.org/LICENSE.txt for license information.
5
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6
//
7
//===----------------------------------------------------------------------===//
8
//
9
// This file is a part of AddressSanitizer, an address sanity checker.
10
//
11
// Issue suppression and suppression-related functions.
12
//===----------------------------------------------------------------------===//
13

14
#include "asan_suppressions.h"
15

16
#include "asan_stack.h"
17
#include "sanitizer_common/sanitizer_placement_new.h"
18
#include "sanitizer_common/sanitizer_suppressions.h"
19
#include "sanitizer_common/sanitizer_symbolizer.h"
20

21
namespace __asan {
22

23
ALIGNED(64) static char suppression_placeholder[sizeof(SuppressionContext)];
24
static SuppressionContext *suppression_ctx = nullptr;
25
static const char kInterceptorName[] = "interceptor_name";
26
static const char kInterceptorViaFunction[] = "interceptor_via_fun";
27
static const char kInterceptorViaLibrary[] = "interceptor_via_lib";
28
static const char kODRViolation[] = "odr_violation";
29
static const char *kSuppressionTypes[] = {
30
    kInterceptorName, kInterceptorViaFunction, kInterceptorViaLibrary,
31
    kODRViolation};
32

33
SANITIZER_INTERFACE_WEAK_DEF(const char *, __asan_default_suppressions, void) {
34
  return "";
35
}
36

37
void InitializeSuppressions() {
38
  CHECK_EQ(nullptr, suppression_ctx);
39
  suppression_ctx = new (suppression_placeholder)
40
      SuppressionContext(kSuppressionTypes, ARRAY_SIZE(kSuppressionTypes));
41
  suppression_ctx->ParseFromFile(flags()->suppressions);
42
  suppression_ctx->Parse(__asan_default_suppressions());
43
}
44

45
bool IsInterceptorSuppressed(const char *interceptor_name) {
46
  CHECK(suppression_ctx);
47
  Suppression *s;
48
  // Match "interceptor_name" suppressions.
49
  return suppression_ctx->Match(interceptor_name, kInterceptorName, &s);
50
}
51

52
bool HaveStackTraceBasedSuppressions() {
53
  CHECK(suppression_ctx);
54
  return suppression_ctx->HasSuppressionType(kInterceptorViaFunction) ||
55
         suppression_ctx->HasSuppressionType(kInterceptorViaLibrary);
56
}
57

58
bool IsODRViolationSuppressed(const char *global_var_name) {
59
  CHECK(suppression_ctx);
60
  Suppression *s;
61
  // Match "odr_violation" suppressions.
62
  return suppression_ctx->Match(global_var_name, kODRViolation, &s);
63
}
64

65
bool IsStackTraceSuppressed(const StackTrace *stack) {
66
  if (!HaveStackTraceBasedSuppressions())
67
    return false;
68

69
  CHECK(suppression_ctx);
70
  Symbolizer *symbolizer = Symbolizer::GetOrInit();
71
  Suppression *s;
72
  for (uptr i = 0; i < stack->size && stack->trace[i]; i++) {
73
    uptr addr = stack->trace[i];
74

75
    if (suppression_ctx->HasSuppressionType(kInterceptorViaLibrary)) {
76
      // Match "interceptor_via_lib" suppressions.
77
      if (const char *module_name = symbolizer->GetModuleNameForPc(addr))
78
        if (suppression_ctx->Match(module_name, kInterceptorViaLibrary, &s))
79
          return true;
80
    }
81

82
    if (suppression_ctx->HasSuppressionType(kInterceptorViaFunction)) {
83
      SymbolizedStackHolder symbolized_stack(symbolizer->SymbolizePC(addr));
84
      const SymbolizedStack *frames = symbolized_stack.get();
85
      CHECK(frames);
86
      for (const SymbolizedStack *cur = frames; cur; cur = cur->next) {
87
        const char *function_name = cur->info.function;
88
        if (!function_name) {
89
          continue;
90
        }
91
        // Match "interceptor_via_fun" suppressions.
92
        if (suppression_ctx->Match(function_name, kInterceptorViaFunction,
93
                                   &s)) {
94
          return true;
95
        }
96
      }
97
    }
98
  }
99
  return false;
100
}
101

102
} // namespace __asan
103