Make the -Wreinterpret-base-class logic safe against invalid
declarations at any point. Patch by Alexander Zinenko, and
report by Richard Smith.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@178098 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/lib/Sema/SemaCast.cpp b/lib/Sema/SemaCast.cpp
index 1dbc9aa..0e19adf 100644
--- a/lib/Sema/SemaCast.cpp
+++ b/lib/Sema/SemaCast.cpp
@@ -695,14 +695,15 @@
const CXXRecordDecl *SrcRD =
SrcPointeeRD ? SrcPointeeRD : SrcType->getAsCXXRecordDecl();
- // Examining subobjects for records is only possible if the complete
- // definition is available. Also, template instantiation is not allowed here.
- if(!SrcRD || !SrcRD->isCompleteDefinition())
+ // Examining subobjects for records is only possible if the complete and
+ // valid definition is available. Also, template instantiation is not
+ // allowed here.
+ if (!SrcRD || !SrcRD->isCompleteDefinition() || SrcRD->isInvalidDecl())
return;
const CXXRecordDecl *DestRD = DestType->getPointeeCXXRecordDecl();
- if(!DestRD || !DestRD->isCompleteDefinition())
+ if (!DestRD || !DestRD->isCompleteDefinition() || DestRD->isInvalidDecl())
return;
enum {
@@ -721,7 +722,7 @@
bool VirtualBase = true;
bool NonZeroOffset = false;
- for (CXXBasePaths::const_paths_iterator I = BasePaths.begin(),
+ for (CXXBasePaths::const_paths_iterator I = BasePaths.begin(),
E = BasePaths.end();
I != E; ++I) {
const CXXBasePath &Path = *I;
@@ -734,8 +735,16 @@
break;
const CXXRecordDecl *BaseRD = IElem->Base->getType()->getAsCXXRecordDecl();
assert(BaseRD && "Base type should be a valid unqualified class type");
+ // Don't check if any base has invalid declaration or has no definition
+ // since it has no layout info.
+ const CXXRecordDecl *Class = IElem->Class,
+ *ClassDefinition = Class->getDefinition();
+ if (Class->isInvalidDecl() || !ClassDefinition ||
+ !ClassDefinition->isCompleteDefinition())
+ return;
+
const ASTRecordLayout &DerivedLayout =
- Self.Context.getASTRecordLayout(IElem->Class);
+ Self.Context.getASTRecordLayout(Class);
Offset += DerivedLayout.getBaseClassOffset(BaseRD);
}
if (!IsVirtual) {
diff --git a/test/SemaCXX/warn-reinterpret-base-class.cpp b/test/SemaCXX/warn-reinterpret-base-class.cpp
index fc7d15c..a7deafe 100644
--- a/test/SemaCXX/warn-reinterpret-base-class.cpp
+++ b/test/SemaCXX/warn-reinterpret-base-class.cpp
@@ -37,6 +37,53 @@
(void)reinterpret_cast<B &>(*c);
}
+// Do not fail on erroneous classes with fields of incompletely-defined types.
+// Base class is malformed.
+namespace BaseMalformed {
+ struct A; // expected-note {{forward declaration of 'BaseMalformed::A'}}
+ struct B {
+ A a; // expected-error {{field has incomplete type 'BaseMalformed::A'}}
+ };
+ struct C : public B {} c;
+ B *b = reinterpret_cast<B *>(&c);
+} // end anonymous namespace
+
+// Child class is malformed.
+namespace ChildMalformed {
+ struct A; // expected-note {{forward declaration of 'ChildMalformed::A'}}
+ struct B {};
+ struct C : public B {
+ A a; // expected-error {{field has incomplete type 'ChildMalformed::A'}}
+ } c;
+ B *b = reinterpret_cast<B *>(&c);
+} // end anonymous namespace
+
+// Base class outside upcast base-chain is malformed.
+namespace BaseBaseMalformed {
+ struct A; // expected-note {{forward declaration of 'BaseBaseMalformed::A'}}
+ struct Y {};
+ struct X { A a; }; // expected-error {{field has incomplete type 'BaseBaseMalformed::A'}}
+ struct B : Y, X {};
+ struct C : B {} c;
+ B *p = reinterpret_cast<B*>(&c);
+}
+
+namespace InheritanceMalformed {
+ struct A; // expected-note {{forward declaration of 'InheritanceMalformed::A'}}
+ struct B : A {}; // expected-error {{base class has incomplete type}}
+ struct C : B {} c;
+ B *p = reinterpret_cast<B*>(&c);
+}
+
+// Virtual base class outside upcast base-chain is malformed.
+namespace VBaseMalformed{
+ struct A; // expected-note {{forward declaration of 'VBaseMalformed::A'}}
+ struct X { A a; }; // expected-error {{field has incomplete type 'VBaseMalformed::A'}}
+ struct B : public virtual X {};
+ struct C : B {} c;
+ B *p = reinterpret_cast<B*>(&c);
+}
+
void reinterpret_not_updowncast(A *pa, const A *pca, A &a, const A &ca) {
(void)*reinterpret_cast<C *>(pa);
(void)*reinterpret_cast<const C *>(pa);