llvm-project/clang/test/SemaCXX/implicit-virtual-member-fun...

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

88 lines
2.6 KiB
C++
Raw Normal View History

// RUN: %clang_cc1 -fsyntax-only -triple %itanium_abi_triple -verify %s
// RUN: %clang_cc1 -fsyntax-only -triple %itanium_abi_triple -verify -std=c++98 %s
// RUN: %clang_cc1 -fsyntax-only -triple %itanium_abi_triple -verify -std=c++11 %s
// RUN: %clang_cc1 -fsyntax-only -triple %ms_abi_triple -DMSABI -verify %s
// RUN: %clang_cc1 -fsyntax-only -triple %ms_abi_triple -DMSABI -verify -std=c++98 %s
// RUN: %clang_cc1 -fsyntax-only -triple %ms_abi_triple -DMSABI -verify -std=c++11 %s
struct A {
virtual ~A();
#if __cplusplus >= 201103L
// expected-note@-2 3 {{overridden virtual function is here}}
#endif
};
struct B : A {
#if __cplusplus <= 199711L
// expected-error@-2 {{no suitable member 'operator delete' in 'B'}}
#else
// expected-error@-4 {{deleted function '~B' cannot override a non-deleted function}}
// expected-note@-5 {{virtual destructor requires an unambiguous, accessible 'operator delete'}}
#ifdef MSABI
// expected-note@-7 {{virtual destructor requires an unambiguous, accessible 'operator delete'}}
#endif
#endif
virtual void f();
void operator delete (void *, int);
#if __cplusplus <= 199711L
// expected-note@-2 {{'operator delete' declared here}}
#endif
};
#ifdef MSABI
B b;
#if __cplusplus <= 199711L
// expected-note@-2 {{implicit destructor for 'B' first required here}}
#else
// expected-error@-4 {{attempt to use a deleted function}}
#endif
#else
void B::f() {
#if __cplusplus <= 199711L
// expected-note@-2 {{implicit destructor for 'B' first required here}}
#endif
}
#endif
struct C : A {
#if __cplusplus <= 199711L
// expected-error@-2 {{no suitable member 'operator delete' in 'C'}}
#else
// expected-error@-4 {{deleted function '~C' cannot override a non-deleted function}}
// expected-note@-5 {{virtual destructor requires an unambiguous, accessible 'operator delete'}}
#endif
C();
void operator delete(void *, int);
#if __cplusplus <= 199711L
// expected-note@-2 {{'operator delete' declared here}}
#endif
};
C::C() { }
#if __cplusplus <= 199711L
// expected-note@-2 {{implicit destructor for 'C' first required here}}
#endif
struct D : A {
#if __cplusplus <= 199711L
// expected-error@-2 {{no suitable member 'operator delete' in 'D'}}
#else
// expected-error@-4 {{deleted function '~D' cannot override a non-deleted function}}
// expected-note@-5 {{virtual destructor requires an unambiguous, accessible 'operator delete'}}
#endif
void operator delete(void *, int);
#if __cplusplus <= 199711L
// expected-note@-2 {{'operator delete' declared here}}
#endif
Rework when and how vtables are emitted, by tracking where vtables are "used" (e.g., we will refer to the vtable in the generated code) and when they are defined (i.e., because we've seen the key function definition). Previously, we were effectively tracking "potential definitions" rather than uses, so we were a bit too eager about emitting vtables for classes without key functions. The new scheme: - For every use of a vtable, Sema calls MarkVTableUsed() to indicate the use. For example, this occurs when calling a virtual member function of the class, defining a constructor of that class type, dynamic_cast'ing from that type to a derived class, casting to/through a virtual base class, etc. - For every definition of a vtable, Sema calls MarkVTableUsed() to indicate the definition. This happens at the end of the translation unit for classes whose key function has been defined (so we can delay computation of the key function; see PR6564), and will also occur with explicit template instantiation definitions. - For every vtable defined/used, we mark all of the virtual member functions of that vtable as defined/used, unless we know that the key function is in another translation unit. This instantiates virtual member functions when needed. - At the end of the translation unit, Sema tells CodeGen (via the ASTConsumer) which vtables must be defined (CodeGen will define them) and which may be used (for which CodeGen will define the vtables lazily). From a language perspective, both the old and the new schemes are permissible: we're allowed to instantiate virtual member functions whenever we want per the standard. However, all other C++ compilers were more lazy than we were, and our eagerness was both a performance issue (we instantiated too much) and a portability problem (we broke Boost test cases, which now pass). Notes: (1) There's a ton of churn in the tests, because the order in which vtables get emitted to IR has changed. I've tried to isolate some of the larger tests from these issues. (2) Some diagnostics related to implicitly-instantiated/implicitly-defined virtual member functions have moved to the point of first use/definition. It's better this way. (3) I could use a review of the places where we MarkVTableUsed, to see if I missed any place where the language effectively requires a vtable. Fixes PR7114 and PR6564. llvm-svn: 103718
2010-05-14 00:44:06 +08:00
};
void f() {
new D;
#if __cplusplus <= 199711L
// expected-note@-2 {{implicit destructor for 'D' first required here}}
#endif
}