247 lines · c
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-exception6//7//===----------------------------------------------------------------------===//8//9// Diagnostics emission for Clang's undefined behavior sanitizer.10//11//===----------------------------------------------------------------------===//12#ifndef UBSAN_DIAG_H13#define UBSAN_DIAG_H14 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(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 a33/// 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_CHECK107};108 109/// \brief Representation of an in-flight diagnostic.110///111/// Temporary \c Diag instances are created by the handler routines to112/// accumulate arguments for a diagnostic. The destructor emits the diagnostic113/// 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 for125 /// 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 IMPLEMENTED185 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(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 202struct ReportOptions {203 // If FromUnrecoverableHandler is specified, UBSan runtime handler is not204 // 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 error218/// report. This class ensures that reports from different threads and from219/// 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 if241// debug info is missing.242bool IsPCSuppressed(ErrorType ET, uptr PC, const char *Filename);243 244} // namespace __ubsan245 246#endif // UBSAN_DIAG_H247