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