member-function-pointers.cpp revision 4d4e5c1ae83f4510caa486b3ad19de13048f9f04 
1// RUN: %clang_cc1 %s -emit-llvm -o - -triple=x86_64-apple-darwin9 | FileCheck %s
2// RUN: %clang_cc1 %s -emit-llvm -o - -triple=i386-apple-darwin9 | FileCheck -check-prefix LP32 %s
3// RUN: %clang_cc1 %s -emit-llvm -o - -triple=armv7-unknown-unknown | FileCheck -check-prefix ARM %s
4
5struct A { int a; void f(); virtual void vf1(); virtual void vf2(); };
6struct B { int b; virtual void g(); };
7struct C : B, A { };
8
9void (A::*pa)();
10void (A::*volatile vpa)();
11void (B::*pb)();
12void (C::*pc)();
13
14// CHECK: @pa2 = global { i64, i64 } { i64 ptrtoint (void (%struct.A*)* @_ZN1A1fEv to i64), i64 0 }, align 8
15void (A::*pa2)() = &A::f;
16
17// CHECK:      @pa3 = global { i64, i64 } { i64 1, i64 0 }, align 8
18// CHECK-LP32: @pa3 = global { i32, i32 } { i32 1, i32 0 }, align 4
19void (A::*pa3)() = &A::vf1;
20
21// CHECK:      @pa4 = global { i64, i64 } { i64 9, i64 0 }, align 8
22// CHECK-LP32: @pa4 = global { i32, i32 } { i32 5, i32 0 }, align 4
23void (A::*pa4)() = &A::vf2;
24
25// CHECK: @pc2 = global { i64, i64 } { i64 ptrtoint (void (%struct.A*)* @_ZN1A1fEv to i64), i64 16 }, align 8
26void (C::*pc2)() = &C::f;
27
28// CHECK: @pc3 = global { i64, i64 } { i64 1, i64 0 }, align 8
29void (A::*pc3)() = &A::vf1;
30
31// Tests for test10.
32// CHECK: @_ZN6test101aE = global { i64, i64 } { i64 ptrtoint (void (%"struct.test10::A"*)* @_ZN6test101A3fooEv to i64), i64 0 }, align 8
33// CHECK: @_ZN6test101bE = global { i64, i64 } { i64 ptrtoint (void (%"struct.test10::A"*)* @_ZN6test101A3fooEv to i64), i64 8 }, align 8
34// CHECK: @_ZN6test101cE = global { i64, i64 } { i64 ptrtoint (void (%"struct.test10::A"*)* @_ZN6test101A3fooEv to i64), i64 8 }, align 8
35// CHECK: @_ZN6test101dE = global { i64, i64 } { i64 ptrtoint (void (%"struct.test10::A"*)* @_ZN6test101A3fooEv to i64), i64 16 }, align 8
36// CHECK-LP32: @_ZN6test101aE = global { i32, i32 } { i32 ptrtoint (void (%"struct.test10::A"*)* @_ZN6test101A3fooEv to i32), i32 0 }, align 4
37// CHECK-LP32: @_ZN6test101bE = global { i32, i32 } { i32 ptrtoint (void (%"struct.test10::A"*)* @_ZN6test101A3fooEv to i32), i32 4 }, align 4
38// CHECK-LP32: @_ZN6test101cE = global { i32, i32 } { i32 ptrtoint (void (%"struct.test10::A"*)* @_ZN6test101A3fooEv to i32), i32 4 }, align 4
39// CHECK-LP32: @_ZN6test101dE = global { i32, i32 } { i32 ptrtoint (void (%"struct.test10::A"*)* @_ZN6test101A3fooEv to i32), i32 8 }, align 4
40
41void f() {
42  // CHECK: store { i64, i64 } zeroinitializer, { i64, i64 }* @pa
43  pa = 0;
44
45  // Is this okay?  What are LLVM's volatile semantics for structs?
46  // CHECK: store volatile { i64, i64 } zeroinitializer, { i64, i64 }* @vpa
47  vpa = 0;
48
49  // CHECK: [[TMP:%.*]] = load { i64, i64 }* @pa, align 8
50  // CHECK: [[TMPADJ:%.*]] = extractvalue { i64, i64 } [[TMP]], 1
51  // CHECK: [[ADJ:%.*]] = add nsw i64 [[TMPADJ]], 16
52  // CHECK: [[RES:%.*]] = insertvalue { i64, i64 } [[TMP]], i64 [[ADJ]], 1
53  // CHECK: store { i64, i64 } [[RES]], { i64, i64 }* @pc, align 8
54  pc = pa;
55
56  // CHECK: [[TMP:%.*]] = load { i64, i64 }* @pc, align 8
57  // CHECK: [[TMPADJ:%.*]] = extractvalue { i64, i64 } [[TMP]], 1
58  // CHECK: [[ADJ:%.*]] = sub nsw i64 [[TMPADJ]], 16
59  // CHECK: [[RES:%.*]] = insertvalue { i64, i64 } [[TMP]], i64 [[ADJ]], 1
60  // CHECK: store { i64, i64 } [[RES]], { i64, i64 }* @pa, align 8
61  pa = static_cast<void (A::*)()>(pc);
62}
63
64void f2() {
65  // CHECK:      store { i64, i64 } { i64 ptrtoint (void (%struct.A*)* @_ZN1A1fEv to i64), i64 0 }
66  void (A::*pa2)() = &A::f;
67
68  // CHECK:      store { i64, i64 } { i64 1, i64 0 }
69  // CHECK-LP32: store { i32, i32 } { i32 1, i32 0 }
70  void (A::*pa3)() = &A::vf1;
71
72  // CHECK:      store { i64, i64 } { i64 9, i64 0 }
73  // CHECK-LP32: store { i32, i32 } { i32 5, i32 0 }
74  void (A::*pa4)() = &A::vf2;
75}
76
77void f3(A *a, A &ar) {
78  (a->*pa)();
79  (ar.*pa)();
80}
81
82bool f4() {
83  return pa;
84}
85
86// PR5177
87namespace PR5177 {
88  struct A {
89   bool foo(int*) const;
90  } a;
91
92  struct B1 {
93   bool (A::*pmf)(int*) const;
94   const A* pa;
95
96   B1() : pmf(&A::foo), pa(&a) {}
97   bool operator()() const { return (pa->*pmf)(new int); }
98  };
99
100  void bar(B1 b2) { while (b2()) ; }
101}
102
103// PR5138
104namespace PR5138 {
105  struct foo {
106      virtual void bar(foo *);
107  };
108
109  extern "C" {
110    void baz(foo *);
111  }
112
113  void (foo::*ptr1)(void *) = (void (foo::*)(void *))&foo::bar;
114  void (*ptr2)(void *) = (void (*)(void *))&baz;
115
116  void (foo::*ptr3)(void) = (void (foo::*)(void))&foo::bar;
117}
118
119// PR5593
120namespace PR5593 {
121  struct A { };
122
123  bool f(void (A::*f)()) {
124    return f && f;
125  }
126}
127
128namespace PR5718 {
129  struct A { };
130
131  bool f(void (A::*f)(), void (A::*g)()) {
132    return f == g;
133  }
134}
135
136namespace BoolMemberPointer {
137  struct A { };
138
139  bool f(void (A::*f)()) {
140    return !f;
141  }
142
143  bool g(void (A::*f)()) {
144    if (!!f)
145      return true;
146    return false;
147  }
148}
149
150// PR5940
151namespace PR5940 {
152  class foo {
153  public:
154    virtual void baz(void);
155  };
156
157  void foo::baz(void) {
158       void (foo::*ptr)(void) = &foo::baz;
159  }
160}
161
162namespace MemberPointerImpCast {
163  struct A {
164    int x;
165  };
166  struct B : public A {
167  };
168  void f(B* obj, void (A::*method)()) {
169    (obj->*method)();
170  }
171}
172
173// PR6258
174namespace PR6258 {
175
176  struct A {
177    void f(bool);
178  };
179
180  void (A::*pf)(bool) = &A::f;
181
182  void f() {
183    void (A::*pf)(bool) = &A::f;
184  }
185}
186
187// PR7027
188namespace PR7027 {
189  struct X { void test( ); };
190  void testX() { &X::test; }
191}
192
193namespace test7 {
194  struct A { void foo(); virtual void vfoo(); };
195  struct B { void foo(); virtual void vfoo(); };
196  struct C : A, B { void foo(); virtual void vfoo(); };
197
198  // CHECK-ARM: @_ZN5test74ptr0E = global {{.*}} { i32 ptrtoint ({{.*}}* @_ZN5test71A3fooEv to i32), i32 0 }
199  // CHECK-ARM: @_ZN5test74ptr1E = global {{.*}} { i32 ptrtoint ({{.*}}* @_ZN5test71B3fooEv to i32), i32 8 }
200  // CHECK-ARM: @_ZN5test74ptr2E = global {{.*}} { i32 ptrtoint ({{.*}}* @_ZN5test71C3fooEv to i32), i32 0 }
201  // CHECK-ARM: @_ZN5test74ptr3E = global {{.*}} { i32 0, i32 1 }
202  // CHECK-ARM: @_ZN5test74ptr4E = global {{.*}} { i32 0, i32 9 }
203  // CHECK-ARM: @_ZN5test74ptr5E = global {{.*}} { i32 0, i32 1 }
204  void (C::*ptr0)() = &A::foo;
205  void (C::*ptr1)() = &B::foo;
206  void (C::*ptr2)() = &C::foo;
207  void (C::*ptr3)() = &A::vfoo;
208  void (C::*ptr4)() = &B::vfoo;
209  void (C::*ptr5)() = &C::vfoo;
210}
211
212namespace test8 {
213  struct X { };
214  typedef int (X::*pmf)(int);
215
216  // CHECK: {{define.*_ZN5test81fEv}}
217  pmf f() {
218    // CHECK: {{ret.*zeroinitializer}}
219    return pmf();
220  }
221}
222
223namespace test9 {
224  struct A {
225    void foo();
226  };
227  struct B : A {
228    void foo();
229  };
230
231  typedef void (A::*fooptr)();
232
233  struct S {
234    fooptr p;
235  };
236
237  // CHECK:    define void @_ZN5test94testEv(
238  // CHECK:      alloca i32
239  // CHECK-NEXT: ret void
240  void test() {
241    int x;
242    static S array[] = { (fooptr) &B::foo };
243  }
244}
245
246// rdar://problem/10815683 - Verify that we can emit reinterprets of
247// member pointers as constant initializers.  For added trickiness,
248// we also add some non-trivial adjustments.
249namespace test10 {
250  struct A {
251    int nonEmpty;
252    void foo();
253  };
254  struct B : public A {
255    virtual void requireNonZeroAdjustment();
256  };
257  struct C {
258    int nonEmpty;
259  };
260  struct D : public C {
261    virtual void requireNonZeroAdjustment();
262  };
263
264  // Non-ARM tests at top of file.
265  void (A::*a)() = &A::foo;
266  void (B::*b)() = (void (B::*)()) &A::foo;
267  void (C::*c)() = (void (C::*)()) (void (B::*)()) &A::foo;
268  void (D::*d)() = (void (C::*)()) (void (B::*)()) &A::foo;
269}
270// It's not that the offsets are doubled on ARM, it's that they're left-shifted by 1.
271// CHECK-ARM: @_ZN6test101aE = global { i32, i32 } { i32 ptrtoint (void (%"struct.test10::A"*)* @_ZN6test101A3fooEv to i32), i32 0 }, align 4
272// CHECK-ARM: @_ZN6test101bE = global { i32, i32 } { i32 ptrtoint (void (%"struct.test10::A"*)* @_ZN6test101A3fooEv to i32), i32 8 }, align 4
273// CHECK-ARM: @_ZN6test101cE = global { i32, i32 } { i32 ptrtoint (void (%"struct.test10::A"*)* @_ZN6test101A3fooEv to i32), i32 8 }, align 4
274// CHECK-ARM: @_ZN6test101dE = global { i32, i32 } { i32 ptrtoint (void (%"struct.test10::A"*)* @_ZN6test101A3fooEv to i32), i32 16 }, align 4
275