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 19 namespace __ubsan { 20 21 SymbolizedStack *getSymbolizedLocation(uptr PC); 22 23 inline SymbolizedStack *getCallerLocation(uptr CallerPC) { 24 CHECK(CallerPC); 25 uptr PC = StackTrace::GetPreviousInstructionPc(CallerPC); 26 return getSymbolizedLocation(PC); 27 } 28 29 /// A location of some data within the program's address space. 30 typedef uptr MemoryLocation; 31 32 /// \brief Location at which a diagnostic can be emitted. Either a 33 /// SourceLocation, a MemoryLocation, or a SymbolizedStack. 34 class Location { 35 public: 36 enum LocationKind { LK_Null, LK_Source, LK_Memory, LK_Symbolized }; 37 38 private: 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 45 public: 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. 76 enum 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. 82 class Range { 83 Location Start, End; 84 const char *Text; 85 86 public: 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*'. 96 class TypeName { 97 const char *Name; 98 public: 99 TypeName(const char *Name) : Name(Name) {} 100 const char *getName() const { return Name; } 101 }; 102 103 enum 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. 114 class 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 128 public: 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 159 private: 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 187 public: 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(Str); } 194 Diag &operator<<(TypeName TN) { return AddArg(TN); } 195 Diag &operator<<(unsigned long long V) { return AddArg(UIntMax(V)); } 196 Diag &operator<<(const void *V) { return AddArg(V); } 197 Diag &operator<<(const TypeDescriptor &V); 198 Diag &operator<<(const Value &V); 199 Diag &operator<<(const Range &R) { return AddRange(R); } 200 }; 201 202 struct 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 211 bool 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. 220 class 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 231 public: 232 ScopedReport(ReportOptions Opts, Location SummaryLoc, ErrorType Type); 233 ~ScopedReport(); 234 235 static void CheckLocked() { ScopedErrorReportLock::CheckLocked(); } 236 }; 237 238 void InitializeSuppressions(); 239 bool IsVptrCheckSuppressed(const char *TypeName); 240 // Sometimes UBSan runtime can know filename from handlers arguments, even if 241 // debug info is missing. 242 bool IsPCSuppressed(ErrorType ET, uptr PC, const char *Filename); 243 244 } // namespace __ubsan 245 246 #endif // UBSAN_DIAG_H 247