forked from OSchip/llvm-project
598 lines
21 KiB
C++
598 lines
21 KiB
C++
// RUN: %clang_cc1 %s -triple=x86_64-linux-gnu -emit-llvm -std=c++98 -o - -fcxx-exceptions -fexceptions | FileCheck -check-prefix=CHECK -check-prefix=CHECK98 %s
|
|
// RUN: %clang_cc1 %s -triple=x86_64-linux-gnu -emit-llvm -std=c++11 -o - -fcxx-exceptions -fexceptions | FileCheck -check-prefix=CHECK -check-prefix=CHECK11 %s
|
|
|
|
typedef __typeof(sizeof(0)) size_t;
|
|
|
|
// Declare the reserved global placement new.
|
|
void *operator new(size_t, void*);
|
|
|
|
// This just shouldn't crash.
|
|
namespace test0 {
|
|
struct allocator {
|
|
allocator();
|
|
allocator(const allocator&);
|
|
~allocator();
|
|
};
|
|
|
|
void f();
|
|
void g(bool b, bool c) {
|
|
if (b) {
|
|
if (!c)
|
|
throw allocator();
|
|
|
|
return;
|
|
}
|
|
f();
|
|
}
|
|
}
|
|
|
|
namespace test1 {
|
|
struct A { A(int); A(int, int); ~A(); void *p; };
|
|
|
|
A *a() {
|
|
// CHECK: define [[A:%.*]]* @_ZN5test11aEv()
|
|
// CHECK: [[NEW:%.*]] = call i8* @_Znwm(i64 8)
|
|
// CHECK-NEXT: [[CAST:%.*]] = bitcast i8* [[NEW]] to [[A]]*
|
|
// CHECK-NEXT: invoke void @_ZN5test11AC1Ei([[A]]* [[CAST]], i32 5)
|
|
// CHECK: ret [[A]]* [[CAST]]
|
|
// CHECK: call void @_ZdlPv(i8* [[NEW]])
|
|
return new A(5);
|
|
}
|
|
|
|
A *b() {
|
|
// CHECK: define [[A:%.*]]* @_ZN5test11bEv()
|
|
// CHECK: [[NEW:%.*]] = call i8* @_Znwm(i64 8)
|
|
// CHECK-NEXT: [[CAST:%.*]] = bitcast i8* [[NEW]] to [[A]]*
|
|
// CHECK-NEXT: [[FOO:%.*]] = invoke i32 @_ZN5test13fooEv()
|
|
// CHECK: invoke void @_ZN5test11AC1Ei([[A]]* [[CAST]], i32 [[FOO]])
|
|
// CHECK: ret [[A]]* [[CAST]]
|
|
// CHECK: call void @_ZdlPv(i8* [[NEW]])
|
|
extern int foo();
|
|
return new A(foo());
|
|
}
|
|
|
|
struct B { B(); ~B(); operator int(); int x; };
|
|
B makeB();
|
|
|
|
A *c() {
|
|
// CHECK: define [[A:%.*]]* @_ZN5test11cEv()
|
|
// CHECK: [[ACTIVE:%.*]] = alloca i1
|
|
// CHECK-NEXT: [[NEW:%.*]] = call i8* @_Znwm(i64 8)
|
|
// CHECK-NEXT: store i1 true, i1* [[ACTIVE]]
|
|
// CHECK-NEXT: [[CAST:%.*]] = bitcast i8* [[NEW]] to [[A]]*
|
|
// CHECK-NEXT: invoke void @_ZN5test11BC1Ev([[B:%.*]]* [[T0:%.*]])
|
|
// CHECK: [[T1:%.*]] = getelementptr inbounds [[B]], [[B]]* [[T0]], i32 0, i32 0
|
|
// CHECK-NEXT: [[T2:%.*]] = load i32, i32* [[T1]], align 4
|
|
// CHECK-NEXT: invoke void @_ZN5test11AC1Ei([[A]]* [[CAST]], i32 [[T2]])
|
|
// CHECK: store i1 false, i1* [[ACTIVE]]
|
|
|
|
// CHECK98-NEXT: invoke void @_ZN5test11BD1Ev([[B]]* [[T0]])
|
|
// CHECK11-NEXT: call void @_ZN5test11BD1Ev([[B]]* [[T0]])
|
|
|
|
// CHECK: ret [[A]]* [[CAST]]
|
|
// CHECK: [[ISACTIVE:%.*]] = load i1, i1* [[ACTIVE]]
|
|
// CHECK-NEXT: br i1 [[ISACTIVE]]
|
|
// CHECK: call void @_ZdlPv(i8* [[NEW]])
|
|
return new A(B().x);
|
|
}
|
|
|
|
// rdar://11904428
|
|
// Terminate landing pads should call __cxa_begin_catch first.
|
|
// CHECK98: define linkonce_odr hidden void @__clang_call_terminate(i8*) [[NI_NR_NUW:#[0-9]+]] comdat
|
|
// CHECK98-NEXT: [[T0:%.*]] = call i8* @__cxa_begin_catch(i8* %0) [[NUW:#[0-9]+]]
|
|
// CHECK98-NEXT: call void @_ZSt9terminatev() [[NR_NUW:#[0-9]+]]
|
|
// CHECK98-NEXT: unreachable
|
|
|
|
A *d() {
|
|
// CHECK: define [[A:%.*]]* @_ZN5test11dEv()
|
|
// CHECK: [[ACTIVE:%.*]] = alloca i1
|
|
// CHECK-NEXT: [[NEW:%.*]] = call i8* @_Znwm(i64 8)
|
|
// CHECK-NEXT: store i1 true, i1* [[ACTIVE]]
|
|
// CHECK-NEXT: [[CAST:%.*]] = bitcast i8* [[NEW]] to [[A]]*
|
|
// CHECK-NEXT: invoke void @_ZN5test11BC1Ev([[B:%.*]]* [[T0:%.*]])
|
|
// CHECK: [[T1:%.*]] = invoke i32 @_ZN5test11BcviEv([[B]]* [[T0]])
|
|
// CHECK: invoke void @_ZN5test11AC1Ei([[A]]* [[CAST]], i32 [[T1]])
|
|
// CHECK: store i1 false, i1* [[ACTIVE]]
|
|
|
|
// CHECK98-NEXT: invoke void @_ZN5test11BD1Ev([[B]]* [[T0]])
|
|
// CHECK11-NEXT: call void @_ZN5test11BD1Ev([[B]]* [[T0]])
|
|
|
|
// CHECK: ret [[A]]* [[CAST]]
|
|
// CHECK: [[ISACTIVE:%.*]] = load i1, i1* [[ACTIVE]]
|
|
// CHECK-NEXT: br i1 [[ISACTIVE]]
|
|
// CHECK: call void @_ZdlPv(i8* [[NEW]])
|
|
return new A(B());
|
|
}
|
|
|
|
A *e() {
|
|
// CHECK: define [[A:%.*]]* @_ZN5test11eEv()
|
|
// CHECK: [[ACTIVE:%.*]] = alloca i1
|
|
// CHECK-NEXT: [[NEW:%.*]] = call i8* @_Znwm(i64 8)
|
|
// CHECK-NEXT: store i1 true, i1* [[ACTIVE]]
|
|
// CHECK-NEXT: [[CAST:%.*]] = bitcast i8* [[NEW]] to [[A]]*
|
|
// CHECK-NEXT: invoke void @_ZN5test11BC1Ev([[B:%.*]]* [[T0:%.*]])
|
|
// CHECK: [[T1:%.*]] = invoke i32 @_ZN5test11BcviEv([[B]]* [[T0]])
|
|
// CHECK: invoke void @_ZN5test11BC1Ev([[B]]* [[T2:%.*]])
|
|
// CHECK: [[T3:%.*]] = invoke i32 @_ZN5test11BcviEv([[B]]* [[T2]])
|
|
// CHECK: invoke void @_ZN5test11AC1Eii([[A]]* [[CAST]], i32 [[T1]], i32 [[T3]])
|
|
// CHECK: store i1 false, i1* [[ACTIVE]]
|
|
|
|
// CHECK98-NEXT: invoke void @_ZN5test11BD1Ev([[B]]* [[T2]])
|
|
// CHECK11-NEXT: call void @_ZN5test11BD1Ev([[B]]* [[T2]])
|
|
|
|
// CHECK98: invoke void @_ZN5test11BD1Ev([[B]]* [[T0]])
|
|
// CHECK11: call void @_ZN5test11BD1Ev([[B]]* [[T0]])
|
|
|
|
// CHECK: ret [[A]]* [[CAST]]
|
|
// CHECK: [[ISACTIVE:%.*]] = load i1, i1* [[ACTIVE]]
|
|
// CHECK-NEXT: br i1 [[ISACTIVE]]
|
|
// CHECK: call void @_ZdlPv(i8* [[NEW]])
|
|
return new A(B(), B());
|
|
}
|
|
A *f() {
|
|
return new A(makeB().x);
|
|
}
|
|
A *g() {
|
|
return new A(makeB());
|
|
}
|
|
A *h() {
|
|
return new A(makeB(), makeB());
|
|
}
|
|
|
|
A *i() {
|
|
// CHECK: define [[A:%.*]]* @_ZN5test11iEv()
|
|
// CHECK: [[X:%.*]] = alloca [[A]]*, align 8
|
|
// CHECK: [[ACTIVE:%.*]] = alloca i1
|
|
// CHECK: [[NEW:%.*]] = call i8* @_Znwm(i64 8)
|
|
// CHECK-NEXT: store i1 true, i1* [[ACTIVE]]
|
|
// CHECK-NEXT: [[CAST:%.*]] = bitcast i8* [[NEW]] to [[A]]*
|
|
// CHECK-NEXT: invoke void @_ZN5test15makeBEv([[B:%.*]]* sret [[T0:%.*]])
|
|
// CHECK: [[T1:%.*]] = invoke i32 @_ZN5test11BcviEv([[B]]* [[T0]])
|
|
// CHECK: invoke void @_ZN5test11AC1Ei([[A]]* [[CAST]], i32 [[T1]])
|
|
// CHECK: store i1 false, i1* [[ACTIVE]]
|
|
// CHECK-NEXT: store [[A]]* [[CAST]], [[A]]** [[X]], align 8
|
|
// CHECK: invoke void @_ZN5test15makeBEv([[B:%.*]]* sret [[T2:%.*]])
|
|
// CHECK: [[RET:%.*]] = load [[A]]*, [[A]]** [[X]], align 8
|
|
|
|
// CHECK98: invoke void @_ZN5test11BD1Ev([[B]]* [[T2]])
|
|
// CHECK11: call void @_ZN5test11BD1Ev([[B]]* [[T2]])
|
|
|
|
// CHECK98: invoke void @_ZN5test11BD1Ev([[B]]* [[T0]])
|
|
// CHECK11: call void @_ZN5test11BD1Ev([[B]]* [[T0]])
|
|
|
|
// CHECK: ret [[A]]* [[RET]]
|
|
// CHECK: [[ISACTIVE:%.*]] = load i1, i1* [[ACTIVE]]
|
|
// CHECK-NEXT: br i1 [[ISACTIVE]]
|
|
// CHECK: call void @_ZdlPv(i8* [[NEW]])
|
|
A *x;
|
|
return (x = new A(makeB()), makeB(), x);
|
|
}
|
|
}
|
|
|
|
namespace test2 {
|
|
struct A {
|
|
A(int); A(int, int); ~A();
|
|
void *p;
|
|
void *operator new(size_t);
|
|
void operator delete(void*, size_t);
|
|
};
|
|
|
|
A *a() {
|
|
// CHECK: define [[A:%.*]]* @_ZN5test21aEv()
|
|
// CHECK: [[NEW:%.*]] = call i8* @_ZN5test21AnwEm(i64 8)
|
|
// CHECK-NEXT: [[CAST:%.*]] = bitcast i8* [[NEW]] to [[A]]*
|
|
// CHECK-NEXT: invoke void @_ZN5test21AC1Ei([[A]]* [[CAST]], i32 5)
|
|
// CHECK: ret [[A]]* [[CAST]]
|
|
|
|
// CHECK98: invoke void @_ZN5test21AdlEPvm(i8* [[NEW]], i64 8)
|
|
// CHECK11: call void @_ZN5test21AdlEPvm(i8* [[NEW]], i64 8)
|
|
|
|
// CHECK98: call void @__clang_call_terminate(i8* {{%.*}}) [[NR_NUW]]
|
|
return new A(5);
|
|
}
|
|
}
|
|
|
|
namespace test3 {
|
|
struct A {
|
|
A(int); A(int, int); A(const A&); ~A();
|
|
void *p;
|
|
void *operator new(size_t, void*, double);
|
|
void operator delete(void*, void*, double);
|
|
};
|
|
|
|
void *foo();
|
|
double bar();
|
|
A makeA(), *makeAPtr();
|
|
|
|
A *a() {
|
|
// CHECK: define [[A:%.*]]* @_ZN5test31aEv()
|
|
// CHECK: [[FOO:%.*]] = call i8* @_ZN5test33fooEv()
|
|
// CHECK: [[BAR:%.*]] = call double @_ZN5test33barEv()
|
|
// CHECK: [[NEW:%.*]] = call i8* @_ZN5test31AnwEmPvd(i64 8, i8* [[FOO]], double [[BAR]])
|
|
// CHECK-NEXT: [[CAST:%.*]] = bitcast i8* [[NEW]] to [[A]]*
|
|
// CHECK-NEXT: invoke void @_ZN5test31AC1Ei([[A]]* [[CAST]], i32 5)
|
|
// CHECK: ret [[A]]* [[CAST]]
|
|
|
|
// CHECK98: invoke void @_ZN5test31AdlEPvS1_d(i8* [[NEW]], i8* [[FOO]], double [[BAR]])
|
|
// CHECK11: call void @_ZN5test31AdlEPvS1_d(i8* [[NEW]], i8* [[FOO]], double [[BAR]])
|
|
|
|
// CHECK98: call void @__clang_call_terminate(i8* {{%.*}}) [[NR_NUW]]
|
|
return new(foo(),bar()) A(5);
|
|
}
|
|
|
|
// rdar://problem/8439196
|
|
A *b(bool cond) {
|
|
|
|
// CHECK: define [[A:%.*]]* @_ZN5test31bEb(i1 zeroext
|
|
// CHECK: [[SAVED0:%.*]] = alloca i8*
|
|
// CHECK-NEXT: [[SAVED1:%.*]] = alloca i8*
|
|
// CHECK-NEXT: [[CLEANUPACTIVE:%.*]] = alloca i1
|
|
|
|
// CHECK: [[COND:%.*]] = trunc i8 {{.*}} to i1
|
|
// CHECK-NEXT: store i1 false, i1* [[CLEANUPACTIVE]]
|
|
// CHECK-NEXT: br i1 [[COND]]
|
|
return (cond ?
|
|
|
|
// CHECK: [[FOO:%.*]] = call i8* @_ZN5test33fooEv()
|
|
// CHECK-NEXT: [[NEW:%.*]] = call i8* @_ZN5test31AnwEmPvd(i64 8, i8* [[FOO]], double [[CONST:.*]])
|
|
// CHECK-NEXT: store i8* [[NEW]], i8** [[SAVED0]]
|
|
// CHECK-NEXT: store i8* [[FOO]], i8** [[SAVED1]]
|
|
// CHECK-NEXT: store i1 true, i1* [[CLEANUPACTIVE]]
|
|
// CHECK-NEXT: [[CAST:%.*]] = bitcast i8* [[NEW]] to [[A]]*
|
|
// CHECK-NEXT: invoke void @_ZN5test35makeAEv([[A]]* sret [[CAST]])
|
|
// CHECK: br label
|
|
// -> cond.end
|
|
new(foo(),10.0) A(makeA()) :
|
|
|
|
// CHECK: [[MAKE:%.*]] = call [[A]]* @_ZN5test38makeAPtrEv()
|
|
// CHECK: br label
|
|
// -> cond.end
|
|
makeAPtr());
|
|
|
|
// cond.end:
|
|
// CHECK: [[RESULT:%.*]] = phi [[A]]* {{.*}}[[CAST]]{{.*}}[[MAKE]]
|
|
// CHECK: ret [[A]]* [[RESULT]]
|
|
|
|
// in the EH path:
|
|
// CHECK: [[ISACTIVE:%.*]] = load i1, i1* [[CLEANUPACTIVE]]
|
|
// CHECK-NEXT: br i1 [[ISACTIVE]]
|
|
// CHECK: [[V0:%.*]] = load i8*, i8** [[SAVED0]]
|
|
// CHECK-NEXT: [[V1:%.*]] = load i8*, i8** [[SAVED1]]
|
|
|
|
// CHECK98-NEXT: invoke void @_ZN5test31AdlEPvS1_d(i8* [[V0]], i8* [[V1]], double [[CONST]])
|
|
// CHECK11-NEXT: call void @_ZN5test31AdlEPvS1_d(i8* [[V0]], i8* [[V1]], double [[CONST]])
|
|
}
|
|
}
|
|
|
|
namespace test4 {
|
|
struct A {
|
|
A(int); A(int, int); ~A();
|
|
void *p;
|
|
void *operator new(size_t, void*, void*);
|
|
void operator delete(void*, size_t, void*, void*); // not a match
|
|
};
|
|
|
|
A *a() {
|
|
// CHECK: define [[A:%.*]]* @_ZN5test41aEv()
|
|
// CHECK: [[FOO:%.*]] = call i8* @_ZN5test43fooEv()
|
|
// CHECK-NEXT: [[BAR:%.*]] = call i8* @_ZN5test43barEv()
|
|
// CHECK-NEXT: [[NEW:%.*]] = call i8* @_ZN5test41AnwEmPvS1_(i64 8, i8* [[FOO]], i8* [[BAR]])
|
|
// CHECK-NEXT: [[CAST:%.*]] = bitcast i8* [[NEW]] to [[A]]*
|
|
// CHECK-NEXT: call void @_ZN5test41AC1Ei([[A]]* [[CAST]], i32 5)
|
|
// CHECK-NEXT: ret [[A]]* [[CAST]]
|
|
extern void *foo(), *bar();
|
|
|
|
return new(foo(),bar()) A(5);
|
|
}
|
|
}
|
|
|
|
// PR7908
|
|
namespace test5 {
|
|
struct T { T(); ~T(); };
|
|
|
|
struct A {
|
|
A(const A &x, const T &t = T());
|
|
~A();
|
|
};
|
|
|
|
void foo();
|
|
|
|
// CHECK-LABEL: define void @_ZN5test54testEv()
|
|
// CHECK: [[EXNSLOT:%.*]] = alloca i8*
|
|
// CHECK-NEXT: [[SELECTORSLOT:%.*]] = alloca i32
|
|
// CHECK-NEXT: [[A:%.*]] = alloca [[A_T:%.*]], align 1
|
|
// CHECK-NEXT: [[T:%.*]] = alloca [[T_T:%.*]], align 1
|
|
// CHECK-NEXT: invoke void @_ZN5test53fooEv()
|
|
// CHECK: [[EXN:%.*]] = load i8*, i8** [[EXNSLOT]]
|
|
// CHECK-NEXT: [[ADJ:%.*]] = call i8* @__cxa_get_exception_ptr(i8* [[EXN]])
|
|
// CHECK-NEXT: [[SRC:%.*]] = bitcast i8* [[ADJ]] to [[A_T]]*
|
|
// CHECK-NEXT: invoke void @_ZN5test51TC1Ev([[T_T]]* [[T]])
|
|
// CHECK: invoke void @_ZN5test51AC1ERKS0_RKNS_1TE([[A_T]]* [[A]], [[A_T]]* dereferenceable({{[0-9]+}}) [[SRC]], [[T_T]]* dereferenceable({{[0-9]+}}) [[T]])
|
|
|
|
// CHECK98: invoke void @_ZN5test51TD1Ev([[T_T]]* [[T]])
|
|
// CHECK11: call void @_ZN5test51TD1Ev([[T_T]]* [[T]])
|
|
|
|
// CHECK98: call i8* @__cxa_begin_catch(i8* [[EXN]]) [[NUW]]
|
|
// CHECK98-NEXT: invoke void @_ZN5test51AD1Ev([[A_T]]* [[A]])
|
|
|
|
// CHECK: call void @__cxa_end_catch()
|
|
void test() {
|
|
try {
|
|
foo();
|
|
} catch (A a) {
|
|
}
|
|
}
|
|
}
|
|
|
|
// PR9303: invalid assert on this
|
|
namespace test6 {
|
|
bool cond();
|
|
void test() {
|
|
try {
|
|
lbl:
|
|
if (cond()) goto lbl;
|
|
} catch (...) {
|
|
}
|
|
}
|
|
}
|
|
|
|
// PR9298
|
|
namespace test7 {
|
|
struct A { A(); ~A(); };
|
|
struct B {
|
|
// The throw() operator means that a bad allocation is signalled
|
|
// with a null return, which means that the initializer is
|
|
// evaluated conditionally.
|
|
static void *operator new(size_t size) throw();
|
|
B(const A&, B*);
|
|
~B();
|
|
};
|
|
|
|
B *test() {
|
|
// CHECK: define [[B:%.*]]* @_ZN5test74testEv()
|
|
// CHECK: [[OUTER_NEW:%.*]] = alloca i1
|
|
// CHECK-NEXT: alloca [[A:%.*]],
|
|
// CHECK-NEXT: alloca i8*
|
|
// CHECK-NEXT: alloca i32
|
|
// CHECK-NEXT: [[OUTER_A:%.*]] = alloca i1
|
|
// CHECK-NEXT: alloca i8*
|
|
// CHECK-NEXT: [[INNER_NEW:%.*]] = alloca i1
|
|
// CHECK-NEXT: alloca [[A]]
|
|
// CHECK-NEXT: [[INNER_A:%.*]] = alloca i1
|
|
|
|
// Allocate the outer object.
|
|
// CHECK-NEXT: [[NEW:%.*]] = call i8* @_ZN5test71BnwEm(
|
|
// CHECK-NEXT: icmp eq i8* [[NEW]], null
|
|
|
|
// These stores, emitted before the outermost conditional branch,
|
|
// deactivate the temporary cleanups.
|
|
// CHECK-NEXT: store i1 false, i1* [[OUTER_NEW]]
|
|
// CHECK-NEXT: store i1 false, i1* [[OUTER_A]]
|
|
// CHECK-NEXT: store i1 false, i1* [[INNER_NEW]]
|
|
// CHECK-NEXT: store i1 false, i1* [[INNER_A]]
|
|
// CHECK-NEXT: br i1
|
|
|
|
// We passed the first null check; activate that cleanup and continue.
|
|
// CHECK: store i1 true, i1* [[OUTER_NEW]]
|
|
// CHECK-NEXT: bitcast
|
|
|
|
// Create the first A temporary and activate that cleanup.
|
|
// CHECK-NEXT: invoke void @_ZN5test71AC1Ev(
|
|
// CHECK: store i1 true, i1* [[OUTER_A]]
|
|
|
|
// Allocate the inner object.
|
|
// CHECK-NEXT: [[NEW:%.*]] = call i8* @_ZN5test71BnwEm(
|
|
// CHECK-NEXT: icmp eq i8* [[NEW]], null
|
|
// CHECK-NEXT: br i1
|
|
|
|
// We passed the second null check; save that pointer, activate
|
|
// that cleanup, and continue.
|
|
// CHECK: store i8* [[NEW]]
|
|
// CHECK-NEXT: store i1 true, i1* [[INNER_NEW]]
|
|
// CHECK-NEXT: bitcast
|
|
|
|
// Build the second A temporary and activate that cleanup.
|
|
// CHECK-NEXT: invoke void @_ZN5test71AC1Ev(
|
|
// CHECK: store i1 true, i1* [[INNER_A]]
|
|
|
|
// Build the inner B object and deactivate the inner delete cleanup.
|
|
// CHECK-NEXT: invoke void @_ZN5test71BC1ERKNS_1AEPS0_(
|
|
// CHECK: store i1 false, i1* [[INNER_NEW]]
|
|
// CHECK: phi
|
|
|
|
// Build the outer B object and deactivate the outer delete cleanup.
|
|
// CHECK-NEXT: invoke void @_ZN5test71BC1ERKNS_1AEPS0_(
|
|
// CHECK: store i1 false, i1* [[OUTER_NEW]]
|
|
// CHECK: phi
|
|
// CHECK-NEXT: store [[B]]*
|
|
|
|
// Destroy the inner A object.
|
|
// CHECK-NEXT: load i1, i1* [[INNER_A]]
|
|
// CHECK-NEXT: br i1
|
|
|
|
// CHECK98: invoke void @_ZN5test71AD1Ev(
|
|
// CHECK11: call void @_ZN5test71AD1Ev(
|
|
|
|
// Destroy the outer A object.
|
|
// CHECK: load i1, i1* [[OUTER_A]]
|
|
// CHECK-NEXT: br i1
|
|
|
|
// CHECK98: invoke void @_ZN5test71AD1Ev(
|
|
// CHECK11: call void @_ZN5test71AD1Ev(
|
|
|
|
return new B(A(), new B(A(), 0));
|
|
}
|
|
}
|
|
|
|
// Just don't crash.
|
|
namespace test8 {
|
|
struct A {
|
|
// Having both of these is required to trigger the assert we're
|
|
// trying to avoid.
|
|
A(const A&);
|
|
A&operator=(const A&);
|
|
|
|
~A();
|
|
};
|
|
|
|
A makeA();
|
|
void test() {
|
|
throw makeA();
|
|
}
|
|
// CHECK-LABEL: define void @_ZN5test84testEv
|
|
}
|
|
|
|
// Make sure we generate the correct code for the delete[] call which
|
|
// happens if A::A() throws. (We were previously calling delete[] on
|
|
// a pointer to the first array element, not the pointer returned by new[].)
|
|
// PR10870
|
|
namespace test9 {
|
|
struct A {
|
|
A();
|
|
~A();
|
|
};
|
|
A* test() {
|
|
return new A[10];
|
|
}
|
|
// CHECK: define {{%.*}}* @_ZN5test94testEv
|
|
// CHECK: [[TEST9_NEW:%.*]] = call i8* @_Znam
|
|
// CHECK: call void @_ZdaPv(i8* [[TEST9_NEW]])
|
|
}
|
|
|
|
// In a destructor with a function-try-block, a return statement in a
|
|
// catch handler behaves differently from running off the end of the
|
|
// catch handler. PR13102.
|
|
namespace test10 {
|
|
extern void cleanup();
|
|
extern bool suppress;
|
|
|
|
struct A { ~A(); };
|
|
A::~A() try { cleanup(); } catch (...) { return; }
|
|
// CHECK-LABEL: define void @_ZN6test101AD1Ev(
|
|
// CHECK: invoke void @_ZN6test107cleanupEv()
|
|
// CHECK-NOT: rethrow
|
|
// CHECK: ret void
|
|
|
|
struct B { ~B(); };
|
|
B::~B() try { cleanup(); } catch (...) {}
|
|
// CHECK-LABEL: define void @_ZN6test101BD1Ev(
|
|
// CHECK: invoke void @_ZN6test107cleanupEv()
|
|
// CHECK: call i8* @__cxa_begin_catch
|
|
// CHECK-NEXT: invoke void @__cxa_rethrow()
|
|
// CHECK: unreachable
|
|
|
|
struct C { ~C(); };
|
|
C::~C() try { cleanup(); } catch (...) { if (suppress) return; }
|
|
// CHECK-LABEL: define void @_ZN6test101CD1Ev(
|
|
// CHECK: invoke void @_ZN6test107cleanupEv()
|
|
// CHECK: call i8* @__cxa_begin_catch
|
|
// CHECK-NEXT: load i8, i8* @_ZN6test108suppressE, align 1
|
|
// CHECK-NEXT: trunc
|
|
// CHECK-NEXT: br i1
|
|
|
|
// CHECK98: call void @__cxa_end_catch()
|
|
// CHECK98-NEXT: br label
|
|
// CHECK11: invoke void @__cxa_end_catch()
|
|
// CHECK11-NEXT: to label
|
|
|
|
// CHECK: invoke void @__cxa_rethrow()
|
|
// CHECK: unreachable
|
|
}
|
|
|
|
// Ensure that an exception in a constructor destroys
|
|
// already-constructed array members. PR14514
|
|
namespace test11 {
|
|
struct A {
|
|
A();
|
|
~A() {}
|
|
};
|
|
|
|
struct C {
|
|
A single;
|
|
A array[2][3];
|
|
|
|
C();
|
|
};
|
|
|
|
C::C() {
|
|
throw 0;
|
|
}
|
|
// CHECK-LABEL: define void @_ZN6test111CC2Ev(
|
|
// CHECK: [[THIS:%.*]] = load [[C:%.*]]*, [[C:%.*]]** {{%.*}}
|
|
// Construct single.
|
|
// CHECK-NEXT: [[SINGLE:%.*]] = getelementptr inbounds [[C]], [[C]]* [[THIS]], i32 0, i32 0
|
|
// CHECK-NEXT: call void @_ZN6test111AC1Ev([[A:%.*]]* [[SINGLE]])
|
|
// Construct array.
|
|
// CHECK-NEXT: [[ARRAY:%.*]] = getelementptr inbounds [[C]], [[C]]* [[THIS]], i32 0, i32 1
|
|
// CHECK-NEXT: [[ARRAYBEGIN:%.*]] = getelementptr inbounds [2 x [3 x [[A]]]], [2 x [3 x [[A]]]]* [[ARRAY]], i32 0, i32 0, i32 0
|
|
// CHECK-NEXT: [[ARRAYEND:%.*]] = getelementptr inbounds [[A]], [[A]]* [[ARRAYBEGIN]], i64 6
|
|
// CHECK-NEXT: br label
|
|
// CHECK: [[CUR:%.*]] = phi [[A]]* [ [[ARRAYBEGIN]], {{%.*}} ], [ [[NEXT:%.*]], {{%.*}} ]
|
|
// CHECK-NEXT: invoke void @_ZN6test111AC1Ev([[A:%.*]]* [[CUR]])
|
|
// CHECK: [[NEXT]] = getelementptr inbounds [[A]], [[A]]* [[CUR]], i64 1
|
|
// CHECK-NEXT: [[DONE:%.*]] = icmp eq [[A]]* [[NEXT]], [[ARRAYEND]]
|
|
// CHECK-NEXT: br i1 [[DONE]],
|
|
// throw 0;
|
|
// CHECK: invoke void @__cxa_throw(
|
|
// Landing pad 1, from constructor in array-initialization loop:
|
|
// CHECK: landingpad
|
|
// - First, destroy already-constructed bits of array.
|
|
// CHECK: [[EMPTY:%.*]] = icmp eq [[A]]* [[ARRAYBEGIN]], [[CUR]]
|
|
// CHECK-NEXT: br i1 [[EMPTY]]
|
|
// CHECK: [[AFTER:%.*]] = phi [[A]]* [ [[CUR]], {{%.*}} ], [ [[ELT:%.*]], {{%.*}} ]
|
|
// CHECK-NEXT: [[ELT]] = getelementptr inbounds [[A]], [[A]]* [[AFTER]], i64 -1
|
|
|
|
// CHECK98-NEXT: invoke void @_ZN6test111AD1Ev([[A]]* [[ELT]])
|
|
// CHECK11-NEXT: call void @_ZN6test111AD1Ev([[A]]* [[ELT]])
|
|
|
|
// CHECK: [[DONE:%.*]] = icmp eq [[A]]* [[ELT]], [[ARRAYBEGIN]]
|
|
// CHECK-NEXT: br i1 [[DONE]],
|
|
// - Next, chain to cleanup for single.
|
|
// CHECK: br label
|
|
// Landing pad 2, from throw site.
|
|
// CHECK: landingpad
|
|
// - First, destroy all of array.
|
|
// CHECK: [[ARRAYBEGIN:%.*]] = getelementptr inbounds [2 x [3 x [[A]]]], [2 x [3 x [[A]]]]* [[ARRAY]], i32 0, i32 0, i32 0
|
|
// CHECK-NEXT: [[ARRAYEND:%.*]] = getelementptr inbounds [[A]], [[A]]* [[ARRAYBEGIN]], i64 6
|
|
// CHECK-NEXT: br label
|
|
// CHECK: [[AFTER:%.*]] = phi [[A]]* [ [[ARRAYEND]], {{%.*}} ], [ [[ELT:%.*]], {{%.*}} ]
|
|
// CHECK-NEXT: [[ELT]] = getelementptr inbounds [[A]], [[A]]* [[AFTER]], i64 -1
|
|
|
|
// CHECK98-NEXT: invoke void @_ZN6test111AD1Ev([[A]]* [[ELT]])
|
|
// CHECK11-NEXT: call void @_ZN6test111AD1Ev([[A]]* [[ELT]])
|
|
|
|
// CHECK: [[DONE:%.*]] = icmp eq [[A]]* [[ELT]], [[ARRAYBEGIN]]
|
|
// CHECK-NEXT: br i1 [[DONE]],
|
|
// - Next, chain to cleanup for single.
|
|
// CHECK: br label
|
|
// Finally, the cleanup for single.
|
|
|
|
// CHECK98: invoke void @_ZN6test111AD1Ev([[A]]* [[SINGLE]])
|
|
// CHECK11: call void @_ZN6test111AD1Ev([[A]]* [[SINGLE]])
|
|
|
|
// CHECK: br label
|
|
// CHECK: resume
|
|
// (After this is a terminate landingpad.)
|
|
}
|
|
|
|
namespace test12 {
|
|
struct A {
|
|
void operator delete(void *, void *);
|
|
A();
|
|
};
|
|
|
|
A *test(void *ptr) {
|
|
return new (ptr) A();
|
|
}
|
|
// CHECK-LABEL: define {{.*}} @_ZN6test124testEPv(
|
|
// CHECK: [[PTR:%.*]] = load i8*, i8*
|
|
// CHECK-NEXT: [[CAST:%.*]] = bitcast i8* [[PTR]] to [[A:%.*]]*
|
|
// CHECK-NEXT: invoke void @_ZN6test121AC1Ev([[A]]* [[CAST]])
|
|
// CHECK: ret [[A]]* [[CAST]]
|
|
|
|
// CHECK98: invoke void @_ZN6test121AdlEPvS1_(i8* [[PTR]], i8* [[PTR]])
|
|
// CHECK11: call void @_ZN6test121AdlEPvS1_(i8* [[PTR]], i8* [[PTR]])
|
|
}
|
|
|
|
// CHECK98: attributes [[NI_NR_NUW]] = { noinline noreturn nounwind }
|