diff options
Diffstat (limited to 'test/CodeGenCXX')
116 files changed, 4013 insertions, 125 deletions
diff --git a/test/CodeGenCXX/2007-01-06-PtrMethodInit.cpp b/test/CodeGenCXX/2007-01-06-PtrMethodInit.cpp index f3aa51e725b15..37005c5e9df77 100644 --- a/test/CodeGenCXX/2007-01-06-PtrMethodInit.cpp +++ b/test/CodeGenCXX/2007-01-06-PtrMethodInit.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -emit-llvm %s -o - +// RUN: %clang_cc1 -emit-llvm %s -o - -triple i386-apple-macosx10.7.2 // PR1084 extern "C" diff --git a/test/CodeGenCXX/2011-12-19-init-list-ctor.cpp b/test/CodeGenCXX/2011-12-19-init-list-ctor.cpp new file mode 100644 index 0000000000000..a853a57fd5630 --- /dev/null +++ b/test/CodeGenCXX/2011-12-19-init-list-ctor.cpp @@ -0,0 +1,26 @@ +// RUN: %clang_cc1 %s -emit-llvm -o - -triple x86_64-linux-gnu | FileCheck %s + +struct A { + A(const char *); +}; + +// CHECK: @arr = global [3 x %struct.S] zeroinitializer +// CHECK: @.str = {{.*}}constant [6 x i8] c"hello\00" +// CHECK: @.str1 = {{.*}}constant [6 x i8] c"world\00" +// CHECK: @.str2 = {{.*}}constant [8 x i8] c"goodbye\00" + +struct S { + int n; + A s; +} arr[] = { + { 0, "hello" }, + { 1, "world" }, + { 2, "goodbye" } +}; + +// CHECK: store i32 0, i32* getelementptr inbounds ([3 x %struct.S]* @arr, i64 0, i64 0, i32 0) +// CHECK: call void @_ZN1AC1EPKc(%struct.A* getelementptr inbounds ([3 x %struct.S]* @arr, i64 0, i64 0, i32 1), i8* getelementptr inbounds ([6 x i8]* @.str, i32 0, i32 0)) +// CHECK: store i32 1, i32* getelementptr inbounds ([3 x %struct.S]* @arr, i64 0, i64 1, i32 0) +// CHECK: call void @_ZN1AC1EPKc(%struct.A* getelementptr inbounds ([3 x %struct.S]* @arr, i64 0, i64 1, i32 1), i8* getelementptr inbounds ([6 x i8]* @.str1, i32 0, i32 0)) +// CHECK: store i32 2, i32* getelementptr inbounds ([3 x %struct.S]* @arr, i64 0, i64 2, i32 0) +// CHECK: call void @_ZN1AC1EPKc(%struct.A* getelementptr inbounds ([3 x %struct.S]* @arr, i64 0, i64 2, i32 1), i8* getelementptr inbounds ([8 x i8]* @.str2, i32 0, i32 0)) diff --git a/test/CodeGenCXX/2012-02-06-VecInitialization.cpp b/test/CodeGenCXX/2012-02-06-VecInitialization.cpp new file mode 100644 index 0000000000000..720420ea7deab --- /dev/null +++ b/test/CodeGenCXX/2012-02-06-VecInitialization.cpp @@ -0,0 +1,8 @@ +// RUN: %clang_cc1 -emit-llvm -o - -triple i386-apple-darwin %s | FileCheck %s +// PR11930 + +typedef char vec_t __attribute__ ((__ext_vector_type__ (8))); +void h() { +// CHECK: store <8 x i8> + vec_t v(0); +} diff --git a/test/CodeGenCXX/2012-03-16-StoreAlign.cpp b/test/CodeGenCXX/2012-03-16-StoreAlign.cpp new file mode 100644 index 0000000000000..a6375f824a671 --- /dev/null +++ b/test/CodeGenCXX/2012-03-16-StoreAlign.cpp @@ -0,0 +1,36 @@ +// RUN: %clang_cc1 -emit-llvm -o - -triple x86_64-apple-darwin %s | FileCheck %s +// <rdar://problem/11043589> + +struct Length { + Length(double v) { + m_floatValue = static_cast<float>(v); + } + + bool operator==(const Length& o) const { + return getFloatValue() == o.getFloatValue(); + } + bool operator!=(const Length& o) const { return !(*this == o); } +private: + float getFloatValue() const { + return m_floatValue; + } + float m_floatValue; +}; + + +struct Foo { + static Length inchLength(double inch); + static bool getPageSizeFromName(const Length &A) { + static const Length legalWidth = inchLength(8.5); + if (A != legalWidth) return true; + return false; + } +}; + +// CHECK: @_ZZN3Foo19getPageSizeFromNameERK6LengthE10legalWidth = linkonce_odr global %struct.Length zeroinitializer, align 4 +// CHECK: store float %{{.*}}, float* getelementptr inbounds (%struct.Length* @_ZZN3Foo19getPageSizeFromNameERK6LengthE10legalWidth, i32 0, i32 0), align 1 + +bool bar(Length &b) { + Foo f; + return f.getPageSizeFromName(b); +} diff --git a/test/CodeGenCXX/apple-kext-guard-variable.cpp b/test/CodeGenCXX/apple-kext-guard-variable.cpp index 26b0d14b34d60..76875a0b69ae7 100644 --- a/test/CodeGenCXX/apple-kext-guard-variable.cpp +++ b/test/CodeGenCXX/apple-kext-guard-variable.cpp @@ -1,4 +1,4 @@ -// RUN: %clang -ccc-host-triple x86_64-apple-darwin10 -S -o %t.s -mkernel -Xclang -verify %s +// RUN: %clang -target x86_64-apple-darwin10 -S -o %t.s -mkernel -Xclang -verify %s // rdar://problem/9143356 diff --git a/test/CodeGenCXX/apple-kext.cpp b/test/CodeGenCXX/apple-kext.cpp new file mode 100644 index 0000000000000..03506a8aacf50 --- /dev/null +++ b/test/CodeGenCXX/apple-kext.cpp @@ -0,0 +1,22 @@ +// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fno-use-cxa-atexit -fapple-kext -emit-llvm -o - %s | FileCheck %s + +// CHECK: @_ZN5test01aE = global [[A:%.*]] zeroinitializer +// CHECK: @llvm.global_ctors = appending global {{.*}} { i32 65535, void ()* [[CTOR0:@.*]] } +// CHECK: @llvm.global_dtors = appending global {{.*}} { i32 65535, void ()* [[DTOR0:@.*]] } + +// rdar://11241230 +namespace test0 { + struct A { A(); ~A(); }; + A a; +} +// CHECK: define internal void [[CTOR0_:@.*]]() +// CHECK: call void @_ZN5test01AC1Ev([[A]]* @_ZN5test01aE) +// CHECK-NEXT: ret void + +// CHECK: define internal void [[CTOR0]]() +// CHECK: call void [[CTOR0_]]() +// CHECK-NEXT: ret void + +// CHECK: define internal void [[DTOR0]]() +// CHECK: call void @_ZN5test01AD1Ev([[A]]* @_ZN5test01aE) +// CHECK-NEXT: ret void diff --git a/test/CodeGenCXX/arm.cpp b/test/CodeGenCXX/arm.cpp index a767f425553ba..6c60f3057c1f9 100644 --- a/test/CodeGenCXX/arm.cpp +++ b/test/CodeGenCXX/arm.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 %s -triple=thumbv7-apple-darwin3.0.0-iphoneos -fno-use-cxa-atexit -target-abi apcs-gnu -emit-llvm -o - -fexceptions | FileCheck %s +// RUN: %clang_cc1 %s -triple=thumbv7-apple-ios3.0 -fno-use-cxa-atexit -target-abi apcs-gnu -emit-llvm -o - -fexceptions | FileCheck %s // CHECK: @_ZZN5test74testEvE1x = internal global i32 0, align 4 // CHECK: @_ZGVZN5test74testEvE1x = internal global i32 0 @@ -20,9 +20,17 @@ public: // The global dtor needs the right calling conv with -fno-use-cxa-atexit // rdar://7817590 -// Checked at end of file. bar baz; +// PR9593 +// Make sure atexit(3) is used for global dtors. + +// CHECK: call [[BAR:%.*]]* @_ZN3barC1Ev( +// CHECK-NEXT: call i32 @atexit(void ()* @__dtor_baz) + +// CHECK: define internal void @__dtor_baz() +// CHECK: call [[BAR]]* @_ZN3barD1Ev([[BAR]]* @baz) + // Destructors and constructors must return this. namespace test1 { void foo(); @@ -45,24 +53,18 @@ namespace test1 { } // CHECK: define linkonce_odr [[A]]* @_ZN5test11AC1Ei([[A]]* %this, i32 %i) unnamed_addr - // CHECK: [[RET:%.*]] = alloca [[A]]*, align 4 // CHECK: [[THIS:%.*]] = alloca [[A]]*, align 4 // CHECK: store [[A]]* {{.*}}, [[A]]** [[THIS]] // CHECK: [[THIS1:%.*]] = load [[A]]** [[THIS]] - // CHECK: store [[A]]* [[THIS1]], [[A]]** [[RET]] // CHECK: call [[A]]* @_ZN5test11AC2Ei( - // CHECK: [[THIS2:%.*]] = load [[A]]** [[RET]] - // CHECK: ret [[A]]* [[THIS2]] + // CHECK: ret [[A]]* [[THIS1]] // CHECK: define linkonce_odr [[A]]* @_ZN5test11AD1Ev([[A]]* %this) unnamed_addr - // CHECK: [[RET:%.*]] = alloca [[A]]*, align 4 // CHECK: [[THIS:%.*]] = alloca [[A]]*, align 4 // CHECK: store [[A]]* {{.*}}, [[A]]** [[THIS]] // CHECK: [[THIS1:%.*]] = load [[A]]** [[THIS]] - // CHECK: store [[A]]* [[THIS1]], [[A]]** [[RET]] // CHECK: call [[A]]* @_ZN5test11AD2Ev( - // CHECK: [[THIS2:%.*]] = load [[A]]** [[RET]] - // CHECK: ret [[A]]* [[THIS2]] + // CHECK: ret [[A]]* [[THIS1]] } // Awkward virtual cases. @@ -363,5 +365,5 @@ namespace test8 { // CHECK: call void @_ZN5test21CD0Ev( // CHECK: ret void -// CHECK: @_GLOBAL__D_a() -// CHECK: call %class.bar* @_ZN3barD1Ev(%class.bar* @baz) +// CH_ECK: @_GLOBAL__D_a() +// CH_ECK: call %class.bar* @_ZN3barD1Ev(%class.bar* @baz) diff --git a/test/CodeGenCXX/assign-operator.cpp b/test/CodeGenCXX/assign-operator.cpp index c4b64e6e51add..e19df272c9ad0 100644 --- a/test/CodeGenCXX/assign-operator.cpp +++ b/test/CodeGenCXX/assign-operator.cpp @@ -17,3 +17,14 @@ void f(int i, int j) { // CHECK: ret (i += j) = 17; } + +// Taken from g++.old-deja/g++.jason/net.C +namespace test1 { + template <class T> void fn (T t) { } + template <class T> struct A { + void (*p)(T); + A() { p = fn; } + }; + + A<int> a; +} diff --git a/test/CodeGenCXX/atomic.cpp b/test/CodeGenCXX/atomic.cpp new file mode 100644 index 0000000000000..36bb4ef5608e5 --- /dev/null +++ b/test/CodeGenCXX/atomic.cpp @@ -0,0 +1,17 @@ +// RUN: %clang_cc1 %s -emit-llvm -o - -triple=i686-apple-darwin9 | FileCheck %s + +namespace PR11411 { + template<typename _Tp> struct Ptr { + void f(); + }; + + // CHECK: define linkonce_odr void @_ZN7PR114113PtrIiE1fEv + // CHECK-NOT: ret + template<typename _Tp> inline void Ptr<_Tp>::f() { + int* _refcount; + // CHECK: atomicrmw add i32* + __sync_fetch_and_add(_refcount, 1); + // CHECK-NEXT: ret void + } + void f(Ptr<int> *a) { a->f(); } +} diff --git a/test/CodeGenCXX/atomicinit.cpp b/test/CodeGenCXX/atomicinit.cpp new file mode 100644 index 0000000000000..38d012e6a9a1c --- /dev/null +++ b/test/CodeGenCXX/atomicinit.cpp @@ -0,0 +1,48 @@ +// RUN: %clang_cc1 %s -emit-llvm -O1 -o - -triple=i686-apple-darwin9 | FileCheck %s +struct A { + _Atomic(int) i; + A(int j); + void v(int j); +}; +// Storing to atomic values should be atomic +// CHECK: store atomic i32 +void A::v(int j) { i = j; } +// Initialising atomic values should not be atomic +// CHECK-NOT: store atomic +A::A(int j) : i(j) {} + +struct B { + int i; + B(int x) : i(x) {} +}; + +_Atomic(B) b; + +// CHECK: define void @_Z11atomic_initR1Ai +void atomic_init(A& a, int i) { + // CHECK-NOT: atomic + // CHECK: tail call void @_ZN1BC1Ei + __c11_atomic_init(&b, B(i)); + // CHECK-NEXT: ret void +} + +// CHECK: define void @_Z16atomic_init_boolPU7_Atomicbb +void atomic_init_bool(_Atomic(bool) *ab, bool b) { + // CHECK-NOT: atomic + // CHECK: {{zext i1.*to i8}} + // CHECK-NEXT: store i8 + __c11_atomic_init(ab, b); + // CHECK-NEXT: ret void +} + +struct AtomicBoolMember { + _Atomic(bool) ab; + AtomicBoolMember(bool b); +}; + +// CHECK: define void @_ZN16AtomicBoolMemberC2Eb +// CHECK: {{zext i1.*to i8}} +// CHECK-NEXT: store i8 +// CHECK-NEXT: ret void +AtomicBoolMember::AtomicBoolMember(bool b) : ab(b) { } + diff --git a/test/CodeGenCXX/block.cpp b/test/CodeGenCXX/block.cpp new file mode 100644 index 0000000000000..619d8b0c7ba4d --- /dev/null +++ b/test/CodeGenCXX/block.cpp @@ -0,0 +1,19 @@ +// RUN: %clang_cc1 %s -emit-llvm -o - -fblocks +// Just test that this doesn't crash the compiler... + +void func(void*); + +struct Test +{ + virtual void use() { func((void*)this); } + Test(Test&c) { func((void*)this); } + Test() { func((void*)this); } +}; + +void useBlock(void (^)(void)); + +int main (void) { + __block Test t; + useBlock(^(void) { t.use(); }); +} + diff --git a/test/CodeGenCXX/blocks-cxx11.cpp b/test/CodeGenCXX/blocks-cxx11.cpp new file mode 100644 index 0000000000000..996db1afe69f1 --- /dev/null +++ b/test/CodeGenCXX/blocks-cxx11.cpp @@ -0,0 +1,84 @@ +// RUN: %clang_cc1 %s -fblocks -triple x86_64-apple-darwin -std=c++11 -emit-llvm -o - | FileCheck %s + +template <class T> void takeItByValue(T); +void takeABlock(void (^)()); + +// rdar://problem/11022704 +namespace test_int { + void test() { + const int x = 100; + takeABlock(^{ takeItByValue(x); }); + // CHECK: call void @_Z13takeItByValueIiEvT_(i32 100) + } +} + +namespace test_int_ref { + void test() { + const int y = 200; + const int &x = y; + takeABlock(^{ takeItByValue(x); }); + + // TODO: there's no good reason that this isn't foldable. + // CHECK: call void @_Z13takeItByValueIiEvT_(i32 {{%.*}}) + } +} + +namespace test_float { + void test() { + const float x = 1; + takeABlock(^{ takeItByValue(x); }); + // CHECK: call void @_Z13takeItByValueIfEvT_(float 1.0 + } +} + +namespace test_float_ref { + void test() { + const float y = 100; + const float &x = y; + takeABlock(^{ takeItByValue(x); }); + + // TODO: there's no good reason that this isn't foldable. + // CHECK: call void @_Z13takeItByValueIfEvT_(float {{%.*}}) + } +} + +namespace test_complex_int { + void test() { + constexpr _Complex int x = 500; + takeABlock(^{ takeItByValue(x); }); + // CHECK: store i32 500, + + // CHECK: store i32 500, + // CHECK-NEXT: store i32 0, + // CHECK-NEXT: [[COERCE:%.*]] = bitcast + // CHECK-NEXT: [[CVAL:%.*]] = load i64* [[COERCE]] + // CHECK-NEXT: call void @_Z13takeItByValueICiEvT_(i64 [[CVAL]]) + } +} + +namespace test_complex_int_ref { + void test() { + const _Complex int y = 100; + const _Complex int &x = y; + takeABlock(^{ takeItByValue(x); }); + // CHECK: call void @_Z13takeItByValueICiEvT_(i64 + } +} + +namespace test_complex_int_ref_mutable { + _Complex int y = 100; + void test() { + const _Complex int &x = y; + takeABlock(^{ takeItByValue(x); }); + // CHECK: [[R:%.*]] = load i32* getelementptr inbounds ({ i32, i32 }* @_ZN28test_complex_int_ref_mutable1yE, i32 0, i32 0) + // CHECK-NEXT: [[I:%.*]] = load i32* getelementptr inbounds ({ i32, i32 }* @_ZN28test_complex_int_ref_mutable1yE, i32 0, i32 1) + // CHECK-NEXT: [[RSLOT:%.*]] = getelementptr inbounds { i32, i32 }* [[CSLOT:%.*]], i32 0, i32 0 + // CHECK-NEXT: [[ISLOT:%.*]] = getelementptr inbounds { i32, i32 }* [[CSLOT]], i32 0, i32 1 + // CHECK-NEXT: store i32 [[R]], i32* [[RSLOT]] + // CHECK-NEXT: store i32 [[I]], i32* [[ISLOT]] + // CHECK-NEXT: [[COERCE:%.*]] = bitcast { i32, i32 }* [[CSLOT]] to i64* + // CHECK-NEXT: [[CVAL:%.*]] = load i64* [[COERCE]], + // CHECK-NEXT: call void @_Z13takeItByValueICiEvT_(i64 [[CVAL]]) + } +} + diff --git a/test/CodeGenCXX/blocks.cpp b/test/CodeGenCXX/blocks.cpp index cc56525e1d54a..eb544787da7e2 100644 --- a/test/CodeGenCXX/blocks.cpp +++ b/test/CodeGenCXX/blocks.cpp @@ -128,3 +128,101 @@ namespace test4 { // CHECK-NEXT: ret void } +namespace test5 { + struct A { + unsigned afield; + A(); + A(const A&); + ~A(); + void foo() const; + }; + + void doWithBlock(void(^)()); + + void test(bool cond) { + A x; + void (^b)() = (cond ? ^{ x.foo(); } : (void(^)()) 0); + doWithBlock(b); + } + + // CHECK: define void @_ZN5test54testEb( + // CHECK: [[COND:%.*]] = alloca i8 + // CHECK-NEXT: [[X:%.*]] = alloca [[A:%.*]], align 4 + // CHECK-NEXT: [[B:%.*]] = alloca void ()*, align 8 + // CHECK-NEXT: [[BLOCK:%.*]] = alloca [[BLOCK_T:.*]], align 8 + // CHECK-NEXT: [[CLEANUP_ACTIVE:%.*]] = alloca i1 + // CHECK-NEXT: [[T0:%.*]] = zext i1 + // CHECK-NEXT: store i8 [[T0]], i8* [[COND]], align 1 + // CHECK-NEXT: call void @_ZN5test51AC1Ev([[A]]* [[X]]) + // CHECK-NEXT: [[CLEANUP_ADDR:%.*]] = getelementptr inbounds [[BLOCK_T]]* [[BLOCK]], i32 0, i32 5 + // CHECK-NEXT: [[T0:%.*]] = load i8* [[COND]], align 1 + // CHECK-NEXT: [[T1:%.*]] = trunc i8 [[T0]] to i1 + // CHECK-NEXT: store i1 false, i1* [[CLEANUP_ACTIVE]] + // CHECK-NEXT: br i1 [[T1]], + + // CHECK-NOT: br + // CHECK: [[CAPTURE:%.*]] = getelementptr inbounds [[BLOCK_T]]* [[BLOCK]], i32 0, i32 5 + // CHECK-NEXT: call void @_ZN5test51AC1ERKS0_([[A]]* [[CAPTURE]], [[A]]* [[X]]) + // CHECK-NEXT: store i1 true, i1* [[CLEANUP_ACTIVE]] + // CHECK-NEXT: bitcast [[BLOCK_T]]* [[BLOCK]] to void ()* + // CHECK-NEXT: br label + // CHECK: br label + // CHECK: phi + // CHECK-NEXT: store + // CHECK-NEXT: load + // CHECK-NEXT: call void @_ZN5test511doWithBlockEU13block_pointerFvvE( + // CHECK-NEXT: [[T0:%.*]] = load i1* [[CLEANUP_ACTIVE]] + // CHECK-NEXT: br i1 [[T0]] + // CHECK: call void @_ZN5test51AD1Ev([[A]]* [[CLEANUP_ADDR]]) + // CHECK-NEXT: br label + // CHECK: call void @_ZN5test51AD1Ev([[A]]* [[X]]) + // CHECK-NEXT: ret void +} + +namespace test6 { + struct A { + A(); + ~A(); + }; + + void foo(const A &, void (^)()); + void bar(); + + void test() { + // Make sure that the temporary cleanup isn't somehow captured + // within the block. + foo(A(), ^{ bar(); }); + bar(); + } + + // CHECK: define void @_ZN5test64testEv() + // CHECK: [[TEMP:%.*]] = alloca [[A:%.*]], align 1 + // CHECK-NEXT: call void @_ZN5test61AC1Ev([[A]]* [[TEMP]]) + // CHECK-NEXT: call void @_ZN5test63fooERKNS_1AEU13block_pointerFvvE( + // CHECK-NEXT: call void @_ZN5test61AD1Ev([[A]]* [[TEMP]]) + // CHECK-NEXT: call void @_ZN5test63barEv() + // CHECK-NEXT: ret void +} + +namespace test7 { + int f() { + static int n; + int *const p = &n; + return ^{ return *p; }(); + } +} + +namespace test8 { + // <rdar://problem/10832617>: failure to capture this after skipping rebuild + // of the 'this' pointer. + struct X { + int x; + + template<typename T> + int foo() { + return ^ { return x; }(); + } + }; + + template int X::foo<int>(); +} diff --git a/test/CodeGenCXX/c99-variable-length-array.cpp b/test/CodeGenCXX/c99-variable-length-array.cpp index 76f99c7b4137d..d486f9b018260 100644 --- a/test/CodeGenCXX/c99-variable-length-array.cpp +++ b/test/CodeGenCXX/c99-variable-length-array.cpp @@ -25,3 +25,13 @@ void f(int argc, const char* argv[]) { // CHECK: call void @_ZN1XD1Ev // CHECK: ret void } + +namespace PR11744 { + // Make sure this doesn't crash; there was a use-after-free issue + // for this testcase. + template<typename T> int f(int n) { + T arr[3][n]; + return 3; + } + int test = f<int>(0); +} diff --git a/test/CodeGenCXX/compound-literals.cpp b/test/CodeGenCXX/compound-literals.cpp index cd44e97c6744f..17a31149e13e7 100644 --- a/test/CodeGenCXX/compound-literals.cpp +++ b/test/CodeGenCXX/compound-literals.cpp @@ -25,3 +25,20 @@ int f() { // CHECK-NEXT: ret i32 [[RESULT]] return ((Y){17, "seventeen"}).i; } + +// CHECK: define i32 @_Z1gv() +int g() { + // CHECK: store [2 x i32]* %{{[a-z0-9.]+}}, [2 x i32]** [[V:%[a-z0-9.]+]] + const int (&v)[2] = (int [2]) {1,2}; + + // CHECK: [[A:%[a-z0-9.]+]] = load [2 x i32]** [[V]] + // CHECK-NEXT: [[A0ADDR:%[a-z0-9.]+]] = getelementptr inbounds [2 x i32]* [[A]], i32 0, {{.*}} 0 + // CHECK-NEXT: [[A0:%[a-z0-9.]+]] = load i32* [[A0ADDR]] + // CHECK-NEXT: ret i32 [[A0]] + return v[0]; +} + +struct Z { int i[3]; }; +int *p = (Z){ {1, 2, 3} }.i; +// CHECK: define {{.*}}__cxx_global_var_init() +// CHECK: store i32* getelementptr inbounds (%struct.Z* @.compoundliteral, i32 0, i32 0, i32 0), i32** @p diff --git a/test/CodeGenCXX/conditional-gnu-ext.cpp b/test/CodeGenCXX/conditional-gnu-ext.cpp index 46c5e7fab6de7..104a91d27356d 100644 --- a/test/CodeGenCXX/conditional-gnu-ext.cpp +++ b/test/CodeGenCXX/conditional-gnu-ext.cpp @@ -140,3 +140,11 @@ namespace test3 { } } + +namespace test4 { + // Make sure this doesn't crash. + void f() { + const int a = 10, b = 20; + const int *c = &(a ?: b); + } +} diff --git a/test/CodeGenCXX/const-base-cast.cpp b/test/CodeGenCXX/const-base-cast.cpp index ed47069d24159..320c790c5e2d7 100644 --- a/test/CodeGenCXX/const-base-cast.cpp +++ b/test/CodeGenCXX/const-base-cast.cpp @@ -1,8 +1,7 @@ -// RUN: %clang_cc1 -O1 -emit-llvm %s -o - | FileCheck %s +// RUN: %clang_cc1 -emit-llvm %s -o - | FileCheck %s // Check that the following construct, which is similar to one which occurs -// in Firefox, is not misfolded (folding it correctly would be a bonus, but -// that doesn't work at the moment, hence the -O1 in the runline). +// in Firefox, is folded correctly. struct A { char x; }; struct B { char y; }; struct C : A,B {}; diff --git a/test/CodeGenCXX/const-init-cxx11.cpp b/test/CodeGenCXX/const-init-cxx11.cpp new file mode 100644 index 0000000000000..c745deebf04b5 --- /dev/null +++ b/test/CodeGenCXX/const-init-cxx11.cpp @@ -0,0 +1,425 @@ +// RUN: %clang_cc1 -verify -triple x86_64-apple-darwin -emit-llvm -o - %s -std=c++11 | FileCheck %s + +// FIXME: The padding in all these objects should be zero-initialized. +namespace StructUnion { + struct A { + int n; + double d; + union U { + constexpr U(int x) : x(x) {} + constexpr U(const char *y) : y(y) {} + int x; + const char *y; + } u; + + constexpr A(int n, double d, int x) : n(n), d(d), u(x) {} + constexpr A(int n, double d, const char *y) : n(n), d(d), u(y) {} + }; + + // CHECK: @_ZN11StructUnion1aE = constant {{.*}} { i32 1, double 2.000000e+00, {{.*}} { i32 3, [4 x i8] undef } } + extern constexpr A a(1, 2.0, 3); + + // CHECK: @_ZN11StructUnion1bE = constant {{.*}} { i32 4, double 5.000000e+00, {{.*}} { i8* getelementptr inbounds ([6 x i8]* @{{.*}}, i32 0, i32 0) } } + extern constexpr A b(4, 5, "hello"); + + struct B { + int n; + }; + + // CHECK: @_ZN11StructUnion1cE = global {{.*}} zeroinitializer + // CHECK: @_ZN11StructUnion2c2E = global {{.*}} zeroinitializer + B c; + B c2 = B(); + + // CHECK: @_ZN11StructUnion1dE = global {{.*}} zeroinitializer + B d[10]; + + struct C { + constexpr C() : c(0) {} + int c; + }; + + // CHECK: @_ZN11StructUnion1eE = global {{.*}} zeroinitializer + C e[10]; + + struct D { + constexpr D() : d(5) {} + int d; + }; + + // CHECK: @_ZN11StructUnion1fE = global {{.*}} { i32 5 } + D f; +} + +namespace BaseClass { + template<typename T, unsigned> struct X : T {}; + struct C { char c = 1; }; + template<unsigned... Ns> struct Cs : X<C,Ns>... {}; + struct N { int n = 3; }; + struct D { double d = 4.0; }; + + template<typename ...Ts> + struct Test : Ts... { constexpr Test() : Ts()..., n(5) {} int n; }; + + using Test1 = Test<N, C, Cs<1,2>, D, X<C,1>>; + // CHECK: @_ZN9BaseClass2t1E = constant {{.*}} { i32 3, i8 1, i8 1, i8 1, double 4.000000e+00, i8 1, i32 5 }, align 8 + extern constexpr Test1 t1 = Test1(); + + struct DN : D, N {}; + struct DND : DN, X<D,0> {}; + struct DNN : DN, X<N,0> {}; + // CHECK: @_ZN9BaseClass3dndE = constant {{.*}} { double 4.000000e+00, i32 3, double 4.000000e+00 } + extern constexpr DND dnd = DND(); + // Note, N subobject is laid out in DN subobject's tail padding. + // CHECK: @_ZN9BaseClass3dnnE = constant {{.*}} { double 4.000000e+00, i32 3, i32 3 } + extern constexpr DNN dnn = DNN(); + + struct E {}; + struct Test2 : X<E,0>, X<E,1>, X<E,2>, X<E,3> {}; + // CHECK: @_ZN9BaseClass2t2E = constant {{.*}} undef + extern constexpr Test2 t2 = Test2(); + + struct __attribute((packed)) PackedD { double y = 2; }; + struct Test3 : C, PackedD { constexpr Test3() {} }; + // CHECK: @_ZN9BaseClass2t3E = constant <{ i8, double }> <{ i8 1, double 2.000000e+00 }> + extern constexpr Test3 t3 = Test3(); +} + +namespace Array { + // CHECK: @_ZN5Array3arrE = constant [2 x i32] [i32 4, i32 0] + extern constexpr int arr[2] = { 4 }; + + // CHECK: @_ZN5Array1cE = constant [6 x [4 x i8]] [{{.*}} c"foo\00", [4 x i8] c"a\00\00\00", [4 x i8] c"bar\00", [4 x i8] c"xyz\00", [4 x i8] c"b\00\00\00", [4 x i8] c"123\00"] + extern constexpr char c[6][4] = { "foo", "a", { "bar" }, { 'x', 'y', 'z' }, { "b" }, '1', '2', '3' }; + + struct C { constexpr C() : n(5) {} int n, m = 3 * n + 1; }; + // CHECK: @_ZN5Array5ctorsE = constant [3 x {{.*}}] [{{.*}} { i32 5, i32 16 }, {{.*}} { i32 5, i32 16 }, {{.*}} { i32 5, i32 16 }] + extern const C ctors[3]; + constexpr C ctors[3]; + + // CHECK: @_ZN5Array1dE = constant {{.*}} { [2 x i32] [i32 1, i32 2], [3 x i32] [i32 3, i32 4, i32 5] } + struct D { int n[2]; int m[3]; } extern constexpr d = { 1, 2, 3, 4, 5 }; + + struct E { + char c[4]; + char d[4]; + constexpr E() : c("foo"), d("x") {} + }; + // CHECK: @_ZN5Array1eE = constant {{.*}} { [4 x i8] c"foo\00", [4 x i8] c"x\00\00\00" } + extern constexpr E e = E(); +} + +namespace MemberPtr { + struct B1 { + int a, b; + virtual void f(); + void g(); + }; + struct B2 { + int c, d; + virtual void h(); + void i(); + }; + struct C : B1 { + int e; + virtual void j(); + void k(); + }; + struct D : C, B2 { + int z; + virtual void l(); + void m(); + }; + + // CHECK: @_ZN9MemberPtr2daE = constant i64 8 + // CHECK: @_ZN9MemberPtr2dbE = constant i64 12 + // CHECK: @_ZN9MemberPtr2dcE = constant i64 32 + // CHECK: @_ZN9MemberPtr2ddE = constant i64 36 + // CHECK: @_ZN9MemberPtr2deE = constant i64 16 + // CHECK: @_ZN9MemberPtr2dzE = constant i64 40 + extern constexpr int (D::*da) = &B1::a; + extern constexpr int (D::*db) = &C::b; + extern constexpr int (D::*dc) = &B2::c; + extern constexpr int (D::*dd) = &D::d; + extern constexpr int (D::*de) = &C::e; + extern constexpr int (D::*dz) = &D::z; + + // CHECK: @_ZN9MemberPtr2baE = constant i64 8 + // CHECK: @_ZN9MemberPtr2bbE = constant i64 12 + // CHECK: @_ZN9MemberPtr2bcE = constant i64 8 + // CHECK: @_ZN9MemberPtr2bdE = constant i64 12 + // CHECK: @_ZN9MemberPtr2beE = constant i64 16 + // CHECK: @_ZN9MemberPtr3b1zE = constant i64 40 + // CHECK: @_ZN9MemberPtr3b2zE = constant i64 16 + extern constexpr int (B1::*ba) = (int(B1::*))&B1::a; + extern constexpr int (B1::*bb) = (int(B1::*))&C::b; + extern constexpr int (B2::*bc) = (int(B2::*))&B2::c; + extern constexpr int (B2::*bd) = (int(B2::*))&D::d; + extern constexpr int (B1::*be) = (int(B1::*))&C::e; + extern constexpr int (B1::*b1z) = (int(B1::*))&D::z; + extern constexpr int (B2::*b2z) = (int(B2::*))&D::z; + + // CHECK: @_ZN9MemberPtr2dfE = constant {{.*}} { i64 1, i64 0 } + // CHECK: @_ZN9MemberPtr2dgE = constant {{.*}} { i64 {{.*}}2B11gEv{{.*}}, i64 0 } + // CHECK: @_ZN9MemberPtr2dhE = constant {{.*}} { i64 1, i64 24 } + // CHECK: @_ZN9MemberPtr2diE = constant {{.*}} { i64 {{.*}}2B21iEv{{.*}}, i64 24 } + // CHECK: @_ZN9MemberPtr2djE = constant {{.*}} { i64 9, i64 0 } + // CHECK: @_ZN9MemberPtr2dkE = constant {{.*}} { i64 {{.*}}1C1kEv{{.*}}, i64 0 } + // CHECK: @_ZN9MemberPtr2dlE = constant {{.*}} { i64 17, i64 0 } + // CHECK: @_ZN9MemberPtr2dmE = constant {{.*}} { i64 {{.*}}1D1mEv{{.*}}, i64 0 } + extern constexpr void (D::*df)() = &C::f; + extern constexpr void (D::*dg)() = &B1::g; + extern constexpr void (D::*dh)() = &B2::h; + extern constexpr void (D::*di)() = &D::i; + extern constexpr void (D::*dj)() = &C::j; + extern constexpr void (D::*dk)() = &C::k; + extern constexpr void (D::*dl)() = &D::l; + extern constexpr void (D::*dm)() = &D::m; + + // CHECK: @_ZN9MemberPtr2bfE = constant {{.*}} { i64 1, i64 0 } + // CHECK: @_ZN9MemberPtr2bgE = constant {{.*}} { i64 {{.*}}2B11gEv{{.*}}, i64 0 } + // CHECK: @_ZN9MemberPtr2bhE = constant {{.*}} { i64 1, i64 0 } + // CHECK: @_ZN9MemberPtr2biE = constant {{.*}} { i64 {{.*}}2B21iEv{{.*}}, i64 0 } + // CHECK: @_ZN9MemberPtr2bjE = constant {{.*}} { i64 9, i64 0 } + // CHECK: @_ZN9MemberPtr2bkE = constant {{.*}} { i64 {{.*}}1C1kEv{{.*}}, i64 0 } + // CHECK: @_ZN9MemberPtr3b1lE = constant {{.*}} { i64 17, i64 0 } + // CHECK: @_ZN9MemberPtr3b1mE = constant {{.*}} { i64 {{.*}}1D1mEv{{.*}}, i64 0 } + // CHECK: @_ZN9MemberPtr3b2lE = constant {{.*}} { i64 17, i64 -24 } + // CHECK: @_ZN9MemberPtr3b2mE = constant {{.*}} { i64 {{.*}}1D1mEv{{.*}}, i64 -24 } + extern constexpr void (B1::*bf)() = (void(B1::*)())&C::f; + extern constexpr void (B1::*bg)() = (void(B1::*)())&B1::g; + extern constexpr void (B2::*bh)() = (void(B2::*)())&B2::h; + extern constexpr void (B2::*bi)() = (void(B2::*)())&D::i; + extern constexpr void (B1::*bj)() = (void(B1::*)())&C::j; + extern constexpr void (B1::*bk)() = (void(B1::*)())&C::k; + extern constexpr void (B1::*b1l)() = (void(B1::*)())&D::l; + extern constexpr void (B1::*b1m)() = (void(B1::*)())&D::m; + extern constexpr void (B2::*b2l)() = (void(B2::*)())&D::l; + extern constexpr void (B2::*b2m)() = (void(B2::*)())&D::m; +} + +namespace LiteralReference { + struct Lit { + constexpr Lit() : n(5) {} + int n; + }; + // FIXME: This should have static initialization, but we do not implement + // that yet. For now, just check that we don't set the (pointer) value of + // the reference to 5! + // + // CHECK: @_ZN16LiteralReference3litE = global {{.*}} null + const Lit &lit = Lit(); +} + +namespace NonLiteralConstexpr { + constexpr int factorial(int n) { + return n ? factorial(n-1) * n : 1; + } + extern void f(int *p); + + struct NonTrivialDtor { + constexpr NonTrivialDtor() : n(factorial(5)), p(&n) {} + ~NonTrivialDtor() { + f(p); + } + + int n; + int *p; + }; + static_assert(!__is_literal(NonTrivialDtor), ""); + // CHECK: @_ZN19NonLiteralConstexpr3ntdE = global {{.*}} { i32 120, i32* getelementptr + NonTrivialDtor ntd; + + struct VolatileMember { + constexpr VolatileMember() : n(5) {} + volatile int n; + }; + static_assert(!__is_literal(VolatileMember), ""); + // CHECK: @_ZN19NonLiteralConstexpr2vmE = global {{.*}} { i32 5 } + VolatileMember vm; + + struct Both { + constexpr Both() : n(10) {} + ~Both(); + volatile int n; + }; + // CHECK: @_ZN19NonLiteralConstexpr1bE = global {{.*}} { i32 10 } + Both b; + + void StaticVars() { + // CHECK: @_ZZN19NonLiteralConstexpr10StaticVarsEvE3ntd = {{.*}} { i32 120, i32* getelementptr {{.*}} + // CHECK: @_ZGVZN19NonLiteralConstexpr10StaticVarsEvE3ntd = + static NonTrivialDtor ntd; + // CHECK: @_ZZN19NonLiteralConstexpr10StaticVarsEvE2vm = {{.*}} { i32 5 } + // CHECK-NOT: @_ZGVZN19NonLiteralConstexpr10StaticVarsEvE2vm = + static VolatileMember vm; + // CHECK: @_ZZN19NonLiteralConstexpr10StaticVarsEvE1b = {{.*}} { i32 10 } + // CHECK: @_ZGVZN19NonLiteralConstexpr10StaticVarsEvE1b = + static Both b; + } +} + +// PR12067 +namespace VirtualMembers { + struct A { + constexpr A(double d) : d(d) {} + virtual void f(); + double d; + }; + struct B : A { + constexpr B() : A(2.0), c{'h', 'e', 'l', 'l', 'o'} {} + constexpr B(int n) : A(n), c{'w', 'o', 'r', 'l', 'd'} {} + virtual void g(); + char c[5]; + }; + struct C { + constexpr C() : n(64) {} + int n; + }; + struct D : C, A, B { + constexpr D() : A(1.0), B(), s(5) {} + short s; + }; + struct E : D, B { + constexpr E() : B(3), c{'b','y','e'} {} + char c[3]; + }; + + // CHECK: @_ZN14VirtualMembers1eE = global { i8**, double, i32, i8**, double, [5 x i8], i16, i8**, double, [5 x i8], [3 x i8] } { i8** getelementptr inbounds ([11 x i8*]* @_ZTVN14VirtualMembers1EE, i64 0, i64 2), double 1.000000e+00, i32 64, i8** getelementptr inbounds ([11 x i8*]* @_ZTVN14VirtualMembers1EE, i64 0, i64 5), double 2.000000e+00, [5 x i8] c"hello", i16 5, i8** getelementptr inbounds ([11 x i8*]* @_ZTVN14VirtualMembers1EE, i64 0, i64 9), double 3.000000e+00, [5 x i8] c"world", [3 x i8] c"bye" } + E e; + + struct nsMemoryImpl { + virtual void f(); + }; + // CHECK: @_ZN14VirtualMembersL13sGlobalMemoryE = internal global { i8** } { i8** getelementptr inbounds ([3 x i8*]* @_ZTVN14VirtualMembers12nsMemoryImplE, i64 0, i64 2) } + static nsMemoryImpl sGlobalMemory; +} + +// Constant initialization tests go before this point, +// dynamic initialization tests go after. + +// We must emit a constant initializer for NonLiteralConstexpr::ntd, but also +// emit an initializer to register its destructor. +// CHECK: define {{.*}}cxx_global_var_init{{.*}} +// CHECK-NOT: NonLiteralConstexpr +// CHECK: call {{.*}}cxa_atexit{{.*}} @_ZN19NonLiteralConstexpr14NonTrivialDtorD1Ev {{.*}} @_ZN19NonLiteralConstexpr3ntdE +// CHECK-NEXT: ret void + +// We don't need to emit any dynamic initialization for NonLiteralConstexpr::vm. +// CHECK-NOT: NonLiteralConstexpr2vm + +// We must emit a constant initializer for NonLiteralConstexpr::b, but also +// emit an initializer to register its destructor. +// CHECK: define {{.*}}cxx_global_var_init{{.*}} +// CHECK-NOT: NonLiteralConstexpr +// CHECK: call {{.*}}cxa_atexit{{.*}} @_ZN19NonLiteralConstexpr4BothD1Ev {{.*}} @_ZN19NonLiteralConstexpr1bE +// CHECK-NEXT: ret void + +// CHECK: define {{.*}}NonLiteralConstexpr10StaticVars +// CHECK-NOT: } +// CHECK: call {{.*}}cxa_atexit{{.*}}@_ZN19NonLiteralConstexpr14NonTrivialDtorD1Ev +// CHECK-NOT: } +// CHECK: call {{.*}}cxa_atexit{{.*}}@_ZN19NonLiteralConstexpr4BothD1Ev + +namespace CrossFuncLabelDiff { + // Make sure we refuse to constant-fold the variable b. + constexpr long a(bool x) { return x ? 0 : (long)&&lbl + (0 && ({lbl: 0;})); } + void test() { static long b = (long)&&lbl - a(false); lbl: return; } + // CHECK: sub nsw i64 ptrtoint (i8* blockaddress(@_ZN18CrossFuncLabelDiff4testEv, {{.*}}) to i64), + // CHECK: store i64 {{.*}}, i64* @_ZZN18CrossFuncLabelDiff4testEvE1b, align 8 +} + +// PR12012 +namespace VirtualBase { + struct B {}; + struct D : virtual B {}; + D d; + // CHECK: call {{.*}}@_ZN11VirtualBase1DC1Ev + + template<typename T> struct X : T { + constexpr X() : T() {} + }; + X<D> x; + // CHECK: call {{.*}}@_ZN11VirtualBase1XINS_1DEEC1Ev +} + +// PR12145 +namespace Unreferenced { + int n; + constexpr int *p = &n; + // We must not emit a load of 'p' here, since it's not odr-used. + int q = *p; + // CHECK-NOT: _ZN12Unreferenced1pE + // CHECK: = load i32* @_ZN12Unreferenced1nE + // CHECK-NEXT: store i32 {{.*}}, i32* @_ZN12Unreferenced1qE + // CHECK-NOT: _ZN12Unreferenced1pE + + // Technically, we are not required to substitute variables of reference types + // initialized by constant expressions, because the special case for odr-use + // of variables in [basic.def.odr]p2 only applies to objects. But we do so + // anyway. + + constexpr int &r = n; + // CHECK-NOT: _ZN12Unreferenced1rE + int s = r; + + const int t = 1; + const int &rt = t; + int f(int); + int u = f(rt); + // CHECK: call i32 @_ZN12Unreferenced1fEi(i32 1) +} + +namespace InitFromConst { + template<typename T> void consume(T); + + const bool b = true; + const int n = 5; + constexpr double d = 4.3; + + struct S { int n = 7; S *p = 0; }; + constexpr S s = S(); + const S &r = s; + constexpr const S *p = &r; + constexpr int S::*mp = &S::n; + constexpr int a[3] = { 1, 4, 9 }; + + void test() { + // CHECK: call void @_ZN13InitFromConst7consumeIbEEvT_(i1 zeroext true) + consume(b); + + // CHECK: call void @_ZN13InitFromConst7consumeIiEEvT_(i32 5) + consume(n); + + // CHECK: call void @_ZN13InitFromConst7consumeIdEEvT_(double 4.300000e+00) + consume(d); + + // CHECK: call void @_ZN13InitFromConst7consumeIRKNS_1SEEEvT_(%"struct.InitFromConst::S"* @_ZN13InitFromConstL1sE) + consume<const S&>(s); + + // FIXME CHECK-NOT: call void @_ZN13InitFromConst7consumeIRKNS_1SEEEvT_(%"struct.InitFromConst::S"* @_ZN13InitFromConstL1sE) + // There's no lvalue-to-rvalue conversion here, so 'r' is odr-used, and + // we're permitted to emit a load of it. This seems likely to be a defect + // in the standard. If we start emitting a direct reference to 's', update + // this test. + consume<const S&>(r); + + // CHECK: call void @_ZN13InitFromConst7consumeIPKNS_1SEEEvT_(%"struct.InitFromConst::S"* @_ZN13InitFromConstL1sE) + consume(p); + + // CHECK: call void @_ZN13InitFromConst7consumeIMNS_1SEiEEvT_(i64 0) + consume(mp); + + // CHECK: call void @_ZN13InitFromConst7consumeIPKiEEvT_(i32* getelementptr inbounds ([3 x i32]* @_ZN13InitFromConstL1aE, i32 0, i32 0)) + consume(a); + } +} + +namespace Null { + decltype(nullptr) null(); + // CHECK: call {{.*}} @_ZN4Null4nullEv( + int *p = null(); + struct S {}; + // CHECK: call {{.*}} @_ZN4Null4nullEv( + int S::*q = null(); +} diff --git a/test/CodeGenCXX/const-init.cpp b/test/CodeGenCXX/const-init.cpp index 797d1377f698d..201ce8f0c64cb 100644 --- a/test/CodeGenCXX/const-init.cpp +++ b/test/CodeGenCXX/const-init.cpp @@ -29,10 +29,50 @@ namespace test2 { struct A { static const double d = 1.0; static const float f = d / 2; - }; + static int g(); + } a; // CHECK: @_ZN5test22t0E = global double {{1\.0+e\+0+}}, align 8 // CHECK: @_ZN5test22t1E = global [2 x double] [double {{1\.0+e\+0+}}, double {{5\.0+e-0*}}1], align 16 + // CHECK: @_ZN5test22t2E = global double* @_ZN5test21A1d + // CHECK: @_ZN5test22t3E = global {{.*}} @_ZN5test21A1g double t0 = A::d; double t1[] = { A::d, A::f }; + const double *t2 = &a.d; + int (*t3)() = &a.g; } + +// We don't expect to fold this in the frontend, but make sure it doesn't crash. +// CHECK: @PR9558 = global float 0.000000e+0 +float PR9558 = reinterpret_cast<const float&>("asd"); + +// An initialized const automatic variable cannot be promoted to a constant +// global if it has a mutable member. +struct MutableMember { + mutable int n; +}; +int writeToMutable() { + // CHECK-NOT: {{.*}}MM{{.*}} = {{.*}}constant + const MutableMember MM = { 0 }; + return ++MM.n; +} + +// Make sure we don't try to fold this in the frontend; the backend can't +// handle it. +// CHECK: @PR11705 = global i128 0 +__int128_t PR11705 = (__int128_t)&PR11705; + +// Make sure we don't try to fold this either. +// CHECK: @_ZZ23UnfoldableAddrLabelDiffvE1x = internal global i128 0 +void UnfoldableAddrLabelDiff() { static __int128_t x = (long)&&a-(long)&&b; a:b:return;} + +// But make sure we do fold this. +// CHECK: @_ZZ21FoldableAddrLabelDiffvE1x = internal global i64 sub (i64 ptrtoint (i8* blockaddress(@_Z21FoldableAddrLabelDiffv +void FoldableAddrLabelDiff() { static long x = (long)&&a-(long)&&b; a:b:return;} + +// CHECK: @i = constant i32* bitcast (float* @PR9558 to i32*) +int &i = reinterpret_cast<int&>(PR9558); + +int arr[2]; +// CHECK: @pastEnd = constant i32* bitcast (i8* getelementptr (i8* bitcast ([2 x i32]* @arr to i8*), i64 8) to i32*) +int &pastEnd = arr[2]; diff --git a/test/CodeGenCXX/constructor-init.cpp b/test/CodeGenCXX/constructor-init.cpp index 6af5188a41f68..9f808f6680ed0 100644 --- a/test/CodeGenCXX/constructor-init.cpp +++ b/test/CodeGenCXX/constructor-init.cpp @@ -201,7 +201,7 @@ namespace PR10720 { pair2(const pair2&) = default; }; - struct pair { + struct pair : X { // Make the copy constructor non-trivial, so we actually generate it. int second[4]; // CHECK-PR10720: define linkonce_odr void @_ZN7PR107204pairC2ERKS0_ // CHECK-PR10720-NOT: ret @@ -220,4 +220,3 @@ namespace PR10720 { } } - diff --git a/test/CodeGenCXX/constructors.cpp b/test/CodeGenCXX/constructors.cpp index ec7f06c868a98..9e2da31f046af 100644 --- a/test/CodeGenCXX/constructors.cpp +++ b/test/CodeGenCXX/constructors.cpp @@ -111,7 +111,5 @@ namespace test1 { B::B() {} // CHECK: define void @_ZN5test11BC2Ev( // CHECK: [[THIS:%.*]] = load [[B:%.*]]** - // CHECK-NEXT: [[A:%.*]] = getelementptr inbounds [[B:%.*]]* [[THIS]], i32 0, i32 1 - // CHECK-NEXT: [[BEGIN:%.*]] = getelementptr inbounds [0 x {{%.*}}]* [[A]], i32 0, i32 0 // CHECK-NEXT: ret void } diff --git a/test/CodeGenCXX/copy-constructor-elim-2.cpp b/test/CodeGenCXX/copy-constructor-elim-2.cpp index a4a688f737d76..9480cbfdbb3a3 100644 --- a/test/CodeGenCXX/copy-constructor-elim-2.cpp +++ b/test/CodeGenCXX/copy-constructor-elim-2.cpp @@ -53,3 +53,25 @@ void f() { } } + +namespace PR12139 { + struct A { + A() : value(1) { } + A(A const &, int value = 2) : value(value) { } + int value; + + static A makeA() { A a; a.value = 2; return a; } + }; + + // CHECK: define i32 @_ZN7PR121394testEv + int test() { + // CHECK: call void @_ZN7PR121391A5makeAEv + // CHECK-NEXT: call void @_ZN7PR121391AC1ERKS0_i + A a(A::makeA(), 3); + // CHECK-NEXT: getelementptr inbounds + // CHECK-NEXT: load + // CHECK-NEXT: ret i32 + return a.value; + } +} + diff --git a/test/CodeGenCXX/cxx-apple-kext.cpp b/test/CodeGenCXX/cxx-apple-kext.cpp index e9a17277b0bbe..e5ec78bf5cb4c 100644 --- a/test/CodeGenCXX/cxx-apple-kext.cpp +++ b/test/CodeGenCXX/cxx-apple-kext.cpp @@ -1,6 +1,6 @@ -// RUN: %clangxx -ccc-host-triple x86_64-apple-darwin10 %s -flto -S -o - |\ +// RUN: %clangxx -target x86_64-apple-darwin10 %s -flto -S -o - |\ // RUN: FileCheck --check-prefix=CHECK-NO-KEXT %s -// RUN: %clangxx -ccc-host-triple x86_64-apple-darwin10 %s -fapple-kext -flto -S -o - |\ +// RUN: %clangxx -target x86_64-apple-darwin10 %s -fapple-kext -flto -S -o - |\ // RUN: FileCheck --check-prefix=CHECK-KEXT %s // CHECK-NO-KEXT-NOT: _GLOBAL__D_a diff --git a/test/CodeGenCXX/cxx0x-initializer-array.cpp b/test/CodeGenCXX/cxx0x-initializer-array.cpp new file mode 100644 index 0000000000000..b773178e6b812 --- /dev/null +++ b/test/CodeGenCXX/cxx0x-initializer-array.cpp @@ -0,0 +1,10 @@ +// RUN: %clang_cc1 -std=c++11 -S -emit-llvm -o - %s | FileCheck %s + +struct A { int a[1]; }; +typedef A x[]; +int f() { + x{{{1}}}; + // CHECK: define i32 @_Z1fv + // CHECK: store i32 1 + // (It's okay if the output changes here, as long as we don't crash.) +} diff --git a/test/CodeGenCXX/cxx0x-initializer-references.cpp b/test/CodeGenCXX/cxx0x-initializer-references.cpp new file mode 100644 index 0000000000000..4c847b8e583c5 --- /dev/null +++ b/test/CodeGenCXX/cxx0x-initializer-references.cpp @@ -0,0 +1,69 @@ +// RUN: %clang_cc1 -std=c++11 -S -emit-llvm -o - %s | FileCheck %s + +namespace reference { + struct A { + int i1, i2; + }; + + void single_init() { + // No superfluous instructions allowed here, they could be + // hiding extra temporaries. + + // CHECK: store i32 1, i32* + // CHECK-NEXT: store i32* %{{.*}}, i32** + const int &cri2a = 1; + + // CHECK-NEXT: store i32 1, i32* + // CHECK-NEXT: store i32* %{{.*}}, i32** + const int &cri1a = {1}; + + // CHECK-NEXT: store i32 1, i32* + int i = 1; + // CHECK-NEXT: store i32* %{{.*}}, i32** + int &ri1a = {i}; + + // CHECK-NEXT: bitcast + // CHECK-NEXT: memcpy + A a{1, 2}; + // CHECK-NEXT: store %{{.*}}* %{{.*}}, %{{.*}}** % + A &ra1a = {a}; + + // CHECK-NEXT: ret + } + + void reference_to_aggregate() { + // CHECK: getelementptr {{.*}}, i32 0, i32 0 + // CHECK-NEXT: store i32 1 + // CHECK-NEXT: getelementptr {{.*}}, i32 0, i32 1 + // CHECK-NEXT: store i32 2 + // CHECK-NEXT: store %{{.*}}* %{{.*}}, %{{.*}}** %{{.*}}, align + const A &ra1{1, 2}; + + // CHECK-NEXT: getelementptr inbounds [3 x i32]* %{{.*}}, i{{32|64}} 0, i{{32|64}} 0 + // CHECK-NEXT: store i32 1 + // CHECK-NEXT: getelementptr inbounds i32* %{{.*}}, i{{32|64}} 1 + // CHECK-NEXT: store i32 2 + // CHECK-NEXT: getelementptr inbounds i32* %{{.*}}, i{{32|64}} 1 + // CHECK-NEXT: store i32 3 + // CHECK-NEXT: store [3 x i32]* %{{.*}}, [3 x i32]** %{{.*}}, align + const int (&arrayRef)[] = {1, 2, 3}; + + // CHECK-NEXT: ret + } + + struct B { + B(); + ~B(); + }; + + void single_init_temp_cleanup() + { + // Ensure lifetime extension. + + // CHECK: call void @_ZN9reference1BC1Ev + // CHECK-NEXT: store %{{.*}}* %{{.*}}, %{{.*}}** % + const B &rb{ B() }; + // CHECK: call void @_ZN9reference1BD1Ev + } + +} diff --git a/test/CodeGenCXX/cxx0x-initializer-stdinitializerlist-pr12086.cpp b/test/CodeGenCXX/cxx0x-initializer-stdinitializerlist-pr12086.cpp new file mode 100644 index 0000000000000..14d2f77291848 --- /dev/null +++ b/test/CodeGenCXX/cxx0x-initializer-stdinitializerlist-pr12086.cpp @@ -0,0 +1,37 @@ +// RUN: %clang_cc1 -std=c++11 -emit-llvm -o - -verify %s + +namespace std { + typedef decltype(sizeof(int)) size_t; + + // libc++'s implementation + template <class _E> + class initializer_list + { + const _E* __begin_; + size_t __size_; + + initializer_list(const _E* __b, size_t __s) + : __begin_(__b), + __size_(__s) + {} + + public: + typedef _E value_type; + typedef const _E& reference; + typedef const _E& const_reference; + typedef size_t size_type; + + typedef const _E* iterator; + typedef const _E* const_iterator; + + initializer_list() : __begin_(nullptr), __size_(0) {} + + size_t size() const {return __size_;} + const _E* begin() const {return __begin_;} + const _E* end() const {return __begin_ + __size_;} + }; +} + +std::initializer_list<std::initializer_list<int>> pleasefail = { + {1, 2}, {3, 4}, {5, 6} // expected-error {{cannot compile}} +}; diff --git a/test/CodeGenCXX/cxx0x-initializer-stdinitializerlist-startend.cpp b/test/CodeGenCXX/cxx0x-initializer-stdinitializerlist-startend.cpp new file mode 100644 index 0000000000000..c533e453a5e4b --- /dev/null +++ b/test/CodeGenCXX/cxx0x-initializer-stdinitializerlist-startend.cpp @@ -0,0 +1,85 @@ +// RUN: %clang_cc1 -std=c++11 -S -emit-llvm -o - %s | FileCheck %s + +namespace std { + typedef decltype(sizeof(int)) size_t; + + // libc++'s implementation with __size_ replaced by __end_ + template <class _E> + class initializer_list + { + const _E* __begin_; + const _E* __end_; + + initializer_list(const _E* __b, const _E* __e) + : __begin_(__b), + __end_(__e) + {} + + public: + typedef _E value_type; + typedef const _E& reference; + typedef const _E& const_reference; + typedef size_t size_type; + + typedef const _E* iterator; + typedef const _E* const_iterator; + + initializer_list() : __begin_(nullptr), __end_(nullptr) {} + + size_t size() const {return __end_ - __begin_;} + const _E* begin() const {return __begin_;} + const _E* end() const {return __end_;} + }; +} + +// CHECK: @_ZL25globalInitList1__initlist = internal global [3 x i32] [i32 1, i32 2, i32 3] +// CHECK: @globalInitList1 = global {{[^ ]+}} { i32* getelementptr inbounds ([3 x i32]* @_ZL25globalInitList1__initlist, {{[^)]*}}), i32* +std::initializer_list<int> globalInitList1 = {1, 2, 3}; + +void fn1(int i) { + // CHECK: define void @_Z3fn1i + // temporary array + // CHECK: [[array:%[^ ]+]] = alloca [3 x i32] + // CHECK: getelementptr inbounds [3 x i32]* [[array]], i{{32|64}} 0 + // CHECK-NEXT: store i32 1, i32* + // CHECK-NEXT: getelementptr + // CHECK-NEXT: store + // CHECK-NEXT: getelementptr + // CHECK-NEXT: load + // CHECK-NEXT: store + // init the list + // CHECK-NEXT: getelementptr + // CHECK-NEXT: getelementptr inbounds [3 x i32]* + // CHECK-NEXT: store i32* + // CHECK-NEXT: getelementptr + // CHECK-NEXT: getelementptr inbounds [3 x i32]* [[array]], i{{32|64}} 0, i{{32|64}} 3 + // CHECK-NEXT: store i32* + std::initializer_list<int> intlist{1, 2, i}; +} + +struct destroyme1 { + ~destroyme1(); +}; +struct destroyme2 { + ~destroyme2(); +}; + + +void fn2() { + // CHECK: define void @_Z3fn2v + void target(std::initializer_list<destroyme1>); + // objects should be destroyed before dm2, after call returns + target({ destroyme1(), destroyme1() }); + // CHECK: call void @_ZN10destroyme1D1Ev + destroyme2 dm2; + // CHECK: call void @_ZN10destroyme2D1Ev +} + +void fn3() { + // CHECK: define void @_Z3fn3v + // objects should be destroyed after dm2 + auto list = { destroyme1(), destroyme1() }; + destroyme2 dm2; + // CHECK: call void @_ZN10destroyme2D1Ev + // CHECK: call void @_ZN10destroyme1D1Ev +} diff --git a/test/CodeGenCXX/cxx0x-initializer-stdinitializerlist.cpp b/test/CodeGenCXX/cxx0x-initializer-stdinitializerlist.cpp new file mode 100644 index 0000000000000..81ce559844665 --- /dev/null +++ b/test/CodeGenCXX/cxx0x-initializer-stdinitializerlist.cpp @@ -0,0 +1,252 @@ +// RUN: %clang_cc1 -std=c++11 -S -emit-llvm -o - %s | FileCheck %s + +namespace std { + typedef decltype(sizeof(int)) size_t; + + // libc++'s implementation + template <class _E> + class initializer_list + { + const _E* __begin_; + size_t __size_; + + initializer_list(const _E* __b, size_t __s) + : __begin_(__b), + __size_(__s) + {} + + public: + typedef _E value_type; + typedef const _E& reference; + typedef const _E& const_reference; + typedef size_t size_type; + + typedef const _E* iterator; + typedef const _E* const_iterator; + + initializer_list() : __begin_(nullptr), __size_(0) {} + + size_t size() const {return __size_;} + const _E* begin() const {return __begin_;} + const _E* end() const {return __begin_ + __size_;} + }; +} + +struct destroyme1 { + ~destroyme1(); +}; +struct destroyme2 { + ~destroyme2(); +}; +struct witharg1 { + witharg1(const destroyme1&); + ~witharg1(); +}; +struct wantslist1 { + wantslist1(std::initializer_list<destroyme1>); + ~wantslist1(); +}; + +// CHECK: @_ZL25globalInitList1__initlist = internal global [3 x i32] [i32 1, i32 2, i32 3] +// CHECK: @globalInitList1 = global %{{[^ ]+}} { i32* getelementptr inbounds ([3 x i32]* @_ZL25globalInitList1__initlist, i32 0, i32 0), i{{32|64}} 3 } +std::initializer_list<int> globalInitList1 = {1, 2, 3}; + +// CHECK: @_ZL25globalInitList2__initlist = internal global [2 x %{{[^ ]*}}] zeroinitializer +// CHECK: @globalInitList2 = global %{{[^ ]+}} { %[[WITHARG:[^ *]+]]* getelementptr inbounds ([2 x +// CHECK: appending global +// CHECK: define internal void +// CHECK: call void @_ZN8witharg1C1ERK10destroyme1(%[[WITHARG]]* getelementptr inbounds ([2 x %[[WITHARG]]]* @_ZL25globalInitList2__initlist, i{{32|64}} 0, i{{32|64}} 0 +// CHECK: call void @_ZN8witharg1C1ERK10destroyme1(%[[WITHARG]]* getelementptr inbounds ([2 x %[[WITHARG]]]* @_ZL25globalInitList2__initlist, i{{32|64}} 0, i{{32|64}} 1 +// CHECK: __cxa_atexit +// CHECK: call void @_ZN10destroyme1D1Ev +// CHECK: call void @_ZN10destroyme1D1Ev +std::initializer_list<witharg1> globalInitList2 = { + witharg1(destroyme1()), witharg1(destroyme1()) +}; + +void fn1(int i) { + // CHECK: define void @_Z3fn1i + // temporary array + // CHECK: [[array:%[^ ]+]] = alloca [3 x i32] + // CHECK: getelementptr inbounds [3 x i32]* [[array]], i{{32|64}} 0 + // CHECK-NEXT: store i32 1, i32* + // CHECK-NEXT: getelementptr + // CHECK-NEXT: store + // CHECK-NEXT: getelementptr + // CHECK-NEXT: load + // CHECK-NEXT: store + // init the list + // CHECK-NEXT: getelementptr + // CHECK-NEXT: getelementptr inbounds [3 x i32]* + // CHECK-NEXT: store i32* + // CHECK-NEXT: getelementptr + // CHECK-NEXT: store i{{32|64}} 3 + std::initializer_list<int> intlist{1, 2, i}; +} + +void fn2() { + // CHECK: define void @_Z3fn2v + void target(std::initializer_list<destroyme1>); + // objects should be destroyed before dm2, after call returns + // CHECK: call void @_Z6targetSt16initializer_listI10destroyme1E + target({ destroyme1(), destroyme1() }); + // CHECK: call void @_ZN10destroyme1D1Ev + destroyme2 dm2; + // CHECK: call void @_ZN10destroyme2D1Ev +} + +void fn3() { + // CHECK: define void @_Z3fn3v + // objects should be destroyed after dm2 + auto list = { destroyme1(), destroyme1() }; + destroyme2 dm2; + // CHECK: call void @_ZN10destroyme2D1Ev + // CHECK: call void @_ZN10destroyme1D1Ev +} + +void fn4() { + // CHECK: define void @_Z3fn4v + void target(std::initializer_list<witharg1>); + // objects should be destroyed before dm2, after call returns + // CHECK: call void @_ZN8witharg1C1ERK10destroyme1 + // CHECK: call void @_Z6targetSt16initializer_listI8witharg1E + target({ witharg1(destroyme1()), witharg1(destroyme1()) }); + // CHECK: call void @_ZN8witharg1D1Ev + // CHECK: call void @_ZN10destroyme1D1Ev + destroyme2 dm2; + // CHECK: call void @_ZN10destroyme2D1Ev +} + +void fn5() { + // CHECK: define void @_Z3fn5v + // temps should be destroyed before dm2 + // objects should be destroyed after dm2 + // CHECK: call void @_ZN8witharg1C1ERK10destroyme1 + auto list = { witharg1(destroyme1()), witharg1(destroyme1()) }; + // CHECK: call void @_ZN10destroyme1D1Ev + destroyme2 dm2; + // CHECK: call void @_ZN10destroyme2D1Ev + // CHECK: call void @_ZN8witharg1D1Ev +} + +void fn6() { + // CHECK: define void @_Z3fn6v + void target(const wantslist1&); + // objects should be destroyed before dm2, after call returns + // CHECK: call void @_ZN10wantslist1C1ESt16initializer_listI10destroyme1E + // CHECK: call void @_Z6targetRK10wantslist1 + target({ destroyme1(), destroyme1() }); + // CHECK: call void @_ZN10wantslist1D1Ev + // CHECK: call void @_ZN10destroyme1D1Ev + destroyme2 dm2; + // CHECK: call void @_ZN10destroyme2D1Ev +} + +void fn7() { + // CHECK: define void @_Z3fn7v + // temps should be destroyed before dm2 + // object should be destroyed after dm2 + // CHECK: call void @_ZN10wantslist1C1ESt16initializer_listI10destroyme1E + wantslist1 wl = { destroyme1(), destroyme1() }; + // CHECK: call void @_ZN10destroyme1D1Ev + destroyme2 dm2; + // CHECK: call void @_ZN10destroyme2D1Ev + // CHECK: call void @_ZN10wantslist1D1Ev +} + +void fn8() { + // CHECK: define void @_Z3fn8v + void target(std::initializer_list<std::initializer_list<destroyme1>>); + // objects should be destroyed before dm2, after call returns + // CHECK: call void @_Z6targetSt16initializer_listIS_I10destroyme1EE + std::initializer_list<destroyme1> inner; + target({ inner, { destroyme1() } }); + // CHECK: call void @_ZN10destroyme1D1Ev + // Only one destroy loop, since only one inner init list is directly inited. + // CHECK-NOT: call void @_ZN10destroyme1D1Ev + destroyme2 dm2; + // CHECK: call void @_ZN10destroyme2D1Ev +} + +void fn9() { + // CHECK: define void @_Z3fn9v + // objects should be destroyed after dm2 + std::initializer_list<destroyme1> inner; + std::initializer_list<std::initializer_list<destroyme1>> list = + { inner, { destroyme1() } }; + destroyme2 dm2; + // CHECK: call void @_ZN10destroyme2D1Ev + // CHECK: call void @_ZN10destroyme1D1Ev + // Only one destroy loop, since only one inner init list is directly inited. + // CHECK-NOT: call void @_ZN10destroyme1D1Ev + // CHECK: ret void +} + +struct haslist1 { + std::initializer_list<int> il; + haslist1(); +}; + +// CHECK: define void @_ZN8haslist1C2Ev +haslist1::haslist1() +// CHECK: alloca [3 x i32] +// CHECK: store i32 1 +// CHECK: store i32 2 +// CHECK: store i32 3 +// CHECK: store i{{32|64}} 3 + : il{1, 2, 3} +{ + destroyme2 dm2; +} + +struct haslist2 { + std::initializer_list<destroyme1> il; + haslist2(); +}; + +// CHECK: define void @_ZN8haslist2C2Ev +haslist2::haslist2() + : il{destroyme1(), destroyme1()} +{ + destroyme2 dm2; + // CHECK: call void @_ZN10destroyme2D1Ev + // CHECK: call void @_ZN10destroyme1D1Ev +} + +void fn10() { + // CHECK: define void @_Z4fn10v + // CHECK: alloca [3 x i32] + // CHECK: call noalias i8* @_Znw{{[jm]}} + // CHECK: store i32 1 + // CHECK: store i32 2 + // CHECK: store i32 3 + // CHECK: store i32* + // CHECK: store i{{32|64}} 3 + (void) new std::initializer_list<int> {1, 2, 3}; +} + +void fn11() { + // CHECK: define void @_Z4fn11v + (void) new std::initializer_list<destroyme1> {destroyme1(), destroyme1()}; + // CHECK: call void @_ZN10destroyme1D1Ev + destroyme2 dm2; + // CHECK: call void @_ZN10destroyme2D1Ev +} + +namespace PR12178 { + struct string { + string(int); + ~string(); + }; + + struct pair { + string a; + int b; + }; + + struct map { + map(std::initializer_list<pair>); + }; + + map m{ {1, 2}, {3, 4} }; +} diff --git a/test/CodeGenCXX/cxx11-unrestricted-union.cpp b/test/CodeGenCXX/cxx11-unrestricted-union.cpp new file mode 100644 index 0000000000000..0397775b7e3c7 --- /dev/null +++ b/test/CodeGenCXX/cxx11-unrestricted-union.cpp @@ -0,0 +1,76 @@ +// RUN: %clang_cc1 -std=c++11 -emit-llvm %s -o - | FileCheck %s + +struct A { + A(); A(const A&); A(A&&); A &operator=(const A&); A &operator=(A&&); ~A(); +}; +struct B { + B(); B(const B&); B(B&&); B &operator=(const B&); B &operator=(B&&); ~B(); +}; + +union U { + U(); + U(const U &); + U(U &&); + U &operator=(const U&); + U &operator=(U&&); + ~U(); + + A a; + int n; +}; + +// CHECK-NOT: _ZN1A +U::U() {} +U::U(const U&) {} +U::U(U&&) {} +U &U::operator=(const U&) { return *this; } +U &U::operator=(U &&) { return *this; } +U::~U() {} + +struct S { + S(); + S(const S &); + S(S &&); + S &operator=(const S&); + S &operator=(S&&); + ~S(); + + union { + A a; + int n; + }; + B b; + int m; +}; + +// CHECK: _ZN1SC2Ev +// CHECK-NOT: _ZN1A +// CHECK: _ZN1BC1Ev +S::S() {} + +// CHECK-NOT: _ZN1A + +// CHECK: _ZN1SC2ERKS_ +// CHECK-NOT: _ZN1A +// CHECK: _ZN1BC1Ev +S::S(const S&) {} + +// CHECK-NOT: _ZN1A + +// CHECK: _ZN1SC2EOS_ +// CHECK-NOT: _ZN1A +// CHECK: _ZN1BC1Ev +S::S(S&&) {} + +// CHECK-NOT: _ZN1A +// CHECK-NOT: _ZN1B +S &S::operator=(const S&) { return *this; } + +S &S::operator=(S &&) { return *this; } + +// CHECK: _ZN1SD2Ev +// CHECK-NOT: _ZN1A +// CHECK: _ZN1BD1Ev +S::~S() {} + +// CHECK-NOT: _ZN1A diff --git a/test/CodeGenCXX/cxx11-user-defined-literal.cpp b/test/CodeGenCXX/cxx11-user-defined-literal.cpp new file mode 100644 index 0000000000000..347ffe91f7d9d --- /dev/null +++ b/test/CodeGenCXX/cxx11-user-defined-literal.cpp @@ -0,0 +1,69 @@ +// RUN: %clang_cc1 -std=c++11 -triple x86_64-linux-gnu -emit-llvm %s -o - | FileCheck %s + +struct S { S(); ~S(); S(const S &); void operator()(int); }; +using size_t = decltype(sizeof(int)); +S operator"" _x(const char *, size_t); +S operator"" _y(wchar_t); +S operator"" _z(unsigned long long); +S operator"" _f(long double); +S operator"" _r(const char *); +template<char...Cs> S operator"" _t() { return S(); } + +// CHECK: @[[s_foo:.*]] = {{.*}} constant [4 x i8] c"foo\00" +// CHECK: @[[s_bar:.*]] = {{.*}} constant [4 x i8] c"bar\00" +// CHECK: @[[s_123:.*]] = {{.*}} constant [4 x i8] c"123\00" +// CHECK: @[[s_4_9:.*]] = {{.*}} constant [4 x i8] c"4.9\00" +// CHECK: @[[s_0xffffeeee:.*]] = {{.*}} constant [11 x i8] c"0xffffeeee\00" + +void f() { + // CHECK: call void @_Zli2_xPKcm({{.*}}, i8* getelementptr inbounds ([4 x i8]* @[[s_foo]], i32 0, i32 0), i64 3) + // CHECK: call void @_Zli2_xPKcm({{.*}}, i8* getelementptr inbounds ([4 x i8]* @[[s_bar]], i32 0, i32 0), i64 3) + // CHECK: call void @_Zli2_yw({{.*}} 97) + // CHECK: call void @_Zli2_zy({{.*}} 42) + // CHECK: call void @_Zli2_fe({{.*}} x86_fp80 0xK3FFF8000000000000000) + // CHECK: call void @_ZN1SD1Ev({{.*}}) + // CHECK: call void @_ZN1SD1Ev({{.*}}) + // CHECK: call void @_ZN1SD1Ev({{.*}}) + // CHECK: call void @_ZN1SD1Ev({{.*}}) + // CHECK: call void @_ZN1SD1Ev({{.*}}) + "foo"_x, "bar"_x, L'a'_y, 42_z, 1.0_f; + + // CHECK: call void @_Zli2_rPKc({{.*}}, i8* getelementptr inbounds ([4 x i8]* @[[s_123]], i32 0, i32 0)) + // CHECK: call void @_Zli2_rPKc({{.*}}, i8* getelementptr inbounds ([4 x i8]* @[[s_4_9]], i32 0, i32 0)) + // CHECK: call void @_Zli2_rPKc({{.*}}, i8* getelementptr inbounds ([11 x i8]* @[[s_0xffffeeee]], i32 0, i32 0)) + // CHECK: call void @_ZN1SD1Ev({{.*}}) + // CHECK: call void @_ZN1SD1Ev({{.*}}) + // CHECK: call void @_ZN1SD1Ev({{.*}}) + 123_r, 4.9_r, 0xffff\ +eeee_r; + + // FIXME: This mangling is insane. Maybe we should have a special case for + // char parameter packs? + // CHECK: call void @_Zli2_tIJLc48ELc120ELc49ELc50ELc51ELc52ELc53ELc54ELc55ELc56EEE1Sv({{.*}}) + // CHECK: call void @_ZN1SD1Ev({{.*}}) + 0x12345678_t; +} + +// CHECK: define {{.*}} @_Zli2_tIJLc48ELc120ELc49ELc50ELc51ELc52ELc53ELc54ELc55ELc56EEE1Sv( + +template<typename T> auto g(T t) -> decltype("foo"_x(t)) { return "foo"_x(t); } +template<typename T> auto i(T t) -> decltype(operator"" _x("foo", 3)(t)) { return operator"" _x("foo", 3)(t); } + +void h() { + g(42); + i(42); +} + +// CHECK: define {{.*}} @_Z1hv() +// CHECK: call void @_Z1gIiEDTclclL_Zli2_xPKcmELA4_S0_ELm3EEfp_EET_(i32 42) +// CHECK: call void @_Z1iIiEDTclclL_Zli2_xPKcmELA4_S0_ELi3EEfp_EET_(i32 42) + +// CHECK: define {{.*}} @_Z1gIiEDTclclL_Zli2_xPKcmELA4_S0_ELm3EEfp_EET_(i32 +// CHECK: call void @_Zli2_xPKcm({{.*}}, i8* getelementptr inbounds ([4 x i8]* @{{.*}}, i32 0, i32 0), i64 3) +// CHECK: call void @_ZN1SclEi +// CHECK: call void @_ZN1SD1Ev + +// CHECK: define {{.*}} @_Z1iIiEDTclclL_Zli2_xPKcmELA4_S0_ELi3EEfp_EET_(i32 +// CHECK: call void @_Zli2_xPKcm({{.*}}, i8* getelementptr inbounds ([4 x i8]* @{{.*}}, i32 0, i32 0), i64 3) +// CHECK: call void @_ZN1SclEi +// CHECK: call void @_ZN1SD1Ev diff --git a/test/CodeGenCXX/debug-info-artificial-arg.cpp b/test/CodeGenCXX/debug-info-artificial-arg.cpp new file mode 100644 index 0000000000000..92d1b162f533d --- /dev/null +++ b/test/CodeGenCXX/debug-info-artificial-arg.cpp @@ -0,0 +1,30 @@ +// RUN: %clang_cc1 -emit-llvm -g -triple x86_64-apple-darwin %s -o - | FileCheck %s + +template<class X> class B { +public: + explicit B(X* p = 0); +}; + +class A +{ +public: + A(int value) : m_a_value(value) {}; + A(int value, A* client_A) : m_a_value (value), m_client_A (client_A) {} + + virtual ~A() {} + +private: + int m_a_value; + B<A> m_client_A; +}; + +int main(int argc, char **argv) { + A reallyA (500); +} + +// FIXME: The numbers are truly awful. +// CHECK: !18 = metadata !{i32 {{.*}}, i32 0, metadata !"", i32 0, i32 0, i64 64, i64 64, i64 0, i32 64, metadata !19} ; [ DW_TAG_pointer_type ] +// CHECK: !19 = metadata !{i32 {{.*}}, null, metadata !"A", metadata !6, i32 8, i64 128, i64 64, i32 0, i32 0, null, metadata !20, i32 0, metadata !19, null} ; [ DW_TAG_class_type ] +// CHECK: metadata !19, metadata !"A", metadata !"A", metadata !"", metadata !6, i32 12, metadata !45, i1 false, i1 false, i32 0, i32 0, null, i32 256, i1 false, null, null, i32 0, metadata !47, i32 12} ; [ DW_TAG_subprogram ] +// CHECK: metadata !"", i32 0, i32 0, i64 0, i64 0, i64 0, i32 0, null, metadata !46, i32 0, i32 0} ; [ DW_TAG_subroutine_type ] +// CHECK: !46 = metadata !{null, metadata !18, metadata !9, metadata !34} diff --git a/test/CodeGenCXX/debug-info-byval.cpp b/test/CodeGenCXX/debug-info-byval.cpp index f0cb6d68c837f..56ffe1323791a 100644 --- a/test/CodeGenCXX/debug-info-byval.cpp +++ b/test/CodeGenCXX/debug-info-byval.cpp @@ -23,7 +23,7 @@ void foo(EVT e); EVT bar(); void get(int *i, unsigned dl, VAL v, VAL *p, unsigned n, EVT missing_arg) { -//CHECK: .ascii "missing_arg" +//CHECK: .asciz "missing_arg" EVT e = bar(); if (dl == n) foo(missing_arg); diff --git a/test/CodeGenCXX/debug-info-char16.cpp b/test/CodeGenCXX/debug-info-char16.cpp index da8ca051da845..24216f9869d27 100644 --- a/test/CodeGenCXX/debug-info-char16.cpp +++ b/test/CodeGenCXX/debug-info-char16.cpp @@ -1,9 +1,6 @@ -// RUN: %clang_cc1 -S -std=c++11 -masm-verbose -g %s -o -| FileCheck %s - -//CHECK: .ascii "char16_t" -//CHECK-NEXT: .byte 0 -//CHECK-NEXT: .byte 16 +// RUN: %clang_cc1 -emit-llvm -std=c++11 -g %s -o -| FileCheck %s // 16 is DW_ATE_UTF (0x10) encoding attribute. char16_t char_a = u'h'; +// CHECK: !7 = metadata !{i32 {{.*}}, null, metadata !"char16_t", null, i32 0, i64 16, i64 16, i64 0, i32 0, i32 16} ; [ DW_TAG_base_type ] diff --git a/test/CodeGenCXX/debug-info-context.cpp b/test/CodeGenCXX/debug-info-context.cpp new file mode 100644 index 0000000000000..d6d44a158c3be --- /dev/null +++ b/test/CodeGenCXX/debug-info-context.cpp @@ -0,0 +1,17 @@ +// RUN: %clang_cc1 -emit-llvm -g -triple x86_64-apple-darwin %s -o - | FileCheck %s +// PR11345 + +class locale { +private: + void _M_add_reference() const throw() { + } +}; +class ios_base { + locale _M_ios_locale; +public: + class Init { + }; +}; +static ios_base::Init __ioinit; + +// CHECK-NOT: _M_ios_locale diff --git a/test/CodeGenCXX/debug-info-dup-fwd-decl.cpp b/test/CodeGenCXX/debug-info-dup-fwd-decl.cpp new file mode 100644 index 0000000000000..e67987b5a3536 --- /dev/null +++ b/test/CodeGenCXX/debug-info-dup-fwd-decl.cpp @@ -0,0 +1,24 @@ +// RUN: %clang_cc1 -emit-llvm -g -triple x86_64-apple-darwin -fno-limit-debug-info %s -o - | FileCheck %s + +class Test +{ +public: + Test () : reserved (new data()) {} + + unsigned + getID() const + { + return reserved->objectID; + } +protected: + struct data { + unsigned objectID; + }; + data* reserved; +}; + +Test t; + +// CHECK: metadata !"", null, i32 0, i64 64, i64 64, i64 0, i32 0, metadata {{.*}} [ DW_TAG_pointer_type ] +// CHECK: metadata !"data", metadata !6, i32 14, i64 32, i64 32, i32 0, i32 0 +// CHECK-NOT: metadata !"data", metadata {{.*}}, i32 14, i64 0, i64 0, i32 0, i32 4, diff --git a/test/CodeGenCXX/debug-info-fn-template.cpp b/test/CodeGenCXX/debug-info-fn-template.cpp index c8291af852d3d..bef9fe144028e 100644 --- a/test/CodeGenCXX/debug-info-fn-template.cpp +++ b/test/CodeGenCXX/debug-info-fn-template.cpp @@ -10,6 +10,6 @@ T fx(XF<T> xi) { return xi.member; } -//CHECK: DW_TAG_template_type_parameter //CHECK: XF<int> +//CHECK: DW_TAG_template_type_parameter template int fx(XF<int>); diff --git a/test/CodeGenCXX/debug-info-fwd-ref.cpp b/test/CodeGenCXX/debug-info-fwd-ref.cpp new file mode 100644 index 0000000000000..5480c6b14fd95 --- /dev/null +++ b/test/CodeGenCXX/debug-info-fwd-ref.cpp @@ -0,0 +1,26 @@ +// RUN: %clang_cc1 -emit-llvm -g -triple x86_64-apple-darwin %s -o - | FileCheck %s + +struct baz { + int h; + baz(int a) : h(a) {} +}; + +struct bar { + baz b; + baz& b_ref; + bar(int x) : b(x), b_ref(b) {} +}; + +int main(int argc, char** argv) { + bar myBar(1); + return 0; +} + +// Make sure we have two DW_TAG_class_types for baz and bar and no forward +// references. +// FIXME: These should be struct types to match the declaration. +// CHECK: metadata !{i32 {{.*}}, null, metadata !"bar", metadata !6, i32 8, i64 128, i64 64, i32 0, i32 0, null, metadata !20, i32 0, null, null} ; [ DW_TAG_class_type ] +// CHECK: metadata !{i32 {{.*}}, null, metadata !"baz", metadata !6, i32 3, i64 32, i64 32, i32 0, i32 0, null, metadata !23, i32 0, null, null} ; [ DW_TAG_class_type ] +// CHECK-NOT: metadata !{i32 {{.*}}, null, metadata !"bar", metadata !6, i32 9, i64 0, i64 0, i32 0, i32 4, i32 0, null, i32 0, i32 0} ; [ DW_TAG_class_type ] +// CHECK-NOT: metadata !{i32 {{.*}}, null, metadata !"baz", metadata !6, i32 3, i64 0, i64 0, i32 0, i32 4, null, null, i32 0, null, null} ; [ DW_TAG_class_type ] + diff --git a/test/CodeGenCXX/debug-info-limit-type.cpp b/test/CodeGenCXX/debug-info-limit-type.cpp new file mode 100644 index 0000000000000..e03024fb3cd99 --- /dev/null +++ b/test/CodeGenCXX/debug-info-limit-type.cpp @@ -0,0 +1,24 @@ +// RUN: %clang -emit-llvm -g -S %s -o - | FileCheck %s +// XFAIL: * + +class B { +public: + int bb; + void fn2() {} +}; + +class A { +public: + int aa; + void fn1(B b) { b.fn2(); } +}; + +void foo(A *aptr) { +} + +void bar() { + A a; +} + +// B should only be emitted as a forward reference (i32 4). +// CHECK: metadata !"B", metadata !6, i32 3, i32 0, i32 0, i32 0, i32 4} ; [ DW_TAG_class_type ] diff --git a/test/CodeGenCXX/debug-info-limit.cpp b/test/CodeGenCXX/debug-info-limit.cpp index 75f9271b003fb..bca887b4db87b 100644 --- a/test/CodeGenCXX/debug-info-limit.cpp +++ b/test/CodeGenCXX/debug-info-limit.cpp @@ -7,8 +7,8 @@ public: int z; }; -A *foo () { - A *a = new A(); +A *foo (A* x) { + A *a = new A(*x); return a; } diff --git a/test/CodeGenCXX/debug-info-member.cpp b/test/CodeGenCXX/debug-info-member.cpp index 5052a6cafb79d..8c2e3ebded4b8 100644 --- a/test/CodeGenCXX/debug-info-member.cpp +++ b/test/CodeGenCXX/debug-info-member.cpp @@ -1,4 +1,4 @@ -// RUN: %clang -fverbose-asm -cc1 -g -S %s -o - | grep DW_ACCESS_public +// RUN: %clang -fverbose-asm -g -S %s -o - | grep DW_ACCESS_public class A { public: int x; diff --git a/test/CodeGenCXX/debug-info-method-spec.cpp b/test/CodeGenCXX/debug-info-method-spec.cpp index 31f66633dc4c5..2068c5ce4fad6 100644 --- a/test/CodeGenCXX/debug-info-method-spec.cpp +++ b/test/CodeGenCXX/debug-info-method-spec.cpp @@ -1,4 +1,4 @@ -// RUN: %clang -fverbose-asm -cc1 -g -S %s -o - | grep DW_AT_specification +// RUN: %clang -fverbose-asm -g -S %s -o - | grep DW_AT_specification // Radar 9254491 class A { public: diff --git a/test/CodeGenCXX/debug-info-method.cpp b/test/CodeGenCXX/debug-info-method.cpp index 5935727851552..cb022bc52cd34 100644 --- a/test/CodeGenCXX/debug-info-method.cpp +++ b/test/CodeGenCXX/debug-info-method.cpp @@ -1,4 +1,4 @@ -// RUN: %clang -fverbose-asm -cc1 -g -S %s -o - | grep DW_ACCESS_protected +// RUN: %clang -fverbose-asm -g -S %s -o - | grep DW_ACCESS_protected class A { protected: int foo(); diff --git a/test/CodeGenCXX/debug-info-method2.cpp b/test/CodeGenCXX/debug-info-method2.cpp new file mode 100644 index 0000000000000..a927c49d307ad --- /dev/null +++ b/test/CodeGenCXX/debug-info-method2.cpp @@ -0,0 +1,19 @@ +// RUN: %clang_cc1 -flimit-debug-info -x c++ -g -S -emit-llvm < %s | FileCheck %s +// rdar://10336845 +// Preserve type qualifiers in -flimit-debug-info mode. + +// CHECK: DW_TAG_const_type +class A { +public: + int bar(int arg) const; +}; + +int A::bar(int arg) const{ + return arg+2; +} + +int main() { + A a; + int i = a.bar(2); + return i; +} diff --git a/test/CodeGenCXX/debug-info-nullptr.cpp b/test/CodeGenCXX/debug-info-nullptr.cpp index 588dc5f3c3993..5540a9217cbee 100644 --- a/test/CodeGenCXX/debug-info-nullptr.cpp +++ b/test/CodeGenCXX/debug-info-nullptr.cpp @@ -1,8 +1,7 @@ -// RUN: %clang_cc1 -S -std=c++11 -masm-verbose -g %s -o -| FileCheck %s - -//CHECK: DW_TAG_unspecified_type -//CHECK-NEXT: "nullptr_t" +// RUN: %clang_cc1 -emit-llvm -std=c++11 -g %s -o -| FileCheck %s void foo() { decltype(nullptr) t = 0; - } +} + +// CHECK: !13 = metadata !{i32 {{.*}}, null, metadata !"nullptr_t", null, i32 0, i64 0, i64 0, i64 0, i32 0, i32 0} ; [ DW_TAG_unspecified_type ] diff --git a/test/CodeGenCXX/debug-info-pubtypes.cpp b/test/CodeGenCXX/debug-info-pubtypes.cpp index 35ba90b13f87d..a7abade3929fc 100644 --- a/test/CodeGenCXX/debug-info-pubtypes.cpp +++ b/test/CodeGenCXX/debug-info-pubtypes.cpp @@ -1,7 +1,9 @@ // REQUIRES: x86-64-registered-target -// RUN: %clang -cc1 -triple x86_64-apple-darwin10 -g -S %s -o %t +// RUN: %clang -cc1 -triple x86_64-apple-darwin10 -g -fno-limit-debug-info -S %s -o %t // RUN: FileCheck %s < %t +// FIXME: This testcase shouldn't rely on assembly emission. +//CHECK: Lpubtypes_begin1: //CHECK: .asciz "G" //CHECK-NEXT: .long 0 //CHECK-NEXT: Lpubtypes_end1: diff --git a/test/CodeGenCXX/debug-info-static-fns.cpp b/test/CodeGenCXX/debug-info-static-fns.cpp new file mode 100644 index 0000000000000..485d28aa7b7c1 --- /dev/null +++ b/test/CodeGenCXX/debug-info-static-fns.cpp @@ -0,0 +1,10 @@ +// RUN: %clang_cc1 -emit-llvm -g -triple x86_64-apple-darwin %s -o - | FileCheck %s + +namespace A { + static int a(int b) { return b + 4; } + + int b(int c) { return c + a(c); } +} + +// Verify that a is present and mangled. +// CHECK: metadata !{i32 786478, i32 0, metadata !6, metadata !"a", metadata !"a", metadata !"_ZN1AL1aEi", metadata !7, i32 4, metadata !8, i1 true, i1 true, i32 0, i32 0, null, i32 256, i1 false, i32 (i32)* @_ZN1AL1aEi, null, null, metadata !14, i32 4} ; [ DW_TAG_subprogram ] diff --git a/test/CodeGenCXX/debug-info-template-limit.cpp b/test/CodeGenCXX/debug-info-template-limit.cpp new file mode 100644 index 0000000000000..796a80fd627f5 --- /dev/null +++ b/test/CodeGenCXX/debug-info-template-limit.cpp @@ -0,0 +1,15 @@ +// RUN: %clang -flimit-debug-info -emit-llvm -g -S %s -o - | FileCheck %s + +// Check that this pointer type is TC<int> +// CHECK: !10} ; [ DW_TAG_pointer_type +// CHECK-NEXT: !10 ={{.*}}"TC<int>" + +template<typename T> +class TC { +public: + TC(const TC &) {} + TC() {} +}; + +TC<int> tci; + diff --git a/test/CodeGenCXX/debug-info-template-member.cpp b/test/CodeGenCXX/debug-info-template-member.cpp new file mode 100644 index 0000000000000..6208c80aeb610 --- /dev/null +++ b/test/CodeGenCXX/debug-info-template-member.cpp @@ -0,0 +1,21 @@ +// RUN: %clang_cc1 -emit-llvm -g -triple x86_64-apple-darwin %s -o - | FileCheck %s + +class MyClass +{ +public: + int add2(int j) + { + return add<2>(j); + } +private: + template <int i> int add(int j) + { + return i + j; + } +}; + +MyClass m; + +// CHECK: metadata !{i32 {{.*}}, null, metadata !"MyClass", metadata {{.*}}, i32 {{.*}}, i64 8, i64 8, i32 0, i32 0, null, metadata [[C_MEM:.*]], i32 0, null, null} ; [ DW_TAG_class_type ] +// CHECK: [[C_MEM]] = metadata !{metadata {{.*}}, metadata [[C_TEMP:.*]], metadata {{.*}}} +// CHECK: [[C_TEMP]] = metadata !{i32 {{.*}}, i32 0, metadata {{.*}}, metadata !"add<2>", metadata !"add<2>", metadata !"_ZN7MyClass3addILi2EEEii", metadata {{.*}} diff --git a/test/CodeGenCXX/debug-info-template-recursive.cpp b/test/CodeGenCXX/debug-info-template-recursive.cpp new file mode 100644 index 0000000000000..ef04d03bb78fa --- /dev/null +++ b/test/CodeGenCXX/debug-info-template-recursive.cpp @@ -0,0 +1,13 @@ +// RUN: %clang_cc1 -emit-llvm -g -triple x86_64-apple-darwin %s -o - | FileCheck %s + +class base { }; + +template <class T> class foo : public base { + void operator=(const foo r) { } +}; + +class bar : public foo<void> { }; +bar filters; + +// For now check that it simply doesn't crash. +// CHECK: {{.*}} diff --git a/test/CodeGenCXX/debug-info-use-after-free.cpp b/test/CodeGenCXX/debug-info-use-after-free.cpp new file mode 100644 index 0000000000000..9757ca4d37064 --- /dev/null +++ b/test/CodeGenCXX/debug-info-use-after-free.cpp @@ -0,0 +1,312 @@ +// RUN: %clang_cc1 -g -emit-llvm-only %s +// Check that we don't crash. +// PR12305, PR12315 + +# 1 "a.h" 3 +template < typename T1 > struct Types1 +{ + typedef T1 Head; +}; +template < typename > struct Types; +template < template < typename > class Tmpl > struct TemplateSel +{ + template < typename T > struct Bind + { + typedef Tmpl < T > type; + }; +}; +template < typename > struct NoneT; +template < template < typename > class T1, template < typename > class > struct Templates2 +{ + typedef TemplateSel < T1 > Head; +}; +template < template < typename > class, template < typename > class = + NoneT, template < typename > class = NoneT, template < typename > class = + NoneT > struct Templates; +template < template < typename > class T1, + template < typename > class T2 > struct Templates <T1, T2 > +{ + typedef Templates2 < T1, T2 > type; +}; +template < typename T > struct TypeList +{ + typedef Types1 < T > type; +}; +template < template < typename > class, class TestSel, + typename Types > class TypeParameterizedTest +{ +public:static bool Register () + { + typedef typename Types::Head Type; + typename TestSel::template Bind < Type >::type TestClass; +}}; + +template < template < typename > class Fixture, typename Tests, + typename Types > class TypeParameterizedTestCase +{ +public:static bool Register (char *, char *, int *) + { + typedef typename Tests::Head Head; + TypeParameterizedTest < Fixture, Head, Types >::Register; +}}; + +template < typename > class TypedTestP1 +{ +}; + +namespace gtest_case_TypedTestP1_ +{ + template < typename gtest_TypeParam_ > class A:TypedTestP1 < + gtest_TypeParam_ > + { + }; +template < typename gtest_TypeParam_ > class B:TypedTestP1 < + gtest_TypeParam_ > + { + }; + typedef Templates < A >::type gtest_AllTests_; +} + +template < typename > class TypedTestP2 +{ +}; + +namespace gtest_case_TypedTestP2_ +{ + template < typename gtest_TypeParam_ > class A:TypedTestP2 < + gtest_TypeParam_ > + { + }; + typedef Templates < A >::type gtest_AllTests_; +} + +bool gtest_Int_TypedTestP1 = + TypeParameterizedTestCase < TypedTestP1, + gtest_case_TypedTestP1_::gtest_AllTests_, + TypeList < int >::type >::Register ("Int", "TypedTestP1", 0); +bool gtest_Int_TypedTestP2 = + TypeParameterizedTestCase < TypedTestP2, + gtest_case_TypedTestP2_::gtest_AllTests_, + TypeList < Types < int > >::type >::Register ("Int", "TypedTestP2", 0); + +template < typename _Tp > struct new_allocator +{ + typedef _Tp *pointer; + template < typename > struct rebind { + typedef new_allocator other; + }; +}; +template < typename _Tp > struct allocator:new_allocator < _Tp > { +}; +template < typename _Tp, typename _Alloc > struct _Vector_base { + typedef typename _Alloc::template rebind < _Tp >::other _Tp_alloc_type; + struct _Vector_impl { + typename _Tp_alloc_type::pointer _M_end_of_storage; + }; + _Vector_base () { + foo((int *) this->_M_impl._M_end_of_storage); + } + void foo(int *); + _Vector_impl _M_impl; +}; +template < typename _Tp, typename _Alloc = +allocator < _Tp > >struct vector:_Vector_base < _Tp, _Alloc > { }; + + +template < class T> struct HHH {}; +struct DDD { int x_;}; +struct Data; +struct X1; +struct CCC:DDD { virtual void xxx (HHH < X1 >); }; +template < class SSS > struct EEE:vector < HHH < SSS > > { }; +template < class SSS, class = EEE < SSS > >class FFF { }; +template < class SSS, class GGG = EEE < SSS > >class AAA:FFF <GGG> { }; +class BBB:virtual CCC { + void xxx (HHH < X1 >); + vector < HHH < X1 > >aaa; +}; +class ZZZ:AAA < Data >, BBB { virtual ZZZ *ppp () ; }; +ZZZ * ZZZ::ppp () { return new ZZZ; } + +namespace std +{ + template < class, class > struct pair; +} +namespace __gnu_cxx { +template < typename > class new_allocator; +} +namespace std { +template < typename _Tp > class allocator:__gnu_cxx::new_allocator < _Tp > { +}; +template < typename, typename > struct _Vector_base { +}; +template < typename _Tp, typename _Alloc = std::allocator < _Tp > >class vector:_Vector_base < _Tp, + _Alloc + > { + }; +} + +namespace +std { + template < + typename, + typename > struct unary_function; + template < + typename, + typename, + typename > struct binary_function; + template < + typename + _Tp > struct equal_to: + binary_function < + _Tp, + _Tp, + bool > { + }; + template < + typename + _Pair > struct _Select1st: + unary_function < + _Pair, + typename + _Pair::first_type > { + }; +} +# 1 "f.h" 3 +using +std::pair; +namespace +__gnu_cxx { + template < + class > struct hash; + template < + class, + class, + class, + class, + class + _EqualKey, + class > + class + hashtable { + public: + typedef _EqualKey + key_equal; + }; + using + std::equal_to; + using + std::allocator; + using + std::_Select1st; + template < class _Key, class _Tp, class _HashFn = + hash < _Key >, class _EqualKey = equal_to < _Key >, class _Alloc = + allocator < _Tp > >class hash_map { + typedef + hashtable < + pair < + _Key, + _Tp >, + _Key, + _HashFn, + _Select1st < + pair < + _Key, + _Tp > >, + _EqualKey, + _Alloc > + _Ht; + public: + typename _Ht::key_type; + typedef typename + _Ht::key_equal + key_equal; + }; +} +using +__gnu_cxx::hash_map; +class +C2; +template < class > class scoped_ptr { +}; +namespace { +class + AAA { + virtual ~ + AAA () { + }}; +} +template < typename > class EEE; +template < typename CCC, typename = +typename CCC::key_equal, typename = +EEE < CCC > >class III { +}; +namespace +util { + class + EEE { + }; +} +namespace { +class + C1: + util::EEE { + public: + class + C3: + AAA { + struct FFF; + typedef + III < + hash_map < + C2, + FFF > > + GGG; + GGG + aaa; + friend + C1; + }; + void + HHH (C3::GGG &); + }; +} +namespace +n1 { + class + Test { + }; + template < + typename > + class + C7 { + }; + class + C4: + n1::Test { + vector < + C1::C3 * > + a1; + }; + enum C5 { }; + class + C6: + C4, + n1::C7 < + C5 > { + }; + class + C8: + C6 { + }; + class + C9: + C8 { + void + TestBody (); + }; + void + C9::TestBody () { + scoped_ptr < C1::C3 > context; + } +} diff --git a/test/CodeGenCXX/debug-lambda-expressions.cpp b/test/CodeGenCXX/debug-lambda-expressions.cpp new file mode 100644 index 0000000000000..859a71b621ca4 --- /dev/null +++ b/test/CodeGenCXX/debug-lambda-expressions.cpp @@ -0,0 +1,71 @@ +// RUN: %clang_cc1 -triple x86_64-apple-darwin10.0.0 -emit-llvm -o - %s -fexceptions -std=c++11 -g | FileCheck %s + +auto var = [](int i) { return i+1; }; + +extern "C" auto cvar = []{}; + +int a() { return []{ return 1; }(); } + +int b(int x) { return [x]{return x;}(); } + +int c(int x) { return [&x]{return x;}(); } + +struct D { D(); D(const D&); int x; }; +int d(int x) { D y[10]; [x,y] { return y[x].x; }(); } + + +// A: 5 +// CHECK: [[A_FUNC:.*]] = metadata !{i32 {{.*}}, i32 0, metadata [[FILE:.*]], metadata !"a", metadata !"a", metadata !"_Z1av", metadata {{.*}}, i32 [[A_LINE:.*]], metadata {{.*}}, i1 false, i1 true, i32 0, i32 0, null, i32 256, i1 false, i32 ()* @_Z1av, null, null, {{.*}} [ DW_TAG_subprogram ] + +// Randomness for file. -- 6 +// CHECK: [[FILE]] = metadata !{i32 {{.*}}, metadata !{{.*}}debug-lambda-expressions.cpp{{.*}}; [ DW_TAG_file_type ] + +// B: 12 +// CHECK: [[B_FUNC:.*]] = metadata !{i32 786478, i32 0, metadata [[FILE]], metadata !"b", metadata !"b", metadata !"_Z1bi", metadata [[FILE]], i32 [[B_LINE:.*]], metadata {{.*}}, i1 false, i1 true, i32 0, i32 0, null, i32 256, i1 false, i32 (i32)* @_Z1bi, null, null, {{.*}} ; [ DW_TAG_subprogram ] + +// C: 17 +// CHECK: [[C_FUNC:.*]] = metadata !{i32 {{.*}}, i32 0, metadata [[FILE]], metadata !"c", metadata !"c", metadata !"_Z1ci", metadata [[FILE]], i32 [[C_LINE:.*]], metadata {{.*}}, i1 false, i1 true, i32 0, i32 0, null, i32 256, i1 false, i32 (i32)* @_Z1ci, null, null, metadata {{.*}} ; [ DW_TAG_subprogram ] + +// D: 20 +// CHECK: [[D_FUNC:.*]] = metadata !{i32 {{.*}}, i32 0, metadata [[FILE]], metadata !"d", metadata !"d", metadata !"_Z1di", metadata [[FILE]], i32 [[D_LINE:.*]], metadata {{.*}}, i1 false, i1 true, i32 0, i32 0, null, i32 256, i1 false, i32 (i32)* @_Z1di, null, null, metadata {{.*}} ; [ DW_TAG_subprogram ] + +// Back to D. -- 120 +// CHECK: [[LAM_D:.*]] = metadata !{i32 {{.*}}, metadata [[D_FUNC]], metadata !"", metadata [[FILE]], i32 [[D_LINE]], i64 352, i64 32, i32 0, i32 0, null, metadata [[LAM_D_ARGS:.*]], i32 0, null, null} ; [ DW_TAG_class_type ] +// CHECK: [[LAM_D_ARGS]] = metadata !{metadata [[CAP_D_X:.*]], metadata [[CAP_D_Y:.*]], metadata [[CON_LAM_D:.*]], metadata [[DES_LAM_D:.*]]} +// CHECK: [[CAP_D_X]] = metadata !{i32 {{.*}}, metadata [[LAM_D]], metadata !"x", metadata [[FILE]], i32 14, i64 32, i64 32, i64 0, i32 1, metadata {{.*}} ; [ DW_TAG_member ] +// CHECK: [[CAP_D_Y]] = metadata !{i32 {{.*}}, metadata [[LAM_D]], metadata !"y", metadata [[FILE]], i32 14, i64 320, i64 32, i64 32, i32 1, metadata {{.*}} ; [ DW_TAG_member ] +// CHECK: [[CON_LAM_D]] = metadata {{.*}}[[LAM_D]], metadata !"operator()", metadata !"operator()"{{.*}}[ DW_TAG_subprogram ] +// CHECK: [[DES_LAM_D]] = metadata {{.*}}[[LAM_D]], metadata !"~", metadata !"~"{{.*}}[ DW_TAG_subprogram ] + + +// Back to C. -- 159 +// CHECK: [[LAM_C:.*]] = metadata !{i32 {{.*}}, metadata [[C_FUNC]], metadata !"", metadata [[FILE]], i32 [[C_LINE]], i64 64, i64 64, i32 0, i32 0, null, metadata [[LAM_C_ARGS:.*]], i32 0, null, null} ; [ DW_TAG_class_type ] +// CHECK: [[LAM_C_ARGS]] = metadata !{metadata [[CAP_C:.*]], metadata [[CON_LAM_C:.*]], metadata [[DES_LAM_C:.*]]} +// Ignoring the member type for now. +// CHECK: [[CAP_C]] = metadata !{i32 {{.*}}, metadata [[LAM_C]], metadata !"x", metadata [[FILE]], i32 [[C_LINE]], i64 64, i64 64, i64 0, i32 1, metadata {{.*}}} ; [ DW_TAG_member ] +// CHECK: [[CON_LAM_C]] = metadata {{.*}}[[LAM_C]], metadata !"operator()", metadata !"operator()"{{.*}}[ DW_TAG_subprogram ] +// CHECK: [[DES_LAM_C]] = metadata {{.*}}[[LAM_C]], metadata !"~", metadata !"~"{{.*}}[ DW_TAG_subprogram ] + + +// Back to B. -- 179 +// CHECK: [[LAM_B:.*]] = metadata !{i32 {{.*}}, metadata [[B_FUNC]], metadata !"", metadata [[FILE]], i32 [[B_LINE]], i64 32, i64 32, i32 0, i32 0, null, metadata [[LAM_B_ARGS:.*]], i32 0, null, null} ; [ DW_TAG_class_type ] +// CHECK: [[LAM_B_ARGS]] = metadata !{metadata [[CAP_B:.*]], metadata [[CON_LAM_B:.*]], metadata [[DES_LAM_B:.*]]} +// CHECK: [[CAP_B]] = metadata !{i32 {{.*}}, metadata [[LAM_B]], metadata !"x", metadata [[FILE]], i32 [[B_LINE]], i64 32, i64 32, i64 0, i32 1, metadata {{.*}}} ; [ DW_TAG_member ] +// CHECK: [[CON_LAM_B]] = metadata {{.*}}[[LAM_B]], metadata !"operator()", metadata !"operator()"{{.*}}[ DW_TAG_subprogram ] +// CHECK: [[DES_LAM_B]] = metadata {{.*}}[[LAM_B]], metadata !"~", metadata !"~"{{.*}}[ DW_TAG_subprogram ] + +// Back to A. -- 204 +// CHECK: [[LAM_A:.*]] = metadata !{i32 {{.*}}, metadata [[A_FUNC]], metadata !"", metadata [[FILE]], i32 [[A_LINE]], i64 8, i64 8, i32 0, i32 0, null, metadata [[LAM_A_ARGS:.*]], i32 0, null, null} ; [ DW_TAG_class_type ] +// CHECK: [[LAM_A_ARGS]] = metadata !{metadata [[CON_LAM_A:.*]], metadata [[DES_LAM_A:.*]]} +// CHECK: [[CON_LAM_A]] = metadata {{.*}}[[LAM_A]], metadata !"operator()", metadata !"operator()"{{.*}}[ DW_TAG_subprogram ] +// CHECK: [[DES_LAM_A]] = metadata {{.*}}[[LAM_A]], metadata !"~", metadata !"~"{{.*}}[ DW_TAG_subprogram ] + +// VAR: +// CHECK: metadata !{i32 {{.*}}, i32 0, null, metadata !"var", metadata !"var", metadata !"", metadata [[FILE]], i32 [[VAR_LINE:.*]], metadata ![[VAR_T:.*]], i32 1, i32 1, %class.anon* @var} ; [ DW_TAG_variable ] +// CHECK: [[VAR_T]] = metadata !{i32 {{.*}}, null, metadata !"", metadata [[FILE]], i32 [[VAR_LINE]], i64 8, i64 8, i32 0, i32 0, null, metadata ![[VAR_ARGS:.*]], i32 0, null, null} ; [ DW_TAG_class_type ] +// CHECK: [[VAR_ARGS]] = metadata !{metadata !{{.*}}, metadata !{{.*}}, metadata !{{.*}}} + +// CVAR: +// CHECK: metadata !{i32 {{.*}}, i32 0, null, metadata !"cvar", metadata !"cvar", metadata !"", metadata [[FILE]], i32 [[CVAR_LINE:.*]], metadata ![[CVAR_T:.*]], i32 0, i32 1, %class.anon.0* @cvar} ; [ DW_TAG_variable ] +// CHECK: [[CVAR_T]] = metadata !{i32 {{.*}}, null, metadata !"", metadata [[FILE]], i32 [[CVAR_LINE]], i64 8, i64 8, i32 0, i32 0, null, metadata ![[CVAR_ARGS:.*]], i32 0, null, null} ; [ DW_TAG_class_type ] +// CHECK: [[CVAR_ARGS]] = metadata !{metadata !{{.*}}, metadata !{{.*}}, metadata !{{.*}}} diff --git a/test/CodeGenCXX/default-arguments.cpp b/test/CodeGenCXX/default-arguments.cpp index 6560d3514f554..206d4d6c88600 100644 --- a/test/CodeGenCXX/default-arguments.cpp +++ b/test/CodeGenCXX/default-arguments.cpp @@ -63,3 +63,14 @@ void f3() { B *bs = new B[2]; delete bs; } + +void f4() { + void g4(int a, int b = 7); + { + void g4(int a, int b = 5); + } + void g4(int a = 5, int b); + + // CHECK: call void @_Z2g4ii(i32 5, i32 7) + g4(); +} diff --git a/test/CodeGenCXX/empty-union.cpp b/test/CodeGenCXX/empty-union.cpp index 118a0d29b47dd..7f3e6ccf50ad8 100644 --- a/test/CodeGenCXX/empty-union.cpp +++ b/test/CodeGenCXX/empty-union.cpp @@ -1,10 +1,7 @@ // RUN: %clang_cc1 -emit-llvm -o - %s union sigval { }; +union sigval Test1; -union sigval sigev_value; - -int main() -{ - return sizeof(sigev_value); -} +union NonPODUnion { ~NonPODUnion(); }; +union NonPODUnion Test2; diff --git a/test/CodeGenCXX/exceptions.cpp b/test/CodeGenCXX/exceptions.cpp index 0fbb09c2624a0..079c1e5e725f8 100644 --- a/test/CodeGenCXX/exceptions.cpp +++ b/test/CodeGenCXX/exceptions.cpp @@ -53,8 +53,8 @@ namespace test1 { A *c() { // CHECK: define [[A:%.*]]* @_ZN5test11cEv() // CHECK: [[ACTIVE:%.*]] = alloca i1 - // CHECK-NEXT: store i1 true, i1* [[ACTIVE]] // CHECK-NEXT: [[NEW:%.*]] = call noalias 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]]* [[T0]], i32 0, i32 0 @@ -72,8 +72,8 @@ namespace test1 { A *d() { // CHECK: define [[A:%.*]]* @_ZN5test11dEv() // CHECK: [[ACTIVE:%.*]] = alloca i1 - // CHECK-NEXT: store i1 true, i1* [[ACTIVE]] // CHECK-NEXT: [[NEW:%.*]] = call noalias 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]]) @@ -90,8 +90,8 @@ namespace test1 { A *e() { // CHECK: define [[A:%.*]]* @_ZN5test11eEv() // CHECK: [[ACTIVE:%.*]] = alloca i1 - // CHECK-NEXT: store i1 true, i1* [[ACTIVE]] // CHECK-NEXT: [[NEW:%.*]] = call noalias 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]]) @@ -121,8 +121,8 @@ namespace test1 { // CHECK: define [[A:%.*]]* @_ZN5test11iEv() // CHECK: [[X:%.*]] = alloca [[A]]*, align 8 // CHECK: [[ACTIVE:%.*]] = alloca i1 - // CHECK: store i1 true, i1* [[ACTIVE]] - // CHECK-NEXT: [[NEW:%.*]] = call noalias i8* @_Znwm(i64 8) + // CHECK: [[NEW:%.*]] = call noalias 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]]) @@ -194,12 +194,9 @@ namespace test3 { // CHECK: [[SAVED0:%.*]] = alloca i8* // CHECK-NEXT: [[SAVED1:%.*]] = alloca i8* // CHECK-NEXT: [[CLEANUPACTIVE:%.*]] = alloca i1 - // CHECK-NEXT: [[TMP:%.*]] = alloca [[A]], align 8 - // CHECK: [[TMPACTIVE:%.*]] = alloca i1 - // CHECK-NEXT: store i1 false, i1* [[CLEANUPACTIVE]] // CHECK: [[COND:%.*]] = trunc i8 {{.*}} to i1 - // CHECK-NEXT: store i1 false, i1* [[TMPACTIVE]] + // CHECK-NEXT: store i1 false, i1* [[CLEANUPACTIVE]] // CHECK-NEXT: br i1 [[COND]] return (cond ? @@ -209,24 +206,18 @@ namespace test3 { // 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 [[TMP]]) - // CHECK: store i1 true, i1* [[TMPACTIVE]] - // CHECK-NEXT: invoke void @_ZN5test31AC1ERKS0_([[A]]* [[CAST]], [[A]]* [[TMP]]) - // CHECK: store i1 false, i1* [[CLEANUPACTIVE]] - // CHECK-NEXT: br label + // CHECK-NEXT: invoke void @_ZN5test35makeAEv([[A]]* sret [[CAST]]) + // CHECK: br label // -> cond.end new(foo(),10.0) A(makeA()) : - // CHECK: [[MAKE:%.*]] = invoke [[A]]* @_ZN5test38makeAPtrEv() + // CHECK: [[MAKE:%.*]] = call [[A]]* @_ZN5test38makeAPtrEv() // CHECK: br label // -> cond.end makeAPtr()); // cond.end: // CHECK: [[RESULT:%.*]] = phi [[A]]* {{.*}}[[CAST]]{{.*}}[[MAKE]] - // CHECK-NEXT: [[ISACTIVE:%.*]] = load i1* [[TMPACTIVE]] - // CHECK-NEXT: br i1 [[ISACTIVE]] - // CHECK: invoke void @_ZN5test31AD1Ev // CHECK: ret [[A]]* [[RESULT]] // in the EH path: @@ -330,17 +321,15 @@ namespace test7 { // CHECK-NEXT: alloca [[A]] // CHECK-NEXT: [[INNER_A:%.*]] = alloca i1 - // These entry-block stores are to deactivate the delete cleanups. - // CHECK-NEXT: store i1 false, i1* [[INNER_NEW]] - // CHECK-NEXT: store i1 false, i1* [[OUTER_NEW]] - // 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 diff --git a/test/CodeGenCXX/field-access-debug-info.cpp b/test/CodeGenCXX/field-access-debug-info.cpp index 907fe04be57db..fd899ed71e1c8 100644 --- a/test/CodeGenCXX/field-access-debug-info.cpp +++ b/test/CodeGenCXX/field-access-debug-info.cpp @@ -1,5 +1,8 @@ -// RUN: %clang_cc1 -g -S -masm-verbose -o %t %s -// RUN: grep DW_AT_accessibility %t +// RUN: %clang_cc1 -g -S -masm-verbose -o - %s | FileCheck %s + +// CHECK: abbrev_begin: +// CHECK: DW_AT_accessibility +// CHECK-NEXT: DW_FORM_data1 class A { public: diff --git a/test/CodeGenCXX/for-range-temporaries.cpp b/test/CodeGenCXX/for-range-temporaries.cpp index c705702f4f51e..a03bb0a815272 100644 --- a/test/CodeGenCXX/for-range-temporaries.cpp +++ b/test/CodeGenCXX/for-range-temporaries.cpp @@ -1,6 +1,9 @@ // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -std=c++11 -emit-llvm -o - -UDESUGAR %s | opt -instnamer -S | FileCheck %s // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -std=c++11 -emit-llvm -o - -DDESUGAR %s | opt -instnamer -S | FileCheck %s +// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -std=c++11 -emit-llvm -o - -UDESUGAR -DTEMPLATE %s | opt -instnamer -S | FileCheck %s // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -std=c++11 -emit-llvm -o - -DDESUGAR -DTEMPLATE %s | opt -instnamer -S | FileCheck %s +// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -std=c++11 -emit-llvm -o - -UDESUGAR -DTEMPLATE -DDEPENDENT %s | opt -instnamer -S | FileCheck %s +// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -std=c++11 -emit-llvm -o - -DDESUGAR -DTEMPLATE -DDEPENDENT %s | opt -instnamer -S | FileCheck %s struct A { A(); @@ -67,7 +70,11 @@ struct I { void body(const I &); #ifdef TEMPLATE +#ifdef DEPENDENT template<typename D> +#else +template<typename> +#endif #endif void for_temps() { A a; diff --git a/test/CodeGenCXX/forward-enum.cpp b/test/CodeGenCXX/forward-enum.cpp new file mode 100644 index 0000000000000..c1169e0139946 --- /dev/null +++ b/test/CodeGenCXX/forward-enum.cpp @@ -0,0 +1,11 @@ +// RUN: %clang_cc1 -std=c++11 -triple x86_64-apple-darwin11.0.0 -emit-llvm -o - %s | FileCheck %s + +enum MyEnum : char; +void bar(MyEnum value) { } + +// CHECK: define void @_Z3foo6MyEnum +void foo(MyEnum value) +{ + // CHECK: call void @_Z3bar6MyEnum(i8 signext + bar(value); +} diff --git a/test/CodeGenCXX/global-dtor-no-atexit.cpp b/test/CodeGenCXX/global-dtor-no-atexit.cpp index 1e125e3f7d814..def97b236159a 100644 --- a/test/CodeGenCXX/global-dtor-no-atexit.cpp +++ b/test/CodeGenCXX/global-dtor-no-atexit.cpp @@ -3,10 +3,15 @@ // PR7097 // RUN: %clang_cc1 -triple x86_64 %s -fno-use-cxa-atexit -mconstructor-aliases -emit-llvm -o - | FileCheck %s -// CHECK: define internal void @_GLOBAL__D_a() -// CHECK: call void @_ZN1AD1Ev(%class.A* @b) -// CHECK: call void @_ZN1AD1Ev(%class.A* @a) -// CHECK: } +// CHECK: call void @_ZN1AC1Ev([[A:%.*]]* @a) +// CHECK-NEXT: call i32 @atexit(void ()* @__dtor_a) +// CHECK: define internal void @__dtor_a() nounwind +// CHECK: call void @_ZN1AD1Ev([[A]]* @a) + +// CHECK: call void @_ZN1AC1Ev([[A]]* @b) +// CHECK-NEXT: call i32 @atexit(void ()* @__dtor_b) +// CHECK: define internal void @__dtor_b() nounwind +// CHECK: call void @_ZN1AD1Ev([[A]]* @b) class A { public: @@ -15,3 +20,25 @@ public: }; A a, b; + +// PR9593 +// CHECK: define void @_Z4funcv() +// CHECK: call i32 @__cxa_guard_acquire(i64* @_ZGVZ4funcvE2a1) +// CHECK: call void @_ZN1AC1Ev([[A]]* @_ZZ4funcvE2a1) +// CHECK-NEXT: call i32 @atexit(void ()* @__dtor__ZZ4funcvE2a1) +// CHECK-NEXT: call void @__cxa_guard_release(i64* @_ZGVZ4funcvE2a1) + +// CHECK: call i32 @__cxa_guard_acquire(i64* @_ZGVZ4funcvE2a2) +// CHECK: call void @_ZN1AC1Ev([[A]]* @_ZZ4funcvE2a2) +// CHECK-NEXT: call i32 @atexit(void ()* @__dtor__ZZ4funcvE2a2) +// CHECK-NEXT: call void @__cxa_guard_release(i64* @_ZGVZ4funcvE2a2) + +// CHECK: define internal void @__dtor__ZZ4funcvE2a1() nounwind +// CHECK: call void @_ZN1AD1Ev([[A]]* @_ZZ4funcvE2a1) + +// CHECK: define internal void @__dtor__ZZ4funcvE2a2() nounwind +// CHECK: call void @_ZN1AD1Ev([[A]]* @_ZZ4funcvE2a2) + +void func() { + static A a1, a2; +} diff --git a/test/CodeGenCXX/global-init.cpp b/test/CodeGenCXX/global-init.cpp index 053210bdfbeca..8e6ef775cad98 100644 --- a/test/CodeGenCXX/global-init.cpp +++ b/test/CodeGenCXX/global-init.cpp @@ -12,7 +12,7 @@ struct C { void *field; }; struct D { ~D(); }; -// CHECK: @__dso_handle = external unnamed_addr global i8* +// CHECK: @__dso_handle = external unnamed_addr global i8 // CHECK: @c = global %struct.C zeroinitializer, align 8 // It's okay if we ever implement the IR-generation optimization to remove this. @@ -24,18 +24,18 @@ struct D { ~D(); }; // CHECK: @_ZN6PR59741bE = global %"struct.PR5974::B"* bitcast (i8* getelementptr (i8* bitcast (%"struct.PR5974::C"* @_ZN6PR59741cE to i8*), i64 4) to %"struct.PR5974::B"*), align 8 // CHECK: call void @_ZN1AC1Ev(%struct.A* @a) -// CHECK: call i32 @__cxa_atexit(void (i8*)* bitcast (void (%struct.A*)* @_ZN1AD1Ev to void (i8*)*), i8* getelementptr inbounds (%struct.A* @a, i32 0, i32 0), i8* bitcast (i8** @__dso_handle to i8*)) +// CHECK: call i32 @__cxa_atexit(void (i8*)* bitcast (void (%struct.A*)* @_ZN1AD1Ev to void (i8*)*), i8* getelementptr inbounds (%struct.A* @a, i32 0, i32 0), i8* @__dso_handle) A a; // CHECK: call void @_ZN1BC1Ev(%struct.B* @b) -// CHECK: call i32 @__cxa_atexit(void (i8*)* bitcast (void (%struct.B*)* @_ZN1BD1Ev to void (i8*)*), i8* getelementptr inbounds (%struct.B* @b, i32 0, i32 0), i8* bitcast (i8** @__dso_handle to i8*)) +// CHECK: call i32 @__cxa_atexit(void (i8*)* bitcast (void (%struct.B*)* @_ZN1BD1Ev to void (i8*)*), i8* getelementptr inbounds (%struct.B* @b, i32 0, i32 0), i8* @__dso_handle) B b; // PR6205: this should not require a global initializer // CHECK-NOT: call void @_ZN1CC1Ev(%struct.C* @c) C c; -// CHECK: call i32 @__cxa_atexit(void (i8*)* bitcast (void (%struct.D*)* @_ZN1DD1Ev to void (i8*)*), i8* getelementptr inbounds (%struct.D* @d, i32 0, i32 0), i8* bitcast (i8** @__dso_handle to i8*)) +// CHECK: call i32 @__cxa_atexit(void (i8*)* bitcast (void (%struct.D*)* @_ZN1DD1Ev to void (i8*)*), i8* getelementptr inbounds (%struct.D* @d, i32 0, i32 0), i8* @__dso_handle) D d; // <rdar://problem/7458115> diff --git a/test/CodeGenCXX/goto.cpp b/test/CodeGenCXX/goto.cpp index f32847d122bcd..77b6166aff413 100644 --- a/test/CodeGenCXX/goto.cpp +++ b/test/CodeGenCXX/goto.cpp @@ -16,10 +16,10 @@ namespace test0 { // CHECK-NEXT: [[V:%.*]] = alloca [[V:%.*]]*, // CHECK-NEXT: [[TMP:%.*]] = alloca [[A]] // CHECK-NEXT: [[CLEANUPACTIVE:%.*]] = alloca i1 - // CHECK: store i1 true, i1* [[CLEANUPACTIVE]] // CHECK: call void @_ZN5test01AC1Ev([[A]]* [[Y]]) // CHECK-NEXT: invoke void @_ZN5test01AC1Ev([[A]]* [[Z]]) // CHECK: [[NEW:%.*]] = invoke noalias i8* @_Znwm(i64 1) + // CHECK: store i1 true, i1* [[CLEANUPACTIVE]] // CHECK: [[NEWCAST:%.*]] = bitcast i8* [[NEW]] to [[V]]* // CHECK-NEXT: invoke void @_ZN5test01AC1Ev([[A]]* [[TMP]]) // CHECK: invoke void @_ZN5test01VC1ERKNS_1AE([[V]]* [[NEWCAST]], [[A]]* [[TMP]]) diff --git a/test/CodeGenCXX/inheriting-constructor.cpp b/test/CodeGenCXX/inheriting-constructor.cpp new file mode 100644 index 0000000000000..b921a6d2bb930 --- /dev/null +++ b/test/CodeGenCXX/inheriting-constructor.cpp @@ -0,0 +1,9 @@ +// RUN: %clang_cc1 -std=c++11 -triple x86_64-apple-darwin10 -emit-llvm -o - %s | FileCheck %s + +// PR12219 +struct A { A(int); virtual ~A(); }; +struct B : A { using A::A; ~B(); }; +B::~B() {} +// CHECK: define void @_ZN1BD0Ev +// CHECK: define void @_ZN1BD1Ev +// CHECK: define void @_ZN1BD2Ev diff --git a/test/CodeGenCXX/init-invariant.cpp b/test/CodeGenCXX/init-invariant.cpp new file mode 100644 index 0000000000000..9eb19896b6bbc --- /dev/null +++ b/test/CodeGenCXX/init-invariant.cpp @@ -0,0 +1,60 @@ +// RUN: %clang_cc1 -triple i686-linux-gnu -emit-llvm %s -O0 -o - | FileCheck %s --check-prefix=CHECK-O0 +// RUN: %clang_cc1 -triple i686-linux-gnu -emit-llvm %s -O1 -o - | FileCheck %s + +// Check that we add an llvm.invariant.start to mark when a global becomes +// read-only. If globalopt can fold the initializer, it will then mark the +// variable as constant. + +// Do not produce markers at -O0. +// CHECK-O0-NOT: llvm.invariant.start + +struct A { + A(); + int n; +}; + +// CHECK: @a = global {{.*}} zeroinitializer +extern const A a = A(); + +struct B { + B(); + mutable int n; +}; + +// CHECK: @b = global {{.*}} zeroinitializer +extern const B b = B(); + +struct C { + C(); + ~C(); + int n; +}; + +// CHECK: @c = global {{.*}} zeroinitializer +extern const C c = C(); + +int f(); +// CHECK: @d = global i32 0 +extern const int d = f(); + +void e() { + static const A a = A(); +} + +// CHECK: call void @_ZN1AC1Ev({{.*}}* @a) +// CHECK: call {{.*}}@llvm.invariant.start(i64 4, i8* bitcast ({{.*}} @a to i8*)) + +// CHECK: call void @_ZN1BC1Ev({{.*}}* @b) +// CHECK-NOT: call {{.*}}@llvm.invariant.start(i64 4, i8* bitcast ({{.*}} @b to i8*)) + +// CHECK: call void @_ZN1CC1Ev({{.*}}* @c) +// CHECK-NOT: call {{.*}}@llvm.invariant.start(i64 4, i8* bitcast ({{.*}} @c to i8*)) + +// CHECK: call i32 @_Z1fv( +// CHECK: store {{.*}}, i32* @d +// CHECK: call {{.*}}@llvm.invariant.start(i64 4, i8* bitcast ({{.*}} @d to i8*)) + +// CHECK: define void @_Z1ev( +// CHECK: call void @_ZN1AC1Ev(%struct.A* @_ZZ1evE1a) +// CHECK: call {{.*}}@llvm.invariant.start(i64 4, i8* bitcast ({{.*}} @_ZZ1evE1a to i8*)) +// CHECK-NOT: llvm.invariant.end diff --git a/test/CodeGenCXX/instantiate-temporaries.cpp b/test/CodeGenCXX/instantiate-temporaries.cpp new file mode 100644 index 0000000000000..29cfc07e92d8a --- /dev/null +++ b/test/CodeGenCXX/instantiate-temporaries.cpp @@ -0,0 +1,37 @@ +// RUN: %clang_cc1 -triple x86_64-apple-macosx10.7.0 -emit-llvm -o - %s | FileCheck %s + +struct X { + X(); + ~X(); +}; + +struct Y { + X get(); +}; + +struct X2 { + X x; +}; + +template<typename T> +void call() { + Y().get(); +} + +// CHECK: define weak_odr void @_Z4callIiEvv +// CHECK: call void @_ZN1Y3getEv +// CHECK-NEXT: call void @_ZN1XD1Ev +// CHECK-NEXT: ret void +template void call<int>(); + +template<typename T> +void compound_literal() { + (X2){}; +} + +// CHECK: define weak_odr void @_Z16compound_literalIiEvv +// CHECK: call void @_ZN1XC1Ev +// CHECK-NEXT: call void @_ZN2X2D1Ev +// CHECK-NEXT: ret void +template void compound_literal<int>(); + diff --git a/test/CodeGenCXX/lambda-expressions.cpp b/test/CodeGenCXX/lambda-expressions.cpp new file mode 100644 index 0000000000000..797cbf43a787f --- /dev/null +++ b/test/CodeGenCXX/lambda-expressions.cpp @@ -0,0 +1,78 @@ +// RUN: %clang_cc1 -triple x86_64-apple-darwin10.0.0 -emit-llvm -o - %s -fexceptions -std=c++11 | FileCheck %s + +// CHECK: @var = internal global +auto var = [](int i) { return i+1; }; + +// CHECK: @cvar = global +extern "C" auto cvar = []{}; + +int a() { return []{ return 1; }(); } +// CHECK: define i32 @_Z1av +// CHECK: call i32 @"_ZZ1avENK3$_0clEv" +// CHECK: define internal i32 @"_ZZ1avENK3$_0clEv" +// CHECK: ret i32 1 + +int b(int x) { return [x]{return x;}(); } +// CHECK: define i32 @_Z1bi +// CHECK: store i32 +// CHECK: load i32* +// CHECK: store i32 +// CHECK: call i32 @"_ZZ1biENK3$_1clEv" +// CHECK: define internal i32 @"_ZZ1biENK3$_1clEv" +// CHECK: load i32* +// CHECK: ret i32 + +int c(int x) { return [&x]{return x;}(); } +// CHECK: define i32 @_Z1ci +// CHECK: store i32 +// CHECK: store i32* +// CHECK: call i32 @"_ZZ1ciENK3$_2clEv" +// CHECK: define internal i32 @"_ZZ1ciENK3$_2clEv" +// CHECK: load i32** +// CHECK: load i32* +// CHECK: ret i32 + +struct D { D(); D(const D&); int x; }; +int d(int x) { D y[10]; [x,y] { return y[x].x; }(); } + +// CHECK: define i32 @_Z1di +// CHECK: call void @_ZN1DC1Ev +// CHECK: icmp ult i64 %{{.*}}, 10 +// CHECK: call void @_ZN1DC1ERKS_ +// CHECK: call i32 @"_ZZ1diENK3$_3clEv" +// CHECK: define internal i32 @"_ZZ1diENK3$_3clEv" +// CHECK: load i32* +// CHECK: load i32* +// CHECK: ret i32 + +struct E { E(); E(const E&); ~E(); int x; }; +int e(E a, E b, bool cond) { [a,b,cond](){ return (cond ? a : b).x; }(); } +// CHECK: define i32 @_Z1e1ES_b +// CHECK: call void @_ZN1EC1ERKS_ +// CHECK: invoke void @_ZN1EC1ERKS_ +// CHECK: invoke i32 @"_ZZ1e1ES_bENK3$_4clEv" +// CHECK: call void @"_ZZ1e1ES_bEN3$_4D1Ev" +// CHECK: call void @"_ZZ1e1ES_bEN3$_4D1Ev" + +// CHECK: define internal i32 @"_ZZ1e1ES_bENK3$_4clEv" +// CHECK: trunc i8 +// CHECK: load i32* +// CHECK: ret i32 + +void f() { + // CHECK: define void @_Z1fv() + // CHECK: @"_ZZ1fvENK3$_5cvPFiiiEEv" + // CHECK-NEXT: store i32 (i32, i32)* + // CHECK-NEXT: ret void + int (*fp)(int, int) = [](int x, int y){ return x + y; }; +} + +// CHECK: define internal i32 @"_ZZ1fvEN3$_58__invokeEii" +// CHECK: store i32 +// CHECK-NEXT: store i32 +// CHECK-NEXT: load i32* +// CHECK-NEXT: load i32* +// CHECK-NEXT: call i32 @"_ZZ1fvENK3$_5clEii" +// CHECK-NEXT: ret i32 + +// CHECK: define internal void @"_ZZ1e1ES_bEN3$_4D2Ev" diff --git a/test/CodeGenCXX/mangle-98.cpp b/test/CodeGenCXX/mangle-98.cpp new file mode 100644 index 0000000000000..a9ab6ca423701 --- /dev/null +++ b/test/CodeGenCXX/mangle-98.cpp @@ -0,0 +1,12 @@ +// RUN: %clang_cc1 -emit-llvm %s -o - -triple=x86_64-apple-darwin9 -std=c++98 | FileCheck %s + +template <bool B> struct S3 {}; + +// CHECK: define void @_Z1f2S3ILb1EE +void f(S3<true>) {} + +// CHECK: define void @_Z1f2S3ILb0EE +void f(S3<false>) {} + +// CHECK: define void @_Z2f22S3ILb1EE +void f2(S3<100>) {} diff --git a/test/CodeGenCXX/mangle-address-space.cpp b/test/CodeGenCXX/mangle-address-space.cpp index fbbcbfa35b58f..ff23c206911cf 100644 --- a/test/CodeGenCXX/mangle-address-space.cpp +++ b/test/CodeGenCXX/mangle-address-space.cpp @@ -4,3 +4,9 @@ void f0(char *p) { } // CHECK: define void @_Z2f0PU3AS1c void f0(char __attribute__((address_space(1))) *p) { } + +struct OpaqueType; +typedef OpaqueType __attribute__((address_space(100))) * OpaqueTypePtr; + +// CHECK: define void @_Z2f0PU5AS10010OpaqueType +void f0(OpaqueTypePtr) { } diff --git a/test/CodeGenCXX/mangle-alias-template.cpp b/test/CodeGenCXX/mangle-alias-template.cpp index 1143ea114a1af..5ace0b01cc2ed 100644 --- a/test/CodeGenCXX/mangle-alias-template.cpp +++ b/test/CodeGenCXX/mangle-alias-template.cpp @@ -11,6 +11,10 @@ template<typename T> void g(T); template<template<typename> class F> void h(F<int>); +template<typename,typename,typename> struct S {}; +template<typename T, typename U> using U = S<T, int, U>; +template<typename...Ts> void h(U<Ts...>, Ts...); + // CHECK: define void @_Z1zv( void z() { vector<int> VI; @@ -38,4 +42,7 @@ void z() { Vec<Vec<int>> VVI; g(VVI); // CHECK: call void @_Z1gI6vectorIS0_Ii5allocIiEES1_IS3_EEEvT_( + + // CHECK: call void @_Z1hIJidEEv1UIDpT_ES2_ + h({}, 0, 0.0); } diff --git a/test/CodeGenCXX/mangle-exprs.cpp b/test/CodeGenCXX/mangle-exprs.cpp index c5f72d83c7501..30da4fbbcdf94 100644 --- a/test/CodeGenCXX/mangle-exprs.cpp +++ b/test/CodeGenCXX/mangle-exprs.cpp @@ -1,5 +1,37 @@ // RUN: %clang_cc1 -std=c++11 -emit-llvm %s -o - -triple=x86_64-apple-darwin9 | FileCheck %s +namespace std { + typedef decltype(sizeof(int)) size_t; + + // libc++'s implementation + template <class _E> + class initializer_list + { + const _E* __begin_; + size_t __size_; + + initializer_list(const _E* __b, size_t __s) + : __begin_(__b), + __size_(__s) + {} + + public: + typedef _E value_type; + typedef const _E& reference; + typedef const _E& const_reference; + typedef size_t size_type; + + typedef const _E* iterator; + typedef const _E* const_iterator; + + initializer_list() : __begin_(nullptr), __size_(0) {} + + size_t size() const {return __size_;} + const _E* begin() const {return __begin_;} + const _E* end() const {return __begin_ + __size_;} + }; +} + template < bool condition, typename T = void > struct enable_if { typedef T type; }; @@ -28,6 +60,10 @@ namespace Casts { void auto_(decltype(new auto(T()))) { } + template< typename T > + void scalar_(decltype(T(), int())) { + } + // FIXME: Test const_cast, reinterpret_cast, dynamic_cast, which are // a bit harder to use in template arguments. template <unsigned N> struct T {}; @@ -48,6 +84,9 @@ namespace Casts { // CHECK: define weak_odr void @_ZN5Casts5auto_IiEEvDTnw_DapicvT__EEE( template void auto_<int>(int*); + + // CHECK: define weak_odr void @_ZN5Casts7scalar_IiEEvDTcmcvT__Ecvi_EE( + template void scalar_<int>(int); } namespace test1 { @@ -125,3 +164,30 @@ namespace test3 { a(x, &X::member, ip); } } + +namespace test4 { + struct X { + X(int); + }; + + template <typename T> + void tf1(decltype(new T(1)) p) + {} + + template <typename T> + void tf2(decltype(new T({1})) p) + {} + + template <typename T> + void tf3(decltype(new T{1}) p) + {} + + // CHECK: void @_ZN5test43tf1INS_1XEEEvDTnw_T_piLi1EEE + template void tf1<X>(X*); + + // CHECK: void @_ZN5test43tf2INS_1XEEEvDTnw_T_piilLi1EEEE + template void tf2<X>(X*); + + // CHECK: void @_ZN5test43tf3INS_1XEEEvDTnw_T_ilLi1EEE + template void tf3<X>(X*); +} diff --git a/test/CodeGenCXX/mangle-lambdas.cpp b/test/CodeGenCXX/mangle-lambdas.cpp new file mode 100644 index 0000000000000..cc53b0105750a --- /dev/null +++ b/test/CodeGenCXX/mangle-lambdas.cpp @@ -0,0 +1,202 @@ +// RUN: %clang_cc1 -std=c++11 -triple x86_64-apple-macosx10.7.0 -emit-llvm -o - %s | FileCheck %s + +// CHECK: define linkonce_odr void @_Z11inline_funci +inline void inline_func(int n) { + // CHECK: call i32 @_ZZ11inline_funciENKUlvE_clEv + int i = []{ return 1; }(); + + // CHECK: call i32 @_ZZ11inline_funciENKUlvE0_clEv + int j = [=] { return n + i; }(); + + // CHECK: call double @_ZZ11inline_funciENKUlvE1_clEv + int k = [=] () -> double { return n + i; }(); + + // CHECK: call i32 @_ZZ11inline_funciENKUliE_clEi + int l = [=] (int x) -> int { return x + i; }(n); + + int inner(int i = []{ return 17; }()); + // CHECK: call i32 @_ZZ11inline_funciENKUlvE2_clEv + // CHECK-NEXT: call i32 @_Z5inneri + inner(); + + // CHECK-NEXT: ret void +} + +void call_inline_func() { + inline_func(17); +} + +struct S { + void f(int = []{return 1;}() + + []{return 2;}(), + int = []{return 3;}()); + void g(int, int); +}; + +void S::g(int i = []{return 1;}(), + int j = []{return 2; }()) {} + +// CHECK: define void @_Z6test_S1S +void test_S(S s) { + // CHECK: call i32 @_ZZN1S1fEiiEd0_NKUlvE_clEv + // CHECK-NEXT: call i32 @_ZZN1S1fEiiEd0_NKUlvE0_clEv + // CHECK-NEXT: add nsw i32 + // CHECK-NEXT: call i32 @_ZZN1S1fEiiEd_NKUlvE_clEv + // CHECK-NEXT: call void @_ZN1S1fEii + s.f(); + + // NOTE: These manglings don't actually matter that much, because + // the lambdas in the default arguments of g() won't be seen by + // multiple translation units. We check them mainly to ensure that they don't + // get the special mangling for lambdas in in-class default arguments. + // CHECK: call i32 @"_ZNK1S3$_0clEv" + // CHECK-NEXT: call i32 @"_ZNK1S3$_1clEv" + // CHECK-NEXT: call void @_ZN1S1gEi + s.g(); + + // CHECK-NEXT: ret void +} + +// Check the linkage of the lambda call operators used in test_S. +// CHECK: define linkonce_odr i32 @_ZZN1S1fEiiEd0_NKUlvE_clEv +// CHECK: ret i32 1 +// CHECK: define linkonce_odr i32 @_ZZN1S1fEiiEd0_NKUlvE0_clEv +// CHECK: ret i32 2 +// CHECK: define linkonce_odr i32 @_ZZN1S1fEiiEd_NKUlvE_clEv +// CHECK: ret i32 3 +// CHECK: define internal i32 @"_ZNK1S3$_0clEv" +// CHECK: ret i32 1 +// CHECK: define internal i32 @"_ZNK1S3$_1clEv" +// CHECK: ret i32 2 + +template<typename T> +struct ST { + void f(T = []{return T() + 1;}() + + []{return T() + 2;}(), + T = []{return T(3);}()); +}; + +// CHECK: define void @_Z7test_ST2STIdE +void test_ST(ST<double> st) { + // CHECK: call double @_ZZN2ST1fET_S0_Ed0_NKUlvE_clEv + // CHECK-NEXT: call double @_ZZN2ST1fET_S0_Ed0_NKUlvE0_clEv + // CHECK-NEXT: fadd double + // CHECK-NEXT: call double @_ZZN2ST1fET_S0_Ed_NKUlvE_clEv + // CHECK-NEXT: call void @_ZN2STIdE1fEdd + st.f(); + + // CHECK-NEXT: ret void +} + +// Check the linkage of the lambda call operators used in test_ST. +// CHECK: define linkonce_odr double @_ZZN2ST1fET_S0_Ed0_NKUlvE_clEv +// CHECK: ret double 1 +// CHECK: define linkonce_odr double @_ZZN2ST1fET_S0_Ed0_NKUlvE0_clEv +// CHECK: ret double 2 +// CHECK: define linkonce_odr double @_ZZN2ST1fET_S0_Ed_NKUlvE_clEv +// CHECK: ret double 3 + +template<typename T> +struct StaticMembers { + static T x; + static T y; + static T z; +}; + +template<typename T> int accept_lambda(T); + +template<typename T> +T StaticMembers<T>::x = []{return 1;}() + []{return 2;}(); + +template<typename T> +T StaticMembers<T>::y = []{return 3;}(); + +template<typename T> +T StaticMembers<T>::z = accept_lambda([]{return 4;}); + +// CHECK: define internal void @__cxx_global_var_init() +// CHECK: call i32 @_ZNK13StaticMembersIfE1xMUlvE_clEv +// CHECK-NEXT: call i32 @_ZNK13StaticMembersIfE1xMUlvE0_clEv +// CHECK-NEXT: add nsw +// CHECK: define linkonce_odr i32 @_ZNK13StaticMembersIfE1xMUlvE_clEv +// CHECK: ret i32 1 +// CHECK: define linkonce_odr i32 @_ZNK13StaticMembersIfE1xMUlvE0_clEv +// CHECK: ret i32 2 +template float StaticMembers<float>::x; + +// CHECK: define internal void @__cxx_global_var_init1() +// CHECK: call i32 @_ZNK13StaticMembersIfE1yMUlvE_clEv +// CHECK: define linkonce_odr i32 @_ZNK13StaticMembersIfE1yMUlvE_clEv +// CHECK: ret i32 3 +template float StaticMembers<float>::y; + +// CHECK: define internal void @__cxx_global_var_init2() +// CHECK: call i32 @_Z13accept_lambdaIN13StaticMembersIfE1zMUlvE_EEiT_ +// CHECK: declare i32 @_Z13accept_lambdaIN13StaticMembersIfE1zMUlvE_EEiT_() +template float StaticMembers<float>::z; + +// CHECK: define internal void @__cxx_global_var_init3 +// CHECK: call i32 @"_ZNK13StaticMembersIdE3$_2clEv" +// CHECK: define internal i32 @"_ZNK13StaticMembersIdE3$_2clEv" +// CHECK: ret i32 42 +template<> double StaticMembers<double>::z = []{return 42; }(); + +template<typename T> +void func_template(T = []{ return T(); }()); + +// CHECK: define void @_Z17use_func_templatev() +void use_func_template() { + // CHECK: call i32 @"_ZZ13func_templateIiEvT_ENKS_IiE3$_3clEv" + func_template<int>(); +} + +// CHECK: define linkonce_odr void @_Z1fIZZNK23TestNestedInstantiationclEvENKUlvE_clEvEUlvE_EvT_ + +struct Members { + int x = [] { return 1; }() + [] { return 2; }(); + int y = [] { return 3; }(); +}; + +void test_Members() { + // CHECK: define linkonce_odr void @_ZN7MembersC2Ev + // CHECK: call i32 @_ZNK7Members1xMUlvE_clEv + // CHECK-NEXT: call i32 @_ZNK7Members1xMUlvE0_clE + // CHECK-NEXT: add nsw i32 + // CHECK: call i32 @_ZNK7Members1yMUlvE_clEv + Members members; + // CHECK: ret void +} + +template<typename P> void f(P) { } + +struct TestNestedInstantiation { + void operator()() const { + []() -> void { + return f([]{}); + }(); + } +}; + +void test_NestedInstantiation() { + TestNestedInstantiation()(); +} + +// Check the linkage of the lambdas used in test_Members. +// CHECK: define linkonce_odr i32 @_ZNK7Members1xMUlvE_clEv +// CHECK: ret i32 1 +// CHECK: define linkonce_odr i32 @_ZNK7Members1xMUlvE0_clEv +// CHECK: ret i32 2 +// CHECK: define linkonce_odr i32 @_ZNK7Members1yMUlvE_clEv +// CHECK: ret i32 3 + +// Check linkage of the various lambdas. +// CHECK: define linkonce_odr i32 @_ZZ11inline_funciENKUlvE_clEv +// CHECK: ret i32 1 +// CHECK: define linkonce_odr i32 @_ZZ11inline_funciENKUlvE0_clEv +// CHECK: ret i32 +// CHECK: define linkonce_odr double @_ZZ11inline_funciENKUlvE1_clEv +// CHECK: ret double +// CHECK: define linkonce_odr i32 @_ZZ11inline_funciENKUliE_clEi +// CHECK: ret i32 +// CHECK: define linkonce_odr i32 @_ZZ11inline_funciENKUlvE2_clEv +// CHECK: ret i32 17 diff --git a/test/CodeGenCXX/mangle-ms.cpp b/test/CodeGenCXX/mangle-ms.cpp index d8d75b7d0f0e7..fe5fde1a1b3bf 100644 --- a/test/CodeGenCXX/mangle-ms.cpp +++ b/test/CodeGenCXX/mangle-ms.cpp @@ -28,7 +28,18 @@ protected: public: static const volatile char f; int operator+(int a); -}; + foo(){} +//CHECK: @"\01??0foo@@QAE@XZ" + + ~foo(){} +//CHECK: @"\01??1foo@@QAE@XZ" + + foo(int i){} +//CHECK: @"\01??0foo@@QAE@H@Z" + + foo(char *q){} +//CHECK: @"\01??0foo@@QAE@PAD@Z" +}f,s1(1),s2((char*)0); struct bar { static int g; diff --git a/test/CodeGenCXX/mangle-nullptr-arg.cpp b/test/CodeGenCXX/mangle-nullptr-arg.cpp new file mode 100644 index 0000000000000..393de0b0ece94 --- /dev/null +++ b/test/CodeGenCXX/mangle-nullptr-arg.cpp @@ -0,0 +1,13 @@ +// RUN: %clang_cc1 -std=c++11 -emit-llvm -o - %s | FileCheck %s + +template<int *ip> struct IP {}; + +// CHECK: define void @_Z5test12IPILPi0EE +void test1(IP<nullptr>) {} + +struct X{ }; +template<int X::*pm> struct PM {}; + +// CHECK: define void @_Z5test22PMILM1Xi0EE +void test2(PM<nullptr>) { } + diff --git a/test/CodeGenCXX/mangle-std-externc.cpp b/test/CodeGenCXX/mangle-std-externc.cpp new file mode 100644 index 0000000000000..a478dee4a42c7 --- /dev/null +++ b/test/CodeGenCXX/mangle-std-externc.cpp @@ -0,0 +1,27 @@ +// RUN: %clang_cc1 %s -DNS=std -emit-llvm -o - | FileCheck %s --check-prefix=CHECK-STD +// RUN: %clang_cc1 %s -DNS=n -emit-llvm -o - | FileCheck %s --check-prefix=CHECK-N + +// _ZNSt1DISt1CE1iE = std::D<std::C>::i +// CHECK-STD: @_ZNSt1DISt1CE1iE = + +// _ZN1n1DINS_1CEE1iE == n::D<n::C>::i +// CHECK-N: @_ZN1n1DINS_1CEE1iE = + +namespace NS { + extern "C" { + class C { + }; + } + + template <class T> + class D { + public: + static int i; + }; + +} + + +int f() { + return NS::D<NS::C>::i; +} diff --git a/test/CodeGenCXX/mangle-template.cpp b/test/CodeGenCXX/mangle-template.cpp index f95e1521549d5..05c3a5851e4a1 100644 --- a/test/CodeGenCXX/mangle-template.cpp +++ b/test/CodeGenCXX/mangle-template.cpp @@ -144,3 +144,29 @@ namespace test10 { f(i, d); } } + +// Report from Jason Merrill on cxx-abi-dev, 2012.01.04. +namespace test11 { + int cmp(char a, char b); + template <typename T, int (*cmp)(T, T)> struct A {}; + template <typename T> void f(A<T,cmp> &) {} + template void f<char>(A<char,cmp> &); + // CHECK: @_ZN6test111fIcEEvRNS_1AIT_L_ZNS_3cmpEccEEE( +} + +namespace test12 { + // Make sure we can mangle non-type template args with internal linkage. + static int f(); + const int n = 10; + template<typename T, T v> void test() {} + void use() { + // CHECK: define internal void @_ZN6test124testIFivEXadL_ZNS_L1fEvEEEEvv( + test<int(), &f>(); + // CHECK: define internal void @_ZN6test124testIRFivEXadL_ZNS_L1fEvEEEEvv( + test<int(&)(), f>(); + // CHECK: define internal void @_ZN6test124testIPKiXadL_ZNS_L1nEEEEEvv( + test<const int*, &n>(); + // CHECK: define internal void @_ZN6test124testIRKiXadL_ZNS_L1nEEEEEvv( + test<const int&, n>(); + } +} diff --git a/test/CodeGenCXX/mangle.cpp b/test/CodeGenCXX/mangle.cpp index 47c42a7347fab..ba1b3bf5acd26 100644 --- a/test/CodeGenCXX/mangle.cpp +++ b/test/CodeGenCXX/mangle.cpp @@ -76,9 +76,6 @@ void f(S3<true>) {} // CHECK: define void @_Z1f2S3ILb0EE void f(S3<false>) {} -// CHECK: define void @_Z2f22S3ILb1EE -void f2(S3<100>) {} - struct S; // CHECK: define void @_Z1fM1SKFvvE @@ -364,6 +361,14 @@ namespace test0 { j<A>(buffer); } // CHECK: define linkonce_odr void @_ZN5test01jINS_1AEEEvRAszdtcvT__E6buffer_c( + + template <class T> void k(char (&buffer)[sizeof(T() + 0.0f)]) {} + void test5() { + char buffer[sizeof(float)]; + k<float>(buffer); + } + // CHECK: define linkonce_odr void @_ZN5test01kIfEEvRAszplcvT__ELf00000000E_c( + } namespace test1 { diff --git a/test/CodeGenCXX/member-function-pointer-calls.cpp b/test/CodeGenCXX/member-function-pointer-calls.cpp index 6f0ef81fe35dc..f8960aac52ef9 100644 --- a/test/CodeGenCXX/member-function-pointer-calls.cpp +++ b/test/CodeGenCXX/member-function-pointer-calls.cpp @@ -9,16 +9,14 @@ int f(A* a, int (A::*fp)()) { } // CHECK: define i32 @_Z2g1v() -// CHECK-NEXT: {{.*}}: -// CHECK-NEXT: ret i32 1 +// CHECK: ret i32 1 int g1() { A a; return f(&a, &A::vf1); } // CHECK: define i32 @_Z2g2v() -// CHECK-NEXT: {{.*}}: -// CHECK-NEXT: ret i32 2 +// CHECK: ret i32 2 int g2() { A a; return f(&a, &A::vf2); diff --git a/test/CodeGenCXX/member-function-pointers.cpp b/test/CodeGenCXX/member-function-pointers.cpp index 5ce5fbf760dba..2417aa41918b2 100644 --- a/test/CodeGenCXX/member-function-pointers.cpp +++ b/test/CodeGenCXX/member-function-pointers.cpp @@ -28,6 +28,16 @@ void (C::*pc2)() = &C::f; // CHECK: @pc3 = global { i64, i64 } { i64 1, i64 0 }, align 8 void (A::*pc3)() = &A::vf1; +// Tests for test10. +// CHECK: @_ZN6test101aE = global { i64, i64 } { i64 ptrtoint (void (%"struct.test10::A"*)* @_ZN6test101A3fooEv to i64), i64 0 }, align 8 +// CHECK: @_ZN6test101bE = global { i64, i64 } { i64 ptrtoint (void (%"struct.test10::A"*)* @_ZN6test101A3fooEv to i64), i64 8 }, align 8 +// CHECK: @_ZN6test101cE = global { i64, i64 } { i64 ptrtoint (void (%"struct.test10::A"*)* @_ZN6test101A3fooEv to i64), i64 8 }, align 8 +// CHECK: @_ZN6test101dE = global { i64, i64 } { i64 ptrtoint (void (%"struct.test10::A"*)* @_ZN6test101A3fooEv to i64), i64 16 }, align 8 +// CHECK-LP32: @_ZN6test101aE = global { i32, i32 } { i32 ptrtoint (void (%"struct.test10::A"*)* @_ZN6test101A3fooEv to i32), i32 0 }, align 4 +// CHECK-LP32: @_ZN6test101bE = global { i32, i32 } { i32 ptrtoint (void (%"struct.test10::A"*)* @_ZN6test101A3fooEv to i32), i32 4 }, align 4 +// CHECK-LP32: @_ZN6test101cE = global { i32, i32 } { i32 ptrtoint (void (%"struct.test10::A"*)* @_ZN6test101A3fooEv to i32), i32 4 }, align 4 +// CHECK-LP32: @_ZN6test101dE = global { i32, i32 } { i32 ptrtoint (void (%"struct.test10::A"*)* @_ZN6test101A3fooEv to i32), i32 8 }, align 4 + void f() { // CHECK: store { i64, i64 } zeroinitializer, { i64, i64 }* @pa pa = 0; @@ -232,3 +242,33 @@ namespace test9 { static S array[] = { (fooptr) &B::foo }; } } + +// rdar://problem/10815683 - Verify that we can emit reinterprets of +// member pointers as constant initializers. For added trickiness, +// we also add some non-trivial adjustments. +namespace test10 { + struct A { + int nonEmpty; + void foo(); + }; + struct B : public A { + virtual void requireNonZeroAdjustment(); + }; + struct C { + int nonEmpty; + }; + struct D : public C { + virtual void requireNonZeroAdjustment(); + }; + + // Non-ARM tests at top of file. + void (A::*a)() = &A::foo; + void (B::*b)() = (void (B::*)()) &A::foo; + void (C::*c)() = (void (C::*)()) (void (B::*)()) &A::foo; + void (D::*d)() = (void (C::*)()) (void (B::*)()) &A::foo; +} +// It's not that the offsets are doubled on ARM, it's that they're left-shifted by 1. +// CHECK-ARM: @_ZN6test101aE = global { i32, i32 } { i32 ptrtoint (void (%"struct.test10::A"*)* @_ZN6test101A3fooEv to i32), i32 0 }, align 4 +// CHECK-ARM: @_ZN6test101bE = global { i32, i32 } { i32 ptrtoint (void (%"struct.test10::A"*)* @_ZN6test101A3fooEv to i32), i32 8 }, align 4 +// CHECK-ARM: @_ZN6test101cE = global { i32, i32 } { i32 ptrtoint (void (%"struct.test10::A"*)* @_ZN6test101A3fooEv to i32), i32 8 }, align 4 +// CHECK-ARM: @_ZN6test101dE = global { i32, i32 } { i32 ptrtoint (void (%"struct.test10::A"*)* @_ZN6test101A3fooEv to i32), i32 16 }, align 4 diff --git a/test/CodeGenCXX/new-array-init-exceptions.cpp b/test/CodeGenCXX/new-array-init-exceptions.cpp new file mode 100644 index 0000000000000..5d9cc9fa636d4 --- /dev/null +++ b/test/CodeGenCXX/new-array-init-exceptions.cpp @@ -0,0 +1,41 @@ +// RUN: %clang_cc1 -std=c++11 -triple i386-unknown-unknown -fexceptions -fcxx-exceptions %s -emit-llvm -o - | FileCheck %s +// REQUIRES: asserts + +struct Throws { + Throws(int); + Throws(); + ~Throws(); +}; + +// CHECK: define void @_Z7cleanupi +void cleanup(int n) { + // CHECK: invoke void @_ZN6ThrowsC1Ei + // CHECK-NEXT: to label %{{[^ ]+}} unwind label %[[LPAD:[^ ]+]] + // CHECK: invoke void @_ZN6ThrowsC1Ei + // CHECK-NEXT: to label %{{[^ ]+}} unwind label %[[LPAD]] + // CHECK: invoke void @_ZN6ThrowsC1Ei + // CHECK-NEXT: to label %{{[^ ]+}} unwind label %[[LPAD]] + // CHECK: invoke void @_ZN6ThrowsC1Ev + // CHECK-NEXT: to label %{{[^ ]+}} unwind label %[[LPAD]] + new Throws[n] { 1, 2, 3 }; + // CHECK: [[LPAD]]: + // CHECK-NEXT: landingpad + // CHECK: call void @_ZN6ThrowsD1Ev + // CHECK: call void @_ZdaPv +} + + +// CHECK: define void @_Z7cleanupv +void cleanup() { + // CHECK: invoke void @_ZN6ThrowsC1Ei + // CHECK-NEXT: to label %{{[^ ]+}} unwind label %[[LPAD2:[^ ]+]] + // CHECK: invoke void @_ZN6ThrowsC1Ei + // CHECK-NEXT: to label %{{[^ ]+}} unwind label %[[LPAD2]] + // CHECK: invoke void @_ZN6ThrowsC1Ei + // CHECK-NEXT: to label %{{[^ ]+}} unwind label %[[LPAD2]] + new Throws[3] { 1, 2, 3 }; + // CHECK: [[LPAD2]]: + // CHECK-NEXT: landingpad + // CHECK: call void @_ZN6ThrowsD1Ev + // CHECK: call void @_ZdaPv +} diff --git a/test/CodeGenCXX/new-array-init.cpp b/test/CodeGenCXX/new-array-init.cpp new file mode 100644 index 0000000000000..231df24781ae7 --- /dev/null +++ b/test/CodeGenCXX/new-array-init.cpp @@ -0,0 +1,33 @@ +// RUN: %clang_cc1 -std=c++11 -triple i386-unknown-unknown %s -emit-llvm -o - | FileCheck %s + +// CHECK: define void @_Z2fni +void fn(int n) { + // CHECK: icmp ult i{{32|64}} %{{[^ ]+}}, 3 + // CHECK: store i32 1 + // CHECK: store i32 2 + // CHECK: store i32 3 + // CHECK: icmp eq i32* + // CHECK-NEXT: br i1 + new int[n] { 1, 2, 3 }; +} + +// CHECK: define void @_Z15const_underflowv +void const_underflow() { + // CHECK-NOT: icmp ult i{{32|64}} %{{[^ ]+}}, 3 + // CHECK: call noalias i8* @_Zna{{.}}(i{{32|64}} -1) + new int[2] { 1, 2, 3 }; +} + +// CHECK: define void @_Z11const_exactv +void const_exact() { + // CHECK-NOT: icmp ult i{{32|64}} %{{[^ ]+}}, 3 + // CHECK-NOT: icmp eq i32* + new int[3] { 1, 2, 3 }; +} + +// CHECK: define void @_Z16const_sufficientv +void const_sufficient() { + // CHECK-NOT: icmp ult i{{32|64}} %{{[^ ]+}}, 3 + new int[4] { 1, 2, 3 }; + // CHECK: ret void +} diff --git a/test/CodeGenCXX/new.cpp b/test/CodeGenCXX/new.cpp index 3a72bb84e7f65..8d9f641ba1cc9 100644 --- a/test/CodeGenCXX/new.cpp +++ b/test/CodeGenCXX/new.cpp @@ -231,3 +231,22 @@ namespace PR10197 { template void f<int>(); } + +namespace PR11523 { + class MyClass; + typedef int MyClass::* NewTy; + // CHECK: define i64* @_ZN7PR115231fEv + // CHECK: store i64 -1 + NewTy* f() { return new NewTy[2](); } +} + +namespace PR11757 { + // Make sure we elide the copy construction. + struct X { X(); X(const X&); }; + X* a(X* x) { return new X(X()); } + // CHECK: define {{.*}} @_ZN7PR117571aEPNS_1XE + // CHECK: [[CALL:%.*]] = call noalias i8* @_Znwm + // CHECK-NEXT: [[CASTED:%.*]] = bitcast i8* [[CALL]] to + // CHECK-NEXT: call void @_ZN7PR117571XC1Ev({{.*}}* [[CASTED]]) + // CHECK-NEXT: ret {{.*}} [[CASTED]] +} diff --git a/test/CodeGenCXX/nrvo.cpp b/test/CodeGenCXX/nrvo.cpp index 57bf27ab7aff9..2feaf682413cb 100644 --- a/test/CodeGenCXX/nrvo.cpp +++ b/test/CodeGenCXX/nrvo.cpp @@ -147,3 +147,15 @@ X test5() { } } #endif + +// rdar://problem/10430868 +// CHECK: define void @_Z5test6v +X test6() { + X a __attribute__((aligned(8))); + return a; + // CHECK: [[A:%.*]] = alloca [[X:%.*]], align 8 + // CHECK-NEXT: call {{.*}} @_ZN1XC1Ev([[X]]* [[A]]) + // CHECK-NEXT: call {{.*}} @_ZN1XC1ERKS_([[X]]* {{%.*}}, [[X]]* [[A]]) + // CHECK-NEXT: call {{.*}} @_ZN1XD1Ev([[X]]* [[A]]) + // CHECK-NEXT: ret void +} diff --git a/test/CodeGenCXX/override-layout.cpp b/test/CodeGenCXX/override-layout.cpp new file mode 100644 index 0000000000000..d432885c58484 --- /dev/null +++ b/test/CodeGenCXX/override-layout.cpp @@ -0,0 +1,64 @@ +// RUN: %clang_cc1 -fdump-record-layouts-simple %s 2> %t.layouts +// RUN: %clang_cc1 -fdump-record-layouts-simple %s > %t.before 2>&1 +// RUN: %clang_cc1 -DPACKED= -DALIGNED16= -fdump-record-layouts-simple -foverride-record-layout=%t.layouts %s > %t.after 2>&1 +// RUN: diff %t.before %t.after +// RUN: FileCheck %s < %t.after + +// If not explicitly disabled, set PACKED to the packed attribute. +#ifndef PACKED +# define PACKED __attribute__((packed)) +#endif + +struct Empty1 { }; +struct Empty2 { }; + +// CHECK: Type: struct X0 +struct X0 : public Empty1 { + int x[6] PACKED; +}; + +// CHECK: Type: struct X1 +struct X1 : public X0, public Empty2 { + char x[13]; + struct X0 y; +} PACKED; + +// CHECK: Type: struct X2 +struct PACKED X2 : public X1, public X0, public Empty1 { + short x; + int y; +}; + +// CHECK: Type: struct X3 +struct PACKED X3 : virtual public X1, public X0 { + short x; + int y; +}; + +// CHECK: Type: struct X4 +struct PACKED X4 { + unsigned int a : 1; + unsigned int b : 1; + unsigned int c : 1; + unsigned int d : 1; + unsigned int e : 1; + unsigned int f : 1; + unsigned int g : 1; + unsigned int h : 1; + unsigned int i : 1; + unsigned int j : 1; + unsigned int k : 1; + unsigned int l : 1; + unsigned int m : 1; + unsigned int n : 1; + X4(); +}; + +void use_structs() { + X0 x0s[sizeof(X0)]; + X1 x1s[sizeof(X1)]; + X2 x2s[sizeof(X2)]; + X3 x3s[sizeof(X3)]; + X4 x4s[sizeof(X4)]; + x4s[1].a = 1; +} diff --git a/test/CodeGenCXX/pointers-to-data-members.cpp b/test/CodeGenCXX/pointers-to-data-members.cpp index f0246c89b6993..90024e4dfed74 100644 --- a/test/CodeGenCXX/pointers-to-data-members.cpp +++ b/test/CodeGenCXX/pointers-to-data-members.cpp @@ -230,3 +230,13 @@ namespace test4 { // CHECK-GLOBAL: @_ZN5test41dE = global %"struct.test4::D" { %"struct.test4::C.base" zeroinitializer, i32* null, %"struct.test4::B.base" { i32 (...)** null, i64 -1 }, %"struct.test4::A" zeroinitializer }, align 8 D d; } + +namespace PR11487 { + union U + { + int U::* mptr; + char x[16]; + } x; + // CHECK-GLOBAL: @_ZN7PR114871xE = global %"union.PR11487::U" { i64 -1, [8 x i8] zeroinitializer }, align 8 + +} diff --git a/test/CodeGenCXX/pr11676.cpp b/test/CodeGenCXX/pr11676.cpp new file mode 100644 index 0000000000000..896751ad6e31b --- /dev/null +++ b/test/CodeGenCXX/pr11676.cpp @@ -0,0 +1,17 @@ +// RUN: %clang_cc1 %s -std=c++11 -emit-llvm-only +// CHECK that we don't crash. + +// PR11676's example is ill-formed: +/* +union _XEvent { +}; +void ProcessEvent() { + _XEvent pluginEvent = _XEvent(); +} +*/ + +// Example from PR11665: +void f() { + union U { int field; } u = U(); + (void)U().field; +} diff --git a/test/CodeGenCXX/pr11797.cpp b/test/CodeGenCXX/pr11797.cpp new file mode 100644 index 0000000000000..05221acc84f37 --- /dev/null +++ b/test/CodeGenCXX/pr11797.cpp @@ -0,0 +1,8 @@ +// RUN: %clang_cc1 %s -fvisibility hidden -emit-llvm -o - | FileCheck %s + +namespace std __attribute__ ((__visibility__ ("default"))) {} +#pragma GCC visibility push(default) +void foo() { +} +#pragma GCC visibility pop +// CHECK: define void @_Z3foov() diff --git a/test/CodeGenCXX/pr12104.cpp b/test/CodeGenCXX/pr12104.cpp new file mode 100644 index 0000000000000..a62f04b66834a --- /dev/null +++ b/test/CodeGenCXX/pr12104.cpp @@ -0,0 +1,7 @@ +// RUN: %clang_cc1 -include %S/pr12104.h %s -emit-llvm -o - | FileCheck %s +// RUN: %clang_cc1 -x c++ -emit-pch -o %t %S/pr12104.h +// RUN: %clang_cc1 -include-pch %t %s -emit-llvm -o - | FileCheck %s + +template struct Patch<1>; + +// CHECK: _ZN5PatchILi1EE11no_neighborE diff --git a/test/CodeGenCXX/pr12104.h b/test/CodeGenCXX/pr12104.h new file mode 100644 index 0000000000000..f3e9363fe1919 --- /dev/null +++ b/test/CodeGenCXX/pr12104.h @@ -0,0 +1,9 @@ +template <int dimm> struct Patch { + static const unsigned int no_neighbor = 1; +}; +template <int dim> +const unsigned int Patch<dim>::no_neighbor; +void f(const unsigned int); +void g() { + f(Patch<1>::no_neighbor); +} diff --git a/test/CodeGenCXX/pr12251.cpp b/test/CodeGenCXX/pr12251.cpp new file mode 100644 index 0000000000000..a9920c073388d --- /dev/null +++ b/test/CodeGenCXX/pr12251.cpp @@ -0,0 +1,146 @@ +// RUN: %clang_cc1 %s -emit-llvm -O1 -relaxed-aliasing -fstrict-enums -std=c++11 -o - | FileCheck %s +// RUN: %clang_cc1 %s -emit-llvm -O1 -relaxed-aliasing -std=c++11 -o - | FileCheck --check-prefix=NO-STRICT-ENUMS %s + +bool f(bool *x) { + return *x; +} +// CHECK: define zeroext i1 @_Z1fPb +// CHECK: load i8* %{{.*}}, align 1, !range !0 + +// Only enum-tests follow. Ensure that after the bool test, no further range +// metadata shows up when strict enums are disabled. +// NO-STRICT-ENUMS: define zeroext i1 @_Z1fPb +// NO-STRICT-ENUMS: load i8* %{{.*}}, align 1, !range !0 +// NO-STRICT-ENUMS-NOT: !range + +enum e1 { }; +e1 g1(e1 *x) { + return *x; +} +// CHECK: define i32 @_Z2g1P2e1 +// CHECK: load i32* %x, align 4, !range !1 + +enum e2 { e2_a = 0 }; +e2 g2(e2 *x) { + return *x; +} +// CHECK: define i32 @_Z2g2P2e2 +// CHECK: load i32* %x, align 4, !range !1 + +enum e3 { e3_a = 16 }; +e3 g3(e3 *x) { + return *x; +} +// CHECK: define i32 @_Z2g3P2e3 +// CHECK: load i32* %x, align 4, !range !2 + +enum e4 { e4_a = -16}; +e4 g4(e4 *x) { + return *x; +} +// CHECK: define i32 @_Z2g4P2e4 +// CHECK: load i32* %x, align 4, !range !3 + +enum e5 { e5_a = -16, e5_b = 16}; +e5 g5(e5 *x) { + return *x; +} +// CHECK: define i32 @_Z2g5P2e5 +// CHECK: load i32* %x, align 4, !range !4 + +enum e6 { e6_a = -1 }; +e6 g6(e6 *x) { + return *x; +} +// CHECK: define i32 @_Z2g6P2e6 +// CHECK: load i32* %x, align 4, !range !5 + +enum e7 { e7_a = -16, e7_b = 2}; +e7 g7(e7 *x) { + return *x; +} +// CHECK: define i32 @_Z2g7P2e7 +// CHECK: load i32* %x, align 4, !range !3 + +enum e8 { e8_a = -17}; +e8 g8(e8 *x) { + return *x; +} +// CHECK: define i32 @_Z2g8P2e8 +// CHECK: load i32* %x, align 4, !range !4 + +enum e9 { e9_a = 17}; +e9 g9(e9 *x) { + return *x; +} +// CHECK: define i32 @_Z2g9P2e9 +// CHECK: load i32* %x, align 4, !range !2 + +enum e10 { e10_a = -16, e10_b = 32}; +e10 g10(e10 *x) { + return *x; +} +// CHECK: define i32 @_Z3g10P3e10 +// CHECK: load i32* %x, align 4, !range !6 + +enum e11 {e11_a = 4294967296 }; +enum e11 g11(enum e11 *x) { + return *x; +} +// CHECK: define i64 @_Z3g11P3e11 +// CHECK: load i64* %x, align {{[84]}}, !range !7 + +enum e12 {e12_a = 9223372036854775808U }; +enum e12 g12(enum e12 *x) { + return *x; +} +// CHECK: define i64 @_Z3g12P3e12 +// CHECK: load i64* %x, align {{[84]}} +// CHECK-NOT: range +// CHECK: ret + +enum e13 : char {e13_a = -1 }; +e13 g13(e13 *x) { + return *x; +} +// CHECK: define signext i8 @_Z3g13P3e13 +// CHECK: load i8* %x, align 1 +// CHECK-NOT: range +// CHECK: ret + +enum class e14 {e14_a = 1}; +e14 g14(e14 *x) { + return *x; +} +// CHECK: define i32 @_Z3g14P3e14 +// CHECK: load i32* %x, align 4 +// CHECK-NOT: range +// CHECK: ret + +enum e15 { e15_a = 2147483648 }; +e15 g15(e15 *x) { + return *x; +} +// CHECK: define i32 @_Z3g15P3e15 +// CHECK: load i32* %x, align 4 +// CHECK-NOT: range +// CHECK: ret + +enum e16 { e16_a = -2147483648 }; +e16 g16(e16 *x) { + return *x; +} +// CHECK: define i32 @_Z3g16P3e16 +// CHECK: load i32* %x, align 4 +// CHECK-NOT: range +// CHECK: ret + + +// CHECK: !0 = metadata !{i8 0, i8 2} +// CHECK: !1 = metadata !{i32 0, i32 1} +// CHECK: !2 = metadata !{i32 0, i32 32} +// CHECK: !3 = metadata !{i32 -16, i32 16} +// CHECK: !4 = metadata !{i32 -32, i32 32} +// CHECK: !5 = metadata !{i32 -1, i32 1} +// CHECK: !6 = metadata !{i32 -64, i32 64} +// CHECK: !7 = metadata !{i64 0, i64 8589934592} diff --git a/test/CodeGenCXX/pr9965.cpp b/test/CodeGenCXX/pr9965.cpp index 145fd4e424f46..0d267ff70372f 100644 --- a/test/CodeGenCXX/pr9965.cpp +++ b/test/CodeGenCXX/pr9965.cpp @@ -1,8 +1,10 @@ // RUN: %clang_cc1 -std=c++11 -emit-llvm -o - %s | FileCheck %s +struct A { A(); }; template<typename T> -struct X +struct X : A // default constructor is not trivial { X() = default; + ~X() {} // not a literal type }; X<int> x; diff --git a/test/CodeGenCXX/pragma-pack-2.cpp b/test/CodeGenCXX/pragma-pack-2.cpp new file mode 100644 index 0000000000000..9c09d5b4a3ee2 --- /dev/null +++ b/test/CodeGenCXX/pragma-pack-2.cpp @@ -0,0 +1,17 @@ +// RUN: %clang_cc1 -triple x86_64-apple-macosx10.7.2 %s -emit-llvm -o - | FileCheck %s +// <rdar://problem/10551376> + +struct FOO { + unsigned int x; +}; + +#pragma pack(push, 2) + +// CHECK: %struct.BAR = type <{ %struct.FOO, i8, i8 }> +struct BAR : FOO { + char y; +}; + +#pragma pack(pop) + +BAR* x = 0;
\ No newline at end of file diff --git a/test/CodeGenCXX/pragma-visibility.cpp b/test/CodeGenCXX/pragma-visibility.cpp index 2dc8bcc74fac4..e54626ee2e11a 100644 --- a/test/CodeGenCXX/pragma-visibility.cpp +++ b/test/CodeGenCXX/pragma-visibility.cpp @@ -55,20 +55,8 @@ namespace n __attribute((visibility("default"))) { #pragma GCC visibility pop namespace n __attribute((visibility("default"))) { - extern int foofoo; // FIXME: Shouldn't be necessary, but otherwise the pragma - // gets to Sema before the namespace! #pragma GCC visibility push(hidden) void g() {} // CHECK: define hidden void @_ZN1n1gEv #pragma GCC visibility pop } - -// We used to test this, but it's insane, so unless it happens in -// headers, we should not support it. -namespace n __attribute((visibility("hidden"))) { - extern int foofoo; // FIXME: Shouldn't be necessary, but otherwise the pragma - // gets to Sema before the namespace! - #pragma GCC visibility pop - void h() {} - // CHECK disabled: define void @_ZN1n1hEv -} diff --git a/test/CodeGenCXX/predefined-expr-sizeof.cpp b/test/CodeGenCXX/predefined-expr-sizeof.cpp index f74cfb38fd133..b4712ad15b4b6 100644 --- a/test/CodeGenCXX/predefined-expr-sizeof.cpp +++ b/test/CodeGenCXX/predefined-expr-sizeof.cpp @@ -1,7 +1,7 @@ // RUN: %clang_cc1 %s -emit-llvm -o - | FileCheck %s -// CHECK: store i32 49, i32* %size -// CHECK: store i32 52, i32* %size +// CHECK: store i32 59, i32* %size +// CHECK: store i32 65, i32* %size template<typename T> class TemplateClass { public: @@ -10,8 +10,8 @@ public: } }; -// CHECK: store i32 27, i32* %size -// CHECK: store i32 30, i32* %size +// CHECK: store i32 35, i32* %size +// CHECK: store i32 38, i32* %size template<typename T> void functionTemplate(T t) { int size = sizeof(__PRETTY_FUNCTION__); diff --git a/test/CodeGenCXX/predefined-expr.cpp b/test/CodeGenCXX/predefined-expr.cpp index 56270b5f6953b..1795ec8b46a48 100644 --- a/test/CodeGenCXX/predefined-expr.cpp +++ b/test/CodeGenCXX/predefined-expr.cpp @@ -1,15 +1,29 @@ -// RUN: %clang_cc1 %s -emit-llvm -o - | FileCheck %s +// RUN: %clang_cc1 -std=c++11 %s -emit-llvm -o - | FileCheck %s // CHECK: private unnamed_addr constant [15 x i8] c"externFunction\00" // CHECK: private unnamed_addr constant [26 x i8] c"void NS::externFunction()\00" +// CHECK: private unnamed_addr constant [49 x i8] c"void functionTemplateExplicitSpecialization(int)\00" + +// CHECK: private unnamed_addr constant [95 x i8] c"void SpecializedClassTemplate<char>::memberFunctionTemplate(T, U) const [T = char, U = double]\00" +// CHECK: private unnamed_addr constant [85 x i8] c"void SpecializedClassTemplate<int>::memberFunctionTemplate(int, U) const [U = float]\00" +// CHECK: private unnamed_addr constant [57 x i8] c"void NonTypeTemplateParam<42>::size() const [Count = 42]\00" +// CHECK: private unnamed_addr constant [122 x i8] c"static void ClassWithTemplateTemplateParam<char, NS::ClassTemplate>::staticMember() [T = char, Param = NS::ClassTemplate]\00" +// CHECK: private unnamed_addr constant [106 x i8] c"void OuterClass<int *>::MiddleClass::InnerClass<float>::memberFunction(T, U) const [T = int *, U = float]\00" +// CHECK: private unnamed_addr constant [65 x i8] c"void functionTemplateWithUnnamedTemplateParameter(T) [T = float]\00" + +// CHECK: private unnamed_addr constant [60 x i8] c"void functionTemplateExplicitSpecialization(T) [T = double]\00" +// CHECK: private unnamed_addr constant [52 x i8] c"T *functionTemplateWithCompoundTypes(T *) [T = int]\00" +// CHECK: private unnamed_addr constant [54 x i8] c"T functionTemplateWithTemplateReturnType() [T = char]\00" +// CHECK: private unnamed_addr constant [57 x i8] c"void functionTemplateWithoutParameterList() [T = double]\00" +// CHECK: private unnamed_addr constant [62 x i8] c"void functionTemplateWithTwoParams(T, U) [T = int, U = float]\00" // CHECK: private unnamed_addr constant [22 x i8] c"classTemplateFunction\00" -// CHECK: private unnamed_addr constant [60 x i8] c"void NS::ClassTemplate<NS::Base *>::classTemplateFunction()\00" -// CHECK: private unnamed_addr constant [53 x i8] c"void NS::ClassTemplate<int>::classTemplateFunction()\00" +// CHECK: private unnamed_addr constant [77 x i8] c"void NS::ClassTemplate<NS::Base *>::classTemplateFunction() [T = NS::Base *]\00" +// CHECK: private unnamed_addr constant [63 x i8] c"void NS::ClassTemplate<int>::classTemplateFunction() [T = int]\00" // CHECK: private unnamed_addr constant [18 x i8] c"functionTemplate1\00" -// CHECK: private unnamed_addr constant [45 x i8] c"void NS::Base::functionTemplate1(NS::Base *)\00" -// CHECK: private unnamed_addr constant [38 x i8] c"void NS::Base::functionTemplate1(int)\00" +// CHECK: private unnamed_addr constant [53 x i8] c"void NS::Base::functionTemplate1(T) [T = NS::Base *]\00" +// CHECK: private unnamed_addr constant [46 x i8] c"void NS::Base::functionTemplate1(T) [T = int]\00" // CHECK: private unnamed_addr constant [23 x i8] c"anonymousUnionFunction\00" // CHECK: private unnamed_addr constant [83 x i8] c"void NS::ContainerForAnonymousRecords::<anonymous union>::anonymousUnionFunction()\00" @@ -31,6 +45,10 @@ // CHECK: private unnamed_addr constant [16 x i8] c"virtualFunction\00" // CHECK: private unnamed_addr constant [44 x i8] c"virtual void NS::Derived::virtualFunction()\00" +// CHECK: private unnamed_addr constant [21 x i8] c"refQualifiedFunction\00" +// CHECK: private unnamed_addr constant [41 x i8] c"void NS::Base::refQualifiedFunction() &&\00" +// CHECK: private unnamed_addr constant [40 x i8] c"void NS::Base::refQualifiedFunction() &\00" + // CHECK: private unnamed_addr constant [22 x i8] c"constVolatileFunction\00" // CHECK: private unnamed_addr constant [54 x i8] c"void NS::Base::constVolatileFunction() const volatile\00" @@ -78,6 +96,8 @@ // CHECK: private unnamed_addr constant [19 x i8] c"localClassFunction\00" // CHECK: private unnamed_addr constant [59 x i8] c"void NS::localClass(int)::LocalClass::localClassFunction()\00" + + int printf(const char * _Format, ...); class ClassInTopLevelNamespace { @@ -203,11 +223,23 @@ public: printf("__FUNCTION__ %s\n", __FUNCTION__); printf("__PRETTY_FUNCTION__ %s\n\n", __PRETTY_FUNCTION__); } + + void refQualifiedFunction() & { + printf("__func__ %s\n", __func__); + printf("__FUNCTION__ %s\n", __FUNCTION__); + printf("__PRETTY_FUNCTION__ %s\n\n", __PRETTY_FUNCTION__); + } + + void refQualifiedFunction() && { + printf("__func__ %s\n", __func__); + printf("__FUNCTION__ %s\n", __FUNCTION__); + printf("__PRETTY_FUNCTION__ %s\n\n", __PRETTY_FUNCTION__); + } }; class Derived : public Base { public: - // Virtual function without being explicitally written. + // Virtual function without being explicitly written. void virtualFunction() { printf("__func__ %s\n", __func__); printf("__FUNCTION__ %s\n", __FUNCTION__); @@ -294,6 +326,116 @@ extern void externFunction() { } // end NS namespace +// additional tests for __PRETTY_FUNCTION__ +template <typename T, typename U> +void functionTemplateWithTwoParams(T, U) +{ + printf("__PRETTY_FUNCTION__ %s\n\n", __PRETTY_FUNCTION__); +} + +template <typename T> +void functionTemplateWithoutParameterList() +{ + T t = T(); + + printf("__PRETTY_FUNCTION__ %s\n\n", __PRETTY_FUNCTION__); +} + +template <typename T> +T functionTemplateWithTemplateReturnType() +{ + printf("__PRETTY_FUNCTION__ %s\n\n", __PRETTY_FUNCTION__); + + return T(); +} + +template <typename T> +T * functionTemplateWithCompoundTypes(T a[]) +{ + printf("__PRETTY_FUNCTION__ %s\n\n", __PRETTY_FUNCTION__); + + return 0; +} + +template <typename T> +void functionTemplateExplicitSpecialization(T t) +{ + printf("__PRETTY_FUNCTION__ %s\n\n", __PRETTY_FUNCTION__); +} + +template <> +void functionTemplateExplicitSpecialization<int>(int i) +{ + printf("__PRETTY_FUNCTION__ %s\n\n", __PRETTY_FUNCTION__); +} + +template <typename, typename T> +void functionTemplateWithUnnamedTemplateParameter(T t) +{ + printf("__PRETTY_FUNCTION__ %s\n\n", __PRETTY_FUNCTION__); +} + +template <typename T> +class OuterClass +{ +public: + class MiddleClass + { + public: + template <typename U> + class InnerClass + { + public: + void memberFunction(T x, U y) const + { + printf("__PRETTY_FUNCTION__ %s\n\n", __PRETTY_FUNCTION__); + } + }; + }; +}; + +template <typename T, template <typename> class Param = NS::ClassTemplate> +class ClassWithTemplateTemplateParam +{ +public: + static void staticMember() + { + printf("__PRETTY_FUNCTION__ %s\n\n", __PRETTY_FUNCTION__); + } +}; + +template <int Count> +class NonTypeTemplateParam +{ +public: + void size() const + { + printf("__PRETTY_FUNCTION__ %s\n\n", __PRETTY_FUNCTION__); + } +}; + +template <typename T> +class SpecializedClassTemplate +{ +public: + template <typename U> + void memberFunctionTemplate(T t, U u) const + { + printf("__PRETTY_FUNCTION__ %s\n\n", __PRETTY_FUNCTION__); + } +}; + +template <> +class SpecializedClassTemplate<int> +{ +public: + template <typename U> + void memberFunctionTemplate(int i, U u) const + { + printf("__PRETTY_FUNCTION__ %s\n\n", __PRETTY_FUNCTION__); + } +}; + int main() { ClassInAnonymousNamespace anonymousNamespace; anonymousNamespace.anonymousNamespaceFunction(); @@ -319,6 +461,8 @@ int main() { b.constFunction(); b.volatileFunction(); b.constVolatileFunction(); + b.refQualifiedFunction(); + NS::Base().refQualifiedFunction(); NS::Derived d; d.virtualFunction(); @@ -345,5 +489,29 @@ int main() { NS::externFunction(); + // additional tests for __PRETTY_FUNCTION__ + + functionTemplateWithTwoParams(0, 0.0f); + functionTemplateWithoutParameterList<double>(); + functionTemplateWithTemplateReturnType<char>(); + int array[] = { 1, 2, 3 }; + functionTemplateWithCompoundTypes(array); + functionTemplateExplicitSpecialization(0); + functionTemplateExplicitSpecialization(0.0); + functionTemplateWithUnnamedTemplateParameter<int, float>(0.0f); + + OuterClass<int *>::MiddleClass::InnerClass<float> omi; + omi.memberFunction(0, 0.0f); + + ClassWithTemplateTemplateParam<char>::staticMember(); + + NonTypeTemplateParam<42> ntt; + ntt.size(); + + SpecializedClassTemplate<int> sct1; + sct1.memberFunctionTemplate(0, 0.0f); + SpecializedClassTemplate<char> sct2; + sct2.memberFunctionTemplate('0', 0.0); + return 0; } diff --git a/test/CodeGenCXX/references.cpp b/test/CodeGenCXX/references.cpp index 4bbc251ab5d05..d315f712213c8 100644 --- a/test/CodeGenCXX/references.cpp +++ b/test/CodeGenCXX/references.cpp @@ -1,10 +1,16 @@ // RUN: %clang_cc1 -triple x86_64-apple-darwin -verify -emit-llvm -o - %s | FileCheck %s void t1() { + // CHECK: define void @_Z2t1v + // CHECK: [[REFLOAD:%.*]] = load i32** @a, align 8 + // CHECK: load i32* [[REFLOAD]], align 4 extern int& a; int b = a; } void t2(int& a) { + // CHECK: define void @_Z2t2Ri + // CHECK: [[REFLOAD2:%.*]] = load i32** {{.*}}, align 8 + // CHECK: load i32* [[REFLOAD2]], align 4 int b = a; } @@ -297,3 +303,11 @@ namespace PR9565 { // CHECK-NEXT: ret void } } + +namespace N6 { + extern struct x {char& x;}y; + int a() { return y.x; } + // CHECK: define i32 @_ZN2N61aEv + // CHECK: [[REFLOAD3:%.*]] = load i8** getelementptr inbounds (%"struct.N6::x"* @_ZN2N61yE, i32 0, i32 0), align 8 + // CHECK: load i8* [[REFLOAD3]], align 1 +} diff --git a/test/CodeGenCXX/regparm.cpp b/test/CodeGenCXX/regparm.cpp new file mode 100644 index 0000000000000..f0ebd2be41675 --- /dev/null +++ b/test/CodeGenCXX/regparm.cpp @@ -0,0 +1,6 @@ +// RUN: %clang_cc1 -triple i386-unknown-unknown %s -emit-llvm -o - | FileCheck %s + + +// CHECK: _Z3fooRi(i32* inreg +void __attribute__ ((regparm (1))) foo(int &a) { +} diff --git a/test/CodeGenCXX/static-data-member.cpp b/test/CodeGenCXX/static-data-member.cpp index b19067af61df2..4ad339db985be 100644 --- a/test/CodeGenCXX/static-data-member.cpp +++ b/test/CodeGenCXX/static-data-member.cpp @@ -5,6 +5,12 @@ // CHECK: @_ZN5test31AIiE1xE = weak_odr global i32 0, align 4 // CHECK: @_ZGVN5test31AIiE1xE = weak_odr global i64 0 +// CHECK: _ZN5test51U2k0E = global i32 0 +// CHECK: _ZN5test51U2k1E = global i32 0 +// CHECK: _ZN5test51U2k2E = constant i32 76 +// CHECK-NOT: test51U2k3E +// CHECK-NOT: test51U2k4E + // PR5564. namespace test1 { struct A { @@ -64,3 +70,35 @@ namespace test3 { // CHECK-NEXT: br label // CHECK: ret void } + +// Test that we can fold member lookup expressions which resolve to static data +// members. +namespace test4 { + struct A { + static const int n = 76; + }; + + int f(A *a) { + // CHECK: define i32 @_ZN5test41fEPNS_1AE + // CHECK: ret i32 76 + return a->n; + } +} + +// Test that static data members in unions behave properly. +namespace test5 { + union U { + static int k0; + static const int k1; + static const int k2 = 76; + static const int k3; + static const int k4 = 81; + }; + int U::k0; + const int U::k1 = (k0 = 9, 42); + const int U::k2; + + // CHECK: store i32 9, i32* @_ZN5test51U2k0E + // CHECK: store i32 {{.*}}, i32* @_ZN5test51U2k1E + // CHECK-NOT: store {{.*}} i32* @_ZN5test51U2k2E +} diff --git a/test/CodeGenCXX/static-init.cpp b/test/CodeGenCXX/static-init.cpp index 9e2673cc967dd..ed659de5e0624 100644 --- a/test/CodeGenCXX/static-init.cpp +++ b/test/CodeGenCXX/static-init.cpp @@ -1,7 +1,9 @@ // RUN: %clang_cc1 %s -triple=x86_64-apple-darwin10 -emit-llvm -o - | FileCheck %s // CHECK: @_ZZ1hvE1i = internal global i32 0, align 4 +// CHECK: @base_req = global [4 x i8] c"foo\00", align 1 +// CHECK: @_ZZN5test31BC1EvE1u = internal global { i8, [3 x i8] } { i8 97, [3 x i8] undef }, align 4 // CHECK: @_ZZN5test1L6getvarEiE3var = internal constant [4 x i32] [i32 1, i32 0, i32 2, i32 4], align 16 // CHECK: @_ZZ2h2vE1i = linkonce_odr global i32 0 // CHECK: @_ZGVZ2h2vE1i = linkonce_odr global i64 0 @@ -15,7 +17,7 @@ void f() { // CHECK: load atomic i8* bitcast (i64* @_ZGVZ1fvE1a to i8*) acquire, align 1 // CHECK: call i32 @__cxa_guard_acquire // CHECK: call void @_ZN1AC1Ev - // CHECK: call i32 @__cxa_atexit(void (i8*)* bitcast (void (%struct.A*)* @_ZN1AD1Ev to void (i8*)*), i8* getelementptr inbounds (%struct.A* @_ZZ1fvE1a, i32 0, i32 0), i8* bitcast (i8** @__dso_handle to i8*)) + // CHECK: call i32 @__cxa_atexit(void (i8*)* bitcast (void (%struct.A*)* @_ZN1AD1Ev to void (i8*)*), i8* getelementptr inbounds (%struct.A* @_ZZ1fvE1a, i32 0, i32 0), i8* @__dso_handle) // CHECK: call void @__cxa_guard_release static A a; } @@ -59,3 +61,92 @@ namespace test1 { void test() { (void) getvar(2); } } + +// Make sure we emit the initializer correctly for the following: +char base_req[] = { "foo" }; + +namespace union_static_local { + // CHECK: define internal void @_ZZN18union_static_local4testEvEN1c4mainEv + // CHECK: call void @_ZN18union_static_local1fEPNS_1xE(%"union.union_static_local::x"* bitcast ({ [2 x i8*] }* @_ZZN18union_static_local4testEvE3foo to %"union.union_static_local::x"*)) + union x { long double y; const char *x[2]; }; + void f(union x*); + void test() { + static union x foo = { .x = { "a", "b" } }; + struct c { + static void main() { + f(&foo); + } + }; + c::main(); + } +} + +// rdar://problem/11091093 +// Static variables should be consistent across constructor +// or destructor variants. +namespace test2 { + struct A { + A(); + ~A(); + }; + + struct B : virtual A { + B(); + ~B(); + }; + + // If we ever implement this as a delegate ctor call, just change + // this to take variadic arguments or something. + extern int foo(); + B::B() { + static int x = foo(); + } + // CHECK: define void @_ZN5test21BC1Ev + // CHECK: load atomic i8* bitcast (i64* @_ZGVZN5test21BC1EvE1x to i8*) acquire, + // CHECK: call i32 @__cxa_guard_acquire(i64* @_ZGVZN5test21BC1EvE1x) + // CHECK: [[T0:%.*]] = call i32 @_ZN5test23fooEv() + // CHECK: store i32 [[T0]], i32* @_ZZN5test21BC1EvE1x, + // CHECK: call void @__cxa_guard_release(i64* @_ZGVZN5test21BC1EvE1x) + + // CHECK: define void @_ZN5test21BC2Ev + // CHECK: load atomic i8* bitcast (i64* @_ZGVZN5test21BC1EvE1x to i8*) acquire, + // CHECK: call i32 @__cxa_guard_acquire(i64* @_ZGVZN5test21BC1EvE1x) + // CHECK: [[T0:%.*]] = call i32 @_ZN5test23fooEv() + // CHECK: store i32 [[T0]], i32* @_ZZN5test21BC1EvE1x, + // CHECK: call void @__cxa_guard_release(i64* @_ZGVZN5test21BC1EvE1x) + + // This is just for completeness, because we actually emit this + // using a delegate dtor call. + B::~B() { + static int y = foo(); + } + // CHECK: define void @_ZN5test21BD1Ev( + // CHECK: call void @_ZN5test21BD2Ev( + + // CHECK: define void @_ZN5test21BD2Ev( + // CHECK: load atomic i8* bitcast (i64* @_ZGVZN5test21BD1EvE1y to i8*) acquire, + // CHECK: call i32 @__cxa_guard_acquire(i64* @_ZGVZN5test21BD1EvE1y) + // CHECK: [[T0:%.*]] = call i32 @_ZN5test23fooEv() + // CHECK: store i32 [[T0]], i32* @_ZZN5test21BD1EvE1y, + // CHECK: call void @__cxa_guard_release(i64* @_ZGVZN5test21BD1EvE1y) +} + +// This shouldn't error out. +namespace test3 { + struct A { + A(); + ~A(); + }; + + struct B : virtual A { + B(); + ~B(); + }; + + B::B() { + union U { char x; int i; }; + static U u = { 'a' }; + } + // CHECK: define void @_ZN5test31BC1Ev( + // CHECK: define void @_ZN5test31BC2Ev( +} diff --git a/test/CodeGenCXX/static-mutable.cpp b/test/CodeGenCXX/static-mutable.cpp new file mode 100644 index 0000000000000..6d51f241d163a --- /dev/null +++ b/test/CodeGenCXX/static-mutable.cpp @@ -0,0 +1,12 @@ +// RUN: %clang_cc1 %s -triple=i686-linux-gnu -emit-llvm -o - | FileCheck %s + +struct S { + mutable int n; +}; +int f() { + // The purpose of this test is to ensure that this variable is a global + // not a constant. + // CHECK: @_ZZ1fvE1s = internal global {{.*}} { i32 12 } + static const S s = { 12 }; + return ++s.n; +} diff --git a/test/CodeGenCXX/switch-case-folding-1.cpp b/test/CodeGenCXX/switch-case-folding-1.cpp new file mode 100644 index 0000000000000..1daeecfd10a92 --- /dev/null +++ b/test/CodeGenCXX/switch-case-folding-1.cpp @@ -0,0 +1,22 @@ +// RUN: %clang_cc1 %s -emit-llvm-only +// CHECK that we don't crash. + +int test(int val){ + int x = 12; + // Make sure we don't crash when constant folding the case 4 + // statement due to the case 5 statement contained in the do loop + switch (val) { + case 4: do { + switch (6) { + case 6: { + case 5: x++; + }; + }; + } while (x < 100); + } + return x; +} + +int main(void) { + return test(4); +} diff --git a/test/CodeGenCXX/switch-case-folding-2.cpp b/test/CodeGenCXX/switch-case-folding-2.cpp new file mode 100644 index 0000000000000..7c0283fa2a529 --- /dev/null +++ b/test/CodeGenCXX/switch-case-folding-2.cpp @@ -0,0 +1,21 @@ +// RUN: %clang_cc1 -emit-llvm %s -o - | FileCheck %s +// CHECK that we don't crash. + +extern int printf(const char*, ...); +int test(int val){ + switch (val) { + case 4: + do { + switch (6) { + case 6: do { case 5: printf("bad\n"); } while (0); + }; + } while (0); + } + return 0; +} + +int main(void) { + return test(5); +} + +// CHECK: call i32 (i8*, ...)* @_Z6printfPKcz diff --git a/test/CodeGenCXX/switch-case-folding.cpp b/test/CodeGenCXX/switch-case-folding.cpp new file mode 100644 index 0000000000000..d4444b12ff58d --- /dev/null +++ b/test/CodeGenCXX/switch-case-folding.cpp @@ -0,0 +1,18 @@ +// RUN: %clang_cc1 %s -emit-llvm-only +// CHECK that we don't crash. + +int main(void){ + int x = 12; + // Make sure we don't crash when constant folding the case 4 + // statement due to the case 5 statement contained in the do loop + switch (4) { + case 4: do { + switch (6) { + case 6: { + case 5: x++; + }; + }; + } while (x < 100); + } + return x; +} diff --git a/test/CodeGenCXX/temporaries.cpp b/test/CodeGenCXX/temporaries.cpp index 98e5ae3e6ee7d..e90c94796faae 100644 --- a/test/CodeGenCXX/temporaries.cpp +++ b/test/CodeGenCXX/temporaries.cpp @@ -519,3 +519,21 @@ namespace PR8623 { b ? A(2) : A(3); } } + +namespace PR11365 { + struct A { A(); ~A(); }; + + // CHECK: define void @_ZN7PR113653fooEv( + void foo() { + // CHECK: [[BEGIN:%.*]] = getelementptr inbounds [3 x [[A:%.*]]]* {{.*}}, i32 0, i32 0 + // CHECK-NEXT: [[END:%.*]] = getelementptr inbounds [[A]]* [[BEGIN]], i64 3 + // CHECK-NEXT: br label + + // CHECK: [[PHI:%.*]] = phi + // CHECK-NEXT: [[ELEM:%.*]] = getelementptr inbounds [[A]]* [[PHI]], i64 -1 + // CHECK-NEXT: call void @_ZN7PR113651AD1Ev([[A]]* [[ELEM]]) + // CHECK-NEXT: icmp eq [[A]]* [[ELEM]], [[BEGIN]] + // CHECK-NEXT: br i1 + (void) (A [3]) {}; + } +} diff --git a/test/CodeGenCXX/thiscall-struct-return.cpp b/test/CodeGenCXX/thiscall-struct-return.cpp new file mode 100644 index 0000000000000..ff531255bba93 --- /dev/null +++ b/test/CodeGenCXX/thiscall-struct-return.cpp @@ -0,0 +1,41 @@ +// For MSVC ABI compatibility, all structures returned by value using the +// thiscall calling convention must use the hidden parameter. +// +// RUN: %clang_cc1 -triple i386-PC-Win32 %s -fms-compatibility -O0 -emit-llvm -o - | FileCheck %s + +// This structure would normally be returned via EAX +struct S { + int i; +}; + +// This structure would normally be returned via EAX/EDX +struct M { + int i; + int j; +}; + +class C { +public: + C() {} + + struct S __attribute__((thiscall)) Small() const { + struct S s = { 0 }; + return s; + } + + struct M __attribute__((thiscall)) Medium() const { + struct M m = { 0 }; + return m; + } +}; + +// CHECK: define void @_Z4testv() +void test( void ) { +// CHECK: call void @_ZN1CC1Ev(%class.C* [[C:%.+]]) + C c; + +// CHECK: call x86_thiscallcc void @_ZNK1C5SmallEv(%struct.S* sret %{{.+}}, %class.C* [[C]]) + (void)c.Small(); +// CHECK: call x86_thiscallcc void @_ZNK1C6MediumEv(%struct.M* sret %{{.+}}, %class.C* [[C]]) + (void)c.Medium(); +} diff --git a/test/CodeGenCXX/throw-expressions.cpp b/test/CodeGenCXX/throw-expressions.cpp index 0fd32c44575bf..2515acb48ee72 100644 --- a/test/CodeGenCXX/throw-expressions.cpp +++ b/test/CodeGenCXX/throw-expressions.cpp @@ -13,3 +13,8 @@ int test2() { void test3() { throw false; } + +// PR10582 +int test4() { + return 1 ? throw val : val; +} diff --git a/test/CodeGenCXX/thunk-use-after-free.cpp b/test/CodeGenCXX/thunk-use-after-free.cpp new file mode 100644 index 0000000000000..d70e9025683d7 --- /dev/null +++ b/test/CodeGenCXX/thunk-use-after-free.cpp @@ -0,0 +1,42 @@ +// RUN: %clang_cc1 -emit-llvm-only -O1 %s +// This used to crash under asan and valgrind. +// PR12284 + +template < typename _Tp > struct new_allocator +{ + typedef _Tp *pointer; + template < typename > struct rebind { + typedef new_allocator other; + }; +}; +template < typename _Tp > struct allocator:new_allocator < _Tp > { +}; +template < typename _Tp, typename _Alloc > struct _Vector_base { + typedef typename _Alloc::template rebind < _Tp >::other _Tp_alloc_type; + struct _Vector_impl { + typename _Tp_alloc_type::pointer _M_end_of_storage; + }; + _Vector_base () { + foo((int *) this->_M_impl._M_end_of_storage); + } + void foo(int *); + _Vector_impl _M_impl; +}; +template < typename _Tp, typename _Alloc = +allocator < _Tp > >struct vector:_Vector_base < _Tp, _Alloc > { }; + + +template < class T> struct HHH {}; +struct DDD { int x_;}; +struct Data; +struct X1; +struct CCC:DDD { virtual void xxx (HHH < X1 >); }; +template < class SSS > struct EEE:vector < HHH < SSS > > { }; +template < class SSS, class = EEE < SSS > >class FFF { }; +template < class SSS, class GGG = EEE < SSS > >class AAA:FFF <GGG> { }; +class BBB:virtual CCC { + void xxx (HHH < X1 >); + vector < HHH < X1 > >aaa; +}; +class ZZZ:AAA < Data >, BBB { virtual ZZZ *ppp () ; }; +ZZZ * ZZZ::ppp () { return new ZZZ; } diff --git a/test/CodeGenCXX/thunks.cpp b/test/CodeGenCXX/thunks.cpp index 7c80b96b79490..04d0820da7a31 100644 --- a/test/CodeGenCXX/thunks.cpp +++ b/test/CodeGenCXX/thunks.cpp @@ -1,5 +1,5 @@ -// RUN: %clang_cc1 %s -triple=x86_64-apple-darwin10 -emit-llvm -o - | FileCheck %s -// RUN: %clang_cc1 %s -triple=x86_64-apple-darwin10 -fhidden-weak-vtables -emit-llvm -o - | FileCheck -check-prefix=HIDDEN %s +// RUN: %clang_cc1 %s -triple=x86_64-pc-linux-gnu -emit-llvm -o - | FileCheck %s +// RUN: %clang_cc1 %s -triple=x86_64-pc-linux-gnu -fhidden-weak-vtables -emit-llvm -o - | FileCheck -check-prefix=HIDDEN %s namespace Test1 { diff --git a/test/CodeGenCXX/typeid-cxx11.cpp b/test/CodeGenCXX/typeid-cxx11.cpp new file mode 100644 index 0000000000000..940274e96575b --- /dev/null +++ b/test/CodeGenCXX/typeid-cxx11.cpp @@ -0,0 +1,30 @@ +// RUN: %clang_cc1 -I%S %s -triple x86_64-apple-darwin10 -emit-llvm -std=c++11 -o - | FileCheck %s +#include <typeinfo> + +namespace Test1 { + +struct Item { + const std::type_info &ti; + const char *name; + void *(*make)(); +}; + +template<typename T> void *make_impl() { return new T; } +template<typename T> constexpr Item item(const char *name) { + return { typeid(T), name, make_impl<T> }; +} + +struct A { virtual ~A(); }; +struct B : virtual A {}; +struct C { int n; }; + +// FIXME: check we produce a constant array for this, once we support IRGen of +// folded structs and arrays. +constexpr Item items[] = { + item<A>("A"), item<B>("B"), item<C>("C"), item<int>("int") +}; + +// CHECK: @_ZN5Test11xE = constant %"class.std::type_info"* bitcast (i8** @_ZTIN5Test11AE to %"class.std::type_info"*), align 8 +constexpr auto &x = items[0].ti; + +} diff --git a/test/CodeGenCXX/typeid.cpp b/test/CodeGenCXX/typeid.cpp index 7ebf41c09f6c2..fce3795344b42 100644 --- a/test/CodeGenCXX/typeid.cpp +++ b/test/CodeGenCXX/typeid.cpp @@ -6,6 +6,27 @@ namespace Test1 { // PR7400 struct A { virtual void f(); }; +// CHECK: @_ZN5Test16int_tiE = constant %"class.std::type_info"* bitcast (i8** @_ZTIi to %"class.std::type_info"*), align 8 +const std::type_info &int_ti = typeid(int); + +// CHECK: @_ZN5Test14A_tiE = constant %"class.std::type_info"* bitcast (i8** @_ZTIN5Test11AE to %"class.std::type_info"*), align 8 +const std::type_info &A_ti = typeid(const volatile A &); + +volatile char c; + +// CHECK: @_ZN5Test14c_tiE = constant %"class.std::type_info"* bitcast (i8** @_ZTIc to %"class.std::type_info"*), align 8 +const std::type_info &c_ti = typeid(c); + +extern const double &d; + +// CHECK: @_ZN5Test14d_tiE = constant %"class.std::type_info"* bitcast (i8** @_ZTId to %"class.std::type_info"*), align 8 +const std::type_info &d_ti = typeid(d); + +extern A &a; + +// CHECK: @_ZN5Test14a_tiE = global +const std::type_info &a_ti = typeid(a); + // CHECK: define i8* @_ZN5Test11fEv const char *f() { try { diff --git a/test/CodeGenCXX/uncode-string.cpp b/test/CodeGenCXX/uncode-string.cpp index e5431497479e0..1d839992f9c0e 100644 --- a/test/CodeGenCXX/uncode-string.cpp +++ b/test/CodeGenCXX/uncode-string.cpp @@ -3,4 +3,4 @@ wchar_t s[] = L"\u2722"; -// CHECK: @s = global [8 x i8] c"\22'\00\00\00\00\00\00" +// CHECK: @s = global [2 x i32] [i32 10018, i32 0], align 4 diff --git a/test/CodeGenCXX/value-init.cpp b/test/CodeGenCXX/value-init.cpp index fb981d1ff717e..6e60f8011059c 100644 --- a/test/CodeGenCXX/value-init.cpp +++ b/test/CodeGenCXX/value-init.cpp @@ -134,8 +134,7 @@ namespace zeroinit { // CHECK: define i32 @_ZN8zeroinit4testEv() int test() { // CHECK: call void @llvm.memset.p0i8.i64 - // CHECK: getelementptr - // CHECK: ret i32 + // CHECK: ret i32 0 return S().i; } diff --git a/test/CodeGenCXX/virtual-implicit-move-assignment.cpp b/test/CodeGenCXX/virtual-implicit-move-assignment.cpp new file mode 100644 index 0000000000000..d8ac1ed4c4890 --- /dev/null +++ b/test/CodeGenCXX/virtual-implicit-move-assignment.cpp @@ -0,0 +1,12 @@ +// RUN: %clang_cc1 -emit-llvm -std=c++11 -o - %s | FileCheck %s + +struct D; +struct B { + virtual D &operator=(D&&) = 0; +}; +struct D : B { D(); virtual void a(); }; +void D::a() {} +D d; + +// CHECK: @_ZTV1D = {{.*}} @_ZN1DaSEOS_ +// CHECK: define linkonce_odr {{.*}} @_ZN1DaSEOS_ diff --git a/test/CodeGenCXX/visibility-inlines-hidden.cpp b/test/CodeGenCXX/visibility-inlines-hidden.cpp index f7fabed8c10a7..d660b1b410518 100644 --- a/test/CodeGenCXX/visibility-inlines-hidden.cpp +++ b/test/CodeGenCXX/visibility-inlines-hidden.cpp @@ -97,3 +97,14 @@ namespace test2 { // CHECK: define available_externally void @_ZN5test22ns3fooINS_1BINS_1AEEEEEvv() } + +namespace PR11642 { + template <typename T> + class Foo { + public: + T foo(T x) { return x; } + }; + extern template class Foo<int>; + template class Foo<int>; + // CHECK: define weak_odr i32 @_ZN7PR116423FooIiE3fooEi +} diff --git a/test/CodeGenCXX/visibility.cpp b/test/CodeGenCXX/visibility.cpp index 0f36a6a753248..59fd7c26f0d5c 100644 --- a/test/CodeGenCXX/visibility.cpp +++ b/test/CodeGenCXX/visibility.cpp @@ -5,6 +5,29 @@ #define PROTECTED __attribute__((visibility("protected"))) #define DEFAULT __attribute__((visibility("default"))) +namespace test25 { + template<typename T> + struct X { + template<typename U> + struct definition { + }; + }; + + class DEFAULT A { }; + + X<int>::definition<A> a; + // CHECK: @_ZN6test251aE = global + // CHECK-HIDDEN: @_ZN6test251aE = hidden global +} + +namespace test28 { + class DEFAULT foo { + }; + foo myvec; + // CHECK: @_ZN6test285myvecE = global + // CHECK-HIDDEN: @_ZN6test285myvecE = hidden global +} + // CHECK: @_ZN5Test425VariableInHiddenNamespaceE = hidden global i32 10 // CHECK: @_ZN5Test71aE = hidden global // CHECK: @_ZN5Test71bE = global @@ -22,6 +45,26 @@ // CHECK-HIDDEN: @_ZN6Test143varE = external global // CHECK: @_ZN6Test154TempINS_1AEE5Inner6bufferE = external global [0 x i8] // CHECK-HIDDEN: @_ZN6Test154TempINS_1AEE5Inner6bufferE = external global [0 x i8] + +namespace test27 { + template<typename T> + class C { + class __attribute__((visibility("default"))) D { + void f(); + }; + }; + + template<> + class C<int>::D { + virtual void g(); + }; + + void C<int>::D::g() { + } + // CHECK: _ZTVN6test271CIiE1DE = unnamed_addr constant + // CHECK-HIDDEN: _ZTVN6test271CIiE1DE = unnamed_addr constant +} + // CHECK: @_ZZN6Test193fooIiEEvvE1a = linkonce_odr global // CHECK: @_ZGVZN6Test193fooIiEEvvE1a = linkonce_odr global i64 // CHECK-HIDDEN: @_ZZN6Test193fooIiEEvvE1a = linkonce_odr hidden global @@ -156,7 +199,7 @@ namespace Test9 { namespace Test10 { struct A; - DEFAULT class B { + class DEFAULT B { void foo(A*); }; @@ -403,10 +446,7 @@ namespace Test20 { B<A<2> >::test4(); } - // CHECK: declare void @_ZN6Test201BINS_1AILj2EEEE5test5Ev() - // (but explicit visibility on a template argument doesn't count as - // explicit visibility for the template for purposes of deciding - // whether an external symbol gets visibility) + // CHECK: declare hidden void @_ZN6Test201BINS_1AILj2EEEE5test5Ev() void test5() { B<A<2> >::test5(); } @@ -454,3 +494,114 @@ namespace test22 { // CHECK-HIDDEN: declare void @_ZN6test221BINS_2A2EE3fooEv() // CHECK-HIDDEN: define linkonce_odr hidden void @_ZN6test221BINS_2A2EE3barEv() } + +namespace PR10113 { + namespace foo DEFAULT { + template<typename T> + class bar { + void zed() {} + }; + } + template class foo::bar<char>; + // CHECK: define weak_odr void @_ZN7PR101133foo3barIcE3zedEv + // CHECK-HIDDEN: define weak_odr void @_ZN7PR101133foo3barIcE3zedEv + + struct zed { + }; + template class foo::bar<zed>; + // CHECK: define weak_odr void @_ZN7PR101133foo3barINS_3zedEE3zedEv + // CHECK-HIDDEN: define weak_odr void @_ZN7PR101133foo3barINS_3zedEE3zedEv +} + +namespace PR11690 { + template<class T> struct Class { + void size() const { + } + }; + template class DEFAULT Class<char>; + // CHECK: define weak_odr void @_ZNK7PR116905ClassIcE4sizeEv + // CHECK-HIDDEN: define weak_odr void @_ZNK7PR116905ClassIcE4sizeEv + + template<class T> void Method() {} + template DEFAULT void Method<char>(); + // CHECK: define weak_odr void @_ZN7PR116906MethodIcEEvv + // CHECK-HIDDEN: define weak_odr void @_ZN7PR116906MethodIcEEvv +} + +namespace PR11690_2 { + namespace foo DEFAULT { + class bar; + template<typename T1, typename T2 = bar> + class zed { + void bar() { + } + }; + } + struct baz { + }; + template class foo::zed<baz>; + // CHECK: define weak_odr void @_ZN9PR11690_23foo3zedINS_3bazENS0_3barEE3barEv + // CHECK-HIDDEN: define weak_odr void @_ZN9PR11690_23foo3zedINS_3bazENS0_3barEE3barEv +} + +namespace test23 { + // Having a template argument that is explicitly visible should not make + // the template instantiation visible. + template <typename T> + struct X { + static void f() { + } + }; + + class DEFAULT A; + + void g() { + X<A> y; + y.f(); + } + // CHECK: define linkonce_odr void @_ZN6test231XINS_1AEE1fEv + // CHECK-HIDDEN: define linkonce_odr hidden void @_ZN6test231XINS_1AEE1fEv +} + +namespace PR12001 { + template <typename P1> + void Bind(const P1& p1) { + } + + class DEFAULT Version { }; + + void f() { + Bind(Version()); + } + // CHECK: define linkonce_odr void @_ZN7PR120014BindINS_7VersionEEEvRKT_ + // CHECK-HIDDEN: define linkonce_odr hidden void @_ZN7PR120014BindINS_7VersionEEEvRKT_ +} + +namespace test24 { + class DEFAULT A { }; + + struct S { + template <typename T> + void mem() {} + }; + + void test() { + S s; + s.mem<A>(); + } + // CHECK: define linkonce_odr void @_ZN6test241S3memINS_1AEEEvv + // CHECK-HIDDEN: define linkonce_odr hidden void @_ZN6test241S3memINS_1AEEEvv +} + +namespace test26 { + template<typename T> + class C { + __attribute__((visibility("default"))) void f(); + }; + + template<> + void C<int>::f() { } + + // CHECK: define void @_ZN6test261CIiE1fEv + // CHECK-HIDDEN: define void @_ZN6test261CIiE1fEv +} diff --git a/test/CodeGenCXX/vla.cpp b/test/CodeGenCXX/vla.cpp index 58cdf795ee5a6..b523c769d541f 100644 --- a/test/CodeGenCXX/vla.cpp +++ b/test/CodeGenCXX/vla.cpp @@ -1,5 +1,19 @@ // RUN: %clang_cc1 -triple x86_64-apple-darwin %s -emit-llvm -o - | FileCheck %s +template<typename T> +struct S { + static int n; +}; +template<typename T> int S<T>::n = 5; + +int f() { + // Make sure that the reference here is enough to trigger the instantiation of + // the static data member. + // CHECK: @_ZN1SIiE1nE = weak_odr global i32 5 + int a[S<int>::n]; + return sizeof a; +} + // rdar://problem/9506377 void test0(void *array, int n) { // CHECK: define void @_Z5test0Pvi( @@ -40,4 +54,3 @@ void test0(void *array, int n) { // CHECK-NEXT: ret void } - diff --git a/test/CodeGenCXX/vtable-layout.cpp b/test/CodeGenCXX/vtable-layout.cpp index bd696813c8141..d7644b98ae094 100644 --- a/test/CodeGenCXX/vtable-layout.cpp +++ b/test/CodeGenCXX/vtable-layout.cpp @@ -42,6 +42,7 @@ // RUN: FileCheck --check-prefix=CHECK-41 %s < %t // RUN: FileCheck --check-prefix=CHECK-42 %s < %t // RUN: FileCheck --check-prefix=CHECK-43 %s < %t +// RUN: FileCheck --check-prefix=CHECK-44 %s < %t // For now, just verify this doesn't crash. namespace test0 { @@ -1701,3 +1702,28 @@ struct C : B { C* C::f() { return 0; } } + +// rdar://problem/10959710 +namespace Test38 { + struct A { + virtual void *foo(); + virtual const void *foo() const; + }; + + // CHECK-44: Vtable for 'Test38::B' (7 entries). + // CHECK-44-NEXT: 0 | vbase_offset (0) + // CHECK-44-NEXT: 1 | vcall_offset (0) + // CHECK-44-NEXT: 2 | vcall_offset (0) + // CHECK-44-NEXT: 3 | offset_to_top (0) + // CHECK-44-NEXT: 4 | Test38::B RTTI + // CHECK-44-NEXT: -- (Test38::A, 0) vtable address -- + // CHECK-44-NEXT: -- (Test38::B, 0) vtable address -- + // CHECK-44-NEXT: 5 | void *Test38::B::foo() + // CHECK-44-NEXT: 6 | const void *Test38::B::foo() const + class B : virtual public A { + void *foo(); + const void *foo() const; + }; + + void *B::foo() { return 0; } +} diff --git a/test/CodeGenCXX/weak-extern-typeinfo.cpp b/test/CodeGenCXX/weak-extern-typeinfo.cpp new file mode 100644 index 0000000000000..3c3406e55970c --- /dev/null +++ b/test/CodeGenCXX/weak-extern-typeinfo.cpp @@ -0,0 +1,47 @@ +// RUN: %clang_cc1 %s -emit-llvm -o - | FileCheck %s +// rdar://10246395 + +#define WEAK __attribute__ ((weak)) + +class WEAK A { + virtual void foo(); +}; + +class B : public A { + virtual void foo(); +}; +void A::foo() { } +void B::foo() { } + +class T {}; +class T1 {}; + +class C : public T1, public B, public T { + virtual void foo(); +}; +void C::foo() { } + +class V1 : public virtual A { + virtual void foo(); +}; + +class V2 : public virtual V1 { + virtual void foo(); +}; +void V1::foo() { } +void V2::foo() { } + +// CHECK: @_ZTS1A = weak_odr constant +// CHECK: @_ZTI1A = weak_odr unnamed_addr constant +// CHECK: @_ZTS1B = weak_odr constant +// CHECK: @_ZTI1B = weak_odr unnamed_addr constant +// CHECK: @_ZTS1C = weak_odr constant +// CHECK: @_ZTS2T1 = linkonce_odr constant +// CHECK: @_ZTI2T1 = linkonce_odr unnamed_addr constant +// CHECK: @_ZTS1T = linkonce_odr constant +// CHECK: @_ZTI1T = linkonce_odr unnamed_addr constant +// CHECK: @_ZTI1C = weak_odr unnamed_addr constant +// CHECK: @_ZTS2V1 = weak_odr constant +// CHECK: @_ZTI2V1 = weak_odr unnamed_addr constant +// CHECK: @_ZTS2V2 = weak_odr constant +// CHECK: @_ZTI2V2 = weak_odr unnamed_addr constant diff --git a/test/CodeGenCXX/x86_32-arguments.cpp b/test/CodeGenCXX/x86_32-arguments.cpp index 1cbeb71b2285d..4404de0f88e5b 100644 --- a/test/CodeGenCXX/x86_32-arguments.cpp +++ b/test/CodeGenCXX/x86_32-arguments.cpp @@ -84,7 +84,7 @@ struct s4_1 { float x; }; struct s4_2 : s4_0, s4_1 { }; s4_2 f4() { return s4_2(); } -// CHECK: define i32 @_Z2f5v() +// CHECK: define i32* @_Z2f5v() struct s5 { s5(); int &x; }; s5 f5() { return s5(); } |