This is an archive of the discontinued LLVM Phabricator instance.

Differential D132907

[msan] Add more specific messages for use-after-destroy
ClosedPublic

Authored by vitalybuka on Aug 29 2022, 6:56 PM.

Details

Reviewers
eugenis
kda
kstoimenov
Commits
rGc059ede28ea8: [msan] Add more specific messages for use-after-destroy

Diff Detail

Event Timeline

vitalybuka created this revision.Aug 29 2022, 6:56 PM
Herald added a project: Restricted Project. · View Herald TranscriptAug 29 2022, 6:56 PM
Herald added a subscriber: Enna1. · View Herald Transcript
vitalybuka requested review of this revision.Aug 29 2022, 6:56 PM
Herald added projects: Restricted Project, Restricted Project. · View Herald TranscriptAug 29 2022, 6:56 PM
Herald added subscribers: Restricted Project, cfe-commits. · View Herald Transcript
Harbormaster completed remote builds in B184054: Diff 456517.Aug 29 2022, 7:36 PM
vitalybuka mentioned this in D132909: [msan] Use Debug Info to point to affected fields.Aug 29 2022, 8:25 PM
vitalybuka added a child revision: D132909: [msan] Use Debug Info to point to affected fields.Aug 29 2022, 8:25 PM
vitalybuka added reviewers: eugenis, kda, kstoimenov.
vitalybuka updated this revision to Diff 456540.Aug 29 2022, 8:54 PM

rebase

Harbormaster completed remote builds in B184072: Diff 456540.Aug 29 2022, 9:42 PM
kstoimenov accepted this revision.Aug 30 2022, 3:14 PM
kstoimenov added inline comments.
clang/lib/CodeGen/CGClass.cpp
1773–1774

Should this be a constant?

This revision is now accepted and ready to land.Aug 30 2022, 3:14 PM
kda accepted this revision.Aug 30 2022, 3:30 PM
vitalybuka added inline comments.Aug 30 2022, 7:52 PM
clang/lib/CodeGen/CGClass.cpp
1773–1774

it would be nice if we can share constants with runtime, but as is clang/compiler-rt do not include each other
without reuse I don't see a point in named constant.

Closed by commit rGc059ede28ea8: [msan] Add more specific messages for use-after-destroy (authored by vitalybuka). · Explain WhyAug 30 2022, 7:52 PM
This revision was automatically updated to reflect the committed changes.
vitalybuka added a commit: rGc059ede28ea8: [msan] Add more specific messages for use-after-destroy.

Revision Contents

Diff 456517

clang/lib/CodeGen/CGClass.cpp

