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 uptr Alignment; 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, 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 struct FunctionTypeMismatchData { 126 SourceLocation Loc; 127 const TypeDescriptor &Type; 128 }; 129 130 RECOVERABLE(function_type_mismatch, 131 FunctionTypeMismatchData *Data, 132 ValueHandle Val) 133 134 struct NonNullReturnData { 135 SourceLocation Loc; 136 SourceLocation AttrLoc; 137 }; 138 139 /// \brief Handle returning null from function with returns_nonnull attribute. 140 RECOVERABLE(nonnull_return, NonNullReturnData *Data) 141 142 struct NonNullArgData { 143 SourceLocation Loc; 144 SourceLocation AttrLoc; 145 int ArgIndex; 146 }; 147 148 /// \brief Handle passing null pointer to function with nonnull attribute. 149 RECOVERABLE(nonnull_arg, NonNullArgData *Data) 150 151 /// \brief Known CFI check kinds. 152 /// Keep in sync with the enum of the same name in CodeGenFunction.h 153 enum CFITypeCheckKind : unsigned char { 154 CFITCK_VCall, 155 CFITCK_NVCall, 156 CFITCK_DerivedCast, 157 CFITCK_UnrelatedCast, 158 CFITCK_ICall, 159 }; 160 161 struct CFICheckFailData { 162 CFITypeCheckKind CheckKind; 163 SourceLocation Loc; 164 const TypeDescriptor &Type; 165 }; 166 167 /// \brief Handle control flow integrity failures. 168 RECOVERABLE(cfi_check_fail, CFICheckFailData *Data, ValueHandle Function, 169 uptr VtableIsValid) 170 } 171 172 #endif // UBSAN_HANDLERS_H 173