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   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 PointerOverflowData {
 150   SourceLocation Loc;
 151 };
 152
 153 RECOVERABLE(pointer_overflow, PointerOverflowData *Data, ValueHandle Base,
 154             ValueHandle Result)
 155
 156 /// \brief Known CFI check kinds.
 157 /// Keep in sync with the enum of the same name in CodeGenFunction.h
 158 enum CFITypeCheckKind : unsigned char {
 159   CFITCK_VCall,
 160   CFITCK_NVCall,
 161   CFITCK_DerivedCast,
 162   CFITCK_UnrelatedCast,
 163   CFITCK_ICall,
 164 };
 165
 166 struct CFIBadIcallData {
 167   SourceLocation Loc;
 168   const TypeDescriptor &Type;
 169 };
 170
 171 struct CFICheckFailData {
 172   CFITypeCheckKind CheckKind;
 173   SourceLocation Loc;
 174   const TypeDescriptor &Type;
 175 };
 176
 177 /// \brief Handle control flow integrity failure for indirect function calls.
 178 RECOVERABLE(cfi_bad_icall, CFIBadIcallData *Data, ValueHandle Function)
 179
 180 /// \brief Handle control flow integrity failures.
 181 RECOVERABLE(cfi_check_fail, CFICheckFailData *Data, ValueHandle Function,
 182             uptr VtableIsValid)
 183 }
 184
 185 #endif // UBSAN_HANDLERS_H