Clang Project

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