1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
|
//===- Sanitizers.cpp - C Language Family Language Options ----------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file defines the classes from Sanitizers.h
//
//===----------------------------------------------------------------------===//
#include "clang/Basic/Sanitizers.h"
#include "llvm/ADT/Hashing.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringSwitch.h"
#include "llvm/Support/MathExtras.h"
using namespace clang;
// Once LLVM switches to C++17, the constexpr variables can be inline and we
// won't need this.
#define SANITIZER(NAME, ID) constexpr SanitizerMask SanitizerKind::ID;
#define SANITIZER_GROUP(NAME, ID, ALIAS) \
constexpr SanitizerMask SanitizerKind::ID; \
constexpr SanitizerMask SanitizerKind::ID##Group;
#include "clang/Basic/Sanitizers.def"
SanitizerMask clang::parseSanitizerValue(StringRef Value, bool AllowGroups) {
SanitizerMask ParsedKind = llvm::StringSwitch<SanitizerMask>(Value)
#define SANITIZER(NAME, ID) .Case(NAME, SanitizerKind::ID)
#define SANITIZER_GROUP(NAME, ID, ALIAS) \
.Case(NAME, AllowGroups ? SanitizerKind::ID##Group : SanitizerMask())
#include "clang/Basic/Sanitizers.def"
.Default(SanitizerMask());
return ParsedKind;
}
void clang::serializeSanitizerSet(SanitizerSet Set,
SmallVectorImpl<StringRef> &Values) {
#define SANITIZER(NAME, ID) \
if (Set.has(SanitizerKind::ID)) \
Values.push_back(NAME);
#include "clang/Basic/Sanitizers.def"
}
SanitizerMask clang::expandSanitizerGroups(SanitizerMask Kinds) {
#define SANITIZER(NAME, ID)
#define SANITIZER_GROUP(NAME, ID, ALIAS) \
if (Kinds & SanitizerKind::ID##Group) \
Kinds |= SanitizerKind::ID;
#include "clang/Basic/Sanitizers.def"
return Kinds;
}
llvm::hash_code SanitizerMask::hash_value() const {
return llvm::hash_combine_range(&maskLoToHigh[0], &maskLoToHigh[kNumElem]);
}
namespace clang {
unsigned SanitizerMask::countPopulation() const {
unsigned total = 0;
for (const auto &Val : maskLoToHigh)
total += llvm::popcount(Val);
return total;
}
llvm::hash_code hash_value(const clang::SanitizerMask &Arg) {
return Arg.hash_value();
}
StringRef AsanDtorKindToString(llvm::AsanDtorKind kind) {
switch (kind) {
case llvm::AsanDtorKind::None:
return "none";
case llvm::AsanDtorKind::Global:
return "global";
case llvm::AsanDtorKind::Invalid:
return "invalid";
}
return "invalid";
}
llvm::AsanDtorKind AsanDtorKindFromString(StringRef kindStr) {
return llvm::StringSwitch<llvm::AsanDtorKind>(kindStr)
.Case("none", llvm::AsanDtorKind::None)
.Case("global", llvm::AsanDtorKind::Global)
.Default(llvm::AsanDtorKind::Invalid);
}
StringRef AsanDetectStackUseAfterReturnModeToString(
llvm::AsanDetectStackUseAfterReturnMode mode) {
switch (mode) {
case llvm::AsanDetectStackUseAfterReturnMode::Always:
return "always";
case llvm::AsanDetectStackUseAfterReturnMode::Runtime:
return "runtime";
case llvm::AsanDetectStackUseAfterReturnMode::Never:
return "never";
case llvm::AsanDetectStackUseAfterReturnMode::Invalid:
return "invalid";
}
return "invalid";
}
llvm::AsanDetectStackUseAfterReturnMode
AsanDetectStackUseAfterReturnModeFromString(StringRef modeStr) {
return llvm::StringSwitch<llvm::AsanDetectStackUseAfterReturnMode>(modeStr)
.Case("always", llvm::AsanDetectStackUseAfterReturnMode::Always)
.Case("runtime", llvm::AsanDetectStackUseAfterReturnMode::Runtime)
.Case("never", llvm::AsanDetectStackUseAfterReturnMode::Never)
.Default(llvm::AsanDetectStackUseAfterReturnMode::Invalid);
}
} // namespace clang
|
