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
100// Keeping this around for binary compatibility with (sanitized) programs
101// compiled with older compilers.
102struct FloatCastOverflowData {
103  const TypeDescriptor &FromType;
104  const TypeDescriptor &ToType;
105};
106
107struct 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*
115RECOVERABLE(float_cast_overflow, void *Data, ValueHandle From)
116
117struct InvalidValueData {
118  SourceLocation Loc;
119  const TypeDescriptor &Type;
120};
121
122/// \brief Handle a load of an invalid value for the type.
123RECOVERABLE(load_invalid_value, InvalidValueData *Data, ValueHandle Val)
124
125struct FunctionTypeMismatchData {
126  SourceLocation Loc;
127  const TypeDescriptor &Type;
128};
129
130RECOVERABLE(function_type_mismatch,
131            FunctionTypeMismatchData *Data,
132            ValueHandle Val)
133
134struct NonNullReturnData {
135  SourceLocation Loc;
136  SourceLocation AttrLoc;
137};
138
139/// \brief Handle returning null from function with returns_nonnull attribute.
140RECOVERABLE(nonnull_return, NonNullReturnData *Data)
141
142struct NonNullArgData {
143  SourceLocation Loc;
144  SourceLocation AttrLoc;
145  int ArgIndex;
146};
147
148/// \brief Handle passing null pointer to function with nonnull attribute.
149RECOVERABLE(nonnull_arg, NonNullArgData *Data)
150
151/// \brief Known CFI check kinds.
152/// Keep in sync with the enum of the same name in CodeGenFunction.h
153enum CFITypeCheckKind : unsigned char {
154  CFITCK_VCall,
155  CFITCK_NVCall,
156  CFITCK_DerivedCast,
157  CFITCK_UnrelatedCast,
158  CFITCK_ICall,
159};
160
161struct CFICheckFailData {
162  CFITypeCheckKind CheckKind;
163  SourceLocation Loc;
164  const TypeDescriptor &Type;
165};
166
167/// \brief Handle control flow integrity failures.
168RECOVERABLE(cfi_check_fail, CFICheckFailData *Data, ValueHandle Function,
169            uptr VtableIsValid)
170}
171
172#endif // UBSAN_HANDLERS_H
173