1 // RUN: %clang_cc1 %s -I%S -triple=x86_64-apple-darwin10 -fstrict-vtable-pointers -std=c++11 -disable-llvm-passes -O2 -emit-llvm -o %t.ll
2 // RUN: FileCheck --check-prefix=CHECK-CTORS %s < %t.ll
3 // RUN: FileCheck --check-prefix=CHECK-NEW %s < %t.ll
4 // RUN: FileCheck --check-prefix=CHECK-DTORS %s < %t.ll
5 // RUN: FileCheck --check-prefix=CHECK-LINK-REQ %s < %t.ll
6 
7 typedef __typeof__(sizeof(0)) size_t;
8 void *operator new(size_t, void*) throw();
9 
10 struct NotTrivialDtor {
11   ~NotTrivialDtor();
12 };
13 
14 struct DynamicBase1 {
15   NotTrivialDtor obj;
16   virtual void foo();
17 };
18 
19 struct DynamicDerived : DynamicBase1 {
20   void foo();
21 };
22 
23 struct DynamicBase2 {
24   virtual void bar();
25   ~DynamicBase2() {
26     bar();
27   }
28 };
29 
30 struct DynamicDerivedMultiple : DynamicBase1, DynamicBase2 {
31   virtual void foo();
32   virtual void bar();
33 };
34 
35 struct StaticBase {
36   NotTrivialDtor obj;
37   void bar();
38 };
39 
40 struct DynamicFromStatic : StaticBase {
41   virtual void bar();
42 };
43 
44 struct DynamicFromVirtualStatic1 : virtual StaticBase {
45 };
46 
47 struct DynamicFromVirtualStatic2 : virtual StaticBase {
48 };
49 
50 struct DynamicFrom2Virtuals :
51             DynamicFromVirtualStatic1,
52             DynamicFromVirtualStatic2 {
53 };
54 
55 // CHECK-NEW-LABEL: define void @_Z12LocalObjectsv()
56 // CHECK-NEW-NOT: @llvm.invariant.group.barrier(
57 // CHECK-NEW-LABEL: {{^}}}
58 void LocalObjects() {
59   DynamicBase1 DB;
60   DB.foo();
61   DynamicDerived DD;
62   DD.foo();
63 
64   DynamicBase2 DB2;
65   DB2.bar();
66 
67   StaticBase SB;
68   SB.bar();
69 
70   DynamicDerivedMultiple DDM;
71   DDM.foo();
72   DDM.bar();
73 
74   DynamicFromStatic DFS;
75   DFS.bar();
76   DynamicFromVirtualStatic1 DFVS1;
77   DFVS1.bar();
78   DynamicFrom2Virtuals DF2V;
79   DF2V.bar();
80 }
81 
82 struct DynamicFromVirtualStatic1;
83 // CHECK-CTORS-LABEL: define linkonce_odr void @_ZN25DynamicFromVirtualStatic1C1Ev
84 // CHECK-CTORS-NOT: @llvm.invariant.group.barrier(
85 // CHECK-CTORS-LABEL: {{^}}}
86 
87 struct DynamicFrom2Virtuals;
88 // CHECK-CTORS-LABEL: define linkonce_odr void @_ZN20DynamicFrom2VirtualsC1Ev
89 // CHECK-CTORS: call i8* @llvm.invariant.group.barrier(
90 // CHECK-CTORS-LABEL: {{^}}}
91 
92 
93 // CHECK-NEW-LABEL: define void @_Z9Pointers1v()
94 // CHECK-NEW-NOT: @llvm.invariant.group.barrier(
95 // CHECK-NEW-LABEL: call void @_ZN12DynamicBase1C1Ev(
96 
97 // CHECK-NEW: %[[THIS3:.*]] = call i8* @llvm.invariant.group.barrier(i8* %[[THIS2:.*]])
98 // CHECK-NEW: %[[THIS4:.*]] = bitcast i8* %[[THIS3]] to %[[DynamicDerived:.*]]*
99 // CHECK-NEW: call void @_ZN14DynamicDerivedC1Ev(%[[DynamicDerived:.*]]* %[[THIS4]])
100 // CHECK-NEW-LABEL: {{^}}}
101 void Pointers1() {
102   DynamicBase1 *DB = new DynamicBase1;
103   DB->foo();
104 
105   DynamicDerived *DD = new (DB) DynamicDerived;
106   DD->foo();
107   DD->~DynamicDerived();
108 }
109 
110 // CHECK-NEW-LABEL: define void @_Z14HackingObjectsv()
111 // CHECK-NEW:  call void @_ZN12DynamicBase1C1Ev
112 // CHECK-NEW:  call i8* @llvm.invariant.group.barrier(
113 // CHECK-NEW:  call void @_ZN14DynamicDerivedC1Ev(
114 // CHECK-NEW:  call i8* @llvm.invariant.group.barrier(
115 // CHECK-NEW: call void @_ZN12DynamicBase1C1Ev(
116 // CHECK-NEW-LABEL: {{^}}}
117 void HackingObjects() {
118   DynamicBase1 DB;
119   DB.foo();
120 
121   DynamicDerived *DB2 = new (&DB) DynamicDerived;
122   // Using DB now is prohibited.
123   DB2->foo();
124   DB2->~DynamicDerived();
125 
126   // We have to get back to the previous type to avoid calling wrong destructor
127   new (&DB) DynamicBase1;
128   DB.foo();
129 }
130 
131 /*** Testing Constructors ***/
132 struct DynamicBase1;
133 // CHECK-CTORS-LABEL: define linkonce_odr void @_ZN12DynamicBase1C2Ev(
134 // CHECK-CTORS-NOT: call i8* @llvm.invariant.group.barrier(
135 // CHECK-CTORS-LABEL: {{^}}}
136 
137 
138 struct DynamicDerived;
139 
140 // CHECK-CTORS-LABEL: define linkonce_odr void @_ZN14DynamicDerivedC2Ev(
141 // CHECK-CTORS: %[[THIS0:.*]] = load %[[DynamicDerived:.*]]*, %[[DynamicDerived]]** {{.*}}
142 // CHECK-CTORS: %[[THIS1:.*]] = bitcast %[[DynamicDerived:.*]]* %[[THIS0]] to i8*
143 // CHECK-CTORS: %[[THIS2:.*]] = call i8* @llvm.invariant.group.barrier(i8* %[[THIS1:.*]])
144 // CHECK-CTORS: %[[THIS3:.*]] = bitcast i8* %[[THIS2]] to %[[DynamicDerived]]*
145 // CHECK-CTORS: %[[THIS4:.*]] = bitcast %[[DynamicDerived]]* %[[THIS3]] to %[[DynamicBase:.*]]*
146 // CHECK-CTORS: call void @_ZN12DynamicBase1C2Ev(%[[DynamicBase]]* %[[THIS4]])
147 
148 // CHECK-CTORS: %[[THIS5:.*]] = bitcast %struct.DynamicDerived* %[[THIS0]] to i32 (...)***
149 // CHECK-CTORS: store {{.*}} %[[THIS5]]
150 // CHECK-CTORS-LABEL: {{^}}}
151 
152 struct DynamicDerivedMultiple;
153 // CHECK-CTORS-LABEL: define linkonce_odr void @_ZN22DynamicDerivedMultipleC2Ev(
154 
155 // CHECK-CTORS: %[[THIS0:.*]] = load %[[CLASS:.*]]*, %[[CLASS]]** {{.*}}
156 // CHECK-CTORS: %[[THIS1:.*]] = bitcast %[[CLASS:.*]]* %[[THIS0]] to i8*
157 // CHECK-CTORS: %[[THIS2:.*]] = call i8* @llvm.invariant.group.barrier(i8* %[[THIS1]])
158 // CHECK-CTORS: %[[THIS3:.*]] = bitcast i8* %[[THIS2]] to %[[CLASS]]*
159 // CHECK-CTORS: %[[THIS4:.*]] = bitcast %[[CLASS]]* %[[THIS3]] to %[[BASE_CLASS:.*]]*
160 // CHECK-CTORS: call void @_ZN12DynamicBase1C2Ev(%[[BASE_CLASS]]* %[[THIS4]])
161 
162 // CHECK-CTORS: call i8* @llvm.invariant.group.barrier(
163 
164 // CHECK-CTORS: call void @_ZN12DynamicBase2C2Ev(
165 // CHECK-CTORS-NOT: @llvm.invariant.group.barrier
166 
167 
168 // CHECK-CTORS: %[[THIS10:.*]] = bitcast %struct.DynamicDerivedMultiple* %[[THIS0]] to i32 (...)***
169 // CHECK-CTORS: store {{.*}} @_ZTV22DynamicDerivedMultiple, i32 0, inrange i32 0, i32 2) {{.*}} %[[THIS10]]
170 // CHECK-CTORS: %[[THIS11:.*]] = bitcast %struct.DynamicDerivedMultiple* %[[THIS0]] to i8*
171 // CHECK-CTORS: %[[THIS_ADD:.*]] = getelementptr inbounds i8, i8* %[[THIS11]], i64 16
172 // CHECK-CTORS: %[[THIS12:.*]]  = bitcast i8* %[[THIS_ADD]] to i32 (...)***
173 
174 
175 // CHECK-CTORS: store {{.*}} @_ZTV22DynamicDerivedMultiple, i32 0, inrange i32 1, i32 2) {{.*}} %[[THIS12]]
176 // CHECK-CTORS-LABEL: {{^}}}
177 
178 struct DynamicFromStatic;
179 // CHECK-CTORS-LABEL: define linkonce_odr void @_ZN17DynamicFromStaticC2Ev(
180 // CHECK-CTORS-NOT: @llvm.invariant.group.barrier(
181 // CHECK-CTORS-LABEL: {{^}}}
182 
183 struct A {
184   virtual void foo();
185 };
186 struct B : A {
187   virtual void foo();
188 };
189 
190 union U {
191   A a;
192   B b;
193 };
194 
195 void changeToB(U *u);
196 void changeToA(U *u);
197 
198 void g2(A *a) {
199   a->foo();
200 }
201 // We have to guard access to union fields with invariant.group, because
202 // it is very easy to skip the barrier with unions. In this example the inlined
203 // g2 will produce loads with the same !invariant.group metadata, and
204 // u->a and u->b would use the same pointer.
205 // CHECK-NEW-LABEL: define void @_Z14UnionsBarriersP1U
206 void UnionsBarriers(U *u) {
207   // CHECK-NEW: call void @_Z9changeToBP1U(
208   changeToB(u);
209   // CHECK-NEW: call i8* @llvm.invariant.group.barrier(i8*
210   // CHECK-NEW: call void @_Z2g2P1A(%struct.A*
211   g2(&u->b);
212   // CHECK-NEW: call void @_Z9changeToAP1U(%union.U*
213   changeToA(u);
214   // CHECK-NEW: call i8* @llvm.invariant.group.barrier(i8*
215   // call void @_Z2g2P1A(%struct.A* %a)
216   g2(&u->a);
217   // CHECK-NEW-NOT: call i8* @llvm.invariant.group.barrier(i8*
218 }
219 
220 struct HoldingVirtuals {
221   A a;
222 };
223 
224 struct Empty {};
225 struct AnotherEmpty {
226   Empty e;
227 };
228 union NoVptrs {
229   int a;
230   AnotherEmpty empty;
231 };
232 void take(AnotherEmpty &);
233 
234 // CHECK-NEW-LABEL: noBarriers
235 void noBarriers(NoVptrs &noVptrs) {
236   // CHECK-NEW-NOT: call i8* @llvm.invariant.group.barrier(i8*
237   // CHECK-NEW: 42
238   noVptrs.a += 42;
239   // CHECK-NEW-NOT: call i8* @llvm.invariant.group.barrier(i8*
240   // CHECK-NEW: call void @_Z4takeR12AnotherEmpty(
241   take(noVptrs.empty);
242 }
243 
244 union U2 {
245   HoldingVirtuals h;
246   int z;
247 };
248 void take(HoldingVirtuals &);
249 
250 // CHECK-NEW-LABEL: define void @_Z15UnionsBarriers2R2U2
251 void UnionsBarriers2(U2 &u) {
252   // CHECK-NEW-NOT: call i8* @llvm.invariant.group.barrier(i8*
253   // CHECK-NEW: 42
254   u.z += 42;
255   // CHECK-NEW: call i8* @llvm.invariant.group.barrier(i8*
256   // CHECK-NEW: call void @_Z4takeR15HoldingVirtuals(
257   take(u.h);
258 }
259 
260 struct VirtualInBase : HoldingVirtuals, Empty {
261 };
262 
263 struct VirtualInVBase : virtual Empty, virtual HoldingVirtuals {
264 };
265 
266 // It has vtable by virtual inheritance.
267 struct VirtualInheritance : virtual Empty {
268 };
269 
270 union U3 {
271   VirtualInBase v1;
272   VirtualInBase v2;
273   VirtualInheritance v3;
274   int z;
275 };
276 
277 void take(VirtualInBase &);
278 void take(VirtualInVBase &);
279 void take(VirtualInheritance &);
280 
281 void UnionsBarrier3(U3 &u) {
282   // CHECK-NEW-NOT: call i8* @llvm.invariant.group.barrier(i8*
283   // CHECK-NEW: 42
284   u.z += 42;
285   // CHECK-NEW: call i8* @llvm.invariant.group.barrier(i8*
286   // CHECK-NEW: call void @_Z4takeR13VirtualInBase(
287   take(u.v1);
288   // CHECK-NEW: call i8* @llvm.invariant.group.barrier(i8*
289   // CHECK-NEW: call void @_Z4takeR13VirtualInBase(
290   take(u.v2);
291 
292   // CHECK-NEW: call i8* @llvm.invariant.group.barrier(i8*
293   // CHECK-NEW: call void @_Z4takeR18VirtualInheritance(
294   take(u.v3);
295 }
296 
297 /** DTORS **/
298 // CHECK-DTORS-LABEL: define linkonce_odr void @_ZN10StaticBaseD2Ev(
299 // CHECK-DTORS-NOT: call i8* @llvm.invariant.group.barrier(
300 // CHECK-DTORS-LABEL: {{^}}}
301 
302 
303 // CHECK-DTORS-LABEL: define linkonce_odr void @_ZN25DynamicFromVirtualStatic2D2Ev(
304 // CHECK-DTORS-NOT: invariant.barrier
305 // CHECK-DTORS-LABEL: {{^}}}
306 
307 // CHECK-DTORS-LABEL: define linkonce_odr void @_ZN17DynamicFromStaticD2Ev
308 // CHECK-DTORS-NOT: call i8* @llvm.invariant.group.barrier(
309 // CHECK-DTORS-LABEL: {{^}}}
310 
311 
312 // CHECK-DTORS-LABEL: define linkonce_odr void @_ZN22DynamicDerivedMultipleD2Ev(
313 
314 // CHECK-DTORS-LABEL: define linkonce_odr void @_ZN12DynamicBase2D2Ev(
315 // CHECK-DTORS: call i8* @llvm.invariant.group.barrier(
316 // CHECK-DTORS-LABEL: {{^}}}
317 
318 // CHECK-DTORS-LABEL: define linkonce_odr void @_ZN12DynamicBase1D2Ev
319 // CHECK-DTORS: call i8* @llvm.invariant.group.barrier(
320 // CHECK-DTORS-LABEL: {{^}}}
321 
322 // CHECK-DTORS-LABEL: define linkonce_odr void @_ZN14DynamicDerivedD2Ev
323 // CHECK-DTORS-NOT: call i8* @llvm.invariant.group.barrier(
324 // CHECK-DTORS-LABEL: {{^}}}
325 
326 
327 // CHECK-LINK-REQ: !llvm.module.flags = !{![[FIRST:[0-9]+]], ![[SEC:[0-9]+]]{{.*}}}
328 
329 // CHECK-LINK-REQ: ![[FIRST]] = !{i32 1, !"StrictVTablePointers", i32 1}
330 // CHECK-LINK-REQ: ![[SEC]] = !{i32 3, !"StrictVTablePointersRequirement", ![[META:.*]]}
331 // CHECK-LINK-REQ: ![[META]] = !{!"StrictVTablePointers", i32 1}
332 
333