f94bbfed7c
Hit this when trying upgrade an old project of mine. I couldn't find a
corresponding existing issue for this when spelunking the open issues
here on github.
Thankfully I can work-around it today with the `[[clang::no_destroy]]`
attribute for my use case. However it should still be properly fixed.
### Issue and History ###
https://godbolt.org/z/EYnhce8MK for reference.
All subsequent text below refers to the example in the godbolt above.
Anonymous unions never have their destructor invoked automatically.
Therefore we can skip vtable initialization of the destructor of a
dynamic class if that destructor effectively does no work.
This worked previously as the following check would be hit and return
true for the trivial anonymous union,
https://github.com/llvm/llvm-project/blob/release/18.x/clang/lib/CodeGen/CGClass.cpp#L1348,
resulting in the code skipping vtable initialization.
This was broken here
982bbf404e
in relation to comments made on this review here
https://reviews.llvm.org/D10508.
### Fixes ###
The check the code is doing is correct however the return value is
inverted. We want to return true here since a field with anonymous union
never has its destructor invoked and thus effectively has a trivial
destructor body from the perspective of requiring vtable init in the
parent dynamic class.
Also added some extra missing unit tests to test for this use case and a
couple others.
263 lines
5.2 KiB
C++
263 lines
5.2 KiB
C++
// RUN: %clang_cc1 %s -triple=x86_64-apple-darwin10 -emit-llvm -o - | FileCheck %s
|
|
|
|
// See Test9 for test description.
|
|
// CHECK: @_ZTTN5Test91BE = linkonce_odr unnamed_addr constant
|
|
namespace Test1 {
|
|
|
|
// Check that we don't initialize the vtable pointer in A::~A(), since the destructor body is trivial.
|
|
struct A {
|
|
virtual void f();
|
|
~A();
|
|
};
|
|
|
|
// CHECK-LABEL: define{{.*}} void @_ZN5Test11AD2Ev
|
|
// CHECK-NOT: store ptr getelementptr inbounds ({ [3 x ptr] }, ptr @_ZTVN5Test11AE, i64 0, i64 2), ptr
|
|
A::~A()
|
|
{
|
|
}
|
|
|
|
}
|
|
|
|
namespace Test2 {
|
|
|
|
// Check that we do initialize the vtable pointer in A::~A() since the destructor body isn't trivial.
|
|
struct A {
|
|
virtual void f();
|
|
~A();
|
|
};
|
|
|
|
// CHECK-LABEL: define{{.*}} void @_ZN5Test21AD2Ev
|
|
// CHECK: store ptr getelementptr inbounds inrange(-16, 8) ({ [3 x ptr] }, ptr @_ZTVN5Test21AE, i32 0, i32 0, i32 2), ptr
|
|
A::~A() {
|
|
f();
|
|
}
|
|
|
|
}
|
|
|
|
namespace Test3 {
|
|
|
|
// Check that we don't initialize the vtable pointer in A::~A(), since the destructor body is trivial
|
|
// and Field's destructor body is also trivial.
|
|
struct Field {
|
|
~Field() { }
|
|
};
|
|
|
|
struct A {
|
|
virtual void f();
|
|
~A();
|
|
|
|
Field field;
|
|
};
|
|
|
|
// CHECK-LABEL: define{{.*}} void @_ZN5Test31AD2Ev
|
|
// CHECK-NOT: store ptr getelementptr inbounds inrange(-16, 8) ({ [3 x ptr] }, ptr @_ZTVN5Test31AE, i32 0, i32 0, i32 2), ptr
|
|
A::~A() {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
namespace Test4 {
|
|
|
|
// Check that we do initialize the vtable pointer in A::~A(), since Field's destructor body
|
|
// isn't trivial.
|
|
|
|
void f();
|
|
|
|
struct Field {
|
|
~Field() { f(); }
|
|
};
|
|
|
|
struct A {
|
|
virtual void f();
|
|
~A();
|
|
|
|
Field field;
|
|
};
|
|
|
|
// CHECK-LABEL: define{{.*}} void @_ZN5Test41AD2Ev
|
|
// CHECK: store ptr getelementptr inbounds inrange(-16, 8) ({ [3 x ptr] }, ptr @_ZTVN5Test41AE, i32 0, i32 0, i32 2), ptr
|
|
A::~A()
|
|
{
|
|
}
|
|
|
|
}
|
|
|
|
namespace Test5 {
|
|
|
|
// Check that we do initialize the vtable pointer in A::~A(), since Field's destructor isn't
|
|
// available in this translation unit.
|
|
|
|
struct Field {
|
|
~Field();
|
|
};
|
|
|
|
struct A {
|
|
virtual void f();
|
|
~A();
|
|
|
|
Field field;
|
|
};
|
|
|
|
// CHECK-LABEL: define{{.*}} void @_ZN5Test51AD2Ev
|
|
// CHECK: store ptr getelementptr inbounds inrange(-16, 8) ({ [3 x ptr] }, ptr @_ZTVN5Test51AE, i32 0, i32 0, i32 2), ptr
|
|
A::~A()
|
|
{
|
|
}
|
|
|
|
}
|
|
|
|
namespace Test6 {
|
|
|
|
// Check that we do initialize the vtable pointer in A::~A(), since Field has a member
|
|
// variable with a non-trivial destructor body.
|
|
|
|
struct NonTrivialDestructorBody {
|
|
~NonTrivialDestructorBody();
|
|
};
|
|
|
|
struct Field {
|
|
NonTrivialDestructorBody nonTrivialDestructorBody;
|
|
};
|
|
|
|
struct A {
|
|
virtual void f();
|
|
~A();
|
|
|
|
Field field;
|
|
};
|
|
|
|
// CHECK-LABEL: define{{.*}} void @_ZN5Test61AD2Ev
|
|
// CHECK: store ptr getelementptr inbounds inrange(-16, 8) ({ [3 x ptr] }, ptr @_ZTVN5Test61AE, i32 0, i32 0, i32 2), ptr
|
|
A::~A()
|
|
{
|
|
}
|
|
|
|
}
|
|
|
|
namespace Test7 {
|
|
|
|
// Check that we do initialize the vtable pointer in A::~A(), since Field has a base
|
|
// class with a non-trivial destructor body.
|
|
|
|
struct NonTrivialDestructorBody {
|
|
~NonTrivialDestructorBody();
|
|
};
|
|
|
|
struct Field : NonTrivialDestructorBody { };
|
|
|
|
struct A {
|
|
virtual void f();
|
|
~A();
|
|
|
|
Field field;
|
|
};
|
|
|
|
// CHECK-LABEL: define{{.*}} void @_ZN5Test71AD2Ev
|
|
// CHECK: store ptr getelementptr inbounds inrange(-16, 8) ({ [3 x ptr] }, ptr @_ZTVN5Test71AE, i32 0, i32 0, i32 2), ptr
|
|
A::~A()
|
|
{
|
|
}
|
|
|
|
}
|
|
|
|
namespace Test8 {
|
|
|
|
// Check that we do initialize the vtable pointer in A::~A(), since Field has a virtual base
|
|
// class with a non-trivial destructor body.
|
|
|
|
struct NonTrivialDestructorBody {
|
|
~NonTrivialDestructorBody();
|
|
};
|
|
|
|
struct Field : virtual NonTrivialDestructorBody { };
|
|
|
|
struct A {
|
|
virtual void f();
|
|
~A();
|
|
|
|
Field field;
|
|
};
|
|
|
|
// CHECK-LABEL: define{{.*}} void @_ZN5Test81AD2Ev
|
|
// CHECK: store ptr getelementptr inbounds inrange(-16, 8) ({ [3 x ptr] }, ptr @_ZTVN5Test81AE, i32 0, i32 0, i32 2), ptr
|
|
A::~A()
|
|
{
|
|
}
|
|
|
|
}
|
|
|
|
namespace Test9 {
|
|
|
|
// Check that we emit a VTT for B, even though we don't initialize the vtable pointer in the destructor.
|
|
struct A { virtual ~A () { } };
|
|
struct B : virtual A {};
|
|
struct C : virtual B {
|
|
virtual ~C();
|
|
};
|
|
C::~C() {}
|
|
|
|
}
|
|
|
|
namespace Test10 {
|
|
|
|
// Check that we don't initialize the vtable pointer in A::~A(), since the class has an anonymous union which
|
|
// never has its destructor invoked.
|
|
struct A {
|
|
virtual void f();
|
|
~A();
|
|
|
|
union
|
|
{
|
|
int i;
|
|
unsigned u;
|
|
};
|
|
};
|
|
|
|
// CHECK-LABEL: define{{.*}} void @_ZN6Test101AD2Ev
|
|
// CHECK-NOT: store ptr getelementptr inbounds ({ [3 x ptr] }, ptr @_ZTVN6Test101AE, i32 0, inrange i32 0, i32 2), ptr
|
|
A::~A() {
|
|
}
|
|
|
|
}
|
|
|
|
namespace Test11 {
|
|
|
|
// Check that we don't initialize the vtable pointer in A::~A(), even if the base class has a non trivial destructor.
|
|
struct Field {
|
|
~Field();
|
|
};
|
|
|
|
struct A : public Field {
|
|
virtual void f();
|
|
~A();
|
|
};
|
|
|
|
// CHECK-LABEL: define{{.*}} void @_ZN6Test111AD2Ev
|
|
// CHECK-NOT: store ptr getelementptr inbounds ({ [3 x ptr] }, ptr @_ZTVN6Test111AE, i32 0, inrange i32 0, i32 2), ptr
|
|
A::~A() {
|
|
}
|
|
|
|
}
|
|
|
|
namespace Test12 {
|
|
|
|
// Check that we don't initialize the vtable pointer in A::~A(), since the class has an anonymous struct with trivial fields.
|
|
struct A {
|
|
virtual void f();
|
|
~A();
|
|
|
|
struct
|
|
{
|
|
int i;
|
|
unsigned u;
|
|
};
|
|
};
|
|
|
|
// CHECK-LABEL: define{{.*}} void @_ZN6Test121AD2Ev
|
|
// CHECK-NOT: store ptr getelementptr inbounds ({ [3 x ptr] }, ptr @_ZTVN6Test121AE, i32 0, inrange i32 0, i32 2), ptr
|
|
A::~A() {
|
|
}
|
|
|
|
}
|