contrib/compiler-rt/lib/ubsan/ubsan_handlers.h

   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
  18 namespace __ubsan {
  19
  20 struct TypeMismatchData {
  21   SourceLocation Loc;
  22   const TypeDescriptor &Type;
  23   unsigned char LogAlignment;
  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.
  40 RECOVERABLE(type_mismatch_v1, TypeMismatchData *Data, ValueHandle Pointer)
  41
  42 struct OverflowData {
  43   SourceLocation Loc;
  44   const TypeDescriptor &Type;
  45 };
  46
  47 /// \brief Handle an integer addition overflow.
  48 RECOVERABLE(add_overflow, OverflowData *Data, ValueHandle LHS, ValueHandle RHS)
  49
  50 /// \brief Handle an integer subtraction overflow.
  51 RECOVERABLE(sub_overflow, OverflowData *Data, ValueHandle LHS, ValueHandle RHS)
  52
  53 /// \brief Handle an integer multiplication overflow.
  54 RECOVERABLE(mul_overflow, OverflowData *Data, ValueHandle LHS, ValueHandle RHS)
  55
  56 /// \brief Handle a signed integer overflow for a unary negate operator.
  57 RECOVERABLE(negate_overflow, OverflowData *Data, ValueHandle OldVal)
  58
  59 /// \brief Handle an INT_MIN/-1 overflow or division by zero.
  60 RECOVERABLE(divrem_overflow, OverflowData *Data,
  61             ValueHandle LHS, ValueHandle RHS)
  62
  63 struct 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.
  71 RECOVERABLE(shift_out_of_bounds, ShiftOutOfBoundsData *Data,
  72             ValueHandle LHS, ValueHandle RHS)
  73
  74 struct OutOfBoundsData {
  75   SourceLocation Loc;
  76   const TypeDescriptor &ArrayType;
  77   const TypeDescriptor &IndexType;
  78 };
  79
  80 /// \brief Handle an array index out of bounds error.
  81 RECOVERABLE(out_of_bounds, OutOfBoundsData *Data, ValueHandle Index)
  82
  83 struct UnreachableData {
  84   SourceLocation Loc;
  85 };
  86
  87 /// \brief Handle a __builtin_unreachable which is reached.
  88 UNRECOVERABLE(builtin_unreachable, UnreachableData *Data)
  89 /// \brief Handle reaching the end of a value-returning function.
  90 UNRECOVERABLE(missing_return, UnreachableData *Data)
  91
  92 struct VLABoundData {
  93   SourceLocation Loc;
  94   const TypeDescriptor &Type;
  95 };
  96
  97 /// \brief Handle a VLA with a non-positive bound.
  98 RECOVERABLE(vla_bound_not_positive, VLABoundData *Data, ValueHandle Bound)
  99
 100 // Keeping this around for binary compatibility with (sanitized) programs
 101 // compiled with older compilers.
 102 struct FloatCastOverflowData {
 103   const TypeDescriptor &FromType;
 104   const TypeDescriptor &ToType;
 105 };
 106
 107 struct 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*
 115 RECOVERABLE(float_cast_overflow, void *Data, ValueHandle From)
 116
 117 struct InvalidValueData {
 118   SourceLocation Loc;
 119   const TypeDescriptor &Type;
 120 };
 121
 122 /// \brief Handle a load of an invalid value for the type.
 123 RECOVERABLE(load_invalid_value, InvalidValueData *Data, ValueHandle Val)
 124
 125 /// Known implicit conversion check kinds.
 126 /// Keep in sync with the enum of the same name in CGExprScalar.cpp
 127 enum ImplicitConversionCheckKind : unsigned char {
 128   ICCK_IntegerTruncation = 0,
 129 };
 130
 131 struct ImplicitConversionData {
 132   SourceLocation Loc;
 133   const TypeDescriptor &FromType;
 134   const TypeDescriptor &ToType;
 135   /* ImplicitConversionCheckKind */ unsigned char Kind;
 136 };
 137
 138 /// \brief Implict conversion that changed the value.
 139 RECOVERABLE(implicit_conversion, ImplicitConversionData *Data, ValueHandle Src,
 140             ValueHandle Dst)
 141
 142 /// Known builtin check kinds.
 143 /// Keep in sync with the enum of the same name in CodeGenFunction.h
 144 enum BuiltinCheckKind : unsigned char {
 145   BCK_CTZPassedZero,
 146   BCK_CLZPassedZero,
 147 };
 148
 149 struct InvalidBuiltinData {
 150   SourceLocation Loc;
 151   unsigned char Kind;
 152 };
 153
 154 /// Handle a builtin called in an invalid way.
 155 RECOVERABLE(invalid_builtin, InvalidBuiltinData *Data)
 156
 157 struct FunctionTypeMismatchData {
 158   SourceLocation Loc;
 159   const TypeDescriptor &Type;
 160 };
 161
 162 RECOVERABLE(function_type_mismatch,
 163             FunctionTypeMismatchData *Data,
 164             ValueHandle Val)
 165
 166 struct NonNullReturnData {
 167   SourceLocation AttrLoc;
 168 };
 169
 170 /// \brief Handle returning null from function with the returns_nonnull
 171 /// attribute, or a return type annotated with _Nonnull.
 172 RECOVERABLE(nonnull_return_v1, NonNullReturnData *Data, SourceLocation *Loc)
 173 RECOVERABLE(nullability_return_v1, NonNullReturnData *Data, SourceLocation *Loc)
 174
 175 struct NonNullArgData {
 176   SourceLocation Loc;
 177   SourceLocation AttrLoc;
 178   int ArgIndex;
 179 };
 180
 181 /// \brief Handle passing null pointer to a function parameter with the nonnull
 182 /// attribute, or a _Nonnull type annotation.
 183 RECOVERABLE(nonnull_arg, NonNullArgData *Data)
 184 RECOVERABLE(nullability_arg, NonNullArgData *Data)
 185
 186 struct PointerOverflowData {
 187   SourceLocation Loc;
 188 };
 189
 190 RECOVERABLE(pointer_overflow, PointerOverflowData *Data, ValueHandle Base,
 191             ValueHandle Result)
 192
 193 /// \brief Known CFI check kinds.
 194 /// Keep in sync with the enum of the same name in CodeGenFunction.h
 195 enum CFITypeCheckKind : unsigned char {
 196   CFITCK_VCall,
 197   CFITCK_NVCall,
 198   CFITCK_DerivedCast,
 199   CFITCK_UnrelatedCast,
 200   CFITCK_ICall,
 201   CFITCK_NVMFCall,
 202   CFITCK_VMFCall,
 203 };
 204
 205 struct CFICheckFailData {
 206   CFITypeCheckKind CheckKind;
 207   SourceLocation Loc;
 208   const TypeDescriptor &Type;
 209 };
 210
 211 /// \brief Handle control flow integrity failures.
 212 RECOVERABLE(cfi_check_fail, CFICheckFailData *Data, ValueHandle Function,
 213             uptr VtableIsValid)
 214
 215 struct ReportOptions;
 216
 217 extern "C" SANITIZER_INTERFACE_ATTRIBUTE void __ubsan_handle_cfi_bad_type(
 218     CFICheckFailData *Data, ValueHandle Vtable, bool ValidVtable,
 219     ReportOptions Opts);
 220
 221 }
 222
 223 #endif // UBSAN_HANDLERS_H