Show First 20 Lines • Show All 1,643 Lines • ▼ Show 20 Lines void Emit(CodeGenFunction &CGF, Flags flags) override {
LValue LV = CGF.EmitLValueForField(ThisLV, field); LValue LV = CGF.EmitLValueForField(ThisLV, field);
assert(LV.isSimple()); assert(LV.isSimple());
CGF.emitDestroy(LV.getAddress(CGF), field->getType(), destroyer, CGF.emitDestroy(LV.getAddress(CGF), field->getType(), destroyer,
flags.isForNormalCleanup() && useEHCleanupForArray); flags.isForNormalCleanup() && useEHCleanupForArray);
} }
}; };
static void EmitSanitizerDtorCallback(CodeGenFunction &CGF, llvm::Value *Ptr, static void EmitSanitizerDtorCallback(
CharUnits::QuantityType PoisonSize) { CodeGenFunction &CGF, StringRef Name, llvm::Value *Ptr,
llvm::Optional<CharUnits::QuantityType> PoisonSize = {}) {
CodeGenFunction::SanitizerScope SanScope(&CGF); CodeGenFunction::SanitizerScope SanScope(&CGF);
// Pass in void pointer and size of region as arguments to runtime // Pass in void pointer and size of region as arguments to runtime
// function // function
llvm::Value *Args[] = {CGF.Builder.CreateBitCast(Ptr, CGF.VoidPtrTy), SmallVector<llvm::Value *, 2> Args = {
llvm::ConstantInt::get(CGF.SizeTy, PoisonSize)}; CGF.Builder.CreateBitCast(Ptr, CGF.VoidPtrTy)};
SmallVector<llvm::Type *, 2> ArgTypes = {CGF.VoidPtrTy};
llvm::Type *ArgTypes[] = {CGF.VoidPtrTy, CGF.SizeTy};
if (PoisonSize.has_value()) {
Args.emplace_back(llvm::ConstantInt::get(CGF.SizeTy, *PoisonSize));
ArgTypes.emplace_back(CGF.SizeTy);
}
llvm::FunctionType *FnType = llvm::FunctionType *FnType =
llvm::FunctionType::get(CGF.VoidTy, ArgTypes, false); llvm::FunctionType::get(CGF.VoidTy, ArgTypes, false);
llvm::FunctionCallee Fn = llvm::FunctionCallee Fn = CGF.CGM.CreateRuntimeFunction(FnType, Name);
CGF.CGM.CreateRuntimeFunction(FnType, "__sanitizer_dtor_callback");
CGF.EmitNounwindRuntimeCall(Fn, Args); CGF.EmitNounwindRuntimeCall(Fn, Args);
} }
static void
EmitSanitizerDtorFieldsCallback(CodeGenFunction &CGF, llvm::Value *Ptr,
CharUnits::QuantityType PoisonSize) {
EmitSanitizerDtorCallback(CGF, "__sanitizer_dtor_callback_fields", Ptr,
PoisonSize);
}
/// Poison base class with a trivial destructor. /// Poison base class with a trivial destructor.
struct SanitizeDtorTrivialBase final : EHScopeStack::Cleanup { struct SanitizeDtorTrivialBase final : EHScopeStack::Cleanup {
const CXXRecordDecl *BaseClass; const CXXRecordDecl *BaseClass;
bool BaseIsVirtual; bool BaseIsVirtual;
SanitizeDtorTrivialBase(const CXXRecordDecl *Base, bool BaseIsVirtual) SanitizeDtorTrivialBase(const CXXRecordDecl *Base, bool BaseIsVirtual)
: BaseClass(Base), BaseIsVirtual(BaseIsVirtual) {} : BaseClass(Base), BaseIsVirtual(BaseIsVirtual) {}
void Emit(CodeGenFunction &CGF, Flags flags) override { void Emit(CodeGenFunction &CGF, Flags flags) override {
const CXXRecordDecl *DerivedClass = const CXXRecordDecl *DerivedClass =
cast<CXXMethodDecl>(CGF.CurCodeDecl)->getParent(); cast<CXXMethodDecl>(CGF.CurCodeDecl)->getParent();
Address Addr = CGF.GetAddressOfDirectBaseInCompleteClass( Address Addr = CGF.GetAddressOfDirectBaseInCompleteClass(
CGF.LoadCXXThisAddress(), DerivedClass, BaseClass, BaseIsVirtual); CGF.LoadCXXThisAddress(), DerivedClass, BaseClass, BaseIsVirtual);
const ASTRecordLayout &BaseLayout = const ASTRecordLayout &BaseLayout =
CGF.getContext().getASTRecordLayout(BaseClass); CGF.getContext().getASTRecordLayout(BaseClass);
CharUnits BaseSize = BaseLayout.getSize(); CharUnits BaseSize = BaseLayout.getSize();
if (!BaseSize.isPositive()) if (!BaseSize.isPositive())
return; return;
EmitSanitizerDtorCallback(CGF, Addr.getPointer(), BaseSize.getQuantity()); EmitSanitizerDtorFieldsCallback(CGF, Addr.getPointer(),
BaseSize.getQuantity());
// Prevent the current stack frame from disappearing from the stack trace. // Prevent the current stack frame from disappearing from the stack trace.
CGF.CurFn->addFnAttr("disable-tail-calls", "true"); CGF.CurFn->addFnAttr("disable-tail-calls", "true");
} }
}; };
class SanitizeDtorFieldRange final : public EHScopeStack::Cleanup { class SanitizeDtorFieldRange final : public EHScopeStack::Cleanup {
const CXXDestructorDecl *Dtor; const CXXDestructorDecl *Dtor;
Show All 31 Lines void Emit(CodeGenFunction &CGF, Flags flags) override {
} else { } else {
PoisonEnd = PoisonEnd =
Context.toCharUnitsFromBits(Layout.getFieldOffset(EndIndex)); Context.toCharUnitsFromBits(Layout.getFieldOffset(EndIndex));
} }
CharUnits PoisonSize = PoisonEnd - PoisonStart; CharUnits PoisonSize = PoisonEnd - PoisonStart;
if (!PoisonSize.isPositive()) if (!PoisonSize.isPositive())
return; return;
EmitSanitizerDtorCallback(CGF, OffsetPtr, PoisonSize.getQuantity()); EmitSanitizerDtorFieldsCallback(CGF, OffsetPtr, PoisonSize.getQuantity());
// Prevent the current stack frame from disappearing from the stack trace. // Prevent the current stack frame from disappearing from the stack trace.
CGF.CurFn->addFnAttr("disable-tail-calls", "true"); CGF.CurFn->addFnAttr("disable-tail-calls", "true");
} }
}; };
class SanitizeDtorVTable final : public EHScopeStack::Cleanup { class SanitizeDtorVTable final : public EHScopeStack::Cleanup {
const CXXDestructorDecl *Dtor; const CXXDestructorDecl *Dtor;
public: public:
SanitizeDtorVTable(const CXXDestructorDecl *Dtor) : Dtor(Dtor) {} SanitizeDtorVTable(const CXXDestructorDecl *Dtor) : Dtor(Dtor) {}
// Generate function call for handling vtable pointer poisoning. // Generate function call for handling vtable pointer poisoning.
void Emit(CodeGenFunction &CGF, Flags flags) override { void Emit(CodeGenFunction &CGF, Flags flags) override {
assert(Dtor->getParent()->isDynamicClass()); assert(Dtor->getParent()->isDynamicClass());
(void)Dtor; (void)Dtor;
ASTContext &Context = CGF.getContext();
// Poison vtable and vtable ptr if they exist for this class. // Poison vtable and vtable ptr if they exist for this class.
llvm::Value *VTablePtr = CGF.LoadCXXThis(); llvm::Value *VTablePtr = CGF.LoadCXXThis();
CharUnits::QuantityType PoisonSize =
Context.toCharUnitsFromBits(CGF.PointerWidthInBits).getQuantity();
// Pass in void pointer and size of region as arguments to runtime // Pass in void pointer and size of region as arguments to runtime
// function // function
EmitSanitizerDtorCallback(CGF, VTablePtr, PoisonSize); EmitSanitizerDtorCallback(CGF, "__sanitizer_dtor_callback_vptr",
VTablePtr);
kstoimenovUnsubmitted
Not Done
ReplyInline Actions

Should this be a constant?

kstoimenov: Should this be a constant?
vitalybukaAuthorUnsubmitted
Done
ReplyInline Actions

it would be nice if we can share constants with runtime, but as is clang/compiler-rt do not include each other
without reuse I don't see a point in named constant.

vitalybuka: it would be nice if we can share constants with runtime, but as is clang/compiler-rt do not…
} }
}; };
class SanitizeDtorCleanupBuilder { class SanitizeDtorCleanupBuilder {
ASTContext &Context; ASTContext &Context;
EHScopeStack &EHStack; EHScopeStack &EHStack;
const CXXDestructorDecl *DD; const CXXDestructorDecl *DD;
llvm::Optional<unsigned> StartIndex; llvm::Optional<unsigned> StartIndex;
▲ Show 20 Lines • Show All 1,235 Lines • Show Last 20 Lines

clang/test/CodeGenCXX/sanitize-dtor-bit-field.cpp

Show First 20 Lines • Show All 57 Lines • ▼ Show 20 Linesstruct Adjacent {
CharStruct a; CharStruct a;
int b : 1; int b : 1;
CharStruct c; CharStruct c;
~Adjacent() {} ~Adjacent() {}
}; };
Adjacent ad; Adjacent ad;
// CHECK-LABEL: define {{.*}}PackedD2Ev // CHECK-LABEL: define {{.*}}PackedD2Ev
// CHECK: call void @__sanitizer_dtor_callback({{.*}}i64 17{{.*}}, !dbg ![[DI1:[0-9]+]] // CHECK: call void @__sanitizer_dtor_callback_fields({{.*}}i64 17{{.*}}, !dbg ![[DI1:[0-9]+]]
// CHECK: ret void // CHECK: ret void
// CHECK-LABEL: define {{.*}}EmptyD2Ev // CHECK-LABEL: define {{.*}}EmptyD2Ev
// CHECK: ret void // CHECK: ret void
// CHECK-LABEL: define {{.*}}SimpleD2Ev // CHECK-LABEL: define {{.*}}SimpleD2Ev
// CHECK: call void @__sanitizer_dtor_callback({{.*}}i64 1{{.*}}, !dbg ![[DI2:[0-9]+]] // CHECK: call void @__sanitizer_dtor_callback_fields({{.*}}i64 1{{.*}}, !dbg ![[DI2:[0-9]+]]
// CHECK: ret void // CHECK: ret void
// CHECK-LABEL: define {{.*}}AnonD2Ev // CHECK-LABEL: define {{.*}}AnonD2Ev
// CHECK: call void @__sanitizer_dtor_callback({{.*}}i64 5{{.*}}, !dbg ![[DI3:[0-9]+]] // CHECK: call void @__sanitizer_dtor_callback_fields({{.*}}i64 5{{.*}}, !dbg ![[DI3:[0-9]+]]
// CHECK: ret void // CHECK: ret void
// CHECK-LABEL: define {{.*}}AdjacentD2Ev // CHECK-LABEL: define {{.*}}AdjacentD2Ev
// CHECK: call void @__sanitizer_dtor_callback({{.*}}i64 1{{.*}}, !dbg ![[DI4:[0-9]+]] // CHECK: call void @__sanitizer_dtor_callback_fields({{.*}}i64 1{{.*}}, !dbg ![[DI4:[0-9]+]]
// CHECK: ret void // CHECK: ret void
// CHECK-LABEL: !DIFile{{.*}}cpp // CHECK-LABEL: !DIFile{{.*}}cpp
// CHECK: ![[DI1]] = {{.*}}line: [[@LINE-68]] // CHECK: ![[DI1]] = {{.*}}line: [[@LINE-68]]
// CHECK: ![[DI2]] = {{.*}}line: [[@LINE-53]] // CHECK: ![[DI2]] = {{.*}}line: [[@LINE-53]]
// CHECK: ![[DI3]] = {{.*}}line: [[@LINE-41]] // CHECK: ![[DI3]] = {{.*}}line: [[@LINE-41]]
// CHECK: ![[DI4]] = {{.*}}line: [[@LINE-28]] // CHECK: ![[DI4]] = {{.*}}line: [[@LINE-28]]

clang/test/CodeGenCXX/sanitize-dtor-callback.cpp

Show First 20 Lines • Show All 50 Lines • ▼ Show 20 Lines
// Note: ordering is important. In the emitted bytecode, these // Note: ordering is important. In the emitted bytecode, these
// second dtors defined after the first. Explicitly checked here // second dtors defined after the first. Explicitly checked here
// to confirm that all invoked dtors have member poisoning // to confirm that all invoked dtors have member poisoning
// instrumentation inserted. // instrumentation inserted.
// CHECK-LABEL: define {{.*}}SimpleD2Ev // CHECK-LABEL: define {{.*}}SimpleD2Ev
// CHECK-NOT: store i{{[0-9]+}} 0, {{.*}}@__msan_param_tls // CHECK-NOT: store i{{[0-9]+}} 0, {{.*}}@__msan_param_tls
// CHECK: call void @__sanitizer_dtor_callback({{.*}}, !dbg ![[DI1:[0-9]+]] // CHECK: call void @__sanitizer_dtor_callback_fields({{.*}}, !dbg ![[DI1:[0-9]+]]
// CHECK: ret void // CHECK: ret void
// CHECK-LABEL: define {{.*}}InlinedD2Ev // CHECK-LABEL: define {{.*}}InlinedD2Ev
// CHECK-NOT: store i{{[0-9]+}} 0, {{.*}}@__msan_param_tls // CHECK-NOT: store i{{[0-9]+}} 0, {{.*}}@__msan_param_tls
// CHECK: call void @__sanitizer_dtor_callback({{.*}}, !dbg ![[DI2:[0-9]+]] // CHECK: call void @__sanitizer_dtor_callback_fields({{.*}}, !dbg ![[DI2:[0-9]+]]
// CHECK: ret void // CHECK: ret void
// CHECK-LABEL: define {{.*}}Defaulted_Non_TrivialD2Ev // CHECK-LABEL: define {{.*}}Defaulted_Non_TrivialD2Ev
// CHECK: call void @__sanitizer_dtor_callback({{.*}}, !dbg ![[DI3:[0-9]+]] // CHECK: call void @__sanitizer_dtor_callback_fields({{.*}}, !dbg ![[DI3:[0-9]+]]
// CHECK: ret void // CHECK: ret void
// CHECK-LABEL: !DIFile{{.*}}cpp // CHECK-LABEL: !DIFile{{.*}}cpp
// CHECK: ![[DI1]] = {{.*}}line: [[@LINE-64]] // CHECK: ![[DI1]] = {{.*}}line: [[@LINE-64]]
// CHECK: ![[DI2]] = {{.*}}line: [[@LINE-55]] // CHECK: ![[DI2]] = {{.*}}line: [[@LINE-55]]
// CHECK: ![[DI3]] = {{.*}}line: [[@LINE-33]] // CHECK: ![[DI3]] = {{.*}}line: [[@LINE-33]]

clang/test/CodeGenCXX/sanitize-dtor-derived-class.cpp

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 Lines
// CHECK: ret void // CHECK: ret void
// CHECK-LABEL: define {{.*}}BaseD0Ev // CHECK-LABEL: define {{.*}}BaseD0Ev
// CHECK: call void {{.*}}BaseD1Ev // CHECK: call void {{.*}}BaseD1Ev
// CHECK: ret void // CHECK: ret void
// Poison members and vtable ptr. // Poison members and vtable ptr.
// CHECK-LABEL: define {{.*}}BaseD2Ev // CHECK-LABEL: define {{.*}}BaseD2Ev
// CHECK: call void @__sanitizer_dtor_callback({{.*}}, !dbg ![[DI1:[0-9]+]] // CHECK: call void @__sanitizer_dtor_callback_fields({{.*}}, !dbg ![[DI1:[0-9]+]]
// CHECK: call void @__sanitizer_dtor_callback({{.*}}i64 8{{.*}}, !dbg ![[DI1]] // CHECK: call void @__sanitizer_dtor_callback_vptr({{.*}}){{.*}}, !dbg ![[DI1]]
// CHECK: ret void // CHECK: ret void
// Poison members and destroy non-virtual base. // Poison members and destroy non-virtual base.
// CHECK-LABEL: define {{.*}}DerivedD2Ev // CHECK-LABEL: define {{.*}}DerivedD2Ev
// CHECK: call void @__sanitizer_dtor_callback({{.*}}, !dbg ![[DI3:[0-9]+]] // CHECK: call void @__sanitizer_dtor_callback_fields({{.*}}, !dbg ![[DI3:[0-9]+]]
// CHECK: call void {{.*}}BaseD2Ev // CHECK: call void {{.*}}BaseD2Ev
// CHECK: call void @__sanitizer_dtor_callback({{.*}}i64 8{{.*}}, !dbg ![[DI3]] // CHECK: call void @__sanitizer_dtor_callback_vptr({{.*}}){{.*}}, !dbg ![[DI3]]
// CHECK: ret void // CHECK: ret void
// CHECK-LABEL: !DIFile{{.*}}cpp // CHECK-LABEL: !DIFile{{.*}}cpp
// CHECK: ![[DI1]] = {{.*}}line: [[@LINE-49]] // CHECK: ![[DI1]] = {{.*}}line: [[@LINE-49]]
// CHECK: ![[DI3]] = {{.*}}line: [[@LINE-39]] // CHECK: ![[DI3]] = {{.*}}line: [[@LINE-39]]

clang/test/CodeGenCXX/sanitize-dtor-nontrivial-virtual-base.cpp

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Lines
Derived d; Derived d;
// Destruction order: // Destruction order:
// Derived: int, Vector, Base, VirtualBase // Derived: int, Vector, Base, VirtualBase
// CHECK-LABEL: define {{.*}}ZN7DerivedD1Ev // CHECK-LABEL: define {{.*}}ZN7DerivedD1Ev
// CHECK: call void {{.*}}ZN11VirtualBaseD2Ev // CHECK: call void {{.*}}ZN11VirtualBaseD2Ev
// CHECK: call void @__sanitizer_dtor_callback({{.*}}){{.*}}, !dbg ![[DI0:[0-9]+]] // CHECK: call void @__sanitizer_dtor_callback_vptr({{.*}}){{.*}}, !dbg ![[DI0:[0-9]+]]
// CHECK: ret void // CHECK: ret void
// CHECK-LABEL: define {{.*}}ZN7DerivedD0Ev // CHECK-LABEL: define {{.*}}ZN7DerivedD0Ev
// CHECK: ret void // CHECK: ret void
// CHECK-LABEL: define {{.*}}ZN11VirtualBaseD1Ev // CHECK-LABEL: define {{.*}}ZN11VirtualBaseD1Ev
// CHECK: ret void // CHECK: ret void
// CHECK-LABEL: define {{.*}}ZN11VirtualBaseD0Ev // CHECK-LABEL: define {{.*}}ZN11VirtualBaseD0Ev
// CHECK: ret void // CHECK: ret void
// poison 2 ints // poison 2 ints
// CHECK-LABEL: define {{.*}}ZN11VirtualBaseD2Ev // CHECK-LABEL: define {{.*}}ZN11VirtualBaseD2Ev
// CHECK: call void @__sanitizer_dtor_callback({{.*}}, i64 8){{.*}}, !dbg ![[DI1:[0-9]+]] // CHECK: call void @__sanitizer_dtor_callback_fields({{.*}}, i64 8){{.*}}, !dbg ![[DI1:[0-9]+]]
// CHECK: call void @__sanitizer_dtor_callback({{.*}}, i64 8) // CHECK: call void @__sanitizer_dtor_callback_vptr({{.*}}){{.*}}, !dbg ![[DI1]]
// CHECK: ret void // CHECK: ret void
// poison int and double // poison int and double
// CHECK-LABEL: define {{.*}}ZN4BaseD2Ev // CHECK-LABEL: define {{.*}}ZN4BaseD2Ev
// CHECK: call void @__sanitizer_dtor_callback({{.*}}{{.*}}, !dbg ![[DI2:[0-9]+]] // CHECK: call void @__sanitizer_dtor_callback_fields({{.*}}, i64 16){{.*}}, !dbg ![[DI2:[0-9]+]]
// CHECK: call void @__sanitizer_dtor_callback({{.*}}, i64 8) // CHECK: call void @__sanitizer_dtor_callback_vptr({{.*}}{{.*}}, !dbg ![[DI2]]
// CHECK: ret void // CHECK: ret void
// poison int, ignore vector, poison int // poison int, ignore vector, poison int
// CHECK-LABEL: define {{.*}}ZN7DerivedD2Ev // CHECK-LABEL: define {{.*}}ZN7DerivedD2Ev
// CHECK: call void @__sanitizer_dtor_callback({{.*}}, i64 4){{.*}}, !dbg ![[DI3:[0-9]+]] // CHECK: call void @__sanitizer_dtor_callback_fields({{.*}}, i64 4){{.*}}, !dbg ![[DI3:[0-9]+]]
// CHECK: call void {{.*}}ZN6VectorIiED1Ev // CHECK: call void {{.*}}ZN6VectorIiED1Ev
// CHECK: call void @__sanitizer_dtor_callback({{.*}}, i64 4){{.*}}, !dbg ![[DI3]] // CHECK: call void @__sanitizer_dtor_callback_fields({{.*}}, i64 4){{.*}}, !dbg ![[DI3]]
// CHECK: call void {{.*}}ZN4BaseD2Ev // CHECK: call void {{.*}}ZN4BaseD2Ev
// CHECK: ret void // CHECK: ret void
// poison int // poison int
// CHECK-LABEL: define {{.*}}ZN6VectorIiED2Ev // CHECK-LABEL: define {{.*}}ZN6VectorIiED2Ev
// CHECK: call void @__sanitizer_dtor_callback({{.*}}, i64 4){{.*}}, !dbg ![[DI5:[0-9]+]] // CHECK: call void @__sanitizer_dtor_callback_fields({{.*}}, i64 4){{.*}}, !dbg ![[DI5:[0-9]+]]
// CHECK: ret void // CHECK: ret void
// CHECK-LABEL: !DIFile{{.*}}.cpp // CHECK-LABEL: !DIFile{{.*}}.cpp
// CHECK: ![[DI0]] = {{.*}}line: [[@LINE-49]] // CHECK: ![[DI0]] = {{.*}}line: [[@LINE-49]]
// CHECK: ![[DI1]] = {{.*}}line: [[@LINE-60]] // CHECK: ![[DI1]] = {{.*}}line: [[@LINE-60]]
// CHECK: ![[DI2]] = {{.*}}line: [[@LINE-71]] // CHECK: ![[DI2]] = {{.*}}line: [[@LINE-71]]
// CHECK: ![[DI3]] = {{.*}}line: [[@LINE-52]] // CHECK: ![[DI3]] = {{.*}}line: [[@LINE-52]]
// CHECK: ![[DI5]] = {{.*}}line: [[@LINE-83]] // CHECK: ![[DI5]] = {{.*}}line: [[@LINE-83]]

clang/test/CodeGenCXX/sanitize-dtor-tail-call.cpp

Show All 9 Linesstruct Simple {
~Simple() { ~Simple() {
x_ += 1; x_ += 1;
} }
}; };
Simple s; Simple s;
// Simple internal member is poisoned by compiler-generated dtor // Simple internal member is poisoned by compiler-generated dtor
// CHECK: define {{.*}}SimpleD2Ev{{.*}} [[ATTRIBUTE:#[0-9]+]] // CHECK: define {{.*}}SimpleD2Ev{{.*}} [[ATTRIBUTE:#[0-9]+]]
// CHECK: {{^ *}}call void @__sanitizer_dtor_callback( // CHECK: call void @__sanitizer_dtor_callback_fields(
// CHECK: ret void // CHECK: ret void
// Destructor does not emit any tail calls // Destructor does not emit any tail calls
// CHECK: attributes [[ATTRIBUTE]] = {{.*}}"disable-tail-calls"="true" // CHECK: attributes [[ATTRIBUTE]] = {{.*}}"disable-tail-calls"="true"

