blob: 27bbbc683277ec75ddd67c5e6b904a7402be6de8 [file] [log] [blame]
// RUN: %clang_cc1 %s -triple=x86_64-pc-windows-msvc -debug-info-kind=limited -S -emit-llvm -o - | FileCheck %s
// RUN: %clang_cc1 %s -triple %itanium_abi_triple -debug-info-kind=limited -S -emit-llvm -o - | FileCheck %s -check-prefix=ITANIUM
//
// Validate we emit a "DIFlagThunk" flag on DISubprogram entries for thunks.
// This flag is used for emitting S_THUNK32 symbols for CodeView debugging.
//
// NOTE:
// Because thunks are compiler generated and don't exist in the source, this
// test is dependent upon the linkage name to identify the thunk. Any changes
// in the name mangling may require this test to be updated.
//
// NOTE:
// The FileCheck directives below use CHECK-DAG because the thunks may not be
// emitted in source order.
//
namespace Test1 {
struct A {
virtual void f();
};
struct B {
virtual void f();
};
struct C : A, B {
virtual void c();
virtual void f();
};
// CHECK-DAG: DISubprogram{{.*}}linkageName: "?f@C@Test1@@W7EAAXXZ"{{.*}} flags: {{.*}}DIFlagThunk
void C::f() { }
}
namespace Test2 {
struct V1 { };
struct V2 : virtual V1 { };
struct A {
virtual V1 *f();
};
struct B : A {
virtual void b();
virtual V2 *f();
};
// CHECK-DAG: DISubprogram{{.*}}linkageName: "?f@B@Test2@@QEAAPEAUV1@2@XZ"{{.*}} flags: {{.*}}DIFlagThunk
V2 *B::f() { return 0; }
}
namespace Test3 {
struct A {
virtual void f();
};
struct B {
virtual void f();
};
struct __attribute__((visibility("protected"))) C : A, B {
virtual void c();
virtual void f();
};
// CHECK-DAG: DISubprogram{{.*}}linkageName: "?f@C@Test3@@W7EAAXXZ"{{.*}} flags: {{.*}}DIFlagThunk
void C::f() { }
}
namespace Test4 {
struct A {
virtual void f();
};
struct B {
virtual void f();
};
namespace {
struct C : A, B {
virtual void c();
virtual void f();
};
}
void C::c() {}
// CHECK-DAG: DISubprogram{{.*}}linkageName: "?f@C@?A0x{{[^@]*}}@Test4@@W7EAAXXZ"{{.*}} flags: {{.*}}DIFlagThunk
void C::f() {}
// Force C::f to be used.
void f() {
C c;
c.f();
}
}
namespace Test5 {
struct X {
X();
X(const X&);
X &operator=(const X&);
~X();
};
struct P {
P();
P(const P&);
~P();
X first;
X second;
};
P getP();
struct Base1 {
int i;
virtual X f() { return X(); }
};
struct Base2 {
float real;
virtual X f() { return X(); }
};
struct Thunks : Base1, Base2 {
long l;
virtual X f();
};
// CHECK-DAG: DISubprogram{{.*}}linkageName: "?f@Thunks@Test5@@WBA@EAA?AUX@2@XZ"{{.*}} flags: {{.*}}DIFlagThunk
X Thunks::f() { return X(); }
}
namespace Test6 {
struct X {
X();
X(const X&);
X &operator=(const X&);
~X();
};
struct Small { short s; };
struct Large {
char array[1024];
};
class A {
protected:
virtual void foo() = 0;
};
class B : public A {
protected:
virtual void bar() = 0;
};
class C : public A {
protected:
virtual void baz(X, X&, _Complex float, Small, Small&, Large) = 0;
};
class D : public B,
public C {
// CHECK-DAG: DISubprogram{{.*}}linkageName: "?foo@D@Test6@@G7EAAXXZ"{{.*}} flags: {{.*}}DIFlagThunk
void foo() {}
void bar() {}
void baz(X, X&, _Complex float, Small, Small&, Large);
};
void D::baz(X, X&, _Complex float, Small, Small&, Large) { }
void testD() { D d; }
}
namespace Test7 {
struct A { virtual void foo(); };
struct B { virtual void foo(); };
// CHECK-DAG: DISubprogram{{.*}}linkageName: "?foo@C@Test7@@W7EAAXXZ"{{.*}} flags: {{.*}}DIFlagThunk
struct C : A, B { void foo() {} };
// Test later.
void test() {
C c;
}
}
namespace Test8 {
struct A { virtual A* f(); };
struct B : virtual A { virtual A* f(); };
struct C : B { virtual C* f(); };
// CHECK-DAG: DISubprogram{{.*}}linkageName: "?f@C@Test8@@QEAAPEAUA@2@XZ"{{.*}} flags: {{.*}}DIFlagThunk
C* C::f() { return 0; }
}
namespace Test9 {
struct B1 {
virtual B1 &foo1();
};
struct Pad1 {
virtual ~Pad1();
};
struct Proxy1 : Pad1, B1 {
virtual ~Proxy1();
};
struct D : virtual Proxy1 {
virtual ~D();
virtual D &foo1();
};
// CHECK-DAG: DISubprogram{{.*}}linkageName: "?foo1@D@Test9@@$4PPPPPPPE@A@EAAAEAUB1@2@XZ"{{.*}} flags: {{.*}}DIFlagThunk
// CHECK-DAG: DISubprogram{{.*}}linkageName: "?foo1@D@Test9@@$4PPPPPPPE@A@EAAAEAU12@XZ"{{.*}} flags: {{.*}}DIFlagThunk
D& D::foo1() {
return *this;
}
}
namespace Test10 {
class A {
virtual void f();
};
class B {
virtual void f();
};
class C : public A, public B {
virtual void f();
};
// CHECK-DAG: DISubprogram{{.*}}linkageName: "?f@C@Test10@@G7EAAXXZ"{{.*}} flags: {{.*}}DIFlagThunk
void C::f() {
}
}
namespace Test11 {
class A {
public:
virtual void f();
};
void test() {
// CHECK-DAG: DISubprogram{{.*}}linkageName: "??_9A@Test11@@$BA@AA"{{.*}} flags: {{.*}}DIFlagThunk
void (A::*p)() = &A::f;
}
}
namespace Test12 {
struct A {
virtual void f();
};
struct B {
virtual void f();
};
struct C : A, B {
virtual void f();
};
void C::f() { }
// ITANIUM: define {{.*}}void @_ZThn{{[48]}}_N6Test121C1fEv
// ITANIUM-SAME: !dbg ![[SP:[0-9]+]]
// ITANIUM-NOT: {{ret }}
// ITANIUM: = load{{.*}} !dbg ![[DBG:[0-9]+]]
// ITANIUM-NOT: {{ret }}
// ITANIUM: ret void, !dbg ![[DBG]]
//
// ITANIUM: ![[SP]] = distinct !DISubprogram(linkageName: "_ZThn{{[48]}}_N6Test121C1fEv"
// ITANIUM-SAME: line: 261
// ITANIUM-SAME: isDefinition: true
// ITANIUM-SAME: DIFlagArtificial
// ITANIUM-SAME: DIFlagThunk
// ITANIUM-SAME: ){{$}}
//
// ITANIUM: ![[DBG]] = !DILocation(line: 0
}