forked from OSchip/llvm-project
224 lines
6.1 KiB
C++
224 lines
6.1 KiB
C++
// RUN: %clang_cc1 -triple x86_64-unknown-unknown -emit-llvm -o - %s | FileCheck %s
|
|
|
|
// Basic base class test.
|
|
struct f0_s0 { unsigned a; };
|
|
struct f0_s1 : public f0_s0 { void *b; };
|
|
// CHECK-LABEL: define void @_Z2f05f0_s1(i32 %a0.coerce0, i8* %a0.coerce1)
|
|
void f0(f0_s1 a0) { }
|
|
|
|
// Check with two eight-bytes in base class.
|
|
struct f1_s0 { unsigned a; unsigned b; float c; };
|
|
struct f1_s1 : public f1_s0 { float d;};
|
|
// CHECK-LABEL: define void @_Z2f15f1_s1(i64 %a0.coerce0, <2 x float> %a0.coerce1)
|
|
void f1(f1_s1 a0) { }
|
|
|
|
// Check with two eight-bytes in base class and merge.
|
|
struct f2_s0 { unsigned a; unsigned b; float c; };
|
|
struct f2_s1 : public f2_s0 { char d;};
|
|
// CHECK-LABEL: define void @_Z2f25f2_s1(i64 %a0.coerce0, i64 %a0.coerce1)
|
|
void f2(f2_s1 a0) { }
|
|
|
|
// PR5831
|
|
// CHECK-LABEL: define void @_Z2f34s3_1(i64 %x.coerce)
|
|
struct s3_0 {};
|
|
struct s3_1 { struct s3_0 a; long b; };
|
|
void f3(struct s3_1 x) {}
|
|
|
|
// CHECK-LABEL: define i64 @_Z4f4_0M2s4i(i64 %a)
|
|
// CHECK: define {{.*}} @_Z4f4_1M2s4FivE(i64 %a.coerce0, i64 %a.coerce1)
|
|
struct s4 {};
|
|
typedef int s4::* s4_mdp;
|
|
typedef int (s4::*s4_mfp)();
|
|
s4_mdp f4_0(s4_mdp a) { return a; }
|
|
s4_mfp f4_1(s4_mfp a) { return a; }
|
|
|
|
// A struct with <= one eightbyte before a member data pointer should still
|
|
// be allowed in registers.
|
|
// CHECK-LABEL: define void @{{.*}}f_struct_with_mdp{{.*}}(i8* %a.coerce0, i64 %a.coerce1)
|
|
struct struct_with_mdp { char *a; s4_mdp b; };
|
|
void f_struct_with_mdp(struct_with_mdp a) { (void)a; }
|
|
|
|
// A struct with anything before a member function will be too big and
|
|
// goes in memory.
|
|
// CHECK-LABEL: define void @{{.*}}f_struct_with_mfp_0{{.*}}(%struct{{.*}} byval(%struct{{.*}}) align 8 %a)
|
|
struct struct_with_mfp_0 { char a; s4_mfp b; };
|
|
void f_struct_with_mfp_0(struct_with_mfp_0 a) { (void)a; }
|
|
|
|
// CHECK-LABEL: define void @{{.*}}f_struct_with_mfp_1{{.*}}(%struct{{.*}} byval(%struct{{.*}}) align 8 %a)
|
|
struct struct_with_mfp_1 { void *a; s4_mfp b; };
|
|
void f_struct_with_mfp_1(struct_with_mfp_1 a) { (void)a; }
|
|
|
|
namespace PR7523 {
|
|
struct StringRef {
|
|
char *a;
|
|
};
|
|
|
|
void AddKeyword(StringRef, int x);
|
|
|
|
void foo() {
|
|
// CHECK-LABEL: define void @_ZN6PR75233fooEv()
|
|
// CHECK: call void @_ZN6PR752310AddKeywordENS_9StringRefEi(i8* {{.*}}, i32 4)
|
|
AddKeyword(StringRef(), 4);
|
|
}
|
|
}
|
|
|
|
namespace PR7742 { // Also rdar://8250764
|
|
struct s2 {
|
|
float a[2];
|
|
};
|
|
|
|
struct c2 : public s2 {};
|
|
|
|
// CHECK-LABEL: define <2 x float> @_ZN6PR77423fooEPNS_2c2E(%"struct.PR7742::c2"* %P)
|
|
c2 foo(c2 *P) {
|
|
return c2();
|
|
}
|
|
|
|
}
|
|
|
|
namespace PR5179 {
|
|
struct B {};
|
|
|
|
struct B1 : B {
|
|
int* pa;
|
|
};
|
|
|
|
struct B2 : B {
|
|
B1 b1;
|
|
};
|
|
|
|
// CHECK-LABEL: define i8* @_ZN6PR51793barENS_2B2E(i32* %b2.coerce)
|
|
const void *bar(B2 b2) {
|
|
return b2.b1.pa;
|
|
}
|
|
}
|
|
|
|
namespace test5 {
|
|
struct Xbase { };
|
|
struct Empty { };
|
|
struct Y;
|
|
struct X : public Xbase {
|
|
Empty empty;
|
|
Y f();
|
|
};
|
|
struct Y : public X {
|
|
Empty empty;
|
|
};
|
|
X getX();
|
|
int takeY(const Y&, int y);
|
|
void g() {
|
|
// rdar://8340348 - The temporary for the X object needs to have a defined
|
|
// address when passed into X::f as 'this'.
|
|
takeY(getX().f(), 42);
|
|
}
|
|
// CHECK: void @_ZN5test51gEv()
|
|
// CHECK: alloca %"struct.test5::Y"
|
|
// CHECK: alloca %"struct.test5::X"
|
|
// CHECK: alloca %"struct.test5::Y"
|
|
}
|
|
|
|
|
|
// rdar://8360877
|
|
namespace test6 {
|
|
struct outer {
|
|
int x;
|
|
struct epsilon_matcher {} e;
|
|
int f;
|
|
};
|
|
|
|
int test(outer x) {
|
|
return x.x + x.f;
|
|
}
|
|
// CHECK-LABEL: define i32 @_ZN5test64testENS_5outerE(i64 %x.coerce0, i32 %x.coerce1)
|
|
}
|
|
|
|
namespace test7 {
|
|
struct StringRef {char* ptr; long len; };
|
|
class A { public: ~A(); };
|
|
A x(A, A, long, long, StringRef) { return A(); }
|
|
// Check that the StringRef is passed byval instead of expanded
|
|
// (which would split it between registers and memory).
|
|
// rdar://problem/9686430
|
|
// CHECK: define void @_ZN5test71xENS_1AES0_llNS_9StringRefE({{.*}} byval({{.*}}) align 8 {{%.*}})
|
|
|
|
// And a couple extra related tests:
|
|
A y(A, long double, long, long, StringRef) { return A(); }
|
|
// CHECK: define void @_ZN5test71yENS_1AEellNS_9StringRefE({{.*}} i8*
|
|
struct StringDouble {char * ptr; double d;};
|
|
A z(A, A, A, A, A, StringDouble) { return A(); }
|
|
A zz(A, A, A, A, StringDouble) { return A(); }
|
|
// CHECK: define void @_ZN5test71zENS_1AES0_S0_S0_S0_NS_12StringDoubleE({{.*}} byval({{.*}}) align 8 {{%.*}})
|
|
// CHECK: define void @_ZN5test72zzENS_1AES0_S0_S0_NS_12StringDoubleE({{.*}} i8*
|
|
}
|
|
|
|
namespace test8 {
|
|
// CHECK: declare void @_ZN5test83fooENS_1BE(%"class.test8::B"* byval(%"class.test8::B") align 8)
|
|
class A {
|
|
char big[17];
|
|
};
|
|
|
|
class B : public A {};
|
|
|
|
void foo(B b);
|
|
void bar() {
|
|
B b;
|
|
foo(b);
|
|
}
|
|
}
|
|
|
|
// PR4242
|
|
namespace test9 {
|
|
// Large enough to be passed indirectly.
|
|
struct S { void *data[3]; };
|
|
|
|
struct T { void *data[2]; };
|
|
|
|
// CHECK: define void @_ZN5test93fooEPNS_1SEPNS_1TE([[S:%.*]]* %0, [[T:%.*]]* %1)
|
|
void foo(S*, T*) {}
|
|
|
|
// CHECK: define void @_ZN5test91aEiiiiNS_1TEPv([[S]]* noalias sret {{%.*}}, i32 %0, i32 %1, i32 %2, i32 %3, [[T]]* byval([[T]]) align 8 %4, i8* %5)
|
|
S a(int, int, int, int, T, void*) {
|
|
return S();
|
|
}
|
|
|
|
// CHECK: define [[S]]* @_ZN5test91bEPNS_1SEiiiiNS_1TEPv([[S]]* {{%.*}}, i32 %0, i32 %1, i32 %2, i32 %3, [[T:%.*]]* byval([[T]]) align 8 %4, i8* %5)
|
|
S* b(S* sret, int, int, int, int, T, void*) {
|
|
return sret;
|
|
}
|
|
|
|
// CHECK: define void @_ZN5test91cEiiiNS_1TEPv([[S]]* noalias sret {{%.*}}, i32 %0, i32 %1, i32 %2, i8* {{%.*}}, i8* {{%.*}}, i8* %3)
|
|
S c(int, int, int, T, void*) {
|
|
return S();
|
|
}
|
|
|
|
// CHECK: define [[S]]* @_ZN5test91dEPNS_1SEiiiNS_1TEPv([[S]]* {{%.*}}, i32 %0, i32 %1, i32 %2, i8* {{%.*}}, i8* {{%.*}}, i8* %3)
|
|
S* d(S* sret, int, int, int, T, void*) {
|
|
return sret;
|
|
}
|
|
}
|
|
|
|
namespace test10 {
|
|
#pragma pack(1)
|
|
struct BasePacked {
|
|
char one;
|
|
short two;
|
|
};
|
|
#pragma pack()
|
|
struct DerivedPacked : public BasePacked {
|
|
int three;
|
|
};
|
|
// CHECK-LABEL: define i32 @_ZN6test1020FuncForDerivedPackedENS_13DerivedPackedE({{.*}}* byval({{.*}}) align 8
|
|
int FuncForDerivedPacked(DerivedPacked d) {
|
|
return d.three;
|
|
}
|
|
}
|
|
|
|
namespace test11 {
|
|
union U {
|
|
float f1;
|
|
char __attribute__((__vector_size__(1))) f2;
|
|
};
|
|
int f(union U u) { return u.f2[1]; }
|
|
// CHECK-LABEL: define i32 @_ZN6test111fENS_1UE(i32
|
|
}
|