diff options
| author | Dimitry Andric <dim@FreeBSD.org> | 2022-07-03 14:10:23 +0000 |
|---|---|---|
| committer | Dimitry Andric <dim@FreeBSD.org> | 2022-07-03 14:10:23 +0000 |
| commit | 145449b1e420787bb99721a429341fa6be3adfb6 (patch) | |
| tree | 1d56ae694a6de602e348dd80165cf881a36600ed /clang/lib/Serialization/ASTWriter.cpp | |
| parent | ecbca9f5fb7d7613d2b94982c4825eb0d33d6842 (diff) | |
Vendor import of llvm-project main llvmorg-15-init-15358-g53dc0f107877.vendor/llvm-project/llvmorg-15-init-15358-g53dc0f107877
Diffstat (limited to 'clang/lib/Serialization/ASTWriter.cpp')
| -rw-r--r-- | clang/lib/Serialization/ASTWriter.cpp | 461 |
1 files changed, 257 insertions, 204 deletions
diff --git a/clang/lib/Serialization/ASTWriter.cpp b/clang/lib/Serialization/ASTWriter.cpp index 763fc9537c04..1787909bb6f7 100644 --- a/clang/lib/Serialization/ASTWriter.cpp +++ b/clang/lib/Serialization/ASTWriter.cpp @@ -164,8 +164,8 @@ namespace { std::set<const FileEntry *> GetAllModuleMaps(const HeaderSearch &HS, Module *RootModule) { std::set<const FileEntry *> ModuleMaps{}; - std::set<Module *> ProcessedModules; - SmallVector<Module *> ModulesToProcess{RootModule}; + std::set<const Module *> ProcessedModules; + SmallVector<const Module *> ModulesToProcess{RootModule}; SmallVector<const FileEntry *, 16> FilesByUID; HS.getFileMgr().GetUniqueIDMapping(FilesByUID); @@ -209,6 +209,11 @@ std::set<const FileEntry *> GetAllModuleMaps(const HeaderSearch &HS, } ModulesToProcess.push_back(ImportedModule); } + + for (const Module *UndeclaredModule : CurrentModule->UndeclaredUses) + if (UndeclaredModule && + ProcessedModules.find(UndeclaredModule) == ProcessedModules.end()) + ModulesToProcess.push_back(UndeclaredModule); } return ModuleMaps; @@ -240,10 +245,19 @@ public: }; class TypeLocWriter : public TypeLocVisitor<TypeLocWriter> { + using LocSeq = SourceLocationSequence; + ASTRecordWriter &Record; + LocSeq *Seq; + + void addSourceLocation(SourceLocation Loc) { + Record.AddSourceLocation(Loc, Seq); + } + void addSourceRange(SourceRange Range) { Record.AddSourceRange(Range, Seq); } public: - TypeLocWriter(ASTRecordWriter &Record) : Record(Record) {} + TypeLocWriter(ASTRecordWriter &Record, LocSeq *Seq) + : Record(Record), Seq(Seq) {} #define ABSTRACT_TYPELOC(CLASS, PARENT) #define TYPELOC(CLASS, PARENT) \ @@ -261,7 +275,7 @@ void TypeLocWriter::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) { } void TypeLocWriter::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) { - Record.AddSourceLocation(TL.getBuiltinLoc()); + addSourceLocation(TL.getBuiltinLoc()); if (TL.needsExtraLocalData()) { Record.push_back(TL.getWrittenTypeSpec()); Record.push_back(static_cast<uint64_t>(TL.getWrittenSignSpec())); @@ -271,11 +285,11 @@ void TypeLocWriter::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) { } void TypeLocWriter::VisitComplexTypeLoc(ComplexTypeLoc TL) { - Record.AddSourceLocation(TL.getNameLoc()); + addSourceLocation(TL.getNameLoc()); } void TypeLocWriter::VisitPointerTypeLoc(PointerTypeLoc TL) { - Record.AddSourceLocation(TL.getStarLoc()); + addSourceLocation(TL.getStarLoc()); } void TypeLocWriter::VisitDecayedTypeLoc(DecayedTypeLoc TL) { @@ -287,25 +301,25 @@ void TypeLocWriter::VisitAdjustedTypeLoc(AdjustedTypeLoc TL) { } void TypeLocWriter::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) { - Record.AddSourceLocation(TL.getCaretLoc()); + addSourceLocation(TL.getCaretLoc()); } void TypeLocWriter::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) { - Record.AddSourceLocation(TL.getAmpLoc()); + addSourceLocation(TL.getAmpLoc()); } void TypeLocWriter::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) { - Record.AddSourceLocation(TL.getAmpAmpLoc()); + addSourceLocation(TL.getAmpAmpLoc()); } void TypeLocWriter::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) { - Record.AddSourceLocation(TL.getStarLoc()); + addSourceLocation(TL.getStarLoc()); Record.AddTypeSourceInfo(TL.getClassTInfo()); } void TypeLocWriter::VisitArrayTypeLoc(ArrayTypeLoc TL) { - Record.AddSourceLocation(TL.getLBracketLoc()); - Record.AddSourceLocation(TL.getRBracketLoc()); + addSourceLocation(TL.getLBracketLoc()); + addSourceLocation(TL.getRBracketLoc()); Record.push_back(TL.getSizeExpr() ? 1 : 0); if (TL.getSizeExpr()) Record.AddStmt(TL.getSizeExpr()); @@ -330,56 +344,56 @@ void TypeLocWriter::VisitDependentSizedArrayTypeLoc( void TypeLocWriter::VisitDependentAddressSpaceTypeLoc( DependentAddressSpaceTypeLoc TL) { - Record.AddSourceLocation(TL.getAttrNameLoc()); + addSourceLocation(TL.getAttrNameLoc()); SourceRange range = TL.getAttrOperandParensRange(); - Record.AddSourceLocation(range.getBegin()); - Record.AddSourceLocation(range.getEnd()); + addSourceLocation(range.getBegin()); + addSourceLocation(range.getEnd()); Record.AddStmt(TL.getAttrExprOperand()); } void TypeLocWriter::VisitDependentSizedExtVectorTypeLoc( DependentSizedExtVectorTypeLoc TL) { - Record.AddSourceLocation(TL.getNameLoc()); + addSourceLocation(TL.getNameLoc()); } void TypeLocWriter::VisitVectorTypeLoc(VectorTypeLoc TL) { - Record.AddSourceLocation(TL.getNameLoc()); + addSourceLocation(TL.getNameLoc()); } void TypeLocWriter::VisitDependentVectorTypeLoc( DependentVectorTypeLoc TL) { - Record.AddSourceLocation(TL.getNameLoc()); + addSourceLocation(TL.getNameLoc()); } void TypeLocWriter::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) { - Record.AddSourceLocation(TL.getNameLoc()); + addSourceLocation(TL.getNameLoc()); } void TypeLocWriter::VisitConstantMatrixTypeLoc(ConstantMatrixTypeLoc TL) { - Record.AddSourceLocation(TL.getAttrNameLoc()); + addSourceLocation(TL.getAttrNameLoc()); SourceRange range = TL.getAttrOperandParensRange(); - Record.AddSourceLocation(range.getBegin()); - Record.AddSourceLocation(range.getEnd()); + addSourceLocation(range.getBegin()); + addSourceLocation(range.getEnd()); Record.AddStmt(TL.getAttrRowOperand()); Record.AddStmt(TL.getAttrColumnOperand()); } void TypeLocWriter::VisitDependentSizedMatrixTypeLoc( DependentSizedMatrixTypeLoc TL) { - Record.AddSourceLocation(TL.getAttrNameLoc()); + addSourceLocation(TL.getAttrNameLoc()); SourceRange range = TL.getAttrOperandParensRange(); - Record.AddSourceLocation(range.getBegin()); - Record.AddSourceLocation(range.getEnd()); + addSourceLocation(range.getBegin()); + addSourceLocation(range.getEnd()); Record.AddStmt(TL.getAttrRowOperand()); Record.AddStmt(TL.getAttrColumnOperand()); } void TypeLocWriter::VisitFunctionTypeLoc(FunctionTypeLoc TL) { - Record.AddSourceLocation(TL.getLocalRangeBegin()); - Record.AddSourceLocation(TL.getLParenLoc()); - Record.AddSourceLocation(TL.getRParenLoc()); - Record.AddSourceRange(TL.getExceptionSpecRange()); - Record.AddSourceLocation(TL.getLocalRangeEnd()); + addSourceLocation(TL.getLocalRangeBegin()); + addSourceLocation(TL.getLParenLoc()); + addSourceLocation(TL.getRParenLoc()); + addSourceRange(TL.getExceptionSpecRange()); + addSourceLocation(TL.getLocalRangeEnd()); for (unsigned i = 0, e = TL.getNumParams(); i != e; ++i) Record.AddDeclRef(TL.getParam(i)); } @@ -393,189 +407,193 @@ void TypeLocWriter::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) { } void TypeLocWriter::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) { - Record.AddSourceLocation(TL.getNameLoc()); + addSourceLocation(TL.getNameLoc()); } void TypeLocWriter::VisitUsingTypeLoc(UsingTypeLoc TL) { - Record.AddSourceLocation(TL.getNameLoc()); + addSourceLocation(TL.getNameLoc()); } void TypeLocWriter::VisitTypedefTypeLoc(TypedefTypeLoc TL) { - Record.AddSourceLocation(TL.getNameLoc()); + addSourceLocation(TL.getNameLoc()); } void TypeLocWriter::VisitObjCTypeParamTypeLoc(ObjCTypeParamTypeLoc TL) { if (TL.getNumProtocols()) { - Record.AddSourceLocation(TL.getProtocolLAngleLoc()); - Record.AddSourceLocation(TL.getProtocolRAngleLoc()); + addSourceLocation(TL.getProtocolLAngleLoc()); + addSourceLocation(TL.getProtocolRAngleLoc()); } for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i) - Record.AddSourceLocation(TL.getProtocolLoc(i)); + addSourceLocation(TL.getProtocolLoc(i)); } void TypeLocWriter::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) { - Record.AddSourceLocation(TL.getTypeofLoc()); - Record.AddSourceLocation(TL.getLParenLoc()); - Record.AddSourceLocation(TL.getRParenLoc()); + addSourceLocation(TL.getTypeofLoc()); + addSourceLocation(TL.getLParenLoc()); + addSourceLocation(TL.getRParenLoc()); } void TypeLocWriter::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) { - Record.AddSourceLocation(TL.getTypeofLoc()); - Record.AddSourceLocation(TL.getLParenLoc()); - Record.AddSourceLocation(TL.getRParenLoc()); + addSourceLocation(TL.getTypeofLoc()); + addSourceLocation(TL.getLParenLoc()); + addSourceLocation(TL.getRParenLoc()); Record.AddTypeSourceInfo(TL.getUnderlyingTInfo()); } void TypeLocWriter::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) { - Record.AddSourceLocation(TL.getDecltypeLoc()); - Record.AddSourceLocation(TL.getRParenLoc()); + addSourceLocation(TL.getDecltypeLoc()); + addSourceLocation(TL.getRParenLoc()); } void TypeLocWriter::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) { - Record.AddSourceLocation(TL.getKWLoc()); - Record.AddSourceLocation(TL.getLParenLoc()); - Record.AddSourceLocation(TL.getRParenLoc()); + addSourceLocation(TL.getKWLoc()); + addSourceLocation(TL.getLParenLoc()); + addSourceLocation(TL.getRParenLoc()); Record.AddTypeSourceInfo(TL.getUnderlyingTInfo()); } void TypeLocWriter::VisitAutoTypeLoc(AutoTypeLoc TL) { - Record.AddSourceLocation(TL.getNameLoc()); + addSourceLocation(TL.getNameLoc()); Record.push_back(TL.isConstrained()); if (TL.isConstrained()) { Record.AddNestedNameSpecifierLoc(TL.getNestedNameSpecifierLoc()); - Record.AddSourceLocation(TL.getTemplateKWLoc()); - Record.AddSourceLocation(TL.getConceptNameLoc()); + addSourceLocation(TL.getTemplateKWLoc()); + addSourceLocation(TL.getConceptNameLoc()); Record.AddDeclRef(TL.getFoundDecl()); - Record.AddSourceLocation(TL.getLAngleLoc()); - Record.AddSourceLocation(TL.getRAngleLoc()); + addSourceLocation(TL.getLAngleLoc()); + addSourceLocation(TL.getRAngleLoc()); for (unsigned I = 0; I < TL.getNumArgs(); ++I) Record.AddTemplateArgumentLocInfo(TL.getTypePtr()->getArg(I).getKind(), TL.getArgLocInfo(I)); } Record.push_back(TL.isDecltypeAuto()); if (TL.isDecltypeAuto()) - Record.AddSourceLocation(TL.getRParenLoc()); + addSourceLocation(TL.getRParenLoc()); } void TypeLocWriter::VisitDeducedTemplateSpecializationTypeLoc( DeducedTemplateSpecializationTypeLoc TL) { - Record.AddSourceLocation(TL.getTemplateNameLoc()); + addSourceLocation(TL.getTemplateNameLoc()); } void TypeLocWriter::VisitRecordTypeLoc(RecordTypeLoc TL) { - Record.AddSourceLocation(TL.getNameLoc()); + addSourceLocation(TL.getNameLoc()); } void TypeLocWriter::VisitEnumTypeLoc(EnumTypeLoc TL) { - Record.AddSourceLocation(TL.getNameLoc()); + addSourceLocation(TL.getNameLoc()); } void TypeLocWriter::VisitAttributedTypeLoc(AttributedTypeLoc TL) { Record.AddAttr(TL.getAttr()); } +void TypeLocWriter::VisitBTFTagAttributedTypeLoc(BTFTagAttributedTypeLoc TL) { + // Nothing to do. +} + void TypeLocWriter::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) { - Record.AddSourceLocation(TL.getNameLoc()); + addSourceLocation(TL.getNameLoc()); } void TypeLocWriter::VisitSubstTemplateTypeParmTypeLoc( SubstTemplateTypeParmTypeLoc TL) { - Record.AddSourceLocation(TL.getNameLoc()); + addSourceLocation(TL.getNameLoc()); } void TypeLocWriter::VisitSubstTemplateTypeParmPackTypeLoc( SubstTemplateTypeParmPackTypeLoc TL) { - Record.AddSourceLocation(TL.getNameLoc()); + addSourceLocation(TL.getNameLoc()); } void TypeLocWriter::VisitTemplateSpecializationTypeLoc( TemplateSpecializationTypeLoc TL) { - Record.AddSourceLocation(TL.getTemplateKeywordLoc()); - Record.AddSourceLocation(TL.getTemplateNameLoc()); - Record.AddSourceLocation(TL.getLAngleLoc()); - Record.AddSourceLocation(TL.getRAngleLoc()); + addSourceLocation(TL.getTemplateKeywordLoc()); + addSourceLocation(TL.getTemplateNameLoc()); + addSourceLocation(TL.getLAngleLoc()); + addSourceLocation(TL.getRAngleLoc()); for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) Record.AddTemplateArgumentLocInfo(TL.getArgLoc(i).getArgument().getKind(), TL.getArgLoc(i).getLocInfo()); } void TypeLocWriter::VisitParenTypeLoc(ParenTypeLoc TL) { - Record.AddSourceLocation(TL.getLParenLoc()); - Record.AddSourceLocation(TL.getRParenLoc()); + addSourceLocation(TL.getLParenLoc()); + addSourceLocation(TL.getRParenLoc()); } void TypeLocWriter::VisitMacroQualifiedTypeLoc(MacroQualifiedTypeLoc TL) { - Record.AddSourceLocation(TL.getExpansionLoc()); + addSourceLocation(TL.getExpansionLoc()); } void TypeLocWriter::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) { - Record.AddSourceLocation(TL.getElaboratedKeywordLoc()); + addSourceLocation(TL.getElaboratedKeywordLoc()); Record.AddNestedNameSpecifierLoc(TL.getQualifierLoc()); } void TypeLocWriter::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) { - Record.AddSourceLocation(TL.getNameLoc()); + addSourceLocation(TL.getNameLoc()); } void TypeLocWriter::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) { - Record.AddSourceLocation(TL.getElaboratedKeywordLoc()); + addSourceLocation(TL.getElaboratedKeywordLoc()); Record.AddNestedNameSpecifierLoc(TL.getQualifierLoc()); - Record.AddSourceLocation(TL.getNameLoc()); + addSourceLocation(TL.getNameLoc()); } void TypeLocWriter::VisitDependentTemplateSpecializationTypeLoc( DependentTemplateSpecializationTypeLoc TL) { - Record.AddSourceLocation(TL.getElaboratedKeywordLoc()); + addSourceLocation(TL.getElaboratedKeywordLoc()); Record.AddNestedNameSpecifierLoc(TL.getQualifierLoc()); - Record.AddSourceLocation(TL.getTemplateKeywordLoc()); - Record.AddSourceLocation(TL.getTemplateNameLoc()); - Record.AddSourceLocation(TL.getLAngleLoc()); - Record.AddSourceLocation(TL.getRAngleLoc()); + addSourceLocation(TL.getTemplateKeywordLoc()); + addSourceLocation(TL.getTemplateNameLoc()); + addSourceLocation(TL.getLAngleLoc()); + addSourceLocation(TL.getRAngleLoc()); for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) Record.AddTemplateArgumentLocInfo(TL.getArgLoc(I).getArgument().getKind(), TL.getArgLoc(I).getLocInfo()); } void TypeLocWriter::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) { - Record.AddSourceLocation(TL.getEllipsisLoc()); + addSourceLocation(TL.getEllipsisLoc()); } void TypeLocWriter::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) { - Record.AddSourceLocation(TL.getNameLoc()); + addSourceLocation(TL.getNameLoc()); } void TypeLocWriter::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) { Record.push_back(TL.hasBaseTypeAsWritten()); - Record.AddSourceLocation(TL.getTypeArgsLAngleLoc()); - Record.AddSourceLocation(TL.getTypeArgsRAngleLoc()); + addSourceLocation(TL.getTypeArgsLAngleLoc()); + addSourceLocation(TL.getTypeArgsRAngleLoc()); for (unsigned i = 0, e = TL.getNumTypeArgs(); i != e; ++i) Record.AddTypeSourceInfo(TL.getTypeArgTInfo(i)); - Record.AddSourceLocation(TL.getProtocolLAngleLoc()); - Record.AddSourceLocation(TL.getProtocolRAngleLoc()); + addSourceLocation(TL.getProtocolLAngleLoc()); + addSourceLocation(TL.getProtocolRAngleLoc()); for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i) - Record.AddSourceLocation(TL.getProtocolLoc(i)); + addSourceLocation(TL.getProtocolLoc(i)); } void TypeLocWriter::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) { - Record.AddSourceLocation(TL.getStarLoc()); + addSourceLocation(TL.getStarLoc()); } void TypeLocWriter::VisitAtomicTypeLoc(AtomicTypeLoc TL) { - Record.AddSourceLocation(TL.getKWLoc()); - Record.AddSourceLocation(TL.getLParenLoc()); - Record.AddSourceLocation(TL.getRParenLoc()); + addSourceLocation(TL.getKWLoc()); + addSourceLocation(TL.getLParenLoc()); + addSourceLocation(TL.getRParenLoc()); } void TypeLocWriter::VisitPipeTypeLoc(PipeTypeLoc TL) { - Record.AddSourceLocation(TL.getKWLoc()); + addSourceLocation(TL.getKWLoc()); } void TypeLocWriter::VisitBitIntTypeLoc(clang::BitIntTypeLoc TL) { - Record.AddSourceLocation(TL.getNameLoc()); + addSourceLocation(TL.getNameLoc()); } void TypeLocWriter::VisitDependentBitIntTypeLoc( clang::DependentBitIntTypeLoc TL) { - Record.AddSourceLocation(TL.getNameLoc()); + addSourceLocation(TL.getNameLoc()); } void ASTWriter::WriteTypeAbbrevs() { @@ -589,30 +607,6 @@ void ASTWriter::WriteTypeAbbrevs() { Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 3)); // Quals TypeExtQualAbbrev = Stream.EmitAbbrev(std::move(Abv)); - - // Abbreviation for TYPE_FUNCTION_PROTO - Abv = std::make_shared<BitCodeAbbrev>(); - Abv->Add(BitCodeAbbrevOp(serialization::TYPE_FUNCTION_PROTO)); - // FunctionType - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // ReturnType - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // NoReturn - Abv->Add(BitCodeAbbrevOp(0)); // HasRegParm - Abv->Add(BitCodeAbbrevOp(0)); // RegParm - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 4)); // CC - Abv->Add(BitCodeAbbrevOp(0)); // ProducesResult - Abv->Add(BitCodeAbbrevOp(0)); // NoCallerSavedRegs - Abv->Add(BitCodeAbbrevOp(0)); // NoCfCheck - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // CmseNSCall - // FunctionProtoType - Abv->Add(BitCodeAbbrevOp(0)); // IsVariadic - Abv->Add(BitCodeAbbrevOp(0)); // HasTrailingReturn - Abv->Add(BitCodeAbbrevOp(0)); // TypeQuals - Abv->Add(BitCodeAbbrevOp(0)); // RefQualifier - Abv->Add(BitCodeAbbrevOp(EST_None)); // ExceptionSpec - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // NumParams - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); - Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Params - TypeFunctionProtoAbbrev = Stream.EmitAbbrev(std::move(Abv)); } //===----------------------------------------------------------------------===// @@ -863,6 +857,7 @@ void ASTWriter::WriteBlockInfoBlock() { RECORD(PP_CONDITIONAL_STACK); RECORD(DECLS_TO_CHECK_FOR_DEFERRED_DIAGS); RECORD(PP_INCLUDED_FILES); + RECORD(PP_ASSUME_NONNULL_LOC); // SourceManager Block. BLOCK(SOURCE_MANAGER_BLOCK); @@ -1107,8 +1102,7 @@ std::pair<ASTFileSignature, ASTFileSignature> ASTWriter::createSignature(StringRef AllBytes, StringRef ASTBlockBytes) { llvm::SHA1 Hasher; Hasher.update(ASTBlockBytes); - auto Hash = Hasher.result(); - ASTFileSignature ASTBlockHash = ASTFileSignature::create(Hash); + ASTFileSignature ASTBlockHash = ASTFileSignature::create(Hasher.result()); // Add the remaining bytes (i.e. bytes before the unhashed control block that // are not part of the AST block). @@ -1116,8 +1110,7 @@ ASTWriter::createSignature(StringRef AllBytes, StringRef ASTBlockBytes) { AllBytes.take_front(ASTBlockBytes.bytes_end() - AllBytes.bytes_begin())); Hasher.update( AllBytes.take_back(AllBytes.bytes_end() - ASTBlockBytes.bytes_end())); - Hash = Hasher.result(); - ASTFileSignature Signature = ASTFileSignature::create(Hash); + ASTFileSignature Signature = ASTFileSignature::create(Hasher.result()); return std::make_pair(ASTBlockHash, Signature); } @@ -1240,15 +1233,24 @@ void ASTWriter::WriteControlBlock(Preprocessor &PP, ASTContext &Context, } if (WritingModule && WritingModule->Directory) { - SmallString<128> BaseDir(WritingModule->Directory->getName()); + SmallString<128> BaseDir; + if (PP.getHeaderSearchInfo().getHeaderSearchOpts().ModuleFileHomeIsCwd) { + // Use the current working directory as the base path for all inputs. + auto *CWD = + Context.getSourceManager().getFileManager().getDirectory(".").get(); + BaseDir.assign(CWD->getName()); + } else { + BaseDir.assign(WritingModule->Directory->getName()); + } cleanPathForOutput(Context.getSourceManager().getFileManager(), BaseDir); // If the home of the module is the current working directory, then we // want to pick up the cwd of the build process loading the module, not // our cwd, when we load this module. - if (!PP.getHeaderSearchInfo() - .getHeaderSearchOpts() - .ModuleMapFileHomeIsCwd || + if (!(PP.getHeaderSearchInfo() + .getHeaderSearchOpts() + .ModuleMapFileHomeIsCwd || + PP.getHeaderSearchInfo().getHeaderSearchOpts().ModuleFileHomeIsCwd) || WritingModule->Directory->getName() != StringRef(".")) { // Module directory. auto Abbrev = std::make_shared<BitCodeAbbrev>(); @@ -1308,8 +1310,7 @@ void ASTWriter::WriteControlBlock(Preprocessor &PP, ASTContext &Context, Record.push_back(M.Signature ? 0 : M.File->getSize()); Record.push_back(M.Signature ? 0 : getTimestampForOutput(M.File)); - for (auto I : M.Signature) - Record.push_back(I); + llvm::append_range(Record, M.Signature); AddString(M.ModuleName, Record); AddPath(M.FileName, Record); @@ -1478,8 +1479,7 @@ void ASTWriter::WriteControlBlock(Preprocessor &PP, ASTContext &Context, unsigned AbbrevCode = Stream.EmitAbbrev(std::move(Abbrev)); SmallString<128> OutputPath(OutputFile); - - SM.getFileManager().makeAbsolutePath(OutputPath); + PreparePathForOutput(OutputPath); StringRef origDir = llvm::sys::path::parent_path(OutputPath); RecordData::value_type Record[] = {ORIGINAL_PCH_DIR}; @@ -1715,8 +1715,8 @@ static unsigned CreateSLocExpansionAbbrev(llvm::BitstreamWriter &Stream) { Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_EXPANSION_ENTRY)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Offset Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Spelling location - Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Start location - Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // End location + Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Start location + Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // End location Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Is token range Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Token length return Stream.EmitAbbrev(std::move(Abbrev)); @@ -1879,7 +1879,7 @@ void ASTWriter::WriteHeaderSearch(const HeaderSearch &HS) { // headers list when emitting resolved headers in the first loop below. // FIXME: It'd be preferable to avoid doing this if we were given // sufficient stat information in the module map. - HS.getModuleMap().resolveHeaderDirectives(M); + HS.getModuleMap().resolveHeaderDirectives(M, /*File=*/llvm::None); // If the file didn't exist, we can still create a module if we were given // enough information in the module map. @@ -2002,15 +2002,11 @@ static void emitBlob(llvm::BitstreamWriter &Stream, StringRef Blob, // consumers will not want its contents. SmallString<0> CompressedBuffer; if (llvm::zlib::isAvailable()) { - llvm::Error E = llvm::zlib::compress(Blob.drop_back(1), CompressedBuffer); - if (!E) { - RecordDataType Record[] = {SM_SLOC_BUFFER_BLOB_COMPRESSED, - Blob.size() - 1}; - Stream.EmitRecordWithBlob(SLocBufferBlobCompressedAbbrv, Record, - CompressedBuffer); - return; - } - llvm::consumeError(std::move(E)); + llvm::zlib::compress(Blob.drop_back(1), CompressedBuffer); + RecordDataType Record[] = {SM_SLOC_BUFFER_BLOB_COMPRESSED, Blob.size() - 1}; + Stream.EmitRecordWithBlob(SLocBufferBlobCompressedAbbrv, Record, + CompressedBuffer); + return; } RecordDataType Record[] = {SM_SLOC_BUFFER_BLOB}; @@ -2143,12 +2139,13 @@ void ASTWriter::WriteSourceManagerBlock(SourceManager &SourceMgr, } else { // The source location entry is a macro expansion. const SrcMgr::ExpansionInfo &Expansion = SLoc->getExpansion(); - AddSourceLocation(Expansion.getSpellingLoc(), Record); - AddSourceLocation(Expansion.getExpansionLocStart(), Record); + LocSeq::State Seq; + AddSourceLocation(Expansion.getSpellingLoc(), Record, Seq); + AddSourceLocation(Expansion.getExpansionLocStart(), Record, Seq); AddSourceLocation(Expansion.isMacroArgExpansion() ? SourceLocation() : Expansion.getExpansionLocEnd(), - Record); + Record, Seq); Record.push_back(Expansion.isExpansionTokenRange()); // Compute the token length for this macro expansion. @@ -2295,10 +2292,21 @@ void ASTWriter::WritePreprocessor(const Preprocessor &PP, bool IsModule) { Stream.EmitRecord(PP_COUNTER_VALUE, Record); } + // If we have a recorded #pragma assume_nonnull, remember it so it can be + // replayed when the preamble terminates into the main file. + SourceLocation AssumeNonNullLoc = + PP.getPreambleRecordedPragmaAssumeNonNullLoc(); + if (AssumeNonNullLoc.isValid()) { + assert(PP.isRecordingPreamble()); + AddSourceLocation(AssumeNonNullLoc, Record); + Stream.EmitRecord(PP_ASSUME_NONNULL_LOC, Record); + Record.clear(); + } + if (PP.isRecordingPreamble() && PP.hasRecordedPreamble()) { assert(!IsModule); auto SkipInfo = PP.getPreambleSkipInfo(); - if (SkipInfo.hasValue()) { + if (SkipInfo) { Record.push_back(true); AddSourceLocation(SkipInfo->HashTokenLoc, Record); AddSourceLocation(SkipInfo->IfTokenLoc, Record); @@ -2348,13 +2356,22 @@ void ASTWriter::WritePreprocessor(const Preprocessor &PP, bool IsModule) { uint64_t StartOffset = Stream.GetCurrentBitNo() - MacroOffsetsBase; assert((StartOffset >> 32) == 0 && "Macro identifiers offset too large"); - // Emit the macro directives in reverse source order. - for (; MD; MD = MD->getPrevious()) { - // Once we hit an ignored macro, we're done: the rest of the chain - // will all be ignored macros. - if (shouldIgnoreMacro(MD, IsModule, PP)) - break; - + // Write out any exported module macros. + bool EmittedModuleMacros = false; + // C+=20 Header Units are compiled module interfaces, but they preserve + // macros that are live (i.e. have a defined value) at the end of the + // compilation. So when writing a header unit, we preserve only the final + // value of each macro (and discard any that are undefined). Header units + // do not have sub-modules (although they might import other header units). + // PCH files, conversely, retain the history of each macro's define/undef + // and of leaf macros in sub modules. + if (IsModule && WritingModule->isHeaderUnit()) { + // This is for the main TU when it is a C++20 header unit. + // We preserve the final state of defined macros, and we do not emit ones + // that are undefined. + if (!MD || shouldIgnoreMacro(MD, IsModule, PP) || + MD->getKind() == MacroDirective::MD_Undefine) + continue; AddSourceLocation(MD->getLocation(), Record); Record.push_back(MD->getKind()); if (auto *DefMD = dyn_cast<DefMacroDirective>(MD)) { @@ -2362,35 +2379,51 @@ void ASTWriter::WritePreprocessor(const Preprocessor &PP, bool IsModule) { } else if (auto *VisMD = dyn_cast<VisibilityMacroDirective>(MD)) { Record.push_back(VisMD->isPublic()); } - } + ModuleMacroRecord.push_back(getSubmoduleID(WritingModule)); + ModuleMacroRecord.push_back(getMacroRef(MD->getMacroInfo(), Name)); + Stream.EmitRecord(PP_MODULE_MACRO, ModuleMacroRecord); + ModuleMacroRecord.clear(); + EmittedModuleMacros = true; + } else { + // Emit the macro directives in reverse source order. + for (; MD; MD = MD->getPrevious()) { + // Once we hit an ignored macro, we're done: the rest of the chain + // will all be ignored macros. + if (shouldIgnoreMacro(MD, IsModule, PP)) + break; + AddSourceLocation(MD->getLocation(), Record); + Record.push_back(MD->getKind()); + if (auto *DefMD = dyn_cast<DefMacroDirective>(MD)) { + Record.push_back(getMacroRef(DefMD->getInfo(), Name)); + } else if (auto *VisMD = dyn_cast<VisibilityMacroDirective>(MD)) { + Record.push_back(VisMD->isPublic()); + } + } - // Write out any exported module macros. - bool EmittedModuleMacros = false; - // We write out exported module macros for PCH as well. - auto Leafs = PP.getLeafModuleMacros(Name); - SmallVector<ModuleMacro*, 8> Worklist(Leafs.begin(), Leafs.end()); - llvm::DenseMap<ModuleMacro*, unsigned> Visits; - while (!Worklist.empty()) { - auto *Macro = Worklist.pop_back_val(); + // We write out exported module macros for PCH as well. + auto Leafs = PP.getLeafModuleMacros(Name); + SmallVector<ModuleMacro *, 8> Worklist(Leafs.begin(), Leafs.end()); + llvm::DenseMap<ModuleMacro *, unsigned> Visits; + while (!Worklist.empty()) { + auto *Macro = Worklist.pop_back_val(); - // Emit a record indicating this submodule exports this macro. - ModuleMacroRecord.push_back( - getSubmoduleID(Macro->getOwningModule())); - ModuleMacroRecord.push_back(getMacroRef(Macro->getMacroInfo(), Name)); - for (auto *M : Macro->overrides()) - ModuleMacroRecord.push_back(getSubmoduleID(M->getOwningModule())); + // Emit a record indicating this submodule exports this macro. + ModuleMacroRecord.push_back(getSubmoduleID(Macro->getOwningModule())); + ModuleMacroRecord.push_back(getMacroRef(Macro->getMacroInfo(), Name)); + for (auto *M : Macro->overrides()) + ModuleMacroRecord.push_back(getSubmoduleID(M->getOwningModule())); - Stream.EmitRecord(PP_MODULE_MACRO, ModuleMacroRecord); - ModuleMacroRecord.clear(); + Stream.EmitRecord(PP_MODULE_MACRO, ModuleMacroRecord); + ModuleMacroRecord.clear(); - // Enqueue overridden macros once we've visited all their ancestors. - for (auto *M : Macro->overrides()) - if (++Visits[M] == M->getNumOverridingMacros()) - Worklist.push_back(M); + // Enqueue overridden macros once we've visited all their ancestors. + for (auto *M : Macro->overrides()) + if (++Visits[M] == M->getNumOverridingMacros()) + Worklist.push_back(M); - EmittedModuleMacros = true; + EmittedModuleMacros = true; + } } - if (Record.empty() && !EmittedModuleMacros) continue; @@ -2431,6 +2464,7 @@ void ASTWriter::WritePreprocessor(const Preprocessor &PP, bool IsModule) { AddSourceLocation(MI->getDefinitionEndLoc(), Record); Record.push_back(MI->isUsed()); Record.push_back(MI->isUsedForHeaderGuard()); + Record.push_back(MI->getNumTokens()); unsigned Code; if (MI->isObjectLike()) { Code = PP_MACRO_OBJECT_LIKE; @@ -2673,7 +2707,7 @@ void ASTWriter::WriteSubmodules(Module *WritingModule) { Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_DEFINITION)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // ID Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Parent - Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // Kind + Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // Kind Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsFramework Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsExplicit Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsSystem @@ -2832,8 +2866,11 @@ void ASTWriter::WriteSubmodules(Module *WritingModule) { { auto TopHeaders = Mod->getTopHeaders(PP->getFileManager()); RecordData::value_type Record[] = {SUBMODULE_TOPHEADER}; - for (auto *H : TopHeaders) - Stream.EmitRecordWithBlob(TopHeaderAbbrev, Record, H->getName()); + for (auto *H : TopHeaders) { + SmallString<128> HeaderName(H->getName()); + PreparePathForOutput(HeaderName); + Stream.EmitRecordWithBlob(TopHeaderAbbrev, Record, HeaderName); + } } // Emit the imports. @@ -2860,6 +2897,8 @@ void ASTWriter::WriteSubmodules(Module *WritingModule) { // Might be unnecessary as use declarations are only used to build the // module itself. + // TODO: Consider serializing undeclared uses of modules. + // Emit the link libraries. for (const auto &LL : Mod->LinkLibraries) { RecordData::value_type Record[] = {SUBMODULE_LINK_LIBRARY, @@ -3096,6 +3135,7 @@ void ASTWriter::WriteFileDeclIDsMap() { for (auto &FileDeclEntry : SortedFileDeclIDs) { DeclIDInFileInfo &Info = *FileDeclEntry.second; Info.FirstDeclIndex = FileGroupedDeclIDs.size(); + llvm::stable_sort(Info.DeclIDs); for (auto &LocDeclEntry : Info.DeclIDs) FileGroupedDeclIDs.push_back(LocDeclEntry.second); } @@ -3694,8 +3734,7 @@ public: data_type ImportData(const reader::ASTDeclContextNameLookupTrait::data_type &FromReader) { unsigned Start = DeclIDs.size(); - for (auto ID : FromReader) - DeclIDs.push_back(ID); + llvm::append_range(DeclIDs, FromReader); return std::make_pair(Start, DeclIDs.size()); } @@ -4553,13 +4592,14 @@ ASTFileSignature ASTWriter::WriteASTCore(Sema &SemaRef, StringRef isysroot, // entire table, since later PCH files in a PCH chain are only interested in // the results at the end of the chain. RecordData WeakUndeclaredIdentifiers; - for (auto &WeakUndeclaredIdentifier : SemaRef.WeakUndeclaredIdentifiers) { - IdentifierInfo *II = WeakUndeclaredIdentifier.first; - WeakInfo &WI = WeakUndeclaredIdentifier.second; - AddIdentifierRef(II, WeakUndeclaredIdentifiers); - AddIdentifierRef(WI.getAlias(), WeakUndeclaredIdentifiers); - AddSourceLocation(WI.getLocation(), WeakUndeclaredIdentifiers); - WeakUndeclaredIdentifiers.push_back(WI.getUsed()); + for (const auto &WeakUndeclaredIdentifierList : + SemaRef.WeakUndeclaredIdentifiers) { + const IdentifierInfo *const II = WeakUndeclaredIdentifierList.first; + for (const auto &WI : WeakUndeclaredIdentifierList.second) { + AddIdentifierRef(II, WeakUndeclaredIdentifiers); + AddIdentifierRef(WI.getAlias(), WeakUndeclaredIdentifiers); + AddSourceLocation(WI.getLocation(), WeakUndeclaredIdentifiers); + } } // Build a record containing all of the ext_vector declarations. @@ -5184,14 +5224,15 @@ void ASTWriter::AddAlignPackInfo(const Sema::AlignPackInfo &Info, Record.push_back(Raw); } -void ASTWriter::AddSourceLocation(SourceLocation Loc, RecordDataImpl &Record) { - SourceLocation::UIntTy Raw = Loc.getRawEncoding(); - Record.push_back((Raw << 1) | (Raw >> (8 * sizeof(Raw) - 1))); +void ASTWriter::AddSourceLocation(SourceLocation Loc, RecordDataImpl &Record, + SourceLocationSequence *Seq) { + Record.push_back(SourceLocationEncoding::encode(Loc, Seq)); } -void ASTWriter::AddSourceRange(SourceRange Range, RecordDataImpl &Record) { - AddSourceLocation(Range.getBegin(), Record); - AddSourceLocation(Range.getEnd(), Record); +void ASTWriter::AddSourceRange(SourceRange Range, RecordDataImpl &Record, + SourceLocationSequence *Seq) { + AddSourceLocation(Range.getBegin(), Record, Seq); + AddSourceLocation(Range.getEnd(), Record, Seq); } void ASTRecordWriter::AddAPFloat(const llvm::APFloat &Value) { @@ -5318,8 +5359,9 @@ void ASTRecordWriter::AddTypeSourceInfo(TypeSourceInfo *TInfo) { AddTypeLoc(TInfo->getTypeLoc()); } -void ASTRecordWriter::AddTypeLoc(TypeLoc TL) { - TypeLocWriter TLW(*this); +void ASTRecordWriter::AddTypeLoc(TypeLoc TL, LocSeq *OuterSeq) { + LocSeq::State Seq(OuterSeq); + TypeLocWriter TLW(*this, Seq); for (; !TL.isNull(); TL = TL.getNextTypeLoc()) TLW.Visit(TL); } @@ -5444,16 +5486,7 @@ void ASTWriter::associateDeclWithFile(const Decl *D, DeclID ID) { 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 = - llvm::upper_bound(Decls, LocDecl, llvm::less_first()); - - Decls.insert(I, LocDecl); + Decls.push_back(LocDecl); } unsigned ASTWriter::getAnonymousDeclarationNumber(const NamedDecl *D) { @@ -5726,7 +5759,7 @@ void ASTRecordWriter::AddCXXDefinitionData(const CXXRecordDecl *D) { // Add lambda-specific data. if (Data.IsLambda) { auto &Lambda = D->getLambdaData(); - Record->push_back(Lambda.Dependent); + Record->push_back(Lambda.DependencyKind); Record->push_back(Lambda.IsGenericLambda); Record->push_back(Lambda.CaptureDefault); Record->push_back(Lambda.NumCaptures); @@ -5904,8 +5937,7 @@ void ASTWriter::AddedVisibleDecl(const DeclContext *DC, const Decl *D) { // We're adding a visible declaration to a predefined decl context. Ensure // that we write out all of its lookup results so we don't get a nasty // surprise when we try to emit its lookup table. - for (auto *Child : DC->decls()) - DeclsToEmitEvenIfUnreferenced.push_back(Child); + llvm::append_range(DeclsToEmitEvenIfUnreferenced, DC->decls()); } DeclsToEmitEvenIfUnreferenced.push_back(D); } @@ -6560,6 +6592,7 @@ void OMPClauseWriter::VisitOMPDependClause(OMPDependClause *C) { Record.push_back(C->getDependencyKind()); Record.AddSourceLocation(C->getDependencyLoc()); Record.AddSourceLocation(C->getColonLoc()); + Record.AddSourceLocation(C->getOmpAllMemoryLoc()); for (auto *VE : C->varlists()) Record.AddStmt(VE); for (unsigned I = 0, E = C->getNumLoops(); I < E; ++I) @@ -6790,6 +6823,26 @@ void OMPClauseWriter::VisitOMPIsDevicePtrClause(OMPIsDevicePtrClause *C) { } } +void OMPClauseWriter::VisitOMPHasDeviceAddrClause(OMPHasDeviceAddrClause *C) { + Record.push_back(C->varlist_size()); + Record.push_back(C->getUniqueDeclarationsNum()); + Record.push_back(C->getTotalComponentListNum()); + Record.push_back(C->getTotalComponentsNum()); + Record.AddSourceLocation(C->getLParenLoc()); + for (auto *E : C->varlists()) + Record.AddStmt(E); + for (auto *D : C->all_decls()) + Record.AddDeclRef(D); + for (auto N : C->all_num_lists()) + Record.push_back(N); + for (auto N : C->all_lists_sizes()) + Record.push_back(N); + for (auto &M : C->all_components()) { + Record.AddStmt(M.getAssociatedExpression()); + Record.AddDeclRef(M.getAssociatedDeclaration()); + } +} + void OMPClauseWriter::VisitOMPUnifiedAddressClause(OMPUnifiedAddressClause *) {} void OMPClauseWriter::VisitOMPUnifiedSharedMemoryClause( |