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 17 namespace 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 f()33 void C::f() { } 34 } 35 36 namespace 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 f()51 V2 *B::f() { return 0; } 52 } 53 54 namespace 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 f()70 void C::f() { } 71 } 72 73 namespace 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 } c()88 void C::c() {} 89 // CHECK-DAG: DISubprogram{{.*}}linkageName: "?f@C@?A0x{{[^@]*}}@Test4@@W7EAAXXZ"{{.*}} flags: {{.*}}DIFlagThunk f()90 void C::f() {} 91 92 // Force C::f to be used. f()93 void f() { 94 C c; 95 c.f(); 96 } 97 } 98 99 namespace 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 fTest5::Base1120 virtual X f() { return X(); } 121 }; 122 123 struct Base2 { 124 float real; 125 fTest5::Base2126 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 f()136 X Thunks::f() { return X(); } 137 } 138 139 namespace 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 foo()170 void foo() {} bar()171 void bar() {} 172 void baz(X, X&, _Complex float, Small, Small&, Large); 173 }; 174 baz(X,X &,_Complex float,Small,Small &,Large)175 void D::baz(X, X&, _Complex float, Small, Small&, Large) { } 176 testD()177 void testD() { D d; } 178 } 179 180 namespace Test7 { 181 struct A { virtual void foo(); }; 182 struct B { virtual void foo(); }; 183 // CHECK-DAG: DISubprogram{{.*}}linkageName: "?foo@C@Test7@@W7EAAXXZ"{{.*}} flags: {{.*}}DIFlagThunk fooTest7::C184 struct C : A, B { void foo() {} }; 185 186 // Test later. test()187 void test() { 188 C c; 189 } 190 } 191 192 namespace 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 f()197 C* C::f() { return 0; } 198 } 199 200 namespace 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 foo1()216 D& D::foo1() { 217 return *this; 218 } 219 } 220 221 namespace 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 f()232 void C::f() { 233 } 234 } 235 236 namespace Test11 { 237 class A { 238 public: 239 virtual void f(); 240 }; 241 test()242 void test() { 243 // CHECK-DAG: DISubprogram{{.*}}linkageName: "??_9A@Test11@@$BA@AA"{{.*}} flags: {{.*}}DIFlagThunk 244 void (A::*p)() = &A::f; 245 } 246 } 247 248 namespace 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 f()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