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 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