Retro68/gcc/libsanitizer/ubsan/ubsan_diag.cc

390 lines
12 KiB
C++
Raw Normal View History

2014-09-21 17:33:12 +00:00
//===-- ubsan_diag.cc -----------------------------------------------------===//
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// Diagnostic reporting for the UBSan runtime.
//
//===----------------------------------------------------------------------===//
2017-04-10 11:32:00 +00:00
#include "ubsan_platform.h"
#if CAN_SANITIZE_UB
2014-09-21 17:33:12 +00:00
#include "ubsan_diag.h"
2015-08-28 15:33:40 +00:00
#include "ubsan_init.h"
#include "ubsan_flags.h"
2017-04-10 11:32:00 +00:00
#include "sanitizer_common/sanitizer_placement_new.h"
2014-09-21 17:33:12 +00:00
#include "sanitizer_common/sanitizer_report_decorator.h"
#include "sanitizer_common/sanitizer_stacktrace.h"
2015-08-28 15:33:40 +00:00
#include "sanitizer_common/sanitizer_stacktrace_printer.h"
2017-04-10 11:32:00 +00:00
#include "sanitizer_common/sanitizer_suppressions.h"
2014-09-21 17:33:12 +00:00
#include "sanitizer_common/sanitizer_symbolizer.h"
#include <stdio.h>
using namespace __ubsan;
2015-08-28 15:33:40 +00:00
static void MaybePrintStackTrace(uptr pc, uptr bp) {
2017-04-10 11:32:00 +00:00
// We assume that flags are already parsed, as UBSan runtime
2015-08-28 15:33:40 +00:00
// will definitely be called when we print the first diagnostics message.
if (!flags()->print_stacktrace)
return;
// We can only use slow unwind, as we don't have any information about stack
// top/bottom.
// FIXME: It's better to respect "fast_unwind_on_fatal" runtime flag and
// fetch stack top/bottom information if we have it (e.g. if we're running
// under ASan).
if (StackTrace::WillUseFastUnwind(false))
return;
BufferedStackTrace stack;
stack.Unwind(kStackTraceMax, pc, bp, 0, 0, 0, false);
stack.Print();
}
2017-04-10 11:32:00 +00:00
static const char *ConvertTypeToString(ErrorType Type) {
switch (Type) {
#define UBSAN_CHECK(Name, SummaryKind, FlagName) \
case ErrorType::Name: \
return SummaryKind;
#include "ubsan_checks.inc"
#undef UBSAN_CHECK
}
UNREACHABLE("unknown ErrorType!");
}
static void MaybeReportErrorSummary(Location Loc, ErrorType Type) {
2015-08-28 15:33:40 +00:00
if (!common_flags()->print_summary)
return;
2017-04-10 11:32:00 +00:00
if (!flags()->report_error_type)
Type = ErrorType::GenericUB;
const char *ErrorKind = ConvertTypeToString(Type);
2015-08-28 15:33:40 +00:00
if (Loc.isSourceLocation()) {
SourceLocation SLoc = Loc.getSourceLocation();
if (!SLoc.isInvalid()) {
2017-04-10 11:32:00 +00:00
AddressInfo AI;
AI.file = internal_strdup(SLoc.getFilename());
AI.line = SLoc.getLine();
AI.column = SLoc.getColumn();
AI.function = internal_strdup(""); // Avoid printing ?? as function name.
ReportErrorSummary(ErrorKind, AI);
AI.Clear();
2015-08-28 15:33:40 +00:00
return;
}
2017-04-10 11:32:00 +00:00
} else if (Loc.isSymbolizedStack()) {
const AddressInfo &AI = Loc.getSymbolizedStack()->info;
ReportErrorSummary(ErrorKind, AI);
return;
2015-08-28 15:33:40 +00:00
}
2017-04-10 11:32:00 +00:00
ReportErrorSummary(ErrorKind);
2015-08-28 15:33:40 +00:00
}
namespace {
class Decorator : public SanitizerCommonDecorator {
public:
Decorator() : SanitizerCommonDecorator() {}
const char *Highlight() const { return Green(); }
const char *EndHighlight() const { return Default(); }
const char *Note() const { return Black(); }
const char *EndNote() const { return Default(); }
};
}
2017-04-10 11:32:00 +00:00
SymbolizedStack *__ubsan::getSymbolizedLocation(uptr PC) {
InitAsStandaloneIfNecessary();
return Symbolizer::GetOrInit()->SymbolizePC(PC);
2014-09-21 17:33:12 +00:00
}
Diag &Diag::operator<<(const TypeDescriptor &V) {
return AddArg(V.getTypeName());
}
Diag &Diag::operator<<(const Value &V) {
if (V.getType().isSignedIntegerTy())
AddArg(V.getSIntValue());
else if (V.getType().isUnsignedIntegerTy())
AddArg(V.getUIntValue());
else if (V.getType().isFloatTy())
AddArg(V.getFloatValue());
else
AddArg("<unknown>");
return *this;
}
/// Hexadecimal printing for numbers too large for Printf to handle directly.
static void PrintHex(UIntMax Val) {
#if HAVE_INT128_T
Printf("0x%08x%08x%08x%08x",
(unsigned int)(Val >> 96),
(unsigned int)(Val >> 64),
(unsigned int)(Val >> 32),
(unsigned int)(Val));
#else
UNREACHABLE("long long smaller than 64 bits?");
#endif
}
static void renderLocation(Location Loc) {
InternalScopedString LocBuffer(1024);
switch (Loc.getKind()) {
case Location::LK_Source: {
SourceLocation SLoc = Loc.getSourceLocation();
if (SLoc.isInvalid())
LocBuffer.append("<unknown>");
else
2015-08-28 15:33:40 +00:00
RenderSourceLocation(&LocBuffer, SLoc.getFilename(), SLoc.getLine(),
2017-04-10 11:32:00 +00:00
SLoc.getColumn(), common_flags()->symbolize_vs_style,
common_flags()->strip_path_prefix);
2014-09-21 17:33:12 +00:00
break;
2015-08-28 15:33:40 +00:00
}
2014-09-21 17:33:12 +00:00
case Location::LK_Memory:
LocBuffer.append("%p", Loc.getMemoryLocation());
break;
2017-04-10 11:32:00 +00:00
case Location::LK_Symbolized: {
const AddressInfo &Info = Loc.getSymbolizedStack()->info;
if (Info.file) {
RenderSourceLocation(&LocBuffer, Info.file, Info.line, Info.column,
common_flags()->symbolize_vs_style,
common_flags()->strip_path_prefix);
} else if (Info.module) {
RenderModuleLocation(&LocBuffer, Info.module, Info.module_offset,
common_flags()->strip_path_prefix);
} else {
LocBuffer.append("%p", Info.address);
}
break;
}
2014-09-21 17:33:12 +00:00
case Location::LK_Null:
LocBuffer.append("<unknown>");
break;
}
Printf("%s:", LocBuffer.data());
}
static void renderText(const char *Message, const Diag::Arg *Args) {
for (const char *Msg = Message; *Msg; ++Msg) {
if (*Msg != '%') {
char Buffer[64];
unsigned I;
for (I = 0; Msg[I] && Msg[I] != '%' && I != 63; ++I)
Buffer[I] = Msg[I];
Buffer[I] = '\0';
Printf(Buffer);
Msg += I - 1;
} else {
const Diag::Arg &A = Args[*++Msg - '0'];
switch (A.Kind) {
case Diag::AK_String:
Printf("%s", A.String);
break;
2017-04-10 11:32:00 +00:00
case Diag::AK_TypeName: {
if (SANITIZER_WINDOWS)
// The Windows implementation demangles names early.
Printf("'%s'", A.String);
else
Printf("'%s'", Symbolizer::GetOrInit()->Demangle(A.String));
2014-09-21 17:33:12 +00:00
break;
}
case Diag::AK_SInt:
// 'long long' is guaranteed to be at least 64 bits wide.
if (A.SInt >= INT64_MIN && A.SInt <= INT64_MAX)
Printf("%lld", (long long)A.SInt);
else
PrintHex(A.SInt);
break;
case Diag::AK_UInt:
if (A.UInt <= UINT64_MAX)
Printf("%llu", (unsigned long long)A.UInt);
else
PrintHex(A.UInt);
break;
case Diag::AK_Float: {
// FIXME: Support floating-point formatting in sanitizer_common's
// printf, and stop using snprintf here.
char Buffer[32];
2017-04-10 11:32:00 +00:00
#if SANITIZER_WINDOWS
sprintf_s(Buffer, sizeof(Buffer), "%Lg", (long double)A.Float);
#else
2014-09-21 17:33:12 +00:00
snprintf(Buffer, sizeof(Buffer), "%Lg", (long double)A.Float);
2017-04-10 11:32:00 +00:00
#endif
2014-09-21 17:33:12 +00:00
Printf("%s", Buffer);
break;
}
case Diag::AK_Pointer:
Printf("%p", A.Pointer);
break;
}
}
}
}
/// Find the earliest-starting range in Ranges which ends after Loc.
static Range *upperBound(MemoryLocation Loc, Range *Ranges,
unsigned NumRanges) {
Range *Best = 0;
for (unsigned I = 0; I != NumRanges; ++I)
if (Ranges[I].getEnd().getMemoryLocation() > Loc &&
(!Best ||
Best->getStart().getMemoryLocation() >
Ranges[I].getStart().getMemoryLocation()))
Best = &Ranges[I];
return Best;
}
2015-08-28 15:33:40 +00:00
static inline uptr subtractNoOverflow(uptr LHS, uptr RHS) {
return (LHS < RHS) ? 0 : LHS - RHS;
}
static inline uptr addNoOverflow(uptr LHS, uptr RHS) {
const uptr Limit = (uptr)-1;
return (LHS > Limit - RHS) ? Limit : LHS + RHS;
}
2014-09-21 17:33:12 +00:00
/// Render a snippet of the address space near a location.
2015-08-28 15:33:40 +00:00
static void renderMemorySnippet(const Decorator &Decor, MemoryLocation Loc,
2014-09-21 17:33:12 +00:00
Range *Ranges, unsigned NumRanges,
const Diag::Arg *Args) {
// Show at least the 8 bytes surrounding Loc.
2015-08-28 15:33:40 +00:00
const unsigned MinBytesNearLoc = 4;
MemoryLocation Min = subtractNoOverflow(Loc, MinBytesNearLoc);
MemoryLocation Max = addNoOverflow(Loc, MinBytesNearLoc);
MemoryLocation OrigMin = Min;
2014-09-21 17:33:12 +00:00
for (unsigned I = 0; I < NumRanges; ++I) {
Min = __sanitizer::Min(Ranges[I].getStart().getMemoryLocation(), Min);
Max = __sanitizer::Max(Ranges[I].getEnd().getMemoryLocation(), Max);
}
// If we have too many interesting bytes, prefer to show bytes after Loc.
2015-08-28 15:33:40 +00:00
const unsigned BytesToShow = 32;
2014-09-21 17:33:12 +00:00
if (Max - Min > BytesToShow)
2015-08-28 15:33:40 +00:00
Min = __sanitizer::Min(Max - BytesToShow, OrigMin);
Max = addNoOverflow(Min, BytesToShow);
if (!IsAccessibleMemoryRange(Min, Max - Min)) {
Printf("<memory cannot be printed>\n");
return;
}
2014-09-21 17:33:12 +00:00
// Emit data.
for (uptr P = Min; P != Max; ++P) {
unsigned char C = *reinterpret_cast<const unsigned char*>(P);
Printf("%s%02x", (P % 8 == 0) ? " " : " ", C);
}
Printf("\n");
// Emit highlights.
2015-08-28 15:33:40 +00:00
Printf(Decor.Highlight());
2014-09-21 17:33:12 +00:00
Range *InRange = upperBound(Min, Ranges, NumRanges);
for (uptr P = Min; P != Max; ++P) {
char Pad = ' ', Byte = ' ';
if (InRange && InRange->getEnd().getMemoryLocation() == P)
InRange = upperBound(P, Ranges, NumRanges);
if (!InRange && P > Loc)
break;
if (InRange && InRange->getStart().getMemoryLocation() < P)
Pad = '~';
if (InRange && InRange->getStart().getMemoryLocation() <= P)
Byte = '~';
char Buffer[] = { Pad, Pad, P == Loc ? '^' : Byte, Byte, 0 };
Printf((P % 8 == 0) ? Buffer : &Buffer[1]);
}
2015-08-28 15:33:40 +00:00
Printf("%s\n", Decor.EndHighlight());
2014-09-21 17:33:12 +00:00
// Go over the line again, and print names for the ranges.
InRange = 0;
unsigned Spaces = 0;
for (uptr P = Min; P != Max; ++P) {
if (!InRange || InRange->getEnd().getMemoryLocation() == P)
InRange = upperBound(P, Ranges, NumRanges);
if (!InRange)
break;
Spaces += (P % 8) == 0 ? 2 : 1;
if (InRange && InRange->getStart().getMemoryLocation() == P) {
while (Spaces--)
Printf(" ");
renderText(InRange->getText(), Args);
Printf("\n");
// FIXME: We only support naming one range for now!
break;
}
Spaces += 2;
}
// FIXME: Print names for anything we can identify within the line:
//
// * If we can identify the memory itself as belonging to a particular
// global, stack variable, or dynamic allocation, then do so.
//
// * If we have a pointer-size, pointer-aligned range highlighted,
// determine whether the value of that range is a pointer to an
// entity which we can name, and if so, print that name.
//
// This needs an external symbolizer, or (preferably) ASan instrumentation.
}
Diag::~Diag() {
2015-08-28 15:33:40 +00:00
// All diagnostics should be printed under report mutex.
CommonSanitizerReportMutex.CheckLocked();
Decorator Decor;
2014-09-21 17:33:12 +00:00
Printf(Decor.Bold());
renderLocation(Loc);
switch (Level) {
case DL_Error:
Printf("%s runtime error: %s%s",
2015-08-28 15:33:40 +00:00
Decor.Warning(), Decor.EndWarning(), Decor.Bold());
2014-09-21 17:33:12 +00:00
break;
case DL_Note:
2015-08-28 15:33:40 +00:00
Printf("%s note: %s", Decor.Note(), Decor.EndNote());
2014-09-21 17:33:12 +00:00
break;
}
renderText(Message, Args);
Printf("%s\n", Decor.Default());
if (Loc.isMemoryLocation())
renderMemorySnippet(Decor, Loc.getMemoryLocation(), Ranges,
NumRanges, Args);
}
2015-08-28 15:33:40 +00:00
2017-04-10 11:32:00 +00:00
ScopedReport::ScopedReport(ReportOptions Opts, Location SummaryLoc,
ErrorType Type)
: Opts(Opts), SummaryLoc(SummaryLoc), Type(Type) {
InitAsStandaloneIfNecessary();
2015-08-28 15:33:40 +00:00
CommonSanitizerReportMutex.Lock();
}
ScopedReport::~ScopedReport() {
MaybePrintStackTrace(Opts.pc, Opts.bp);
2017-04-10 11:32:00 +00:00
MaybeReportErrorSummary(SummaryLoc, Type);
2015-08-28 15:33:40 +00:00
CommonSanitizerReportMutex.Unlock();
if (Opts.DieAfterReport || flags()->halt_on_error)
Die();
}
2017-04-10 11:32:00 +00:00
ALIGNED(64) static char suppression_placeholder[sizeof(SuppressionContext)];
static SuppressionContext *suppression_ctx = nullptr;
static const char kVptrCheck[] = "vptr_check";
static const char *kSuppressionTypes[] = { kVptrCheck };
void __ubsan::InitializeSuppressions() {
CHECK_EQ(nullptr, suppression_ctx);
suppression_ctx = new (suppression_placeholder) // NOLINT
SuppressionContext(kSuppressionTypes, ARRAY_SIZE(kSuppressionTypes));
suppression_ctx->ParseFromFile(flags()->suppressions);
}
bool __ubsan::IsVptrCheckSuppressed(const char *TypeName) {
InitAsStandaloneIfNecessary();
CHECK(suppression_ctx);
2015-08-28 15:33:40 +00:00
Suppression *s;
2017-04-10 11:32:00 +00:00
return suppression_ctx->Match(TypeName, kVptrCheck, &s);
2015-08-28 15:33:40 +00:00
}
2017-04-10 11:32:00 +00:00
#endif // CAN_SANITIZE_UB