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 18namespace __ubsan { 19 20struct 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. 40RECOVERABLE(type_mismatch, TypeMismatchData *Data, ValueHandle Pointer) 41 42struct OverflowData { 43 SourceLocation Loc; 44 const TypeDescriptor &Type; 45}; 46 47/// \brief Handle an integer addition overflow. 48RECOVERABLE(add_overflow, OverflowData *Data, ValueHandle LHS, ValueHandle RHS) 49 50/// \brief Handle an integer subtraction overflow. 51RECOVERABLE(sub_overflow, OverflowData *Data, ValueHandle LHS, ValueHandle RHS) 52 53/// \brief Handle an integer multiplication overflow. 54RECOVERABLE(mul_overflow, OverflowData *Data, ValueHandle LHS, ValueHandle RHS) 55 56/// \brief Handle a signed integer overflow for a unary negate operator. 57RECOVERABLE(negate_overflow, OverflowData *Data, ValueHandle OldVal) 58 59/// \brief Handle an INT_MIN/-1 overflow or division by zero. 60RECOVERABLE(divrem_overflow, OverflowData *Data, 61 ValueHandle LHS, ValueHandle RHS) 62 63struct 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. 71RECOVERABLE(shift_out_of_bounds, ShiftOutOfBoundsData *Data, 72 ValueHandle LHS, ValueHandle RHS) 73 74struct OutOfBoundsData { 75 SourceLocation Loc; 76 const TypeDescriptor &ArrayType; 77 const TypeDescriptor &IndexType; 78}; 79 80/// \brief Handle an array index out of bounds error. 81RECOVERABLE(out_of_bounds, OutOfBoundsData *Data, ValueHandle Index) 82 83struct UnreachableData { 84 SourceLocation Loc; 85}; 86 87/// \brief Handle a __builtin_unreachable which is reached. 88UNRECOVERABLE(builtin_unreachable, UnreachableData *Data) 89/// \brief Handle reaching the end of a value-returning function. 90UNRECOVERABLE(missing_return, UnreachableData *Data) 91 92struct VLABoundData { 93 SourceLocation Loc; 94 const TypeDescriptor &Type; 95}; 96 97/// \brief Handle a VLA with a non-positive bound. 98RECOVERABLE(vla_bound_not_positive, VLABoundData *Data, ValueHandle Bound) 99 100// Keeping this around for binary compatibility with (sanitized) programs 101// compiled with older compilers. 102struct FloatCastOverflowData { 103 const TypeDescriptor &FromType; 104 const TypeDescriptor &ToType; 105}; 106 107struct 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* 115RECOVERABLE(float_cast_overflow, void *Data, ValueHandle From) 116 117struct InvalidValueData { 118 SourceLocation Loc; 119 const TypeDescriptor &Type; 120}; 121 122/// \brief Handle a load of an invalid value for the type. 123RECOVERABLE(load_invalid_value, InvalidValueData *Data, ValueHandle Val) 124 125struct FunctionTypeMismatchData { 126 SourceLocation Loc; 127 const TypeDescriptor &Type; 128}; 129 130RECOVERABLE(function_type_mismatch, 131 FunctionTypeMismatchData *Data, 132 ValueHandle Val) 133 134struct NonNullReturnData { 135 SourceLocation Loc; 136 SourceLocation AttrLoc; 137}; 138 139/// \brief Handle returning null from function with returns_nonnull attribute. 140RECOVERABLE(nonnull_return, NonNullReturnData *Data) 141 142struct NonNullArgData { 143 SourceLocation Loc; 144 SourceLocation AttrLoc; 145 int ArgIndex; 146}; 147 148/// \brief Handle passing null pointer to function with nonnull attribute. 149RECOVERABLE(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 153enum CFITypeCheckKind : unsigned char { 154 CFITCK_VCall, 155 CFITCK_NVCall, 156 CFITCK_DerivedCast, 157 CFITCK_UnrelatedCast, 158 CFITCK_ICall, 159}; 160 161struct CFICheckFailData { 162 CFITypeCheckKind CheckKind; 163 SourceLocation Loc; 164 const TypeDescriptor &Type; 165}; 166 167/// \brief Handle control flow integrity failures. 168RECOVERABLE(cfi_check_fail, CFICheckFailData *Data, ValueHandle Function, 169 uptr VtableIsValid) 170} 171 172#endif // UBSAN_HANDLERS_H 173