Clang Project

clang_source_code/test/CodeGenCXX/debug-info-thunk.cpp
1// RUN: %clang_cc1 %s -triple=x86_64-pc-windows-msvc -debug-info-kind=limited -S -emit-llvm -o - | FileCheck %s
2// RUN: %clang_cc1 %s -triple %itanium_abi_triple -debug-info-kind=limited -S -emit-llvm -o - | FileCheck %s -check-prefix=ITANIUM
3//
4// Validate we emit a "DIFlagThunk" flag on DISubprogram entries for thunks.
5// This flag is used for emitting S_THUNK32 symbols for CodeView debugging.
6//
7// NOTE:
8// Because thunks are compiler generated and don't exist in the source, this
9// test is dependent upon the linkage name to identify the thunk.  Any changes
10// in the name mangling may require this test to be updated.
11//
12// NOTE:
13// The FileCheck directives below use CHECK-DAG because the thunks may not be
14// emitted in source order.
15//
16
17namespace Test1 {
18  struct A {
19    virtual void f();
20  };
21  
22  struct B {
23    virtual void f();
24  };
25  
26  struct C : A, B {
27    virtual void c();
28    
29    virtual void f();
30  };
31  
32// CHECK-DAG: DISubprogram{{.*}}linkageName: "?f@C@Test1@@W7EAAXXZ"{{.*}} flags: {{.*}}DIFlagThunk
33  void C::f() { }
34}
35
36namespace Test2 {
37  struct V1 { };
38  struct V2 : virtual V1 { };
39  
40  struct A {
41    virtual V1 *f();
42  };
43  
44  struct B : A {
45    virtual void b();
46    
47    virtual V2 *f();
48  };
49  
50// CHECK-DAG: DISubprogram{{.*}}linkageName: "?f@B@Test2@@QEAAPEAUV1@2@XZ"{{.*}} flags: {{.*}}DIFlagThunk
51  V2 *B::f() { return 0; }
52}
53
54namespace Test3 {
55  struct A {
56    virtual void f();
57  };
58  
59  struct B {
60    virtual void f();
61  };
62  
63  struct __attribute__((visibility("protected"))) C : A, B {
64    virtual void c();
65    
66    virtual void f();
67  };
68  
69// CHECK-DAG: DISubprogram{{.*}}linkageName: "?f@C@Test3@@W7EAAXXZ"{{.*}} flags: {{.*}}DIFlagThunk
70  void C::f() { }
71}
72
73namespace Test4 {
74  struct A {
75    virtual void f();
76  };
77
78  struct B {
79    virtual void f();
80  };
81
82  namespace {
83    struct C : A, B {
84      virtual void c();
85      virtual void f();
86    };
87  }
88  void C::c() {}
89// CHECK-DAG: DISubprogram{{.*}}linkageName: "?f@C@?A0x{{[^@]*}}@Test4@@W7EAAXXZ"{{.*}} flags: {{.*}}DIFlagThunk
90  void C::f() {}
91
92  // Force C::f to be used.
93  void f() { 
94    C c; 
95    c.f();
96  }
97}
98
99namespace Test5 {
100  struct X {
101    X();
102    X(const X&);
103    X &operator=(const X&);
104    ~X();
105  };
106
107  struct P {
108    P();
109    P(const P&);
110    ~P();
111    X first;
112    X second;
113  };
114
115  P getP();
116
117  struct Base1 {
118    int i;
119
120    virtual X f() { return X(); }
121  };
122
123  struct Base2 {
124    float real;
125
126    virtual X f() { return X(); }
127  };
128
129  struct Thunks : Base1, Base2 {
130    long l;
131
132    virtual X f();
133  };
134
135// CHECK-DAG: DISubprogram{{.*}}linkageName: "?f@Thunks@Test5@@WBA@EAA?AUX@2@XZ"{{.*}} flags: {{.*}}DIFlagThunk
136  X Thunks::f() { return X(); }
137}
138
139namespace Test6 {
140  struct X {
141    X();
142    X(const X&);
143    X &operator=(const X&);
144    ~X();
145  };
146
147  struct Small { short s; };
148  struct Large {
149    char array[1024];
150  };
151
152  class A {
153  protected:
154    virtual void foo() = 0;
155  };
156
157  class B : public A {
158  protected:
159    virtual void bar() = 0;
160  };
161
162  class C : public A  {
163  protected:
164    virtual void baz(X, X&, _Complex float, Small, Small&, Large) = 0;
165  };
166
167  class D : public B,
168            public C {
169// CHECK-DAG: DISubprogram{{.*}}linkageName: "?foo@D@Test6@@G7EAAXXZ"{{.*}} flags: {{.*}}DIFlagThunk
170    void foo() {}
171    void bar() {}
172    void baz(X, X&, _Complex float, Small, Small&, Large);
173  };
174
175  void D::baz(X, X&, _Complex float, Small, Small&, Large) { }
176
177  void testD() { D d; }
178}
179
180namespace Test7 {
181  struct A { virtual void foo(); };
182  struct B { virtual void foo(); };
183// CHECK-DAG: DISubprogram{{.*}}linkageName: "?foo@C@Test7@@W7EAAXXZ"{{.*}} flags: {{.*}}DIFlagThunk
184  struct C : A, B { void foo() {} };
185
186  // Test later.
187  void test() {
188    C c;
189  }
190}
191
192namespace Test8 {
193  struct A {             virtual A* f(); };
194  struct B : virtual A { virtual A* f(); };
195  struct C : B         { virtual C* f(); };
196// CHECK-DAG: DISubprogram{{.*}}linkageName: "?f@C@Test8@@QEAAPEAUA@2@XZ"{{.*}} flags: {{.*}}DIFlagThunk
197  C* C::f() { return 0; }
198}
199
200namespace Test9 {
201  struct B1 {
202    virtual B1 &foo1();
203  };
204  struct Pad1 {
205    virtual ~Pad1();
206  };
207  struct Proxy1 : Pad1, B1 {
208    virtual ~Proxy1();
209  };
210  struct D : virtual Proxy1 {
211    virtual ~D();
212    virtual D &foo1();
213  };
214// CHECK-DAG: DISubprogram{{.*}}linkageName: "?foo1@D@Test9@@$4PPPPPPPE@A@EAAAEAUB1@2@XZ"{{.*}} flags: {{.*}}DIFlagThunk
215// CHECK-DAG: DISubprogram{{.*}}linkageName: "?foo1@D@Test9@@$4PPPPPPPE@A@EAAAEAU12@XZ"{{.*}} flags: {{.*}}DIFlagThunk
216  D& D::foo1() {
217    return *this;
218  }
219}
220
221namespace Test10 {
222  class A {
223    virtual void f();
224  };
225  class B {
226    virtual void f();
227  };
228  class C : public A, public B  {
229    virtual void f();
230  };
231// CHECK-DAG: DISubprogram{{.*}}linkageName: "?f@C@Test10@@G7EAAXXZ"{{.*}} flags: {{.*}}DIFlagThunk
232  void C::f() {
233  }
234}
235
236namespace Test11 {
237  class A {
238  public:
239    virtual void f();
240  };
241
242  void test() {
243// CHECK-DAG: DISubprogram{{.*}}linkageName: "??_9A@Test11@@$BA@AA"{{.*}} flags: {{.*}}DIFlagThunk
244    void (A::*p)() = &A::f;
245  }
246}
247
248namespace Test12 {
249  struct A {
250    virtual void f();
251  };
252  
253  struct B {
254    virtual void f();
255  };
256  
257  struct C : A, B {
258    virtual void f();
259  };
260  
261  void C::f() { }
262  // ITANIUM: define {{.*}}void @_ZThn{{[48]}}_N6Test121C1fEv
263  // ITANIUM-SAME: !dbg ![[SP:[0-9]+]]
264  // ITANIUM-NOT: {{ret }}
265  // ITANIUM: = load{{.*}} !dbg ![[DBG:[0-9]+]]
266  // ITANIUM-NOT: {{ret }}
267  // ITANIUM: ret void, !dbg ![[DBG]]
268  //
269  // ITANIUM: ![[SP]] = distinct !DISubprogram(linkageName: "_ZThn{{[48]}}_N6Test121C1fEv"
270  // ITANIUM-SAME:          line: 261
271  // ITANIUM-SAME:          DIFlagArtificial
272  // ITANIUM-SAME:          DIFlagThunk
273  // ITANIUM-SAME:          DISPFlagDefinition
274  // ITANIUM-SAME:          ){{$}}
275  //
276  // ITANIUM: ![[DBG]] = !DILocation(line: 0
277}
278
CodeThinker, Enjoy your reading code