1 //===- Sanitizers.h - C Language Family Language Options --------*- C++ -*-===//
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 /// \file
10 /// Defines the clang::SanitizerKind enum.
11 //
12 //===----------------------------------------------------------------------===//
13
14 #ifndef LLVM_CLANG_BASIC_SANITIZERS_H
15 #define LLVM_CLANG_BASIC_SANITIZERS_H
16
17 #include "clang/Basic/LLVM.h"
18 #include "llvm/ADT/StringRef.h"
19 #include "llvm/Support/MathExtras.h"
20 #include <cassert>
21 #include <cstdint>
22
23 namespace llvm {
24 class hash_code;
25 }
26
27 namespace clang {
28
29 class SanitizerMask {
30 // NOTE: this class assumes kNumElem == 2 in most of the constexpr functions,
31 // in order to work within the C++11 constexpr function constraints. If you
32 // change kNumElem, you'll need to update those member functions as well.
33
34 /// Number of array elements.
35 static constexpr unsigned kNumElem = 2;
36 /// Mask value initialized to 0.
37 uint64_t maskLoToHigh[kNumElem]{};
38 /// Number of bits in a mask.
39 static constexpr unsigned kNumBits = sizeof(decltype(maskLoToHigh)) * 8;
40 /// Number of bits in a mask element.
41 static constexpr unsigned kNumBitElem = sizeof(decltype(maskLoToHigh[0])) * 8;
42
SanitizerMask(uint64_t mask1,uint64_t mask2)43 constexpr SanitizerMask(uint64_t mask1, uint64_t mask2)
44 : maskLoToHigh{mask1, mask2} {}
45
46 public:
47 SanitizerMask() = default;
48
checkBitPos(const unsigned Pos)49 static constexpr bool checkBitPos(const unsigned Pos) {
50 return Pos < kNumBits;
51 }
52
53 /// Create a mask with a bit enabled at position Pos.
bitPosToMask(const unsigned Pos)54 static constexpr SanitizerMask bitPosToMask(const unsigned Pos) {
55 return SanitizerMask((Pos < kNumBitElem) ? 1ULL << Pos % kNumBitElem : 0,
56 (Pos >= kNumBitElem && Pos < kNumBitElem * 2)
57 ? 1ULL << Pos % kNumBitElem
58 : 0);
59 }
60
countPopulation()61 unsigned countPopulation() const {
62 unsigned total = 0;
63 for (const auto &Val : maskLoToHigh)
64 total += llvm::countPopulation(Val);
65 return total;
66 }
67
flipAllBits()68 void flipAllBits() {
69 for (auto &Val : maskLoToHigh)
70 Val = ~Val;
71 }
72
isPowerOf2()73 bool isPowerOf2() const {
74 return countPopulation() == 1;
75 }
76
77 llvm::hash_code hash_value() const;
78
79 constexpr explicit operator bool() const {
80 return maskLoToHigh[0] || maskLoToHigh[1];
81 }
82
83 constexpr bool operator==(const SanitizerMask &V) const {
84 return maskLoToHigh[0] == V.maskLoToHigh[0] &&
85 maskLoToHigh[1] == V.maskLoToHigh[1];
86 }
87
88 SanitizerMask &operator&=(const SanitizerMask &RHS) {
89 for (unsigned k = 0; k < kNumElem; k++)
90 maskLoToHigh[k] &= RHS.maskLoToHigh[k];
91 return *this;
92 }
93
94 SanitizerMask &operator|=(const SanitizerMask &RHS) {
95 for (unsigned k = 0; k < kNumElem; k++)
96 maskLoToHigh[k] |= RHS.maskLoToHigh[k];
97 return *this;
98 }
99
100 constexpr bool operator!() const { return !bool(*this); }
101
102 constexpr bool operator!=(const SanitizerMask &RHS) const {
103 return !((*this) == RHS);
104 }
105
106 friend constexpr inline SanitizerMask operator~(SanitizerMask v) {
107 return SanitizerMask(~v.maskLoToHigh[0], ~v.maskLoToHigh[1]);
108 }
109
110 friend constexpr inline SanitizerMask operator&(SanitizerMask a,
111 const SanitizerMask &b) {
112 return SanitizerMask(a.maskLoToHigh[0] & b.maskLoToHigh[0],
113 a.maskLoToHigh[1] & b.maskLoToHigh[1]);
114 }
115
116 friend constexpr inline SanitizerMask operator|(SanitizerMask a,
117 const SanitizerMask &b) {
118 return SanitizerMask(a.maskLoToHigh[0] | b.maskLoToHigh[0],
119 a.maskLoToHigh[1] | b.maskLoToHigh[1]);
120 }
121 };
122
123 // Declaring in clang namespace so that it can be found by ADL.
124 llvm::hash_code hash_value(const clang::SanitizerMask &Arg);
125
126 // Define the set of sanitizer kinds, as well as the set of sanitizers each
127 // sanitizer group expands into.
128 struct SanitizerKind {
129 // Assign ordinals to possible values of -fsanitize= flag, which we will use
130 // as bit positions.
131 enum SanitizerOrdinal : uint64_t {
132 #define SANITIZER(NAME, ID) SO_##ID,
133 #define SANITIZER_GROUP(NAME, ID, ALIAS) SO_##ID##Group,
134 #include "clang/Basic/Sanitizers.def"
135 SO_Count
136 };
137
138 #define SANITIZER(NAME, ID) \
139 static constexpr SanitizerMask ID = SanitizerMask::bitPosToMask(SO_##ID); \
140 static_assert(SanitizerMask::checkBitPos(SO_##ID), "Bit position too big.");
141 #define SANITIZER_GROUP(NAME, ID, ALIAS) \
142 static constexpr SanitizerMask ID = SanitizerMask(ALIAS); \
143 static constexpr SanitizerMask ID##Group = \
144 SanitizerMask::bitPosToMask(SO_##ID##Group); \
145 static_assert(SanitizerMask::checkBitPos(SO_##ID##Group), \
146 "Bit position too big.");
147 #include "clang/Basic/Sanitizers.def"
148 }; // SanitizerKind
149
150 struct SanitizerSet {
151 /// Check if a certain (single) sanitizer is enabled.
hasSanitizerSet152 bool has(SanitizerMask K) const {
153 assert(K.isPowerOf2() && "Has to be a single sanitizer.");
154 return static_cast<bool>(Mask & K);
155 }
156
157 /// Check if one or more sanitizers are enabled.
hasOneOfSanitizerSet158 bool hasOneOf(SanitizerMask K) const { return static_cast<bool>(Mask & K); }
159
160 /// Enable or disable a certain (single) sanitizer.
setSanitizerSet161 void set(SanitizerMask K, bool Value) {
162 assert(K.isPowerOf2() && "Has to be a single sanitizer.");
163 Mask = Value ? (Mask | K) : (Mask & ~K);
164 }
165
166 /// Disable the sanitizers specified in \p K.
167 void clear(SanitizerMask K = SanitizerKind::All) { Mask &= ~K; }
168
169 /// Returns true if no sanitizers are enabled.
emptySanitizerSet170 bool empty() const { return !Mask; }
171
172 /// Bitmask of enabled sanitizers.
173 SanitizerMask Mask;
174 };
175
176 /// Parse a single value from a -fsanitize= or -fno-sanitize= value list.
177 /// Returns a non-zero SanitizerMask, or \c 0 if \p Value is not known.
178 SanitizerMask parseSanitizerValue(StringRef Value, bool AllowGroups);
179
180 /// For each sanitizer group bit set in \p Kinds, set the bits for sanitizers
181 /// this group enables.
182 SanitizerMask expandSanitizerGroups(SanitizerMask Kinds);
183
184 /// Return the sanitizers which do not affect preprocessing.
getPPTransparentSanitizers()185 inline SanitizerMask getPPTransparentSanitizers() {
186 return SanitizerKind::CFI | SanitizerKind::Integer |
187 SanitizerKind::ImplicitConversion | SanitizerKind::Nullability |
188 SanitizerKind::Undefined | SanitizerKind::FloatDivideByZero;
189 }
190
191 } // namespace clang
192
193 #endif // LLVM_CLANG_BASIC_SANITIZERS_H
194