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