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

   1 //===-- ubsan_diag.cc -----------------------------------------------------===//
   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 // Diagnostic reporting for the UBSan runtime.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "ubsan_platform.h"
  15 #if CAN_SANITIZE_UB
  16 #include "ubsan_diag.h"
  17 #include "ubsan_init.h"
  18 #include "ubsan_flags.h"
  19 #include "sanitizer_common/sanitizer_placement_new.h"
  20 #include "sanitizer_common/sanitizer_report_decorator.h"
  21 #include "sanitizer_common/sanitizer_stacktrace.h"
  22 #include "sanitizer_common/sanitizer_stacktrace_printer.h"
  23 #include "sanitizer_common/sanitizer_suppressions.h"
  24 #include "sanitizer_common/sanitizer_symbolizer.h"
  25 #include <stdio.h>
  26
  27 using namespace __ubsan;
  28
  29 static void MaybePrintStackTrace(uptr pc, uptr bp) {
  30   // We assume that flags are already parsed, as UBSan runtime
  31   // will definitely be called when we print the first diagnostics message.
  32   if (!flags()->print_stacktrace)
  33     return;
  34   // We can only use slow unwind, as we don't have any information about stack
  35   // top/bottom.
  36   // FIXME: It's better to respect "fast_unwind_on_fatal" runtime flag and
  37   // fetch stack top/bottom information if we have it (e.g. if we're running
  38   // under ASan).
  39   if (StackTrace::WillUseFastUnwind(false))
  40     return;
  41   BufferedStackTrace stack;
  42   stack.Unwind(kStackTraceMax, pc, bp, 0, 0, 0, false);
  43   stack.Print();
  44 }
  45
  46 static const char *ConvertTypeToString(ErrorType Type) {
  47   switch (Type) {
  48 #define UBSAN_CHECK(Name, SummaryKind, FSanitizeFlagName)                      \
  49   case ErrorType::Name:                                                        \
  50     return SummaryKind;
  51 #include "ubsan_checks.inc"
  52 #undef UBSAN_CHECK
  53   }
  54   UNREACHABLE("unknown ErrorType!");
  55 }
  56
  57 static const char *ConvertTypeToFlagName(ErrorType Type) {
  58   switch (Type) {
  59 #define UBSAN_CHECK(Name, SummaryKind, FSanitizeFlagName)                      \
  60   case ErrorType::Name:                                                        \
  61     return FSanitizeFlagName;
  62 #include "ubsan_checks.inc"
  63 #undef UBSAN_CHECK
  64   }
  65   UNREACHABLE("unknown ErrorType!");
  66 }
  67
  68 static void MaybeReportErrorSummary(Location Loc, ErrorType Type) {
  69   if (!common_flags()->print_summary)
  70     return;
  71   if (!flags()->report_error_type)
  72     Type = ErrorType::GenericUB;
  73   const char *ErrorKind = ConvertTypeToString(Type);
  74   if (Loc.isSourceLocation()) {
  75     SourceLocation SLoc = Loc.getSourceLocation();
  76     if (!SLoc.isInvalid()) {
  77       AddressInfo AI;
  78       AI.file = internal_strdup(SLoc.getFilename());
  79       AI.line = SLoc.getLine();
  80       AI.column = SLoc.getColumn();
  81       AI.function = internal_strdup("");  // Avoid printing ?? as function name.
  82       ReportErrorSummary(ErrorKind, AI);
  83       AI.Clear();
  84       return;
  85     }
  86   } else if (Loc.isSymbolizedStack()) {
  87     const AddressInfo &AI = Loc.getSymbolizedStack()->info;
  88     ReportErrorSummary(ErrorKind, AI);
  89     return;
  90   }
  91   ReportErrorSummary(ErrorKind);
  92 }
  93
  94 namespace {
  95 class Decorator : public SanitizerCommonDecorator {
  96  public:
  97   Decorator() : SanitizerCommonDecorator() {}
  98   const char *Highlight() const { return Green(); }
  99   const char *EndHighlight() const { return Default(); }
 100   const char *Note() const { return Black(); }
 101   const char *EndNote() const { return Default(); }
 102 };
 103 }
 104
 105 SymbolizedStack *__ubsan::getSymbolizedLocation(uptr PC) {
 106   InitAsStandaloneIfNecessary();
 107   return Symbolizer::GetOrInit()->SymbolizePC(PC);
 108 }
 109
 110 Diag &Diag::operator<<(const TypeDescriptor &V) {
 111   return AddArg(V.getTypeName());
 112 }
 113
 114 Diag &Diag::operator<<(const Value &V) {
 115   if (V.getType().isSignedIntegerTy())
 116     AddArg(V.getSIntValue());
 117   else if (V.getType().isUnsignedIntegerTy())
 118     AddArg(V.getUIntValue());
 119   else if (V.getType().isFloatTy())
 120     AddArg(V.getFloatValue());
 121   else
 122     AddArg("<unknown>");
 123   return *this;
 124 }
 125
 126 /// Hexadecimal printing for numbers too large for Printf to handle directly.
 127 static void PrintHex(UIntMax Val) {
 128 #if HAVE_INT128_T
 129   Printf("0x%08x%08x%08x%08x",
 130           (unsigned int)(Val >> 96),
 131           (unsigned int)(Val >> 64),
 132           (unsigned int)(Val >> 32),
 133           (unsigned int)(Val));
 134 #else
 135   UNREACHABLE("long long smaller than 64 bits?");
 136 #endif
 137 }
 138
 139 static void renderLocation(Location Loc) {
 140   InternalScopedString LocBuffer(1024);
 141   switch (Loc.getKind()) {
 142   case Location::LK_Source: {
 143     SourceLocation SLoc = Loc.getSourceLocation();
 144     if (SLoc.isInvalid())
 145       LocBuffer.append("<unknown>");
 146     else
 147       RenderSourceLocation(&LocBuffer, SLoc.getFilename(), SLoc.getLine(),
 148                            SLoc.getColumn(), common_flags()->symbolize_vs_style,
 149                            common_flags()->strip_path_prefix);
 150     break;
 151   }
 152   case Location::LK_Memory:
 153     LocBuffer.append("%p", Loc.getMemoryLocation());
 154     break;
 155   case Location::LK_Symbolized: {
 156     const AddressInfo &Info = Loc.getSymbolizedStack()->info;
 157     if (Info.file) {
 158       RenderSourceLocation(&LocBuffer, Info.file, Info.line, Info.column,
 159                            common_flags()->symbolize_vs_style,
 160                            common_flags()->strip_path_prefix);
 161     } else if (Info.module) {
 162       RenderModuleLocation(&LocBuffer, Info.module, Info.module_offset,
 163                            common_flags()->strip_path_prefix);
 164     } else {
 165       LocBuffer.append("%p", Info.address);
 166     }
 167     break;
 168   }
 169   case Location::LK_Null:
 170     LocBuffer.append("<unknown>");
 171     break;
 172   }
 173   Printf("%s:", LocBuffer.data());
 174 }
 175
 176 static void renderText(const char *Message, const Diag::Arg *Args) {
 177   for (const char *Msg = Message; *Msg; ++Msg) {
 178     if (*Msg != '%') {
 179       char Buffer[64];
 180       unsigned I;
 181       for (I = 0; Msg[I] && Msg[I] != '%' && I != 63; ++I)
 182         Buffer[I] = Msg[I];
 183       Buffer[I] = '\0';
 184       Printf(Buffer);
 185       Msg += I - 1;
 186     } else {
 187       const Diag::Arg &A = Args[*++Msg - '0'];
 188       switch (A.Kind) {
 189       case Diag::AK_String:
 190         Printf("%s", A.String);
 191         break;
 192       case Diag::AK_TypeName: {
 193         if (SANITIZER_WINDOWS)
 194           // The Windows implementation demangles names early.
 195           Printf("'%s'", A.String);
 196         else
 197           Printf("'%s'", Symbolizer::GetOrInit()->Demangle(A.String));
 198         break;
 199       }
 200       case Diag::AK_SInt:
 201         // 'long long' is guaranteed to be at least 64 bits wide.
 202         if (A.SInt >= INT64_MIN && A.SInt <= INT64_MAX)
 203           Printf("%lld", (long long)A.SInt);
 204         else
 205           PrintHex(A.SInt);
 206         break;
 207       case Diag::AK_UInt:
 208         if (A.UInt <= UINT64_MAX)
 209           Printf("%llu", (unsigned long long)A.UInt);
 210         else
 211           PrintHex(A.UInt);
 212         break;
 213       case Diag::AK_Float: {
 214         // FIXME: Support floating-point formatting in sanitizer_common's
 215         //        printf, and stop using snprintf here.
 216         char Buffer[32];
 217 #if SANITIZER_WINDOWS
 218         sprintf_s(Buffer, sizeof(Buffer), "%Lg", (long double)A.Float);
 219 #else
 220         snprintf(Buffer, sizeof(Buffer), "%Lg", (long double)A.Float);
 221 #endif
 222         Printf("%s", Buffer);
 223         break;
 224       }
 225       case Diag::AK_Pointer:
 226         Printf("%p", A.Pointer);
 227         break;
 228       }
 229     }
 230   }
 231 }
 232
 233 /// Find the earliest-starting range in Ranges which ends after Loc.
 234 static Range *upperBound(MemoryLocation Loc, Range *Ranges,
 235                          unsigned NumRanges) {
 236   Range *Best = 0;
 237   for (unsigned I = 0; I != NumRanges; ++I)
 238     if (Ranges[I].getEnd().getMemoryLocation() > Loc &&
 239         (!Best ||
 240          Best->getStart().getMemoryLocation() >
 241          Ranges[I].getStart().getMemoryLocation()))
 242       Best = &Ranges[I];
 243   return Best;
 244 }
 245
 246 static inline uptr subtractNoOverflow(uptr LHS, uptr RHS) {
 247   return (LHS < RHS) ? 0 : LHS - RHS;
 248 }
 249
 250 static inline uptr addNoOverflow(uptr LHS, uptr RHS) {
 251   const uptr Limit = (uptr)-1;
 252   return (LHS > Limit - RHS) ? Limit : LHS + RHS;
 253 }
 254
 255 /// Render a snippet of the address space near a location.
 256 static void renderMemorySnippet(const Decorator &Decor, MemoryLocation Loc,
 257                                 Range *Ranges, unsigned NumRanges,
 258                                 const Diag::Arg *Args) {
 259   // Show at least the 8 bytes surrounding Loc.
 260   const unsigned MinBytesNearLoc = 4;
 261   MemoryLocation Min = subtractNoOverflow(Loc, MinBytesNearLoc);
 262   MemoryLocation Max = addNoOverflow(Loc, MinBytesNearLoc);
 263   MemoryLocation OrigMin = Min;
 264   for (unsigned I = 0; I < NumRanges; ++I) {
 265     Min = __sanitizer::Min(Ranges[I].getStart().getMemoryLocation(), Min);
 266     Max = __sanitizer::Max(Ranges[I].getEnd().getMemoryLocation(), Max);
 267   }
 268
 269   // If we have too many interesting bytes, prefer to show bytes after Loc.
 270   const unsigned BytesToShow = 32;
 271   if (Max - Min > BytesToShow)
 272     Min = __sanitizer::Min(Max - BytesToShow, OrigMin);
 273   Max = addNoOverflow(Min, BytesToShow);
 274
 275   if (!IsAccessibleMemoryRange(Min, Max - Min)) {
 276     Printf("<memory cannot be printed>\n");
 277     return;
 278   }
 279
 280   // Emit data.
 281   for (uptr P = Min; P != Max; ++P) {
 282     unsigned char C = *reinterpret_cast<const unsigned char*>(P);
 283     Printf("%s%02x", (P % 8 == 0) ? "  " : " ", C);
 284   }
 285   Printf("\n");
 286
 287   // Emit highlights.
 288   Printf(Decor.Highlight());
 289   Range *InRange = upperBound(Min, Ranges, NumRanges);
 290   for (uptr P = Min; P != Max; ++P) {
 291     char Pad = ' ', Byte = ' ';
 292     if (InRange && InRange->getEnd().getMemoryLocation() == P)
 293       InRange = upperBound(P, Ranges, NumRanges);
 294     if (!InRange && P > Loc)
 295       break;
 296     if (InRange && InRange->getStart().getMemoryLocation() < P)
 297       Pad = '~';
 298     if (InRange && InRange->getStart().getMemoryLocation() <= P)
 299       Byte = '~';
 300     char Buffer[] = { Pad, Pad, P == Loc ? '^' : Byte, Byte, 0 };
 301     Printf((P % 8 == 0) ? Buffer : &Buffer[1]);
 302   }
 303   Printf("%s\n", Decor.EndHighlight());
 304
 305   // Go over the line again, and print names for the ranges.
 306   InRange = 0;
 307   unsigned Spaces = 0;
 308   for (uptr P = Min; P != Max; ++P) {
 309     if (!InRange || InRange->getEnd().getMemoryLocation() == P)
 310       InRange = upperBound(P, Ranges, NumRanges);
 311     if (!InRange)
 312       break;
 313
 314     Spaces += (P % 8) == 0 ? 2 : 1;
 315
 316     if (InRange && InRange->getStart().getMemoryLocation() == P) {
 317       while (Spaces--)
 318         Printf(" ");
 319       renderText(InRange->getText(), Args);
 320       Printf("\n");
 321       // FIXME: We only support naming one range for now!
 322       break;
 323     }
 324
 325     Spaces += 2;
 326   }
 327
 328   // FIXME: Print names for anything we can identify within the line:
 329   //
 330   //  * If we can identify the memory itself as belonging to a particular
 331   //    global, stack variable, or dynamic allocation, then do so.
 332   //
 333   //  * If we have a pointer-size, pointer-aligned range highlighted,
 334   //    determine whether the value of that range is a pointer to an
 335   //    entity which we can name, and if so, print that name.
 336   //
 337   // This needs an external symbolizer, or (preferably) ASan instrumentation.
 338 }
 339
 340 Diag::~Diag() {
 341   // All diagnostics should be printed under report mutex.
 342   CommonSanitizerReportMutex.CheckLocked();
 343   Decorator Decor;
 344   Printf(Decor.Bold());
 345
 346   renderLocation(Loc);
 347
 348   switch (Level) {
 349   case DL_Error:
 350     Printf("%s runtime error: %s%s",
 351            Decor.Warning(), Decor.EndWarning(), Decor.Bold());
 352     break;
 353
 354   case DL_Note:
 355     Printf("%s note: %s", Decor.Note(), Decor.EndNote());
 356     break;
 357   }
 358
 359   renderText(Message, Args);
 360
 361   Printf("%s\n", Decor.Default());
 362
 363   if (Loc.isMemoryLocation())
 364     renderMemorySnippet(Decor, Loc.getMemoryLocation(), Ranges,
 365                         NumRanges, Args);
 366 }
 367
 368 ScopedReport::ScopedReport(ReportOptions Opts, Location SummaryLoc,
 369                            ErrorType Type)
 370     : Opts(Opts), SummaryLoc(SummaryLoc), Type(Type) {
 371   InitAsStandaloneIfNecessary();
 372   CommonSanitizerReportMutex.Lock();
 373 }
 374
 375 ScopedReport::~ScopedReport() {
 376   MaybePrintStackTrace(Opts.pc, Opts.bp);
 377   MaybeReportErrorSummary(SummaryLoc, Type);
 378   CommonSanitizerReportMutex.Unlock();
 379   if (flags()->halt_on_error)
 380     Die();
 381 }
 382
 383 ALIGNED(64) static char suppression_placeholder[sizeof(SuppressionContext)];
 384 static SuppressionContext *suppression_ctx = nullptr;
 385 static const char kVptrCheck[] = "vptr_check";
 386 static const char *kSuppressionTypes[] = {
 387 #define UBSAN_CHECK(Name, SummaryKind, FSanitizeFlagName) FSanitizeFlagName,
 388 #include "ubsan_checks.inc"
 389 #undef UBSAN_CHECK
 390     kVptrCheck,
 391 };
 392
 393 void __ubsan::InitializeSuppressions() {
 394   CHECK_EQ(nullptr, suppression_ctx);
 395   suppression_ctx = new (suppression_placeholder) // NOLINT
 396       SuppressionContext(kSuppressionTypes, ARRAY_SIZE(kSuppressionTypes));
 397   suppression_ctx->ParseFromFile(flags()->suppressions);
 398 }
 399
 400 bool __ubsan::IsVptrCheckSuppressed(const char *TypeName) {
 401   InitAsStandaloneIfNecessary();
 402   CHECK(suppression_ctx);
 403   Suppression *s;
 404   return suppression_ctx->Match(TypeName, kVptrCheck, &s);
 405 }
 406
 407 bool __ubsan::IsPCSuppressed(ErrorType ET, uptr PC, const char *Filename) {
 408   InitAsStandaloneIfNecessary();
 409   CHECK(suppression_ctx);
 410   const char *SuppType = ConvertTypeToFlagName(ET);
 411   // Fast path: don't symbolize PC if there is no suppressions for given UB
 412   // type.
 413   if (!suppression_ctx->HasSuppressionType(SuppType))
 414     return false;
 415   Suppression *s = nullptr;
 416   // Suppress by file name known to runtime.
 417   if (Filename != nullptr && suppression_ctx->Match(Filename, SuppType, &s))
 418     return true;
 419   // Suppress by module name.
 420   if (const char *Module = Symbolizer::GetOrInit()->GetModuleNameForPc(PC)) {
 421     if (suppression_ctx->Match(Module, SuppType, &s))
 422       return true;
 423   }
 424   // Suppress by function or source file name from debug info.
 425   SymbolizedStackHolder Stack(Symbolizer::GetOrInit()->SymbolizePC(PC));
 426   const AddressInfo &AI = Stack.get()->info;
 427   return suppression_ctx->Match(AI.function, SuppType, &s) ||
 428          suppression_ctx->Match(AI.file, SuppType, &s);
 429 }
 430
 431 #endif  // CAN_SANITIZE_UB