Home | History | Annotate | Line # | Download | only in ubsan
ubsan_handlers.h revision 1.1.1.1 
      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 struct FloatCastOverflowData {
     99   // FIXME: SourceLocation Loc;
    100   const TypeDescriptor &FromType;
    101   const TypeDescriptor &ToType;
    102 };
    103 
    104 /// \brief Handle overflow in a conversion to or from a floating-point type.
    105 RECOVERABLE(float_cast_overflow, FloatCastOverflowData *Data, ValueHandle From)
    106 
    107 struct InvalidValueData {
    108   SourceLocation Loc;
    109   const TypeDescriptor &Type;
    110 };
    111 
    112 /// \brief Handle a load of an invalid value for the type.
    113 RECOVERABLE(load_invalid_value, InvalidValueData *Data, ValueHandle Val)
    114 
    115 struct FunctionTypeMismatchData {
    116   SourceLocation Loc;
    117   const TypeDescriptor &Type;
    118 };
    119 
    120 RECOVERABLE(function_type_mismatch,
    121             FunctionTypeMismatchData *Data,
    122             ValueHandle Val)
    123 
    124 struct NonNullReturnData {
    125   SourceLocation Loc;
    126   SourceLocation AttrLoc;
    127 };
    128 
    129 /// \brief Handle returning null from function with returns_nonnull attribute.
    130 RECOVERABLE(nonnull_return, NonNullReturnData *Data)
    131 
    132 struct NonNullArgData {
    133   SourceLocation Loc;
    134   SourceLocation AttrLoc;
    135   int ArgIndex;
    136 };
    137 
    138 /// \brief Handle passing null pointer to function with nonnull attribute.
    139 RECOVERABLE(nonnull_arg, NonNullArgData *Data)
    140 
    141 }
    142 
    143 #endif // UBSAN_HANDLERS_H
    144