Clang Project

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