clang/test/CodeGenCXX/sanitize-dtor-trivial-base.cpp

Show All 14 Linespublic:
} }
}; };
Derived d; Derived d;
// Poison members, then poison the trivial base class. // Poison members, then poison the trivial base class.
// CHECK-LABEL: define {{.*}}DerivedD2Ev // CHECK-LABEL: define {{.*}}DerivedD2Ev
// CHECK: %[[GEP:[0-9a-z]+]] = getelementptr i8, i8* {{.*}}, i64 16 // CHECK: %[[GEP:[0-9a-z]+]] = getelementptr i8, i8* {{.*}}, i64 16
// CHECK: call void @__sanitizer_dtor_callback({{.*}}%[[GEP]], i64 4{{.*}}, !dbg ![[DI:[0-9]+]] // CHECK: call void @__sanitizer_dtor_callback_fields({{.*}}%[[GEP]], i64 4{{.*}}, !dbg ![[DI:[0-9]+]]
// CHECK: call void @__sanitizer_dtor_callback({{.*}}, i64 16{{.*}}, !dbg ![[DI]] // CHECK: call void @__sanitizer_dtor_callback_fields({{.*}}, i64 16{{.*}}, !dbg ![[DI]]
// CHECK: ret void // CHECK: ret void
// CHECK-LABEL: !DIFile{{.*}}cpp // CHECK-LABEL: !DIFile{{.*}}cpp
// CHECK: ![[DI]] = {{.*}}line: [[@LINE-14]] // CHECK: ![[DI]] = {{.*}}line: [[@LINE-14]]

clang/test/CodeGenCXX/sanitize-dtor-vtable.cpp

