Home | History | Annotate | Download | only in ubsan 
      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 void MaybeReportErrorSummary(Location Loc) {
     47   if (!common_flags()->print_summary)
     48     return;
     49   // Don't try to unwind the stack trace in UBSan summaries: just use the
     50   // provided location.
     51   if (Loc.isSourceLocation()) {
     52     SourceLocation SLoc = Loc.getSourceLocation();
     53     if (!SLoc.isInvalid()) {
     54       AddressInfo AI;
     55       AI.file = internal_strdup(SLoc.getFilename());
     56       AI.line = SLoc.getLine();
     57       AI.column = SLoc.getColumn();
     58       AI.function = internal_strdup("");  // Avoid printing ?? as function name.
     59       ReportErrorSummary("undefined-behavior", AI);
     60       AI.Clear();
     61       return;
     62     }
     63   }
     64   ReportErrorSummary("undefined-behavior");
     65 }
     66 
     67 namespace {
     68 class Decorator : public SanitizerCommonDecorator {
     69  public:
     70   Decorator() : SanitizerCommonDecorator() {}
     71   const char *Highlight() const { return Green(); }
     72   const char *EndHighlight() const { return Default(); }
     73   const char *Note() const { return Black(); }
     74   const char *EndNote() const { return Default(); }
     75 };
     76 }
     77 
     78 SymbolizedStack *__ubsan::getSymbolizedLocation(uptr PC) {
     79   InitAsStandaloneIfNecessary();
     80   return Symbolizer::GetOrInit()->SymbolizePC(PC);
     81 }
     82 
     83 Diag &Diag::operator<<(const TypeDescriptor &V) {
     84   return AddArg(V.getTypeName());
     85 }
     86 
     87 Diag &Diag::operator<<(const Value &V) {
     88   if (V.getType().isSignedIntegerTy())
     89     AddArg(V.getSIntValue());
     90   else if (V.getType().isUnsignedIntegerTy())
     91     AddArg(V.getUIntValue());
     92   else if (V.getType().isFloatTy())
     93     AddArg(V.getFloatValue());
     94   else
     95     AddArg("<unknown>");
     96   return *this;
     97 }
     98 
     99 /// Hexadecimal printing for numbers too large for Printf to handle directly.
    100 static void PrintHex(UIntMax Val) {
    101 #if HAVE_INT128_T
    102   Printf("0x%08x%08x%08x%08x",
    103           (unsigned int)(Val >> 96),
    104           (unsigned int)(Val >> 64),
    105           (unsigned int)(Val >> 32),
    106           (unsigned int)(Val));
    107 #else
    108   UNREACHABLE("long long smaller than 64 bits?");
    109 #endif
    110 }
    111 
    112 static void renderLocation(Location Loc) {
    113   InternalScopedString LocBuffer(1024);
    114   switch (Loc.getKind()) {
    115   case Location::LK_Source: {
    116     SourceLocation SLoc = Loc.getSourceLocation();
    117     if (SLoc.isInvalid())
    118       LocBuffer.append("<unknown>");
    119     else
    120       RenderSourceLocation(&LocBuffer, SLoc.getFilename(), SLoc.getLine(),
    121                            SLoc.getColumn(), common_flags()->strip_path_prefix);
    122     break;
    123   }
    124   case Location::LK_Memory:
    125     LocBuffer.append("%p", Loc.getMemoryLocation());
    126     break;
    127   case Location::LK_Symbolized: {
    128     const AddressInfo &Info = Loc.getSymbolizedStack()->info;
    129     if (Info.file) {
    130       RenderSourceLocation(&LocBuffer, Info.file, Info.line, Info.column,
    131                            common_flags()->strip_path_prefix);
    132     } else if (Info.module) {
    133       RenderModuleLocation(&LocBuffer, Info.module, Info.module_offset,
    134                            common_flags()->strip_path_prefix);
    135     } else {
    136       LocBuffer.append("%p", Info.address);
    137     }
    138     break;
    139   }
    140   case Location::LK_Null:
    141     LocBuffer.append("<unknown>");
    142     break;
    143   }
    144   Printf("%s:", LocBuffer.data());
    145 }
    146 
    147 static void renderText(const char *Message, const Diag::Arg *Args) {
    148   for (const char *Msg = Message; *Msg; ++Msg) {
    149     if (*Msg != '%') {
    150       char Buffer[64];
    151       unsigned I;
    152       for (I = 0; Msg[I] && Msg[I] != '%' && I != 63; ++I)
    153         Buffer[I] = Msg[I];
    154       Buffer[I] = '\0';
    155       Printf(Buffer);
    156       Msg += I - 1;
    157     } else {
    158       const Diag::Arg &A = Args[*++Msg - '0'];
    159       switch (A.Kind) {
    160       case Diag::AK_String:
    161         Printf("%s", A.String);
    162         break;
    163       case Diag::AK_Mangled: {
    164         Printf("'%s'", Symbolizer::GetOrInit()->Demangle(A.String));
    165         break;
    166       }
    167       case Diag::AK_SInt:
    168         // 'long long' is guaranteed to be at least 64 bits wide.
    169         if (A.SInt >= INT64_MIN && A.SInt <= INT64_MAX)
    170           Printf("%lld", (long long)A.SInt);
    171         else
    172           PrintHex(A.SInt);
    173         break;
    174       case Diag::AK_UInt:
    175         if (A.UInt <= UINT64_MAX)
    176           Printf("%llu", (unsigned long long)A.UInt);
    177         else
    178           PrintHex(A.UInt);
    179         break;
    180       case Diag::AK_Float: {
    181         // FIXME: Support floating-point formatting in sanitizer_common's
    182         //        printf, and stop using snprintf here.
    183         char Buffer[32];
    184         snprintf(Buffer, sizeof(Buffer), "%Lg", (long double)A.Float);
    185         Printf("%s", Buffer);
    186         break;
    187       }
    188       case Diag::AK_Pointer:
    189         Printf("%p", A.Pointer);
    190         break;
    191       }
    192     }
    193   }
    194 }
    195 
    196 /// Find the earliest-starting range in Ranges which ends after Loc.
    197 static Range *upperBound(MemoryLocation Loc, Range *Ranges,
    198                          unsigned NumRanges) {
    199   Range *Best = 0;
    200   for (unsigned I = 0; I != NumRanges; ++I)
    201     if (Ranges[I].getEnd().getMemoryLocation() > Loc &&
    202         (!Best ||
    203          Best->getStart().getMemoryLocation() >
    204          Ranges[I].getStart().getMemoryLocation()))
    205       Best = &Ranges[I];
    206   return Best;
    207 }
    208 
    209 static inline uptr subtractNoOverflow(uptr LHS, uptr RHS) {
    210   return (LHS < RHS) ? 0 : LHS - RHS;
    211 }
    212 
    213 static inline uptr addNoOverflow(uptr LHS, uptr RHS) {
    214   const uptr Limit = (uptr)-1;
    215   return (LHS > Limit - RHS) ? Limit : LHS + RHS;
    216 }
    217 
    218 /// Render a snippet of the address space near a location.
    219 static void renderMemorySnippet(const Decorator &Decor, MemoryLocation Loc,
    220                                 Range *Ranges, unsigned NumRanges,
    221                                 const Diag::Arg *Args) {
    222   // Show at least the 8 bytes surrounding Loc.
    223   const unsigned MinBytesNearLoc = 4;
    224   MemoryLocation Min = subtractNoOverflow(Loc, MinBytesNearLoc);
    225   MemoryLocation Max = addNoOverflow(Loc, MinBytesNearLoc);
    226   MemoryLocation OrigMin = Min;
    227   for (unsigned I = 0; I < NumRanges; ++I) {
    228     Min = __sanitizer::Min(Ranges[I].getStart().getMemoryLocation(), Min);
    229     Max = __sanitizer::Max(Ranges[I].getEnd().getMemoryLocation(), Max);
    230   }
    231 
    232   // If we have too many interesting bytes, prefer to show bytes after Loc.
    233   const unsigned BytesToShow = 32;
    234   if (Max - Min > BytesToShow)
    235     Min = __sanitizer::Min(Max - BytesToShow, OrigMin);
    236   Max = addNoOverflow(Min, BytesToShow);
    237 
    238   if (!IsAccessibleMemoryRange(Min, Max - Min)) {
    239     Printf("<memory cannot be printed>\n");
    240     return;
    241   }
    242 
    243   // Emit data.
    244   for (uptr P = Min; P != Max; ++P) {
    245     unsigned char C = *reinterpret_cast<const unsigned char*>(P);
    246     Printf("%s%02x", (P % 8 == 0) ? "  " : " ", C);
    247   }
    248   Printf("\n");
    249 
    250   // Emit highlights.
    251   Printf(Decor.Highlight());
    252   Range *InRange = upperBound(Min, Ranges, NumRanges);
    253   for (uptr P = Min; P != Max; ++P) {
    254     char Pad = ' ', Byte = ' ';
    255     if (InRange && InRange->getEnd().getMemoryLocation() == P)
    256       InRange = upperBound(P, Ranges, NumRanges);
    257     if (!InRange && P > Loc)
    258       break;
    259     if (InRange && InRange->getStart().getMemoryLocation() < P)
    260       Pad = '~';
    261     if (InRange && InRange->getStart().getMemoryLocation() <= P)
    262       Byte = '~';
    263     char Buffer[] = { Pad, Pad, P == Loc ? '^' : Byte, Byte, 0 };
    264     Printf((P % 8 == 0) ? Buffer : &Buffer[1]);
    265   }
    266   Printf("%s\n", Decor.EndHighlight());
    267 
    268   // Go over the line again, and print names for the ranges.
    269   InRange = 0;
    270   unsigned Spaces = 0;
    271   for (uptr P = Min; P != Max; ++P) {
    272     if (!InRange || InRange->getEnd().getMemoryLocation() == P)
    273       InRange = upperBound(P, Ranges, NumRanges);
    274     if (!InRange)
    275       break;
    276 
    277     Spaces += (P % 8) == 0 ? 2 : 1;
    278 
    279     if (InRange && InRange->getStart().getMemoryLocation() == P) {
    280       while (Spaces--)
    281         Printf(" ");
    282       renderText(InRange->getText(), Args);
    283       Printf("\n");
    284       // FIXME: We only support naming one range for now!
    285       break;
    286     }
    287 
    288     Spaces += 2;
    289   }
    290 
    291   // FIXME: Print names for anything we can identify within the line:
    292   //
    293   //  * If we can identify the memory itself as belonging to a particular
    294   //    global, stack variable, or dynamic allocation, then do so.
    295   //
    296   //  * If we have a pointer-size, pointer-aligned range highlighted,
    297   //    determine whether the value of that range is a pointer to an
    298   //    entity which we can name, and if so, print that name.
    299   //
    300   // This needs an external symbolizer, or (preferably) ASan instrumentation.
    301 }
    302 
    303 Diag::~Diag() {
    304   // All diagnostics should be printed under report mutex.
    305   CommonSanitizerReportMutex.CheckLocked();
    306   Decorator Decor;
    307   Printf(Decor.Bold());
    308 
    309   renderLocation(Loc);
    310 
    311   switch (Level) {
    312   case DL_Error:
    313     Printf("%s runtime error: %s%s",
    314            Decor.Warning(), Decor.EndWarning(), Decor.Bold());
    315     break;
    316 
    317   case DL_Note:
    318     Printf("%s note: %s", Decor.Note(), Decor.EndNote());
    319     break;
    320   }
    321 
    322   renderText(Message, Args);
    323 
    324   Printf("%s\n", Decor.Default());
    325 
    326   if (Loc.isMemoryLocation())
    327     renderMemorySnippet(Decor, Loc.getMemoryLocation(), Ranges,
    328                         NumRanges, Args);
    329 }
    330 
    331 ScopedReport::ScopedReport(ReportOptions Opts, Location SummaryLoc)
    332     : Opts(Opts), SummaryLoc(SummaryLoc) {
    333   InitAsStandaloneIfNecessary();
    334   CommonSanitizerReportMutex.Lock();
    335 }
    336 
    337 ScopedReport::~ScopedReport() {
    338   MaybePrintStackTrace(Opts.pc, Opts.bp);
    339   MaybeReportErrorSummary(SummaryLoc);
    340   CommonSanitizerReportMutex.Unlock();
    341   if (Opts.DieAfterReport || flags()->halt_on_error)
    342     Die();
    343 }
    344 
    345 ALIGNED(64) static char suppression_placeholder[sizeof(SuppressionContext)];
    346 static SuppressionContext *suppression_ctx = nullptr;
    347 static const char kVptrCheck[] = "vptr_check";
    348 static const char *kSuppressionTypes[] = { kVptrCheck };
    349 
    350 void __ubsan::InitializeSuppressions() {
    351   CHECK_EQ(nullptr, suppression_ctx);
    352   suppression_ctx = new (suppression_placeholder) // NOLINT
    353       SuppressionContext(kSuppressionTypes, ARRAY_SIZE(kSuppressionTypes));
    354   suppression_ctx->ParseFromFile(flags()->suppressions);
    355 }
    356 
    357 bool __ubsan::IsVptrCheckSuppressed(const char *TypeName) {
    358   InitAsStandaloneIfNecessary();
    359   CHECK(suppression_ctx);
    360   Suppression *s;
    361   return suppression_ctx->Match(TypeName, kVptrCheck, &s);
    362 }
    363 
    364 #endif  // CAN_SANITIZE_UB
    365