diff options
Diffstat (limited to 'contrib/llvm-project/clang/lib/Serialization/ASTWriterStmt.cpp')
-rw-r--r-- | contrib/llvm-project/clang/lib/Serialization/ASTWriterStmt.cpp | 452 |
1 files changed, 349 insertions, 103 deletions
diff --git a/contrib/llvm-project/clang/lib/Serialization/ASTWriterStmt.cpp b/contrib/llvm-project/clang/lib/Serialization/ASTWriterStmt.cpp index 2bb5e4f3563d..e5836f5dcbe9 100644 --- a/contrib/llvm-project/clang/lib/Serialization/ASTWriterStmt.cpp +++ b/contrib/llvm-project/clang/lib/Serialization/ASTWriterStmt.cpp @@ -11,15 +11,16 @@ /// //===----------------------------------------------------------------------===// -#include "clang/AST/ExprOpenMP.h" -#include "clang/Serialization/ASTRecordWriter.h" -#include "clang/Sema/DeclSpec.h" +#include "clang/AST/ASTConcept.h" #include "clang/AST/ASTContext.h" #include "clang/AST/DeclCXX.h" #include "clang/AST/DeclObjC.h" #include "clang/AST/DeclTemplate.h" +#include "clang/AST/ExprOpenMP.h" #include "clang/AST/StmtVisitor.h" #include "clang/Lex/Token.h" +#include "clang/Sema/DeclSpec.h" +#include "clang/Serialization/ASTRecordWriter.h" #include "llvm/Bitstream/BitstreamWriter.h" using namespace clang; @@ -36,14 +37,70 @@ namespace clang { serialization::StmtCode Code; unsigned AbbrevToUse; + /// A helper that can help us to write a packed bit across function + /// calls. For example, we may write seperate bits in seperate functions: + /// + /// void VisitA(A* a) { + /// Record.push_back(a->isSomething()); + /// } + /// + /// void Visitb(B *b) { + /// VisitA(b); + /// Record.push_back(b->isAnother()); + /// } + /// + /// In such cases, it'll be better if we can pack these 2 bits. We achieve + /// this by writing a zero value in `VisitA` and recorded that first and add + /// the new bit to the recorded value. + class PakedBitsWriter { + public: + PakedBitsWriter(ASTRecordWriter &Record) : RecordRef(Record) {} + ~PakedBitsWriter() { assert(!CurrentIndex); } + + void addBit(bool Value) { + assert(CurrentIndex && "Writing Bits without recording first!"); + PackingBits.addBit(Value); + } + void addBits(uint32_t Value, uint32_t BitsWidth) { + assert(CurrentIndex && "Writing Bits without recording first!"); + PackingBits.addBits(Value, BitsWidth); + } + + void writeBits() { + if (!CurrentIndex) + return; + + RecordRef[*CurrentIndex] = (uint32_t)PackingBits; + CurrentIndex = std::nullopt; + PackingBits.reset(0); + } + + void updateBits() { + writeBits(); + + CurrentIndex = RecordRef.size(); + RecordRef.push_back(0); + } + + private: + BitsPacker PackingBits; + ASTRecordWriter &RecordRef; + std::optional<unsigned> CurrentIndex; + }; + + PakedBitsWriter CurrentPackingBits; + public: ASTStmtWriter(ASTWriter &Writer, ASTWriter::RecordData &Record) : Writer(Writer), Record(Writer, Record), - Code(serialization::STMT_NULL_PTR), AbbrevToUse(0) {} + Code(serialization::STMT_NULL_PTR), AbbrevToUse(0), + CurrentPackingBits(this->Record) {} ASTStmtWriter(const ASTStmtWriter&) = delete; + ASTStmtWriter &operator=(const ASTStmtWriter &) = delete; uint64_t Emit() { + CurrentPackingBits.writeBits(); assert(Code != serialization::STMT_NULL_PTR && "unhandled sub-statement writing AST file"); return Record.EmitStmt(Code, AbbrevToUse); @@ -80,11 +137,20 @@ void ASTStmtWriter::VisitNullStmt(NullStmt *S) { void ASTStmtWriter::VisitCompoundStmt(CompoundStmt *S) { VisitStmt(S); + Record.push_back(S->size()); + Record.push_back(S->hasStoredFPFeatures()); + for (auto *CS : S->body()) Record.AddStmt(CS); + if (S->hasStoredFPFeatures()) + Record.push_back(S->getStoredFPFeatures().getAsOpaqueInt()); Record.AddSourceLocation(S->getLBracLoc()); Record.AddSourceLocation(S->getRBracLoc()); + + if (!S->hasStoredFPFeatures()) + AbbrevToUse = Writer.getCompoundStmtAbbrev(); + Code = serialization::STMT_COMPOUND; } @@ -138,17 +204,18 @@ void ASTStmtWriter::VisitIfStmt(IfStmt *S) { bool HasVar = S->getConditionVariableDeclStmt() != nullptr; bool HasInit = S->getInit() != nullptr; - Record.push_back(S->isConstexpr()); - Record.push_back(HasElse); - Record.push_back(HasVar); - Record.push_back(HasInit); + CurrentPackingBits.updateBits(); + CurrentPackingBits.addBit(HasElse); + CurrentPackingBits.addBit(HasVar); + CurrentPackingBits.addBit(HasInit); + Record.push_back(static_cast<uint64_t>(S->getStatementKind())); Record.AddStmt(S->getCond()); Record.AddStmt(S->getThen()); if (HasElse) Record.AddStmt(S->getElse()); if (HasVar) - Record.AddDeclRef(S->getConditionVariable()); + Record.AddStmt(S->getConditionVariableDeclStmt()); if (HasInit) Record.AddStmt(S->getInit()); @@ -175,7 +242,7 @@ void ASTStmtWriter::VisitSwitchStmt(SwitchStmt *S) { if (HasInit) Record.AddStmt(S->getInit()); if (HasVar) - Record.AddDeclRef(S->getConditionVariable()); + Record.AddStmt(S->getConditionVariableDeclStmt()); Record.AddSourceLocation(S->getSwitchLoc()); Record.AddSourceLocation(S->getLParenLoc()); @@ -196,7 +263,7 @@ void ASTStmtWriter::VisitWhileStmt(WhileStmt *S) { Record.AddStmt(S->getCond()); Record.AddStmt(S->getBody()); if (HasVar) - Record.AddDeclRef(S->getConditionVariable()); + Record.AddStmt(S->getConditionVariableDeclStmt()); Record.AddSourceLocation(S->getWhileLoc()); Record.AddSourceLocation(S->getLParenLoc()); @@ -218,7 +285,7 @@ void ASTStmtWriter::VisitForStmt(ForStmt *S) { VisitStmt(S); Record.AddStmt(S->getInit()); Record.AddStmt(S->getCond()); - Record.AddDeclRef(S->getConditionVariable()); + Record.AddStmt(S->getConditionVariableDeclStmt()); Record.AddStmt(S->getInc()); Record.AddStmt(S->getBody()); Record.AddSourceLocation(S->getForLoc()); @@ -314,7 +381,10 @@ void ASTStmtWriter::VisitGCCAsmStmt(GCCAsmStmt *S) { Record.AddStmt(S->getClobberStringLiteral(I)); // Labels - for (auto *E : S->labels()) Record.AddStmt(E); + for (unsigned I = 0, N = S->getNumLabels(); I != N; ++I) { + Record.AddIdentifierRef(S->getLabelIdentifier(I)); + Record.AddStmt(S->getLabelExpr(I)); + } Code = serialization::STMT_GCCASM; } @@ -400,6 +470,7 @@ static void addConstraintSatisfaction(ASTRecordWriter &Record, const ASTConstraintSatisfaction &Satisfaction) { Record.push_back(Satisfaction.IsSatisfied); + Record.push_back(Satisfaction.ContainsErrors); if (!Satisfaction.IsSatisfied) { Record.push_back(Satisfaction.NumRecords); for (const auto &DetailRecord : Satisfaction) { @@ -430,16 +501,11 @@ addSubstitutionDiagnostic( void ASTStmtWriter::VisitConceptSpecializationExpr( ConceptSpecializationExpr *E) { VisitExpr(E); - ArrayRef<TemplateArgument> TemplateArgs = E->getTemplateArguments(); - Record.push_back(TemplateArgs.size()); - Record.AddNestedNameSpecifierLoc(E->getNestedNameSpecifierLoc()); - Record.AddSourceLocation(E->getTemplateKWLoc()); - Record.AddDeclarationNameInfo(E->getConceptNameInfo()); - Record.AddDeclRef(E->getNamedConcept()); - Record.AddDeclRef(E->getFoundDecl()); - Record.AddASTTemplateArgumentListInfo(E->getTemplateArgsAsWritten()); - for (const TemplateArgument &Arg : TemplateArgs) - Record.AddTemplateArgument(Arg); + Record.AddDeclRef(E->getSpecializationDecl()); + const ConceptReference *CR = E->getConceptReference(); + Record.push_back(CR != nullptr); + if (CR) + Record.AddConceptReference(CR); if (!E->isValueDependent()) addConstraintSatisfaction(Record, E->getSatisfaction()); @@ -493,17 +559,19 @@ void ASTStmtWriter::VisitRequiresExpr(RequiresExpr *E) { } else { auto *NestedReq = cast<concepts::NestedRequirement>(R); Record.push_back(concepts::Requirement::RK_Nested); - Record.push_back(NestedReq->isSubstitutionFailure()); - if (NestedReq->isSubstitutionFailure()){ - addSubstitutionDiagnostic(Record, - NestedReq->getSubstitutionDiagnostic()); + Record.push_back(NestedReq->hasInvalidConstraint()); + if (NestedReq->hasInvalidConstraint()) { + Record.AddString(NestedReq->getInvalidConstraintEntity()); + addConstraintSatisfaction(Record, *NestedReq->Satisfaction); } else { - Record.AddStmt(NestedReq->Value.get<Expr *>()); + Record.AddStmt(NestedReq->getConstraintExpr()); if (!NestedReq->isDependent()) addConstraintSatisfaction(Record, *NestedReq->Satisfaction); } } } + Record.AddSourceLocation(E->getLParenLoc()); + Record.AddSourceLocation(E->getRParenLoc()); Record.AddSourceLocation(E->getEndLoc()); Code = serialization::EXPR_REQUIRES; @@ -543,14 +611,13 @@ void ASTStmtWriter::VisitCapturedStmt(CapturedStmt *S) { void ASTStmtWriter::VisitExpr(Expr *E) { VisitStmt(E); + + CurrentPackingBits.updateBits(); + CurrentPackingBits.addBits(E->getDependence(), /*BitsWidth=*/5); + CurrentPackingBits.addBits(E->getValueKind(), /*BitsWidth=*/2); + CurrentPackingBits.addBits(E->getObjectKind(), /*BitsWidth=*/3); + Record.AddTypeRef(E->getType()); - Record.push_back(E->isTypeDependent()); - Record.push_back(E->isValueDependent()); - Record.push_back(E->isInstantiationDependent()); - Record.push_back(E->containsUnexpandedParameterPack()); - Record.push_back(E->containsErrors()); - Record.push_back(E->getValueKind()); - Record.push_back(E->getObjectKind()); } void ASTStmtWriter::VisitConstantExpr(ConstantExpr *E) { @@ -563,17 +630,15 @@ void ASTStmtWriter::VisitConstantExpr(ConstantExpr *E) { // HasCleanup not serialized since we can just query the APValue. Record.push_back(E->ConstantExprBits.IsImmediateInvocation); - switch (E->ConstantExprBits.ResultKind) { - case ConstantExpr::RSK_None: + switch (E->getResultStorageKind()) { + case ConstantResultStorageKind::None: break; - case ConstantExpr::RSK_Int64: + case ConstantResultStorageKind::Int64: Record.push_back(E->Int64Result()); break; - case ConstantExpr::RSK_APValue: + case ConstantResultStorageKind::APValue: Record.AddAPValue(E->APValueResult()); break; - default: - llvm_unreachable("unexpected ResultKind!"); } Record.AddStmt(E->getSubExpr()); @@ -596,7 +661,9 @@ void ASTStmtWriter::VisitPredefinedExpr(PredefinedExpr *E) { bool HasFunctionName = E->getFunctionName() != nullptr; Record.push_back(HasFunctionName); - Record.push_back(E->getIdentKind()); // FIXME: stable encoding + Record.push_back( + llvm::to_underlying(E->getIdentKind())); // FIXME: stable encoding + Record.push_back(E->isTransparent()); Record.AddSourceLocation(E->getLocation()); if (HasFunctionName) Record.AddStmt(E->getFunctionName()); @@ -606,12 +673,15 @@ void ASTStmtWriter::VisitPredefinedExpr(PredefinedExpr *E) { void ASTStmtWriter::VisitDeclRefExpr(DeclRefExpr *E) { VisitExpr(E); - Record.push_back(E->hasQualifier()); - Record.push_back(E->getDecl() != E->getFoundDecl()); - Record.push_back(E->hasTemplateKWAndArgsInfo()); - Record.push_back(E->hadMultipleCandidates()); - Record.push_back(E->refersToEnclosingVariableOrCapture()); - Record.push_back(E->isNonOdrUse()); + CurrentPackingBits.updateBits(); + + CurrentPackingBits.addBit(E->hadMultipleCandidates()); + CurrentPackingBits.addBit(E->refersToEnclosingVariableOrCapture()); + CurrentPackingBits.addBits(E->isNonOdrUse(), /*Width=*/2); + CurrentPackingBits.addBit(E->isImmediateEscalating()); + CurrentPackingBits.addBit(E->getDecl() != E->getFoundDecl()); + CurrentPackingBits.addBit(E->hasQualifier()); + CurrentPackingBits.addBit(E->hasTemplateKWAndArgsInfo()); if (E->hasTemplateKWAndArgsInfo()) { unsigned NumTemplateArgs = E->getNumTemplateArgs(); @@ -622,8 +692,7 @@ void ASTStmtWriter::VisitDeclRefExpr(DeclRefExpr *E) { if ((!E->hasTemplateKWAndArgsInfo()) && (!E->hasQualifier()) && (E->getDecl() == E->getFoundDecl()) && - nk == DeclarationName::Identifier && - !E->refersToEnclosingVariableOrCapture() && !E->isNonOdrUse()) { + nk == DeclarationName::Identifier && E->getObjectKind() == OK_Ordinary) { AbbrevToUse = Writer.getDeclRefExprAbbrev(); } @@ -685,7 +754,7 @@ void ASTStmtWriter::VisitStringLiteral(StringLiteral *E) { Record.push_back(E->getNumConcatenated()); Record.push_back(E->getLength()); Record.push_back(E->getCharByteWidth()); - Record.push_back(E->getKind()); + Record.push_back(llvm::to_underlying(E->getKind())); Record.push_back(E->isPascal()); // Store the trailing array of SourceLocation. @@ -704,7 +773,7 @@ void ASTStmtWriter::VisitCharacterLiteral(CharacterLiteral *E) { VisitExpr(E); Record.push_back(E->getValue()); Record.AddSourceLocation(E->getLocation()); - Record.push_back(E->getKind()); + Record.push_back(llvm::to_underlying(E->getKind())); AbbrevToUse = Writer.getCharacterLiteralAbbrev(); @@ -734,11 +803,13 @@ void ASTStmtWriter::VisitUnaryOperator(UnaryOperator *E) { bool HasFPFeatures = E->hasStoredFPFeatures(); // Write this first for easy access when deserializing, as they affect the // size of the UnaryOperator. - Record.push_back(HasFPFeatures); + CurrentPackingBits.addBit(HasFPFeatures); Record.AddStmt(E->getSubExpr()); - Record.push_back(E->getOpcode()); // FIXME: stable encoding + CurrentPackingBits.addBits(E->getOpcode(), + /*Width=*/5); // FIXME: stable encoding Record.AddSourceLocation(E->getOperatorLoc()); - Record.push_back(E->canOverflow()); + CurrentPackingBits.addBit(E->canOverflow()); + if (HasFPFeatures) Record.push_back(E->getStoredFPFeatures().getAsOpaqueInt()); Code = serialization::EXPR_UNARY_OPERATOR; @@ -863,16 +934,25 @@ void ASTStmtWriter::VisitOMPIteratorExpr(OMPIteratorExpr *E) { void ASTStmtWriter::VisitCallExpr(CallExpr *E) { VisitExpr(E); + Record.push_back(E->getNumArgs()); - Record.push_back(E->hasStoredFPFeatures()); + CurrentPackingBits.updateBits(); + CurrentPackingBits.addBit(static_cast<bool>(E->getADLCallKind())); + CurrentPackingBits.addBit(E->hasStoredFPFeatures()); + Record.AddSourceLocation(E->getRParenLoc()); Record.AddStmt(E->getCallee()); for (CallExpr::arg_iterator Arg = E->arg_begin(), ArgEnd = E->arg_end(); Arg != ArgEnd; ++Arg) Record.AddStmt(*Arg); - Record.push_back(static_cast<unsigned>(E->getADLCallKind())); + if (E->hasStoredFPFeatures()) Record.push_back(E->getFPFeatures().getAsOpaqueInt()); + + if (!E->hasStoredFPFeatures() && !static_cast<bool>(E->getADLCallKind()) && + E->getStmtClass() == Stmt::CallExprClass) + AbbrevToUse = Writer.getCallExprAbbrev(); + Code = serialization::EXPR_CALL; } @@ -899,9 +979,10 @@ void ASTStmtWriter::VisitMemberExpr(MemberExpr *E) { // Write these first for easy access when deserializing, as they affect the // size of the MemberExpr. - Record.push_back(HasQualifier); - Record.push_back(HasFoundDecl); - Record.push_back(HasTemplateInfo); + CurrentPackingBits.updateBits(); + CurrentPackingBits.addBit(HasQualifier); + CurrentPackingBits.addBit(HasFoundDecl); + CurrentPackingBits.addBit(HasTemplateInfo); Record.push_back(NumTemplateArgs); Record.AddStmt(E->getBase()); @@ -909,15 +990,15 @@ void ASTStmtWriter::VisitMemberExpr(MemberExpr *E) { Record.AddDeclarationNameLoc(E->MemberDNLoc, E->getMemberDecl()->getDeclName()); Record.AddSourceLocation(E->getMemberLoc()); - Record.push_back(E->isArrow()); - Record.push_back(E->hadMultipleCandidates()); - Record.push_back(E->isNonOdrUse()); + CurrentPackingBits.addBit(E->isArrow()); + CurrentPackingBits.addBit(E->hadMultipleCandidates()); + CurrentPackingBits.addBits(E->isNonOdrUse(), /*Width=*/2); Record.AddSourceLocation(E->getOperatorLoc()); if (HasFoundDecl) { DeclAccessPair FoundDecl = E->getFoundDecl(); Record.AddDeclRef(FoundDecl.getDecl()); - Record.push_back(FoundDecl.getAccess()); + CurrentPackingBits.addBits(FoundDecl.getAccess(), /*BitWidth=*/2); } if (HasQualifier) @@ -957,10 +1038,13 @@ void ASTStmtWriter::VisitObjCBridgedCastExpr(ObjCBridgedCastExpr *E) { void ASTStmtWriter::VisitCastExpr(CastExpr *E) { VisitExpr(E); + Record.push_back(E->path_size()); - Record.push_back(E->hasStoredFPFeatures()); + CurrentPackingBits.updateBits(); + // 7 bits should be enough to store the casting kinds. + CurrentPackingBits.addBits(E->getCastKind(), /*Width=*/7); + CurrentPackingBits.addBit(E->hasStoredFPFeatures()); Record.AddStmt(E->getSubExpr()); - Record.push_back(E->getCastKind()); // FIXME: stable encoding for (CastExpr::path_iterator PI = E->path_begin(), PE = E->path_end(); PI != PE; ++PI) @@ -972,16 +1056,23 @@ void ASTStmtWriter::VisitCastExpr(CastExpr *E) { void ASTStmtWriter::VisitBinaryOperator(BinaryOperator *E) { VisitExpr(E); - bool HasFPFeatures = E->hasStoredFPFeatures(); + // Write this first for easy access when deserializing, as they affect the // size of the UnaryOperator. - Record.push_back(HasFPFeatures); - Record.push_back(E->getOpcode()); // FIXME: stable encoding + CurrentPackingBits.updateBits(); + CurrentPackingBits.addBits(E->getOpcode(), /*Width=*/6); + bool HasFPFeatures = E->hasStoredFPFeatures(); + CurrentPackingBits.addBit(HasFPFeatures); Record.AddStmt(E->getLHS()); Record.AddStmt(E->getRHS()); Record.AddSourceLocation(E->getOperatorLoc()); if (HasFPFeatures) Record.push_back(E->getStoredFPFeatures().getAsOpaqueInt()); + + if (!HasFPFeatures && E->getValueKind() == VK_PRValue && + E->getObjectKind() == OK_Ordinary) + AbbrevToUse = Writer.getBinaryOperatorAbbrev(); + Code = serialization::EXPR_BINARY_OPERATOR; } @@ -989,6 +1080,11 @@ void ASTStmtWriter::VisitCompoundAssignOperator(CompoundAssignOperator *E) { VisitBinaryOperator(E); Record.AddTypeRef(E->getComputationLHSType()); Record.AddTypeRef(E->getComputationResultType()); + + if (!E->hasStoredFPFeatures() && E->getValueKind() == VK_PRValue && + E->getObjectKind() == OK_Ordinary) + AbbrevToUse = Writer.getCompoundAssignOperatorAbbrev(); + Code = serialization::EXPR_COMPOUND_ASSIGN_OPERATOR; } @@ -1017,7 +1113,7 @@ ASTStmtWriter::VisitBinaryConditionalOperator(BinaryConditionalOperator *E) { void ASTStmtWriter::VisitImplicitCastExpr(ImplicitCastExpr *E) { VisitCastExpr(E); - Record.push_back(E->isPartOfExplicitCast()); + CurrentPackingBits.addBit(E->isPartOfExplicitCast()); if (E->path_size() == 0 && !E->hasStoredFPFeatures()) AbbrevToUse = Writer.getExprImplicitCastAbbrev(); @@ -1091,7 +1187,7 @@ void ASTStmtWriter::VisitDesignatedInitExpr(DesignatedInitExpr *E) { Record.push_back(E->usesGNUSyntax()); for (const DesignatedInitExpr::Designator &D : E->designators()) { if (D.isFieldDesignator()) { - if (FieldDecl *Field = D.getField()) { + if (FieldDecl *Field = D.getFieldDecl()) { Record.push_back(serialization::DESIG_FIELD_DECL); Record.AddDeclRef(Field); } else { @@ -1102,13 +1198,13 @@ void ASTStmtWriter::VisitDesignatedInitExpr(DesignatedInitExpr *E) { Record.AddSourceLocation(D.getFieldLoc()); } else if (D.isArrayDesignator()) { Record.push_back(serialization::DESIG_ARRAY); - Record.push_back(D.getFirstExprIndex()); + Record.push_back(D.getArrayIndex()); Record.AddSourceLocation(D.getLBracketLoc()); Record.AddSourceLocation(D.getRBracketLoc()); } else { assert(D.isArrayRangeDesignator() && "Unknown designator"); Record.push_back(serialization::DESIG_ARRAY_RANGE); - Record.push_back(D.getFirstExprIndex()); + Record.push_back(D.getArrayIndex()); Record.AddSourceLocation(D.getLBracketLoc()); Record.AddSourceLocation(D.getEllipsisLoc()); Record.AddSourceLocation(D.getRBracketLoc()); @@ -1161,7 +1257,7 @@ void ASTStmtWriter::VisitSourceLocExpr(SourceLocExpr *E) { Record.AddDeclRef(cast_or_null<Decl>(E->getParentContext())); Record.AddSourceLocation(E->getBeginLoc()); Record.AddSourceLocation(E->getEndLoc()); - Record.push_back(E->getIdentKind()); + Record.push_back(llvm::to_underlying(E->getIdentKind())); Code = serialization::EXPR_SOURCE_LOC; } @@ -1228,6 +1324,7 @@ void ASTStmtWriter::VisitGenericSelectionExpr(GenericSelectionExpr *E) { VisitExpr(E); Record.push_back(E->getNumAssocs()); + Record.push_back(E->isExprPredicate()); Record.push_back(E->ResultIndex); Record.AddSourceLocation(E->getGenericLoc()); Record.AddSourceLocation(E->getDefaultLoc()); @@ -1483,8 +1580,8 @@ void ASTStmtWriter::VisitObjCAtTryStmt(ObjCAtTryStmt *S) { Record.push_back(S->getNumCatchStmts()); Record.push_back(S->getFinallyStmt() != nullptr); Record.AddStmt(S->getTryBody()); - for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I) - Record.AddStmt(S->getCatchStmt(I)); + for (ObjCAtCatchStmt *C : S->catch_stmts()) + Record.AddStmt(C); if (S->getFinallyStmt()) Record.AddStmt(S->getFinallyStmt()); Record.AddSourceLocation(S->getAtTryLoc()); @@ -1573,11 +1670,19 @@ void ASTStmtWriter::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) { VisitCallExpr(E); Record.push_back(E->getOperator()); Record.AddSourceRange(E->Range); + + if (!E->hasStoredFPFeatures() && !static_cast<bool>(E->getADLCallKind())) + AbbrevToUse = Writer.getCXXOperatorCallExprAbbrev(); + Code = serialization::EXPR_CXX_OPERATOR_CALL; } void ASTStmtWriter::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) { VisitCallExpr(E); + + if (!E->hasStoredFPFeatures() && !static_cast<bool>(E->getADLCallKind())) + AbbrevToUse = Writer.getCXXMemberCallExprAbbrev(); + Code = serialization::EXPR_CXX_MEMBER_CALL; } @@ -1598,7 +1703,9 @@ void ASTStmtWriter::VisitCXXConstructExpr(CXXConstructExpr *E) { Record.push_back(E->isListInitialization()); Record.push_back(E->isStdInitListInitialization()); Record.push_back(E->requiresZeroInitialization()); - Record.push_back(E->getConstructionKind()); // FIXME: stable encoding + Record.push_back( + llvm::to_underlying(E->getConstructionKind())); // FIXME: stable encoding + Record.push_back(E->isImmediateEscalating()); Record.AddSourceLocation(E->getLocation()); Record.AddDeclRef(E->getConstructor()); Record.AddSourceRange(E->getParenOrBraceRange()); @@ -1656,7 +1763,9 @@ void ASTStmtWriter::VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) void ASTStmtWriter::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) { VisitExplicitCastExpr(E); Record.AddSourceRange(SourceRange(E->getOperatorLoc(), E->getRParenLoc())); - Record.AddSourceRange(E->getAngleBrackets()); + CurrentPackingBits.addBit(E->getAngleBrackets().isValid()); + if (E->getAngleBrackets().isValid()) + Record.AddSourceRange(E->getAngleBrackets()); } void ASTStmtWriter::VisitCXXStaticCastExpr(CXXStaticCastExpr *E) { @@ -1733,6 +1842,7 @@ void ASTStmtWriter::VisitCXXThisExpr(CXXThisExpr *E) { VisitExpr(E); Record.AddSourceLocation(E->getLocation()); Record.push_back(E->isImplicit()); + Code = serialization::EXPR_CXX_THIS; } @@ -1749,14 +1859,20 @@ void ASTStmtWriter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) { Record.AddDeclRef(E->getParam()); Record.AddDeclRef(cast_or_null<Decl>(E->getUsedContext())); Record.AddSourceLocation(E->getUsedLocation()); + Record.push_back(E->hasRewrittenInit()); + if (E->hasRewrittenInit()) + Record.AddStmt(E->getRewrittenExpr()); Code = serialization::EXPR_CXX_DEFAULT_ARG; } void ASTStmtWriter::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) { VisitExpr(E); + Record.push_back(E->hasRewrittenInit()); Record.AddDeclRef(E->getField()); Record.AddDeclRef(cast_or_null<Decl>(E->getUsedContext())); Record.AddSourceLocation(E->getExprLoc()); + if (E->hasRewrittenInit()) + Record.AddStmt(E->getRewrittenExpr()); Code = serialization::EXPR_CXX_DEFAULT_INIT; } @@ -1785,6 +1901,7 @@ void ASTStmtWriter::VisitCXXNewExpr(CXXNewExpr *E) { Record.push_back(E->isGlobalNew()); Record.push_back(E->passAlignment()); Record.push_back(E->doesUsualArrayDeleteWantSize()); + Record.push_back(E->CXXNewExprBits.HasInitializer); Record.push_back(E->CXXNewExprBits.StoredInitializationStyle); Record.AddDeclRef(E->getOperatorNew()); @@ -1860,10 +1977,10 @@ void ASTStmtWriter::VisitCXXDependentScopeMemberExpr( // Don't emit anything here (or if you do you will have to update // the corresponding deserialization function). - - Record.push_back(E->hasTemplateKWAndArgsInfo()); Record.push_back(E->getNumTemplateArgs()); - Record.push_back(E->hasFirstQualifierFoundInScope()); + CurrentPackingBits.updateBits(); + CurrentPackingBits.addBit(E->hasTemplateKWAndArgsInfo()); + CurrentPackingBits.addBit(E->hasFirstQualifierFoundInScope()); if (E->hasTemplateKWAndArgsInfo()) { const ASTTemplateKWAndArgsInfo &ArgInfo = @@ -1872,14 +1989,15 @@ void ASTStmtWriter::VisitCXXDependentScopeMemberExpr( E->getTrailingObjects<TemplateArgumentLoc>()); } - Record.push_back(E->isArrow()); - Record.AddSourceLocation(E->getOperatorLoc()); + CurrentPackingBits.addBit(E->isArrow()); + Record.AddTypeRef(E->getBaseType()); Record.AddNestedNameSpecifierLoc(E->getQualifierLoc()); + CurrentPackingBits.addBit(!E->isImplicitAccess()); if (!E->isImplicitAccess()) Record.AddStmt(E->getBase()); - else - Record.AddStmt(nullptr); + + Record.AddSourceLocation(E->getOperatorLoc()); if (E->hasFirstQualifierFoundInScope()) Record.AddDeclRef(E->getFirstQualifierFoundInScope()); @@ -1894,12 +2012,14 @@ ASTStmtWriter::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) { // Don't emit anything here, HasTemplateKWAndArgsInfo must be // emitted first. + CurrentPackingBits.addBit( + E->DependentScopeDeclRefExprBits.HasTemplateKWAndArgsInfo); - Record.push_back(E->DependentScopeDeclRefExprBits.HasTemplateKWAndArgsInfo); if (E->DependentScopeDeclRefExprBits.HasTemplateKWAndArgsInfo) { const ASTTemplateKWAndArgsInfo &ArgInfo = *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(); - Record.push_back(ArgInfo.NumTemplateArgs); + // 16 bits should be enought to store the number of args + CurrentPackingBits.addBits(ArgInfo.NumTemplateArgs, /*Width=*/16); AddTemplateKWAndArgsInfo(ArgInfo, E->getTrailingObjects<TemplateArgumentLoc>()); } @@ -1919,6 +2039,7 @@ ASTStmtWriter::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) { Record.AddTypeSourceInfo(E->getTypeSourceInfo()); Record.AddSourceLocation(E->getLParenLoc()); Record.AddSourceLocation(E->getRParenLoc()); + Record.push_back(E->isListInitialization()); Code = serialization::EXPR_CXX_UNRESOLVED_CONSTRUCT; } @@ -1926,7 +2047,9 @@ void ASTStmtWriter::VisitOverloadExpr(OverloadExpr *E) { VisitExpr(E); Record.push_back(E->getNumDecls()); - Record.push_back(E->hasTemplateKWAndArgsInfo()); + + CurrentPackingBits.updateBits(); + CurrentPackingBits.addBit(E->hasTemplateKWAndArgsInfo()); if (E->hasTemplateKWAndArgsInfo()) { const ASTTemplateKWAndArgsInfo &ArgInfo = *E->getTrailingASTTemplateKWAndArgsInfo(); @@ -1947,18 +2070,22 @@ void ASTStmtWriter::VisitOverloadExpr(OverloadExpr *E) { void ASTStmtWriter::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) { VisitOverloadExpr(E); - Record.push_back(E->isArrow()); - Record.push_back(E->hasUnresolvedUsing()); - Record.AddStmt(!E->isImplicitAccess() ? E->getBase() : nullptr); - Record.AddTypeRef(E->getBaseType()); + CurrentPackingBits.addBit(E->isArrow()); + CurrentPackingBits.addBit(E->hasUnresolvedUsing()); + CurrentPackingBits.addBit(!E->isImplicitAccess()); + if (!E->isImplicitAccess()) + Record.AddStmt(E->getBase()); + Record.AddSourceLocation(E->getOperatorLoc()); + + Record.AddTypeRef(E->getBaseType()); Code = serialization::EXPR_CXX_UNRESOLVED_MEMBER; } void ASTStmtWriter::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) { VisitOverloadExpr(E); - Record.push_back(E->requiresADL()); - Record.push_back(E->isOverloaded()); + CurrentPackingBits.addBit(E->requiresADL()); + CurrentPackingBits.addBit(E->isOverloaded()); Record.AddDeclRef(E->getNamingClass()); Code = serialization::EXPR_CXX_UNRESOLVED_LOOKUP; } @@ -2029,8 +2156,13 @@ void ASTStmtWriter::VisitSizeOfPackExpr(SizeOfPackExpr *E) { void ASTStmtWriter::VisitSubstNonTypeTemplateParmExpr( SubstNonTypeTemplateParmExpr *E) { VisitExpr(E); - Record.AddDeclRef(E->getParameter()); - Record.push_back(E->isReferenceParameter()); + Record.AddDeclRef(E->getAssociatedDecl()); + CurrentPackingBits.addBit(E->isReferenceParameter()); + CurrentPackingBits.addBits(E->getIndex(), /*Width=*/12); + CurrentPackingBits.addBit((bool)E->getPackIndex()); + if (auto PackIndex = E->getPackIndex()) + Record.push_back(*PackIndex + 1); + Record.AddSourceLocation(E->getNameLoc()); Record.AddStmt(E->getReplacement()); Code = serialization::EXPR_SUBST_NON_TYPE_TEMPLATE_PARM; @@ -2039,7 +2171,8 @@ void ASTStmtWriter::VisitSubstNonTypeTemplateParmExpr( void ASTStmtWriter::VisitSubstNonTypeTemplateParmPackExpr( SubstNonTypeTemplateParmPackExpr *E) { VisitExpr(E); - Record.AddDeclRef(E->getParameterPack()); + Record.AddDeclRef(E->getAssociatedDecl()); + Record.push_back(E->getIndex()); Record.AddTemplateArgument(E->getArgumentPack()); Record.AddSourceLocation(E->getParameterPackLocation()); Code = serialization::EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK; @@ -2079,6 +2212,30 @@ void ASTStmtWriter::VisitCXXFoldExpr(CXXFoldExpr *E) { Code = serialization::EXPR_CXX_FOLD; } +void ASTStmtWriter::VisitCXXParenListInitExpr(CXXParenListInitExpr *E) { + VisitExpr(E); + ArrayRef<Expr *> InitExprs = E->getInitExprs(); + Record.push_back(InitExprs.size()); + Record.push_back(E->getUserSpecifiedInitExprs().size()); + Record.AddSourceLocation(E->getInitLoc()); + Record.AddSourceLocation(E->getBeginLoc()); + Record.AddSourceLocation(E->getEndLoc()); + for (Expr *InitExpr : E->getInitExprs()) + Record.AddStmt(InitExpr); + Expr *ArrayFiller = E->getArrayFiller(); + FieldDecl *UnionField = E->getInitializedFieldInUnion(); + bool HasArrayFillerOrUnionDecl = ArrayFiller || UnionField; + Record.push_back(HasArrayFillerOrUnionDecl); + if (HasArrayFillerOrUnionDecl) { + Record.push_back(static_cast<bool>(ArrayFiller)); + if (ArrayFiller) + Record.AddStmt(ArrayFiller); + else + Record.AddDeclRef(UnionField); + } + Code = serialization::EXPR_CXX_PAREN_LIST_INIT; +} + void ASTStmtWriter::VisitOpaqueValueExpr(OpaqueValueExpr *E) { VisitExpr(E); Record.AddStmt(E->getSourceExpr()); @@ -2193,6 +2350,7 @@ void ASTStmtWriter::VisitOMPExecutableDirective(OMPExecutableDirective *E) { Record.writeOMPChildren(E->Data); Record.AddSourceLocation(E->getBeginLoc()); Record.AddSourceLocation(E->getEndLoc()); + Record.writeEnum(E->getMappedDirective()); } void ASTStmtWriter::VisitOMPLoopBasedDirective(OMPLoopBasedDirective *D) { @@ -2205,6 +2363,13 @@ void ASTStmtWriter::VisitOMPLoopDirective(OMPLoopDirective *D) { VisitOMPLoopBasedDirective(D); } +void ASTStmtWriter::VisitOMPMetaDirective(OMPMetaDirective *D) { + VisitStmt(D); + Record.push_back(D->getNumClauses()); + VisitOMPExecutableDirective(D); + Code = serialization::STMT_OMP_META_DIRECTIVE; +} + void ASTStmtWriter::VisitOMPParallelDirective(OMPParallelDirective *D) { VisitStmt(D); VisitOMPExecutableDirective(D); @@ -2217,13 +2382,19 @@ void ASTStmtWriter::VisitOMPSimdDirective(OMPSimdDirective *D) { Code = serialization::STMT_OMP_SIMD_DIRECTIVE; } -void ASTStmtWriter::VisitOMPTileDirective(OMPTileDirective *D) { +void ASTStmtWriter::VisitOMPLoopTransformationDirective( + OMPLoopTransformationDirective *D) { VisitOMPLoopBasedDirective(D); + Record.writeUInt32(D->getNumGeneratedLoops()); +} + +void ASTStmtWriter::VisitOMPTileDirective(OMPTileDirective *D) { + VisitOMPLoopTransformationDirective(D); Code = serialization::STMT_OMP_TILE_DIRECTIVE; } void ASTStmtWriter::VisitOMPUnrollDirective(OMPUnrollDirective *D) { - VisitOMPLoopBasedDirective(D); + VisitOMPLoopTransformationDirective(D); Code = serialization::STMT_OMP_UNROLL_DIRECTIVE; } @@ -2252,6 +2423,12 @@ void ASTStmtWriter::VisitOMPSectionDirective(OMPSectionDirective *D) { Code = serialization::STMT_OMP_SECTION_DIRECTIVE; } +void ASTStmtWriter::VisitOMPScopeDirective(OMPScopeDirective *D) { + VisitStmt(D); + VisitOMPExecutableDirective(D); + Code = serialization::STMT_OMP_SCOPE_DIRECTIVE; +} + void ASTStmtWriter::VisitOMPSingleDirective(OMPSingleDirective *D) { VisitStmt(D); VisitOMPExecutableDirective(D); @@ -2290,6 +2467,13 @@ void ASTStmtWriter::VisitOMPParallelMasterDirective( Code = serialization::STMT_OMP_PARALLEL_MASTER_DIRECTIVE; } +void ASTStmtWriter::VisitOMPParallelMaskedDirective( + OMPParallelMaskedDirective *D) { + VisitStmt(D); + VisitOMPExecutableDirective(D); + Code = serialization::STMT_OMP_PARALLEL_MASKED_DIRECTIVE; +} + void ASTStmtWriter::VisitOMPParallelSectionsDirective( OMPParallelSectionsDirective *D) { VisitStmt(D); @@ -2310,6 +2494,7 @@ void ASTStmtWriter::VisitOMPAtomicDirective(OMPAtomicDirective *D) { VisitOMPExecutableDirective(D); Record.writeBool(D->isXLHSInRHSPart()); Record.writeBool(D->isPostfixUpdate()); + Record.writeBool(D->isFailOnly()); Code = serialization::STMT_OMP_ATOMIC_DIRECTIVE; } @@ -2368,10 +2553,18 @@ void ASTStmtWriter::VisitOMPBarrierDirective(OMPBarrierDirective *D) { void ASTStmtWriter::VisitOMPTaskwaitDirective(OMPTaskwaitDirective *D) { VisitStmt(D); + Record.push_back(D->getNumClauses()); VisitOMPExecutableDirective(D); Code = serialization::STMT_OMP_TASKWAIT_DIRECTIVE; } +void ASTStmtWriter::VisitOMPErrorDirective(OMPErrorDirective *D) { + VisitStmt(D); + Record.push_back(D->getNumClauses()); + VisitOMPExecutableDirective(D); + Code = serialization::STMT_OMP_ERROR_DIRECTIVE; +} + void ASTStmtWriter::VisitOMPTaskgroupDirective(OMPTaskgroupDirective *D) { VisitStmt(D); VisitOMPExecutableDirective(D); @@ -2441,12 +2634,25 @@ void ASTStmtWriter::VisitOMPMasterTaskLoopDirective( Code = serialization::STMT_OMP_MASTER_TASKLOOP_DIRECTIVE; } +void ASTStmtWriter::VisitOMPMaskedTaskLoopDirective( + OMPMaskedTaskLoopDirective *D) { + VisitOMPLoopDirective(D); + Record.writeBool(D->hasCancel()); + Code = serialization::STMT_OMP_MASKED_TASKLOOP_DIRECTIVE; +} + void ASTStmtWriter::VisitOMPMasterTaskLoopSimdDirective( OMPMasterTaskLoopSimdDirective *D) { VisitOMPLoopDirective(D); Code = serialization::STMT_OMP_MASTER_TASKLOOP_SIMD_DIRECTIVE; } +void ASTStmtWriter::VisitOMPMaskedTaskLoopSimdDirective( + OMPMaskedTaskLoopSimdDirective *D) { + VisitOMPLoopDirective(D); + Code = serialization::STMT_OMP_MASKED_TASKLOOP_SIMD_DIRECTIVE; +} + void ASTStmtWriter::VisitOMPParallelMasterTaskLoopDirective( OMPParallelMasterTaskLoopDirective *D) { VisitOMPLoopDirective(D); @@ -2454,12 +2660,25 @@ void ASTStmtWriter::VisitOMPParallelMasterTaskLoopDirective( Code = serialization::STMT_OMP_PARALLEL_MASTER_TASKLOOP_DIRECTIVE; } +void ASTStmtWriter::VisitOMPParallelMaskedTaskLoopDirective( + OMPParallelMaskedTaskLoopDirective *D) { + VisitOMPLoopDirective(D); + Record.writeBool(D->hasCancel()); + Code = serialization::STMT_OMP_PARALLEL_MASKED_TASKLOOP_DIRECTIVE; +} + void ASTStmtWriter::VisitOMPParallelMasterTaskLoopSimdDirective( OMPParallelMasterTaskLoopSimdDirective *D) { VisitOMPLoopDirective(D); Code = serialization::STMT_OMP_PARALLEL_MASTER_TASKLOOP_SIMD_DIRECTIVE; } +void ASTStmtWriter::VisitOMPParallelMaskedTaskLoopSimdDirective( + OMPParallelMaskedTaskLoopSimdDirective *D) { + VisitOMPLoopDirective(D); + Code = serialization::STMT_OMP_PARALLEL_MASKED_TASKLOOP_SIMD_DIRECTIVE; +} + void ASTStmtWriter::VisitOMPDistributeDirective(OMPDistributeDirective *D) { VisitOMPLoopDirective(D); Code = serialization::STMT_OMP_DISTRIBUTE_DIRECTIVE; @@ -2577,21 +2796,48 @@ void ASTStmtWriter::VisitOMPMaskedDirective(OMPMaskedDirective *D) { Code = serialization::STMT_OMP_MASKED_DIRECTIVE; } +void ASTStmtWriter::VisitOMPGenericLoopDirective(OMPGenericLoopDirective *D) { + VisitOMPLoopDirective(D); + Code = serialization::STMT_OMP_GENERIC_LOOP_DIRECTIVE; +} + +void ASTStmtWriter::VisitOMPTeamsGenericLoopDirective( + OMPTeamsGenericLoopDirective *D) { + VisitOMPLoopDirective(D); + Code = serialization::STMT_OMP_TEAMS_GENERIC_LOOP_DIRECTIVE; +} + +void ASTStmtWriter::VisitOMPTargetTeamsGenericLoopDirective( + OMPTargetTeamsGenericLoopDirective *D) { + VisitOMPLoopDirective(D); + Code = serialization::STMT_OMP_TARGET_TEAMS_GENERIC_LOOP_DIRECTIVE; +} + +void ASTStmtWriter::VisitOMPParallelGenericLoopDirective( + OMPParallelGenericLoopDirective *D) { + VisitOMPLoopDirective(D); + Code = serialization::STMT_OMP_PARALLEL_GENERIC_LOOP_DIRECTIVE; +} + +void ASTStmtWriter::VisitOMPTargetParallelGenericLoopDirective( + OMPTargetParallelGenericLoopDirective *D) { + VisitOMPLoopDirective(D); + Code = serialization::STMT_OMP_TARGET_PARALLEL_GENERIC_LOOP_DIRECTIVE; +} + //===----------------------------------------------------------------------===// // ASTWriter Implementation //===----------------------------------------------------------------------===// unsigned ASTWriter::RecordSwitchCaseID(SwitchCase *S) { - assert(SwitchCaseIDs.find(S) == SwitchCaseIDs.end() && - "SwitchCase recorded twice"); + assert(!SwitchCaseIDs.contains(S) && "SwitchCase recorded twice"); unsigned NextID = SwitchCaseIDs.size(); SwitchCaseIDs[S] = NextID; return NextID; } unsigned ASTWriter::getSwitchCaseID(SwitchCase *S) { - assert(SwitchCaseIDs.find(S) != SwitchCaseIDs.end() && - "SwitchCase hasn't been seen yet"); + assert(SwitchCaseIDs.contains(S) && "SwitchCase hasn't been seen yet"); return SwitchCaseIDs[S]; } |