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_diag.h"
     15 #include "sanitizer_common/sanitizer_common.h"
     16 #include "sanitizer_common/sanitizer_libc.h"
     17 #include "sanitizer_common/sanitizer_report_decorator.h"
     18 #include "sanitizer_common/sanitizer_stacktrace.h"
     19 #include "sanitizer_common/sanitizer_symbolizer.h"
     20 #include <stdio.h>
     21 
     22 using namespace __ubsan;
     23 
     24 Location __ubsan::getCallerLocation(uptr CallerLoc) {
     25   if (!CallerLoc)
     26     return Location();
     27 
     28   uptr Loc = StackTrace::GetPreviousInstructionPc(CallerLoc);
     29 
     30   AddressInfo Info;
     31   if (!SymbolizeCode(Loc, &Info, 1) || !Info.module || !*Info.module)
     32     return Location(Loc);
     33 
     34   if (!Info.file)
     35     return ModuleLocation(Info.module, Info.module_offset);
     36 
     37   return SourceLocation(Info.file, Info.line, Info.column);
     38 }
     39 
     40 Diag &Diag::operator<<(const TypeDescriptor &V) {
     41   return AddArg(V.getTypeName());
     42 }
     43 
     44 Diag &Diag::operator<<(const Value &V) {
     45   if (V.getType().isSignedIntegerTy())
     46     AddArg(V.getSIntValue());
     47   else if (V.getType().isUnsignedIntegerTy())
     48     AddArg(V.getUIntValue());
     49   else if (V.getType().isFloatTy())
     50     AddArg(V.getFloatValue());
     51   else
     52     AddArg("<unknown>");
     53   return *this;
     54 }
     55 
     56 /// Hexadecimal printing for numbers too large for Printf to handle directly.
     57 static void PrintHex(UIntMax Val) {
     58 #if HAVE_INT128_T
     59   Printf("0x%08x%08x%08x%08x",
     60           (unsigned int)(Val >> 96),
     61           (unsigned int)(Val >> 64),
     62           (unsigned int)(Val >> 32),
     63           (unsigned int)(Val));
     64 #else
     65   UNREACHABLE("long long smaller than 64 bits?");
     66 #endif
     67 }
     68 
     69 static void renderLocation(Location Loc) {
     70   switch (Loc.getKind()) {
     71   case Location::LK_Source: {
     72     SourceLocation SLoc = Loc.getSourceLocation();
     73     if (SLoc.isInvalid())
     74       Printf("<unknown>:");
     75     else {
     76       Printf("%s:%d:", SLoc.getFilename(), SLoc.getLine());
     77       if (SLoc.getColumn())
     78         Printf("%d:", SLoc.getColumn());
     79     }
     80     break;
     81   }
     82   case Location::LK_Module:
     83     Printf("%s:0x%zx:", Loc.getModuleLocation().getModuleName(),
     84            Loc.getModuleLocation().getOffset());
     85     break;
     86   case Location::LK_Memory:
     87     Printf("%p:", Loc.getMemoryLocation());
     88     break;
     89   case Location::LK_Null:
     90     Printf("<unknown>:");
     91     break;
     92   }
     93 }
     94 
     95 static void renderText(const char *Message, const Diag::Arg *Args) {
     96   for (const char *Msg = Message; *Msg; ++Msg) {
     97     if (*Msg != '%') {
     98       char Buffer[64];
     99       unsigned I;
    100       for (I = 0; Msg[I] && Msg[I] != '%' && I != 63; ++I)
    101         Buffer[I] = Msg[I];
    102       Buffer[I] = '\0';
    103       Printf(Buffer);
    104       Msg += I - 1;
    105     } else {
    106       const Diag::Arg &A = Args[*++Msg - '0'];
    107       switch (A.Kind) {
    108       case Diag::AK_String:
    109         Printf("%s", A.String);
    110         break;
    111       case Diag::AK_Mangled: {
    112         Printf("'%s'", Demangle(A.String));
    113         break;
    114       }
    115       case Diag::AK_SInt:
    116         // 'long long' is guaranteed to be at least 64 bits wide.
    117         if (A.SInt >= INT64_MIN && A.SInt <= INT64_MAX)
    118           Printf("%lld", (long long)A.SInt);
    119         else
    120           PrintHex(A.SInt);
    121         break;
    122       case Diag::AK_UInt:
    123         if (A.UInt <= UINT64_MAX)
    124           Printf("%llu", (unsigned long long)A.UInt);
    125         else
    126           PrintHex(A.UInt);
    127         break;
    128       case Diag::AK_Float: {
    129         // FIXME: Support floating-point formatting in sanitizer_common's
    130         //        printf, and stop using snprintf here.
    131         char Buffer[32];
    132         snprintf(Buffer, sizeof(Buffer), "%Lg", (long double)A.Float);
    133         Printf("%s", Buffer);
    134         break;
    135       }
    136       case Diag::AK_Pointer:
    137         Printf("%p", A.Pointer);
    138         break;
    139       }
    140     }
    141   }
    142 }
    143 
    144 /// Find the earliest-starting range in Ranges which ends after Loc.
    145 static Range *upperBound(MemoryLocation Loc, Range *Ranges,
    146                          unsigned NumRanges) {
    147   Range *Best = 0;
    148   for (unsigned I = 0; I != NumRanges; ++I)
    149     if (Ranges[I].getEnd().getMemoryLocation() > Loc &&
    150         (!Best ||
    151          Best->getStart().getMemoryLocation() >
    152          Ranges[I].getStart().getMemoryLocation()))
    153       Best = &Ranges[I];
    154   return Best;
    155 }
    156 
    157 /// Render a snippet of the address space near a location.
    158 static void renderMemorySnippet(const __sanitizer::AnsiColorDecorator &Decor,
    159                                 MemoryLocation Loc,
    160                                 Range *Ranges, unsigned NumRanges,
    161                                 const Diag::Arg *Args) {
    162   const unsigned BytesToShow = 32;
    163   const unsigned MinBytesNearLoc = 4;
    164 
    165   // Show at least the 8 bytes surrounding Loc.
    166   MemoryLocation Min = Loc - MinBytesNearLoc, Max = Loc + MinBytesNearLoc;
    167   for (unsigned I = 0; I < NumRanges; ++I) {
    168     Min = __sanitizer::Min(Ranges[I].getStart().getMemoryLocation(), Min);
    169     Max = __sanitizer::Max(Ranges[I].getEnd().getMemoryLocation(), Max);
    170   }
    171 
    172   // If we have too many interesting bytes, prefer to show bytes after Loc.
    173   if (Max - Min > BytesToShow)
    174     Min = __sanitizer::Min(Max - BytesToShow, Loc - MinBytesNearLoc);
    175   Max = Min + BytesToShow;
    176 
    177   // Emit data.
    178   for (uptr P = Min; P != Max; ++P) {
    179     // FIXME: Check that the address is readable before printing it.
    180     unsigned char C = *reinterpret_cast<const unsigned char*>(P);
    181     Printf("%s%02x", (P % 8 == 0) ? "  " : " ", C);
    182   }
    183   Printf("\n");
    184 
    185   // Emit highlights.
    186   Printf(Decor.Green());
    187   Range *InRange = upperBound(Min, Ranges, NumRanges);
    188   for (uptr P = Min; P != Max; ++P) {
    189     char Pad = ' ', Byte = ' ';
    190     if (InRange && InRange->getEnd().getMemoryLocation() == P)
    191       InRange = upperBound(P, Ranges, NumRanges);
    192     if (!InRange && P > Loc)
    193       break;
    194     if (InRange && InRange->getStart().getMemoryLocation() < P)
    195       Pad = '~';
    196     if (InRange && InRange->getStart().getMemoryLocation() <= P)
    197       Byte = '~';
    198     char Buffer[] = { Pad, Pad, P == Loc ? '^' : Byte, Byte, 0 };
    199     Printf((P % 8 == 0) ? Buffer : &Buffer[1]);
    200   }
    201   Printf("%s\n", Decor.Default());
    202 
    203   // Go over the line again, and print names for the ranges.
    204   InRange = 0;
    205   unsigned Spaces = 0;
    206   for (uptr P = Min; P != Max; ++P) {
    207     if (!InRange || InRange->getEnd().getMemoryLocation() == P)
    208       InRange = upperBound(P, Ranges, NumRanges);
    209     if (!InRange)
    210       break;
    211 
    212     Spaces += (P % 8) == 0 ? 2 : 1;
    213 
    214     if (InRange && InRange->getStart().getMemoryLocation() == P) {
    215       while (Spaces--)
    216         Printf(" ");
    217       renderText(InRange->getText(), Args);
    218       Printf("\n");
    219       // FIXME: We only support naming one range for now!
    220       break;
    221     }
    222 
    223     Spaces += 2;
    224   }
    225 
    226   // FIXME: Print names for anything we can identify within the line:
    227   //
    228   //  * If we can identify the memory itself as belonging to a particular
    229   //    global, stack variable, or dynamic allocation, then do so.
    230   //
    231   //  * If we have a pointer-size, pointer-aligned range highlighted,
    232   //    determine whether the value of that range is a pointer to an
    233   //    entity which we can name, and if so, print that name.
    234   //
    235   // This needs an external symbolizer, or (preferably) ASan instrumentation.
    236 }
    237 
    238 Diag::~Diag() {
    239   __sanitizer::AnsiColorDecorator Decor(PrintsToTty());
    240   SpinMutexLock l(&CommonSanitizerReportMutex);
    241   Printf(Decor.Bold());
    242 
    243   renderLocation(Loc);
    244 
    245   switch (Level) {
    246   case DL_Error:
    247     Printf("%s runtime error: %s%s",
    248            Decor.Red(), Decor.Default(), Decor.Bold());
    249     break;
    250 
    251   case DL_Note:
    252     Printf("%s note: %s", Decor.Black(), Decor.Default());
    253     break;
    254   }
    255 
    256   renderText(Message, Args);
    257 
    258   Printf("%s\n", Decor.Default());
    259 
    260   if (Loc.isMemoryLocation())
    261     renderMemorySnippet(Decor, Loc.getMemoryLocation(), Ranges,
    262                         NumRanges, Args);
    263 }
    264