Home | History | Annotate | Download | only in ubsan 
      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
    256