1 //===-- ubsan_handlers.h ----------------------------------------*- 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 // Entry points to the runtime library for Clang's undefined behavior sanitizer.
10 //
11 //===----------------------------------------------------------------------===//
12 #ifndef UBSAN_HANDLERS_H
13 #define UBSAN_HANDLERS_H
14
15 #include "ubsan_value.h"
16
17 namespace __ubsan {
18
19 struct TypeMismatchData {
20 SourceLocation Loc;
21 const TypeDescriptor &Type;
22 unsigned char LogAlignment;
23 unsigned char TypeCheckKind;
24 };
25
26 #define UNRECOVERABLE(checkname, ...) \
27 extern "C" SANITIZER_INTERFACE_ATTRIBUTE NORETURN \
28 void __ubsan_handle_ ## checkname( __VA_ARGS__ );
29
30 #define RECOVERABLE(checkname, ...) \
31 extern "C" SANITIZER_INTERFACE_ATTRIBUTE \
32 void __ubsan_handle_ ## checkname( __VA_ARGS__ ); \
33 extern "C" SANITIZER_INTERFACE_ATTRIBUTE NORETURN \
34 void __ubsan_handle_ ## checkname ## _abort( __VA_ARGS__ );
35
36 /// \brief Handle a runtime type check failure, caused by either a misaligned
37 /// pointer, a null pointer, or a pointer to insufficient storage for the
38 /// type.
39 RECOVERABLE(type_mismatch_v1, TypeMismatchData *Data, ValueHandle Pointer)
40
41 struct AlignmentAssumptionData {
42 SourceLocation Loc;
43 SourceLocation AssumptionLoc;
44 const TypeDescriptor &Type;
45 };
46
47 /// \brief Handle a runtime alignment assumption check failure,
48 /// caused by a misaligned pointer.
49 RECOVERABLE(alignment_assumption, AlignmentAssumptionData *Data,
50 ValueHandle Pointer, ValueHandle Alignment, ValueHandle Offset)
51
52 struct OverflowData {
53 SourceLocation Loc;
54 const TypeDescriptor &Type;
55 };
56
57 /// \brief Handle an integer addition overflow.
58 RECOVERABLE(add_overflow, OverflowData *Data, ValueHandle LHS, ValueHandle RHS)
59
60 /// \brief Handle an integer subtraction overflow.
61 RECOVERABLE(sub_overflow, OverflowData *Data, ValueHandle LHS, ValueHandle RHS)
62
63 /// \brief Handle an integer multiplication overflow.
64 RECOVERABLE(mul_overflow, OverflowData *Data, ValueHandle LHS, ValueHandle RHS)
65
66 /// \brief Handle a signed integer overflow for a unary negate operator.
67 RECOVERABLE(negate_overflow, OverflowData *Data, ValueHandle OldVal)
68
69 /// \brief Handle an INT_MIN/-1 overflow or division by zero.
70 RECOVERABLE(divrem_overflow, OverflowData *Data,
71 ValueHandle LHS, ValueHandle RHS)
72
73 struct ShiftOutOfBoundsData {
74 SourceLocation Loc;
75 const TypeDescriptor &LHSType;
76 const TypeDescriptor &RHSType;
77 };
78
79 /// \brief Handle a shift where the RHS is out of bounds or a left shift where
80 /// the LHS is negative or overflows.
81 RECOVERABLE(shift_out_of_bounds, ShiftOutOfBoundsData *Data,
82 ValueHandle LHS, ValueHandle RHS)
83
84 struct OutOfBoundsData {
85 SourceLocation Loc;
86 const TypeDescriptor &ArrayType;
87 const TypeDescriptor &IndexType;
88 };
89
90 /// \brief Handle an array index out of bounds error.
91 RECOVERABLE(out_of_bounds, OutOfBoundsData *Data, ValueHandle Index)
92
93 struct UnreachableData {
94 SourceLocation Loc;
95 };
96
97 /// \brief Handle a __builtin_unreachable which is reached.
98 UNRECOVERABLE(builtin_unreachable, UnreachableData *Data)
99 /// \brief Handle reaching the end of a value-returning function.
100 UNRECOVERABLE(missing_return, UnreachableData *Data)
101
102 struct VLABoundData {
103 SourceLocation Loc;
104 const TypeDescriptor &Type;
105 };
106
107 /// \brief Handle a VLA with a non-positive bound.
108 RECOVERABLE(vla_bound_not_positive, VLABoundData *Data, ValueHandle Bound)
109
110 // Keeping this around for binary compatibility with (sanitized) programs
111 // compiled with older compilers.
112 struct FloatCastOverflowData {
113 const TypeDescriptor &FromType;
114 const TypeDescriptor &ToType;
115 };
116
117 struct FloatCastOverflowDataV2 {
118 SourceLocation Loc;
119 const TypeDescriptor &FromType;
120 const TypeDescriptor &ToType;
121 };
122
123 /// Handle overflow in a conversion to or from a floating-point type.
124 /// void *Data is one of FloatCastOverflowData* or FloatCastOverflowDataV2*
125 RECOVERABLE(float_cast_overflow, void *Data, ValueHandle From)
126
127 struct InvalidValueData {
128 SourceLocation Loc;
129 const TypeDescriptor &Type;
130 };
131
132 /// \brief Handle a load of an invalid value for the type.
133 RECOVERABLE(load_invalid_value, InvalidValueData *Data, ValueHandle Val)
134
135 /// Known implicit conversion check kinds.
136 /// Keep in sync with the enum of the same name in CGExprScalar.cpp
137 enum ImplicitConversionCheckKind : unsigned char {
138 ICCK_IntegerTruncation = 0, // Legacy, was only used by clang 7.
139 ICCK_UnsignedIntegerTruncation = 1,
140 ICCK_SignedIntegerTruncation = 2,
141 ICCK_IntegerSignChange = 3,
142 ICCK_SignedIntegerTruncationOrSignChange = 4,
143 };
144
145 struct ImplicitConversionData {
146 SourceLocation Loc;
147 const TypeDescriptor &FromType;
148 const TypeDescriptor &ToType;
149 /* ImplicitConversionCheckKind */ unsigned char Kind;
150 };
151
152 /// \brief Implict conversion that changed the value.
153 RECOVERABLE(implicit_conversion, ImplicitConversionData *Data, ValueHandle Src,
154 ValueHandle Dst)
155
156 /// Known builtin check kinds.
157 /// Keep in sync with the enum of the same name in CodeGenFunction.h
158 enum BuiltinCheckKind : unsigned char {
159 BCK_CTZPassedZero,
160 BCK_CLZPassedZero,
161 };
162
163 struct InvalidBuiltinData {
164 SourceLocation Loc;
165 unsigned char Kind;
166 };
167
168 /// Handle a builtin called in an invalid way.
169 RECOVERABLE(invalid_builtin, InvalidBuiltinData *Data)
170
171 struct InvalidObjCCast {
172 SourceLocation Loc;
173 const TypeDescriptor &ExpectedType;
174 };
175
176 /// Handle an invalid ObjC cast.
177 RECOVERABLE(invalid_objc_cast, InvalidObjCCast *Data, ValueHandle Pointer)
178
179 struct NonNullReturnData {
180 SourceLocation AttrLoc;
181 };
182
183 /// \brief Handle returning null from function with the returns_nonnull
184 /// attribute, or a return type annotated with _Nonnull.
185 RECOVERABLE(nonnull_return_v1, NonNullReturnData *Data, SourceLocation *Loc)
186 RECOVERABLE(nullability_return_v1, NonNullReturnData *Data, SourceLocation *Loc)
187
188 struct NonNullArgData {
189 SourceLocation Loc;
190 SourceLocation AttrLoc;
191 int ArgIndex;
192 };
193
194 /// \brief Handle passing null pointer to a function parameter with the nonnull
195 /// attribute, or a _Nonnull type annotation.
196 RECOVERABLE(nonnull_arg, NonNullArgData *Data)
197 RECOVERABLE(nullability_arg, NonNullArgData *Data)
198
199 struct PointerOverflowData {
200 SourceLocation Loc;
201 };
202
203 RECOVERABLE(pointer_overflow, PointerOverflowData *Data, ValueHandle Base,
204 ValueHandle Result)
205
206 /// \brief Known CFI check kinds.
207 /// Keep in sync with the enum of the same name in CodeGenFunction.h
208 enum CFITypeCheckKind : unsigned char {
209 CFITCK_VCall,
210 CFITCK_NVCall,
211 CFITCK_DerivedCast,
212 CFITCK_UnrelatedCast,
213 CFITCK_ICall,
214 CFITCK_NVMFCall,
215 CFITCK_VMFCall,
216 };
217
218 struct CFIBadIcallData {
219 SourceLocation Loc;
220 const TypeDescriptor &Type;
221 };
222
223 struct CFICheckFailData {
224 CFITypeCheckKind CheckKind;
225 SourceLocation Loc;
226 const TypeDescriptor &Type;
227 };
228
229 /// \brief Handle control flow integrity failure for indirect function calls.
230 RECOVERABLE(cfi_bad_icall, CFIBadIcallData *Data, ValueHandle Function)
231
232 /// \brief Handle control flow integrity failures.
233 RECOVERABLE(cfi_check_fail, CFICheckFailData *Data, ValueHandle Function,
234 uptr VtableIsValid)
235
236 struct ReportOptions;
237
238 extern "C" SANITIZER_INTERFACE_ATTRIBUTE void __ubsan_handle_cfi_bad_type(
239 CFICheckFailData *Data, ValueHandle Vtable, bool ValidVtable,
240 ReportOptions Opts);
241
242 }
243
244 #endif // UBSAN_HANDLERS_H