shylie/llvm-project
1
0
Fork 0
Code Issues Pull Requests Actions 6 Packages Projects Releases Wiki Activity
llvm-project/clang/test/CodeGenCXX/thunks.cpp
Vedant Kumar 04818d8386 [DebugInfo] Don't emit incorrect descriptions of thunk params (PR42627) 
The `this` parameter of a thunk requires adjustment. Stop emitting an
incorrect dbg.declare pointing to the unadjusted pointer.

We could describe the adjusted value instead, but there may not be much
benefit in doing so as users tend not to debug thunks.

Robert O'Callahan reports that this matches gcc's behavior.

Fixes PR42627.

Differential Revision: https://reviews.llvm.org/D65035

llvm-svn: 367269
2019-07-29 22:49:55 +00:00

426 lines
8.8 KiB
C++
Raw Blame History

// RUN: %clang_cc1 %s -triple=x86_64-pc-linux-gnu -munwind-tables -emit-llvm -o - | FileCheck --check-prefix=CHECK --check-prefix=CHECK-NONOPT %s
// RUN: %clang_cc1 %s -triple=x86_64-pc-linux-gnu -debug-info-kind=standalone -dwarf-version=5 -munwind-tables -emit-llvm -o - | FileCheck --check-prefix=CHECK --check-prefix=CHECK-NONOPT --check-prefix=CHECK-DBG %s
// RUN: %clang_cc1 %s -triple=x86_64-pc-linux-gnu -munwind-tables -emit-llvm -o - -O1 -disable-llvm-passes | FileCheck --check-prefix=CHECK --check-prefix=CHECK-OPT %s
namespace Test1 {
// Check that we emit a non-virtual thunk for C::f.
struct A {
virtual void f();
};
struct B {
virtual void f();
};
struct C : A, B {
virtual void c();
virtual void f();
};
// CHECK-LABEL: define void @_ZThn8_N5Test11C1fEv(
// CHECK-DBG-NOT: dbg.declare
// CHECK: ret void
void C::f() { }
}
namespace Test2 {
// Check that we emit a thunk for B::f since it's overriding a virtual base.
struct A {
virtual void f();
};
struct B : virtual A {
virtual void b();
virtual void f();
};
// CHECK-LABEL: define void @_ZTv0_n24_N5Test21B1fEv(
// CHECK-DBG-NOT: dbg.declare
// CHECK: ret void
void B::f() { }
}
namespace Test3 {
// Check that we emit a covariant thunk for B::f.
struct V1 { };
struct V2 : virtual V1 { };
struct A {
virtual V1 *f();
};
struct B : A {
virtual void b();
virtual V2 *f();
};
// CHECK: define %{{.*}}* @_ZTch0_v0_n24_N5Test31B1fEv(
V2 *B::f() { return 0; }
}
namespace Test4 {
// Check that the thunk for 'C::f' has the same visibility as the function itself.
struct A {
virtual void f();
};
struct B {
virtual void f();
};
struct __attribute__((visibility("protected"))) C : A, B {
virtual void c();
virtual void f();
};
// CHECK-LABEL: define protected void @_ZThn8_N5Test41C1fEv(
// CHECK-DBG-NOT: dbg.declare
// CHECK: ret void
void C::f() { }
}
// Check that the thunk gets internal linkage.
namespace Test4B {
struct A {
virtual void f();
};
struct B {
virtual void f();
};
namespace {
struct C : A, B {
virtual void c();
virtual void f();
};
}
void C::c() {}
void C::f() {}
// Force C::f to be used.
void f() {
C c;
c.f();
}
}
namespace Test5 {
// Check that the thunk for 'B::f' gets the same linkage as the function itself.
struct A {
virtual void f();
};
struct B : virtual A {
virtual void f() { }
};
void f(B b) {
b.f();
}
}
namespace Test6 {
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-LABEL: define void @_ZThn16_N5Test66Thunks1fEv
// CHECK-DBG-NOT: dbg.declare
// CHECK-NOT: memcpy
// CHECK: {{call void @_ZN5Test66Thunks1fEv.*sret}}
// CHECK: ret void
X Thunks::f() { return X(); }
}
namespace Test7 {
// PR7188
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 {
void foo() {}
void bar() {}
void baz(X, X&, _Complex float, Small, Small&, Large);
};
void D::baz(X, X&, _Complex float, Small, Small&, Large) { }
// CHECK-LABEL: define void @_ZThn8_N5Test71D3bazENS_1XERS1_CfNS_5SmallERS4_NS_5LargeE(
// CHECK-DBG-NOT: dbg.declare
// CHECK-NOT: memcpy
// CHECK: ret void
void testD() { D d; }
}
namespace Test8 {
struct NonPOD { ~NonPOD(); int x, y, z; };
struct A { virtual void foo(); };
struct B { virtual void bar(NonPOD); };
struct C : A, B { virtual void bar(NonPOD); static void helper(NonPOD); };
// CHECK: define void @_ZN5Test81C6helperENS_6NonPODE([[NONPODTYPE:%.*]]*
void C::helper(NonPOD var) {}
// CHECK-LABEL: define void @_ZThn8_N5Test81C3barENS_6NonPODE(
// CHECK-DBG-NOT: dbg.declare
// CHECK-NOT: load [[NONPODTYPE]], [[NONPODTYPE]]*
// CHECK-NOT: memcpy
// CHECK: ret void
void C::bar(NonPOD var) {}
}
// PR7241: Emitting thunks for a method shouldn't require the vtable for
// that class to be emitted.
namespace Test9 {
struct A { virtual ~A() { } };
struct B : A { virtual void test() const {} };
struct C : B { C(); ~C(); };
struct D : C { D() {} };
void test() {
D d;
}
}
namespace Test10 {
struct A { virtual void foo(); };
struct B { virtual void foo(); };
struct C : A, B { void foo() {} };
// Test later.
void test() {
C c;
}
}
// PR7611
namespace Test11 {
struct A { virtual A* f(); };
struct B : virtual A { virtual A* f(); };
struct C : B { virtual C* f(); };
C* C::f() { return 0; }
// C::f itself.
// CHECK: define {{.*}} @_ZN6Test111C1fEv(
// The this-adjustment and return-adjustment thunk required when
// C::f appears in a vtable where A is at a nonzero offset from C.
// CHECK: define {{.*}} @_ZTcv0_n24_v0_n32_N6Test111C1fEv(
// CHECK-DBG-NOT: dbg.declare
// CHECK: ret
// The return-adjustment thunk required when C::f appears in a vtable
// where A is at a zero offset from C.
// CHECK: define {{.*}} @_ZTch0_v0_n32_N6Test111C1fEv(
// CHECK-DBG-NOT: dbg.declare
// CHECK: ret
}
// Varargs thunk test.
namespace Test12 {
struct A {
virtual A* f(int x, ...);
};
struct B {
virtual B* f(int x, ...);
};
struct C : A, B {
virtual void c();
virtual C* f(int x, ...);
};
C* C::f(int x, ...) { return this; }
// C::f
// CHECK: define {{.*}} @_ZN6Test121C1fEiz
// Varargs thunk; check that both the this and covariant adjustments
// are generated.
// CHECK: define {{.*}} @_ZTchn8_h8_N6Test121C1fEiz
// CHECK-DBG-NOT: dbg.declare
// CHECK: getelementptr inbounds i8, i8* {{.*}}, i64 -8
// CHECK: getelementptr inbounds i8, i8* {{.*}}, i64 8
}
// PR13832
namespace Test13 {
struct B1 {
virtual B1 &foo1();
};
struct Pad1 {
virtual ~Pad1();
};
struct Proxy1 : Pad1, B1 {
virtual ~Proxy1();
};
struct D : virtual Proxy1 {
virtual ~D();
virtual D &foo1();
};
D& D::foo1() {
return *this;
}
// CHECK: define {{.*}} @_ZTcvn8_n32_v8_n24_N6Test131D4foo1Ev
// CHECK-DBG-NOT: dbg.declare
// CHECK: getelementptr inbounds i8, i8* {{.*}}, i64 -8
// CHECK: getelementptr inbounds i8, i8* {{.*}}, i64 -32
// CHECK: getelementptr inbounds i8, i8* {{.*}}, i64 -24
// CHECK: getelementptr inbounds i8, i8* {{.*}}, i64 8
// CHECK: ret %"struct.Test13::D"*
}
namespace Test14 {
class A {
virtual void f();
};
class B {
virtual void f();
};
class C : public A, public B {
virtual void f();
};
void C::f() {
}
// CHECK: define void @_ZThn8_N6Test141C1fEv({{.*}}) unnamed_addr [[NUW:#[0-9]+]]
// CHECK-DBG-NOT: dbg.declare
// CHECK: ret void
}
// Varargs non-covariant thunk test.
// PR18098
namespace Test15 {
struct A {
virtual ~A();
};
struct B {
virtual void f(int x, ...);
};
struct C : A, B {
virtual void c();
virtual void f(int x, ...);
};
void C::c() {}
// C::c
// CHECK: declare void @_ZN6Test151C1fEiz
// non-virtual thunk to C::f
// CHECK: declare void @_ZThn8_N6Test151C1fEiz
}
namespace Test16 {
struct A {
virtual ~A();
};
struct B {
virtual void foo();
};
struct C : public A, public B {
void foo() {}
};
struct D : public C {
~D();
};
D::~D() {}
// CHECK: define linkonce_odr void @_ZThn8_N6Test161C3fooEv({{.*}}) {{.*}} comdat
// CHECK-DBG-NOT: dbg.declare
// CHECK: ret void
}
/**** The following has to go at the end of the file ****/
// checking without opt
// CHECK-NONOPT-LABEL: define internal void @_ZThn8_N6Test4B12_GLOBAL__N_11C1fEv(
// CHECK-NONOPT-NOT: comdat
// This is from Test5:
// CHECK-NONOPT-LABEL: define linkonce_odr void @_ZTv0_n24_N5Test51B1fEv
// This is from Test10:
// CHECK-NONOPT-LABEL: define linkonce_odr void @_ZN6Test101C3fooEv
// CHECK-NONOPT-LABEL: define linkonce_odr void @_ZThn8_N6Test101C3fooEv
// Checking with opt
// CHECK-OPT-LABEL: define internal void @_ZThn8_N6Test4B12_GLOBAL__N_11C1fEv(%"struct.Test4B::(anonymous namespace)::C"* %this) unnamed_addr #0 align 2
// This is from Test5:
// CHECK-OPT-LABEL: define linkonce_odr void @_ZTv0_n24_N5Test51B1fEv
// This is from Test10:
// CHECK-OPT-LABEL: define linkonce_odr void @_ZN6Test101C3fooEv
// CHECK-OPT-LABEL: define linkonce_odr void @_ZThn8_N6Test101C3fooEv
// CHECK-NONOPT: attributes [[NUW]] = { noinline nounwind optnone uwtable{{.*}} }
// CHECK-OPT: attributes [[NUW]] = { nounwind uwtable{{.*}} }
Reference in New Issue View Git Blame Copy Permalink