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