1 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -emit-llvm -o - %s | FileCheck %s
2 
3 // Basic base class test.
4 struct f0_s0 { unsigned a; };
5 struct f0_s1 : public f0_s0 { void *b; };
6 // CHECK-LABEL: define void @_Z2f05f0_s1(i32 %a0.coerce0, i8* %a0.coerce1)
7 void f0(f0_s1 a0) { }
8 
9 // Check with two eight-bytes in base class.
10 struct f1_s0 { unsigned a; unsigned b; float c; };
11 struct f1_s1 : public f1_s0 { float d;};
12 // CHECK-LABEL: define void @_Z2f15f1_s1(i64 %a0.coerce0, <2 x float> %a0.coerce1)
13 void f1(f1_s1 a0) { }
14 
15 // Check with two eight-bytes in base class and merge.
16 struct f2_s0 { unsigned a; unsigned b; float c; };
17 struct f2_s1 : public f2_s0 { char d;};
18 // CHECK-LABEL: define void @_Z2f25f2_s1(i64 %a0.coerce0, i64 %a0.coerce1)
19 void f2(f2_s1 a0) { }
20 
21 // PR5831
22 // CHECK-LABEL: define void @_Z2f34s3_1(i64 %x.coerce)
23 struct s3_0 {};
24 struct s3_1 { struct s3_0 a; long b; };
25 void f3(struct s3_1 x) {}
26 
27 // CHECK-LABEL: define i64 @_Z4f4_0M2s4i(i64 %a)
28 // CHECK: define {{.*}} @_Z4f4_1M2s4FivE(i64 %a.coerce0, i64 %a.coerce1)
29 struct s4 {};
30 typedef int s4::* s4_mdp;
31 typedef int (s4::*s4_mfp)();
32 s4_mdp f4_0(s4_mdp a) { return a; }
33 s4_mfp f4_1(s4_mfp a) { return a; }
34 
35 // A struct with <= one eightbyte before a member data pointer should still
36 // be allowed in registers.
37 // CHECK-LABEL: define void @{{.*}}f_struct_with_mdp{{.*}}(i8* %a.coerce0, i64 %a.coerce1)
38 struct struct_with_mdp { char *a; s4_mdp b; };
39 void f_struct_with_mdp(struct_with_mdp a) { (void)a; }
40 
41 // A struct with anything before a member function will be too big and
42 // goes in memory.
43 // CHECK-LABEL: define void @{{.*}}f_struct_with_mfp_0{{.*}}(%struct{{.*}} byval align 8 %a)
44 struct struct_with_mfp_0 { char a; s4_mfp b; };
45 void f_struct_with_mfp_0(struct_with_mfp_0 a) { (void)a; }
46 
47 // CHECK-LABEL: define void @{{.*}}f_struct_with_mfp_1{{.*}}(%struct{{.*}} byval align 8 %a)
48 struct struct_with_mfp_1 { void *a; s4_mfp b; };
49 void f_struct_with_mfp_1(struct_with_mfp_1 a) { (void)a; }
50 
51 namespace PR7523 {
52 struct StringRef {
53   char *a;
54 };
55 
56 void AddKeyword(StringRef, int x);
57 
58 void foo() {
59   // CHECK-LABEL: define void @_ZN6PR75233fooEv()
60   // CHECK: call void @_ZN6PR752310AddKeywordENS_9StringRefEi(i8* {{.*}}, i32 4)
61   AddKeyword(StringRef(), 4);
62 }
63 }
64 
65 namespace PR7742 { // Also rdar://8250764
66   struct s2 {
67     float a[2];
68   };
69 
70   struct c2 : public s2 {};
71 
72   // CHECK-LABEL: define <2 x float> @_ZN6PR77423fooEPNS_2c2E(%"struct.PR7742::c2"* %P)
73   c2 foo(c2 *P) {
74     return c2();
75   }
76 
77 }
78 
79 namespace PR5179 {
80   struct B {};
81 
82   struct B1 : B {
83     int* pa;
84   };
85 
86   struct B2 : B {
87     B1 b1;
88   };
89 
90   // CHECK-LABEL: define i8* @_ZN6PR51793barENS_2B2E(i32* %b2.coerce)
91   const void *bar(B2 b2) {
92     return b2.b1.pa;
93   }
94 }
95 
96 namespace test5 {
97   struct Xbase { };
98   struct Empty { };
99   struct Y;
100   struct X : public Xbase {
101     Empty empty;
102     Y f();
103   };
104   struct Y : public X {
105     Empty empty;
106   };
107   X getX();
108   int takeY(const Y&, int y);
109   void g() {
110     // rdar://8340348 - The temporary for the X object needs to have a defined
111     // address when passed into X::f as 'this'.
112     takeY(getX().f(), 42);
113   }
114   // CHECK: void @_ZN5test51gEv()
115   // CHECK: alloca %"struct.test5::Y"
116   // CHECK: alloca %"struct.test5::X"
117   // CHECK: alloca %"struct.test5::Y"
118 }
119 
120 
121 // rdar://8360877
122 namespace test6 {
123   struct outer {
124     int x;
125     struct epsilon_matcher {} e;
126     int f;
127   };
128 
129   int test(outer x) {
130     return x.x + x.f;
131   }
132   // CHECK-LABEL: define i32 @_ZN5test64testENS_5outerE(i64 %x.coerce0, i32 %x.coerce1)
133 }
134 
135 namespace test7 {
136   struct StringRef {char* ptr; long len; };
137   class A { public: ~A(); };
138   A x(A, A, long, long, StringRef) { return A(); }
139   // Check that the StringRef is passed byval instead of expanded
140   // (which would split it between registers and memory).
141   // rdar://problem/9686430
142   // CHECK: define void @_ZN5test71xENS_1AES0_llNS_9StringRefE({{.*}} byval align 8)
143 
144   // And a couple extra related tests:
145   A y(A, long double, long, long, StringRef) { return A(); }
146   // CHECK: define void @_ZN5test71yENS_1AEellNS_9StringRefE({{.*}} i8*
147   struct StringDouble {char * ptr; double d;};
148   A z(A, A, A, A, A, StringDouble) { return A(); }
149   A zz(A, A, A, A, StringDouble) { return A(); }
150   // CHECK: define void @_ZN5test71zENS_1AES0_S0_S0_S0_NS_12StringDoubleE({{.*}} byval align 8)
151   // CHECK: define void @_ZN5test72zzENS_1AES0_S0_S0_NS_12StringDoubleE({{.*}} i8*
152 }
153 
154 namespace test8 {
155   // CHECK: declare void @_ZN5test83fooENS_1BE(%"class.test8::B"* byval align 8)
156   class A {
157    char big[17];
158   };
159 
160   class B : public A {};
161 
162   void foo(B b);
163   void bar() {
164    B b;
165    foo(b);
166   }
167 }
168 
169 // PR4242
170 namespace test9 {
171   // Large enough to be passed indirectly.
172   struct S { void *data[3]; };
173 
174   struct T { void *data[2]; };
175 
176   // CHECK: define void @_ZN5test93fooEPNS_1SEPNS_1TE([[S:%.*]]*, [[T:%.*]]*)
177   void foo(S*, T*) {}
178 
179   // CHECK: define void @_ZN5test91aEiiiiNS_1TEPv([[S]]* noalias sret {{%.*}}, i32, i32, i32, i32, [[T]]* byval align 8, i8*)
180   S a(int, int, int, int, T, void*) {
181     return S();
182   }
183 
184   // CHECK: define [[S]]* @_ZN5test91bEPNS_1SEiiiiNS_1TEPv([[S]]* {{%.*}}, i32, i32, i32, i32, [[T:%.*]]* byval align 8, i8*)
185   S* b(S* sret, int, int, int, int, T, void*) {
186     return sret;
187   }
188 
189   // CHECK: define void @_ZN5test91cEiiiNS_1TEPv([[S]]* noalias sret {{%.*}}, i32, i32, i32, i8* {{%.*}}, i8* {{%.*}}, i8*)
190   S c(int, int, int, T, void*) {
191     return S();
192   }
193 
194   // CHECK: define [[S]]* @_ZN5test91dEPNS_1SEiiiNS_1TEPv([[S]]* {{%.*}}, i32, i32, i32, i8* {{%.*}}, i8* {{%.*}}, i8*)
195   S* d(S* sret, int, int, int, T, void*) {
196     return sret;
197   }
198 }
199 
200 namespace test10 {
201 #pragma pack(1)
202 struct BasePacked {
203   char one;
204   short two;
205 };
206 #pragma pack()
207 struct DerivedPacked : public BasePacked {
208   int three;
209 };
210 // CHECK-LABEL: define i32 @_ZN6test1020FuncForDerivedPackedENS_13DerivedPackedE({{.*}}* byval align 8
211 int FuncForDerivedPacked(DerivedPacked d) {
212   return d.three;
213 }
214 }
215 
216 namespace test11 {
217 union U {
218   float f1;
219   char __attribute__((__vector_size__(1))) f2;
220 };
221 int f(union U u) { return u.f2[1]; }
222 // CHECK-LABEL: define i32 @_ZN6test111fENS_1UE(i32
223 }
224