contrib/compiler-rt/lib/ubsan/ubsan_diag.h

   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
  20 namespace __ubsan {
  21
  22 class SymbolizedStackHolder {
  23   SymbolizedStack *Stack;
  24
  25   void clear() {
  26     if (Stack)
  27       Stack->ClearAll();
  28   }
  29
  30 public:
  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
  42 SymbolizedStack *getSymbolizedLocation(uptr PC);
  43
  44 inline 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.
  51 typedef uptr MemoryLocation;
  52
  53 /// \brief Location at which a diagnostic can be emitted. Either a
  54 /// SourceLocation, a MemoryLocation, or a SymbolizedStack.
  55 class Location {
  56 public:
  57   enum LocationKind { LK_Null, LK_Source, LK_Memory, LK_Symbolized };
  58
  59 private:
  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
  66 public:
  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.
  97 enum 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.
 103 class Range {
 104   Location Start, End;
 105   const char *Text;
 106
 107 public:
 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*'.
 117 class TypeName {
 118   const char *Name;
 119 public:
 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.
 129 class 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
 140 public:
 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
 171 private:
 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
 199 public:
 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
 213 struct 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
 222 enum class ErrorType {
 223 #define UBSAN_CHECK(Name, SummaryKind, FSanitizeFlagName) Name,
 224 #include "ubsan_checks.inc"
 225 #undef UBSAN_CHECK
 226 };
 227
 228 bool 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.
 237 class ScopedReport {
 238   ReportOptions Opts;
 239   Location SummaryLoc;
 240   ErrorType Type;
 241
 242 public:
 243   ScopedReport(ReportOptions Opts, Location SummaryLoc, ErrorType Type);
 244   ~ScopedReport();
 245 };
 246
 247 void InitializeSuppressions();
 248 bool IsVptrCheckSuppressed(const char *TypeName);
 249 // Sometimes UBSan runtime can know filename from handlers arguments, even if
 250 // debug info is missing.
 251 bool IsPCSuppressed(ErrorType ET, uptr PC, const char *Filename);
 252
 253 } // namespace __ubsan
 254
 255 #endif // UBSAN_DIAG_H