diff options
Diffstat (limited to 'contrib/llvm/tools/clang/lib/Serialization/ASTWriter.cpp')
| -rw-r--r-- | contrib/llvm/tools/clang/lib/Serialization/ASTWriter.cpp | 929 |
1 files changed, 722 insertions, 207 deletions
diff --git a/contrib/llvm/tools/clang/lib/Serialization/ASTWriter.cpp b/contrib/llvm/tools/clang/lib/Serialization/ASTWriter.cpp index a1645d7..a4301b5 100644 --- a/contrib/llvm/tools/clang/lib/Serialization/ASTWriter.cpp +++ b/contrib/llvm/tools/clang/lib/Serialization/ASTWriter.cpp @@ -185,6 +185,7 @@ void ASTTypeWriter::VisitFunctionProtoType(const FunctionProtoType *T) { for (unsigned I = 0, N = T->getNumArgs(); I != N; ++I) Writer.AddTypeRef(T->getArgType(I), Record); Record.push_back(T->isVariadic()); + Record.push_back(T->hasTrailingReturn()); Record.push_back(T->getTypeQuals()); Record.push_back(static_cast<unsigned>(T->getRefQualifier())); Record.push_back(T->getExceptionSpecType()); @@ -221,6 +222,7 @@ void ASTTypeWriter::VisitTypeOfType(const TypeOfType *T) { } void ASTTypeWriter::VisitDecltypeType(const DecltypeType *T) { + Writer.AddTypeRef(T->getUnderlyingType(), Record); Writer.AddStmt(T->getUnderlyingExpr()); Code = TYPE_DECLTYPE; } @@ -239,7 +241,7 @@ void ASTTypeWriter::VisitAutoType(const AutoType *T) { void ASTTypeWriter::VisitTagType(const TagType *T) { Record.push_back(T->isDependentType()); - Writer.AddDeclRef(T->getDecl(), Record); + Writer.AddDeclRef(T->getDecl()->getCanonicalDecl(), Record); assert(!T->isBeingDefined() && "Cannot serialize in the middle of a type definition"); } @@ -363,13 +365,13 @@ void ASTTypeWriter::VisitElaboratedType(const ElaboratedType *T) { } void ASTTypeWriter::VisitInjectedClassNameType(const InjectedClassNameType *T) { - Writer.AddDeclRef(T->getDecl(), Record); + Writer.AddDeclRef(T->getDecl()->getCanonicalDecl(), Record); Writer.AddTypeRef(T->getInjectedSpecializationType(), Record); Code = TYPE_INJECTED_CLASS_NAME; } void ASTTypeWriter::VisitObjCInterfaceType(const ObjCInterfaceType *T) { - Writer.AddDeclRef(T->getDecl(), Record); + Writer.AddDeclRef(T->getDecl()->getCanonicalDecl(), Record); Code = TYPE_OBJC_INTERFACE; } @@ -552,6 +554,7 @@ void TypeLocWriter::VisitSubstTemplateTypeParmPackTypeLoc( } void TypeLocWriter::VisitTemplateSpecializationTypeLoc( TemplateSpecializationTypeLoc TL) { + Writer.AddSourceLocation(TL.getTemplateKeywordLoc(), Record); Writer.AddSourceLocation(TL.getTemplateNameLoc(), Record); Writer.AddSourceLocation(TL.getLAngleLoc(), Record); Writer.AddSourceLocation(TL.getRAngleLoc(), Record); @@ -564,22 +567,23 @@ void TypeLocWriter::VisitParenTypeLoc(ParenTypeLoc TL) { Writer.AddSourceLocation(TL.getRParenLoc(), Record); } void TypeLocWriter::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) { - Writer.AddSourceLocation(TL.getKeywordLoc(), Record); + Writer.AddSourceLocation(TL.getElaboratedKeywordLoc(), Record); Writer.AddNestedNameSpecifierLoc(TL.getQualifierLoc(), Record); } void TypeLocWriter::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) { Writer.AddSourceLocation(TL.getNameLoc(), Record); } void TypeLocWriter::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) { - Writer.AddSourceLocation(TL.getKeywordLoc(), Record); + Writer.AddSourceLocation(TL.getElaboratedKeywordLoc(), Record); Writer.AddNestedNameSpecifierLoc(TL.getQualifierLoc(), Record); Writer.AddSourceLocation(TL.getNameLoc(), Record); } void TypeLocWriter::VisitDependentTemplateSpecializationTypeLoc( DependentTemplateSpecializationTypeLoc TL) { - Writer.AddSourceLocation(TL.getKeywordLoc(), Record); + Writer.AddSourceLocation(TL.getElaboratedKeywordLoc(), Record); Writer.AddNestedNameSpecifierLoc(TL.getQualifierLoc(), Record); - Writer.AddSourceLocation(TL.getNameLoc(), Record); + Writer.AddSourceLocation(TL.getTemplateKeywordLoc(), Record); + Writer.AddSourceLocation(TL.getTemplateNameLoc(), Record); Writer.AddSourceLocation(TL.getLAngleLoc(), Record); Writer.AddSourceLocation(TL.getRAngleLoc(), Record); for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) @@ -689,9 +693,11 @@ static void AddStmtsExprs(llvm::BitstreamWriter &Stream, RECORD(EXPR_GNU_NULL); RECORD(EXPR_SHUFFLE_VECTOR); RECORD(EXPR_BLOCK); - RECORD(EXPR_BLOCK_DECL_REF); RECORD(EXPR_GENERIC_SELECTION); RECORD(EXPR_OBJC_STRING_LITERAL); + RECORD(EXPR_OBJC_NUMERIC_LITERAL); + RECORD(EXPR_OBJC_ARRAY_LITERAL); + RECORD(EXPR_OBJC_DICTIONARY_LITERAL); RECORD(EXPR_OBJC_ENCODE); RECORD(EXPR_OBJC_SELECTOR_EXPR); RECORD(EXPR_OBJC_PROTOCOL_EXPR); @@ -705,6 +711,7 @@ static void AddStmtsExprs(llvm::BitstreamWriter &Stream, RECORD(STMT_OBJC_AT_TRY); RECORD(STMT_OBJC_AT_SYNCHRONIZED); RECORD(STMT_OBJC_AT_THROW); + RECORD(EXPR_OBJC_BOOL_LITERAL); RECORD(EXPR_CXX_OPERATOR_CALL); RECORD(EXPR_CXX_CONSTRUCT); RECORD(EXPR_CXX_STATIC_CAST); @@ -712,6 +719,7 @@ static void AddStmtsExprs(llvm::BitstreamWriter &Stream, RECORD(EXPR_CXX_REINTERPRET_CAST); RECORD(EXPR_CXX_CONST_CAST); RECORD(EXPR_CXX_FUNCTIONAL_CAST); + RECORD(EXPR_USER_DEFINED_LITERAL); RECORD(EXPR_CXX_BOOL_LITERAL); RECORD(EXPR_CXX_NULL_PTR_LITERAL); RECORD(EXPR_CXX_TYPEID_EXPR); @@ -778,7 +786,7 @@ void ASTWriter::WriteBlockInfoBlock() { RECORD(IMPORTS); RECORD(REFERENCED_SELECTOR_POOL); RECORD(TU_UPDATE_LEXICAL); - RECORD(REDECLS_UPDATE_LATEST); + RECORD(LOCAL_REDECLARATIONS_MAP); RECORD(SEMA_DECL_REFS); RECORD(WEAK_UNDECLARED_IDENTIFIERS); RECORD(PENDING_IMPLICIT_INSTANTIATIONS); @@ -798,7 +806,13 @@ void ASTWriter::WriteBlockInfoBlock() { RECORD(KNOWN_NAMESPACES); RECORD(MODULE_OFFSET_MAP); RECORD(SOURCE_MANAGER_LINE_TABLE); - + RECORD(OBJC_CATEGORIES_MAP); + RECORD(FILE_SORTED_DECLS); + RECORD(IMPORTED_MODULES); + RECORD(MERGED_DECLARATIONS); + RECORD(LOCAL_REDECLARATIONS); + RECORD(OBJC_CATEGORIES); + // SourceManager Block. BLOCK(SOURCE_MANAGER_BLOCK); RECORD(SM_SLOC_FILE_ENTRY); @@ -862,8 +876,6 @@ void ASTWriter::WriteBlockInfoBlock() { RECORD(DECL_OBJC_PROTOCOL); RECORD(DECL_OBJC_IVAR); RECORD(DECL_OBJC_AT_DEFS_FIELD); - RECORD(DECL_OBJC_CLASS); - RECORD(DECL_OBJC_FORWARD_PROTOCOL); RECORD(DECL_OBJC_CATEGORY); RECORD(DECL_OBJC_CATEGORY_IMPL); RECORD(DECL_OBJC_IMPLEMENTATION); @@ -969,6 +981,7 @@ void ASTWriter::WriteMetadata(ASTContext &Context, StringRef isysroot, MetaAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Clang major MetaAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Clang minor MetaAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Relocatable + MetaAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Has errors MetaAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Target triple unsigned MetaAbbrevCode = Stream.EmitAbbrev(MetaAbbrev); @@ -979,6 +992,7 @@ void ASTWriter::WriteMetadata(ASTContext &Context, StringRef isysroot, Record.push_back(CLANG_VERSION_MAJOR); Record.push_back(CLANG_VERSION_MINOR); Record.push_back(!isysroot.empty()); + Record.push_back(ASTHasCompilerErrors); const std::string &Triple = Target.getTriple().getTriple(); Stream.EmitRecordWithBlob(MetaAbbrevCode, Record, Triple); @@ -1011,7 +1025,7 @@ void ASTWriter::WriteMetadata(ASTContext &Context, StringRef isysroot, FileAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name unsigned FileAbbrevCode = Stream.EmitAbbrev(FileAbbrev); - llvm::SmallString<128> MainFilePath(MainFile->getName()); + SmallString<128> MainFilePath(MainFile->getName()); llvm::sys::fs::make_absolute(MainFilePath); @@ -1034,7 +1048,7 @@ void ASTWriter::WriteMetadata(ASTContext &Context, StringRef isysroot, Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name unsigned AbbrevCode = Stream.EmitAbbrev(Abbrev); - llvm::SmallString<128> OutputPath(OutputFile); + SmallString<128> OutputPath(OutputFile); llvm::sys::fs::make_absolute(OutputPath); StringRef origDir = llvm::sys::path::parent_path(OutputPath); @@ -1063,6 +1077,9 @@ void ASTWriter::WriteLanguageOptions(const LangOptions &LangOpts) { #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \ Record.push_back(static_cast<unsigned>(LangOpts.get##Name())); #include "clang/Basic/LangOptions.def" + + Record.push_back(LangOpts.CurrentModule.size()); + Record.append(LangOpts.CurrentModule.begin(), LangOpts.CurrentModule.end()); Stream.EmitRecord(LANGUAGE_OPTIONS, Record); } @@ -1128,7 +1145,7 @@ void ASTWriter::WriteStatCache(MemorizeStatCalls &StatCalls) { } // Create the on-disk hash table in a buffer. - llvm::SmallString<4096> StatCacheData; + SmallString<4096> StatCacheData; uint32_t BucketOffset; { llvm::raw_svector_ostream Out(StatCacheData); @@ -1171,7 +1188,10 @@ static unsigned CreateSLocFileAbbrev(llvm::BitstreamWriter &Stream) { // FileEntry fields. Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 12)); // Size Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 32)); // Modification time + Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // BufferOverridden Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // NumCreatedFIDs + Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 24)); // FirstDeclIndex + Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // NumDecls Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name return Stream.EmitAbbrev(Abbrev); } @@ -1218,14 +1238,14 @@ namespace { // Trait used for the on-disk hash table of header search information. class HeaderFileInfoTrait { ASTWriter &Writer; - HeaderSearch &HS; + const HeaderSearch &HS; // Keep track of the framework names we've used during serialization. SmallVector<char, 128> FrameworkStringData; llvm::StringMap<unsigned> FrameworkNameOffset; public: - HeaderFileInfoTrait(ASTWriter &Writer, HeaderSearch &HS) + HeaderFileInfoTrait(ASTWriter &Writer, const HeaderSearch &HS) : Writer(Writer), HS(HS) { } typedef const char *key_type; @@ -1304,7 +1324,7 @@ namespace { /// \param HS The header search structure to save. /// /// \param Chain Whether we're creating a chained AST file. -void ASTWriter::WriteHeaderSearch(HeaderSearch &HS, StringRef isysroot) { +void ASTWriter::WriteHeaderSearch(const HeaderSearch &HS, StringRef isysroot) { SmallVector<const FileEntry *, 16> FilesByUID; HS.getFileMgr().GetUniqueIDMapping(FilesByUID); @@ -1320,7 +1340,9 @@ void ASTWriter::WriteHeaderSearch(HeaderSearch &HS, StringRef isysroot) { if (!File) continue; - const HeaderFileInfo &HFI = HS.header_file_begin()[UID]; + // Use HeaderSearch's getFileInfo to make sure we get the HeaderFileInfo + // from the external source if it was not provided already. + const HeaderFileInfo &HFI = HS.getFileInfo(File); if (HFI.External && Chain) continue; @@ -1340,7 +1362,7 @@ void ASTWriter::WriteHeaderSearch(HeaderSearch &HS, StringRef isysroot) { } // Create the on-disk hash table in a buffer. - llvm::SmallString<4096> TableData; + SmallString<4096> TableData; uint32_t BucketOffset; { llvm::raw_svector_ostream Out(TableData); @@ -1414,7 +1436,8 @@ void ASTWriter::WriteSourceManagerBlock(SourceManager &SourceMgr, // Figure out which record code to use. unsigned Code; if (SLoc->isFile()) { - if (SLoc->getFile().getContentCache()->OrigEntry) { + const SrcMgr::ContentCache *Cache = SLoc->getFile().getContentCache(); + if (Cache->OrigEntry) { Code = SM_SLOC_FILE_ENTRY; SLocFileEntryOffsets.push_back(Stream.GetCurrentBitNo()); } else @@ -1435,7 +1458,7 @@ void ASTWriter::WriteSourceManagerBlock(SourceManager &SourceMgr, const SrcMgr::ContentCache *Content = File.getContentCache(); if (Content->OrigEntry) { assert(Content->OrigEntry == Content->ContentsEntry && - "Writing to AST an overriden file is not supported"); + "Writing to AST an overridden file is not supported"); // The source location entry is a file. The blob associated // with this entry is the file name. @@ -1443,12 +1466,21 @@ void ASTWriter::WriteSourceManagerBlock(SourceManager &SourceMgr, // Emit size/modification time for this file. Record.push_back(Content->OrigEntry->getSize()); Record.push_back(Content->OrigEntry->getModificationTime()); - + Record.push_back(Content->BufferOverridden); Record.push_back(File.NumCreatedFIDs); - + + FileDeclIDsTy::iterator FDI = FileDeclIDs.find(SLoc); + if (FDI != FileDeclIDs.end()) { + Record.push_back(FDI->second->FirstDeclIndex); + Record.push_back(FDI->second->DeclIDs.size()); + } else { + Record.push_back(0); + Record.push_back(0); + } + // Turn the file name into an absolute path, if it isn't already. const char *Filename = Content->OrigEntry->getName(); - llvm::SmallString<128> FilePath(Filename); + SmallString<128> FilePath(Filename); // Ask the file manager to fixup the relative path for us. This will // honor the working directory. @@ -1461,6 +1493,16 @@ void ASTWriter::WriteSourceManagerBlock(SourceManager &SourceMgr, Filename = adjustFilenameForRelocatablePCH(Filename, isysroot); Stream.EmitRecordWithBlob(SLocFileAbbrv, Record, Filename); + + if (Content->BufferOverridden) { + Record.clear(); + Record.push_back(SM_SLOC_BUFFER_BLOB); + const llvm::MemoryBuffer *Buffer + = Content->getBuffer(PP.getDiagnostics(), PP.getSourceManager()); + Stream.EmitRecordWithBlob(SLocBufferBlobAbbrv, Record, + StringRef(Buffer->getBufferStart(), + Buffer->getBufferSize() + 1)); + } } else { // The source location entry is a buffer. The blob associated // with this entry contains the contents of the buffer. @@ -1629,8 +1671,9 @@ void ASTWriter::WritePreprocessor(const Preprocessor &PP, bool IsModule) { for (Preprocessor::macro_iterator I = PP.macro_begin(Chain == 0), E = PP.macro_end(Chain == 0); I != E; ++I) { - if (!IsModule || I->second->isExported()) { - MacroDefinitionsSeen.insert(I->first); + const IdentifierInfo *Name = I->first; + if (!IsModule || I->second->isPublic()) { + MacroDefinitionsSeen.insert(Name); MacrosToEmit.push_back(std::make_pair(I->first, I->second)); } } @@ -1664,15 +1707,17 @@ void ASTWriter::WritePreprocessor(const Preprocessor &PP, bool IsModule) { // chained PCH, by storing the offset into the original PCH rather than // writing the macro definition a second time. if (MI->isBuiltinMacro() || - (Chain && Name->isFromAST() && MI->isFromAST() && - !MI->hasChangedAfterLoad())) + (Chain && + Name->isFromAST() && !Name->hasChangedSinceDeserialization() && + MI->isFromAST() && !MI->hasChangedAfterLoad())) continue; AddIdentifierRef(Name, Record); MacroOffsets[Name] = Stream.GetCurrentBitNo(); Record.push_back(MI->getDefinitionLoc().getRawEncoding()); Record.push_back(MI->isUsed()); - AddSourceLocation(MI->getExportLocation(), Record); + Record.push_back(MI->isPublic()); + AddSourceLocation(MI->getVisibilityLocation(), Record); unsigned Code; if (MI->isObjectLike()) { Code = PP_MACRO_OBJECT_LIKE; @@ -1784,9 +1829,12 @@ void ASTWriter::WritePreprocessorDetail(PreprocessingRecord &PPRec) { Record.push_back(ID->getFileName().size()); Record.push_back(ID->wasInQuotes()); Record.push_back(static_cast<unsigned>(ID->getKind())); - llvm::SmallString<64> Buffer; + SmallString<64> Buffer; Buffer += ID->getFileName(); - Buffer += ID->getFile()->getName(); + // Check that the FileEntry is not null because it was not resolved and + // we create a PCH even with compiler errors. + if (ID->getFile()) + Buffer += ID->getFile()->getName(); Stream.EmitRecordWithBlob(InclusionAbbrev, Record, Buffer); continue; } @@ -1815,6 +1863,202 @@ void ASTWriter::WritePreprocessorDetail(PreprocessingRecord &PPRec) { } } +unsigned ASTWriter::getSubmoduleID(Module *Mod) { + llvm::DenseMap<Module *, unsigned>::iterator Known = SubmoduleIDs.find(Mod); + if (Known != SubmoduleIDs.end()) + return Known->second; + + return SubmoduleIDs[Mod] = NextSubmoduleID++; +} + +/// \brief Compute the number of modules within the given tree (including the +/// given module). +static unsigned getNumberOfModules(Module *Mod) { + unsigned ChildModules = 0; + for (Module::submodule_iterator Sub = Mod->submodule_begin(), + SubEnd = Mod->submodule_end(); + Sub != SubEnd; ++Sub) + ChildModules += getNumberOfModules(*Sub); + + return ChildModules + 1; +} + +void ASTWriter::WriteSubmodules(Module *WritingModule) { + // Determine the dependencies of our module and each of it's submodules. + // FIXME: This feels like it belongs somewhere else, but there are no + // other consumers of this information. + SourceManager &SrcMgr = PP->getSourceManager(); + ModuleMap &ModMap = PP->getHeaderSearchInfo().getModuleMap(); + for (ASTContext::import_iterator I = Context->local_import_begin(), + IEnd = Context->local_import_end(); + I != IEnd; ++I) { + if (Module *ImportedFrom + = ModMap.inferModuleFromLocation(FullSourceLoc(I->getLocation(), + SrcMgr))) { + ImportedFrom->Imports.push_back(I->getImportedModule()); + } + } + + // Enter the submodule description block. + Stream.EnterSubblock(SUBMODULE_BLOCK_ID, NUM_ALLOWED_ABBREVS_SIZE); + + // Write the abbreviations needed for the submodules block. + using namespace llvm; + BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); + Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_DEFINITION)); + Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // ID + Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Parent + Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsFramework + Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsExplicit + Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsSystem + Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // InferSubmodules... + Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // InferExplicit... + Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // InferExportWild... + Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name + unsigned DefinitionAbbrev = Stream.EmitAbbrev(Abbrev); + + Abbrev = new BitCodeAbbrev(); + Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_UMBRELLA_HEADER)); + Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name + unsigned UmbrellaAbbrev = Stream.EmitAbbrev(Abbrev); + + Abbrev = new BitCodeAbbrev(); + Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_HEADER)); + Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name + unsigned HeaderAbbrev = Stream.EmitAbbrev(Abbrev); + + Abbrev = new BitCodeAbbrev(); + Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_UMBRELLA_DIR)); + Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name + unsigned UmbrellaDirAbbrev = Stream.EmitAbbrev(Abbrev); + + Abbrev = new BitCodeAbbrev(); + Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_REQUIRES)); + Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Feature + unsigned RequiresAbbrev = Stream.EmitAbbrev(Abbrev); + + // Write the submodule metadata block. + RecordData Record; + Record.push_back(getNumberOfModules(WritingModule)); + Record.push_back(FirstSubmoduleID - NUM_PREDEF_SUBMODULE_IDS); + Stream.EmitRecord(SUBMODULE_METADATA, Record); + + // Write all of the submodules. + std::queue<Module *> Q; + Q.push(WritingModule); + while (!Q.empty()) { + Module *Mod = Q.front(); + Q.pop(); + unsigned ID = getSubmoduleID(Mod); + + // Emit the definition of the block. + Record.clear(); + Record.push_back(SUBMODULE_DEFINITION); + Record.push_back(ID); + if (Mod->Parent) { + assert(SubmoduleIDs[Mod->Parent] && "Submodule parent not written?"); + Record.push_back(SubmoduleIDs[Mod->Parent]); + } else { + Record.push_back(0); + } + Record.push_back(Mod->IsFramework); + Record.push_back(Mod->IsExplicit); + Record.push_back(Mod->IsSystem); + Record.push_back(Mod->InferSubmodules); + Record.push_back(Mod->InferExplicitSubmodules); + Record.push_back(Mod->InferExportWildcard); + Stream.EmitRecordWithBlob(DefinitionAbbrev, Record, Mod->Name); + + // Emit the requirements. + for (unsigned I = 0, N = Mod->Requires.size(); I != N; ++I) { + Record.clear(); + Record.push_back(SUBMODULE_REQUIRES); + Stream.EmitRecordWithBlob(RequiresAbbrev, Record, + Mod->Requires[I].data(), + Mod->Requires[I].size()); + } + + // Emit the umbrella header, if there is one. + if (const FileEntry *UmbrellaHeader = Mod->getUmbrellaHeader()) { + Record.clear(); + Record.push_back(SUBMODULE_UMBRELLA_HEADER); + Stream.EmitRecordWithBlob(UmbrellaAbbrev, Record, + UmbrellaHeader->getName()); + } else if (const DirectoryEntry *UmbrellaDir = Mod->getUmbrellaDir()) { + Record.clear(); + Record.push_back(SUBMODULE_UMBRELLA_DIR); + Stream.EmitRecordWithBlob(UmbrellaDirAbbrev, Record, + UmbrellaDir->getName()); + } + + // Emit the headers. + for (unsigned I = 0, N = Mod->Headers.size(); I != N; ++I) { + Record.clear(); + Record.push_back(SUBMODULE_HEADER); + Stream.EmitRecordWithBlob(HeaderAbbrev, Record, + Mod->Headers[I]->getName()); + } + + // Emit the imports. + if (!Mod->Imports.empty()) { + Record.clear(); + for (unsigned I = 0, N = Mod->Imports.size(); I != N; ++I) { + unsigned ImportedID = getSubmoduleID(Mod->Imports[I]); + assert(ImportedID && "Unknown submodule!"); + Record.push_back(ImportedID); + } + Stream.EmitRecord(SUBMODULE_IMPORTS, Record); + } + + // Emit the exports. + if (!Mod->Exports.empty()) { + Record.clear(); + for (unsigned I = 0, N = Mod->Exports.size(); I != N; ++I) { + if (Module *Exported = Mod->Exports[I].getPointer()) { + unsigned ExportedID = SubmoduleIDs[Exported]; + assert(ExportedID > 0 && "Unknown submodule ID?"); + Record.push_back(ExportedID); + } else { + Record.push_back(0); + } + + Record.push_back(Mod->Exports[I].getInt()); + } + Stream.EmitRecord(SUBMODULE_EXPORTS, Record); + } + + // Queue up the submodules of this module. + for (Module::submodule_iterator Sub = Mod->submodule_begin(), + SubEnd = Mod->submodule_end(); + Sub != SubEnd; ++Sub) + Q.push(*Sub); + } + + Stream.ExitBlock(); + + assert((NextSubmoduleID - FirstSubmoduleID + == getNumberOfModules(WritingModule)) && "Wrong # of submodules"); +} + +serialization::SubmoduleID +ASTWriter::inferSubmoduleIDFromLocation(SourceLocation Loc) { + if (Loc.isInvalid() || !WritingModule) + return 0; // No submodule + + // Find the module that owns this location. + ModuleMap &ModMap = PP->getHeaderSearchInfo().getModuleMap(); + Module *OwningMod + = ModMap.inferModuleFromLocation(FullSourceLoc(Loc,PP->getSourceManager())); + if (!OwningMod) + return 0; + + // Check whether this submodule is part of our own module. + if (WritingModule != OwningMod && !OwningMod->isSubModuleOf(WritingModule)) + return 0; + + return getSubmoduleID(OwningMod); +} + void ASTWriter::WritePragmaDiagnosticMappings(const DiagnosticsEngine &Diag) { RecordData Record; for (DiagnosticsEngine::DiagStatePointsTy::const_iterator @@ -1970,6 +2214,29 @@ void ASTWriter::WriteTypeDeclOffsets() { Stream.EmitRecordWithBlob(DeclOffsetAbbrev, Record, data(DeclOffsets)); } +void ASTWriter::WriteFileDeclIDsMap() { + using namespace llvm; + RecordData Record; + + // Join the vectors of DeclIDs from all files. + SmallVector<DeclID, 256> FileSortedIDs; + for (FileDeclIDsTy::iterator + FI = FileDeclIDs.begin(), FE = FileDeclIDs.end(); FI != FE; ++FI) { + DeclIDInFileInfo &Info = *FI->second; + Info.FirstDeclIndex = FileSortedIDs.size(); + for (LocDeclIDsTy::iterator + DI = Info.DeclIDs.begin(), DE = Info.DeclIDs.end(); DI != DE; ++DI) + FileSortedIDs.push_back(DI->second); + } + + BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); + Abbrev->Add(BitCodeAbbrevOp(FILE_SORTED_DECLS)); + Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); + unsigned AbbrevCode = Stream.EmitAbbrev(Abbrev); + Record.push_back(FILE_SORTED_DECLS); + Stream.EmitRecordWithBlob(AbbrevCode, Record, data(FileSortedIDs)); +} + //===----------------------------------------------------------------------===// // Global Method Pool and Selector Serialization //===----------------------------------------------------------------------===// @@ -2117,7 +2384,7 @@ void ASTWriter::WriteSelectors(Sema &SemaRef) { } // Create the on-disk hash table in a buffer. - llvm::SmallString<4096> MethodPool; + SmallString<4096> MethodPool; uint32_t BucketOffset; { ASTMethodPoolTrait Trait(*this); @@ -2190,6 +2457,7 @@ namespace { class ASTIdentifierTableTrait { ASTWriter &Writer; Preprocessor &PP; + IdentifierResolver &IdResolver; bool IsModule; /// \brief Determines whether this is an "interesting" identifier @@ -2199,6 +2467,7 @@ class ASTIdentifierTableTrait { if (II->isPoisoned() || II->isExtensionToken() || II->getObjCOrBuiltinID() || + II->hasRevertedTokenIDToIdentifier() || II->getFETokenInfo<void>()) return true; @@ -2210,7 +2479,7 @@ class ASTIdentifierTableTrait { return false; if (Macro || (Macro = PP.getMacroInfo(II))) - return !Macro->isBuiltinMacro() && (!IsModule || Macro->isExported()); + return !Macro->isBuiltinMacro() && (!IsModule || Macro->isPublic()); return false; } @@ -2222,24 +2491,26 @@ public: typedef IdentID data_type; typedef data_type data_type_ref; - ASTIdentifierTableTrait(ASTWriter &Writer, Preprocessor &PP, bool IsModule) - : Writer(Writer), PP(PP), IsModule(IsModule) { } + ASTIdentifierTableTrait(ASTWriter &Writer, Preprocessor &PP, + IdentifierResolver &IdResolver, bool IsModule) + : Writer(Writer), PP(PP), IdResolver(IdResolver), IsModule(IsModule) { } static unsigned ComputeHash(const IdentifierInfo* II) { return llvm::HashString(II->getName()); } std::pair<unsigned,unsigned> - EmitKeyDataLength(raw_ostream& Out, IdentifierInfo* II, IdentID ID) { + EmitKeyDataLength(raw_ostream& Out, IdentifierInfo* II, IdentID ID) { unsigned KeyLen = II->getLength() + 1; unsigned DataLen = 4; // 4 bytes for the persistent ID << 1 MacroInfo *Macro = 0; if (isInterestingIdentifier(II, Macro)) { DataLen += 2; // 2 bytes for builtin ID, flags if (hasMacroDefinition(II, Macro)) - DataLen += 4; - for (IdentifierResolver::iterator D = IdentifierResolver::begin(II), - DEnd = IdentifierResolver::end(); + DataLen += 8; + + for (IdentifierResolver::iterator D = IdResolver.begin(II), + DEnd = IdResolver.end(); D != DEnd; ++D) DataLen += sizeof(DeclID); } @@ -2271,6 +2542,7 @@ public: uint32_t Bits = 0; bool HasMacroDefinition = hasMacroDefinition(II, Macro); Bits = (uint32_t)II->getObjCOrBuiltinID(); + assert((Bits & 0x7ff) == Bits && "ObjCOrBuiltinID too big for ASTReader."); Bits = (Bits << 1) | unsigned(HasMacroDefinition); Bits = (Bits << 1) | unsigned(II->isExtensionToken()); Bits = (Bits << 1) | unsigned(II->isPoisoned()); @@ -2278,20 +2550,22 @@ public: Bits = (Bits << 1) | unsigned(II->isCPlusPlusOperatorKeyword()); clang::io::Emit16(Out, Bits); - if (HasMacroDefinition) + if (HasMacroDefinition) { clang::io::Emit32(Out, Writer.getMacroOffset(II)); - + clang::io::Emit32(Out, + Writer.inferSubmoduleIDFromLocation(Macro->getDefinitionLoc())); + } + // Emit the declaration IDs in reverse order, because the // IdentifierResolver provides the declarations as they would be // visible (e.g., the function "stat" would come before the struct - // "stat"), but IdentifierResolver::AddDeclToIdentifierChain() - // adds declarations to the end of the list (so we need to see the - // struct "status" before the function "status"). + // "stat"), but the ASTReader adds declarations to the end of the list + // (so we need to see the struct "status" before the function "status"). // Only emit declarations that aren't from a chained PCH, though. - SmallVector<Decl *, 16> Decls(IdentifierResolver::begin(II), - IdentifierResolver::end()); + SmallVector<Decl *, 16> Decls(IdResolver.begin(II), + IdResolver.end()); for (SmallVector<Decl *, 16>::reverse_iterator D = Decls.rbegin(), - DEnd = Decls.rend(); + DEnd = Decls.rend(); D != DEnd; ++D) clang::io::Emit32(Out, Writer.getDeclID(*D)); } @@ -2303,14 +2577,16 @@ public: /// The identifier table consists of a blob containing string data /// (the actual identifiers themselves) and a separate "offsets" index /// that maps identifier IDs to locations within the blob. -void ASTWriter::WriteIdentifierTable(Preprocessor &PP, bool IsModule) { +void ASTWriter::WriteIdentifierTable(Preprocessor &PP, + IdentifierResolver &IdResolver, + bool IsModule) { using namespace llvm; // Create and write out the blob that contains the identifier // strings. { OnDiskChainedHashTableGenerator<ASTIdentifierTableTrait> Generator; - ASTIdentifierTableTrait Trait(*this, PP, IsModule); + ASTIdentifierTableTrait Trait(*this, PP, IdResolver, IsModule); // Look for any identifiers that were named while processing the // headers, but are otherwise not needed. We add these to the hash @@ -2329,16 +2605,17 @@ void ASTWriter::WriteIdentifierTable(Preprocessor &PP, bool IsModule) { ID = IdentifierIDs.begin(), IDEnd = IdentifierIDs.end(); ID != IDEnd; ++ID) { assert(ID->first && "NULL identifier in identifier table"); - if (!Chain || !ID->first->isFromAST()) + if (!Chain || !ID->first->isFromAST() || + ID->first->hasChangedSinceDeserialization()) Generator.insert(const_cast<IdentifierInfo *>(ID->first), ID->second, Trait); } // Create the on-disk hash table in a buffer. - llvm::SmallString<4096> IdentifierTable; + SmallString<4096> IdentifierTable; uint32_t BucketOffset; { - ASTIdentifierTableTrait Trait(*this, PP, IsModule); + ASTIdentifierTableTrait Trait(*this, PP, IdResolver, IsModule); llvm::raw_svector_ostream Out(IdentifierTable); // Make sure that no bucket is at offset 0 clang::io::Emit32(Out, 0); @@ -2512,20 +2789,16 @@ uint64_t ASTWriter::WriteDeclContextVisibleBlock(ASTContext &Context, // IdentifierInfo chains, don't bother to build a visible-declarations table. // FIXME: In C++ we need the visible declarations in order to "see" the // friend declarations, is there a way to do this without writing the table ? - if (DC->isTranslationUnit() && !Context.getLangOptions().CPlusPlus) + if (DC->isTranslationUnit() && !Context.getLangOpts().CPlusPlus) return 0; - // Force the DeclContext to build a its name-lookup table. - if (!DC->hasExternalVisibleStorage()) - DC->lookup(DeclarationName()); - // Serialize the contents of the mapping used for lookup. Note that, // although we have two very different code paths, the serialized // representation is the same for both cases: a declaration name, // followed by a size, followed by references to the visible // declarations that have that name. uint64_t Offset = Stream.GetCurrentBitNo(); - StoredDeclsMap *Map = static_cast<StoredDeclsMap*>(DC->getLookupPtr()); + StoredDeclsMap *Map = DC->buildLookup(); if (!Map || Map->empty()) return 0; @@ -2565,7 +2838,7 @@ uint64_t ASTWriter::WriteDeclContextVisibleBlock(ASTContext &Context, } // Create the on-disk hash table in a buffer. - llvm::SmallString<4096> LookupTable; + SmallString<4096> LookupTable; uint32_t BucketOffset; { llvm::raw_svector_ostream Out(LookupTable); @@ -2590,7 +2863,8 @@ uint64_t ASTWriter::WriteDeclContextVisibleBlock(ASTContext &Context, /// /// UPDATE_VISIBLE blocks contain the declarations that are added to an existing /// DeclContext in a dependent AST file. As such, they only exist for the TU -/// (in C++) and for namespaces. +/// (in C++), for namespaces, and for classes with forward-declared unscoped +/// enumeration members (in C++11). void ASTWriter::WriteDeclContextVisibleUpdate(const DeclContext *DC) { StoredDeclsMap *Map = static_cast<StoredDeclsMap*>(DC->getLookupPtr()); if (!Map || Map->empty()) @@ -2611,7 +2885,7 @@ void ASTWriter::WriteDeclContextVisibleUpdate(const DeclContext *DC) { } // Create the on-disk hash table in a buffer. - llvm::SmallString<4096> LookupTable; + SmallString<4096> LookupTable; uint32_t BucketOffset; { llvm::raw_svector_ostream Out(LookupTable); @@ -2637,7 +2911,7 @@ void ASTWriter::WriteFPPragmaOptions(const FPOptions &Opts) { /// \brief Write an OPENCL_EXTENSIONS block for the given OpenCLOptions. void ASTWriter::WriteOpenCLExtensions(Sema &SemaRef) { - if (!SemaRef.Context.getLangOptions().OpenCL) + if (!SemaRef.Context.getLangOpts().OpenCL) return; const OpenCLOptions &Opts = SemaRef.getOpenCLOptions(); @@ -2647,6 +2921,143 @@ void ASTWriter::WriteOpenCLExtensions(Sema &SemaRef) { Stream.EmitRecord(OPENCL_EXTENSIONS, Record); } +void ASTWriter::WriteRedeclarations() { + RecordData LocalRedeclChains; + SmallVector<serialization::LocalRedeclarationsInfo, 2> LocalRedeclsMap; + + for (unsigned I = 0, N = Redeclarations.size(); I != N; ++I) { + Decl *First = Redeclarations[I]; + assert(First->getPreviousDecl() == 0 && "Not the first declaration?"); + + Decl *MostRecent = First->getMostRecentDecl(); + + // If we only have a single declaration, there is no point in storing + // a redeclaration chain. + if (First == MostRecent) + continue; + + unsigned Offset = LocalRedeclChains.size(); + unsigned Size = 0; + LocalRedeclChains.push_back(0); // Placeholder for the size. + + // Collect the set of local redeclarations of this declaration. + for (Decl *Prev = MostRecent; Prev != First; + Prev = Prev->getPreviousDecl()) { + if (!Prev->isFromASTFile()) { + AddDeclRef(Prev, LocalRedeclChains); + ++Size; + } + } + LocalRedeclChains[Offset] = Size; + + // Reverse the set of local redeclarations, so that we store them in + // order (since we found them in reverse order). + std::reverse(LocalRedeclChains.end() - Size, LocalRedeclChains.end()); + + // Add the mapping from the first ID to the set of local declarations. + LocalRedeclarationsInfo Info = { getDeclID(First), Offset }; + LocalRedeclsMap.push_back(Info); + + assert(N == Redeclarations.size() && + "Deserialized a declaration we shouldn't have"); + } + + if (LocalRedeclChains.empty()) + return; + + // Sort the local redeclarations map by the first declaration ID, + // since the reader will be performing binary searches on this information. + llvm::array_pod_sort(LocalRedeclsMap.begin(), LocalRedeclsMap.end()); + + // Emit the local redeclarations map. + using namespace llvm; + llvm::BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); + Abbrev->Add(BitCodeAbbrevOp(LOCAL_REDECLARATIONS_MAP)); + Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // # of entries + Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); + unsigned AbbrevID = Stream.EmitAbbrev(Abbrev); + + RecordData Record; + Record.push_back(LOCAL_REDECLARATIONS_MAP); + Record.push_back(LocalRedeclsMap.size()); + Stream.EmitRecordWithBlob(AbbrevID, Record, + reinterpret_cast<char*>(LocalRedeclsMap.data()), + LocalRedeclsMap.size() * sizeof(LocalRedeclarationsInfo)); + + // Emit the redeclaration chains. + Stream.EmitRecord(LOCAL_REDECLARATIONS, LocalRedeclChains); +} + +void ASTWriter::WriteObjCCategories() { + llvm::SmallVector<ObjCCategoriesInfo, 2> CategoriesMap; + RecordData Categories; + + for (unsigned I = 0, N = ObjCClassesWithCategories.size(); I != N; ++I) { + unsigned Size = 0; + unsigned StartIndex = Categories.size(); + + ObjCInterfaceDecl *Class = ObjCClassesWithCategories[I]; + + // Allocate space for the size. + Categories.push_back(0); + + // Add the categories. + for (ObjCCategoryDecl *Cat = Class->getCategoryList(); + Cat; Cat = Cat->getNextClassCategory(), ++Size) { + assert(getDeclID(Cat) != 0 && "Bogus category"); + AddDeclRef(Cat, Categories); + } + + // Update the size. + Categories[StartIndex] = Size; + + // Record this interface -> category map. + ObjCCategoriesInfo CatInfo = { getDeclID(Class), StartIndex }; + CategoriesMap.push_back(CatInfo); + } + + // Sort the categories map by the definition ID, since the reader will be + // performing binary searches on this information. + llvm::array_pod_sort(CategoriesMap.begin(), CategoriesMap.end()); + + // Emit the categories map. + using namespace llvm; + llvm::BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); + Abbrev->Add(BitCodeAbbrevOp(OBJC_CATEGORIES_MAP)); + Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // # of entries + Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); + unsigned AbbrevID = Stream.EmitAbbrev(Abbrev); + + RecordData Record; + Record.push_back(OBJC_CATEGORIES_MAP); + Record.push_back(CategoriesMap.size()); + Stream.EmitRecordWithBlob(AbbrevID, Record, + reinterpret_cast<char*>(CategoriesMap.data()), + CategoriesMap.size() * sizeof(ObjCCategoriesInfo)); + + // Emit the category lists. + Stream.EmitRecord(OBJC_CATEGORIES, Categories); +} + +void ASTWriter::WriteMergedDecls() { + if (!Chain || Chain->MergedDecls.empty()) + return; + + RecordData Record; + for (ASTReader::MergedDeclsMap::iterator I = Chain->MergedDecls.begin(), + IEnd = Chain->MergedDecls.end(); + I != IEnd; ++I) { + DeclID CanonID = I->first->isFromASTFile()? I->first->getGlobalID() + : getDeclID(I->first); + assert(CanonID && "Merged declaration not known?"); + + Record.push_back(CanonID); + Record.push_back(I->second.size()); + Record.append(I->second.begin(), I->second.end()); + } + Stream.EmitRecord(MERGED_DECLARATIONS, Record); +} + //===----------------------------------------------------------------------===// // General Serialization Routines //===----------------------------------------------------------------------===// @@ -2705,10 +3116,13 @@ void ASTWriter::SetSelectorOffset(Selector Sel, uint32_t Offset) { } ASTWriter::ASTWriter(llvm::BitstreamWriter &Stream) - : Stream(Stream), Context(0), Chain(0), WritingAST(false), + : Stream(Stream), Context(0), PP(0), Chain(0), WritingModule(0), + WritingAST(false), ASTHasCompilerErrors(false), FirstDeclID(NUM_PREDEF_DECL_IDS), NextDeclID(FirstDeclID), FirstTypeID(NUM_PREDEF_TYPE_IDS), NextTypeID(FirstTypeID), FirstIdentID(NUM_PREDEF_IDENT_IDS), NextIdentID(FirstIdentID), + FirstSubmoduleID(NUM_PREDEF_SUBMODULE_IDS), + NextSubmoduleID(FirstSubmoduleID), FirstSelectorID(NUM_PREDEF_SELECTOR_IDS), NextSelectorID(FirstSelectorID), CollectedStmts(&StmtsToEmit), NumStatements(0), NumMacros(0), NumLexicalDeclContexts(0), @@ -2724,11 +3138,20 @@ ASTWriter::ASTWriter(llvm::BitstreamWriter &Stream) { } +ASTWriter::~ASTWriter() { + for (FileDeclIDsTy::iterator + I = FileDeclIDs.begin(), E = FileDeclIDs.end(); I != E; ++I) + delete I->second; +} + void ASTWriter::WriteAST(Sema &SemaRef, MemorizeStatCalls *StatCalls, const std::string &OutputFile, - bool IsModule, StringRef isysroot) { + Module *WritingModule, StringRef isysroot, + bool hasErrors) { WritingAST = true; + ASTHasCompilerErrors = hasErrors; + // Emit the file header. Stream.Emit((unsigned)'C', 8); Stream.Emit((unsigned)'P', 8); @@ -2738,8 +3161,12 @@ void ASTWriter::WriteAST(Sema &SemaRef, MemorizeStatCalls *StatCalls, WriteBlockInfoBlock(); Context = &SemaRef.Context; - WriteASTCore(SemaRef, StatCalls, isysroot, OutputFile, IsModule); + PP = &SemaRef.PP; + this->WritingModule = WritingModule; + WriteASTCore(SemaRef, StatCalls, isysroot, OutputFile, WritingModule); Context = 0; + PP = 0; + this->WritingModule = 0; WritingAST = false; } @@ -2755,9 +3182,14 @@ static void AddLazyVectorDecls(ASTWriter &Writer, Vector &Vec, void ASTWriter::WriteASTCore(Sema &SemaRef, MemorizeStatCalls *StatCalls, StringRef isysroot, - const std::string &OutputFile, bool IsModule) { + const std::string &OutputFile, + Module *WritingModule) { using namespace llvm; + // Make sure that the AST reader knows to finalize itself. + if (Chain) + Chain->finalizeForWriting(); + ASTContext &Context = SemaRef.Context; Preprocessor &PP = SemaRef.PP; @@ -2769,6 +3201,8 @@ void ASTWriter::WriteASTCore(Sema &SemaRef, MemorizeStatCalls *StatCalls, DeclIDs[Context.ObjCSelDecl] = PREDEF_DECL_OBJC_SEL_ID; if (Context.ObjCClassDecl) DeclIDs[Context.ObjCClassDecl] = PREDEF_DECL_OBJC_CLASS_ID; + if (Context.ObjCProtocolClassDecl) + DeclIDs[Context.ObjCProtocolClassDecl] = PREDEF_DECL_OBJC_PROTOCOL_ID; if (Context.Int128Decl) DeclIDs[Context.Int128Decl] = PREDEF_DECL_INT_128_ID; if (Context.UInt128Decl) @@ -2785,11 +3219,20 @@ void ASTWriter::WriteASTCore(Sema &SemaRef, MemorizeStatCalls *StatCalls, IdentifierTable &Table = PP.getIdentifierTable(); SmallVector<const char *, 32> BuiltinNames; Context.BuiltinInfo.GetBuiltinNames(BuiltinNames, - Context.getLangOptions().NoBuiltin); + Context.getLangOpts().NoBuiltin); for (unsigned I = 0, N = BuiltinNames.size(); I != N; ++I) getIdentifierRef(&Table.get(BuiltinNames[I])); } + // If there are any out-of-date identifiers, bring them up to date. + if (ExternalPreprocessorSource *ExtSource = PP.getExternalSource()) { + for (IdentifierTable::iterator ID = PP.getIdentifierTable().begin(), + IDEnd = PP.getIdentifierTable().end(); + ID != IDEnd; ++ID) + if (ID->second->isOutOfDate()) + ExtSource->updateOutOfDateIdentifier(*ID->second); + } + // Build a record containing all of the tentative definitions in this file, in // TentativeDefinitions order. Generally, this record will be empty for // headers. @@ -2890,52 +3333,9 @@ void ASTWriter::WriteASTCore(Sema &SemaRef, MemorizeStatCalls *StatCalls, RecordData Record; Stream.EnterSubblock(AST_BLOCK_ID, 5); WriteMetadata(Context, isysroot, OutputFile); - WriteLanguageOptions(Context.getLangOptions()); + WriteLanguageOptions(Context.getLangOpts()); if (StatCalls && isysroot.empty()) WriteStatCache(*StatCalls); - WriteSourceManagerBlock(Context.getSourceManager(), PP, isysroot); - - if (Chain) { - // Write the mapping information describing our module dependencies and how - // each of those modules were mapped into our own offset/ID space, so that - // the reader can build the appropriate mapping to its own offset/ID space. - // The map consists solely of a blob with the following format: - // *(module-name-len:i16 module-name:len*i8 - // source-location-offset:i32 - // identifier-id:i32 - // preprocessed-entity-id:i32 - // macro-definition-id:i32 - // selector-id:i32 - // declaration-id:i32 - // c++-base-specifiers-id:i32 - // type-id:i32) - // - llvm::BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); - Abbrev->Add(BitCodeAbbrevOp(MODULE_OFFSET_MAP)); - Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); - unsigned ModuleOffsetMapAbbrev = Stream.EmitAbbrev(Abbrev); - llvm::SmallString<2048> Buffer; - { - llvm::raw_svector_ostream Out(Buffer); - for (ModuleManager::ModuleConstIterator M = Chain->ModuleMgr.begin(), - MEnd = Chain->ModuleMgr.end(); - M != MEnd; ++M) { - StringRef FileName = (*M)->FileName; - io::Emit16(Out, FileName.size()); - Out.write(FileName.data(), FileName.size()); - io::Emit32(Out, (*M)->SLocEntryBaseOffset); - io::Emit32(Out, (*M)->BaseIdentifierID); - io::Emit32(Out, (*M)->BasePreprocessedEntityID); - io::Emit32(Out, (*M)->BaseSelectorID); - io::Emit32(Out, (*M)->BaseDeclID); - io::Emit32(Out, (*M)->BaseTypeIndex); - } - } - Record.clear(); - Record.push_back(MODULE_OFFSET_MAP); - Stream.EmitRecordWithBlob(ModuleOffsetMapAbbrev, Record, - Buffer.data(), Buffer.size()); - } // Create a lexical update block containing all of the declarations in the // translation unit that do not come from other AST files. @@ -2946,8 +3346,6 @@ void ASTWriter::WriteASTCore(Sema &SemaRef, MemorizeStatCalls *StatCalls, I != E; ++I) { if (!(*I)->isFromASTFile()) NewGlobalDecls.push_back(std::make_pair((*I)->getKind(), GetDeclRef(*I))); - else if ((*I)->isChangedSinceDeserialization()) - (void)GetDeclRef(*I); // Make sure it's written, but don't record it. } llvm::BitCodeAbbrev *Abv = new llvm::BitCodeAbbrev(); @@ -2978,15 +3376,12 @@ void ASTWriter::WriteASTCore(Sema &SemaRef, MemorizeStatCalls *StatCalls, } } - // Resolve any declaration pointers within the declaration updates block and - // chained Objective-C categories block to declaration IDs. + // Resolve any declaration pointers within the declaration updates block. ResolveDeclUpdatesBlocks(); - ResolveChainedObjCCategories(); // Form the record of special types. RecordData SpecialTypes; AddTypeRef(Context.getBuiltinVaListType(), SpecialTypes); - AddTypeRef(Context.ObjCProtoType, SpecialTypes); AddTypeRef(Context.getRawCFConstantStringType(), SpecialTypes); AddTypeRef(Context.getFILEType(), SpecialTypes); AddTypeRef(Context.getjmp_bufType(), SpecialTypes); @@ -2995,7 +3390,7 @@ void ASTWriter::WriteASTCore(Sema &SemaRef, MemorizeStatCalls *StatCalls, AddTypeRef(Context.ObjCClassRedefinitionType, SpecialTypes); AddTypeRef(Context.ObjCSelRedefinitionType, SpecialTypes); AddTypeRef(Context.getucontext_tType(), SpecialTypes); - + // Keep writing types and declarations until all types and // declarations have been written. Stream.EnterSubblock(DECLTYPES_BLOCK_ID, NUM_ALLOWED_ABBREVS_SIZE); @@ -3014,11 +3409,57 @@ void ASTWriter::WriteASTCore(Sema &SemaRef, MemorizeStatCalls *StatCalls, } Stream.ExitBlock(); - WritePreprocessor(PP, IsModule); + WriteFileDeclIDsMap(); + WriteSourceManagerBlock(Context.getSourceManager(), PP, isysroot); + + if (Chain) { + // Write the mapping information describing our module dependencies and how + // each of those modules were mapped into our own offset/ID space, so that + // the reader can build the appropriate mapping to its own offset/ID space. + // The map consists solely of a blob with the following format: + // *(module-name-len:i16 module-name:len*i8 + // source-location-offset:i32 + // identifier-id:i32 + // preprocessed-entity-id:i32 + // macro-definition-id:i32 + // submodule-id:i32 + // selector-id:i32 + // declaration-id:i32 + // c++-base-specifiers-id:i32 + // type-id:i32) + // + llvm::BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); + Abbrev->Add(BitCodeAbbrevOp(MODULE_OFFSET_MAP)); + Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); + unsigned ModuleOffsetMapAbbrev = Stream.EmitAbbrev(Abbrev); + SmallString<2048> Buffer; + { + llvm::raw_svector_ostream Out(Buffer); + for (ModuleManager::ModuleConstIterator M = Chain->ModuleMgr.begin(), + MEnd = Chain->ModuleMgr.end(); + M != MEnd; ++M) { + StringRef FileName = (*M)->FileName; + io::Emit16(Out, FileName.size()); + Out.write(FileName.data(), FileName.size()); + io::Emit32(Out, (*M)->SLocEntryBaseOffset); + io::Emit32(Out, (*M)->BaseIdentifierID); + io::Emit32(Out, (*M)->BasePreprocessedEntityID); + io::Emit32(Out, (*M)->BaseSubmoduleID); + io::Emit32(Out, (*M)->BaseSelectorID); + io::Emit32(Out, (*M)->BaseDeclID); + io::Emit32(Out, (*M)->BaseTypeIndex); + } + } + Record.clear(); + Record.push_back(MODULE_OFFSET_MAP); + Stream.EmitRecordWithBlob(ModuleOffsetMapAbbrev, Record, + Buffer.data(), Buffer.size()); + } + WritePreprocessor(PP, WritingModule != 0); WriteHeaderSearch(PP.getHeaderSearchInfo(), isysroot); WriteSelectors(SemaRef); WriteReferencedSelectorsPool(SemaRef); - WriteIdentifierTable(PP, IsModule); + WriteIdentifierTable(PP, SemaRef.IdResolver, WritingModule != 0); WriteFPPragmaOptions(SemaRef.getFPOptions()); WriteOpenCLExtensions(SemaRef); @@ -3027,20 +3468,11 @@ void ASTWriter::WriteASTCore(Sema &SemaRef, MemorizeStatCalls *StatCalls, WriteCXXBaseSpecifiersOffsets(); - Stream.EmitRecord(SPECIAL_TYPES, SpecialTypes); + // If we're emitting a module, write out the submodule information. + if (WritingModule) + WriteSubmodules(WritingModule); - /// Build a record containing first declarations from a chained PCH and the - /// most recent declarations in this AST that they point to. - RecordData FirstLatestDeclIDs; - for (FirstLatestDeclMap::iterator I = FirstLatestDecls.begin(), - E = FirstLatestDecls.end(); - I != E; ++I) { - AddDeclRef(I->first, FirstLatestDeclIDs); - AddDeclRef(I->second, FirstLatestDeclIDs); - } - - if (!FirstLatestDeclIDs.empty()) - Stream.EmitRecord(REDECLS_UPDATE_LATEST, FirstLatestDeclIDs); + Stream.EmitRecord(SPECIAL_TYPES, SpecialTypes); // Write the record containing external, unnamed definitions. if (!ExternalDefinitions.empty()) @@ -3103,10 +3535,34 @@ void ASTWriter::WriteASTCore(Sema &SemaRef, MemorizeStatCalls *StatCalls, I != E; ++I) WriteDeclContextVisibleUpdate(*I); + if (!WritingModule) { + // Write the submodules that were imported, if any. + RecordData ImportedModules; + for (ASTContext::import_iterator I = Context.local_import_begin(), + IEnd = Context.local_import_end(); + I != IEnd; ++I) { + assert(SubmoduleIDs.find(I->getImportedModule()) != SubmoduleIDs.end()); + ImportedModules.push_back(SubmoduleIDs[I->getImportedModule()]); + } + if (!ImportedModules.empty()) { + // Sort module IDs. + llvm::array_pod_sort(ImportedModules.begin(), ImportedModules.end()); + + // Unique module IDs. + ImportedModules.erase(std::unique(ImportedModules.begin(), + ImportedModules.end()), + ImportedModules.end()); + + Stream.EmitRecord(IMPORTED_MODULES, ImportedModules); + } + } + WriteDeclUpdatesBlocks(); WriteDeclReplacementsBlock(); - WriteChainedObjCCategories(); - + WriteMergedDecls(); + WriteRedeclarations(); + WriteObjCCategories(); + // Some simple statistics Record.clear(); Record.push_back(NumStatements); @@ -3125,13 +3581,12 @@ void ASTWriter::ResolveDeclUpdatesBlocks() { const Decl *D = I->first; UpdateRecord &URec = I->second; - if (DeclsToRewrite.count(D)) + if (isRewritten(D)) continue; // The decl will be written completely unsigned Idx = 0, N = URec.size(); while (Idx < N) { switch ((DeclUpdateKind)URec[Idx++]) { - case UPD_CXX_SET_DEFINITIONDATA: case UPD_CXX_ADDED_IMPLICIT_MEMBER: case UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION: case UPD_CXX_ADDED_ANONYMOUS_NAMESPACE: @@ -3158,7 +3613,7 @@ void ASTWriter::WriteDeclUpdatesBlocks() { const Decl *D = I->first; UpdateRecord &URec = I->second; - if (DeclsToRewrite.count(D)) + if (isRewritten(D)) continue; // The decl will be written completely,no need to store updates. uint64_t Offset = Stream.GetCurrentBitNo(); @@ -3176,45 +3631,15 @@ void ASTWriter::WriteDeclReplacementsBlock() { return; RecordData Record; - for (SmallVector<std::pair<DeclID, uint64_t>, 16>::iterator + for (SmallVector<ReplacedDeclInfo, 16>::iterator I = ReplacedDecls.begin(), E = ReplacedDecls.end(); I != E; ++I) { - Record.push_back(I->first); - Record.push_back(I->second); + Record.push_back(I->ID); + Record.push_back(I->Offset); + Record.push_back(I->Loc); } Stream.EmitRecord(DECL_REPLACEMENTS, Record); } -void ASTWriter::ResolveChainedObjCCategories() { - for (SmallVector<ChainedObjCCategoriesData, 16>::iterator - I = LocalChainedObjCCategories.begin(), - E = LocalChainedObjCCategories.end(); I != E; ++I) { - ChainedObjCCategoriesData &Data = *I; - Data.InterfaceID = GetDeclRef(Data.Interface); - Data.TailCategoryID = GetDeclRef(Data.TailCategory); - } - -} - -void ASTWriter::WriteChainedObjCCategories() { - if (LocalChainedObjCCategories.empty()) - return; - - RecordData Record; - for (SmallVector<ChainedObjCCategoriesData, 16>::iterator - I = LocalChainedObjCCategories.begin(), - E = LocalChainedObjCCategories.end(); I != E; ++I) { - ChainedObjCCategoriesData &Data = *I; - serialization::DeclID - HeadCatID = getDeclID(Data.Interface->getCategoryList()); - assert(HeadCatID != 0 && "Category not written ?"); - - Record.push_back(Data.InterfaceID); - Record.push_back(HeadCatID); - Record.push_back(Data.TailCategoryID); - } - Stream.EmitRecord(OBJC_CHAINED_CATEGORIES, Record); -} - void ASTWriter::AddSourceLocation(SourceLocation Loc, RecordDataImpl &Record) { Record.push_back(Loc.getRawEncoding()); } @@ -3397,6 +3822,12 @@ DeclID ASTWriter::GetDeclRef(const Decl *D) { if (D == 0) { return 0; } + + // If D comes from an AST file, its declaration ID is already known and + // fixed. + if (D->isFromASTFile()) + return D->getGlobalID(); + assert(!(reinterpret_cast<uintptr_t>(D) & 0x01) && "Invalid decl pointer"); DeclID &ID = DeclIDs[D]; if (ID == 0) { @@ -3404,12 +3835,6 @@ DeclID ASTWriter::GetDeclRef(const Decl *D) { // enqueue it in the list of declarations to emit. ID = NextDeclID++; DeclTypesToEmit.push(const_cast<Decl *>(D)); - } else if (ID < FirstDeclID && D->isChangedSinceDeserialization()) { - // We don't add it to the replacement collection here, because we don't - // have the offset yet. - DeclTypesToEmit.push(const_cast<Decl *>(D)); - // Reset the flag, so that we don't add this decl multiple times. - const_cast<Decl *>(D)->setChangedSinceDeserialization(false); } return ID; @@ -3419,10 +3844,65 @@ DeclID ASTWriter::getDeclID(const Decl *D) { if (D == 0) return 0; + // If D comes from an AST file, its declaration ID is already known and + // fixed. + if (D->isFromASTFile()) + return D->getGlobalID(); + assert(DeclIDs.find(D) != DeclIDs.end() && "Declaration not emitted!"); return DeclIDs[D]; } +static inline bool compLocDecl(std::pair<unsigned, serialization::DeclID> L, + std::pair<unsigned, serialization::DeclID> R) { + return L.first < R.first; +} + +void ASTWriter::associateDeclWithFile(const Decl *D, DeclID ID) { + assert(ID); + assert(D); + + SourceLocation Loc = D->getLocation(); + if (Loc.isInvalid()) + return; + + // We only keep track of the file-level declarations of each file. + if (!D->getLexicalDeclContext()->isFileContext()) + return; + // FIXME: ParmVarDecls that are part of a function type of a parameter of + // a function/objc method, should not have TU as lexical context. + if (isa<ParmVarDecl>(D)) + return; + + SourceManager &SM = Context->getSourceManager(); + SourceLocation FileLoc = SM.getFileLoc(Loc); + assert(SM.isLocalSourceLocation(FileLoc)); + FileID FID; + unsigned Offset; + llvm::tie(FID, Offset) = SM.getDecomposedLoc(FileLoc); + if (FID.isInvalid()) + return; + const SrcMgr::SLocEntry *Entry = &SM.getSLocEntry(FID); + assert(Entry->isFile()); + + DeclIDInFileInfo *&Info = FileDeclIDs[Entry]; + if (!Info) + Info = new DeclIDInFileInfo(); + + std::pair<unsigned, serialization::DeclID> LocDecl(Offset, ID); + LocDeclIDsTy &Decls = Info->DeclIDs; + + if (Decls.empty() || Decls.back().first <= Offset) { + Decls.push_back(LocDecl); + return; + } + + LocDeclIDsTy::iterator + I = std::upper_bound(Decls.begin(), Decls.end(), LocDecl, compLocDecl); + + Decls.insert(I, LocDecl); +} + void ASTWriter::AddDeclarationName(DeclarationName Name, RecordDataImpl &Record) { // FIXME: Emit a stable enum for NameKind. 0 = Identifier etc. Record.push_back(Name.getNameKind()); @@ -3776,11 +4256,11 @@ void ASTWriter::AddCXXCtorInitializers( if (Init->isBaseInitializer()) { Record.push_back(CTOR_INITIALIZER_BASE); - AddTypeSourceInfo(Init->getBaseClassInfo(), Record); + AddTypeSourceInfo(Init->getTypeSourceInfo(), Record); Record.push_back(Init->isBaseVirtual()); } else if (Init->isDelegatingInitializer()) { Record.push_back(CTOR_INITIALIZER_DELEGATING); - AddDeclRef(Init->getTargetConstructor(), Record); + AddTypeSourceInfo(Init->getTypeSourceInfo(), Record); } else if (Init->isMemberInitializer()){ Record.push_back(CTOR_INITIALIZER_MEMBER); AddDeclRef(Init->getMember(), Record); @@ -3807,6 +4287,7 @@ void ASTWriter::AddCXXCtorInitializers( void ASTWriter::AddCXXDefinitionData(const CXXRecordDecl *D, RecordDataImpl &Record) { assert(D->DefinitionData); struct CXXRecordDecl::DefinitionData &Data = *D->DefinitionData; + Record.push_back(Data.IsLambda); Record.push_back(Data.UserDeclaredConstructor); Record.push_back(Data.UserDeclaredCopyConstructor); Record.push_back(Data.UserDeclaredMoveConstructor); @@ -3824,13 +4305,21 @@ void ASTWriter::AddCXXDefinitionData(const CXXRecordDecl *D, RecordDataImpl &Rec Record.push_back(Data.HasProtectedFields); Record.push_back(Data.HasPublicFields); Record.push_back(Data.HasMutableFields); + Record.push_back(Data.HasOnlyCMembers); Record.push_back(Data.HasTrivialDefaultConstructor); Record.push_back(Data.HasConstexprNonCopyMoveConstructor); + Record.push_back(Data.DefaultedDefaultConstructorIsConstexpr); + Record.push_back(Data.DefaultedCopyConstructorIsConstexpr); + Record.push_back(Data.DefaultedMoveConstructorIsConstexpr); + Record.push_back(Data.HasConstexprDefaultConstructor); + Record.push_back(Data.HasConstexprCopyConstructor); + Record.push_back(Data.HasConstexprMoveConstructor); Record.push_back(Data.HasTrivialCopyConstructor); Record.push_back(Data.HasTrivialMoveConstructor); Record.push_back(Data.HasTrivialCopyAssignment); Record.push_back(Data.HasTrivialMoveAssignment); Record.push_back(Data.HasTrivialDestructor); + Record.push_back(Data.HasIrrelevantDestructor); Record.push_back(Data.HasNonLiteralTypeFieldsOrBases); Record.push_back(Data.ComputedVisibleConversions); Record.push_back(Data.UserProvidedDefaultConstructor); @@ -3842,6 +4331,7 @@ void ASTWriter::AddCXXDefinitionData(const CXXRecordDecl *D, RecordDataImpl &Rec Record.push_back(Data.DeclaredDestructor); Record.push_back(Data.FailedImplicitMoveConstructor); Record.push_back(Data.FailedImplicitMoveAssignment); + // IsLambda bit is already saved. Record.push_back(Data.NumBases); if (Data.NumBases > 0) @@ -3858,6 +4348,27 @@ void ASTWriter::AddCXXDefinitionData(const CXXRecordDecl *D, RecordDataImpl &Rec AddUnresolvedSet(Data.VisibleConversions, Record); // Data.Definition is the owning decl, no need to write it. AddDeclRef(Data.FirstFriend, Record); + + // Add lambda-specific data. + if (Data.IsLambda) { + CXXRecordDecl::LambdaDefinitionData &Lambda = D->getLambdaData(); + Record.push_back(Lambda.Dependent); + Record.push_back(Lambda.NumCaptures); + Record.push_back(Lambda.NumExplicitCaptures); + Record.push_back(Lambda.ManglingNumber); + AddDeclRef(Lambda.ContextDecl, Record); + for (unsigned I = 0, N = Lambda.NumCaptures; I != N; ++I) { + LambdaExpr::Capture &Capture = Lambda.Captures[I]; + AddSourceLocation(Capture.getLocation(), Record); + Record.push_back(Capture.isImplicit()); + Record.push_back(Capture.getCaptureKind()); // FIXME: stable! + VarDecl *Var = Capture.capturesVariable()? Capture.getCapturedVar() : 0; + AddDeclRef(Var, Record); + AddSourceLocation(Capture.isPackExpansion()? Capture.getEllipsisLoc() + : SourceLocation(), + Record); + } + } } void ASTWriter::ReaderInitialized(ASTReader *Reader) { @@ -3866,6 +4377,7 @@ void ASTWriter::ReaderInitialized(ASTReader *Reader) { assert(FirstDeclID == NextDeclID && FirstTypeID == NextTypeID && FirstIdentID == NextIdentID && + FirstSubmoduleID == NextSubmoduleID && FirstSelectorID == NextSelectorID && "Setting chain after writing has started."); @@ -3874,11 +4386,13 @@ void ASTWriter::ReaderInitialized(ASTReader *Reader) { FirstDeclID = NUM_PREDEF_DECL_IDS + Chain->getTotalNumDecls(); FirstTypeID = NUM_PREDEF_TYPE_IDS + Chain->getTotalNumTypes(); FirstIdentID = NUM_PREDEF_IDENT_IDS + Chain->getTotalNumIdentifiers(); + FirstSubmoduleID = NUM_PREDEF_SUBMODULE_IDS + Chain->getTotalNumSubmodules(); FirstSelectorID = NUM_PREDEF_SELECTOR_IDS + Chain->getTotalNumSelectors(); NextDeclID = FirstDeclID; NextTypeID = FirstTypeID; NextIdentID = FirstIdentID; NextSelectorID = FirstSelectorID; + NextSubmoduleID = FirstSubmoduleID; } void ASTWriter::IdentifierRead(IdentID ID, IdentifierInfo *II) { @@ -3898,10 +4412,6 @@ void ASTWriter::TypeRead(TypeIdx Idx, QualType T) { StoredIdx = Idx; } -void ASTWriter::DeclRead(DeclID ID, const Decl *D) { - DeclIDs[D] = ID; -} - void ASTWriter::SelectorRead(SelectorID ID, Selector S) { SelectorIDs[S] = ID; } @@ -3912,6 +4422,15 @@ void ASTWriter::MacroDefinitionRead(serialization::PreprocessedEntityID ID, MacroDefinitions[MD] = ID; } +void ASTWriter::MacroVisible(IdentifierInfo *II) { + DeserializedMacroNames.push_back(II); +} + +void ASTWriter::ModuleRead(serialization::SubmoduleID ID, Module *Mod) { + assert(SubmoduleIDs.find(Mod) == SubmoduleIDs.end()); + SubmoduleIDs[Mod] = ID; +} + void ASTWriter::CompletedTagDefinition(const TagDecl *D) { assert(D->isCompleteDefinition()); assert(!WritingAST && "Already writing the AST!"); @@ -3923,22 +4442,6 @@ void ASTWriter::CompletedTagDefinition(const TagDecl *D) { // have created a new definition decl instead ? RewriteDecl(RD); } - - for (CXXRecordDecl::redecl_iterator - I = RD->redecls_begin(), E = RD->redecls_end(); I != E; ++I) { - CXXRecordDecl *Redecl = cast<CXXRecordDecl>(*I); - if (Redecl == RD) - continue; - - // We are interested when a PCH decl is modified. - if (Redecl->isFromASTFile()) { - UpdateRecord &Record = DeclUpdates[Redecl]; - Record.push_back(UPD_CXX_SET_DEFINITIONDATA); - assert(Redecl->DefinitionData); - assert(Redecl->DefinitionData->Definition == D); - Record.push_back(reinterpret_cast<uint64_t>(D)); // the DefinitionDecl - } - } } } void ASTWriter::AddedVisibleDecl(const DeclContext *DC, const Decl *D) { @@ -4023,11 +4526,23 @@ void ASTWriter::AddedObjCCategoryToInterface(const ObjCCategoryDecl *CatD, assert(!WritingAST && "Already writing the AST!"); if (!IFD->isFromASTFile()) return; // Declaration not imported from PCH. - if (CatD->getNextClassCategory() && - !CatD->getNextClassCategory()->isFromASTFile()) - return; // We already recorded that the tail of a category chain should be - // attached to an interface. + + assert(IFD->getDefinition() && "Category on a class without a definition?"); + ObjCClassesWithCategories.insert( + const_cast<ObjCInterfaceDecl *>(IFD->getDefinition())); +} + + +void ASTWriter::AddedObjCPropertyInClassExtension(const ObjCPropertyDecl *Prop, + const ObjCPropertyDecl *OrigProp, + const ObjCCategoryDecl *ClassExt) { + const ObjCInterfaceDecl *D = ClassExt->getClassInterface(); + if (!D) + return; + + assert(!WritingAST && "Already writing the AST!"); + if (!D->isFromASTFile()) + return; // Declaration not imported from PCH. - ChainedObjCCategoriesData Data = { IFD, CatD, 0, 0 }; - LocalChainedObjCCategories.push_back(Data); + RewriteDecl(D); } |