Show All 19 Lines
// CHECK-LABEL: define {{.*}}AD1Ev // CHECK-LABEL: define {{.*}}AD1Ev
// CHECK: call void {{.*}}AD2Ev // CHECK: call void {{.*}}AD2Ev
// CHECK: ret void // CHECK: ret void
// After invoking base dtor and dtor for virtual base, poison vtable ptr. // After invoking base dtor and dtor for virtual base, poison vtable ptr.
// CHECK-LABEL: define {{.*}}BD1Ev // CHECK-LABEL: define {{.*}}BD1Ev
// CHECK: call void {{.*}}BD2Ev // CHECK: call void {{.*}}BD2Ev
// CHECK: call void {{.*}}AD2Ev // CHECK: call void {{.*}}AD2Ev
// CHECK: call void @__sanitizer_dtor_callback({{.*}}, !dbg ![[DI1:[0-9]+]] // CHECK: call void @__sanitizer_dtor_callback_vptr({{.*}}, !dbg ![[DI1:[0-9]+]]
// CHECK: ret void // CHECK: ret void
// Since no virtual bases, poison vtable ptr here. // Since no virtual bases, poison vtable ptr here.
// CHECK-LABEL: define {{.*}}AD2Ev // CHECK-LABEL: define {{.*}}AD2Ev
// CHECK: call void @__sanitizer_dtor_callback({{.*}}, !dbg ![[DI2:[0-9]+]] // CHECK: call void @__sanitizer_dtor_callback_fields({{.*}}, !dbg ![[DI2:[0-9]+]]
// CHECK: call void @__sanitizer_dtor_callback({{.*}}, !dbg ![[DI2]] // CHECK: call void @__sanitizer_dtor_callback_vptr({{.*}}, !dbg ![[DI2]]
// CHECK: ret void // CHECK: ret void
// Poison members // Poison members
// CHECK-LABEL: define {{.*}}BD2Ev // CHECK-LABEL: define {{.*}}BD2Ev
// CHECK: call void @__sanitizer_dtor_callback({{.*}}, !dbg ![[DI4:[0-9]+]] // CHECK: call void @__sanitizer_dtor_callback_fields({{.*}}, !dbg ![[DI4:[0-9]+]]
// CHECK: ret void // CHECK: ret void
// CHECK-LABEL: !DIFile{{.*}}cpp // CHECK-LABEL: !DIFile{{.*}}cpp
// CHECK: ![[DI1]] = {{.*}}line: [[@LINE-28]] // CHECK: ![[DI1]] = {{.*}}line: [[@LINE-28]]
// CHECK: ![[DI2]] = {{.*}}line: [[@LINE-37]] // CHECK: ![[DI2]] = {{.*}}line: [[@LINE-37]]
// CHECK: ![[DI4]] = {{.*}}line: [[@LINE-30]] // CHECK: ![[DI4]] = {{.*}}line: [[@LINE-30]]

clang/test/CodeGenCXX/sanitize-dtor-zero-size-field.cpp

