maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/clang/test/CodeGenCXX/destructors.cpp

404 lines
12 KiB
C++
Raw Normal View History

Add -fcxx-exceptions to all tests that use C++ exceptions. llvm-svn: 126599
2011-02-28 08:40:07 +08:00
// RUN: %clang_cc1 %s -triple x86_64-apple-darwin10 -emit-llvm -o - -mconstructor-aliases -fcxx-exceptions -fexceptions | FileCheck %s
Perform two more constructor/destructor code-size optimizations: 1) emit base destructors as aliases to their unique base class destructors under some careful conditions. This is enabled for the same targets that can support complete-to-base aliases, i.e. not darwin. 2) Emit non-variadic complete constructors for classes with no virtual bases as calls to the base constructor. This is enabled on all targets and in theory can trigger in situations that the alias optimization can't (mostly involving virtual bases, mostly not yet supported). These are bundled together because I didn't think it worthwhile to split them, not because they really need to be. llvm-svn: 96842
2010-02-23 08:48:20 +08:00
// CHECK: @_ZN5test01AD1Ev = alias {{.*}} @_ZN5test01AD2Ev
// CHECK: @_ZN5test11MD2Ev = alias {{.*}} @_ZN5test11AD2Ev
// CHECK: @_ZN5test11ND2Ev = alias {{.*}} @_ZN5test11AD2Ev
// CHECK: @_ZN5test11OD2Ev = alias {{.*}} @_ZN5test11AD2Ev
// CHECK: @_ZN5test11SD2Ev = alias bitcast {{.*}} @_ZN5test11AD2Ev
When deciding whether a deferred declaration has already been emitted, aliases count as definitions regardless of whether their target has been emitted yet. Fixes PR 7142. llvm-svn: 104796
2010-05-27 09:45:30 +08:00
// CHECK: @_ZN5test312_GLOBAL__N_11DD1Ev = alias internal {{.*}} @_ZN5test312_GLOBAL__N_11DD2Ev
// CHECK: @_ZN5test312_GLOBAL__N_11DD2Ev = alias internal bitcast {{.*}} @_ZN5test312_GLOBAL__N_11CD2Ev
// CHECK: @_ZN5test312_GLOBAL__N_11CD1Ev = alias internal {{.*}} @_ZN5test312_GLOBAL__N_11CD2Ev
We can generate constructors/destructors with base classes and non-trivial fields just fine now. llvm-svn: 80701
2009-09-02 02:33:46 +08:00
struct A {
int a;
~A();
};
// Base with non-trivial destructor
struct B : A {
~B();
};
B::~B() { }
// Field with non-trivial destructor
struct C {
A a;
~C();
};
CodeGen may see out-of-line declarations of the various special member functions when they are explicitly declared, e.g., via a function template specialization or explicit template instantiation declaration. Don't try to synthesize bodies for the special member functions in this case; rather, check whether we have an implicit declaration and, if so, synthesize the appropriate function body. Fixes PR5084. llvm-svn: 83212
2009-10-02 04:44:19 +08:00
C::~C() { }
Reinstate fix for PR7526, which was failing because, now that we aren't dropping all exception specifications on destructors, the exception specifications on implicitly-declared destructors were detected as being wrong (which they were). Introduce logic to provide a proper exception-specification for implicitly-declared destructors. This also fixes PR6972. Note that the other implicitly-declared special member functions also need to get exception-specifications. I'll deal with that in a subsequent commit. llvm-svn: 107385
2010-07-01 13:10:53 +08:00
namespace PR7526 {
extern void foo();
struct allocator {
~allocator() throw();
};
struct allocator_derived : allocator { };
clang side to match the LLVM IR type system rewrite patch. llvm-svn: 134831
2011-07-10 01:41:47 +08:00
// CHECK: define void @_ZN6PR75269allocatorD2Ev(%"struct.PR7526::allocator"* %this) unnamed_addr
Reinstate fix for PR7526, which was failing because, now that we aren't dropping all exception specifications on destructors, the exception specifications on implicitly-declared destructors were detected as being wrong (which they were). Introduce logic to provide a proper exception-specification for implicitly-declared destructors. This also fixes PR6972. Note that the other implicitly-declared special member functions also need to get exception-specifications. I'll deal with that in a subsequent commit. llvm-svn: 107385
2010-07-01 13:10:53 +08:00
// CHECK: call void @__cxa_call_unexpected
allocator::~allocator() throw() { foo(); }
clang side to match the LLVM IR type system rewrite patch. llvm-svn: 134831
2011-07-10 01:41:47 +08:00
// CHECK: define linkonce_odr void @_ZN6PR752617allocator_derivedD1Ev(%"struct.PR7526::allocator_derived"* %this) unnamed_addr
Mark calls to 'throw()' functions as nounwind, and mark the functions nounwind as well. llvm-svn: 107858
2010-07-08 14:48:12 +08:00
// CHECK-NOT: call void @__cxa_call_unexpected
// CHECK: }
Reinstate fix for PR7526, which was failing because, now that we aren't dropping all exception specifications on destructors, the exception specifications on implicitly-declared destructors were detected as being wrong (which they were). Introduce logic to provide a proper exception-specification for implicitly-declared destructors. This also fixes PR6972. Note that the other implicitly-declared special member functions also need to get exception-specifications. I'll deal with that in a subsequent commit. llvm-svn: 107385
2010-07-01 13:10:53 +08:00
void foo() {
allocator_derived ad;
}
}
CodeGen may see out-of-line declarations of the various special member functions when they are explicitly declared, e.g., via a function template specialization or explicit template instantiation declaration. Don't try to synthesize bodies for the special member functions in this case; rather, check whether we have an implicit declaration and, if so, synthesize the appropriate function body. Fixes PR5084. llvm-svn: 83212
2009-10-02 04:44:19 +08:00
// PR5084
template<typename T>
class A1 {
~A1();
};
template<> A1<char>::~A1();
Unify the way destructor epilogues are generated for synthesized and regular destructors. Also fix PR5529. llvm-svn: 89034
2009-11-17 12:44:12 +08:00
// PR5529
namespace PR5529 {
struct A {
~A();
};
A::~A() { }
struct B : A {
virtual ~B();
};
B::~B() {}
}
More refactoring around constructor/destructor code generation. Fix some bugs with function-try-blocks and simplify normal try-block code generation. This implementation excludes a deleting destructor's call to operator delete() from the function-try-block, which I believe is correct but which I can't find straightforward support for at a moment's glance. llvm-svn: 96670
2010-02-19 17:25:03 +08:00
// FIXME: there's a known problem in the codegen here where, if one
// destructor throws, the remaining destructors aren't run. Fix it,
// then make this code check for it.
namespace test0 {
void foo();
struct VBase { ~VBase(); };
struct Base { ~Base(); };
struct Member { ~Member(); };
struct A : Base {
Member M;
~A();
};
// The function-try-block won't suppress -mconstructor-aliases here.
A::~A() try { } catch (int i) {}
Perform two more constructor/destructor code-size optimizations: 1) emit base destructors as aliases to their unique base class destructors under some careful conditions. This is enabled for the same targets that can support complete-to-base aliases, i.e. not darwin. 2) Emit non-variadic complete constructors for classes with no virtual bases as calls to the base constructor. This is enabled on all targets and in theory can trigger in situations that the alias optimization can't (mostly involving virtual bases, mostly not yet supported). These are bundled together because I didn't think it worthwhile to split them, not because they really need to be. llvm-svn: 96842
2010-02-23 08:48:20 +08:00
// complete destructor alias tested above
More refactoring around constructor/destructor code generation. Fix some bugs with function-try-blocks and simplify normal try-block code generation. This implementation excludes a deleting destructor's call to operator delete() from the function-try-block, which I believe is correct but which I can't find straightforward support for at a moment's glance. llvm-svn: 96670
2010-02-19 17:25:03 +08:00
Move unnamed_addr after the function arguments on Sabre's request. llvm-svn: 124210
2011-01-26 03:10:24 +08:00
// CHECK: define void @_ZN5test01AD2Ev(%"struct.test0::A"* %this) unnamed_addr
More refactoring around constructor/destructor code generation. Fix some bugs with function-try-blocks and simplify normal try-block code generation. This implementation excludes a deleting destructor's call to operator delete() from the function-try-block, which I believe is correct but which I can't find straightforward support for at a moment's glance. llvm-svn: 96670
2010-02-19 17:25:03 +08:00
// CHECK: invoke void @_ZN5test06MemberD1Ev
// CHECK: unwind label [[MEM_UNWIND:%[a-zA-Z0-9.]+]]
// CHECK: invoke void @_ZN5test04BaseD2Ev
// CHECK: unwind label [[BASE_UNWIND:%[a-zA-Z0-9.]+]]
struct B : Base, virtual VBase {
Member M;
~B();
};
B::~B() try { } catch (int i) {}
// It will suppress the delegation optimization here, though.
Move unnamed_addr after the function arguments on Sabre's request. llvm-svn: 124210
2011-01-26 03:10:24 +08:00
// CHECK: define void @_ZN5test01BD1Ev(%"struct.test0::B"* %this) unnamed_addr
More refactoring around constructor/destructor code generation. Fix some bugs with function-try-blocks and simplify normal try-block code generation. This implementation excludes a deleting destructor's call to operator delete() from the function-try-block, which I believe is correct but which I can't find straightforward support for at a moment's glance. llvm-svn: 96670
2010-02-19 17:25:03 +08:00
// CHECK: invoke void @_ZN5test06MemberD1Ev
// CHECK: unwind label [[MEM_UNWIND:%[a-zA-Z0-9.]+]]
// CHECK: invoke void @_ZN5test04BaseD2Ev
// CHECK: unwind label [[BASE_UNWIND:%[a-zA-Z0-9.]+]]
// CHECK: invoke void @_ZN5test05VBaseD2Ev
// CHECK: unwind label [[VBASE_UNWIND:%[a-zA-Z0-9.]+]]
Move unnamed_addr after the function arguments on Sabre's request. llvm-svn: 124210
2011-01-26 03:10:24 +08:00
// CHECK: define void @_ZN5test01BD2Ev(%"struct.test0::B"* %this, i8** %vtt) unnamed_addr
More refactoring around constructor/destructor code generation. Fix some bugs with function-try-blocks and simplify normal try-block code generation. This implementation excludes a deleting destructor's call to operator delete() from the function-try-block, which I believe is correct but which I can't find straightforward support for at a moment's glance. llvm-svn: 96670
2010-02-19 17:25:03 +08:00
// CHECK: invoke void @_ZN5test06MemberD1Ev
// CHECK: unwind label [[MEM_UNWIND:%[a-zA-Z0-9.]+]]
// CHECK: invoke void @_ZN5test04BaseD2Ev
// CHECK: unwind label [[BASE_UNWIND:%[a-zA-Z0-9.]+]]
}
Perform two more constructor/destructor code-size optimizations: 1) emit base destructors as aliases to their unique base class destructors under some careful conditions. This is enabled for the same targets that can support complete-to-base aliases, i.e. not darwin. 2) Emit non-variadic complete constructors for classes with no virtual bases as calls to the base constructor. This is enabled on all targets and in theory can trigger in situations that the alias optimization can't (mostly involving virtual bases, mostly not yet supported). These are bundled together because I didn't think it worthwhile to split them, not because they really need to be. llvm-svn: 96842
2010-02-23 08:48:20 +08:00
// Test base-class aliasing.
namespace test1 {
struct A { ~A(); char ***m; }; // non-trivial destructor
struct B { ~B(); }; // non-trivial destructor
struct Empty { }; // trivial destructor, empty
struct NonEmpty { int x; }; // trivial destructor, non-empty
Don't emit derived-to-base destructor aliases if we don't have a definition for the base destructor, because aliases to declarations aren't legal. Fixes PR 6471. llvm-svn: 97637
2010-03-03 11:40:11 +08:00
// There must be a definition in this translation unit for the alias
// optimization to apply.
A::~A() { delete m; }
Perform two more constructor/destructor code-size optimizations: 1) emit base destructors as aliases to their unique base class destructors under some careful conditions. This is enabled for the same targets that can support complete-to-base aliases, i.e. not darwin. 2) Emit non-variadic complete constructors for classes with no virtual bases as calls to the base constructor. This is enabled on all targets and in theory can trigger in situations that the alias optimization can't (mostly involving virtual bases, mostly not yet supported). These are bundled together because I didn't think it worthwhile to split them, not because they really need to be. llvm-svn: 96842
2010-02-23 08:48:20 +08:00
struct M : A { ~M(); };
M::~M() {} // alias tested above
struct N : A, Empty { ~N(); };
N::~N() {} // alias tested above
struct O : Empty, A { ~O(); };
O::~O() {} // alias tested above
struct P : NonEmpty, A { ~P(); };
Move unnamed_addr after the function arguments on Sabre's request. llvm-svn: 124210
2011-01-26 03:10:24 +08:00
P::~P() {} // CHECK: define void @_ZN5test11PD2Ev(%"struct.test1::P"* %this) unnamed_addr
Perform two more constructor/destructor code-size optimizations: 1) emit base destructors as aliases to their unique base class destructors under some careful conditions. This is enabled for the same targets that can support complete-to-base aliases, i.e. not darwin. 2) Emit non-variadic complete constructors for classes with no virtual bases as calls to the base constructor. This is enabled on all targets and in theory can trigger in situations that the alias optimization can't (mostly involving virtual bases, mostly not yet supported). These are bundled together because I didn't think it worthwhile to split them, not because they really need to be. llvm-svn: 96842
2010-02-23 08:48:20 +08:00
struct Q : A, B { ~Q(); };
clang side to match the LLVM IR type system rewrite patch. llvm-svn: 134831
2011-07-10 01:41:47 +08:00
Q::~Q() {} // CHECK: define void @_ZN5test11QD2Ev(%"struct.test1::Q"* %this) unnamed_addr
Perform two more constructor/destructor code-size optimizations: 1) emit base destructors as aliases to their unique base class destructors under some careful conditions. This is enabled for the same targets that can support complete-to-base aliases, i.e. not darwin. 2) Emit non-variadic complete constructors for classes with no virtual bases as calls to the base constructor. This is enabled on all targets and in theory can trigger in situations that the alias optimization can't (mostly involving virtual bases, mostly not yet supported). These are bundled together because I didn't think it worthwhile to split them, not because they really need to be. llvm-svn: 96842
2010-02-23 08:48:20 +08:00
struct R : A { ~R(); };
clang side to match the LLVM IR type system rewrite patch. llvm-svn: 134831
2011-07-10 01:41:47 +08:00
R::~R() { A a; } // CHECK: define void @_ZN5test11RD2Ev(%"struct.test1::R"* %this) unnamed_addr
Perform two more constructor/destructor code-size optimizations: 1) emit base destructors as aliases to their unique base class destructors under some careful conditions. This is enabled for the same targets that can support complete-to-base aliases, i.e. not darwin. 2) Emit non-variadic complete constructors for classes with no virtual bases as calls to the base constructor. This is enabled on all targets and in theory can trigger in situations that the alias optimization can't (mostly involving virtual bases, mostly not yet supported). These are bundled together because I didn't think it worthwhile to split them, not because they really need to be. llvm-svn: 96842
2010-02-23 08:48:20 +08:00
struct S : A { ~S(); int x; };
S::~S() {} // alias tested above
struct T : A { ~T(); B x; };
Move unnamed_addr after the function arguments on Sabre's request. llvm-svn: 124210
2011-01-26 03:10:24 +08:00
T::~T() {} // CHECK: define void @_ZN5test11TD2Ev(%"struct.test1::T"* %this) unnamed_addr
Perform two more constructor/destructor code-size optimizations: 1) emit base destructors as aliases to their unique base class destructors under some careful conditions. This is enabled for the same targets that can support complete-to-base aliases, i.e. not darwin. 2) Emit non-variadic complete constructors for classes with no virtual bases as calls to the base constructor. This is enabled on all targets and in theory can trigger in situations that the alias optimization can't (mostly involving virtual bases, mostly not yet supported). These are bundled together because I didn't think it worthwhile to split them, not because they really need to be. llvm-svn: 96842
2010-02-23 08:48:20 +08:00
// The VTT parameter prevents this. We could still make this work
// for calling conventions that are safe against extra parameters.
struct U : A, virtual B { ~U(); };
Move unnamed_addr after the function arguments on Sabre's request. llvm-svn: 124210
2011-01-26 03:10:24 +08:00
U::~U() {} // CHECK: define void @_ZN5test11UD2Ev(%"struct.test1::U"* %this, i8** %vtt) unnamed_addr
Perform two more constructor/destructor code-size optimizations: 1) emit base destructors as aliases to their unique base class destructors under some careful conditions. This is enabled for the same targets that can support complete-to-base aliases, i.e. not darwin. 2) Emit non-variadic complete constructors for classes with no virtual bases as calls to the base constructor. This is enabled on all targets and in theory can trigger in situations that the alias optimization can't (mostly involving virtual bases, mostly not yet supported). These are bundled together because I didn't think it worthwhile to split them, not because they really need to be. llvm-svn: 96842
2010-02-23 08:48:20 +08:00
}
Don't emit derived-to-base destructor aliases if we don't have a definition for the base destructor, because aliases to declarations aren't legal. Fixes PR 6471. llvm-svn: 97637
2010-03-03 11:40:11 +08:00
// PR6471
namespace test2 {
struct A { ~A(); char ***m; };
struct B : A { ~B(); };
B::~B() {}
clang side to match the LLVM IR type system rewrite patch. llvm-svn: 134831
2011-07-10 01:41:47 +08:00
// CHECK: define void @_ZN5test21BD2Ev(%"struct.test2::B"* %this) unnamed_addr
Don't emit derived-to-base destructor aliases if we don't have a definition for the base destructor, because aliases to declarations aren't legal. Fixes PR 6471. llvm-svn: 97637
2010-03-03 11:40:11 +08:00
// CHECK: call void @_ZN5test21AD2Ev
}
When deciding whether a deferred declaration has already been emitted, aliases count as definitions regardless of whether their target has been emitted yet. Fixes PR 7142. llvm-svn: 104796
2010-05-27 09:45:30 +08:00
// PR7142
namespace test3 {
struct A { virtual ~A(); };
struct B { virtual ~B(); };
namespace { // internal linkage => deferred
struct C : A, B {}; // ~B() in D requires a this-adjustment thunk
struct D : C {}; // D::~D() is an alias to C::~C()
}
void test() {
new D; // Force emission of D's vtable
}
// Checked at top of file:
// @_ZN5test312_GLOBAL__N_11CD1Ev = alias internal {{.*}} @_ZN5test312_GLOBAL__N_11CD2Ev
Validated by nightly-test runs on x86 and x86-64 darwin, including after self-host. Hopefully these results hold up on different platforms. I tried to keep the GNU ObjC runtime happy, but it's hard for me to test. Reimplement how clang generates IR for exceptions. Instead of creating new invoke destinations which sequentially chain to the previous destination, push a more semantic representation of *why* we need the cleanup/catch/filter behavior, then collect that information into a single landing pad upon request. Also reorganizes how normal cleanups (i.e. cleanups triggered by non-exceptional control flow) are generated, since it's actually fairly closely tied in with the former. Remove the need to track which cleanup scope a block is associated with. Document a lot of previously poorly-understood (by me, at least) behavior. The new framework implements the Horrible Hack (tm), which requires every landing pad to have a catch-all so that inlining will work. Clang no longer requires the Horrible Hack just to make exceptions flow correctly within a function, however. The HH is an unfortunate requirement of LLVM's EH IR. llvm-svn: 107631
2010-07-06 09:34:17 +08:00
// More checks at end of file.
}
namespace test4 {
struct A { ~A(); };
// CHECK: define void @_ZN5test43fooEv()
// CHECK: call void @_ZN5test41AD1Ev
// CHECK: ret void
void foo() {
{
A a;
goto failure;
}
failure:
return;
}
// CHECK: define void @_ZN5test43barEi(
// CHECK: [[X:%.*]] = alloca i32
// CHECK-NEXT: [[A:%.*]] = alloca
// CHECK: br label
// CHECK: [[TMP:%.*]] = load i32* [[X]]
// CHECK-NEXT: [[CMP:%.*]] = icmp ne i32 [[TMP]], 0
// CHECK-NEXT: br i1
// CHECK: call void @_ZN5test41AD1Ev(
// CHECK: br label
// CHECK: [[TMP:%.*]] = load i32* [[X]]
// CHECK: [[TMP2:%.*]] = add nsw i32 [[TMP]], -1
// CHECK: store i32 [[TMP2]], i32* [[X]]
// CHECK: br label
// CHECK: ret void
void bar(int x) {
for (A a; x; ) {
x--;
}
}
}
When destroying a cleanup, kill any references to instructions in the entry block before deleting it. Fixes PR7575. This really just a short-term fix before implementing lazy cleanups. llvm-svn: 107676
2010-07-07 01:35:03 +08:00
// PR7575
namespace test5 {
struct A { ~A(); };
// CHECK: define void @_ZN5test53fooEv()
// CHECK: [[ELEMS:%.*]] = alloca [5 x [[A:%.*]]], align
Fix a lot of problems with the partial destruction of arrays: - an off-by-one error in emission of irregular array limits for InitListExprs - use an EH partial-destruction cleanup within the normal array-destruction cleanup - get the branch destinations right for the empty check Also some refactoring which unfortunately obscures these changes. llvm-svn: 134890
2011-07-11 16:38:19 +08:00
// CHECK-NEXT: [[EXN:%.*]] = alloca i8*
// CHECK-NEXT: [[SEL:%.*]] = alloca i32
A number of array-related IR-gen cleanups. - Emit default-initialization of arrays that were partially initialized with initializer lists with a loop, rather than emitting the default initializer N times; - support destroying VLAs of non-trivial type, although this is not yet exposed to users; and - support the partial destruction of arrays initialized with initializer lists when an initializer throws an exception. llvm-svn: 134784
2011-07-09 09:37:26 +08:00
// CHECK-NEXT: [[BEGIN:%.*]] = getelementptr inbounds [5 x [[A]]]* [[ELEMS]], i32 0, i32 0
// CHECK-NEXT: [[END:%.*]] = getelementptr inbounds [[A]]* [[BEGIN]], i64 5
When destroying a cleanup, kill any references to instructions in the entry block before deleting it. Fixes PR7575. This really just a short-term fix before implementing lazy cleanups. llvm-svn: 107676
2010-07-07 01:35:03 +08:00
// CHECK-NEXT: br label
A number of array-related IR-gen cleanups. - Emit default-initialization of arrays that were partially initialized with initializer lists with a loop, rather than emitting the default initializer N times; - support destroying VLAs of non-trivial type, although this is not yet exposed to users; and - support the partial destruction of arrays initialized with initializer lists when an initializer throws an exception. llvm-svn: 134784
2011-07-09 09:37:26 +08:00
// CHECK: [[POST:%.*]] = phi [[A]]* [ [[END]], {{%.*}} ], [ [[ELT:%.*]], {{%.*}} ]
// CHECK-NEXT: [[ELT]] = getelementptr inbounds [[A]]* [[POST]], i64 -1
Fix a lot of problems with the partial destruction of arrays: - an off-by-one error in emission of irregular array limits for InitListExprs - use an EH partial-destruction cleanup within the normal array-destruction cleanup - get the branch destinations right for the empty check Also some refactoring which unfortunately obscures these changes. llvm-svn: 134890
2011-07-11 16:38:19 +08:00
// CHECK-NEXT: invoke void @_ZN5test51AD1Ev([[A]]* [[ELT]])
// CHECK: [[T0:%.*]] = icmp eq [[A]]* [[ELT]], [[BEGIN]]
A number of array-related IR-gen cleanups. - Emit default-initialization of arrays that were partially initialized with initializer lists with a loop, rather than emitting the default initializer N times; - support destroying VLAs of non-trivial type, although this is not yet exposed to users; and - support the partial destruction of arrays initialized with initializer lists when an initializer throws an exception. llvm-svn: 134784
2011-07-09 09:37:26 +08:00
// CHECK-NEXT: br i1 [[T0]],
When destroying a cleanup, kill any references to instructions in the entry block before deleting it. Fixes PR7575. This really just a short-term fix before implementing lazy cleanups. llvm-svn: 107676
2010-07-07 01:35:03 +08:00
// CHECK: ret void
Fix a lot of problems with the partial destruction of arrays: - an off-by-one error in emission of irregular array limits for InitListExprs - use an EH partial-destruction cleanup within the normal array-destruction cleanup - get the branch destinations right for the empty check Also some refactoring which unfortunately obscures these changes. llvm-svn: 134890
2011-07-11 16:38:19 +08:00
// lpad
// CHECK: [[EMPTY:%.*]] = icmp eq [[A]]* [[BEGIN]], [[ELT]]
// CHECK-NEXT: br i1 [[EMPTY]]
// CHECK: [[AFTER:%.*]] = phi [[A]]* [ [[ELT]], {{%.*}} ], [ [[CUR:%.*]], {{%.*}} ]
// CHECK-NEXT: [[CUR:%.*]] = getelementptr inbounds [[A]]* [[AFTER]], i64 -1
// CHECK-NEXT: invoke void @_ZN5test51AD1Ev([[A]]* [[CUR]])
// CHECK: [[DONE:%.*]] = icmp eq [[A]]* [[CUR]], [[BEGIN]]
// CHECK-NEXT: br i1 [[DONE]],
When destroying a cleanup, kill any references to instructions in the entry block before deleting it. Fixes PR7575. This really just a short-term fix before implementing lazy cleanups. llvm-svn: 107676
2010-07-07 01:35:03 +08:00
void foo() {
A elems[5];
}
}
Implement proper base/member destructor EH chaining. llvm-svn: 108989
2010-07-21 13:30:47 +08:00
namespace test6 {
void opaque();
struct A { ~A(); };
template <unsigned> struct B { B(); ~B(); int _; };
struct C : B<0>, B<1>, virtual B<2>, virtual B<3> {
A x, y, z;
C();
~C();
};
C::C() { opaque(); }
Move unnamed_addr after the function arguments on Sabre's request. llvm-svn: 124210
2011-01-26 03:10:24 +08:00
// CHECK: define void @_ZN5test61CC1Ev(%"struct.test6::C"* %this) unnamed_addr
Implement proper base/member destructor EH chaining. llvm-svn: 108989
2010-07-21 13:30:47 +08:00
// CHECK: call void @_ZN5test61BILj2EEC2Ev
// CHECK: invoke void @_ZN5test61BILj3EEC2Ev
// CHECK: invoke void @_ZN5test61BILj0EEC2Ev
// CHECK: invoke void @_ZN5test61BILj1EEC2Ev
// CHECK: invoke void @_ZN5test66opaqueEv
// CHECK: ret void
// FIXME: way too much EH cleanup code follows
C::~C() { opaque(); }
Move unnamed_addr after the function arguments on Sabre's request. llvm-svn: 124210
2011-01-26 03:10:24 +08:00
// CHECK: define void @_ZN5test61CD1Ev(%"struct.test6::C"* %this) unnamed_addr
Implement proper base/member destructor EH chaining. llvm-svn: 108989
2010-07-21 13:30:47 +08:00
// CHECK: invoke void @_ZN5test61CD2Ev
// CHECK: invoke void @_ZN5test61BILj3EED2Ev
// CHECK: call void @_ZN5test61BILj2EED2Ev
// CHECK: ret void
// CHECK: invoke void @_ZN5test61BILj3EED2Ev
// CHECK: invoke void @_ZN5test61BILj2EED2Ev
Move unnamed_addr after the function arguments on Sabre's request. llvm-svn: 124210
2011-01-26 03:10:24 +08:00
// CHECK: define void @_ZN5test61CD2Ev(%"struct.test6::C"* %this, i8** %vtt) unnamed_addr
Implement proper base/member destructor EH chaining. llvm-svn: 108989
2010-07-21 13:30:47 +08:00
// CHECK: invoke void @_ZN5test66opaqueEv
// CHECK: invoke void @_ZN5test61AD1Ev
// CHECK: invoke void @_ZN5test61AD1Ev
// CHECK: invoke void @_ZN5test61AD1Ev
// CHECK: invoke void @_ZN5test61BILj1EED2Ev
// CHECK: call void @_ZN5test61BILj0EED2Ev
// CHECK: ret void
// CHECK: invoke void @_ZN5test61AD1Ev
// CHECK: invoke void @_ZN5test61AD1Ev
// CHECK: invoke void @_ZN5test61AD1Ev
// CHECK: invoke void @_ZN5test61BILj1EED2Ev
// CHECK: invoke void @_ZN5test61BILj0EED2Ev
}
Look through array types when deciding whether a field requires non-trivial destruction in the destructor-aliases logic. Fixes PR 9197. llvm-svn: 125447
2011-02-13 08:46:43 +08:00
// PR 9197
namespace test7 {
struct D { ~D(); };
struct A { ~A(); };
A::~A() { }
struct B : public A {
~B();
D arr[1];
};
// Verify that this doesn't get emitted as an alias
// CHECK: define void @_ZN5test71BD2Ev(
// CHECK: invoke void @_ZN5test71DD1Ev(
// CHECK: call void @_ZN5test71AD2Ev(
B::~B() {}
Be sure to destroy the normal entry block of a cleanup that we aren't actually going to make a normal cleanup for. Sometimes we optimistically create branches to such blocks for fixups, and then we resolve the fixup to somewhere within the cleanup's scope, and then the cleanup is actually not reachable for some reason. The process of resolving the fixup leaves us with switches whose default edge leads to the cleanup; we can replace that with unreachable, then (in many cases) turn the switch into an unconditional branch. Fixes PR10467. llvm-svn: 137011
2011-08-06 14:53:52 +08:00
}
// PR10467
namespace test8 {
struct A { A(); ~A(); };
Look through array types when deciding whether a field requires non-trivial destruction in the destructor-aliases logic. Fixes PR 9197. llvm-svn: 125447
2011-02-13 08:46:43 +08:00
Be sure to destroy the normal entry block of a cleanup that we aren't actually going to make a normal cleanup for. Sometimes we optimistically create branches to such blocks for fixups, and then we resolve the fixup to somewhere within the cleanup's scope, and then the cleanup is actually not reachable for some reason. The process of resolving the fixup leaves us with switches whose default edge leads to the cleanup; we can replace that with unreachable, then (in many cases) turn the switch into an unconditional branch. Fixes PR10467. llvm-svn: 137011
2011-08-06 14:53:52 +08:00
void die() __attribute__((noreturn));
void test() {
A x;
while (1) {
A y;
goto l;
}
l: die();
}
// CHECK: define void @_ZN5test84testEv()
// CHECK: [[X:%.*]] = alloca [[A:%.*]], align 1
// CHECK-NEXT: [[Y:%.*]] = alloca [[A:%.*]], align 1
// CHECK: call void @_ZN5test81AC1Ev([[A]]* [[X]])
// CHECK-NEXT: br label
// CHECK: invoke void @_ZN5test81AC1Ev([[A]]* [[Y]])
// CHECK: invoke void @_ZN5test81AD1Ev([[A]]* [[Y]])
// CHECK-NOT: switch
// CHECK: invoke void @_ZN5test83dieEv()
// CHECK: unreachable
Look through array types when deciding whether a field requires non-trivial destruction in the destructor-aliases logic. Fixes PR 9197. llvm-svn: 125447
2011-02-13 08:46:43 +08:00
}
Validated by nightly-test runs on x86 and x86-64 darwin, including after self-host. Hopefully these results hold up on different platforms. I tried to keep the GNU ObjC runtime happy, but it's hard for me to test. Reimplement how clang generates IR for exceptions. Instead of creating new invoke destinations which sequentially chain to the previous destination, push a more semantic representation of *why* we need the cleanup/catch/filter behavior, then collect that information into a single landing pad upon request. Also reorganizes how normal cleanups (i.e. cleanups triggered by non-exceptional control flow) are generated, since it's actually fairly closely tied in with the former. Remove the need to track which cleanup scope a block is associated with. Document a lot of previously poorly-understood (by me, at least) behavior. The new framework implements the Horrible Hack (tm), which requires every landing pad to have a catch-all so that inlining will work. Clang no longer requires the Horrible Hack just to make exceptions flow correctly within a function, however. The HH is an unfortunate requirement of LLVM's EH IR. llvm-svn: 107631
2010-07-06 09:34:17 +08:00
// Checks from test3:
Move unnamed_addr after the function arguments on Sabre's request. llvm-svn: 124210
2011-01-26 03:10:24 +08:00
// CHECK: define internal void @_ZN5test312_GLOBAL__N_11DD0Ev(%"struct.test3::<anonymous namespace>::D"* %this) unnamed_addr
Validated by nightly-test runs on x86 and x86-64 darwin, including after self-host. Hopefully these results hold up on different platforms. I tried to keep the GNU ObjC runtime happy, but it's hard for me to test. Reimplement how clang generates IR for exceptions. Instead of creating new invoke destinations which sequentially chain to the previous destination, push a more semantic representation of *why* we need the cleanup/catch/filter behavior, then collect that information into a single landing pad upon request. Also reorganizes how normal cleanups (i.e. cleanups triggered by non-exceptional control flow) are generated, since it's actually fairly closely tied in with the former. Remove the need to track which cleanup scope a block is associated with. Document a lot of previously poorly-understood (by me, at least) behavior. The new framework implements the Horrible Hack (tm), which requires every landing pad to have a catch-all so that inlining will work. Clang no longer requires the Horrible Hack just to make exceptions flow correctly within a function, however. The HH is an unfortunate requirement of LLVM's EH IR. llvm-svn: 107631
2010-07-06 09:34:17 +08:00
// CHECK: invoke void @_ZN5test312_GLOBAL__N_11DD1Ev(
Mark calls to 'throw()' functions as nounwind, and mark the functions nounwind as well. llvm-svn: 107858
2010-07-08 14:48:12 +08:00
// CHECK: call void @_ZdlPv({{.*}}) nounwind
When deciding whether a deferred declaration has already been emitted, aliases count as definitions regardless of whether their target has been emitted yet. Fixes PR 7142. llvm-svn: 104796
2010-05-27 09:45:30 +08:00
// CHECK: ret void
Throw the switch to convert clang to the new exception handling model! This model uses the 'landingpad' instruction, which is pinned to the top of the landing pad. (A landing pad is defined as the destination of the unwind branch of an invoke instruction.) All of the information needed to generate the correct exception handling metadata during code generation is encoded into the landingpad instruction. The new 'resume' instruction takes the place of the llvm.eh.resume intrinsic call. It's lowered in much the same way as the intrinsic is. llvm-svn: 140049
2011-09-20 04:31:14 +08:00
// CHECK: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
// CHECK-NEXT: cleanup
Mark calls to 'throw()' functions as nounwind, and mark the functions nounwind as well. llvm-svn: 107858
2010-07-08 14:48:12 +08:00
// CHECK: call void @_ZdlPv({{.*}}) nounwind
Throw the switch to convert clang to the new exception handling model! This model uses the 'landingpad' instruction, which is pinned to the top of the landing pad. (A landing pad is defined as the destination of the unwind branch of an invoke instruction.) All of the information needed to generate the correct exception handling metadata during code generation is encoded into the landingpad instruction. The new 'resume' instruction takes the place of the llvm.eh.resume intrinsic call. It's lowered in much the same way as the intrinsic is. llvm-svn: 140049
2011-09-20 04:31:14 +08:00
// CHECK: resume { i8*, i32 }
When deciding whether a deferred declaration has already been emitted, aliases count as definitions regardless of whether their target has been emitted yet. Fixes PR 7142. llvm-svn: 104796
2010-05-27 09:45:30 +08:00
// Checked at top of file:
// @_ZN5test312_GLOBAL__N_11DD1Ev = alias internal {{.*}} @_ZN5test312_GLOBAL__N_11DD2Ev
// @_ZN5test312_GLOBAL__N_11DD2Ev = alias internal bitcast {{.*}} @_ZN5test312_GLOBAL__N_11CD2Ev
// CHECK: define internal void @_ZThn8_N5test312_GLOBAL__N_11DD1Ev(
// CHECK: getelementptr inbounds i8* {{.*}}, i64 -8
// CHECK: call void @_ZN5test312_GLOBAL__N_11DD1Ev(
// CHECK: ret void
// CHECK: define internal void @_ZThn8_N5test312_GLOBAL__N_11DD0Ev(
// CHECK: getelementptr inbounds i8* {{.*}}, i64 -8
// CHECK: call void @_ZN5test312_GLOBAL__N_11DD0Ev(
// CHECK: ret void
Move unnamed_addr after the function arguments on Sabre's request. llvm-svn: 124210
2011-01-26 03:10:24 +08:00
// CHECK: define internal void @_ZN5test312_GLOBAL__N_11CD2Ev(%"struct.test3::<anonymous namespace>::C"* %this) unnamed_addr
Implement proper base/member destructor EH chaining. llvm-svn: 108989
2010-07-21 13:30:47 +08:00
// CHECK: invoke void @_ZN5test31BD2Ev(
Convert the EH cleanups for base and member destructors in a constructor into lazy cleanups. llvm-svn: 108978
2010-07-21 09:23:41 +08:00
// CHECK: call void @_ZN5test31AD2Ev(
// CHECK: ret void
When deciding whether a deferred declaration has already been emitted, aliases count as definitions regardless of whether their target has been emitted yet. Fixes PR 7142. llvm-svn: 104796
2010-05-27 09:45:30 +08:00
// CHECK: declare void @_ZN5test31BD2Ev(
// CHECK: declare void @_ZN5test31AD2Ev(
Move unnamed_addr after the function arguments on Sabre's request. llvm-svn: 124210
2011-01-26 03:10:24 +08:00
// CHECK: define internal void @_ZN5test312_GLOBAL__N_11CD0Ev(%"struct.test3::<anonymous namespace>::C"* %this) unnamed_addr
Validated by nightly-test runs on x86 and x86-64 darwin, including after self-host. Hopefully these results hold up on different platforms. I tried to keep the GNU ObjC runtime happy, but it's hard for me to test. Reimplement how clang generates IR for exceptions. Instead of creating new invoke destinations which sequentially chain to the previous destination, push a more semantic representation of *why* we need the cleanup/catch/filter behavior, then collect that information into a single landing pad upon request. Also reorganizes how normal cleanups (i.e. cleanups triggered by non-exceptional control flow) are generated, since it's actually fairly closely tied in with the former. Remove the need to track which cleanup scope a block is associated with. Document a lot of previously poorly-understood (by me, at least) behavior. The new framework implements the Horrible Hack (tm), which requires every landing pad to have a catch-all so that inlining will work. Clang no longer requires the Horrible Hack just to make exceptions flow correctly within a function, however. The HH is an unfortunate requirement of LLVM's EH IR. llvm-svn: 107631
2010-07-06 09:34:17 +08:00
// CHECK: invoke void @_ZN5test312_GLOBAL__N_11CD1Ev(
Mark calls to 'throw()' functions as nounwind, and mark the functions nounwind as well. llvm-svn: 107858
2010-07-08 14:48:12 +08:00
// CHECK: call void @_ZdlPv({{.*}}) nounwind
When deciding whether a deferred declaration has already been emitted, aliases count as definitions regardless of whether their target has been emitted yet. Fixes PR 7142. llvm-svn: 104796
2010-05-27 09:45:30 +08:00
// CHECK: ret void
Throw the switch to convert clang to the new exception handling model! This model uses the 'landingpad' instruction, which is pinned to the top of the landing pad. (A landing pad is defined as the destination of the unwind branch of an invoke instruction.) All of the information needed to generate the correct exception handling metadata during code generation is encoded into the landingpad instruction. The new 'resume' instruction takes the place of the llvm.eh.resume intrinsic call. It's lowered in much the same way as the intrinsic is. llvm-svn: 140049
2011-09-20 04:31:14 +08:00
// CHECK: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
// CHECK-NEXT: cleanup
Mark calls to 'throw()' functions as nounwind, and mark the functions nounwind as well. llvm-svn: 107858
2010-07-08 14:48:12 +08:00
// CHECK: call void @_ZdlPv({{.*}}) nounwind
Throw the switch to convert clang to the new exception handling model! This model uses the 'landingpad' instruction, which is pinned to the top of the landing pad. (A landing pad is defined as the destination of the unwind branch of an invoke instruction.) All of the information needed to generate the correct exception handling metadata during code generation is encoded into the landingpad instruction. The new 'resume' instruction takes the place of the llvm.eh.resume intrinsic call. It's lowered in much the same way as the intrinsic is. llvm-svn: 140049
2011-09-20 04:31:14 +08:00
// CHECK: resume { i8*, i32 }
When deciding whether a deferred declaration has already been emitted, aliases count as definitions regardless of whether their target has been emitted yet. Fixes PR 7142. llvm-svn: 104796
2010-05-27 09:45:30 +08:00
// CHECK: define internal void @_ZThn8_N5test312_GLOBAL__N_11CD1Ev(
// CHECK: getelementptr inbounds i8* {{.*}}, i64 -8
// CHECK: call void @_ZN5test312_GLOBAL__N_11CD1Ev(
// CHECK: ret void
// CHECK: define internal void @_ZThn8_N5test312_GLOBAL__N_11CD0Ev(
// CHECK: getelementptr inbounds i8* {{.*}}, i64 -8
// CHECK: call void @_ZN5test312_GLOBAL__N_11CD0Ev(
// CHECK: ret void