adding tests for various dtor decl types

[eugenis]

test/CodeGenCXX/sanitize-dtor-callback.cpp

6 ↗

(On Diff #29692)

Why all this c++11 complexity? It does not seem to affect the test at all.

It's OK to only test c++11.

47 ↗

(On Diff #29692)

Please make this a regular check, and a CHECK-LABEL for the function name. Does not have to be "main".

Also, STD11-LABEL - without "CHECK".
Please verify that such tests actually fail when the implementation is broken.

This case is not handled in the implementation, there is no sanitizer call in the .ll output.
The test matches a sanitizer call from a different function (because in -std=c++11 mode you build 4 destructors but only do 2 checks).

This uncovers another problem - destructors are not emitted in the c++ declaration order. I'm not sure what the order is, you'll need either to reorder the checks or split into multiple files.

[nmusgrave]

• modified tests for instr ordering flexibility

[eugenis]

test/CodeGenCXX/sanitize-dtor-callback.cpp

45 ↗

(On Diff #29719)

Regular expressions must be in {{}}.
Just do CHECK-NOT: call{{.*}}Defaulted_Trivial

64 ↗

(On Diff #29719)

Why CHECK-DAG? This does not check the order of the calls, which is super important.

[nmusgrave]

• refactored to cope with llvm language ordering issues

[eugenis]

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

39 ↗

(On Diff #29739)

This is not what's happening here. Just read the bitcode (FileCheck input):

define linkonce_odr void @_ZN21Defaulted_Non_TrivialD1Ev(%struct.Defaulted_Non_Trivial* %this) unnamed_addr #0 comdat align 2 {
...

call void @__sanitizer_dtor_callback(i8* %11, i64 1) #1
ret void

}

define linkonce_odr void @_ZN6SimpleD1Ev(%struct.Simple* %this) unnamed_addr #0 comdat align 2 {
...
call void @_ZN6SimpleD2Ev(%struct.Simple* %this1) #1
...
call void @__sanitizer_dtor_callback(i8* %11, i64 1) #1

ret void

}

define linkonce_odr void @_ZN6SimpleD2Ev(%struct.Simple* %this) unnamed_addr #0 comdat align 2 {
...

call void @__sanitizer_dtor_callback(i8* %11, i64 1) #1
ret void

}

The CHECKs are matching code from 2 or 3 different functions.
I suggest adding CHECK-LABEL and CHECK: ret void for all destructors that are emitted for this file to avoid this.
Also, it looks like we insert instrumentation in 2 different destructors of struct Simple, and one of them calls the other. This poisons the object twice.

[nmusgrave]

• revised tests to explicitly check for all dtors

[nmusgrave]

• added testing without flag, to ensure members not sanitized without feature enabled

[eugenis]

LGTM with a nit

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

18 ↗

(On Diff #29833)

This (and below) comments are wrong, just remove them.
Replace all checks with a single ​// CHECK-NOT: call void @__sanitizer_dtor_callback

[nmusgrave]

• revised no-dtor test comments

cfe/trunk/test/CodeGenCXX/sanitize-dtor-callback.cpp

 // Test -fsanitize-memory-use-after-dtor
 // RUN: %clang_cc1 -fsanitize=memory -fsanitize-memory-use-after-dtor -triple=x86_64-pc-linux -emit-llvm -o - %s | FileCheck %s
-// RUN: %clang_cc1 -fsanitize=memory -triple=x86_64-pc-linux -emit-llvm -o - %s | FileCheck %s -check-prefix=NO_DTOR_CHECK
+// RUN: %clang_cc1 -fsanitize=memory -triple=x86_64-pc-linux -emit-llvm -o - %s | FileCheck %s -check-prefix=NO-DTOR-CHECK
+
+// RUN: %clang_cc1 -std=c++11 -fsanitize=memory -fsanitize-memory-use-after-dtor -triple=x86_64-pc-linux -emit-llvm -o - %s | FileCheck %s -check-prefix=STD11
+// RUN: %clang_cc1 -std=c++11 -fsanitize=memory -triple=x86_64-pc-linux -emit-llvm -o - %s | FileCheck %s -check-prefix=NO-DTOR-STD11-CHECK
 
 struct Simple {
   ~Simple() {}
 };
 Simple s;
 // Simple internal member is poisoned by compiler-generated dtor
 // CHECK-LABEL: @_ZN6SimpleD2Ev
 // CHECK: call void @__sanitizer_dtor_callback
 // CHECK: ret void
 
 // Compiling without the flag does not generate member-poisoning dtor
-// NO_DTOR_CHECK-LABEL: @_ZN6SimpleD2Ev
-// NO_DTOR_CHECK-NOT: call void @sanitizer_dtor_callback
-// NO_DTOR_CHECK: ret void
+// NO-DTOR-CHECK-LABEL: @_ZN6SimpleD2Ev
+// NO-DTOR-CHECK-NOT: call void @__sanitizer_dtor_callback
+// NO-DTOR-CHECK: ret void
+
+
+struct Inlined {
+  inline ~Inlined() {}
+};
+Inlined in;
+// Dtor that is inlined where invoked poisons object
+// CHECK-LABEL: @_ZN7InlinedD2Ev
+// CHECK: call void @__sanitizer_dtor_callback
+// CHECK: ret void
+
+// Compiling without the flag does not generate member-poisoning dtor
+// NO-DTOR-CHECK-LABEL: @_ZN7InlinedD2Ev
+// NO-DTOR-CHECK-NOT: call void @__sanitizer_dtor_callback
+// NO-DTOR-CHECK: ret void
+
+
+struct Defaulted_Trivial {
+  ~Defaulted_Trivial() = default;
+};
+int main() {
+  Defaulted_Trivial def_trivial;
+}
+// The compiler is explicitly signalled to handle object cleanup.
+// No complex member attributes ensures that the compiler destroys
+// the memory inline. However, it must still poison this memory.
+// STD11-CHECK-LABEL: alloca %struct.Defaulted_Trivial
+// STD11: call void @__sanitizer_dtor_callback
+// STD11: ret void
+
+// Compiling without the flag does not generate member-poisoning dtor
+// NO-DTOR-STD11-CHECK-LABEL: alloca %struct.Defaulted_Trivial
+// NO-DTOR-STD11-CHECK-NOT: call void @__sanitizer_dtor_callback
+// NO-DTOR-STD11-CHECK: ret void
+
+
+struct Defaulted_Non_Trivial {
+  Simple s;
+  ~Defaulted_Non_Trivial() = default;
+};
+Defaulted_Non_Trivial def_non_trivial;
+// Explicitly compiler-generated dtor poisons object.
+// By including a Simple member in the struct, the compiler is
+// forced to generate a non-trivial destructor..
+// STD11-CHECK-LABEL: @_ZN21Defaulted_Non_TrivialD2Ev
+// STD11: call void @__sanitizer_dtor_callback
+// STD11: ret void
+
+// Compiling without the flag does not generate member-poisoning dtor
+// NO-DTOR-STD11-CHECK-LABEL: @_ZN21Defaulted_Non_TrivialD2Ev
+// NO-DTOR-STD11-CHECK-NOT: call void @__sanitizer_dtor_callback
+// NO-DTOR-STD11-CHECK: ret void