// RUN: %clang_cc1 -no-opaque-pointers -O0 -fsanitize=memory -fsanitize-memory-use-after-dtor -disable-llvm-passes -std=c++20 -triple=x86_64-pc-linux -emit-llvm -o - %s | FileCheck %s --implicit-check-not "call void @__sanitizer_dtor_callback" // RUN: %clang_cc1 -no-opaque-pointers -O0 -fsanitize=memory -fsanitize-memory-use-after-dtor -disable-llvm-passes -std=c++20 -triple=x86_64-pc-linux -emit-llvm -o - %s | FileCheck %s --implicit-check-not "call void @__sanitizer_dtor_callback_fields"
// RUN: %clang_cc1 -no-opaque-pointers -O1 -fsanitize=memory -fsanitize-memory-use-after-dtor -disable-llvm-passes -std=c++20 -triple=x86_64-pc-linux -emit-llvm -o - %s | FileCheck %s --implicit-check-not "call void @__sanitizer_dtor_callback" // RUN: %clang_cc1 -no-opaque-pointers -O1 -fsanitize=memory -fsanitize-memory-use-after-dtor -disable-llvm-passes -std=c++20 -triple=x86_64-pc-linux -emit-llvm -o - %s | FileCheck %s --implicit-check-not "call void @__sanitizer_dtor_callback_fields"
struct Empty {}; struct Empty {};
struct EmptyNonTrivial { struct EmptyNonTrivial {
~EmptyNonTrivial(); ~EmptyNonTrivial();
}; };
struct Trivial { struct Trivial {
Show All 14 Linesstruct Struct {
Trivial f1; Trivial f1;
int f2; int f2;
char f3; char f3;
~Struct(){}; ~Struct(){};
} var; } var;
static_assert(sizeof(Struct) == 16); static_assert(sizeof(Struct) == 16);
} // namespace T0 } // namespace T0
// CHECK-LABEL: define {{.*}} @_ZN2T06StructD2Ev( // CHECK-LABEL: define {{.*}} @_ZN2T06StructD2Ev(
// CHECK: call void @__sanitizer_dtor_callback(i8* {{.*}}, i64 13) // CHECK: call void @__sanitizer_dtor_callback_fields(i8* {{.*}}, i64 13)
// CHECK-NEXT: ret void // CHECK-NEXT: ret void
namespace empty { namespace empty {
namespace T1 { namespace T1 {
struct Struct { struct Struct {
NonTrivial nt; NonTrivial nt;
Trivial f1; Trivial f1;
int f2; int f2;
char f3; char f3;
} var; } var;
static_assert(sizeof(Struct) == 24); static_assert(sizeof(Struct) == 24);
} // namespace T1 } // namespace T1
// CHECK-LABEL: define {{.*}} @_ZN5empty2T16StructD2Ev( // CHECK-LABEL: define {{.*}} @_ZN5empty2T16StructD2Ev(
// CHECK: [[GEP:%.+]] = getelementptr i8, {{.*}}, i64 8{{$}} // CHECK: [[GEP:%.+]] = getelementptr i8, {{.*}}, i64 8{{$}}
// CHECK: call void @__sanitizer_dtor_callback(i8* [[GEP]], i64 13) // CHECK: call void @__sanitizer_dtor_callback_fields(i8* [[GEP]], i64 13)
// CHECK: call void @_ZN10NonTrivialD1Ev( // CHECK: call void @_ZN10NonTrivialD1Ev(
// CHECK-NEXT: ret void // CHECK-NEXT: ret void
namespace T2 { namespace T2 {
struct Struct { struct Struct {
Trivial f1; Trivial f1;
NonTrivial nt; NonTrivial nt;
int f2; int f2;
char f3; char f3;
} var; } var;
static_assert(sizeof(Struct) == 24); static_assert(sizeof(Struct) == 24);
} // namespace T2 } // namespace T2
// CHECK-LABEL: define {{.*}} @_ZN5empty2T26StructD2Ev( // CHECK-LABEL: define {{.*}} @_ZN5empty2T26StructD2Ev(
// CHECK: [[GEP1:%.+]] = getelementptr i8, {{.*}}, i64 16{{$}} // CHECK: [[GEP1:%.+]] = getelementptr i8, {{.*}}, i64 16{{$}}
// CHECK: call void @__sanitizer_dtor_callback(i8* [[GEP1]], i64 5) // CHECK: call void @__sanitizer_dtor_callback_fields(i8* [[GEP1]], i64 5)
// CHECK: call void @_ZN10NonTrivialD1Ev( // CHECK: call void @_ZN10NonTrivialD1Ev(
// CHECK: [[GEP2:%.+]] = getelementptr i8, {{.*}}, i64 0{{$}} // CHECK: [[GEP2:%.+]] = getelementptr i8, {{.*}}, i64 0{{$}}
// CHECK: call void @__sanitizer_dtor_callback(i8* [[GEP2]], i64 8) // CHECK: call void @__sanitizer_dtor_callback_fields(i8* [[GEP2]], i64 8)
// CHECK-NEXT: ret void // CHECK-NEXT: ret void
namespace T3 { namespace T3 {
struct Struct { struct Struct {
Trivial f1; Trivial f1;
int f2; int f2;
NonTrivial nt; NonTrivial nt;
char f3; char f3;
} var; } var;
static_assert(sizeof(Struct) == 24); static_assert(sizeof(Struct) == 24);
} // namespace T3 } // namespace T3
// CHECK-LABEL: define {{.*}} @_ZN5empty2T36StructD2Ev( // CHECK-LABEL: define {{.*}} @_ZN5empty2T36StructD2Ev(
// CHECK: [[GEP1:%.+]] = getelementptr i8, {{.*}}, i64 20{{$}} // CHECK: [[GEP1:%.+]] = getelementptr i8, {{.*}}, i64 20{{$}}
// CHECK: call void @__sanitizer_dtor_callback(i8* [[GEP1]], i64 1) // CHECK: call void @__sanitizer_dtor_callback_fields(i8* [[GEP1]], i64 1)
// CHECK: call void @_ZN10NonTrivialD1Ev( // CHECK: call void @_ZN10NonTrivialD1Ev(
// CHECK: [[GEP2:%.+]] = getelementptr i8, {{.*}}, i64 0{{$}} // CHECK: [[GEP2:%.+]] = getelementptr i8, {{.*}}, i64 0{{$}}
// CHECK: call void @__sanitizer_dtor_callback(i8* [[GEP2]], i64 12) // CHECK: call void @__sanitizer_dtor_callback_fields(i8* [[GEP2]], i64 12)
// CHECK-NEXT: ret void // CHECK-NEXT: ret void
namespace T4 { namespace T4 {
struct Struct { struct Struct {
Trivial f1; Trivial f1;
int f2; int f2;
char f3; char f3;
NonTrivial nt; NonTrivial nt;
} var; } var;
static_assert(sizeof(Struct) == 24); static_assert(sizeof(Struct) == 24);
} // namespace T4 } // namespace T4
// CHECK-LABEL: define {{.*}} @_ZN5empty2T46StructD2Ev( // CHECK-LABEL: define {{.*}} @_ZN5empty2T46StructD2Ev(
// CHECK: call void @__sanitizer_dtor_callback(i8* {{.*}}, i64 16) // CHECK: call void @__sanitizer_dtor_callback_fields(i8* {{.*}}, i64 16)
// CHECK-NEXT: ret void // CHECK-NEXT: ret void
namespace T5 { namespace T5 {
struct Struct { struct Struct {
[[no_unique_address]] Empty e; [[no_unique_address]] Empty e;
NonTrivial nt; NonTrivial nt;
Trivial f1; Trivial f1;
int f2; int f2;
char f3; char f3;
} var; } var;
static_assert(sizeof(Struct) == 24); static_assert(sizeof(Struct) == 24);
} // namespace T5 } // namespace T5
// CHECK-LABEL: define {{.*}} @_ZN5empty2T56StructD2Ev( // CHECK-LABEL: define {{.*}} @_ZN5empty2T56StructD2Ev(
// CHECK: call void @__sanitizer_dtor_callback(i8* {{.*}}, i64 13) // CHECK: call void @__sanitizer_dtor_callback_fields(i8* {{.*}}, i64 13)
// CHECK: call void @_ZN10NonTrivialD1Ev( // CHECK: call void @_ZN10NonTrivialD1Ev(
// CHECK-NEXT: ret void // CHECK-NEXT: ret void
namespace T6 { namespace T6 {
struct Struct { struct Struct {
NonTrivial nt; NonTrivial nt;
[[no_unique_address]] Empty e; [[no_unique_address]] Empty e;
Trivial f1; Trivial f1;
int f2; int f2;
char f3; char f3;
} var; } var;
static_assert(sizeof(Struct) == 24); static_assert(sizeof(Struct) == 24);
} // namespace T6 } // namespace T6
// CHECK-LABEL: define {{.*}} @_ZN5empty2T66StructD2Ev( // CHECK-LABEL: define {{.*}} @_ZN5empty2T66StructD2Ev(
// CHECK: call void @__sanitizer_dtor_callback(i8* {{.*}}, i64 13) // CHECK: call void @__sanitizer_dtor_callback_fields(i8* {{.*}}, i64 13)
// CHECK: call void @_ZN10NonTrivialD1Ev( // CHECK: call void @_ZN10NonTrivialD1Ev(
// CHECK-NEXT: ret void // CHECK-NEXT: ret void
namespace T7 { namespace T7 {
struct Struct { struct Struct {
Trivial f1; Trivial f1;
NonTrivial nt; NonTrivial nt;
[[no_unique_address]] Empty e; [[no_unique_address]] Empty e;
int f2; int f2;
char f3; char f3;
} var; } var;
static_assert(sizeof(Struct) == 24); static_assert(sizeof(Struct) == 24);
} // namespace T7 } // namespace T7
// CHECK-LABEL: define {{.*}} @_ZN5empty2T76StructD2Ev( // CHECK-LABEL: define {{.*}} @_ZN5empty2T76StructD2Ev(
// CHECK: call void @__sanitizer_dtor_callback(i8* {{.*}}, i64 5) // CHECK: call void @__sanitizer_dtor_callback_fields(i8* {{.*}}, i64 5)
// CHECK: call void @_ZN10NonTrivialD1Ev( // CHECK: call void @_ZN10NonTrivialD1Ev(
// CHECK: call void @__sanitizer_dtor_callback(i8* {{.*}}, i64 8) // CHECK: call void @__sanitizer_dtor_callback_fields(i8* {{.*}}, i64 8)
// CHECK-NEXT: ret void // CHECK-NEXT: ret void
namespace T8 { namespace T8 {
struct Struct { struct Struct {
Trivial f1; Trivial f1;
[[no_unique_address]] Empty e; [[no_unique_address]] Empty e;
NonTrivial nt; NonTrivial nt;
int f2; int f2;
char f3; char f3;
} var; } var;
static_assert(sizeof(Struct) == 24); static_assert(sizeof(Struct) == 24);
} // namespace T8 } // namespace T8
// CHECK-LABEL: define {{.*}} @_ZN5empty2T86StructD2Ev( // CHECK-LABEL: define {{.*}} @_ZN5empty2T86StructD2Ev(
// CHECK: call void @__sanitizer_dtor_callback(i8* {{.*}}, i64 5) // CHECK: call void @__sanitizer_dtor_callback_fields(i8* {{.*}}, i64 5)
// CHECK: call void @__sanitizer_dtor_callback(i8* {{.*}}, i64 8) // CHECK: call void @__sanitizer_dtor_callback_fields(i8* {{.*}}, i64 8)
// CHECK-NEXT: ret void // CHECK-NEXT: ret void
namespace T9 { namespace T9 {
struct Struct { struct Struct {
Trivial f1; Trivial f1;
int f2; int f2;
NonTrivial nt; NonTrivial nt;
[[no_unique_address]] Empty e; [[no_unique_address]] Empty e;
char f3; char f3;
} var; } var;
static_assert(sizeof(Struct) == 24); static_assert(sizeof(Struct) == 24);
} // namespace T9 } // namespace T9
// CHECK-LABEL: define {{.*}} @_ZN5empty2T96StructD2Ev( // CHECK-LABEL: define {{.*}} @_ZN5empty2T96StructD2Ev(
// CHECK: call void @__sanitizer_dtor_callback(i8* {{.*}}, i64 1) // CHECK: call void @__sanitizer_dtor_callback_fields(i8* {{.*}}, i64 1)
// CHECK: call void @__sanitizer_dtor_callback(i8* {{.*}}, i64 12) // CHECK: call void @__sanitizer_dtor_callback_fields(i8* {{.*}}, i64 12)
// CHECK-NEXT: ret void // CHECK-NEXT: ret void
namespace T10 { namespace T10 {
struct Struct { struct Struct {
Trivial f1; Trivial f1;
int f2; int f2;
[[no_unique_address]] Empty e; [[no_unique_address]] Empty e;
NonTrivial nt; NonTrivial nt;
char f3; char f3;
} var; } var;
static_assert(sizeof(Struct) == 24); static_assert(sizeof(Struct) == 24);
} // namespace T10 } // namespace T10
// CHECK-LABEL: define {{.*}} @_ZN5empty3T106StructD2Ev( // CHECK-LABEL: define {{.*}} @_ZN5empty3T106StructD2Ev(
// CHECK: call void @__sanitizer_dtor_callback(i8* {{.*}}, i64 1) // CHECK: call void @__sanitizer_dtor_callback_fields(i8* {{.*}}, i64 1)
// CHECK: call void @__sanitizer_dtor_callback(i8* {{.*}}, i64 12) // CHECK: call void @__sanitizer_dtor_callback_fields(i8* {{.*}}, i64 12)
// CHECK-NEXT: ret void // CHECK-NEXT: ret void
namespace T11 { namespace T11 {
struct Struct { struct Struct {
Trivial f1; Trivial f1;
int f2; int f2;
char f3; char f3;
NonTrivial nt; NonTrivial nt;
[[no_unique_address]] Empty e; [[no_unique_address]] Empty e;
} var; } var;
static_assert(sizeof(Struct) == 24); static_assert(sizeof(Struct) == 24);
} // namespace T11 } // namespace T11
// CHECK-LABEL: define {{.*}} @_ZN5empty3T116StructD2Ev( // CHECK-LABEL: define {{.*}} @_ZN5empty3T116StructD2Ev(
// CHECK: call void @__sanitizer_dtor_callback(i8* {{.*}}, i64 16) // CHECK: call void @__sanitizer_dtor_callback_fields(i8* {{.*}}, i64 16)
// CHECK-NEXT: ret void // CHECK-NEXT: ret void
namespace T12 { namespace T12 {
struct Struct { struct Struct {
Trivial f1; Trivial f1;
int f2; int f2;
char f3; char f3;
[[no_unique_address]] Empty e; [[no_unique_address]] Empty e;
NonTrivial nt; NonTrivial nt;
} var; } var;
static_assert(sizeof(Struct) == 24); static_assert(sizeof(Struct) == 24);
} // namespace T12 } // namespace T12
} // namespace empty } // namespace empty
// CHECK-LABEL: define {{.*}} @_ZN5empty3T126StructD2Ev( // CHECK-LABEL: define {{.*}} @_ZN5empty3T126StructD2Ev(
// CHECK: call void @_ZN10NonTrivialD1Ev( // CHECK: call void @_ZN10NonTrivialD1Ev(
// CHECK: call void @__sanitizer_dtor_callback(i8* {{.*}}, i64 16) // CHECK: call void @__sanitizer_dtor_callback_fields(i8* {{.*}}, i64 16)
// CHECK-NEXT: ret void // CHECK-NEXT: ret void
namespace empty_non_trivial { namespace empty_non_trivial {
namespace T1 { namespace T1 {
struct Struct { struct Struct {
NonTrivial nt; NonTrivial nt;
Trivial f1; Trivial f1;
int f2; int f2;
char f3; char f3;
} var; } var;
static_assert(sizeof(Struct) == 24); static_assert(sizeof(Struct) == 24);
} // namespace T1 } // namespace T1
// CHECK-LABEL: define {{.*}} @_ZN17empty_non_trivial2T16StructD2Ev( // CHECK-LABEL: define {{.*}} @_ZN17empty_non_trivial2T16StructD2Ev(
// CHECK: call void @__sanitizer_dtor_callback(i8* {{.*}}, i64 13) // CHECK: call void @__sanitizer_dtor_callback_fields(i8* {{.*}}, i64 13)
// CHECK: call void @_ZN10NonTrivialD1Ev( // CHECK: call void @_ZN10NonTrivialD1Ev(
// CHECK-NEXT: ret void // CHECK-NEXT: ret void
namespace T2 { namespace T2 {
struct Struct { struct Struct {
Trivial f1; Trivial f1;
NonTrivial nt; NonTrivial nt;
int f2; int f2;
char f3; char f3;
} var; } var;
static_assert(sizeof(Struct) == 24); static_assert(sizeof(Struct) == 24);
} // namespace T2 } // namespace T2
// CHECK-LABEL: define {{.*}} @_ZN17empty_non_trivial2T26StructD2Ev( // CHECK-LABEL: define {{.*}} @_ZN17empty_non_trivial2T26StructD2Ev(
// CHECK: call void @__sanitizer_dtor_callback(i8* {{.*}}, i64 5) // CHECK: call void @__sanitizer_dtor_callback_fields(i8* {{.*}}, i64 5)
// CHECK: call void @__sanitizer_dtor_callback(i8* {{.*}}, i64 8) // CHECK: call void @__sanitizer_dtor_callback_fields(i8* {{.*}}, i64 8)
// CHECK-NEXT: ret void // CHECK-NEXT: ret void
namespace T3 { namespace T3 {
struct Struct { struct Struct {
Trivial f1; Trivial f1;
int f2; int f2;
NonTrivial nt; NonTrivial nt;
char f3; char f3;
} var; } var;
static_assert(sizeof(Struct) == 24); static_assert(sizeof(Struct) == 24);
} // namespace T3 } // namespace T3
// CHECK-LABEL: define {{.*}} @_ZN17empty_non_trivial2T36StructD2Ev( // CHECK-LABEL: define {{.*}} @_ZN17empty_non_trivial2T36StructD2Ev(
// CHECK: call void @__sanitizer_dtor_callback(i8* {{.*}}, i64 1) // CHECK: call void @__sanitizer_dtor_callback_fields(i8* {{.*}}, i64 1)
// CHECK: call void @__sanitizer_dtor_callback(i8* {{.*}}, i64 12) // CHECK: call void @__sanitizer_dtor_callback_fields(i8* {{.*}}, i64 12)
// CHECK-NEXT: ret void // CHECK-NEXT: ret void
namespace T4 { namespace T4 {
struct Struct { struct Struct {
Trivial f1; Trivial f1;
int f2; int f2;
char f3; char f3;
NonTrivial nt; NonTrivial nt;
} var; } var;
static_assert(sizeof(Struct) == 24); static_assert(sizeof(Struct) == 24);
} // namespace T4 } // namespace T4
// CHECK-LABEL: define {{.*}} @_ZN17empty_non_trivial2T46StructD2Ev( // CHECK-LABEL: define {{.*}} @_ZN17empty_non_trivial2T46StructD2Ev(
// CHECK: call void @__sanitizer_dtor_callback(i8* {{.*}}, i64 16) // CHECK: call void @__sanitizer_dtor_callback_fields(i8* {{.*}}, i64 16)
// CHECK-NEXT: ret void // CHECK-NEXT: ret void
namespace T5 { namespace T5 {
struct Struct { struct Struct {
[[no_unique_address]] EmptyNonTrivial e; [[no_unique_address]] EmptyNonTrivial e;
NonTrivial nt; NonTrivial nt;
Trivial f1; Trivial f1;
int f2; int f2;
char f3; char f3;
} var; } var;
static_assert(sizeof(Struct) == 24); static_assert(sizeof(Struct) == 24);
} // namespace T5 } // namespace T5
// CHECK-LABEL: define {{.*}} @_ZN17empty_non_trivial2T56StructD2Ev( // CHECK-LABEL: define {{.*}} @_ZN17empty_non_trivial2T56StructD2Ev(
// CHECK: call void @__sanitizer_dtor_callback(i8* {{.*}}, i64 13) // CHECK: call void @__sanitizer_dtor_callback_fields(i8* {{.*}}, i64 13)
// CHECK: call void @_ZN10NonTrivialD1Ev( // CHECK: call void @_ZN10NonTrivialD1Ev(
// CHECK: call void @_ZN15EmptyNonTrivialD1Ev( // CHECK: call void @_ZN15EmptyNonTrivialD1Ev(
// CHECK-NEXT: ret void // CHECK-NEXT: ret void
namespace T6 { namespace T6 {
struct Struct { struct Struct {
NonTrivial nt; NonTrivial nt;
[[no_unique_address]] EmptyNonTrivial e; [[no_unique_address]] EmptyNonTrivial e;
Trivial f1; Trivial f1;
int f2; int f2;
char f3; char f3;
} var; } var;
static_assert(sizeof(Struct) == 24); static_assert(sizeof(Struct) == 24);
} // namespace T6 } // namespace T6
// CHECK-LABEL: define {{.*}} @_ZN17empty_non_trivial2T66StructD2Ev( // CHECK-LABEL: define {{.*}} @_ZN17empty_non_trivial2T66StructD2Ev(
// CHECK: call void @__sanitizer_dtor_callback(i8* {{.*}}, i64 13) // CHECK: call void @__sanitizer_dtor_callback_fields(i8* {{.*}}, i64 13)
// CHECK: call void @_ZN15EmptyNonTrivialD1Ev( // CHECK: call void @_ZN15EmptyNonTrivialD1Ev(
// CHECK: call void @_ZN10NonTrivialD1Ev( // CHECK: call void @_ZN10NonTrivialD1Ev(
// CHECK-NEXT: ret void // CHECK-NEXT: ret void
namespace T7 { namespace T7 {
struct Struct { struct Struct {
Trivial f1; Trivial f1;
NonTrivial nt; NonTrivial nt;
[[no_unique_address]] EmptyNonTrivial e; [[no_unique_address]] EmptyNonTrivial e;
int f2; int f2;
char f3; char f3;
} var; } var;
static_assert(sizeof(Struct) == 24); static_assert(sizeof(Struct) == 24);
} // namespace T7 } // namespace T7
// CHECK-LABEL: define {{.*}} @_ZN17empty_non_trivial2T76StructD2Ev( // CHECK-LABEL: define {{.*}} @_ZN17empty_non_trivial2T76StructD2Ev(
// CHECK: call void @__sanitizer_dtor_callback(i8* {{.*}}, i64 5) // CHECK: call void @__sanitizer_dtor_callback_fields(i8* {{.*}}, i64 5)
// CHECK: call void @_ZN15EmptyNonTrivialD1Ev( // CHECK: call void @_ZN15EmptyNonTrivialD1Ev(
// CHECK: call void @_ZN10NonTrivialD1Ev( // CHECK: call void @_ZN10NonTrivialD1Ev(
// CHECK: call void @__sanitizer_dtor_callback(i8* {{.*}}, i64 8) // CHECK: call void @__sanitizer_dtor_callback_fields(i8* {{.*}}, i64 8)
// CHECK-NEXT: ret void // CHECK-NEXT: ret void
namespace T8 { namespace T8 {
struct Struct { struct Struct {
Trivial f1; Trivial f1;
[[no_unique_address]] EmptyNonTrivial e; [[no_unique_address]] EmptyNonTrivial e;
NonTrivial nt; NonTrivial nt;
int f2; int f2;
char f3; char f3;
} var; } var;
static_assert(sizeof(Struct) == 24); static_assert(sizeof(Struct) == 24);
} // namespace T8 } // namespace T8
// CHECK-LABEL: define {{.*}} @_ZN17empty_non_trivial2T86StructD2Ev( // CHECK-LABEL: define {{.*}} @_ZN17empty_non_trivial2T86StructD2Ev(
// CHECK: call void @__sanitizer_dtor_callback(i8* {{.*}}, i64 5) // CHECK: call void @__sanitizer_dtor_callback_fields(i8* {{.*}}, i64 5)
// CHECK: call void @_ZN10NonTrivialD1Ev( // CHECK: call void @_ZN10NonTrivialD1Ev(
// CHECK: call void @__sanitizer_dtor_callback(i8* {{.*}}, i64 8) // CHECK: call void @__sanitizer_dtor_callback_fields(i8* {{.*}}, i64 8)
// CHECK: call void @_ZN15EmptyNonTrivialD1Ev( // CHECK: call void @_ZN15EmptyNonTrivialD1Ev(
// CHECK-NEXT: ret void // CHECK-NEXT: ret void
namespace T9 { namespace T9 {
struct Struct { struct Struct {
Trivial f1; Trivial f1;
int f2; int f2;
NonTrivial nt; NonTrivial nt;
[[no_unique_address]] EmptyNonTrivial e; [[no_unique_address]] EmptyNonTrivial e;
char f3; char f3;
} var; } var;
static_assert(sizeof(Struct) == 24); static_assert(sizeof(Struct) == 24);
} // namespace T9 } // namespace T9
// CHECK-LABEL: define {{.*}} @_ZN17empty_non_trivial2T96StructD2Ev( // CHECK-LABEL: define {{.*}} @_ZN17empty_non_trivial2T96StructD2Ev(
// CHECK: call void @__sanitizer_dtor_callback(i8* {{.*}}, i64 1) // CHECK: call void @__sanitizer_dtor_callback_fields(i8* {{.*}}, i64 1)
// CHECK: call void @_ZN15EmptyNonTrivialD1Ev( // CHECK: call void @_ZN15EmptyNonTrivialD1Ev(
// CHECK: call void @_ZN10NonTrivialD1Ev( // CHECK: call void @_ZN10NonTrivialD1Ev(
// CHECK: call void @__sanitizer_dtor_callback(i8* {{.*}}, i64 12) // CHECK: call void @__sanitizer_dtor_callback_fields(i8* {{.*}}, i64 12)
// CHECK-NEXT: ret void // CHECK-NEXT: ret void
namespace T10 { namespace T10 {
struct Struct { struct Struct {
Trivial f1; Trivial f1;
int f2; int f2;
[[no_unique_address]] EmptyNonTrivial e; [[no_unique_address]] EmptyNonTrivial e;
NonTrivial nt; NonTrivial nt;
char f3; char f3;
} var; } var;
static_assert(sizeof(Struct) == 24); static_assert(sizeof(Struct) == 24);
} // namespace T10 } // namespace T10
// CHECK-LABEL: define {{.*}} @_ZN17empty_non_trivial3T106StructD2Ev( // CHECK-LABEL: define {{.*}} @_ZN17empty_non_trivial3T106StructD2Ev(
// CHECK: call void @__sanitizer_dtor_callback(i8* {{.*}}, i64 1) // CHECK: call void @__sanitizer_dtor_callback_fields(i8* {{.*}}, i64 1)
// CHECK: call void @_ZN10NonTrivialD1Ev( // CHECK: call void @_ZN10NonTrivialD1Ev(
// CHECK: call void @__sanitizer_dtor_callback(i8* {{.*}}, i64 12) // CHECK: call void @__sanitizer_dtor_callback_fields(i8* {{.*}}, i64 12)
// CHECK: call void @_ZN15EmptyNonTrivialD1Ev( // CHECK: call void @_ZN15EmptyNonTrivialD1Ev(
// CHECK-NEXT: ret void // CHECK-NEXT: ret void
namespace T11 { namespace T11 {
struct Struct { struct Struct {
Trivial f1; Trivial f1;
int f2; int f2;
char f3; char f3;
NonTrivial nt; NonTrivial nt;
[[no_unique_address]] EmptyNonTrivial e; [[no_unique_address]] EmptyNonTrivial e;
} var; } var;
static_assert(sizeof(Struct) == 24); static_assert(sizeof(Struct) == 24);
} // namespace T11 } // namespace T11
// CHECK-LABEL: define {{.*}} @_ZN17empty_non_trivial3T116StructD2Ev( // CHECK-LABEL: define {{.*}} @_ZN17empty_non_trivial3T116StructD2Ev(
// CHECK: call void @_ZN15EmptyNonTrivialD1Ev( // CHECK: call void @_ZN15EmptyNonTrivialD1Ev(
// CHECK: call void @_ZN10NonTrivialD1Ev( // CHECK: call void @_ZN10NonTrivialD1Ev(
// CHECK: call void @__sanitizer_dtor_callback(i8* {{.*}}, i64 16) // CHECK: call void @__sanitizer_dtor_callback_fields(i8* {{.*}}, i64 16)
// CHECK-NEXT: ret void // CHECK-NEXT: ret void
namespace T12 { namespace T12 {
struct Struct { struct Struct {
Trivial f1; Trivial f1;
int f2; int f2;
char f3; char f3;
[[no_unique_address]] EmptyNonTrivial e; [[no_unique_address]] EmptyNonTrivial e;
NonTrivial nt; NonTrivial nt;
} var; } var;
static_assert(sizeof(Struct) == 24); static_assert(sizeof(Struct) == 24);
} // namespace T12 } // namespace T12
} // namespace empty_non_trivial } // namespace empty_non_trivial
// CHECK-LABEL: define {{.*}} @_ZN17empty_non_trivial3T126StructD2Ev( // CHECK-LABEL: define {{.*}} @_ZN17empty_non_trivial3T126StructD2Ev(
// CHECK: call void @_ZN10NonTrivialD1Ev( // CHECK: call void @_ZN10NonTrivialD1Ev(
// CHECK: call void @__sanitizer_dtor_callback(i8* {{.*}}, i64 16) // CHECK: call void @__sanitizer_dtor_callback_fields(i8* {{.*}}, i64 16)
// CHECK: call void @_ZN15EmptyNonTrivialD1Ev( // CHECK: call void @_ZN15EmptyNonTrivialD1Ev(
// CHECK: ret void // CHECK: ret void

compiler-rt/include/sanitizer/msan_interface.h

Show First 20 Lines • Show All 86 Lines • ▼ Show 20 Lines#endif
int __msan_has_dynamic_component(void); int __msan_has_dynamic_component(void);
/* Tell MSan about newly allocated memory (ex.: custom allocator). /* Tell MSan about newly allocated memory (ex.: custom allocator).
Memory will be marked uninitialized, with origin at the call site. */ Memory will be marked uninitialized, with origin at the call site. */
void __msan_allocated_memory(const volatile void* data, size_t size); void __msan_allocated_memory(const volatile void* data, size_t size);
/* Tell MSan about newly destroyed memory. Mark memory as uninitialized. */ /* Tell MSan about newly destroyed memory. Mark memory as uninitialized. */
void __sanitizer_dtor_callback(const volatile void* data, size_t size); void __sanitizer_dtor_callback(const volatile void* data, size_t size);
void __sanitizer_dtor_callback_fields(const volatile void *data, size_t size);
void __sanitizer_dtor_callback_vptr(const volatile void *data);
/* This function may be optionally provided by user and should return /* This function may be optionally provided by user and should return
a string containing Msan runtime options. See msan_flags.h for details. */ a string containing Msan runtime options. See msan_flags.h for details. */
const char* __msan_default_options(void); const char* __msan_default_options(void);
/* Deprecated. Call __sanitizer_set_death_callback instead. */ /* Deprecated. Call __sanitizer_set_death_callback instead. */
void __msan_set_death_callback(void (*callback)(void)); void __msan_set_death_callback(void (*callback)(void));
Show All 22 Lines

compiler-rt/lib/msan/msan.h

Show First 20 Lines • Show All 343 Lines • ▼ Show 20 Lines
void UnpoisonParam(uptr n); void UnpoisonParam(uptr n);
void UnpoisonThreadLocalState(); void UnpoisonThreadLocalState();
// Returns a "chained" origin id, pointing to the given stack trace followed by // Returns a "chained" origin id, pointing to the given stack trace followed by
// the previous origin id. // the previous origin id.
u32 ChainOrigin(u32 id, StackTrace *stack); u32 ChainOrigin(u32 id, StackTrace *stack);
const int STACK_TRACE_TAG_POISON = StackTrace::TAG_CUSTOM + 1; const int STACK_TRACE_TAG_POISON = StackTrace::TAG_CUSTOM + 1;
const int STACK_TRACE_TAG_FIELDS = STACK_TRACE_TAG_POISON + 1;
const int STACK_TRACE_TAG_VPTR = STACK_TRACE_TAG_FIELDS + 1;
#define GET_MALLOC_STACK_TRACE \ #define GET_MALLOC_STACK_TRACE \
BufferedStackTrace stack; \ BufferedStackTrace stack; \
if (__msan_get_track_origins() && msan_inited) \ if (__msan_get_track_origins() && msan_inited) \
stack.Unwind(StackTrace::GetCurrentPc(), GET_CURRENT_FRAME(), \ stack.Unwind(StackTrace::GetCurrentPc(), GET_CURRENT_FRAME(), \
nullptr, common_flags()->fast_unwind_on_malloc, \ nullptr, common_flags()->fast_unwind_on_malloc, \
common_flags()->malloc_context_size) common_flags()->malloc_context_size)
Show All 40 Lines

compiler-rt/lib/msan/msan_interceptors.cpp

Show First 20 Lines • Show All 938 Lines • ▼ Show 20 Lines
void __sanitizer_dtor_callback(const void *data, uptr size) { void __sanitizer_dtor_callback(const void *data, uptr size) {
if (flags()->poison_in_dtor) { if (flags()->poison_in_dtor) {
GET_MALLOC_STACK_TRACE; GET_MALLOC_STACK_TRACE;
stack.tag = STACK_TRACE_TAG_POISON; stack.tag = STACK_TRACE_TAG_POISON;
PoisonMemory(data, size, &stack); PoisonMemory(data, size, &stack);
} }
} }
void __sanitizer_dtor_callback_fields(const void *data, uptr size) {
if (flags()->poison_in_dtor) {
GET_MALLOC_STACK_TRACE;
stack.tag = STACK_TRACE_TAG_FIELDS;
PoisonMemory(data, size, &stack);
}
}
void __sanitizer_dtor_callback_vptr(const void *data) {
if (flags()->poison_in_dtor) {
GET_MALLOC_STACK_TRACE;
stack.tag = STACK_TRACE_TAG_VPTR;
PoisonMemory(data, sizeof(void *), &stack);
}
}
template <class Mmap> template <class Mmap>
static void *mmap_interceptor(Mmap real_mmap, void *addr, SIZE_T length, static void *mmap_interceptor(Mmap real_mmap, void *addr, SIZE_T length,
int prot, int flags, int fd, OFF64_T offset) { int prot, int flags, int fd, OFF64_T offset) {
SIZE_T rounded_length = RoundUpTo(length, GetPageSize()); SIZE_T rounded_length = RoundUpTo(length, GetPageSize());
void *end_addr = (char *)addr + (rounded_length - 1); void *end_addr = (char *)addr + (rounded_length - 1);
if (addr && (!MEM_IS_APP(addr) || !MEM_IS_APP(end_addr))) { if (addr && (!MEM_IS_APP(addr) || !MEM_IS_APP(end_addr))) {
if (flags & map_fixed) { if (flags & map_fixed) {
errno = errno_EINVAL; errno = errno_EINVAL;
▲ Show 20 Lines • Show All 814 Lines • Show Last 20 Lines

compiler-rt/lib/msan/msan_interface_internal.h

Show First 20 Lines • Show All 156 Lines • ▼ Show 20 Lines
// Memory will be marked uninitialized, with origin at the call site. // Memory will be marked uninitialized, with origin at the call site.
SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_INTERFACE_ATTRIBUTE
void __msan_allocated_memory(const void* data, uptr size); void __msan_allocated_memory(const void* data, uptr size);
// Tell MSan about newly destroyed memory. Memory will be marked // Tell MSan about newly destroyed memory. Memory will be marked
// uninitialized. // uninitialized.
SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_INTERFACE_ATTRIBUTE
void __sanitizer_dtor_callback(const void* data, uptr size); void __sanitizer_dtor_callback(const void* data, uptr size);
SANITIZER_INTERFACE_ATTRIBUTE
void __sanitizer_dtor_callback_fields(const void *data, uptr size);
SANITIZER_INTERFACE_ATTRIBUTE
void __sanitizer_dtor_callback_vptr(const void *data);
SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_INTERFACE_ATTRIBUTE
u16 __sanitizer_unaligned_load16(const uu16 *p); u16 __sanitizer_unaligned_load16(const uu16 *p);
SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_INTERFACE_ATTRIBUTE
u32 __sanitizer_unaligned_load32(const uu32 *p); u32 __sanitizer_unaligned_load32(const uu32 *p);
SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_INTERFACE_ATTRIBUTE
Show All 31 Lines

compiler-rt/lib/msan/msan_report.cpp

Show First 20 Lines • Show All 75 Lines • ▼ Show 20 Lines switch (stack.tag) {
case StackTrace::TAG_DEALLOC: case StackTrace::TAG_DEALLOC:
Printf(" %sUninitialized value was created by a heap deallocation%s\n", Printf(" %sUninitialized value was created by a heap deallocation%s\n",
d.Origin(), d.Default()); d.Origin(), d.Default());
break; break;
case STACK_TRACE_TAG_POISON: case STACK_TRACE_TAG_POISON:
Printf(" %sMemory was marked as uninitialized%s\n", d.Origin(), Printf(" %sMemory was marked as uninitialized%s\n", d.Origin(),
d.Default()); d.Default());
break; break;
case STACK_TRACE_TAG_FIELDS:
Printf(" %sMember fields were destroyed%s\n", d.Origin(), d.Default());
break;
case STACK_TRACE_TAG_VPTR:
Printf(" %sVirtual table ptr was destroyed%s\n", d.Origin(),
d.Default());
break;
default: default:
Printf(" %sUninitialized value was created%s\n", d.Origin(), Printf(" %sUninitialized value was created%s\n", d.Origin(),
d.Default()); d.Default());
break; break;
} }
stack.Print(); stack.Print();
} }
} }
▲ Show 20 Lines • Show All 181 Lines • Show Last 20 Lines

compiler-rt/test/msan/dtor-base-access.cpp

Show First 20 Lines • Show All 60 Lines • ▼ Show 20 Linesint main() {
g->~Derived(); g->~Derived();
// not ok to access everything // not ok to access everything
assert(__msan_test_shadow(&g->tb0, sizeof(g->tb0)) == 0); assert(__msan_test_shadow(&g->tb0, sizeof(g->tb0)) == 0);
assert(__msan_test_shadow(&g->b, sizeof(g->b)) == 0); assert(__msan_test_shadow(&g->b, sizeof(g->b)) == 0);
assert(__msan_test_shadow(&g->tb1, sizeof(g->tb1)) == 0); assert(__msan_test_shadow(&g->tb1, sizeof(g->tb1)) == 0);
assert(__msan_test_shadow(&g->d, sizeof(g->d)) == 0); assert(__msan_test_shadow(&g->d, sizeof(g->d)) == 0);
__msan_print_shadow(&g->tb0, sizeof(g->tb0)); __msan_print_shadow(&g->tb0, sizeof(g->tb0));
// CHECK: Memory was marked as uninitialized // CHECK: Member fields were destroyed
// CHECK: {{#0 0x.* in __sanitizer_dtor_callback}} // CHECK: {{#0 0x.* in __sanitizer_dtor_callback}}
// CHECK: {{#1 0x.* in .*~Derived.*cpp:}}[[@LINE-20]]: // CHECK: {{#1 0x.* in .*~Derived.*cpp:}}[[@LINE-20]]:
__msan_print_shadow(&g->b, sizeof(g->b)); __msan_print_shadow(&g->b, sizeof(g->b));
// CHECK: Memory was marked as uninitialized // CHECK: Member fields were destroyed
// CHECK: {{#0 0x.* in __sanitizer_dtor_callback}} // CHECK: {{#0 0x.* in __sanitizer_dtor_callback}}
// CHECK: {{#1 0x.* in .*~Base.*cpp:}}[[@LINE-33]]: // CHECK: {{#1 0x.* in .*~Base.*cpp:}}[[@LINE-33]]:
__msan_print_shadow(&g->tb1, sizeof(g->tb1)); __msan_print_shadow(&g->tb1, sizeof(g->tb1));
// CHECK: Memory was marked as uninitialized // CHECK: Member fields were destroyed
// CHECK: {{#0 0x.* in __sanitizer_dtor_callback}} // CHECK: {{#0 0x.* in __sanitizer_dtor_callback}}
// CHECK: {{#1 0x.* in .*~Derived.*cpp:}}[[@LINE-30]]: // CHECK: {{#1 0x.* in .*~Derived.*cpp:}}[[@LINE-30]]:
return 0; return 0;
} }

compiler-rt/test/msan/dtor-vtable-multiple-inheritance.cpp

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Lines
int main() { int main() {
// Simple linear inheritance // Simple linear inheritance
C *c = new C(); C *c = new C();
c->~C(); c->~C();
// This fails // This fails
#ifdef CVPTR #ifdef CVPTR
c->A_Foo(); c->A_Foo();
// CVPTR: Memory was marked as uninitialized // CVPTR: Virtual table ptr was destroyed
// CVPTR: {{#0 0x.* in __sanitizer_dtor_callback}} // CVPTR: {{#0 0x.* in __sanitizer_dtor_callback_vptr}}
// CVPTR: {{#1 0x.* in ~C .*cpp:}}[[@LINE-28]]: // CVPTR: {{#1 0x.* in ~C .*cpp:}}[[@LINE-28]]:
// CVPTR: {{#2 0x.* in main .*cpp:}}[[@LINE-7]]: // CVPTR: {{#2 0x.* in main .*cpp:}}[[@LINE-7]]:
#endif #endif
// Multiple inheritance, so has multiple vtables // Multiple inheritance, so has multiple vtables
E *e = new E(); E *e = new E();
e->~E(); e->~E();
// Both of these fail // Both of these fail
#ifdef EAVPTR #ifdef EAVPTR
e->A_Foo(); e->A_Foo();
// EAVPTR: Memory was marked as uninitialized // EAVPTR: Virtual table ptr was destroyed
// EAVPTR: {{#0 0x.* in __sanitizer_dtor_callback}} // EAVPTR: {{#0 0x.* in __sanitizer_dtor_callback_vptr}}
// EAVPTR: {{#1 0x.* in ~E .*cpp:}}[[@LINE-25]]: // EAVPTR: {{#1 0x.* in ~E .*cpp:}}[[@LINE-25]]:
// EAVPTR: {{#2 0x.* in main .*cpp:}}[[@LINE-7]]: // EAVPTR: {{#2 0x.* in main .*cpp:}}[[@LINE-7]]:
#endif #endif
#ifdef EDVPTR #ifdef EDVPTR
e->D_Foo(); e->D_Foo();
// EDVPTR: Memory was marked as uninitialized // EDVPTR: Virtual table ptr was destroyed
// EDVPTR: {{#0 0x.* in __sanitizer_dtor_callback}} // EDVPTR: {{#0 0x.* in __sanitizer_dtor_callback_vptr}}
// EDVPTR: {{#1 0x.* in ~E .*cpp:}}[[@LINE-33]]: // EDVPTR: {{#1 0x.* in ~E .*cpp:}}[[@LINE-33]]:
// EDVPTR: {{#2 0x.* in main .*cpp:}}[[@LINE-15]]: // EDVPTR: {{#2 0x.* in main .*cpp:}}[[@LINE-15]]:
#endif #endif
} }

compiler-rt/test/msan/use-after-dtor.cpp

Show All 26 Linesint main() {
s->~Simple(); s->~Simple();
fprintf(stderr, "\n"); // Need output to parse for CHECK-UAD-OFF case fprintf(stderr, "\n"); // Need output to parse for CHECK-UAD-OFF case
return s->x_; return s->x_;
// CHECK-UAD: WARNING: MemorySanitizer: use-of-uninitialized-value // CHECK-UAD: WARNING: MemorySanitizer: use-of-uninitialized-value
// CHECK-UAD: {{#0 0x.* in main.*use-after-dtor.cpp:}}[[@LINE-3]] // CHECK-UAD: {{#0 0x.* in main.*use-after-dtor.cpp:}}[[@LINE-3]]
// CHECK-ORIGINS: Memory was marked as uninitialized // CHECK-ORIGINS: Member fields were destroyed
// CHECK-ORIGINS: {{#0 0x.* in __sanitizer_dtor_callback}} // CHECK-ORIGINS: {{#0 0x.* in __sanitizer_dtor_callback}}
// CHECK-ORIGINS: {{#1 0x.* in .*~Simple.*cpp:}}[[@LINE-18]]: // CHECK-ORIGINS: {{#1 0x.* in .*~Simple.*cpp:}}[[@LINE-18]]:
// CHECK-UAD: SUMMARY: MemorySanitizer: use-of-uninitialized-value {{.*main}} // CHECK-UAD: SUMMARY: MemorySanitizer: use-of-uninitialized-value {{.*main}}
// CHECK-UAD-OFF-NOT: SUMMARY: MemorySanitizer: use-of-uninitialized-value // CHECK-UAD-OFF-NOT: SUMMARY: MemorySanitizer: use-of-uninitialized-value
} }