• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // RUN: %clang_cc1 %s -fno-rtti -triple=i386-pc-win32 -emit-llvm -o %t
2 // RUN: FileCheck %s < %t
3 // RUN: FileCheck --check-prefix=CHECK2 %s < %t
4 
5 // For now, just make sure x86_64 doesn't crash.
6 // RUN: %clang_cc1 %s -fno-rtti -triple=x86_64-pc-win32 -emit-llvm -o %t
7 
8 struct VBase {
9   virtual ~VBase();
10   virtual void foo();
11   virtual void bar();
12   int field;
13 };
14 
15 struct B : virtual VBase {
16   B();
17   virtual ~B();
18   virtual void foo();
19   virtual void bar();
20 };
21 
B()22 B::B() {
23   // CHECK-LABEL: define x86_thiscallcc %struct.B* @"\01??0B@@QAE@XZ"
24   // CHECK:   %[[THIS:.*]] = load %struct.B*, %struct.B**
25   // CHECK:   br i1 %{{.*}}, label %[[INIT_VBASES:.*]], label %[[SKIP_VBASES:.*]]
26 
27   // Don't check the INIT_VBASES case as it's covered by the ctor tests.
28 
29   // CHECK: %[[SKIP_VBASES]]
30   // CHECK:   %[[THIS_i8:.*]] = bitcast %struct.B* %[[THIS]] to i8*
31   // CHECK:   %[[VBPTR:.*]] = getelementptr inbounds i8, i8* %[[THIS_i8]], i32 0
32   // ...
33   // CHECK:   %[[THIS_i8:.*]] = bitcast %struct.B* %[[THIS]] to i8*
34   // CHECK:   %[[VFPTR_i8:.*]] = getelementptr inbounds i8, i8* %[[THIS_i8]], i32 %{{.*}}
35   // CHECK:   %[[VFPTR:.*]] = bitcast i8* %[[VFPTR_i8]] to i32 (...)***
36   // CHECK:   store i32 (...)** bitcast ([3 x i8*]* @"\01??_7B@@6B@" to i32 (...)**), i32 (...)*** %[[VFPTR]]
37 
38   // Initialize vtorDisp:
39   // CHECK:   %[[THIS_i8:.*]] = bitcast %struct.B* %[[THIS]] to i8*
40   // CHECK:   %[[VBPTR:.*]] = getelementptr inbounds i8, i8* %[[THIS_i8]], i32 0
41   // ...
42   // CHECK:   %[[VBASE_OFFSET:.*]] = add nsw i32 0, %{{.*}}
43   // CHECK:   %[[VTORDISP_VAL:.*]] = sub i32 %[[VBASE_OFFSET]], 8
44   // CHECK:   %[[THIS_i8:.*]] = bitcast %struct.B* %[[THIS]] to i8*
45   // CHECK:   %[[VBASE_i8:.*]] = getelementptr inbounds i8, i8* %[[THIS_i8]], i32 %[[VBASE_OFFSET]]
46   // CHECK:   %[[VTORDISP_i8:.*]] = getelementptr i8, i8* %[[VBASE_i8]], i32 -4
47   // CHECK:   %[[VTORDISP_PTR:.*]] = bitcast i8* %[[VTORDISP_i8]] to i32*
48   // CHECK:   store i32 %[[VTORDISP_VAL]], i32* %[[VTORDISP_PTR]]
49 
50   // CHECK: ret
51 }
52 
~B()53 B::~B() {
54   // CHECK-LABEL: define x86_thiscallcc void @"\01??1B@@UAE@XZ"
55   // Adjust the this parameter:
56   // CHECK:   %[[THIS_PARAM_i8:.*]] = bitcast %struct.B* {{.*}} to i8*
57   // CHECK:   %[[THIS_i8:.*]] = getelementptr inbounds i8, i8* %[[THIS_PARAM_i8]], i32 -8
58   // CHECK:   %[[THIS:.*]] = bitcast i8* %[[THIS_i8]] to %struct.B*
59   // CHECK:   store %struct.B* %[[THIS]], %struct.B** %[[THIS_ADDR:.*]], align 4
60   // CHECK:   %[[THIS:.*]] = load %struct.B*, %struct.B** %[[THIS_ADDR]]
61 
62   // Restore the vfptr that could have been changed by a subclass.
63   // CHECK:   %[[THIS_i8:.*]] = bitcast %struct.B* %[[THIS]] to i8*
64   // CHECK:   %[[VBPTR:.*]] = getelementptr inbounds i8, i8* %[[THIS_i8]], i32 0
65   // ...
66   // CHECK:   %[[THIS_i8:.*]] = bitcast %struct.B* %[[THIS]] to i8*
67   // CHECK:   %[[VFPTR_i8:.*]] = getelementptr inbounds i8, i8* %[[THIS_i8]], i32 %{{.*}}
68   // CHECK:   %[[VFPTR:.*]] = bitcast i8* %[[VFPTR_i8]] to i32 (...)***
69   // CHECK:   store i32 (...)** bitcast ([3 x i8*]* @"\01??_7B@@6B@" to i32 (...)**), i32 (...)*** %[[VFPTR]]
70 
71   // Initialize vtorDisp:
72   // CHECK:   %[[THIS_i8:.*]] = bitcast %struct.B* %[[THIS]] to i8*
73   // CHECK:   %[[VBPTR:.*]] = getelementptr inbounds i8, i8* %[[THIS_i8]], i32 0
74   // ...
75   // CHECK:   %[[VBASE_OFFSET:.*]] = add nsw i32 0, %{{.*}}
76   // CHECK:   %[[VTORDISP_VAL:.*]] = sub i32 %[[VBASE_OFFSET]], 8
77   // CHECK:   %[[THIS_i8:.*]] = bitcast %struct.B* %[[THIS]] to i8*
78   // CHECK:   %[[VBASE_i8:.*]] = getelementptr inbounds i8, i8* %[[THIS_i8]], i32 %[[VBASE_OFFSET]]
79   // CHECK:   %[[VTORDISP_i8:.*]] = getelementptr i8, i8* %[[VBASE_i8]], i32 -4
80   // CHECK:   %[[VTORDISP_PTR:.*]] = bitcast i8* %[[VTORDISP_i8]] to i32*
81   // CHECK:   store i32 %[[VTORDISP_VAL]], i32* %[[VTORDISP_PTR]]
82 
83   foo();  // Avoid the "trivial destructor" optimization.
84 
85   // CHECK: ret
86 
87   // CHECK2-LABEL: define linkonce_odr x86_thiscallcc void @"\01??_DB@@UAE@XZ"(%struct.B*
88   // CHECK2: %[[THIS:.*]] = load %struct.B*, %struct.B** {{.*}}
89   // CHECK2: %[[THIS_i8:.*]] = bitcast %struct.B* %[[THIS]] to i8*
90   // CHECK2: %[[B_i8:.*]] = getelementptr i8, i8* %[[THIS_i8]], i32 8
91   // CHECK2: %[[B:.*]] = bitcast i8* %[[B_i8]] to %struct.B*
92   // CHECK2: call x86_thiscallcc void @"\01??1B@@UAE@XZ"(%struct.B* %[[B]])
93   // CHECK2: %[[THIS_i8:.*]] = bitcast %struct.B* %[[THIS]] to i8*
94   // CHECK2: %[[VBASE_i8:.*]] = getelementptr inbounds i8, i8* %[[THIS_i8]], i32 8
95   // CHECK2: %[[VBASE:.*]] = bitcast i8* %[[VBASE_i8]] to %struct.VBase*
96   // CHECK2: call x86_thiscallcc void @"\01??1VBase@@UAE@XZ"(%struct.VBase* %[[VBASE]])
97   // CHECK2: ret
98 
99   // CHECK2-LABEL: define linkonce_odr x86_thiscallcc i8* @"\01??_GB@@UAEPAXI@Z"
100   // CHECK2:   %[[THIS_PARAM_i8:.*]] = bitcast %struct.B* {{.*}} to i8*
101   // CHECK2:   %[[THIS_i8:.*]] = getelementptr inbounds i8, i8* %[[THIS_PARAM_i8:.*]], i32 -8
102   // CHECK2:   %[[THIS:.*]] = bitcast i8* %[[THIS_i8]] to %struct.B*
103   // CHECK2:   store %struct.B* %[[THIS]], %struct.B** %[[THIS_ADDR:.*]], align 4
104   // CHECK2:   %[[THIS:.*]] = load %struct.B*, %struct.B** %[[THIS_ADDR]]
105   // CHECK2:   call x86_thiscallcc void @"\01??_DB@@UAE@XZ"(%struct.B* %[[THIS]])
106   // ...
107   // CHECK2: ret
108 }
109 
foo()110 void B::foo() {
111 // CHECK-LABEL: define x86_thiscallcc void @"\01?foo@B@@UAEXXZ"(i8*
112 //
113 // B::foo gets 'this' cast to VBase* in ECX (i.e. this+8) so we
114 // need to adjust 'this' before use.
115 //
116 // CHECK: %[[THIS_ADDR:.*]] = alloca %struct.B*, align 4
117 // CHECK: %[[THIS_i8:.*]] = getelementptr inbounds i8, i8* %[[ECX:.*]], i32 -8
118 // CHECK: %[[THIS:.*]] = bitcast i8* %[[THIS_i8]] to %struct.B*
119 // CHECK: store %struct.B* %[[THIS]], %struct.B** %[[THIS_ADDR]], align 4
120 
121   field = 42;
122 // CHECK: %[[THIS:.*]] = load %struct.B*, %struct.B** %[[THIS_ADDR]]
123 // CHECK: %[[THIS8:.*]] = bitcast %struct.B* %[[THIS]] to i8*
124 // CHECK: %[[VBPTR:.*]] = getelementptr inbounds i8, i8* %[[THIS8]], i32 0
125 // CHECK: %[[VBPTR8:.*]] = bitcast i8* %[[VBPTR]] to i32**
126 // CHECK: %[[VBTABLE:.*]] = load i32*, i32** %[[VBPTR8]]
127 // CHECK: %[[VBENTRY:.*]] = getelementptr inbounds i32, i32* %[[VBTABLE]], i32 1
128 // CHECK: %[[VBOFFSET32:.*]] = load i32, i32* %[[VBENTRY]]
129 // CHECK: %[[VBOFFSET:.*]] = add nsw i32 0, %[[VBOFFSET32]]
130 // CHECK: %[[THIS8:.*]] = bitcast %struct.B* %[[THIS]] to i8*
131 // CHECK: %[[VBASE_i8:.*]] = getelementptr inbounds i8, i8* %[[THIS8]], i32 %[[VBOFFSET]]
132 // CHECK: %[[VBASE:.*]] = bitcast i8* %[[VBASE_i8]] to %struct.VBase*
133 // CHECK: %[[FIELD:.*]] = getelementptr inbounds %struct.VBase, %struct.VBase* %[[VBASE]], i32 0, i32 1
134 // CHECK: store i32 42, i32* %[[FIELD]], align 4
135 //
136 // CHECK: ret void
137 }
138 
call_vbase_bar(B * obj)139 void call_vbase_bar(B *obj) {
140 // CHECK-LABEL: define void @"\01?call_vbase_bar@@YAXPAUB@@@Z"(%struct.B* %obj)
141 // CHECK: %[[OBJ:.*]] = load %struct.B
142 
143   obj->bar();
144 // When calling a vbase's virtual method, one needs to adjust 'this'
145 // at the caller site.
146 //
147 // CHECK: %[[OBJ_i8:.*]] = bitcast %struct.B* %[[OBJ]] to i8*
148 // CHECK: %[[VBPTR:.*]] = getelementptr inbounds i8, i8* %[[OBJ_i8]], i32 0
149 // CHECK: %[[VBPTR8:.*]] = bitcast i8* %[[VBPTR]] to i32**
150 // CHECK: %[[VBTABLE:.*]] = load i32*, i32** %[[VBPTR8]]
151 // CHECK: %[[VBENTRY:.*]] = getelementptr inbounds i32, i32* %[[VBTABLE]], i32 1
152 // CHECK: %[[VBOFFSET32:.*]] = load i32, i32* %[[VBENTRY]]
153 // CHECK: %[[VBOFFSET:.*]] = add nsw i32 0, %[[VBOFFSET32]]
154 // CHECK: %[[VBASE_i8:.*]] = getelementptr inbounds i8, i8* %[[OBJ_i8]], i32 %[[VBOFFSET]]
155 // CHECK: %[[VFPTR:.*]] = bitcast i8* %[[VBASE_i8]] to void (i8*)***
156 // CHECK: %[[VFTABLE:.*]] = load void (i8*)**, void (i8*)*** %[[VFPTR]]
157 // CHECK: %[[VFUN:.*]] = getelementptr inbounds void (i8*)*, void (i8*)** %[[VFTABLE]], i64 2
158 // CHECK: %[[VFUN_VALUE:.*]] = load void (i8*)*, void (i8*)** %[[VFUN]]
159 //
160 // CHECK: %[[OBJ_i8:.*]] = bitcast %struct.B* %[[OBJ]] to i8*
161 // CHECK: %[[VBPTR:.*]] = getelementptr inbounds i8, i8* %[[OBJ_i8]], i32 0
162 // CHECK: %[[VBPTR8:.*]] = bitcast i8* %[[VBPTR]] to i32**
163 // CHECK: %[[VBTABLE:.*]] = load i32*, i32** %[[VBPTR8]]
164 // CHECK: %[[VBENTRY:.*]] = getelementptr inbounds i32, i32* %[[VBTABLE]], i32 1
165 // CHECK: %[[VBOFFSET32:.*]] = load i32, i32* %[[VBENTRY]]
166 // CHECK: %[[VBOFFSET:.*]] = add nsw i32 0, %[[VBOFFSET32]]
167 // CHECK: %[[VBASE:.*]] = getelementptr inbounds i8, i8* %[[OBJ_i8]], i32 %[[VBOFFSET]]
168 //
169 // CHECK: call x86_thiscallcc void %[[VFUN_VALUE]](i8* %[[VBASE]])
170 //
171 // CHECK: ret void
172 }
173 
delete_B(B * obj)174 void delete_B(B *obj) {
175 // CHECK-LABEL: define void @"\01?delete_B@@YAXPAUB@@@Z"(%struct.B* %obj)
176 // CHECK: %[[OBJ:.*]] = load %struct.B
177 
178   delete obj;
179 // CHECK: %[[OBJ_i8:.*]] = bitcast %struct.B* %[[OBJ]] to i8*
180 // CHECK: %[[VBPTR:.*]] = getelementptr inbounds i8, i8* %[[OBJ_i8]], i32 0
181 // CHECK: %[[VBPTR8:.*]] = bitcast i8* %[[VBPTR]] to i32**
182 // CHECK: %[[VBTABLE:.*]] = load i32*, i32** %[[VBPTR8]]
183 // CHECK: %[[VBENTRY:.*]] = getelementptr inbounds i32, i32* %[[VBTABLE]], i32 1
184 // CHECK: %[[VBOFFSET32:.*]] = load i32, i32* %[[VBENTRY]]
185 // CHECK: %[[VBOFFSET:.*]] = add nsw i32 0, %[[VBOFFSET32]]
186 // CHECK: %[[VBASE_i8:.*]] = getelementptr inbounds i8, i8* %[[OBJ_i8]], i32 %[[VBOFFSET]]
187 // CHECK: %[[VFPTR:.*]] = bitcast i8* %[[VBASE_i8]] to i8* (%struct.B*, i32)***
188 // CHECK: %[[VFTABLE:.*]] = load i8* (%struct.B*, i32)**, i8* (%struct.B*, i32)*** %[[VFPTR]]
189 // CHECK: %[[VFUN:.*]] = getelementptr inbounds i8* (%struct.B*, i32)*, i8* (%struct.B*, i32)** %[[VFTABLE]], i64 0
190 // CHECK: %[[VFUN_VALUE:.*]] = load i8* (%struct.B*, i32)*, i8* (%struct.B*, i32)** %[[VFUN]]
191 //
192 // CHECK: %[[OBJ_i8:.*]] = bitcast %struct.B* %[[OBJ]] to i8*
193 // CHECK: %[[VBPTR:.*]] = getelementptr inbounds i8, i8* %[[OBJ_i8]], i32 0
194 // CHECK: %[[VBPTR8:.*]] = bitcast i8* %[[VBPTR]] to i32**
195 // CHECK: %[[VBTABLE:.*]] = load i32*, i32** %[[VBPTR8]]
196 // CHECK: %[[VBENTRY:.*]] = getelementptr inbounds i32, i32* %[[VBTABLE]], i32 1
197 // CHECK: %[[VBOFFSET32:.*]] = load i32, i32* %[[VBENTRY]]
198 // CHECK: %[[VBOFFSET:.*]] = add nsw i32 0, %[[VBOFFSET32]]
199 // CHECK: %[[VBASE_i8:.*]] = getelementptr inbounds i8, i8* %[[OBJ_i8]], i32 %[[VBOFFSET]]
200 // CHECK: %[[VBASE:.*]] = bitcast i8* %[[VBASE_i8]] to %struct.B*
201 //
202 // CHECK: call x86_thiscallcc i8* %[[VFUN_VALUE]](%struct.B* %[[VBASE]], i32 1)
203 // CHECK: ret void
204 }
205 
call_complete_dtor()206 void call_complete_dtor() {
207   // CHECK-LABEL: define void @"\01?call_complete_dtor@@YAXXZ"
208   B b;
209   // CHECK: call x86_thiscallcc %struct.B* @"\01??0B@@QAE@XZ"(%struct.B* %[[B:.*]], i32 1)
210   // CHECK-NOT: getelementptr
211   // CHECK: call x86_thiscallcc void @"\01??_DB@@UAE@XZ"(%struct.B* %[[B]])
212   // CHECK: ret
213 }
214 
215 struct C : B {
216   C();
217   // has an implicit vdtor.
218 };
219 
220 // Used to crash on an assertion.
C()221 C::C() {
222 // CHECK-LABEL: define x86_thiscallcc %struct.C* @"\01??0C@@QAE@XZ"
223 }
224 
225 namespace multiple_vbases {
226 struct A {
227   virtual void a();
228 };
229 
230 struct B {
231   virtual void b();
232 };
233 
234 struct C {
235   virtual void c();
236 };
237 
238 struct D : virtual A, virtual B, virtual C {
239   virtual void a();
240   virtual void b();
241   virtual void c();
242   D();
243 };
244 
D()245 D::D() {
246   // CHECK-LABEL: define x86_thiscallcc %"struct.multiple_vbases::D"* @"\01??0D@multiple_vbases@@QAE@XZ"
247   // Just make sure we emit 3 vtordisps after initializing vfptrs.
248   // CHECK: store i32 (...)** bitcast ([1 x i8*]* @"\01??_7D@multiple_vbases@@6BA@1@@" to i32 (...)**), i32 (...)*** %{{.*}}
249   // CHECK: store i32 (...)** bitcast ([1 x i8*]* @"\01??_7D@multiple_vbases@@6BB@1@@" to i32 (...)**), i32 (...)*** %{{.*}}
250   // CHECK: store i32 (...)** bitcast ([1 x i8*]* @"\01??_7D@multiple_vbases@@6BC@1@@" to i32 (...)**), i32 (...)*** %{{.*}}
251   // ...
252   // CHECK: store i32 %{{.*}}, i32* %{{.*}}
253   // CHECK: store i32 %{{.*}}, i32* %{{.*}}
254   // CHECK: store i32 %{{.*}}, i32* %{{.*}}
255   // CHECK: ret
256 }
257 }
258 
259 namespace diamond {
260 struct A {
261   A();
262   virtual ~A();
263 };
264 
265 struct B : virtual A {
266   B();
267   ~B();
268 };
269 
270 struct C : virtual A {
271   C();
272   ~C();
273   int c1, c2, c3;
274 };
275 
276 struct Z {
277   int z;
278 };
279 
280 struct D : virtual Z, B, C {
281   D();
282   ~D();
283 } d;
284 
~D()285 D::~D() {
286   // CHECK-LABEL: define x86_thiscallcc void @"\01??1D@diamond@@UAE@XZ"(%"struct.diamond::D"*)
287   // CHECK: %[[ARG_i8:.*]] = bitcast %"struct.diamond::D"* %{{.*}} to i8*
288   // CHECK: %[[THIS_i8:.*]] = getelementptr inbounds i8, i8* %[[ARG_i8]], i32 -24
289   // CHECK: %[[THIS:.*]] = bitcast i8* %[[THIS_i8]] to %"struct.diamond::D"*
290   // CHECK: store %"struct.diamond::D"* %[[THIS]], %"struct.diamond::D"** %[[THIS_VAL:.*]], align 4
291   // CHECK: %[[THIS:.*]] = load %"struct.diamond::D"*, %"struct.diamond::D"** %[[THIS_VAL]]
292   // CHECK: %[[D_i8:.*]] = bitcast %"struct.diamond::D"* %[[THIS]] to i8*
293   // CHECK: %[[C_i8:.*]] = getelementptr inbounds i8, i8* %[[D_i8]], i32 4
294   // CHECK: %[[C:.*]] = bitcast i8* %[[C_i8]] to %"struct.diamond::C"*
295   // CHECK: %[[C_i8:.*]] = bitcast %"struct.diamond::C"* %[[C]] to i8*
296   // CHECK: %[[ARG_i8:.*]] = getelementptr i8, i8* %{{.*}}, i32 16
297   // FIXME: We might consider changing the dtor this parameter type to i8*.
298   // CHECK: %[[ARG:.*]] = bitcast i8* %[[ARG_i8]] to %"struct.diamond::C"*
299   // CHECK: call x86_thiscallcc void @"\01??1C@diamond@@UAE@XZ"(%"struct.diamond::C"* %[[ARG]])
300 
301   // CHECK: %[[B:.*]] = bitcast %"struct.diamond::D"* %[[THIS]] to %"struct.diamond::B"*
302   // CHECK: %[[B_i8:.*]] = bitcast %"struct.diamond::B"* %[[B]] to i8*
303   // CHECK: %[[ARG_i8:.*]] = getelementptr i8, i8* %[[B_i8]], i32 4
304   // CHECK: %[[ARG:.*]] = bitcast i8* %[[ARG_i8]] to %"struct.diamond::B"*
305   // CHECK: call x86_thiscallcc void @"\01??1B@diamond@@UAE@XZ"(%"struct.diamond::B"* %[[ARG]])
306   // CHECK: ret void
307 }
308 
309 }
310 
311 namespace test2 {
312 struct A { A(); };
Btest2::B313 struct B : virtual A { B() {} };
Ctest2::C314 struct C : B, A { C() {} };
315 
316 // PR18435: Order mattered here.  We were generating code for the delegating
317 // call to B() from C().
callC()318 void callC() { C x; }
319 
320 // CHECK-LABEL: define linkonce_odr x86_thiscallcc %"struct.test2::C"* @"\01??0C@test2@@QAE@XZ"
321 // CHECK:           (%"struct.test2::C"* returned %this, i32 %is_most_derived)
322 // CHECK: br i1
323 //   Virtual bases
324 // CHECK: call x86_thiscallcc %"struct.test2::A"* @"\01??0A@test2@@QAE@XZ"(%"struct.test2::A"* %{{.*}})
325 // CHECK: br label
326 //   Non-virtual bases
327 // CHECK: call x86_thiscallcc %"struct.test2::B"* @"\01??0B@test2@@QAE@XZ"(%"struct.test2::B"* %{{.*}}, i32 0)
328 // CHECK: call x86_thiscallcc %"struct.test2::A"* @"\01??0A@test2@@QAE@XZ"(%"struct.test2::A"* %{{.*}})
329 // CHECK: ret
330 
331 // CHECK2-LABEL: define linkonce_odr x86_thiscallcc %"struct.test2::B"* @"\01??0B@test2@@QAE@XZ"
332 // CHECK2:           (%"struct.test2::B"* returned %this, i32 %is_most_derived)
333 // CHECK2: call x86_thiscallcc %"struct.test2::A"* @"\01??0A@test2@@QAE@XZ"(%"struct.test2::A"* %{{.*}})
334 // CHECK2: ret
335 
336 }
337 
338 namespace test3 {
339 // PR19104: A non-virtual call of a virtual method doesn't use vftable thunks,
340 // so requires only static adjustment which is different to the one used
341 // for virtual calls.
342 struct A {
343   virtual void foo();
344 };
345 
346 struct B : virtual A {
347   virtual void bar();
348 };
349 
350 struct C : virtual A {
351   virtual void foo();
352 };
353 
354 struct D : B, C {
355   virtual void bar();
356   int field;  // Laid out between C and A subobjects in D.
357 };
358 
bar()359 void D::bar() {
360   // CHECK-LABEL: define x86_thiscallcc void @"\01?bar@D@test3@@UAEXXZ"(%"struct.test3::D"* %this)
361 
362   C::foo();
363   // Shouldn't need any vbtable lookups.  All we have to do is adjust to C*,
364   // then compensate for the adjustment performed in the C::foo() prologue.
365   // CHECK-NOT: load i8*, i8**
366   // CHECK: %[[OBJ_i8:.*]] = bitcast %"struct.test3::D"* %{{.*}} to i8*
367   // CHECK: %[[C_i8:.*]] = getelementptr inbounds i8, i8* %[[OBJ_i8]], i32 8
368   // CHECK: %[[C:.*]] = bitcast i8* %[[C_i8]] to %"struct.test3::C"*
369   // CHECK: %[[C_i8:.*]] = bitcast %"struct.test3::C"* %[[C]] to i8*
370   // CHECK: %[[ARG:.*]] = getelementptr i8, i8* %[[C_i8]], i32 4
371   // CHECK: call x86_thiscallcc void @"\01?foo@C@test3@@UAEXXZ"(i8* %[[ARG]])
372   // CHECK: ret
373 }
374 }
375 
376 namespace test4{
377 // PR19172: We used to merge method vftable locations wrong.
378 
379 struct A {
~Atest4::A380   virtual ~A() {}
381 };
382 
383 struct B {
~Btest4::B384   virtual ~B() {}
385 };
386 
387 struct C : virtual A, B {
388   virtual ~C();
389 };
390 
391 void foo(void*);
392 
~C()393 C::~C() {
394   // CHECK-LABEL: define x86_thiscallcc void @"\01??1C@test4@@UAE@XZ"(%"struct.test4::C"* %this)
395 
396   // In this case "this" points to the most derived class, so no GEPs needed.
397   // CHECK-NOT: getelementptr
398   // CHECK-NOT: bitcast
399   // CHECK: %[[VFPTR_i8:.*]] = bitcast %"struct.test4::C"* %{{.*}} to i32 (...)***
400   // CHECK: store i32 (...)** bitcast ([1 x i8*]* @"\01??_7C@test4@@6BB@1@@" to i32 (...)**), i32 (...)*** %[[VFPTR_i8]]
401 
402   foo(this);
403   // CHECK: ret
404 }
405 
destroy(C * obj)406 void destroy(C *obj) {
407   // CHECK-LABEL: define void @"\01?destroy@test4@@YAXPAUC@1@@Z"(%"struct.test4::C"* %obj)
408 
409   delete obj;
410   // CHECK: %[[VPTR:.*]] = bitcast %"struct.test4::C"* %[[OBJ:.*]] to i8* (%"struct.test4::C"*, i32)***
411   // CHECK: %[[VFTABLE:.*]] = load i8* (%"struct.test4::C"*, i32)**, i8* (%"struct.test4::C"*, i32)*** %[[VPTR]]
412   // CHECK: %[[VFTENTRY:.*]] = getelementptr inbounds i8* (%"struct.test4::C"*, i32)*, i8* (%"struct.test4::C"*, i32)** %[[VFTABLE]], i64 0
413   // CHECK: %[[VFUN:.*]] = load i8* (%"struct.test4::C"*, i32)*, i8* (%"struct.test4::C"*, i32)** %[[VFTENTRY]]
414   // CHECK: call x86_thiscallcc i8* %[[VFUN]](%"struct.test4::C"* %[[OBJ]], i32 1)
415   // CHECK: ret
416 }
417 
418 struct D {
419   virtual void d();
420 };
421 
422 // The first non-virtual base doesn't have a vdtor,
423 // but "this adjustment" is not needed.
424 struct E : D, B, virtual A {
425   virtual ~E();
426 };
427 
~E()428 E::~E() {
429   // CHECK-LABEL: define x86_thiscallcc void @"\01??1E@test4@@UAE@XZ"(%"struct.test4::E"* %this)
430 
431   // In this case "this" points to the most derived class, so no GEPs needed.
432   // CHECK-NOT: getelementptr
433   // CHECK-NOT: bitcast
434   // CHECK: %[[VFPTR_i8:.*]] = bitcast %"struct.test4::E"* %{{.*}} to i32 (...)***
435   // CHECK: store i32 (...)** bitcast ([1 x i8*]* @"\01??_7E@test4@@6BD@1@@" to i32 (...)**), i32 (...)*** %[[VFPTR_i8]]
436   foo(this);
437 }
438 
destroy(E * obj)439 void destroy(E *obj) {
440   // CHECK-LABEL: define void @"\01?destroy@test4@@YAXPAUE@1@@Z"(%"struct.test4::E"* %obj)
441 
442   // CHECK-NOT: getelementptr
443   // CHECK: %[[OBJ_i8:.*]] = bitcast %"struct.test4::E"* %[[OBJ:.*]] to i8*
444   // CHECK: %[[B_i8:.*]] = getelementptr inbounds i8, i8* %[[OBJ_i8]], i32 4
445   // CHECK: %[[VPTR:.*]] = bitcast i8* %[[B_i8]] to i8* (%"struct.test4::E"*, i32)***
446   // CHECK: %[[VFTABLE:.*]] = load i8* (%"struct.test4::E"*, i32)**, i8* (%"struct.test4::E"*, i32)*** %[[VPTR]]
447   // CHECK: %[[VFTENTRY:.*]] = getelementptr inbounds i8* (%"struct.test4::E"*, i32)*, i8* (%"struct.test4::E"*, i32)** %[[VFTABLE]], i64 0
448   // CHECK: %[[VFUN:.*]] = load i8* (%"struct.test4::E"*, i32)*, i8* (%"struct.test4::E"*, i32)** %[[VFTENTRY]]
449   // CHECK: %[[OBJ_i8:.*]] = bitcast %"struct.test4::E"* %[[OBJ]] to i8*
450   // CHECK: %[[B_i8:.*]] = getelementptr inbounds i8, i8* %[[OBJ_i8]], i32 4
451   // FIXME: in fact, the call should take i8* and the bitcast is redundant.
452   // CHECK: %[[B_as_E:.*]] = bitcast i8* %[[B_i8]] to %"struct.test4::E"*
453   // CHECK: call x86_thiscallcc i8* %[[VFUN]](%"struct.test4::E"* %[[B_as_E]], i32 1)
454   delete obj;
455 }
456 
457 }
458 
459 namespace test5 {
460 // PR25370: Don't zero-initialize vbptrs in virtual bases.
461 struct A {
462   virtual void f();
463 };
464 
465 struct B : virtual A {
466   int Field;
467 };
468 
469 struct C : B {
470   C();
471 };
472 
C()473 C::C() : B() {}
474 // CHECK-LABEL: define x86_thiscallcc %"struct.test5::C"* @"\01??0C@test5@@QAE@XZ"(
475 // CHECK:   %[[THIS:.*]] = load %"struct.test5::C"*, %"struct.test5::C"**
476 // CHECK:   br i1 %{{.*}}, label %[[INIT_VBASES:.*]], label %[[SKIP_VBASES:.*]]
477 
478 // CHECK: %[[SKIP_VBASES]]
479 // CHECK:   %[[B:.*]] = bitcast %"struct.test5::C"* %[[THIS]] to %"struct.test5::B"*
480 // CHECK:   %[[B_i8:.*]] = bitcast %"struct.test5::B"* %[[B]] to i8*
481 // CHECK:   %[[FIELD:.*]] = getelementptr inbounds i8, i8* %[[B_i8]], i32 4
482 // CHECK:   call void @llvm.memset.p0i8.i32(i8* %[[FIELD]], i8 0, i32 4, i32 4, i1 false)
483 }
484 
485 namespace pr27621 {
486 // Devirtualization through a static_cast used to make us compute the 'this'
487 // adjustment for B::g instead of C::g. When we directly call C::g, 'this' is a
488 // B*, and the prologue of C::g will adjust it to a C*.
489 struct A { virtual void f(); };
490 struct B { virtual void g(); };
491 struct C final : A, B {
492   virtual void h();
493   void g() override;
494 };
callit(C * p)495 void callit(C *p) {
496   static_cast<B*>(p)->g();
497 }
498 // CHECK-LABEL: define void @"\01?callit@pr27621@@YAXPAUC@1@@Z"(%"struct.pr27621::C"* %{{.*}})
499 // CHECK: %[[B_i8:.*]] = getelementptr i8, i8* %{{.*}}, i32 4
500 // CHECK: call x86_thiscallcc void @"\01?g@C@pr27621@@UAEXXZ"(i8* %[[B_i8]])
501 }
502 
503 namespace test6 {
504 class A {};
505 class B : virtual A {};
506 class C : virtual B {
507   virtual void m_fn1();
508   float field;
509 };
510 class D : C {
511   D();
512 };
D()513 D::D() : C() {}
514 // CHECK-LABEL: define x86_thiscallcc %"class.test6::D"* @"\01??0D@test6@@AAE@XZ"(
515 // CHECK:   %[[THIS:.*]] = load %"class.test6::D"*, %"class.test6::D"**
516 // CHECK:   br i1 %{{.*}}, label %[[INIT_VBASES:.*]], label %[[SKIP_VBASES:.*]]
517 
518 // CHECK: %[[SKIP_VBASES]]
519 // CHECK:   %[[C:.*]] = bitcast %"class.test6::D"* %[[THIS]] to %"class.test6::C"*
520 // CHECK:   %[[C_i8:.*]] = bitcast %"class.test6::C"* %[[C]] to i8*
521 // CHECK:   %[[FIELD:.*]] = getelementptr inbounds i8, i8* %[[C_i8]], i32 8
522 // CHECK:   call void @llvm.memset.p0i8.i32(i8* %[[FIELD]], i8 0, i32 4, i32 4, i1 false)
523 }
524