1 //===-- ubsan_handlers.h ----------------------------------------*- C++ -*-===// 2 // 3 // This file is distributed under the University of Illinois Open Source 4 // License. See LICENSE.TXT for details. 5 // 6 //===----------------------------------------------------------------------===// 7 // 8 // Entry points to the runtime library for Clang's undefined behavior sanitizer. 9 // 10 //===----------------------------------------------------------------------===// 11 #ifndef UBSAN_HANDLERS_H 12 #define UBSAN_HANDLERS_H 13 14 #include "ubsan_value.h" 15 16 namespace __ubsan { 17 18 struct TypeMismatchData { 19 SourceLocation Loc; 20 const TypeDescriptor &Type; 21 uptr Alignment; 22 unsigned char TypeCheckKind; 23 }; 24 25 #define UNRECOVERABLE(checkname, ...) \ 26 extern "C" SANITIZER_INTERFACE_ATTRIBUTE NORETURN \ 27 void __ubsan_handle_ ## checkname( __VA_ARGS__ ); 28 29 #define RECOVERABLE(checkname, ...) \ 30 extern "C" SANITIZER_INTERFACE_ATTRIBUTE \ 31 void __ubsan_handle_ ## checkname( __VA_ARGS__ ); \ 32 extern "C" SANITIZER_INTERFACE_ATTRIBUTE NORETURN \ 33 void __ubsan_handle_ ## checkname ## _abort( __VA_ARGS__ ); 34 35 /// \brief Handle a runtime type check failure, caused by either a misaligned 36 /// pointer, a null pointer, or a pointer to insufficient storage for the 37 /// type. 38 RECOVERABLE(type_mismatch, TypeMismatchData *Data, ValueHandle Pointer) 39 40 struct OverflowData { 41 SourceLocation Loc; 42 const TypeDescriptor &Type; 43 }; 44 45 /// \brief Handle an integer addition overflow. 46 RECOVERABLE(add_overflow, OverflowData *Data, ValueHandle LHS, ValueHandle RHS) 47 48 /// \brief Handle an integer subtraction overflow. 49 RECOVERABLE(sub_overflow, OverflowData *Data, ValueHandle LHS, ValueHandle RHS) 50 51 /// \brief Handle an integer multiplication overflow. 52 RECOVERABLE(mul_overflow, OverflowData *Data, ValueHandle LHS, ValueHandle RHS) 53 54 /// \brief Handle a signed integer overflow for a unary negate operator. 55 RECOVERABLE(negate_overflow, OverflowData *Data, ValueHandle OldVal) 56 57 /// \brief Handle an INT_MIN/-1 overflow or division by zero. 58 RECOVERABLE(divrem_overflow, OverflowData *Data, 59 ValueHandle LHS, ValueHandle RHS) 60 61 struct ShiftOutOfBoundsData { 62 SourceLocation Loc; 63 const TypeDescriptor &LHSType; 64 const TypeDescriptor &RHSType; 65 }; 66 67 /// \brief Handle a shift where the RHS is out of bounds or a left shift where 68 /// the LHS is negative or overflows. 69 RECOVERABLE(shift_out_of_bounds, ShiftOutOfBoundsData *Data, 70 ValueHandle LHS, ValueHandle RHS) 71 72 struct OutOfBoundsData { 73 SourceLocation Loc; 74 const TypeDescriptor &ArrayType; 75 const TypeDescriptor &IndexType; 76 }; 77 78 /// \brief Handle an array index out of bounds error. 79 RECOVERABLE(out_of_bounds, OutOfBoundsData *Data, ValueHandle Index) 80 81 struct UnreachableData { 82 SourceLocation Loc; 83 }; 84 85 /// \brief Handle a __builtin_unreachable which is reached. 86 UNRECOVERABLE(builtin_unreachable, UnreachableData *Data) 87 /// \brief Handle reaching the end of a value-returning function. 88 UNRECOVERABLE(missing_return, UnreachableData *Data) 89 90 struct VLABoundData { 91 SourceLocation Loc; 92 const TypeDescriptor &Type; 93 }; 94 95 /// \brief Handle a VLA with a non-positive bound. 96 RECOVERABLE(vla_bound_not_positive, VLABoundData *Data, ValueHandle Bound) 97 98 // Keeping this around for binary compatibility with (sanitized) programs 99 // compiled with older compilers. 100 struct FloatCastOverflowData { 101 const TypeDescriptor &FromType; 102 const TypeDescriptor &ToType; 103 }; 104 105 struct FloatCastOverflowDataV2 { 106 SourceLocation Loc; 107 const TypeDescriptor &FromType; 108 const TypeDescriptor &ToType; 109 }; 110 111 /// Handle overflow in a conversion to or from a floating-point type. 112 /// void *Data is one of FloatCastOverflowData* or FloatCastOverflowDataV2* 113 RECOVERABLE(float_cast_overflow, void *Data, ValueHandle From) 114 115 struct InvalidValueData { 116 SourceLocation Loc; 117 const TypeDescriptor &Type; 118 }; 119 120 /// \brief Handle a load of an invalid value for the type. 121 RECOVERABLE(load_invalid_value, InvalidValueData *Data, ValueHandle Val) 122 123 struct FunctionTypeMismatchData { 124 SourceLocation Loc; 125 const TypeDescriptor &Type; 126 }; 127 128 RECOVERABLE(function_type_mismatch, 129 FunctionTypeMismatchData *Data, 130 ValueHandle Val) 131 132 struct NonNullReturnData { 133 SourceLocation Loc; 134 SourceLocation AttrLoc; 135 }; 136 137 /// \brief Handle returning null from function with returns_nonnull attribute. 138 RECOVERABLE(nonnull_return, NonNullReturnData *Data) 139 140 struct NonNullArgData { 141 SourceLocation Loc; 142 SourceLocation AttrLoc; 143 int ArgIndex; 144 }; 145 146 /// \brief Handle passing null pointer to function with nonnull attribute. 147 RECOVERABLE(nonnull_arg, NonNullArgData *Data) 148 149 struct CFIBadIcallData { 150 SourceLocation Loc; 151 const TypeDescriptor &Type; 152 }; 153 154 /// \brief Handle control flow integrity failure for indirect function calls. 155 RECOVERABLE(cfi_bad_icall, CFIBadIcallData *Data, ValueHandle Function) 156 157 } 158 159 #endif // UBSAN_HANDLERS_H 160