1//===-- ubsan_diag.h --------------------------------------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// Diagnostics emission for Clang's undefined behavior sanitizer.
10//
11//===----------------------------------------------------------------------===//
12#ifndef UBSAN_DIAG_H
13#define UBSAN_DIAG_H
14
15#include "ubsan_value.h"
16#include "sanitizer_common/sanitizer_stacktrace.h"
17#include "sanitizer_common/sanitizer_symbolizer.h"
18
19namespace __ubsan {
20
21SymbolizedStack *getSymbolizedLocation(uptr PC);
22
23inline SymbolizedStack *getCallerLocation(uptr CallerPC) {
24 CHECK(CallerPC);
25 uptr PC = StackTrace::GetPreviousInstructionPc(pc: CallerPC);
26 return getSymbolizedLocation(PC);
27}
28
29/// A location of some data within the program's address space.
30typedef uptr MemoryLocation;
31
32/// \brief Location at which a diagnostic can be emitted. Either a
33/// SourceLocation, a MemoryLocation, or a SymbolizedStack.
34class Location {
35public:
36 enum LocationKind { LK_Null, LK_Source, LK_Memory, LK_Symbolized };
37
38private:
39 LocationKind Kind;
40 // FIXME: In C++11, wrap these in an anonymous union.
41 SourceLocation SourceLoc;
42 MemoryLocation MemoryLoc;
43 const SymbolizedStack *SymbolizedLoc; // Not owned.
44
45public:
46 Location() : Kind(LK_Null) {}
47 Location(SourceLocation Loc) :
48 Kind(LK_Source), SourceLoc(Loc) {}
49 Location(MemoryLocation Loc) :
50 Kind(LK_Memory), MemoryLoc(Loc) {}
51 // SymbolizedStackHolder must outlive Location object.
52 Location(const SymbolizedStackHolder &Stack) :
53 Kind(LK_Symbolized), SymbolizedLoc(Stack.get()) {}
54
55 LocationKind getKind() const { return Kind; }
56
57 bool isSourceLocation() const { return Kind == LK_Source; }
58 bool isMemoryLocation() const { return Kind == LK_Memory; }
59 bool isSymbolizedStack() const { return Kind == LK_Symbolized; }
60
61 SourceLocation getSourceLocation() const {
62 CHECK(isSourceLocation());
63 return SourceLoc;
64 }
65 MemoryLocation getMemoryLocation() const {
66 CHECK(isMemoryLocation());
67 return MemoryLoc;
68 }
69 const SymbolizedStack *getSymbolizedStack() const {
70 CHECK(isSymbolizedStack());
71 return SymbolizedLoc;
72 }
73};
74
75/// A diagnostic severity level.
76enum DiagLevel {
77 DL_Error, ///< An error.
78 DL_Note ///< A note, attached to a prior diagnostic.
79};
80
81/// \brief Annotation for a range of locations in a diagnostic.
82class Range {
83 Location Start, End;
84 const char *Text;
85
86public:
87 Range() : Start(), End(), Text() {}
88 Range(MemoryLocation Start, MemoryLocation End, const char *Text)
89 : Start(Start), End(End), Text(Text) {}
90 Location getStart() const { return Start; }
91 Location getEnd() const { return End; }
92 const char *getText() const { return Text; }
93};
94
95/// \brief A C++ type name. Really just a strong typedef for 'const char*'.
96class TypeName {
97 const char *Name;
98public:
99 TypeName(const char *Name) : Name(Name) {}
100 const char *getName() const { return Name; }
101};
102
103enum class ErrorType {
104#define UBSAN_CHECK(Name, SummaryKind, FSanitizeFlagName) Name,
105#include "ubsan_checks.inc"
106#undef UBSAN_CHECK
107};
108
109/// \brief Representation of an in-flight diagnostic.
110///
111/// Temporary \c Diag instances are created by the handler routines to
112/// accumulate arguments for a diagnostic. The destructor emits the diagnostic
113/// message.
114class Diag {
115 /// The location at which the problem occurred.
116 Location Loc;
117
118 /// The diagnostic level.
119 DiagLevel Level;
120
121 /// The error type.
122 ErrorType ET;
123
124 /// The message which will be emitted, with %0, %1, ... placeholders for
125 /// arguments.
126 const char *Message;
127
128public:
129 /// Kinds of arguments, corresponding to members of \c Arg's union.
130 enum ArgKind {
131 AK_String, ///< A string argument, displayed as-is.
132 AK_TypeName,///< A C++ type name, possibly demangled before display.
133 AK_UInt, ///< An unsigned integer argument.
134 AK_SInt, ///< A signed integer argument.
135 AK_Float, ///< A floating-point argument.
136 AK_Pointer ///< A pointer argument, displayed in hexadecimal.
137 };
138
139 /// An individual diagnostic message argument.
140 struct Arg {
141 Arg() {}
142 Arg(const char *String) : Kind(AK_String), String(String) {}
143 Arg(TypeName TN) : Kind(AK_TypeName), String(TN.getName()) {}
144 Arg(UIntMax UInt) : Kind(AK_UInt), UInt(UInt) {}
145 Arg(SIntMax SInt) : Kind(AK_SInt), SInt(SInt) {}
146 Arg(FloatMax Float) : Kind(AK_Float), Float(Float) {}
147 Arg(const void *Pointer) : Kind(AK_Pointer), Pointer(Pointer) {}
148
149 ArgKind Kind;
150 union {
151 const char *String;
152 UIntMax UInt;
153 SIntMax SInt;
154 FloatMax Float;
155 const void *Pointer;
156 };
157 };
158
159private:
160 static const unsigned MaxArgs = 8;
161 static const unsigned MaxRanges = 1;
162
163 /// The arguments which have been added to this diagnostic so far.
164 Arg Args[MaxArgs];
165 unsigned NumArgs;
166
167 /// The ranges which have been added to this diagnostic so far.
168 Range Ranges[MaxRanges];
169 unsigned NumRanges;
170
171 Diag &AddArg(Arg A) {
172 CHECK(NumArgs != MaxArgs);
173 Args[NumArgs++] = A;
174 return *this;
175 }
176
177 Diag &AddRange(Range A) {
178 CHECK(NumRanges != MaxRanges);
179 Ranges[NumRanges++] = A;
180 return *this;
181 }
182
183 /// \c Diag objects are not copyable.
184 Diag(const Diag &); // NOT IMPLEMENTED
185 Diag &operator=(const Diag &);
186
187public:
188 Diag(Location Loc, DiagLevel Level, ErrorType ET, const char *Message)
189 : Loc(Loc), Level(Level), ET(ET), Message(Message), NumArgs(0),
190 NumRanges(0) {}
191 ~Diag();
192
193 Diag &operator<<(const char *Str) { return AddArg(A: Str); }
194 Diag &operator<<(TypeName TN) { return AddArg(A: TN); }
195 Diag &operator<<(unsigned long long V) { return AddArg(A: UIntMax(V)); }
196 Diag &operator<<(const void *V) { return AddArg(A: V); }
197 Diag &operator<<(const TypeDescriptor &V);
198 Diag &operator<<(const Value &V);
199 Diag &operator<<(const Range &R) { return AddRange(A: R); }
200};
201
202struct ReportOptions {
203 // If FromUnrecoverableHandler is specified, UBSan runtime handler is not
204 // expected to return.
205 bool FromUnrecoverableHandler;
206 /// pc/bp are used to unwind the stack trace.
207 uptr pc;
208 uptr bp;
209};
210
211bool ignoreReport(SourceLocation SLoc, ReportOptions Opts, ErrorType ET);
212
213#define GET_REPORT_OPTIONS(unrecoverable_handler) \
214 GET_CALLER_PC_BP; \
215 ReportOptions Opts = {unrecoverable_handler, pc, bp}
216
217/// \brief Instantiate this class before printing diagnostics in the error
218/// report. This class ensures that reports from different threads and from
219/// different sanitizers won't be mixed.
220class ScopedReport {
221 struct Initializer {
222 Initializer();
223 };
224 Initializer initializer_;
225 ScopedErrorReportLock report_lock_;
226
227 ReportOptions Opts;
228 Location SummaryLoc;
229 ErrorType Type;
230
231public:
232 ScopedReport(ReportOptions Opts, Location SummaryLoc, ErrorType Type);
233 ~ScopedReport();
234
235 static void CheckLocked() { ScopedErrorReportLock::CheckLocked(); }
236};
237
238void InitializeSuppressions();
239bool IsVptrCheckSuppressed(const char *TypeName);
240// Sometimes UBSan runtime can know filename from handlers arguments, even if
241// debug info is missing.
242bool IsPCSuppressed(ErrorType ET, uptr PC, const char *Filename);
243
244} // namespace __ubsan
245
246#endif // UBSAN_DIAG_H
247

source code of compiler-rt/lib/ubsan/ubsan_diag.h