libsanitizer/ubsan/ubsan_handlers.h

   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   unsigned char LogAlignment;
  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_v1, 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 /// Known builtin check kinds.
 124 /// Keep in sync with the enum of the same name in CodeGenFunction.h
 125 enum BuiltinCheckKind : unsigned char {
 126   BCK_CTZPassedZero,
 127   BCK_CLZPassedZero,
 128 };
 129
 130 struct InvalidBuiltinData {
 131   SourceLocation Loc;
 132   unsigned char Kind;
 133 };
 134
 135 /// Handle a builtin called in an invalid way.
 136 RECOVERABLE(invalid_builtin, InvalidBuiltinData *Data)
 137
 138 struct FunctionTypeMismatchData {
 139   SourceLocation Loc;
 140   const TypeDescriptor &Type;
 141 };
 142
 143 RECOVERABLE(function_type_mismatch,
 144             FunctionTypeMismatchData *Data,
 145             ValueHandle Val)
 146
 147 struct NonNullReturnData {
 148   SourceLocation AttrLoc;
 149 };
 150
 151 /// \brief Handle returning null from function with the returns_nonnull
 152 /// attribute, or a return type annotated with _Nonnull.
 153 RECOVERABLE(nonnull_return_v1, NonNullReturnData *Data, SourceLocation *Loc)
 154 RECOVERABLE(nullability_return_v1, NonNullReturnData *Data, SourceLocation *Loc)
 155
 156 struct NonNullArgData {
 157   SourceLocation Loc;
 158   SourceLocation AttrLoc;
 159   int ArgIndex;
 160 };
 161
 162 /// \brief Handle passing null pointer to a function parameter with the nonnull
 163 /// attribute, or a _Nonnull type annotation.
 164 RECOVERABLE(nonnull_arg, NonNullArgData *Data)
 165 RECOVERABLE(nullability_arg, NonNullArgData *Data)
 166
 167 struct PointerOverflowData {
 168   SourceLocation Loc;
 169 };
 170
 171 RECOVERABLE(pointer_overflow, PointerOverflowData *Data, ValueHandle Base,
 172             ValueHandle Result)
 173
 174 /// \brief Known CFI check kinds.
 175 /// Keep in sync with the enum of the same name in CodeGenFunction.h
 176 enum CFITypeCheckKind : unsigned char {
 177   CFITCK_VCall,
 178   CFITCK_NVCall,
 179   CFITCK_DerivedCast,
 180   CFITCK_UnrelatedCast,
 181   CFITCK_ICall,
 182 };
 183
 184 struct CFICheckFailData {
 185   CFITypeCheckKind CheckKind;
 186   SourceLocation Loc;
 187   const TypeDescriptor &Type;
 188 };
 189
 190 /// \brief Handle control flow integrity failures.
 191 RECOVERABLE(cfi_check_fail, CFICheckFailData *Data, ValueHandle Function,
 192             uptr VtableIsValid)
 193
 194 struct ReportOptions;
 195
 196 extern "C" SANITIZER_INTERFACE_ATTRIBUTE void __ubsan_handle_cfi_bad_type(
 197     CFICheckFailData *Data, ValueHandle Vtable, bool ValidVtable,
 198     ReportOptions Opts);
 199
 200 }
 201
 202 #endif // UBSAN_HANDLERS_H