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