[compiler-rt] r329586 - [ASan] NFC: make use of a new ErrorBase ctor
Alex Shlyapnikov via llvm-commits
llvm-commits at lists.llvm.org
Mon Apr 9 09:00:10 PDT 2018
Author: alekseyshl
Date: Mon Apr 9 09:00:10 2018
New Revision: 329586
URL: http://llvm.org/viewvc/llvm-project?rev=329586&view=rev
Log:
[ASan] NFC: make use of a new ErrorBase ctor
Summary:
Minor style changes to complement D44404:
- make use of a new ErrorBase ctor
- de-duplicate a comment about VS2013 support
Reviewers: eugenis
Subscribers: kubamracek, delcypher, llvm-commits, #sanitizers
Differential Revision: https://reviews.llvm.org/D45390
Modified:
compiler-rt/trunk/lib/asan/asan_errors.h
Modified: compiler-rt/trunk/lib/asan/asan_errors.h
URL: http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/lib/asan/asan_errors.h?rev=329586&r1=329585&r2=329586&view=diff
==============================================================================
--- compiler-rt/trunk/lib/asan/asan_errors.h (original)
+++ compiler-rt/trunk/lib/asan/asan_errors.h Mon Apr 9 09:00:10 2018
@@ -20,24 +20,30 @@
namespace __asan {
+// (*) VS2013 does not implement unrestricted unions, so we need a trivial
+// default constructor explicitly defined for each particular error.
+
+// None of the error classes own the stack traces mentioned in them.
+
struct ErrorBase {
- ErrorBase() = default;
+ ScarinessScoreBase scariness;
+ u32 tid;
+
+ ErrorBase() = default; // (*)
explicit ErrorBase(u32 tid_) : tid(tid_) {}
ErrorBase(u32 tid_, int initial_score, const char *reason) : tid(tid_) {
scariness.Clear();
scariness.Scare(initial_score, reason);
}
- ScarinessScoreBase scariness;
- u32 tid;
};
struct ErrorDeadlySignal : ErrorBase {
SignalContext signal;
- // VS2013 doesn't implement unrestricted unions, so we need a trivial default
- // constructor
- ErrorDeadlySignal() = default;
+
+ ErrorDeadlySignal() = default; // (*)
ErrorDeadlySignal(u32 tid, const SignalContext &sig)
- : ErrorBase(tid), signal(sig) {
+ : ErrorBase(tid),
+ signal(sig) {
scariness.Clear();
if (signal.IsStackOverflow()) {
scariness.Scare(10, "stack-overflow");
@@ -59,112 +65,88 @@ struct ErrorDeadlySignal : ErrorBase {
};
struct ErrorDoubleFree : ErrorBase {
- // ErrorDoubleFree doesn't own the stack trace.
const BufferedStackTrace *second_free_stack;
HeapAddressDescription addr_description;
- // VS2013 doesn't implement unrestricted unions, so we need a trivial default
- // constructor
- ErrorDoubleFree() = default;
+
+ ErrorDoubleFree() = default; // (*)
ErrorDoubleFree(u32 tid, BufferedStackTrace *stack, uptr addr)
- : ErrorBase(tid), second_free_stack(stack) {
+ : ErrorBase(tid, 42, "double-free"),
+ second_free_stack(stack) {
CHECK_GT(second_free_stack->size, 0);
GetHeapAddressInformation(addr, 1, &addr_description);
- scariness.Clear();
- scariness.Scare(42, "double-free");
}
void Print();
};
struct ErrorNewDeleteTypeMismatch : ErrorBase {
- // ErrorNewDeleteTypeMismatch doesn't own the stack trace.
const BufferedStackTrace *free_stack;
HeapAddressDescription addr_description;
uptr delete_size;
uptr delete_alignment;
- // VS2013 doesn't implement unrestricted unions, so we need a trivial default
- // constructor
- ErrorNewDeleteTypeMismatch() = default;
+
+ ErrorNewDeleteTypeMismatch() = default; // (*)
ErrorNewDeleteTypeMismatch(u32 tid, BufferedStackTrace *stack, uptr addr,
uptr delete_size_, uptr delete_alignment_)
- : ErrorBase(tid), free_stack(stack), delete_size(delete_size_),
+ : ErrorBase(tid, 10, "new-delete-type-mismatch"),
+ free_stack(stack),
+ delete_size(delete_size_),
delete_alignment(delete_alignment_) {
GetHeapAddressInformation(addr, 1, &addr_description);
- scariness.Clear();
- scariness.Scare(10, "new-delete-type-mismatch");
}
void Print();
};
struct ErrorFreeNotMalloced : ErrorBase {
- // ErrorFreeNotMalloced doesn't own the stack trace.
const BufferedStackTrace *free_stack;
AddressDescription addr_description;
- // VS2013 doesn't implement unrestricted unions, so we need a trivial default
- // constructor
- ErrorFreeNotMalloced() = default;
+
+ ErrorFreeNotMalloced() = default; // (*)
ErrorFreeNotMalloced(u32 tid, BufferedStackTrace *stack, uptr addr)
- : ErrorBase(tid),
+ : ErrorBase(tid, 40, "bad-free"),
free_stack(stack),
- addr_description(addr, /*shouldLockThreadRegistry=*/false) {
- scariness.Clear();
- scariness.Scare(40, "bad-free");
- }
+ addr_description(addr, /*shouldLockThreadRegistry=*/false) {}
void Print();
};
struct ErrorAllocTypeMismatch : ErrorBase {
- // ErrorAllocTypeMismatch doesn't own the stack trace.
const BufferedStackTrace *dealloc_stack;
HeapAddressDescription addr_description;
AllocType alloc_type, dealloc_type;
- // VS2013 doesn't implement unrestricted unions, so we need a trivial default
- // constructor
- ErrorAllocTypeMismatch() = default;
+
+ ErrorAllocTypeMismatch() = default; // (*)
ErrorAllocTypeMismatch(u32 tid, BufferedStackTrace *stack, uptr addr,
AllocType alloc_type_, AllocType dealloc_type_)
- : ErrorBase(tid),
+ : ErrorBase(tid, 10, "alloc-dealloc-mismatch"),
dealloc_stack(stack),
alloc_type(alloc_type_),
dealloc_type(dealloc_type_) {
GetHeapAddressInformation(addr, 1, &addr_description);
- scariness.Clear();
- scariness.Scare(10, "alloc-dealloc-mismatch");
};
void Print();
};
struct ErrorMallocUsableSizeNotOwned : ErrorBase {
- // ErrorMallocUsableSizeNotOwned doesn't own the stack trace.
const BufferedStackTrace *stack;
AddressDescription addr_description;
- // VS2013 doesn't implement unrestricted unions, so we need a trivial default
- // constructor
- ErrorMallocUsableSizeNotOwned() = default;
+
+ ErrorMallocUsableSizeNotOwned() = default; // (*)
ErrorMallocUsableSizeNotOwned(u32 tid, BufferedStackTrace *stack_, uptr addr)
- : ErrorBase(tid),
+ : ErrorBase(tid, 10, "bad-malloc_usable_size"),
stack(stack_),
- addr_description(addr, /*shouldLockThreadRegistry=*/false) {
- scariness.Clear();
- scariness.Scare(10, "bad-malloc_usable_size");
- }
+ addr_description(addr, /*shouldLockThreadRegistry=*/false) {}
void Print();
};
struct ErrorSanitizerGetAllocatedSizeNotOwned : ErrorBase {
- // ErrorSanitizerGetAllocatedSizeNotOwned doesn't own the stack trace.
const BufferedStackTrace *stack;
AddressDescription addr_description;
- // VS2013 doesn't implement unrestricted unions, so we need a trivial default
- // constructor
- ErrorSanitizerGetAllocatedSizeNotOwned() = default;
+
+ ErrorSanitizerGetAllocatedSizeNotOwned() = default; // (*)
ErrorSanitizerGetAllocatedSizeNotOwned(u32 tid, BufferedStackTrace *stack_,
uptr addr)
- : ErrorBase(tid),
+ : ErrorBase(tid, 10, "bad-__sanitizer_get_allocated_size"),
stack(stack_),
- addr_description(addr, /*shouldLockThreadRegistry=*/false) {
- scariness.Clear();
- scariness.Scare(10, "bad-__sanitizer_get_allocated_size");
- }
+ addr_description(addr, /*shouldLockThreadRegistry=*/false) {}
void Print();
};
@@ -172,9 +154,8 @@ struct ErrorCallocOverflow : ErrorBase {
const BufferedStackTrace *stack;
uptr count;
uptr size;
- // VS2013 doesn't implement unrestricted unions, so we need a trivial default
- // constructor
- ErrorCallocOverflow() = default;
+
+ ErrorCallocOverflow() = default; // (*)
ErrorCallocOverflow(u32 tid, BufferedStackTrace *stack_, uptr count_,
uptr size_)
: ErrorBase(tid, 10, "calloc-overflow"),
@@ -187,9 +168,8 @@ struct ErrorCallocOverflow : ErrorBase {
struct ErrorPvallocOverflow : ErrorBase {
const BufferedStackTrace *stack;
uptr size;
- // VS2013 doesn't implement unrestricted unions, so we need a trivial default
- // constructor
- ErrorPvallocOverflow() = default;
+
+ ErrorPvallocOverflow() = default; // (*)
ErrorPvallocOverflow(u32 tid, BufferedStackTrace *stack_, uptr size_)
: ErrorBase(tid, 10, "pvalloc-overflow"),
stack(stack_),
@@ -200,9 +180,8 @@ struct ErrorPvallocOverflow : ErrorBase
struct ErrorInvalidAllocationAlignment : ErrorBase {
const BufferedStackTrace *stack;
uptr alignment;
- // VS2013 doesn't implement unrestricted unions, so we need a trivial default
- // constructor
- ErrorInvalidAllocationAlignment() = default;
+
+ ErrorInvalidAllocationAlignment() = default; // (*)
ErrorInvalidAllocationAlignment(u32 tid, BufferedStackTrace *stack_,
uptr alignment_)
: ErrorBase(tid, 10, "invalid-allocation-alignment"),
@@ -214,9 +193,8 @@ struct ErrorInvalidAllocationAlignment :
struct ErrorInvalidPosixMemalignAlignment : ErrorBase {
const BufferedStackTrace *stack;
uptr alignment;
- // VS2013 doesn't implement unrestricted unions, so we need a trivial default
- // constructor
- ErrorInvalidPosixMemalignAlignment() = default;
+
+ ErrorInvalidPosixMemalignAlignment() = default; // (*)
ErrorInvalidPosixMemalignAlignment(u32 tid, BufferedStackTrace *stack_,
uptr alignment_)
: ErrorBase(tid, 10, "invalid-posix-memalign-alignment"),
@@ -230,9 +208,8 @@ struct ErrorAllocationSizeTooBig : Error
uptr user_size;
uptr total_size;
uptr max_size;
- // VS2013 doesn't implement unrestricted unions, so we need a trivial default
- // constructor
- ErrorAllocationSizeTooBig() = default;
+
+ ErrorAllocationSizeTooBig() = default; // (*)
ErrorAllocationSizeTooBig(u32 tid, BufferedStackTrace *stack_,
uptr user_size_, uptr total_size_, uptr max_size_)
: ErrorBase(tid, 10, "allocation-size-too-big"),
@@ -245,9 +222,8 @@ struct ErrorAllocationSizeTooBig : Error
struct ErrorRssLimitExceeded : ErrorBase {
const BufferedStackTrace *stack;
- // VS2013 doesn't implement unrestricted unions, so we need a trivial default
- // constructor
- ErrorRssLimitExceeded() = default;
+
+ ErrorRssLimitExceeded() = default; // (*)
ErrorRssLimitExceeded(u32 tid, BufferedStackTrace *stack_)
: ErrorBase(tid, 10, "rss-limit-exceeded"),
stack(stack_) {}
@@ -257,9 +233,8 @@ struct ErrorRssLimitExceeded : ErrorBase
struct ErrorOutOfMemory : ErrorBase {
const BufferedStackTrace *stack;
uptr requested_size;
- // VS2013 doesn't implement unrestricted unions, so we need a trivial default
- // constructor
- ErrorOutOfMemory() = default;
+
+ ErrorOutOfMemory() = default; // (*)
ErrorOutOfMemory(u32 tid, BufferedStackTrace *stack_, uptr requested_size_)
: ErrorBase(tid, 10, "out-of-memory"),
stack(stack_),
@@ -268,15 +243,13 @@ struct ErrorOutOfMemory : ErrorBase {
};
struct ErrorStringFunctionMemoryRangesOverlap : ErrorBase {
- // ErrorStringFunctionMemoryRangesOverlap doesn't own the stack trace.
const BufferedStackTrace *stack;
uptr length1, length2;
AddressDescription addr1_description;
AddressDescription addr2_description;
const char *function;
- // VS2013 doesn't implement unrestricted unions, so we need a trivial default
- // constructor
- ErrorStringFunctionMemoryRangesOverlap() = default;
+
+ ErrorStringFunctionMemoryRangesOverlap() = default; // (*)
ErrorStringFunctionMemoryRangesOverlap(u32 tid, BufferedStackTrace *stack_,
uptr addr1, uptr length1_, uptr addr2,
uptr length2_, const char *function_)
@@ -296,65 +269,51 @@ struct ErrorStringFunctionMemoryRangesOv
};
struct ErrorStringFunctionSizeOverflow : ErrorBase {
- // ErrorStringFunctionSizeOverflow doesn't own the stack trace.
const BufferedStackTrace *stack;
AddressDescription addr_description;
uptr size;
- // VS2013 doesn't implement unrestricted unions, so we need a trivial default
- // constructor
- ErrorStringFunctionSizeOverflow() = default;
+
+ ErrorStringFunctionSizeOverflow() = default; // (*)
ErrorStringFunctionSizeOverflow(u32 tid, BufferedStackTrace *stack_,
uptr addr, uptr size_)
- : ErrorBase(tid),
+ : ErrorBase(tid, 10, "negative-size-param"),
stack(stack_),
addr_description(addr, /*shouldLockThreadRegistry=*/false),
- size(size_) {
- scariness.Clear();
- scariness.Scare(10, "negative-size-param");
- }
+ size(size_) {}
void Print();
};
struct ErrorBadParamsToAnnotateContiguousContainer : ErrorBase {
- // ErrorBadParamsToAnnotateContiguousContainer doesn't own the stack trace.
const BufferedStackTrace *stack;
uptr beg, end, old_mid, new_mid;
- // VS2013 doesn't implement unrestricted unions, so we need a trivial default
- // constructor
- ErrorBadParamsToAnnotateContiguousContainer() = default;
+
+ ErrorBadParamsToAnnotateContiguousContainer() = default; // (*)
// PS4: Do we want an AddressDescription for beg?
ErrorBadParamsToAnnotateContiguousContainer(u32 tid,
BufferedStackTrace *stack_,
uptr beg_, uptr end_,
uptr old_mid_, uptr new_mid_)
- : ErrorBase(tid),
+ : ErrorBase(tid, 10, "bad-__sanitizer_annotate_contiguous_container"),
stack(stack_),
beg(beg_),
end(end_),
old_mid(old_mid_),
- new_mid(new_mid_) {
- scariness.Clear();
- scariness.Scare(10, "bad-__sanitizer_annotate_contiguous_container");
- }
+ new_mid(new_mid_) {}
void Print();
};
struct ErrorODRViolation : ErrorBase {
__asan_global global1, global2;
u32 stack_id1, stack_id2;
- // VS2013 doesn't implement unrestricted unions, so we need a trivial default
- // constructor
- ErrorODRViolation() = default;
+
+ ErrorODRViolation() = default; // (*)
ErrorODRViolation(u32 tid, const __asan_global *g1, u32 stack_id1_,
const __asan_global *g2, u32 stack_id2_)
- : ErrorBase(tid),
+ : ErrorBase(tid, 10, "odr-violation"),
global1(*g1),
global2(*g2),
stack_id1(stack_id1_),
- stack_id2(stack_id2_) {
- scariness.Clear();
- scariness.Scare(10, "odr-violation");
- }
+ stack_id2(stack_id2_) {}
void Print();
};
@@ -362,20 +321,16 @@ struct ErrorInvalidPointerPair : ErrorBa
uptr pc, bp, sp;
AddressDescription addr1_description;
AddressDescription addr2_description;
- // VS2013 doesn't implement unrestricted unions, so we need a trivial default
- // constructor
- ErrorInvalidPointerPair() = default;
+
+ ErrorInvalidPointerPair() = default; // (*)
ErrorInvalidPointerPair(u32 tid, uptr pc_, uptr bp_, uptr sp_, uptr p1,
uptr p2)
- : ErrorBase(tid),
+ : ErrorBase(tid, 10, "invalid-pointer-pair"),
pc(pc_),
bp(bp_),
sp(sp_),
addr1_description(p1, 1, /*shouldLockThreadRegistry=*/false),
- addr2_description(p2, 1, /*shouldLockThreadRegistry=*/false) {
- scariness.Clear();
- scariness.Scare(10, "invalid-pointer-pair");
- }
+ addr2_description(p2, 1, /*shouldLockThreadRegistry=*/false) {}
void Print();
};
@@ -386,9 +341,8 @@ struct ErrorGeneric : ErrorBase {
const char *bug_descr;
bool is_write;
u8 shadow_val;
- // VS2013 doesn't implement unrestricted unions, so we need a trivial default
- // constructor
- ErrorGeneric() = default;
+
+ ErrorGeneric() = default; // (*)
ErrorGeneric(u32 tid, uptr addr, uptr pc_, uptr bp_, uptr sp_, bool is_write_,
uptr access_size_);
void Print();
More information about the llvm-commits
mailing list