From 33feeb019a5742b286eededd5446ec0fe87c5a61 Mon Sep 17 00:00:00 2001 From: Steve Naroff Date: Mon, 20 Apr 2009 20:09:33 +0000 Subject: [PATCH] Add pch reader/writer support for ObjCContainerDecl, ObjCInterfaceDecl, & ObjCIvarDecl. Next step: Add selector support to PCHWriter::AddDeclarationName(). git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@69619 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/clang/AST/DeclObjC.h | 10 +++++-- include/clang/Frontend/PCHBitCodes.h | 4 +++ lib/Frontend/PCHReader.cpp | 43 ++++++++++++++++++++++++++++ lib/Frontend/PCHWriter.cpp | 33 +++++++++++++++++++++ lib/Sema/SemaDeclObjC.cpp | 2 +- tools/clang-cc/RewriteObjC.cpp | 2 +- 6 files changed, 90 insertions(+), 4 deletions(-) diff --git a/include/clang/AST/DeclObjC.h b/include/clang/AST/DeclObjC.h index 7ee7c7b91b..c4b4c0b156 100644 --- a/include/clang/AST/DeclObjC.h +++ b/include/clang/AST/DeclObjC.h @@ -479,15 +479,21 @@ public: SourceLocation getLocEnd() const { return EndLoc; } void setLocEnd(SourceLocation LE) { EndLoc = LE; }; + void setClassLoc(SourceLocation Loc) { ClassLoc = Loc; } SourceLocation getClassLoc() const { return ClassLoc; } void setSuperClassLoc(SourceLocation Loc) { SuperClassLoc = Loc; } SourceLocation getSuperClassLoc() const { return SuperClassLoc; } - /// ImplicitInterfaceDecl - check that this is an implicitely declared + /// isImplicitInterfaceDecl - check that this is an implicitely declared /// ObjCInterfaceDecl node. This is for legacy objective-c @implementation /// declaration without an @interface declaration. - bool ImplicitInterfaceDecl() const { return InternalInterface; } + bool isImplicitInterfaceDecl() const { return InternalInterface; } + void setImplicitInterfaceDecl(bool val) { InternalInterface = val; } + // Low-level accessor + Type *getTypeForDecl() const { return TypeForDecl; } + void setTypeForDecl(Type *TD) { TypeForDecl = TD; } + static bool classof(const Decl *D) { return D->getKind() == ObjCInterface; } static bool classof(const ObjCInterfaceDecl *D) { return true; } }; diff --git a/include/clang/Frontend/PCHBitCodes.h b/include/clang/Frontend/PCHBitCodes.h index c1e6a8f493..ad07e2ae6b 100644 --- a/include/clang/Frontend/PCHBitCodes.h +++ b/include/clang/Frontend/PCHBitCodes.h @@ -356,6 +356,10 @@ namespace clang { DECL_FUNCTION, /// \brief A ObjCMethodDecl record. DECL_OBJC_METHOD, + /// \brief A ObjCInterfaceDecl record. + DECL_OBJC_INTERFACE_DECL, + /// \brief A ObjCIvarDecl record. + DECL_OBJC_IVAR_DECL, /// \brief A FieldDecl record. DECL_FIELD, /// \brief A VarDecl record. diff --git a/lib/Frontend/PCHReader.cpp b/lib/Frontend/PCHReader.cpp index 3975747b52..f1cb4d3cdc 100644 --- a/lib/Frontend/PCHReader.cpp +++ b/lib/Frontend/PCHReader.cpp @@ -68,6 +68,9 @@ namespace { void VisitBlockDecl(BlockDecl *BD); std::pair VisitDeclContext(DeclContext *DC); void VisitObjCMethodDecl(ObjCMethodDecl *D); + void VisitObjCContainerDecl(ObjCContainerDecl *D); + void VisitObjCInterfaceDecl(ObjCInterfaceDecl *D); + void VisitObjCIvarDecl(ObjCIvarDecl *D); }; } @@ -184,6 +187,35 @@ void PCHDeclReader::VisitObjCMethodDecl(ObjCMethodDecl *MD) { MD->setMethodParams(Reader.getContext(), &Params[0], NumParams); } +void PCHDeclReader::VisitObjCContainerDecl(ObjCContainerDecl *CD) { + VisitNamedDecl(CD); + CD->setAtEndLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); +} + +void PCHDeclReader::VisitObjCInterfaceDecl(ObjCInterfaceDecl *ID) { + VisitObjCContainerDecl(ID); + ID->setTypeForDecl(Reader.GetType(Record[Idx++]).getTypePtr()); + ID->setSuperClass(cast(Reader.GetDecl(Record[Idx++]))); + unsigned NumIvars = Record[Idx++]; + llvm::SmallVector IVars; + IVars.reserve(NumIvars); + for (unsigned I = 0; I != NumIvars; ++I) + IVars.push_back(cast(Reader.GetDecl(Record[Idx++]))); + ID->setIVarList(&IVars[0], NumIvars, Reader.getContext()); + + ID->setForwardDecl(Record[Idx++]); + ID->setImplicitInterfaceDecl(Record[Idx++]); + ID->setClassLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); + ID->setSuperClassLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); + ID->setLocEnd(SourceLocation::getFromRawEncoding(Record[Idx++])); + // FIXME: add protocols, categories. +} + +void PCHDeclReader::VisitObjCIvarDecl(ObjCIvarDecl *IVD) { + VisitFieldDecl(IVD); + IVD->setAccessControl((ObjCIvarDecl::AccessControl)Record[Idx++]); +} + void PCHDeclReader::VisitFieldDecl(FieldDecl *FD) { VisitValueDecl(FD); FD->setMutable(Record[Idx++]); @@ -1801,6 +1833,17 @@ Decl *PCHReader::ReadDeclRecord(uint64_t Offset, unsigned Index) { break; } + case pch::DECL_OBJC_INTERFACE_DECL: { + D = ObjCInterfaceDecl::Create(Context, 0, SourceLocation(), 0); + break; + } + + case pch::DECL_OBJC_IVAR_DECL: { + D = ObjCIvarDecl::Create(Context, 0, SourceLocation(), 0, QualType(), + ObjCIvarDecl::None); + break; + } + case pch::DECL_FIELD: { D = FieldDecl::Create(Context, 0, SourceLocation(), 0, QualType(), 0, false); diff --git a/lib/Frontend/PCHWriter.cpp b/lib/Frontend/PCHWriter.cpp index 9f6c4c1be0..22c52aa0ff 100644 --- a/lib/Frontend/PCHWriter.cpp +++ b/lib/Frontend/PCHWriter.cpp @@ -272,6 +272,9 @@ namespace { void VisitDeclContext(DeclContext *DC, uint64_t LexicalOffset, uint64_t VisibleOffset); void VisitObjCMethodDecl(ObjCMethodDecl *D); + void VisitObjCContainerDecl(ObjCContainerDecl *D); + void VisitObjCInterfaceDecl(ObjCInterfaceDecl *D); + void VisitObjCIvarDecl(ObjCIvarDecl *D); }; } @@ -387,6 +390,36 @@ void PCHDeclWriter::VisitObjCMethodDecl(ObjCMethodDecl *D) { Code = pch::DECL_OBJC_METHOD; } +void PCHDeclWriter::VisitObjCContainerDecl(ObjCContainerDecl *D) { + VisitNamedDecl(D); + Writer.AddSourceLocation(D->getAtEndLoc(), Record); + // Abstract class (no need to define a stable pch::DECL code). +} + +void PCHDeclWriter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) { + VisitObjCContainerDecl(D); + Writer.AddTypeRef(QualType(D->getTypeForDecl(), 0), Record); + Writer.AddDeclRef(D->getSuperClass(), Record); + Record.push_back(D->ivar_size()); + for (ObjCInterfaceDecl::ivar_iterator I = D->ivar_begin(), + IEnd = D->ivar_end(); I != IEnd; ++I) + Writer.AddDeclRef(*I, Record); + Record.push_back(D->isForwardDecl()); + Record.push_back(D->isImplicitInterfaceDecl()); + Writer.AddSourceLocation(D->getClassLoc(), Record); + Writer.AddSourceLocation(D->getSuperClassLoc(), Record); + Writer.AddSourceLocation(D->getLocEnd(), Record); + // FIXME: add protocols, categories. + Code = pch::DECL_OBJC_INTERFACE_DECL; +} + +void PCHDeclWriter::VisitObjCIvarDecl(ObjCIvarDecl *D) { + VisitFieldDecl(D); + // FIXME: stable encoding for @public/@private/@protected/@package + Record.push_back(D->getAccessControl()); + Code = pch::DECL_OBJC_IVAR_DECL; +} + void PCHDeclWriter::VisitFieldDecl(FieldDecl *D) { VisitValueDecl(D); Record.push_back(D->isMutable()); diff --git a/lib/Sema/SemaDeclObjC.cpp b/lib/Sema/SemaDeclObjC.cpp index b813e085ee..9b5f0d7bb0 100644 --- a/lib/Sema/SemaDeclObjC.cpp +++ b/lib/Sema/SemaDeclObjC.cpp @@ -699,7 +699,7 @@ void Sema::CheckImplementationIvars(ObjCImplementationDecl *ImpDecl, /// Check case of non-existing @interface decl. /// (legacy objective-c @implementation decl without an @interface decl). /// Add implementations's ivar to the synthesize class's ivar list. - if (IDecl->ImplicitInterfaceDecl()) { + if (IDecl->isImplicitInterfaceDecl()) { IDecl->setIVarList(ivars, numIvars, Context); IDecl->setLocEnd(RBrace); return; diff --git a/tools/clang-cc/RewriteObjC.cpp b/tools/clang-cc/RewriteObjC.cpp index 46f8e7ead3..842b63010f 100644 --- a/tools/clang-cc/RewriteObjC.cpp +++ b/tools/clang-cc/RewriteObjC.cpp @@ -3164,7 +3164,7 @@ void RewriteObjC::RewriteObjCClassMetaData(ObjCImplementationDecl *IDecl, ObjCInterfaceDecl *CDecl = IDecl->getClassInterface(); // Explictly declared @interface's are already synthesized. - if (CDecl->ImplicitInterfaceDecl()) { + if (CDecl->isImplicitInterfaceDecl()) { // FIXME: Implementation of a class with no @interface (legacy) doese not // produce correct synthesis as yet. SynthesizeObjCInternalStruct(CDecl, Result); -- 2.40.0