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