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
18namespace __ubsan {
19
20struct 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.
40RECOVERABLE(type_mismatch, TypeMismatchData *Data, ValueHandle Pointer)
41
42struct OverflowData {
43  SourceLocation Loc;
44  const TypeDescriptor &Type;
45};
46
47/// \brief Handle an integer addition overflow.
48RECOVERABLE(add_overflow, OverflowData *Data, ValueHandle LHS, ValueHandle RHS)
49
50/// \brief Handle an integer subtraction overflow.
51RECOVERABLE(sub_overflow, OverflowData *Data, ValueHandle LHS, ValueHandle RHS)
52
53/// \brief Handle an integer multiplication overflow.
54RECOVERABLE(mul_overflow, OverflowData *Data, ValueHandle LHS, ValueHandle RHS)
55
56/// \brief Handle a signed integer overflow for a unary negate operator.
57RECOVERABLE(negate_overflow, OverflowData *Data, ValueHandle OldVal)
58
59/// \brief Handle an INT_MIN/-1 overflow or division by zero.
60RECOVERABLE(divrem_overflow, OverflowData *Data,
61            ValueHandle LHS, ValueHandle RHS)
62
63struct 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.
71RECOVERABLE(shift_out_of_bounds, ShiftOutOfBoundsData *Data,
72            ValueHandle LHS, ValueHandle RHS)
73
74struct OutOfBoundsData {
75  SourceLocation Loc;
76  const TypeDescriptor &ArrayType;
77  const TypeDescriptor &IndexType;
78};
79
80/// \brief Handle an array index out of bounds error.
81RECOVERABLE(out_of_bounds, OutOfBoundsData *Data, ValueHandle Index)
82
83struct UnreachableData {
84  SourceLocation Loc;
85};
86
87/// \brief Handle a __builtin_unreachable which is reached.
88UNRECOVERABLE(builtin_unreachable, UnreachableData *Data)
89/// \brief Handle reaching the end of a value-returning function.
90UNRECOVERABLE(missing_return, UnreachableData *Data)
91
92struct VLABoundData {
93  SourceLocation Loc;
94  const TypeDescriptor &Type;
95};
96
97/// \brief Handle a VLA with a non-positive bound.
98RECOVERABLE(vla_bound_not_positive, VLABoundData *Data, ValueHandle Bound)
99
100struct 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.
107RECOVERABLE(float_cast_overflow, FloatCastOverflowData *Data, ValueHandle From)
108
109struct InvalidValueData {
110  SourceLocation Loc;
111  const TypeDescriptor &Type;
112};
113
114/// \brief Handle a load of an invalid value for the type.
115RECOVERABLE(load_invalid_value, InvalidValueData *Data, ValueHandle Val)
116
117struct FunctionTypeMismatchData {
118  SourceLocation Loc;
119  const TypeDescriptor &Type;
120};
121
122RECOVERABLE(function_type_mismatch,
123            FunctionTypeMismatchData *Data,
124            ValueHandle Val)
125
126struct NonNullReturnData {
127  SourceLocation Loc;
128  SourceLocation AttrLoc;
129};
130
131/// \brief Handle returning null from function with returns_nonnull attribute.
132RECOVERABLE(nonnull_return, NonNullReturnData *Data)
133
134struct NonNullArgData {
135  SourceLocation Loc;
136  SourceLocation AttrLoc;
137  int ArgIndex;
138};
139
140/// \brief Handle passing null pointer to function with nonnull attribute.
141RECOVERABLE(nonnull_arg, NonNullArgData *Data)
142
143}
144
145#endif // UBSAN_HANDLERS_H
146