1 // RUN: %clang_cc1 -std=c++11 -Wno-uninitialized -fno-rtti -emit-llvm %s -o - -triple=i386-pc-win32 -fms-extensions | FileCheck %s
2 // RUN: %clang_cc1 -std=c++11 -Wno-uninitialized -fno-rtti -emit-llvm %s -o - -triple=x86_64-pc-win32 -fms-extensions | FileCheck %s -check-prefix=X64
3 // RUN: %clang_cc1 -std=c++11 -Wno-uninitialized -fno-rtti -emit-llvm %s -o - -triple=i386-pc-win32 -DINCOMPLETE_VIRTUAL -fms-extensions -verify
4 // RUN: %clang_cc1 -std=c++11 -Wno-uninitialized -fno-rtti -emit-llvm %s -o - -triple=i386-pc-win32 -DINCOMPLETE_VIRTUAL -DMEMFUN -fms-extensions -verify
5
6 struct PR26313_Y;
7 typedef void (PR26313_Y::*PR26313_FUNC)();
8 struct PR26313_X {
9 PR26313_FUNC *ptr;
10 PR26313_X();
11 };
PR26313_X()12 PR26313_X::PR26313_X() {}
PR26313_f(PR26313_FUNC * p)13 void PR26313_f(PR26313_FUNC *p) { delete p; }
14
15 struct PR26313_Z;
16 int PR26313_Z::**a = nullptr;
17 int PR26313_Z::*b = *a;
18 // CHECK-DAG: @"\01?a@@3PAPQPR26313_Z@@HA" = global %0* null, align 4
19 // CHECK-DAG: @"\01?b@@3PQPR26313_Z@@HQ1@" = global { i32, i32, i32 } { i32 0, i32 0, i32 -1 }, align 4
20
21 namespace PR20947 {
22 struct A;
23 int A::**a = nullptr;
24 // CHECK-DAG: @"\01?a@PR20947@@3PAPQA@1@HA" = global %{{.*}}* null, align 4
25
26 struct B;
27 int B::*&b = b;
28 // CHECK-DAG: @"\01?b@PR20947@@3AAPQB@1@HA" = global %{{.*}}* null, align 4
29 }
30
31 namespace PR20017 {
32 template <typename T>
33 struct A {
m_fn1PR20017::A34 int T::*m_fn1() { return nullptr; }
35 };
36 struct B;
37 auto a = &A<B>::m_fn1;
38 // CHECK-DAG: @"\01?a@PR20017@@3P8?$A@UB@PR20017@@@1@AEPQB@1@HXZQ21@" = global i8* bitcast ({ i32, i32, i32 } ({{.*}}*)* @"\01?m_fn1@?$A@UB@PR20017@@@PR20017@@QAEPQB@2@HXZ" to i8*), align 4
39 }
40
41 #ifndef INCOMPLETE_VIRTUAL
42 struct B1 {
43 void foo();
44 int b;
45 };
46 struct B2 {
47 int b2;
48 void foo();
49 };
50 struct Single : B1 {
51 void foo();
52 };
53 struct Multiple : B1, B2 {
54 int m;
55 void foo();
56 };
57 struct Virtual : virtual B1 {
58 int v;
59 void foo();
60 };
61
62 struct POD {
63 int a;
64 int b;
65 };
66
67 struct Polymorphic {
68 virtual void myVirtual();
69 int a;
70 int b;
71 };
72
73 // This class uses the virtual inheritance model, yet its vbptr offset is not 0.
74 // We still use zero for the null field offset, despite it being a valid field
75 // offset.
76 struct NonZeroVBPtr : POD, Virtual {
77 int n;
78 void foo();
79 };
80
81 struct Unspecified;
82 struct UnspecSingle;
83
84 // Check that we can lower the LLVM types and get the null initializers right.
85 int Single ::*s_d_memptr;
86 int Polymorphic::*p_d_memptr;
87 int Multiple ::*m_d_memptr;
88 int Virtual ::*v_d_memptr;
89 int NonZeroVBPtr::*n_d_memptr;
90 int Unspecified::*u_d_memptr;
91 int UnspecSingle::*us_d_memptr;
92 // CHECK: @"\01?s_d_memptr@@3PQSingle@@HQ1@" = global i32 -1, align 4
93 // CHECK: @"\01?p_d_memptr@@3PQPolymorphic@@HQ1@" = global i32 0, align 4
94 // CHECK: @"\01?m_d_memptr@@3PQMultiple@@HQ1@" = global i32 -1, align 4
95 // CHECK: @"\01?v_d_memptr@@3PQVirtual@@HQ1@" = global { i32, i32 }
96 // CHECK: { i32 0, i32 -1 }, align 4
97 // CHECK: @"\01?n_d_memptr@@3PQNonZeroVBPtr@@HQ1@" = global { i32, i32 }
98 // CHECK: { i32 0, i32 -1 }, align 4
99 // CHECK: @"\01?u_d_memptr@@3PQUnspecified@@HQ1@" = global { i32, i32, i32 }
100 // CHECK: { i32 0, i32 0, i32 -1 }, align 4
101 // CHECK: @"\01?us_d_memptr@@3PQUnspecSingle@@HQ1@" = global { i32, i32, i32 }
102 // CHECK: { i32 0, i32 0, i32 -1 }, align 4
103
104 void (Single ::*s_f_memptr)();
105 void (Multiple::*m_f_memptr)();
106 void (Virtual ::*v_f_memptr)();
107 // CHECK: @"\01?s_f_memptr@@3P8Single@@AEXXZQ1@" = global i8* null, align 4
108 // CHECK: @"\01?m_f_memptr@@3P8Multiple@@AEXXZQ1@" = global { i8*, i32 } zeroinitializer, align 4
109 // CHECK: @"\01?v_f_memptr@@3P8Virtual@@AEXXZQ1@" = global { i8*, i32, i32 } zeroinitializer, align 4
110
111 // We can define Unspecified after locking in the inheritance model.
112 struct Unspecified : Multiple, Virtual {
113 void foo();
114 int u;
115 };
116
117 struct UnspecSingle {
118 void foo();
119 };
120
121 // Test memptr emission in a constant expression.
122 namespace Const {
123 void (Single ::*s_f_mp)() = &Single::foo;
124 void (Multiple ::*m_f_mp)() = &B2::foo;
125 void (Virtual ::*v_f_mp)() = &Virtual::foo;
126 void (Unspecified::*u_f_mp)() = &Unspecified::foo;
127 void (UnspecSingle::*us_f_mp)() = &UnspecSingle::foo;
128 // CHECK: @"\01?s_f_mp@Const@@3P8Single@@AEXXZQ2@" =
129 // CHECK: global i8* bitcast ({{.*}} @"\01?foo@Single@@QAEXXZ" to i8*), align 4
130 // CHECK: @"\01?m_f_mp@Const@@3P8Multiple@@AEXXZQ2@" =
131 // CHECK: global { i8*, i32 } { i8* bitcast ({{.*}} @"\01?foo@B2@@QAEXXZ" to i8*), i32 4 }, align 4
132 // CHECK: @"\01?v_f_mp@Const@@3P8Virtual@@AEXXZQ2@" =
133 // CHECK: global { i8*, i32, i32 } { i8* bitcast ({{.*}} @"\01?foo@Virtual@@QAEXXZ" to i8*), i32 0, i32 0 }, align 4
134 // CHECK: @"\01?u_f_mp@Const@@3P8Unspecified@@AEXXZQ2@" =
135 // CHECK: global { i8*, i32, i32, i32 } { i8* bitcast ({{.*}} @"\01?foo@Unspecified@@QAEXXZ" to i8*), i32 0, i32 0, i32 0 }, align 4
136 // CHECK: @"\01?us_f_mp@Const@@3P8UnspecSingle@@AEXXZQ2@" =
137 // CHECK: global { i8*, i32, i32, i32 } { i8* bitcast ({{.*}} @"\01?foo@UnspecSingle@@QAEXXZ" to i8*), i32 0, i32 0, i32 0 }, align 4
138 }
139
140 namespace CastParam {
141 // This exercises ConstExprEmitter instead of ValueDecl::evaluateValue. The
142 // extra reinterpret_cast for the parameter type requires more careful folding.
143 // FIXME: Or does it? If reinterpret_casts are no-ops, we should be able to
144 // strip them in evaluateValue() and just proceed as normal with an APValue.
145 struct A {
146 int a;
147 void foo(A *p);
148 };
149 struct B { int b; };
150 struct C : B, A { int c; };
151
152 void (A::*ptr1)(void *) = (void (A::*)(void *)) &A::foo;
153 // CHECK: @"\01?ptr1@CastParam@@3P8A@1@AEXPAX@ZQ21@" =
154 // CHECK: global i8* bitcast (void ({{.*}})* @"\01?foo@A@CastParam@@QAEXPAU12@@Z" to i8*), align 4
155
156 // Try a reinterpret_cast followed by a memptr conversion.
157 void (C::*ptr2)(void *) = (void (C::*)(void *)) (void (A::*)(void *)) &A::foo;
158 // CHECK: @"\01?ptr2@CastParam@@3P8C@1@AEXPAX@ZQ21@" =
159 // CHECK: global { i8*, i32 } { i8* bitcast (void ({{.*}})* @"\01?foo@A@CastParam@@QAEXPAU12@@Z" to i8*), i32 4 }, align 4
160
161 void (C::*ptr3)(void *) = (void (C::*)(void *)) (void (A::*)(void *)) (void (A::*)(A *)) 0;
162 // CHECK: @"\01?ptr3@CastParam@@3P8C@1@AEXPAX@ZQ21@" =
163 // CHECK: global { i8*, i32 } zeroinitializer, align 4
164
165 struct D : C {
166 virtual void isPolymorphic();
167 int d;
168 };
169
170 // Try a cast that changes the inheritance model. Null for D is 0, but null for
171 // C is -1. We need the cast to long in order to hit the non-APValue path.
172 int C::*ptr4 = (int C::*) (int D::*) (long D::*) 0;
173 // CHECK: @"\01?ptr4@CastParam@@3PQC@1@HQ21@" = global i32 -1, align 4
174
175 // MSVC rejects this but we accept it.
176 int C::*ptr5 = (int C::*) (long D::*) 0;
177 // CHECK: @"\01?ptr5@CastParam@@3PQC@1@HQ21@" = global i32 -1, align 4
178 }
179
180 struct UnspecWithVBPtr;
181 int UnspecWithVBPtr::*forceUnspecWithVBPtr;
182 struct UnspecWithVBPtr : B1, virtual B2 {
183 int u;
184 void foo();
185 };
186
187 // Test emitting non-virtual member pointers in a non-constexpr setting.
EmitNonVirtualMemberPointers()188 void EmitNonVirtualMemberPointers() {
189 void (Single ::*s_f_memptr)() = &Single::foo;
190 void (Multiple ::*m_f_memptr)() = &Multiple::foo;
191 void (Virtual ::*v_f_memptr)() = &Virtual::foo;
192 void (Unspecified::*u_f_memptr)() = &Unspecified::foo;
193 void (UnspecWithVBPtr::*u2_f_memptr)() = &UnspecWithVBPtr::foo;
194 // CHECK: define void @"\01?EmitNonVirtualMemberPointers@@YAXXZ"() {{.*}} {
195 // CHECK: alloca i8*, align 4
196 // CHECK: alloca { i8*, i32 }, align 4
197 // CHECK: alloca { i8*, i32, i32 }, align 4
198 // CHECK: alloca { i8*, i32, i32, i32 }, align 4
199 // CHECK: store i8* bitcast (void (%{{.*}}*)* @"\01?foo@Single@@QAEXXZ" to i8*), i8** %{{.*}}, align 4
200 // CHECK: store { i8*, i32 }
201 // CHECK: { i8* bitcast (void (%{{.*}}*)* @"\01?foo@Multiple@@QAEXXZ" to i8*), i32 0 },
202 // CHECK: { i8*, i32 }* %{{.*}}, align 4
203 // CHECK: store { i8*, i32, i32 }
204 // CHECK: { i8* bitcast (void (%{{.*}}*)* @"\01?foo@Virtual@@QAEXXZ" to i8*), i32 0, i32 0 },
205 // CHECK: { i8*, i32, i32 }* %{{.*}}, align 4
206 // CHECK: store { i8*, i32, i32, i32 }
207 // CHECK: { i8* bitcast (void (%{{.*}}*)* @"\01?foo@Unspecified@@QAEXXZ" to i8*), i32 0, i32 0, i32 0 },
208 // CHECK: { i8*, i32, i32, i32 }* %{{.*}}, align 4
209 // CHECK: store { i8*, i32, i32, i32 }
210 // CHECK: { i8* bitcast (void (%{{.*}}*)* @"\01?foo@UnspecWithVBPtr@@QAEXXZ" to i8*),
211 // CHECK: i32 0, i32 0, i32 0 },
212 // CHECK: { i8*, i32, i32, i32 }* %{{.*}}, align 4
213 // CHECK: ret void
214 // CHECK: }
215 }
216
podMemPtrs()217 void podMemPtrs() {
218 int POD::*memptr;
219 memptr = &POD::a;
220 memptr = &POD::b;
221 if (memptr)
222 memptr = 0;
223 // Check that member pointers use the right offsets and that null is -1.
224 // CHECK: define void @"\01?podMemPtrs@@YAXXZ"() {{.*}} {
225 // CHECK: %[[memptr:.*]] = alloca i32, align 4
226 // CHECK-NEXT: store i32 0, i32* %[[memptr]], align 4
227 // CHECK-NEXT: store i32 4, i32* %[[memptr]], align 4
228 // CHECK-NEXT: %[[memptr_val:.*]] = load i32, i32* %[[memptr]], align 4
229 // CHECK-NEXT: %{{.*}} = icmp ne i32 %[[memptr_val]], -1
230 // CHECK-NEXT: br i1 %{{.*}}, label %{{.*}}, label %{{.*}}
231 // CHECK: store i32 -1, i32* %[[memptr]], align 4
232 // CHECK: ret void
233 // CHECK: }
234 }
235
polymorphicMemPtrs()236 void polymorphicMemPtrs() {
237 int Polymorphic::*memptr;
238 memptr = &Polymorphic::a;
239 memptr = &Polymorphic::b;
240 if (memptr)
241 memptr = 0;
242 // Member pointers for polymorphic classes include the vtable slot in their
243 // offset and use 0 to represent null.
244 // CHECK: define void @"\01?polymorphicMemPtrs@@YAXXZ"() {{.*}} {
245 // CHECK: %[[memptr:.*]] = alloca i32, align 4
246 // CHECK-NEXT: store i32 4, i32* %[[memptr]], align 4
247 // CHECK-NEXT: store i32 8, i32* %[[memptr]], align 4
248 // CHECK-NEXT: %[[memptr_val:.*]] = load i32, i32* %[[memptr]], align 4
249 // CHECK-NEXT: %{{.*}} = icmp ne i32 %[[memptr_val]], 0
250 // CHECK-NEXT: br i1 %{{.*}}, label %{{.*}}, label %{{.*}}
251 // CHECK: store i32 0, i32* %[[memptr]], align 4
252 // CHECK: ret void
253 // CHECK: }
254 }
255
nullTestDataUnspecified(int Unspecified::* mp)256 bool nullTestDataUnspecified(int Unspecified::*mp) {
257 return mp;
258 // CHECK: define zeroext i1 @"\01?nullTestDataUnspecified@@YA_NPQUnspecified@@H@Z"{{.*}} {
259 // CHECK: %{{.*}} = load { i32, i32, i32 }, { i32, i32, i32 }* %{{.*}}, align 4
260 // CHECK: store { i32, i32, i32 } {{.*}} align 4
261 // CHECK: %[[mp:.*]] = load { i32, i32, i32 }, { i32, i32, i32 }* %{{.*}}, align 4
262 // CHECK: %[[mp0:.*]] = extractvalue { i32, i32, i32 } %[[mp]], 0
263 // CHECK: %[[cmp0:.*]] = icmp ne i32 %[[mp0]], 0
264 // CHECK: %[[mp1:.*]] = extractvalue { i32, i32, i32 } %[[mp]], 1
265 // CHECK: %[[cmp1:.*]] = icmp ne i32 %[[mp1]], 0
266 // CHECK: %[[and0:.*]] = or i1 %[[cmp0]], %[[cmp1]]
267 // CHECK: %[[mp2:.*]] = extractvalue { i32, i32, i32 } %[[mp]], 2
268 // CHECK: %[[cmp2:.*]] = icmp ne i32 %[[mp2]], -1
269 // CHECK: %[[and1:.*]] = or i1 %[[and0]], %[[cmp2]]
270 // CHECK: ret i1 %[[and1]]
271 // CHECK: }
272
273 // Pass this large type indirectly.
274 // X64-LABEL: define zeroext i1 @"\01?nullTestDataUnspecified@@
275 // X64: ({ i32, i32, i32 }*)
276 }
277
nullTestFunctionUnspecified(void (Unspecified::* mp)())278 bool nullTestFunctionUnspecified(void (Unspecified::*mp)()) {
279 return mp;
280 // CHECK: define zeroext i1 @"\01?nullTestFunctionUnspecified@@YA_NP8Unspecified@@AEXXZ@Z"{{.*}} {
281 // CHECK: %{{.*}} = load { i8*, i32, i32, i32 }, { i8*, i32, i32, i32 }* %{{.*}}, align 4
282 // CHECK: store { i8*, i32, i32, i32 } {{.*}} align 4
283 // CHECK: %[[mp:.*]] = load { i8*, i32, i32, i32 }, { i8*, i32, i32, i32 }* %{{.*}}, align 4
284 // CHECK: %[[mp0:.*]] = extractvalue { i8*, i32, i32, i32 } %[[mp]], 0
285 // CHECK: %[[cmp0:.*]] = icmp ne i8* %[[mp0]], null
286 // CHECK: ret i1 %[[cmp0]]
287 // CHECK: }
288 }
289
loadDataMemberPointerVirtual(Virtual * o,int Virtual::* memptr)290 int loadDataMemberPointerVirtual(Virtual *o, int Virtual::*memptr) {
291 return o->*memptr;
292 // Test that we can unpack this aggregate member pointer and load the member
293 // data pointer.
294 // CHECK: define i32 @"\01?loadDataMemberPointerVirtual@@YAHPAUVirtual@@PQ1@H@Z"{{.*}} {
295 // CHECK: %[[o:.*]] = load %{{.*}}*, %{{.*}}** %{{.*}}, align 4
296 // CHECK: %[[memptr:.*]] = load { i32, i32 }, { i32, i32 }* %{{.*}}, align 4
297 // CHECK: %[[memptr0:.*]] = extractvalue { i32, i32 } %[[memptr:.*]], 0
298 // CHECK: %[[memptr1:.*]] = extractvalue { i32, i32 } %[[memptr:.*]], 1
299 // CHECK: %[[v6:.*]] = bitcast %{{.*}}* %[[o]] to i8*
300 // CHECK: %[[vbptr:.*]] = getelementptr inbounds i8, i8* %[[v6]], i32 0
301 // CHECK: %[[vbptr_a:.*]] = bitcast i8* %[[vbptr]] to i32**
302 // CHECK: %[[vbtable:.*]] = load i32*, i32** %[[vbptr_a:.*]]
303 // CHECK: %[[memptr1_shr:.*]] = ashr exact i32 %[[memptr1]], 2
304 // CHECK: %[[v7:.*]] = getelementptr inbounds i32, i32* %[[vbtable]], i32 %[[memptr1_shr]]
305 // CHECK: %[[vbase_offs:.*]] = load i32, i32* %[[v7]]
306 // CHECK: %[[v10:.*]] = getelementptr inbounds i8, i8* %[[vbptr]], i32 %[[vbase_offs]]
307 // CHECK: %[[offset:.*]] = getelementptr inbounds i8, i8* %[[v10]], i32 %[[memptr0]]
308 // CHECK: %[[v11:.*]] = bitcast i8* %[[offset]] to i32*
309 // CHECK: %[[v12:.*]] = load i32, i32* %[[v11]]
310 // CHECK: ret i32 %[[v12]]
311 // CHECK: }
312
313 // A two-field data memptr on x64 gets coerced to i64 and is passed in a
314 // register or memory.
315 // X64-LABEL: define i32 @"\01?loadDataMemberPointerVirtual@@YAHPEAUVirtual@@PEQ1@H@Z"
316 // X64: (%struct.Virtual* %o, i64 %memptr.coerce)
317 }
318
loadDataMemberPointerUnspecified(Unspecified * o,int Unspecified::* memptr)319 int loadDataMemberPointerUnspecified(Unspecified *o, int Unspecified::*memptr) {
320 return o->*memptr;
321 // Test that we can unpack this aggregate member pointer and load the member
322 // data pointer.
323 // CHECK: define i32 @"\01?loadDataMemberPointerUnspecified@@YAHPAUUnspecified@@PQ1@H@Z"{{.*}} {
324 // CHECK: %[[o:.*]] = load %{{.*}}*, %{{.*}}** %{{.*}}, align 4
325 // CHECK: %[[memptr:.*]] = load { i32, i32, i32 }, { i32, i32, i32 }* %{{.*}}, align 4
326 // CHECK: %[[memptr0:.*]] = extractvalue { i32, i32, i32 } %[[memptr:.*]], 0
327 // CHECK: %[[memptr1:.*]] = extractvalue { i32, i32, i32 } %[[memptr:.*]], 1
328 // CHECK: %[[memptr2:.*]] = extractvalue { i32, i32, i32 } %[[memptr:.*]], 2
329 // CHECK: %[[base:.*]] = bitcast %{{.*}}* %[[o]] to i8*
330 // CHECK: %[[is_vbase:.*]] = icmp ne i32 %[[memptr2]], 0
331 // CHECK: br i1 %[[is_vbase]], label %[[vadjust:.*]], label %[[skip:.*]]
332 //
333 // CHECK: [[vadjust]]
334 // CHECK: %[[vbptr:.*]] = getelementptr inbounds i8, i8* %[[base]], i32 %[[memptr1]]
335 // CHECK: %[[vbptr_a:.*]] = bitcast i8* %[[vbptr]] to i32**
336 // CHECK: %[[vbtable:.*]] = load i32*, i32** %[[vbptr_a:.*]]
337 // CHECK: %[[memptr2_shr:.*]] = ashr exact i32 %[[memptr2]], 2
338 // CHECK: %[[v7:.*]] = getelementptr inbounds i32, i32* %[[vbtable]], i32 %[[memptr2_shr]]
339 // CHECK: %[[vbase_offs:.*]] = load i32, i32* %[[v7]]
340 // CHECK: %[[base_adj:.*]] = getelementptr inbounds i8, i8* %[[vbptr]], i32 %[[vbase_offs]]
341 //
342 // CHECK: [[skip]]
343 // CHECK: %[[new_base:.*]] = phi i8* [ %[[base]], %{{.*}} ], [ %[[base_adj]], %[[vadjust]] ]
344 // CHECK: %[[offset:.*]] = getelementptr inbounds i8, i8* %[[new_base]], i32 %[[memptr0]]
345 // CHECK: %[[v11:.*]] = bitcast i8* %[[offset]] to i32*
346 // CHECK: %[[v12:.*]] = load i32, i32* %[[v11]]
347 // CHECK: ret i32 %[[v12]]
348 // CHECK: }
349 }
350
callMemberPointerSingle(Single * o,void (Single::* memptr)())351 void callMemberPointerSingle(Single *o, void (Single::*memptr)()) {
352 (o->*memptr)();
353 // Just look for an indirect thiscall.
354 // CHECK: define void @"\01?callMemberPointerSingle@@{{.*}} {{.*}} {
355 // CHECK: call x86_thiscallcc void %{{.*}}(%{{.*}} %{{.*}})
356 // CHECK: ret void
357 // CHECK: }
358
359 // X64-LABEL: define void @"\01?callMemberPointerSingle@@
360 // X64: (%struct.Single* %o, i8* %memptr)
361 // X64: bitcast i8* %{{[^ ]*}} to void (%struct.Single*)*
362 // X64: ret void
363 }
364
callMemberPointerMultiple(Multiple * o,void (Multiple::* memptr)())365 void callMemberPointerMultiple(Multiple *o, void (Multiple::*memptr)()) {
366 (o->*memptr)();
367 // CHECK: define void @"\01?callMemberPointerMultiple@@{{.*}} {
368 // CHECK: %[[memptr0:.*]] = extractvalue { i8*, i32 } %{{.*}}, 0
369 // CHECK: %[[memptr1:.*]] = extractvalue { i8*, i32 } %{{.*}}, 1
370 // CHECK: %[[this_adjusted:.*]] = getelementptr inbounds i8, i8* %{{.*}}, i32 %[[memptr1]]
371 // CHECK: %[[this:.*]] = bitcast i8* %[[this_adjusted]] to {{.*}}
372 // CHECK: %[[fptr:.*]] = bitcast i8* %[[memptr0]] to {{.*}}
373 // CHECK: call x86_thiscallcc void %[[fptr]](%{{.*}} %[[this]])
374 // CHECK: ret void
375 // CHECK: }
376 }
377
callMemberPointerVirtualBase(Virtual * o,void (Virtual::* memptr)())378 void callMemberPointerVirtualBase(Virtual *o, void (Virtual::*memptr)()) {
379 (o->*memptr)();
380 // This shares a lot with virtual data member pointers.
381 // CHECK: define void @"\01?callMemberPointerVirtualBase@@{{.*}} {
382 // CHECK: %[[memptr0:.*]] = extractvalue { i8*, i32, i32 } %{{.*}}, 0
383 // CHECK: %[[memptr1:.*]] = extractvalue { i8*, i32, i32 } %{{.*}}, 1
384 // CHECK: %[[memptr2:.*]] = extractvalue { i8*, i32, i32 } %{{.*}}, 2
385 // CHECK: %[[vbptr:.*]] = getelementptr inbounds i8, i8* %{{.*}}, i32 0
386 // CHECK: %[[vbptr_a:.*]] = bitcast i8* %[[vbptr]] to i32**
387 // CHECK: %[[vbtable:.*]] = load i32*, i32** %[[vbptr_a:.*]]
388 // CHECK: %[[memptr2_shr:.*]] = ashr exact i32 %[[memptr2]], 2
389 // CHECK: %[[v7:.*]] = getelementptr inbounds i32, i32* %[[vbtable]], i32 %[[memptr2_shr]]
390 // CHECK: %[[vbase_offs:.*]] = load i32, i32* %[[v7]]
391 // CHECK: %[[v10:.*]] = getelementptr inbounds i8, i8* %[[vbptr]], i32 %[[vbase_offs]]
392 // CHECK: %[[this_adjusted:.*]] = getelementptr inbounds i8, i8* %[[v10]], i32 %[[memptr1]]
393 // CHECK: %[[fptr:.*]] = bitcast i8* %[[memptr0]] to void ({{.*}})
394 // CHECK: %[[this:.*]] = bitcast i8* %[[this_adjusted]] to {{.*}}
395 // CHECK: call x86_thiscallcc void %[[fptr]](%{{.*}} %[[this]])
396 // CHECK: ret void
397 // CHECK: }
398 }
399
compareSingleFunctionMemptr(void (Single::* l)(),void (Single::* r)())400 bool compareSingleFunctionMemptr(void (Single::*l)(), void (Single::*r)()) {
401 return l == r;
402 // Should only be one comparison here.
403 // CHECK: define zeroext i1 @"\01?compareSingleFunctionMemptr@@YA_NP8Single@@AEXXZ0@Z"{{.*}} {
404 // CHECK-NOT: icmp
405 // CHECK: %[[r:.*]] = icmp eq
406 // CHECK-NOT: icmp
407 // CHECK: ret i1 %[[r]]
408 // CHECK: }
409
410 // X64-LABEL: define zeroext i1 @"\01?compareSingleFunctionMemptr@@
411 // X64: (i8* %{{[^,]*}}, i8* %{{[^)]*}})
412 }
413
compareNeqSingleFunctionMemptr(void (Single::* l)(),void (Single::* r)())414 bool compareNeqSingleFunctionMemptr(void (Single::*l)(), void (Single::*r)()) {
415 return l != r;
416 // Should only be one comparison here.
417 // CHECK: define zeroext i1 @"\01?compareNeqSingleFunctionMemptr@@YA_NP8Single@@AEXXZ0@Z"{{.*}} {
418 // CHECK-NOT: icmp
419 // CHECK: %[[r:.*]] = icmp ne
420 // CHECK-NOT: icmp
421 // CHECK: ret i1 %[[r]]
422 // CHECK: }
423 }
424
unspecFuncMemptrEq(void (Unspecified::* l)(),void (Unspecified::* r)())425 bool unspecFuncMemptrEq(void (Unspecified::*l)(), void (Unspecified::*r)()) {
426 return l == r;
427 // CHECK: define zeroext i1 @"\01?unspecFuncMemptrEq@@YA_NP8Unspecified@@AEXXZ0@Z"{{.*}} {
428 // CHECK: %[[lhs0:.*]] = extractvalue { i8*, i32, i32, i32 } %[[l:.*]], 0
429 // CHECK: %{{.*}} = extractvalue { i8*, i32, i32, i32 } %[[r:.*]], 0
430 // CHECK: %[[cmp0:.*]] = icmp eq i8* %[[lhs0]], %{{.*}}
431 // CHECK: %{{.*}} = extractvalue { i8*, i32, i32, i32 } %[[l]], 1
432 // CHECK: %{{.*}} = extractvalue { i8*, i32, i32, i32 } %[[r]], 1
433 // CHECK: %[[cmp1:.*]] = icmp eq i32
434 // CHECK: %{{.*}} = extractvalue { i8*, i32, i32, i32 } %[[l]], 2
435 // CHECK: %{{.*}} = extractvalue { i8*, i32, i32, i32 } %[[r]], 2
436 // CHECK: %[[cmp2:.*]] = icmp eq i32
437 // CHECK: %[[res12:.*]] = and i1 %[[cmp1]], %[[cmp2]]
438 // CHECK: %{{.*}} = extractvalue { i8*, i32, i32, i32 } %[[l]], 3
439 // CHECK: %{{.*}} = extractvalue { i8*, i32, i32, i32 } %[[r]], 3
440 // CHECK: %[[cmp3:.*]] = icmp eq i32
441 // CHECK: %[[res123:.*]] = and i1 %[[res12]], %[[cmp3]]
442 // CHECK: %[[iszero:.*]] = icmp eq i8* %[[lhs0]], null
443 // CHECK: %[[bits_or_null:.*]] = or i1 %[[res123]], %[[iszero]]
444 // CHECK: %{{.*}} = and i1 %[[bits_or_null]], %[[cmp0]]
445 // CHECK: ret i1 %{{.*}}
446 // CHECK: }
447
448 // X64-LABEL: define zeroext i1 @"\01?unspecFuncMemptrEq@@
449 // X64: ({ i8*, i32, i32, i32 }*, { i8*, i32, i32, i32 }*)
450 }
451
unspecFuncMemptrNeq(void (Unspecified::* l)(),void (Unspecified::* r)())452 bool unspecFuncMemptrNeq(void (Unspecified::*l)(), void (Unspecified::*r)()) {
453 return l != r;
454 // CHECK: define zeroext i1 @"\01?unspecFuncMemptrNeq@@YA_NP8Unspecified@@AEXXZ0@Z"{{.*}} {
455 // CHECK: %[[lhs0:.*]] = extractvalue { i8*, i32, i32, i32 } %[[l:.*]], 0
456 // CHECK: %{{.*}} = extractvalue { i8*, i32, i32, i32 } %[[r:.*]], 0
457 // CHECK: %[[cmp0:.*]] = icmp ne i8* %[[lhs0]], %{{.*}}
458 // CHECK: %{{.*}} = extractvalue { i8*, i32, i32, i32 } %[[l]], 1
459 // CHECK: %{{.*}} = extractvalue { i8*, i32, i32, i32 } %[[r]], 1
460 // CHECK: %[[cmp1:.*]] = icmp ne i32
461 // CHECK: %{{.*}} = extractvalue { i8*, i32, i32, i32 } %[[l]], 2
462 // CHECK: %{{.*}} = extractvalue { i8*, i32, i32, i32 } %[[r]], 2
463 // CHECK: %[[cmp2:.*]] = icmp ne i32
464 // CHECK: %[[res12:.*]] = or i1 %[[cmp1]], %[[cmp2]]
465 // CHECK: %{{.*}} = extractvalue { i8*, i32, i32, i32 } %[[l]], 3
466 // CHECK: %{{.*}} = extractvalue { i8*, i32, i32, i32 } %[[r]], 3
467 // CHECK: %[[cmp3:.*]] = icmp ne i32
468 // CHECK: %[[res123:.*]] = or i1 %[[res12]], %[[cmp3]]
469 // CHECK: %[[iszero:.*]] = icmp ne i8* %[[lhs0]], null
470 // CHECK: %[[bits_or_null:.*]] = and i1 %[[res123]], %[[iszero]]
471 // CHECK: %{{.*}} = or i1 %[[bits_or_null]], %[[cmp0]]
472 // CHECK: ret i1 %{{.*}}
473 // CHECK: }
474 }
475
unspecDataMemptrEq(int Unspecified::* l,int Unspecified::* r)476 bool unspecDataMemptrEq(int Unspecified::*l, int Unspecified::*r) {
477 return l == r;
478 // CHECK: define zeroext i1 @"\01?unspecDataMemptrEq@@YA_NPQUnspecified@@H0@Z"{{.*}} {
479 // CHECK: extractvalue { i32, i32, i32 } %{{.*}}, 0
480 // CHECK: extractvalue { i32, i32, i32 } %{{.*}}, 0
481 // CHECK: icmp eq i32
482 // CHECK: extractvalue { i32, i32, i32 } %{{.*}}, 1
483 // CHECK: extractvalue { i32, i32, i32 } %{{.*}}, 1
484 // CHECK: icmp eq i32
485 // CHECK: extractvalue { i32, i32, i32 } %{{.*}}, 2
486 // CHECK: extractvalue { i32, i32, i32 } %{{.*}}, 2
487 // CHECK: icmp eq i32
488 // CHECK: and i1
489 // CHECK: and i1
490 // CHECK: ret i1
491 // CHECK: }
492
493 // X64-LABEL: define zeroext i1 @"\01?unspecDataMemptrEq@@
494 // X64: ({ i32, i32, i32 }*, { i32, i32, i32 }*)
495 }
496
convertB2FuncToMultiple(void (B2::* mp)())497 void (Multiple::*convertB2FuncToMultiple(void (B2::*mp)()))() {
498 return mp;
499 // CHECK: define i64 @"\01?convertB2FuncToMultiple@@YAP8Multiple@@AEXXZP8B2@@AEXXZ@Z"{{.*}} {
500 // CHECK: store
501 // CHECK: %[[mp:.*]] = load i8*, i8** %{{.*}}, align 4
502 // CHECK: icmp ne i8* %[[mp]], null
503 // CHECK: br i1 %{{.*}} label %{{.*}}, label %{{.*}}
504 //
505 // memptr.convert: ; preds = %entry
506 // CHECK: insertvalue { i8*, i32 } undef, i8* %[[mp]], 0
507 // CHECK: insertvalue { i8*, i32 } %{{.*}}, i32 4, 1
508 // CHECK: br label
509 //
510 // memptr.converted: ; preds = %memptr.convert, %entry
511 // CHECK: phi { i8*, i32 } [ zeroinitializer, %{{.*}} ], [ {{.*}} ]
512 // CHECK: }
513 }
514
convertMultipleFuncToB2(void (Multiple::* mp)())515 void (B2::*convertMultipleFuncToB2(void (Multiple::*mp)()))() {
516 // FIXME: cl emits warning C4407 on this code because of the representation
517 // change. We might want to do the same.
518 return static_cast<void (B2::*)()>(mp);
519 // FIXME: We should return i8* instead of i32 here. The ptrtoint cast prevents
520 // LLVM from optimizing away the branch. This is likely a bug in
521 // lib/CodeGen/TargetInfo.cpp with how we classify memptr types for returns.
522 //
523 // CHECK: define i32 @"\01?convertMultipleFuncToB2@@YAP8B2@@AEXXZP8Multiple@@AEXXZ@Z"{{.*}} {
524 // CHECK: store
525 // CHECK: %[[src:.*]] = load { i8*, i32 }, { i8*, i32 }* %{{.*}}, align 4
526 // CHECK: extractvalue { i8*, i32 } %[[src]], 0
527 // CHECK: icmp ne i8* %{{.*}}, null
528 // CHECK: br i1 %{{.*}}, label %{{.*}}, label %{{.*}}
529 //
530 // memptr.convert: ; preds = %entry
531 // CHECK: %[[fp:.*]] = extractvalue { i8*, i32 } %[[src]], 0
532 // CHECK: br label
533 //
534 // memptr.converted: ; preds = %memptr.convert, %entry
535 // CHECK: phi i8* [ null, %{{.*}} ], [ %[[fp]], %{{.*}} ]
536 // CHECK: }
537 }
538
539 namespace Test1 {
540
541 struct A { int a; };
542 struct B { int b; };
543 struct C : virtual A { int c; };
544 struct D : B, C { int d; };
545
convertCToD(void (C::* mp)())546 void (D::*convertCToD(void (C::*mp)()))() {
547 return mp;
548 // CHECK: define void @"\01?convertCToD@Test1@@YAP8D@1@AEXXZP8C@1@AEXXZ@Z"{{.*}} {
549 // CHECK: store
550 // CHECK: load { i8*, i32, i32 }, { i8*, i32, i32 }* %{{.*}}, align 4
551 // CHECK: extractvalue { i8*, i32, i32 } %{{.*}}, 0
552 // CHECK: icmp ne i8* %{{.*}}, null
553 // CHECK: br i1 %{{.*}}, label %{{.*}}, label %{{.*}}
554 //
555 // memptr.convert: ; preds = %entry
556 // CHECK: extractvalue { i8*, i32, i32 } %{{.*}}, 0
557 // CHECK: %[[nvoff:.*]] = extractvalue { i8*, i32, i32 } %{{.*}}, 1
558 // CHECK: %[[vbidx:.*]] = extractvalue { i8*, i32, i32 } %{{.*}}, 2
559 // CHECK: %[[is_nvbase:.*]] = icmp eq i32 %[[vbidx]], 0
560 // CHECK: %[[nv_disp:.*]] = add nsw i32 %[[nvoff]], 4
561 // CHECK: %[[nv_adj:.*]] = select i1 %[[is_nvbase]], i32 %[[nv_disp]], i32 0
562 // CHECK: %[[dst_adj:.*]] = select i1 %[[is_nvbase]], i32 4, i32 0
563 // CHECK: %[[adj:.*]] = sub nsw i32 %[[nv_adj]], %[[dst_adj]]
564 // CHECK: insertvalue { i8*, i32, i32 } undef, i8* {{.*}}, 0
565 // CHECK: insertvalue { i8*, i32, i32 } {{.*}}, i32 %[[adj]], 1
566 // CHECK: insertvalue { i8*, i32, i32 } {{.*}}, i32 {{.*}}, 2
567 // CHECK: br label
568 //
569 // memptr.converted: ; preds = %memptr.convert, %entry
570 // CHECK: phi { i8*, i32, i32 } [ { i8* null, i32 0, i32 -1 }, {{.*}} ], [ {{.*}} ]
571 // CHECK: }
572 }
573
574 }
575
576 namespace Test2 {
577 // Test that we dynamically convert between different null reps.
578
579 struct A { int a; };
580 struct B : A { int b; };
581 struct C : A {
582 int c;
583 virtual void hasVfPtr();
584 };
585
reinterpret(int B::* mp)586 int A::*reinterpret(int B::*mp) {
587 return reinterpret_cast<int A::*>(mp);
588 // CHECK: define i32 @"\01?reinterpret@Test2@@YAPQA@1@HPQB@1@H@Z"{{.*}} {
589 // CHECK-NOT: select
590 // CHECK: ret i32
591 // CHECK: }
592 }
593
reinterpret(int C::* mp)594 int A::*reinterpret(int C::*mp) {
595 return reinterpret_cast<int A::*>(mp);
596 // CHECK: define i32 @"\01?reinterpret@Test2@@YAPQA@1@HPQC@1@H@Z"{{.*}} {
597 // CHECK: %[[mp:.*]] = load i32, i32*
598 // CHECK: %[[cmp:.*]] = icmp ne i32 %[[mp]], 0
599 // CHECK: select i1 %[[cmp]], i32 %[[mp]], i32 -1
600 // CHECK: }
601 }
602
603 }
604
605 namespace Test3 {
606 // Make sure we cast 'this' to i8* before using GEP.
607
608 struct A {
609 int a;
610 int b;
611 };
612
load_data(A * a,int A::* mp)613 int *load_data(A *a, int A::*mp) {
614 return &(a->*mp);
615 // CHECK-LABEL: define i32* @"\01?load_data@Test3@@YAPAHPAUA@1@PQ21@H@Z"{{.*}} {
616 // CHECK: %[[a:.*]] = load %"struct.Test3::A"*, %"struct.Test3::A"** %{{.*}}, align 4
617 // CHECK: %[[mp:.*]] = load i32, i32* %{{.*}}, align 4
618 // CHECK: %[[a_i8:.*]] = bitcast %"struct.Test3::A"* %[[a]] to i8*
619 // CHECK: getelementptr inbounds i8, i8* %[[a_i8]], i32 %[[mp]]
620 // CHECK: }
621 }
622
623 }
624
625 namespace Test4 {
626
627 struct A { virtual void f(); };
628 struct B { virtual void g(); };
629 struct C : A, B { virtual void g(); };
630
getmp()631 void (C::*getmp())() {
632 return &C::g;
633 }
634 // CHECK-LABEL: define i64 @"\01?getmp@Test4@@YAP8C@1@AEXXZXZ"()
635 // CHECK: store { i8*, i32 } { i8* bitcast (void (%"struct.Test4::C"*, ...)* @"\01??_9C@Test4@@$BA@AE" to i8*), i32 4 }, { i8*, i32 }* %{{.*}}
636 //
637
638 // CHECK-LABEL: define linkonce_odr x86_thiscallcc void @"\01??_9C@Test4@@$BA@AE"(%"struct.Test4::C"* %this, ...) {{.*}} comdat
639 // CHECK-NOT: getelementptr
640 // CHECK: load void (%"struct.Test4::C"*, ...)**, void (%"struct.Test4::C"*, ...)*** %{{.*}}
641 // CHECK: getelementptr inbounds void (%"struct.Test4::C"*, ...)*, void (%"struct.Test4::C"*, ...)** %{{.*}}, i64 0
642 // CHECK-NOT: getelementptr
643 // CHECK: musttail call x86_thiscallcc void (%"struct.Test4::C"*, ...) %
644
645 }
646
647 namespace pr20007 {
648 struct A {
649 void f();
650 void f(int);
651 };
652 struct B : public A {};
test()653 void test() { void (B::*a)() = &B::f; }
654 // CHECK-LABEL: define void @"\01?test@pr20007@@YAXXZ"
655 // CHECK: store i8* bitcast (void (%"struct.pr20007::A"*)* @"\01?f@A@pr20007@@QAEXXZ" to i8*)
656 }
657
658 namespace pr20007_kw {
659 struct A {
660 void f();
661 void f(int);
662 };
663 struct __single_inheritance B;
664 struct B : public A {};
test()665 void test() { void (B::*a)() = &B::f; }
666 // CHECK-LABEL: define void @"\01?test@pr20007_kw@@YAXXZ"
667 // CHECK: store i8* bitcast (void (%"struct.pr20007_kw::A"*)* @"\01?f@A@pr20007_kw@@QAEXXZ" to i8*)
668 }
669
670 namespace pr20007_pragma {
671 struct A {
672 void f();
673 void f(int);
674 };
675 struct B : public A {};
test()676 void test() { (void)(void (B::*)()) &B::f; }
677 #pragma pointers_to_members(full_generality, virtual_inheritance)
678 static_assert(sizeof(int B::*) == 4, "");
679 static_assert(sizeof(int A::*) == 4, "");
680 #pragma pointers_to_members(best_case)
681 // CHECK-LABEL: define void @"\01?test@pr20007_pragma@@YAXXZ"
682 }
683
684 namespace pr20007_pragma2 {
685 struct A {
686 };
687 struct B : public A {
688 void f();
689 };
test()690 void test() { (void)&B::f; }
691 #pragma pointers_to_members(full_generality, virtual_inheritance)
692 static_assert(sizeof(int B::*) == 4, "");
693 static_assert(sizeof(int A::*) == 12, "");
694 #pragma pointers_to_members(best_case)
695 // CHECK-LABEL: define void @"\01?test@pr20007_pragma2@@YAXXZ"
696 }
697
698 namespace pr23823 {
699 struct Base { void Method(); };
700 struct Child : Base {};
701 void use(void (Child::*const &)());
f()702 void f() { use(&Child::Method); }
703 #pragma pointers_to_members(full_generality, virtual_inheritance)
704 static_assert(sizeof(int Base::*) == 4, "");
705 static_assert(sizeof(int Child::*) == 4, "");
706 #pragma pointers_to_members(best_case)
707 }
708
709 namespace pr19987 {
710 template <typename T>
711 struct S {
712 int T::*x;
713 };
714
715 struct U : S<U> {};
716
717 static_assert(sizeof(S<U>::x) == 12, "");
718 }
719
720 #else
721 struct __virtual_inheritance A;
722 #ifdef MEMFUN
foo(A * a,int (A::* mp)())723 int foo(A *a, int (A::*mp)()) {
724 return (a->*mp)(); // expected-error{{requires a complete class type}}
725 }
726 #else
foo(A * a,int A::* mp)727 int foo(A *a, int A::*mp) {
728 return a->*mp; // expected-error{{requires a complete class type}}
729 }
730 #endif
731 #endif
732
733 namespace pr23878 {
734 struct A { virtual void g(); };
735 struct B { virtual void f(); };
736 struct C : virtual B { void f(); };
737 struct D : A, C {};
738
739 typedef void (D::*DMemPtrTy)();
740
741 // CHECK-LABEL: define void @"\01?get_memptr@pr23878@@YAP8D@1@AEXXZXZ"
742 // CHECK: @"\01??_9C@pr23878@@$BA@AE" to i8*), i32 0, i32 4
get_memptr()743 DMemPtrTy get_memptr() { return &D::f; }
744 }
745
746 class C {};
747
748 typedef void (C::*f)();
749
750 class CA : public C {
751 public:
752 void OnHelp(void);
753 int OnHelp(int);
754 };
755
756 // CHECK-LABEL: foo_fun
foo_fun()757 void foo_fun() {
758 // CHECK: store i8* bitcast (void (%class.CA*)* @"\01?OnHelp@CA@@QAEXXZ" to i8*), i8**
759 f func = (f)&CA::OnHelp;
760 }
761 namespace PR24703 {
762 struct S;
763
f(int S::* & p)764 void f(int S::*&p) {}
765 // CHECK-LABEL: define void @"\01?f@PR24703@@YAXAAPQS@1@H@Z"(
766 }
767
768 namespace ReferenceToMPTWithIncompleteClass {
769 struct S;
770 struct J;
771 struct K;
772 extern K *k;
773
774 // CHECK-LABEL: @"\01?f@ReferenceToMPTWithIncompleteClass@@YAIAAPQS@1@H@Z"(
775 // CHECK: ret i32 12
f(int S::* & p)776 unsigned f(int S::*&p) { return sizeof p; }
777
778 // CHECK-LABEL: @"\01?g@ReferenceToMPTWithIncompleteClass@@YA_NAAPQJ@1@H0@Z"(
g(int J::* & p,int J::* & q)779 bool g(int J::*&p, int J::*&q) { return p == q; }
780
781 // CHECK-LABEL: @"\01?h@ReferenceToMPTWithIncompleteClass@@YAHAAPQK@1@H@Z"(
h(int K::* & p)782 int h(int K::*&p) { return k->*p; }
783 }
784
785 namespace PMFInTemplateArgument {
786 template <class C, int (C::*M)(int)>
787 void JSMethod();
788 class A {
789 int printd(int);
790 void printd();
791 };
printd()792 void A::printd() { JSMethod<A, &A::printd>(); }
793 // CHECK-LABEL: @"\01??$JSMethod@VA@PMFInTemplateArgument@@$1?printd@12@AAEHH@Z@PMFInTemplateArgument@@YAXXZ"(
794 }
795