| //===- ASTReaderStmt.cpp - Stmt/Expr Deserialization ----------------------===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| // |
| // Statement/expression deserialization. This implements the |
| // ASTReader::ReadStmt method. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "clang/AST/ASTConcept.h" |
| #include "clang/AST/ASTContext.h" |
| #include "clang/AST/AttrIterator.h" |
| #include "clang/AST/Decl.h" |
| #include "clang/AST/DeclAccessPair.h" |
| #include "clang/AST/DeclCXX.h" |
| #include "clang/AST/DeclGroup.h" |
| #include "clang/AST/DeclObjC.h" |
| #include "clang/AST/DeclTemplate.h" |
| #include "clang/AST/DeclarationName.h" |
| #include "clang/AST/DependenceFlags.h" |
| #include "clang/AST/Expr.h" |
| #include "clang/AST/ExprCXX.h" |
| #include "clang/AST/ExprObjC.h" |
| #include "clang/AST/ExprOpenMP.h" |
| #include "clang/AST/NestedNameSpecifier.h" |
| #include "clang/AST/OpenMPClause.h" |
| #include "clang/AST/OperationKinds.h" |
| #include "clang/AST/Stmt.h" |
| #include "clang/AST/StmtCXX.h" |
| #include "clang/AST/StmtObjC.h" |
| #include "clang/AST/StmtOpenMP.h" |
| #include "clang/AST/StmtVisitor.h" |
| #include "clang/AST/TemplateBase.h" |
| #include "clang/AST/Type.h" |
| #include "clang/AST/UnresolvedSet.h" |
| #include "clang/Basic/CapturedStmt.h" |
| #include "clang/Basic/ExpressionTraits.h" |
| #include "clang/Basic/LLVM.h" |
| #include "clang/Basic/Lambda.h" |
| #include "clang/Basic/LangOptions.h" |
| #include "clang/Basic/OpenMPKinds.h" |
| #include "clang/Basic/OperatorKinds.h" |
| #include "clang/Basic/SourceLocation.h" |
| #include "clang/Basic/Specifiers.h" |
| #include "clang/Basic/TypeTraits.h" |
| #include "clang/Lex/Token.h" |
| #include "clang/Serialization/ASTBitCodes.h" |
| #include "clang/Serialization/ASTRecordReader.h" |
| #include "llvm/ADT/BitmaskEnum.h" |
| #include "llvm/ADT/DenseMap.h" |
| #include "llvm/ADT/SmallString.h" |
| #include "llvm/ADT/SmallVector.h" |
| #include "llvm/ADT/StringRef.h" |
| #include "llvm/Bitstream/BitstreamReader.h" |
| #include "llvm/Support/Casting.h" |
| #include "llvm/Support/ErrorHandling.h" |
| #include <algorithm> |
| #include <cassert> |
| #include <cstdint> |
| #include <string> |
| |
| using namespace clang; |
| using namespace serialization; |
| |
| namespace clang { |
| |
| class ASTStmtReader : public StmtVisitor<ASTStmtReader> { |
| ASTRecordReader &Record; |
| llvm::BitstreamCursor &DeclsCursor; |
| |
| SourceLocation readSourceLocation() { |
| return Record.readSourceLocation(); |
| } |
| |
| SourceRange readSourceRange() { |
| return Record.readSourceRange(); |
| } |
| |
| std::string readString() { |
| return Record.readString(); |
| } |
| |
| TypeSourceInfo *readTypeSourceInfo() { |
| return Record.readTypeSourceInfo(); |
| } |
| |
| Decl *readDecl() { |
| return Record.readDecl(); |
| } |
| |
| template<typename T> |
| T *readDeclAs() { |
| return Record.readDeclAs<T>(); |
| } |
| |
| public: |
| ASTStmtReader(ASTRecordReader &Record, llvm::BitstreamCursor &Cursor) |
| : Record(Record), DeclsCursor(Cursor) {} |
| |
| /// The number of record fields required for the Stmt class |
| /// itself. |
| static const unsigned NumStmtFields = 0; |
| |
| /// The number of record fields required for the Expr class |
| /// itself. |
| static const unsigned NumExprFields = |
| NumStmtFields + llvm::BitWidth<ExprDependence> + 3; |
| |
| /// Read and initialize a ExplicitTemplateArgumentList structure. |
| void ReadTemplateKWAndArgsInfo(ASTTemplateKWAndArgsInfo &Args, |
| TemplateArgumentLoc *ArgsLocArray, |
| unsigned NumTemplateArgs); |
| |
| /// Read and initialize a ExplicitTemplateArgumentList structure. |
| void ReadExplicitTemplateArgumentList(ASTTemplateArgumentListInfo &ArgList, |
| unsigned NumTemplateArgs); |
| |
| void VisitStmt(Stmt *S); |
| #define STMT(Type, Base) \ |
| void Visit##Type(Type *); |
| #include "clang/AST/StmtNodes.inc" |
| }; |
| |
| } // namespace clang |
| |
| void ASTStmtReader::ReadTemplateKWAndArgsInfo(ASTTemplateKWAndArgsInfo &Args, |
| TemplateArgumentLoc *ArgsLocArray, |
| unsigned NumTemplateArgs) { |
| SourceLocation TemplateKWLoc = readSourceLocation(); |
| TemplateArgumentListInfo ArgInfo; |
| ArgInfo.setLAngleLoc(readSourceLocation()); |
| ArgInfo.setRAngleLoc(readSourceLocation()); |
| for (unsigned i = 0; i != NumTemplateArgs; ++i) |
| ArgInfo.addArgument(Record.readTemplateArgumentLoc()); |
| Args.initializeFrom(TemplateKWLoc, ArgInfo, ArgsLocArray); |
| } |
| |
| void ASTStmtReader::VisitStmt(Stmt *S) { |
| assert(Record.getIdx() == NumStmtFields && "Incorrect statement field count"); |
| } |
| |
| void ASTStmtReader::VisitNullStmt(NullStmt *S) { |
| VisitStmt(S); |
| S->setSemiLoc(readSourceLocation()); |
| S->NullStmtBits.HasLeadingEmptyMacro = Record.readInt(); |
| } |
| |
| void ASTStmtReader::VisitCompoundStmt(CompoundStmt *S) { |
| VisitStmt(S); |
| SmallVector<Stmt *, 16> Stmts; |
| unsigned NumStmts = Record.readInt(); |
| while (NumStmts--) |
| Stmts.push_back(Record.readSubStmt()); |
| S->setStmts(Stmts); |
| S->CompoundStmtBits.LBraceLoc = readSourceLocation(); |
| S->RBraceLoc = readSourceLocation(); |
| } |
| |
| void ASTStmtReader::VisitSwitchCase(SwitchCase *S) { |
| VisitStmt(S); |
| Record.recordSwitchCaseID(S, Record.readInt()); |
| S->setKeywordLoc(readSourceLocation()); |
| S->setColonLoc(readSourceLocation()); |
| } |
| |
| void ASTStmtReader::VisitCaseStmt(CaseStmt *S) { |
| VisitSwitchCase(S); |
| bool CaseStmtIsGNURange = Record.readInt(); |
| S->setLHS(Record.readSubExpr()); |
| S->setSubStmt(Record.readSubStmt()); |
| if (CaseStmtIsGNURange) { |
| S->setRHS(Record.readSubExpr()); |
| S->setEllipsisLoc(readSourceLocation()); |
| } |
| } |
| |
| void ASTStmtReader::VisitDefaultStmt(DefaultStmt *S) { |
| VisitSwitchCase(S); |
| S->setSubStmt(Record.readSubStmt()); |
| } |
| |
| void ASTStmtReader::VisitLabelStmt(LabelStmt *S) { |
| VisitStmt(S); |
| bool IsSideEntry = Record.readInt(); |
| auto *LD = readDeclAs<LabelDecl>(); |
| LD->setStmt(S); |
| S->setDecl(LD); |
| S->setSubStmt(Record.readSubStmt()); |
| S->setIdentLoc(readSourceLocation()); |
| S->setSideEntry(IsSideEntry); |
| } |
| |
| void ASTStmtReader::VisitAttributedStmt(AttributedStmt *S) { |
| VisitStmt(S); |
| // NumAttrs in AttributedStmt is set when creating an empty |
| // AttributedStmt in AttributedStmt::CreateEmpty, since it is needed |
| // to allocate the right amount of space for the trailing Attr *. |
| uint64_t NumAttrs = Record.readInt(); |
| AttrVec Attrs; |
| Record.readAttributes(Attrs); |
| (void)NumAttrs; |
| assert(NumAttrs == S->AttributedStmtBits.NumAttrs); |
| assert(NumAttrs == Attrs.size()); |
| std::copy(Attrs.begin(), Attrs.end(), S->getAttrArrayPtr()); |
| S->SubStmt = Record.readSubStmt(); |
| S->AttributedStmtBits.AttrLoc = readSourceLocation(); |
| } |
| |
| void ASTStmtReader::VisitIfStmt(IfStmt *S) { |
| VisitStmt(S); |
| |
| bool HasElse = Record.readInt(); |
| bool HasVar = Record.readInt(); |
| bool HasInit = Record.readInt(); |
| |
| S->setStatementKind(static_cast<IfStatementKind>(Record.readInt())); |
| S->setCond(Record.readSubExpr()); |
| S->setThen(Record.readSubStmt()); |
| if (HasElse) |
| S->setElse(Record.readSubStmt()); |
| if (HasVar) |
| S->setConditionVariable(Record.getContext(), readDeclAs<VarDecl>()); |
| if (HasInit) |
| S->setInit(Record.readSubStmt()); |
| |
| S->setIfLoc(readSourceLocation()); |
| S->setLParenLoc(readSourceLocation()); |
| S->setRParenLoc(readSourceLocation()); |
| if (HasElse) |
| S->setElseLoc(readSourceLocation()); |
| } |
| |
| void ASTStmtReader::VisitSwitchStmt(SwitchStmt *S) { |
| VisitStmt(S); |
| |
| bool HasInit = Record.readInt(); |
| bool HasVar = Record.readInt(); |
| bool AllEnumCasesCovered = Record.readInt(); |
| if (AllEnumCasesCovered) |
| S->setAllEnumCasesCovered(); |
| |
| S->setCond(Record.readSubExpr()); |
| S->setBody(Record.readSubStmt()); |
| if (HasInit) |
| S->setInit(Record.readSubStmt()); |
| if (HasVar) |
| S->setConditionVariable(Record.getContext(), readDeclAs<VarDecl>()); |
| |
| S->setSwitchLoc(readSourceLocation()); |
| S->setLParenLoc(readSourceLocation()); |
| S->setRParenLoc(readSourceLocation()); |
| |
| SwitchCase *PrevSC = nullptr; |
| for (auto E = Record.size(); Record.getIdx() != E; ) { |
| SwitchCase *SC = Record.getSwitchCaseWithID(Record.readInt()); |
| if (PrevSC) |
| PrevSC->setNextSwitchCase(SC); |
| else |
| S->setSwitchCaseList(SC); |
| |
| PrevSC = SC; |
| } |
| } |
| |
| void ASTStmtReader::VisitWhileStmt(WhileStmt *S) { |
| VisitStmt(S); |
| |
| bool HasVar = Record.readInt(); |
| |
| S->setCond(Record.readSubExpr()); |
| S->setBody(Record.readSubStmt()); |
| if (HasVar) |
| S->setConditionVariable(Record.getContext(), readDeclAs<VarDecl>()); |
| |
| S->setWhileLoc(readSourceLocation()); |
| S->setLParenLoc(readSourceLocation()); |
| S->setRParenLoc(readSourceLocation()); |
| } |
| |
| void ASTStmtReader::VisitDoStmt(DoStmt *S) { |
| VisitStmt(S); |
| S->setCond(Record.readSubExpr()); |
| S->setBody(Record.readSubStmt()); |
| S->setDoLoc(readSourceLocation()); |
| S->setWhileLoc(readSourceLocation()); |
| S->setRParenLoc(readSourceLocation()); |
| } |
| |
| void ASTStmtReader::VisitForStmt(ForStmt *S) { |
| VisitStmt(S); |
| S->setInit(Record.readSubStmt()); |
| S->setCond(Record.readSubExpr()); |
| S->setConditionVariable(Record.getContext(), readDeclAs<VarDecl>()); |
| S->setInc(Record.readSubExpr()); |
| S->setBody(Record.readSubStmt()); |
| S->setForLoc(readSourceLocation()); |
| S->setLParenLoc(readSourceLocation()); |
| S->setRParenLoc(readSourceLocation()); |
| } |
| |
| void ASTStmtReader::VisitGotoStmt(GotoStmt *S) { |
| VisitStmt(S); |
| S->setLabel(readDeclAs<LabelDecl>()); |
| S->setGotoLoc(readSourceLocation()); |
| S->setLabelLoc(readSourceLocation()); |
| } |
| |
| void ASTStmtReader::VisitIndirectGotoStmt(IndirectGotoStmt *S) { |
| VisitStmt(S); |
| S->setGotoLoc(readSourceLocation()); |
| S->setStarLoc(readSourceLocation()); |
| S->setTarget(Record.readSubExpr()); |
| } |
| |
| void ASTStmtReader::VisitContinueStmt(ContinueStmt *S) { |
| VisitStmt(S); |
| S->setContinueLoc(readSourceLocation()); |
| } |
| |
| void ASTStmtReader::VisitBreakStmt(BreakStmt *S) { |
| VisitStmt(S); |
| S->setBreakLoc(readSourceLocation()); |
| } |
| |
| void ASTStmtReader::VisitReturnStmt(ReturnStmt *S) { |
| VisitStmt(S); |
| |
| bool HasNRVOCandidate = Record.readInt(); |
| |
| S->setRetValue(Record.readSubExpr()); |
| if (HasNRVOCandidate) |
| S->setNRVOCandidate(readDeclAs<VarDecl>()); |
| |
| S->setReturnLoc(readSourceLocation()); |
| } |
| |
| void ASTStmtReader::VisitDeclStmt(DeclStmt *S) { |
| VisitStmt(S); |
| S->setStartLoc(readSourceLocation()); |
| S->setEndLoc(readSourceLocation()); |
| |
| if (Record.size() - Record.getIdx() == 1) { |
| // Single declaration |
| S->setDeclGroup(DeclGroupRef(readDecl())); |
| } else { |
| SmallVector<Decl *, 16> Decls; |
| int N = Record.size() - Record.getIdx(); |
| Decls.reserve(N); |
| for (int I = 0; I < N; ++I) |
| Decls.push_back(readDecl()); |
| S->setDeclGroup(DeclGroupRef(DeclGroup::Create(Record.getContext(), |
| Decls.data(), |
| Decls.size()))); |
| } |
| } |
| |
| void ASTStmtReader::VisitAsmStmt(AsmStmt *S) { |
| VisitStmt(S); |
| S->NumOutputs = Record.readInt(); |
| S->NumInputs = Record.readInt(); |
| S->NumClobbers = Record.readInt(); |
| S->setAsmLoc(readSourceLocation()); |
| S->setVolatile(Record.readInt()); |
| S->setSimple(Record.readInt()); |
| } |
| |
| void ASTStmtReader::VisitGCCAsmStmt(GCCAsmStmt *S) { |
| VisitAsmStmt(S); |
| S->NumLabels = Record.readInt(); |
| S->setRParenLoc(readSourceLocation()); |
| S->setAsmString(cast_or_null<StringLiteral>(Record.readSubStmt())); |
| |
| unsigned NumOutputs = S->getNumOutputs(); |
| unsigned NumInputs = S->getNumInputs(); |
| unsigned NumClobbers = S->getNumClobbers(); |
| unsigned NumLabels = S->getNumLabels(); |
| |
| // Outputs and inputs |
| SmallVector<IdentifierInfo *, 16> Names; |
| SmallVector<StringLiteral*, 16> Constraints; |
| SmallVector<Stmt*, 16> Exprs; |
| for (unsigned I = 0, N = NumOutputs + NumInputs; I != N; ++I) { |
| Names.push_back(Record.readIdentifier()); |
| Constraints.push_back(cast_or_null<StringLiteral>(Record.readSubStmt())); |
| Exprs.push_back(Record.readSubStmt()); |
| } |
| |
| // Constraints |
| SmallVector<StringLiteral*, 16> Clobbers; |
| for (unsigned I = 0; I != NumClobbers; ++I) |
| Clobbers.push_back(cast_or_null<StringLiteral>(Record.readSubStmt())); |
| |
| // Labels |
| for (unsigned I = 0, N = NumLabels; I != N; ++I) |
| Exprs.push_back(Record.readSubStmt()); |
| |
| S->setOutputsAndInputsAndClobbers(Record.getContext(), |
| Names.data(), Constraints.data(), |
| Exprs.data(), NumOutputs, NumInputs, |
| NumLabels, |
| Clobbers.data(), NumClobbers); |
| } |
| |
| void ASTStmtReader::VisitMSAsmStmt(MSAsmStmt *S) { |
| VisitAsmStmt(S); |
| S->LBraceLoc = readSourceLocation(); |
| S->EndLoc = readSourceLocation(); |
| S->NumAsmToks = Record.readInt(); |
| std::string AsmStr = readString(); |
| |
| // Read the tokens. |
| SmallVector<Token, 16> AsmToks; |
| AsmToks.reserve(S->NumAsmToks); |
| for (unsigned i = 0, e = S->NumAsmToks; i != e; ++i) { |
| AsmToks.push_back(Record.readToken()); |
| } |
| |
| // The calls to reserve() for the FooData vectors are mandatory to |
| // prevent dead StringRefs in the Foo vectors. |
| |
| // Read the clobbers. |
| SmallVector<std::string, 16> ClobbersData; |
| SmallVector<StringRef, 16> Clobbers; |
| ClobbersData.reserve(S->NumClobbers); |
| Clobbers.reserve(S->NumClobbers); |
| for (unsigned i = 0, e = S->NumClobbers; i != e; ++i) { |
| ClobbersData.push_back(readString()); |
| Clobbers.push_back(ClobbersData.back()); |
| } |
| |
| // Read the operands. |
| unsigned NumOperands = S->NumOutputs + S->NumInputs; |
| SmallVector<Expr*, 16> Exprs; |
| SmallVector<std::string, 16> ConstraintsData; |
| SmallVector<StringRef, 16> Constraints; |
| Exprs.reserve(NumOperands); |
| ConstraintsData.reserve(NumOperands); |
| Constraints.reserve(NumOperands); |
| for (unsigned i = 0; i != NumOperands; ++i) { |
| Exprs.push_back(cast<Expr>(Record.readSubStmt())); |
| ConstraintsData.push_back(readString()); |
| Constraints.push_back(ConstraintsData.back()); |
| } |
| |
| S->initialize(Record.getContext(), AsmStr, AsmToks, |
| Constraints, Exprs, Clobbers); |
| } |
| |
| void ASTStmtReader::VisitCoroutineBodyStmt(CoroutineBodyStmt *S) { |
| VisitStmt(S); |
| assert(Record.peekInt() == S->NumParams); |
| Record.skipInts(1); |
| auto *StoredStmts = S->getStoredStmts(); |
| for (unsigned i = 0; |
| i < CoroutineBodyStmt::SubStmt::FirstParamMove + S->NumParams; ++i) |
| StoredStmts[i] = Record.readSubStmt(); |
| } |
| |
| void ASTStmtReader::VisitCoreturnStmt(CoreturnStmt *S) { |
| VisitStmt(S); |
| S->CoreturnLoc = Record.readSourceLocation(); |
| for (auto &SubStmt: S->SubStmts) |
| SubStmt = Record.readSubStmt(); |
| S->IsImplicit = Record.readInt() != 0; |
| } |
| |
| void ASTStmtReader::VisitCoawaitExpr(CoawaitExpr *E) { |
| VisitExpr(E); |
| E->KeywordLoc = readSourceLocation(); |
| for (auto &SubExpr: E->SubExprs) |
| SubExpr = Record.readSubStmt(); |
| E->OpaqueValue = cast_or_null<OpaqueValueExpr>(Record.readSubStmt()); |
| E->setIsImplicit(Record.readInt() != 0); |
| } |
| |
| void ASTStmtReader::VisitCoyieldExpr(CoyieldExpr *E) { |
| VisitExpr(E); |
| E->KeywordLoc = readSourceLocation(); |
| for (auto &SubExpr: E->SubExprs) |
| SubExpr = Record.readSubStmt(); |
| E->OpaqueValue = cast_or_null<OpaqueValueExpr>(Record.readSubStmt()); |
| } |
| |
| void ASTStmtReader::VisitDependentCoawaitExpr(DependentCoawaitExpr *E) { |
| VisitExpr(E); |
| E->KeywordLoc = readSourceLocation(); |
| for (auto &SubExpr: E->SubExprs) |
| SubExpr = Record.readSubStmt(); |
| } |
| |
| void ASTStmtReader::VisitCapturedStmt(CapturedStmt *S) { |
| VisitStmt(S); |
| Record.skipInts(1); |
| S->setCapturedDecl(readDeclAs<CapturedDecl>()); |
| S->setCapturedRegionKind(static_cast<CapturedRegionKind>(Record.readInt())); |
| S->setCapturedRecordDecl(readDeclAs<RecordDecl>()); |
| |
| // Capture inits |
| for (CapturedStmt::capture_init_iterator I = S->capture_init_begin(), |
| E = S->capture_init_end(); |
| I != E; ++I) |
| *I = Record.readSubExpr(); |
| |
| // Body |
| S->setCapturedStmt(Record.readSubStmt()); |
| S->getCapturedDecl()->setBody(S->getCapturedStmt()); |
| |
| // Captures |
| for (auto &I : S->captures()) { |
| I.VarAndKind.setPointer(readDeclAs<VarDecl>()); |
| I.VarAndKind.setInt( |
| static_cast<CapturedStmt::VariableCaptureKind>(Record.readInt())); |
| I.Loc = readSourceLocation(); |
| } |
| } |
| |
| void ASTStmtReader::VisitExpr(Expr *E) { |
| VisitStmt(E); |
| E->setType(Record.readType()); |
| |
| // FIXME: write and read all DependentFlags with a single call. |
| bool TypeDependent = Record.readInt(); |
| bool ValueDependent = Record.readInt(); |
| bool InstantiationDependent = Record.readInt(); |
| bool ContainsUnexpandedTemplateParameters = Record.readInt(); |
| bool ContainsErrors = Record.readInt(); |
| auto Deps = ExprDependence::None; |
| if (TypeDependent) |
| Deps |= ExprDependence::Type; |
| if (ValueDependent) |
| Deps |= ExprDependence::Value; |
| if (InstantiationDependent) |
| Deps |= ExprDependence::Instantiation; |
| if (ContainsUnexpandedTemplateParameters) |
| Deps |= ExprDependence::UnexpandedPack; |
| if (ContainsErrors) |
| Deps |= ExprDependence::Error; |
| E->setDependence(Deps); |
| |
| E->setValueKind(static_cast<ExprValueKind>(Record.readInt())); |
| E->setObjectKind(static_cast<ExprObjectKind>(Record.readInt())); |
| assert(Record.getIdx() == NumExprFields && |
| "Incorrect expression field count"); |
| } |
| |
| void ASTStmtReader::VisitConstantExpr(ConstantExpr *E) { |
| VisitExpr(E); |
| |
| auto StorageKind = Record.readInt(); |
| assert(E->ConstantExprBits.ResultKind == StorageKind && "Wrong ResultKind!"); |
| |
| E->ConstantExprBits.APValueKind = Record.readInt(); |
| E->ConstantExprBits.IsUnsigned = Record.readInt(); |
| E->ConstantExprBits.BitWidth = Record.readInt(); |
| E->ConstantExprBits.HasCleanup = false; // Not serialized, see below. |
| E->ConstantExprBits.IsImmediateInvocation = Record.readInt(); |
| |
| switch (StorageKind) { |
| case ConstantExpr::RSK_None: |
| break; |
| |
| case ConstantExpr::RSK_Int64: |
| E->Int64Result() = Record.readInt(); |
| break; |
| |
| case ConstantExpr::RSK_APValue: |
| E->APValueResult() = Record.readAPValue(); |
| if (E->APValueResult().needsCleanup()) { |
| E->ConstantExprBits.HasCleanup = true; |
| Record.getContext().addDestruction(&E->APValueResult()); |
| } |
| break; |
| default: |
| llvm_unreachable("unexpected ResultKind!"); |
| } |
| |
| E->setSubExpr(Record.readSubExpr()); |
| } |
| |
| void ASTStmtReader::VisitSYCLUniqueStableNameExpr(SYCLUniqueStableNameExpr *E) { |
| VisitExpr(E); |
| |
| E->setLocation(readSourceLocation()); |
| E->setLParenLocation(readSourceLocation()); |
| E->setRParenLocation(readSourceLocation()); |
| |
| E->setTypeSourceInfo(Record.readTypeSourceInfo()); |
| } |
| |
| void ASTStmtReader::VisitPredefinedExpr(PredefinedExpr *E) { |
| VisitExpr(E); |
| bool HasFunctionName = Record.readInt(); |
| E->PredefinedExprBits.HasFunctionName = HasFunctionName; |
| E->PredefinedExprBits.Kind = Record.readInt(); |
| E->setLocation(readSourceLocation()); |
| if (HasFunctionName) |
| E->setFunctionName(cast<StringLiteral>(Record.readSubExpr())); |
| } |
| |
| void ASTStmtReader::VisitDeclRefExpr(DeclRefExpr *E) { |
| VisitExpr(E); |
| |
| E->DeclRefExprBits.HasQualifier = Record.readInt(); |
| E->DeclRefExprBits.HasFoundDecl = Record.readInt(); |
| E->DeclRefExprBits.HasTemplateKWAndArgsInfo = Record.readInt(); |
| E->DeclRefExprBits.HadMultipleCandidates = Record.readInt(); |
| E->DeclRefExprBits.RefersToEnclosingVariableOrCapture = Record.readInt(); |
| E->DeclRefExprBits.NonOdrUseReason = Record.readInt(); |
| unsigned NumTemplateArgs = 0; |
| if (E->hasTemplateKWAndArgsInfo()) |
| NumTemplateArgs = Record.readInt(); |
| |
| if (E->hasQualifier()) |
| new (E->getTrailingObjects<NestedNameSpecifierLoc>()) |
| NestedNameSpecifierLoc(Record.readNestedNameSpecifierLoc()); |
| |
| if (E->hasFoundDecl()) |
| *E->getTrailingObjects<NamedDecl *>() = readDeclAs<NamedDecl>(); |
| |
| if (E->hasTemplateKWAndArgsInfo()) |
| ReadTemplateKWAndArgsInfo( |
| *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(), |
| E->getTrailingObjects<TemplateArgumentLoc>(), NumTemplateArgs); |
| |
| E->D = readDeclAs<ValueDecl>(); |
| E->setLocation(readSourceLocation()); |
| E->DNLoc = Record.readDeclarationNameLoc(E->getDecl()->getDeclName()); |
| } |
| |
| void ASTStmtReader::VisitIntegerLiteral(IntegerLiteral *E) { |
| VisitExpr(E); |
| E->setLocation(readSourceLocation()); |
| E->setValue(Record.getContext(), Record.readAPInt()); |
| } |
| |
| void ASTStmtReader::VisitFixedPointLiteral(FixedPointLiteral *E) { |
| VisitExpr(E); |
| E->setLocation(readSourceLocation()); |
| E->setScale(Record.readInt()); |
| E->setValue(Record.getContext(), Record.readAPInt()); |
| } |
| |
| void ASTStmtReader::VisitFloatingLiteral(FloatingLiteral *E) { |
| VisitExpr(E); |
| E->setRawSemantics( |
| static_cast<llvm::APFloatBase::Semantics>(Record.readInt())); |
| E->setExact(Record.readInt()); |
| E->setValue(Record.getContext(), Record.readAPFloat(E->getSemantics())); |
| E->setLocation(readSourceLocation()); |
| } |
| |
| void ASTStmtReader::VisitImaginaryLiteral(ImaginaryLiteral *E) { |
| VisitExpr(E); |
| E->setSubExpr(Record.readSubExpr()); |
| } |
| |
| void ASTStmtReader::VisitStringLiteral(StringLiteral *E) { |
| VisitExpr(E); |
| |
| // NumConcatenated, Length and CharByteWidth are set by the empty |
| // ctor since they are needed to allocate storage for the trailing objects. |
| unsigned NumConcatenated = Record.readInt(); |
| unsigned Length = Record.readInt(); |
| unsigned CharByteWidth = Record.readInt(); |
| assert((NumConcatenated == E->getNumConcatenated()) && |
| "Wrong number of concatenated tokens!"); |
| assert((Length == E->getLength()) && "Wrong Length!"); |
| assert((CharByteWidth == E->getCharByteWidth()) && "Wrong character width!"); |
| E->StringLiteralBits.Kind = Record.readInt(); |
| E->StringLiteralBits.IsPascal = Record.readInt(); |
| |
| // The character width is originally computed via mapCharByteWidth. |
| // Check that the deserialized character width is consistant with the result |
| // of calling mapCharByteWidth. |
| assert((CharByteWidth == |
| StringLiteral::mapCharByteWidth(Record.getContext().getTargetInfo(), |
| E->getKind())) && |
| "Wrong character width!"); |
| |
| // Deserialize the trailing array of SourceLocation. |
| for (unsigned I = 0; I < NumConcatenated; ++I) |
| E->setStrTokenLoc(I, readSourceLocation()); |
| |
| // Deserialize the trailing array of char holding the string data. |
| char *StrData = E->getStrDataAsChar(); |
| for (unsigned I = 0; I < Length * CharByteWidth; ++I) |
| StrData[I] = Record.readInt(); |
| } |
| |
| void ASTStmtReader::VisitCharacterLiteral(CharacterLiteral *E) { |
| VisitExpr(E); |
| E->setValue(Record.readInt()); |
| E->setLocation(readSourceLocation()); |
| E->setKind(static_cast<CharacterLiteral::CharacterKind>(Record.readInt())); |
| } |
| |
| void ASTStmtReader::VisitParenExpr(ParenExpr *E) { |
| VisitExpr(E); |
| E->setLParen(readSourceLocation()); |
| E->setRParen(readSourceLocation()); |
| E->setSubExpr(Record.readSubExpr()); |
| } |
| |
| void ASTStmtReader::VisitParenListExpr(ParenListExpr *E) { |
| VisitExpr(E); |
| unsigned NumExprs = Record.readInt(); |
| assert((NumExprs == E->getNumExprs()) && "Wrong NumExprs!"); |
| for (unsigned I = 0; I != NumExprs; ++I) |
| E->getTrailingObjects<Stmt *>()[I] = Record.readSubStmt(); |
| E->LParenLoc = readSourceLocation(); |
| E->RParenLoc = readSourceLocation(); |
| } |
| |
| void ASTStmtReader::VisitUnaryOperator(UnaryOperator *E) { |
| VisitExpr(E); |
| bool hasFP_Features = Record.readInt(); |
| assert(hasFP_Features == E->hasStoredFPFeatures()); |
| E->setSubExpr(Record.readSubExpr()); |
| E->setOpcode((UnaryOperator::Opcode)Record.readInt()); |
| E->setOperatorLoc(readSourceLocation()); |
| E->setCanOverflow(Record.readInt()); |
| if (hasFP_Features) |
| E->setStoredFPFeatures( |
| FPOptionsOverride::getFromOpaqueInt(Record.readInt())); |
| } |
| |
| void ASTStmtReader::VisitOffsetOfExpr(OffsetOfExpr *E) { |
| VisitExpr(E); |
| assert(E->getNumComponents() == Record.peekInt()); |
| Record.skipInts(1); |
| assert(E->getNumExpressions() == Record.peekInt()); |
| Record.skipInts(1); |
| E->setOperatorLoc(readSourceLocation()); |
| E->setRParenLoc(readSourceLocation()); |
| E->setTypeSourceInfo(readTypeSourceInfo()); |
| for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) { |
| auto Kind = static_cast<OffsetOfNode::Kind>(Record.readInt()); |
| SourceLocation Start = readSourceLocation(); |
| SourceLocation End = readSourceLocation(); |
| switch (Kind) { |
| case OffsetOfNode::Array: |
| E->setComponent(I, OffsetOfNode(Start, Record.readInt(), End)); |
| break; |
| |
| case OffsetOfNode::Field: |
| E->setComponent( |
| I, OffsetOfNode(Start, readDeclAs<FieldDecl>(), End)); |
| break; |
| |
| case OffsetOfNode::Identifier: |
| E->setComponent( |
| I, |
| OffsetOfNode(Start, Record.readIdentifier(), End)); |
| break; |
| |
| case OffsetOfNode::Base: { |
| auto *Base = new (Record.getContext()) CXXBaseSpecifier(); |
| *Base = Record.readCXXBaseSpecifier(); |
| E->setComponent(I, OffsetOfNode(Base)); |
| break; |
| } |
| } |
| } |
| |
| for (unsigned I = 0, N = E->getNumExpressions(); I != N; ++I) |
| E->setIndexExpr(I, Record.readSubExpr()); |
| } |
| |
| void ASTStmtReader::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) { |
| VisitExpr(E); |
| E->setKind(static_cast<UnaryExprOrTypeTrait>(Record.readInt())); |
| if (Record.peekInt() == 0) { |
| E->setArgument(Record.readSubExpr()); |
| Record.skipInts(1); |
| } else { |
| E->setArgument(readTypeSourceInfo()); |
| } |
| E->setOperatorLoc(readSourceLocation()); |
| E->setRParenLoc(readSourceLocation()); |
| } |
| |
| static ConstraintSatisfaction |
| readConstraintSatisfaction(ASTRecordReader &Record) { |
| ConstraintSatisfaction Satisfaction; |
| Satisfaction.IsSatisfied = Record.readInt(); |
| if (!Satisfaction.IsSatisfied) { |
| unsigned NumDetailRecords = Record.readInt(); |
| for (unsigned i = 0; i != NumDetailRecords; ++i) { |
| Expr *ConstraintExpr = Record.readExpr(); |
| if (/* IsDiagnostic */Record.readInt()) { |
| SourceLocation DiagLocation = Record.readSourceLocation(); |
| std::string DiagMessage = Record.readString(); |
| Satisfaction.Details.emplace_back( |
| ConstraintExpr, new (Record.getContext()) |
| ConstraintSatisfaction::SubstitutionDiagnostic{ |
| DiagLocation, DiagMessage}); |
| } else |
| Satisfaction.Details.emplace_back(ConstraintExpr, Record.readExpr()); |
| } |
| } |
| return Satisfaction; |
| } |
| |
| void ASTStmtReader::VisitConceptSpecializationExpr( |
| ConceptSpecializationExpr *E) { |
| VisitExpr(E); |
| unsigned NumTemplateArgs = Record.readInt(); |
| E->NestedNameSpec = Record.readNestedNameSpecifierLoc(); |
| E->TemplateKWLoc = Record.readSourceLocation(); |
| E->ConceptName = Record.readDeclarationNameInfo(); |
| E->NamedConcept = readDeclAs<ConceptDecl>(); |
| E->FoundDecl = Record.readDeclAs<NamedDecl>(); |
| E->ArgsAsWritten = Record.readASTTemplateArgumentListInfo(); |
| llvm::SmallVector<TemplateArgument, 4> Args; |
| for (unsigned I = 0; I < NumTemplateArgs; ++I) |
| Args.push_back(Record.readTemplateArgument()); |
| E->setTemplateArguments(Args); |
| E->Satisfaction = E->isValueDependent() ? nullptr : |
| ASTConstraintSatisfaction::Create(Record.getContext(), |
| readConstraintSatisfaction(Record)); |
| } |
| |
| static concepts::Requirement::SubstitutionDiagnostic * |
| readSubstitutionDiagnostic(ASTRecordReader &Record) { |
| std::string SubstitutedEntity = Record.readString(); |
| SourceLocation DiagLoc = Record.readSourceLocation(); |
| std::string DiagMessage = Record.readString(); |
| return new (Record.getContext()) |
| concepts::Requirement::SubstitutionDiagnostic{SubstitutedEntity, DiagLoc, |
| DiagMessage}; |
| } |
| |
| void ASTStmtReader::VisitRequiresExpr(RequiresExpr *E) { |
| VisitExpr(E); |
| unsigned NumLocalParameters = Record.readInt(); |
| unsigned NumRequirements = Record.readInt(); |
| E->RequiresExprBits.RequiresKWLoc = Record.readSourceLocation(); |
| E->RequiresExprBits.IsSatisfied = Record.readInt(); |
| E->Body = Record.readDeclAs<RequiresExprBodyDecl>(); |
| llvm::SmallVector<ParmVarDecl *, 4> LocalParameters; |
| for (unsigned i = 0; i < NumLocalParameters; ++i) |
| LocalParameters.push_back(cast<ParmVarDecl>(Record.readDecl())); |
| std::copy(LocalParameters.begin(), LocalParameters.end(), |
| E->getTrailingObjects<ParmVarDecl *>()); |
| llvm::SmallVector<concepts::Requirement *, 4> Requirements; |
| for (unsigned i = 0; i < NumRequirements; ++i) { |
| auto RK = |
| static_cast<concepts::Requirement::RequirementKind>(Record.readInt()); |
| concepts::Requirement *R = nullptr; |
| switch (RK) { |
| case concepts::Requirement::RK_Type: { |
| auto Status = |
| static_cast<concepts::TypeRequirement::SatisfactionStatus>( |
| Record.readInt()); |
| if (Status == concepts::TypeRequirement::SS_SubstitutionFailure) |
| R = new (Record.getContext()) |
| concepts::TypeRequirement(readSubstitutionDiagnostic(Record)); |
| else |
| R = new (Record.getContext()) |
| concepts::TypeRequirement(Record.readTypeSourceInfo()); |
| } break; |
| case concepts::Requirement::RK_Simple: |
| case concepts::Requirement::RK_Compound: { |
| auto Status = |
| static_cast<concepts::ExprRequirement::SatisfactionStatus>( |
| Record.readInt()); |
| llvm::PointerUnion<concepts::Requirement::SubstitutionDiagnostic *, |
| Expr *> E; |
| if (Status == concepts::ExprRequirement::SS_ExprSubstitutionFailure) { |
| E = readSubstitutionDiagnostic(Record); |
| } else |
| E = Record.readExpr(); |
| |
| llvm::Optional<concepts::ExprRequirement::ReturnTypeRequirement> Req; |
| ConceptSpecializationExpr *SubstitutedConstraintExpr = nullptr; |
| SourceLocation NoexceptLoc; |
| if (RK == concepts::Requirement::RK_Simple) { |
| Req.emplace(); |
| } else { |
| NoexceptLoc = Record.readSourceLocation(); |
| switch (/* returnTypeRequirementKind */Record.readInt()) { |
| case 0: |
| // No return type requirement. |
| Req.emplace(); |
| break; |
| case 1: { |
| // type-constraint |
| TemplateParameterList *TPL = Record.readTemplateParameterList(); |
| if (Status >= |
| concepts::ExprRequirement::SS_ConstraintsNotSatisfied) |
| SubstitutedConstraintExpr = |
| cast<ConceptSpecializationExpr>(Record.readExpr()); |
| Req.emplace(TPL); |
| } break; |
| case 2: |
| // Substitution failure |
| Req.emplace(readSubstitutionDiagnostic(Record)); |
| break; |
| } |
| } |
| if (Expr *Ex = E.dyn_cast<Expr *>()) |
| R = new (Record.getContext()) concepts::ExprRequirement( |
| Ex, RK == concepts::Requirement::RK_Simple, NoexceptLoc, |
| std::move(*Req), Status, SubstitutedConstraintExpr); |
| else |
| R = new (Record.getContext()) concepts::ExprRequirement( |
| E.get<concepts::Requirement::SubstitutionDiagnostic *>(), |
| RK == concepts::Requirement::RK_Simple, NoexceptLoc, |
| std::move(*Req)); |
| } break; |
| case concepts::Requirement::RK_Nested: { |
| if (/* IsSubstitutionDiagnostic */Record.readInt()) { |
| R = new (Record.getContext()) concepts::NestedRequirement( |
| readSubstitutionDiagnostic(Record)); |
| break; |
| } |
| Expr *E = Record.readExpr(); |
| if (E->isInstantiationDependent()) |
| R = new (Record.getContext()) concepts::NestedRequirement(E); |
| else |
| R = new (Record.getContext()) |
| concepts::NestedRequirement(Record.getContext(), E, |
| readConstraintSatisfaction(Record)); |
| } break; |
| } |
| if (!R) |
| continue; |
| Requirements.push_back(R); |
| } |
| std::copy(Requirements.begin(), Requirements.end(), |
| E->getTrailingObjects<concepts::Requirement *>()); |
| E->RBraceLoc = Record.readSourceLocation(); |
| } |
| |
| void ASTStmtReader::VisitArraySubscriptExpr(ArraySubscriptExpr *E) { |
| VisitExpr(E); |
| E->setLHS(Record.readSubExpr()); |
| E->setRHS(Record.readSubExpr()); |
| E->setRBracketLoc(readSourceLocation()); |
| } |
| |
| void ASTStmtReader::VisitMatrixSubscriptExpr(MatrixSubscriptExpr *E) { |
| VisitExpr(E); |
| E->setBase(Record.readSubExpr()); |
| E->setRowIdx(Record.readSubExpr()); |
| E->setColumnIdx(Record.readSubExpr()); |
| E->setRBracketLoc(readSourceLocation()); |
| } |
| |
| void ASTStmtReader::VisitOMPArraySectionExpr(OMPArraySectionExpr *E) { |
| VisitExpr(E); |
| E->setBase(Record.readSubExpr()); |
| E->setLowerBound(Record.readSubExpr()); |
| E->setLength(Record.readSubExpr()); |
| E->setStride(Record.readSubExpr()); |
| E->setColonLocFirst(readSourceLocation()); |
| E->setColonLocSecond(readSourceLocation()); |
| E->setRBracketLoc(readSourceLocation()); |
| } |
| |
| void ASTStmtReader::VisitOMPArrayShapingExpr(OMPArrayShapingExpr *E) { |
| VisitExpr(E); |
| unsigned NumDims = Record.readInt(); |
| E->setBase(Record.readSubExpr()); |
| SmallVector<Expr *, 4> Dims(NumDims); |
| for (unsigned I = 0; I < NumDims; ++I) |
| Dims[I] = Record.readSubExpr(); |
| E->setDimensions(Dims); |
| SmallVector<SourceRange, 4> SRs(NumDims); |
| for (unsigned I = 0; I < NumDims; ++I) |
| SRs[I] = readSourceRange(); |
| E->setBracketsRanges(SRs); |
| E->setLParenLoc(readSourceLocation()); |
| E->setRParenLoc(readSourceLocation()); |
| } |
| |
| void ASTStmtReader::VisitOMPIteratorExpr(OMPIteratorExpr *E) { |
| VisitExpr(E); |
| unsigned NumIters = Record.readInt(); |
| E->setIteratorKwLoc(readSourceLocation()); |
| E->setLParenLoc(readSourceLocation()); |
| E->setRParenLoc(readSourceLocation()); |
| for (unsigned I = 0; I < NumIters; ++I) { |
| E->setIteratorDeclaration(I, Record.readDeclRef()); |
| E->setAssignmentLoc(I, readSourceLocation()); |
| Expr *Begin = Record.readSubExpr(); |
| Expr *End = Record.readSubExpr(); |
| Expr *Step = Record.readSubExpr(); |
| SourceLocation ColonLoc = readSourceLocation(); |
| SourceLocation SecColonLoc; |
| if (Step) |
| SecColonLoc = readSourceLocation(); |
| E->setIteratorRange(I, Begin, ColonLoc, End, SecColonLoc, Step); |
| // Deserialize helpers |
| OMPIteratorHelperData HD; |
| HD.CounterVD = cast_or_null<VarDecl>(Record.readDeclRef()); |
| HD.Upper = Record.readSubExpr(); |
| HD.Update = Record.readSubExpr(); |
| HD.CounterUpdate = Record.readSubExpr(); |
| E->setHelper(I, HD); |
| } |
| } |
| |
| void ASTStmtReader::VisitCallExpr(CallExpr *E) { |
| VisitExpr(E); |
| unsigned NumArgs = Record.readInt(); |
| bool HasFPFeatures = Record.readInt(); |
| assert((NumArgs == E->getNumArgs()) && "Wrong NumArgs!"); |
| E->setRParenLoc(readSourceLocation()); |
| E->setCallee(Record.readSubExpr()); |
| for (unsigned I = 0; I != NumArgs; ++I) |
| E->setArg(I, Record.readSubExpr()); |
| E->setADLCallKind(static_cast<CallExpr::ADLCallKind>(Record.readInt())); |
| if (HasFPFeatures) |
| E->setStoredFPFeatures( |
| FPOptionsOverride::getFromOpaqueInt(Record.readInt())); |
| } |
| |
| void ASTStmtReader::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) { |
| VisitCallExpr(E); |
| } |
| |
| void ASTStmtReader::VisitMemberExpr(MemberExpr *E) { |
| VisitExpr(E); |
| |
| bool HasQualifier = Record.readInt(); |
| bool HasFoundDecl = Record.readInt(); |
| bool HasTemplateInfo = Record.readInt(); |
| unsigned NumTemplateArgs = Record.readInt(); |
| |
| E->Base = Record.readSubExpr(); |
| E->MemberDecl = Record.readDeclAs<ValueDecl>(); |
| E->MemberDNLoc = Record.readDeclarationNameLoc(E->MemberDecl->getDeclName()); |
| E->MemberLoc = Record.readSourceLocation(); |
| E->MemberExprBits.IsArrow = Record.readInt(); |
| E->MemberExprBits.HasQualifierOrFoundDecl = HasQualifier || HasFoundDecl; |
| E->MemberExprBits.HasTemplateKWAndArgsInfo = HasTemplateInfo; |
| E->MemberExprBits.HadMultipleCandidates = Record.readInt(); |
| E->MemberExprBits.NonOdrUseReason = Record.readInt(); |
| E->MemberExprBits.OperatorLoc = Record.readSourceLocation(); |
| |
| if (HasQualifier || HasFoundDecl) { |
| DeclAccessPair FoundDecl; |
| if (HasFoundDecl) { |
| auto *FoundD = Record.readDeclAs<NamedDecl>(); |
| auto AS = (AccessSpecifier)Record.readInt(); |
| FoundDecl = DeclAccessPair::make(FoundD, AS); |
| } else { |
| FoundDecl = DeclAccessPair::make(E->MemberDecl, |
| E->MemberDecl->getAccess()); |
| } |
| E->getTrailingObjects<MemberExprNameQualifier>()->FoundDecl = FoundDecl; |
| |
| NestedNameSpecifierLoc QualifierLoc; |
| if (HasQualifier) |
| QualifierLoc = Record.readNestedNameSpecifierLoc(); |
| E->getTrailingObjects<MemberExprNameQualifier>()->QualifierLoc = |
| QualifierLoc; |
| } |
| |
| if (HasTemplateInfo) |
| ReadTemplateKWAndArgsInfo( |
| *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(), |
| E->getTrailingObjects<TemplateArgumentLoc>(), NumTemplateArgs); |
| } |
| |
| void ASTStmtReader::VisitObjCIsaExpr(ObjCIsaExpr *E) { |
| VisitExpr(E); |
| E->setBase(Record.readSubExpr()); |
| E->setIsaMemberLoc(readSourceLocation()); |
| E->setOpLoc(readSourceLocation()); |
| E->setArrow(Record.readInt()); |
| } |
| |
| void ASTStmtReader:: |
| VisitObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) { |
| VisitExpr(E); |
| E->Operand = Record.readSubExpr(); |
| E->setShouldCopy(Record.readInt()); |
| } |
| |
| void ASTStmtReader::VisitObjCBridgedCastExpr(ObjCBridgedCastExpr *E) { |
| VisitExplicitCastExpr(E); |
| E->LParenLoc = readSourceLocation(); |
| E->BridgeKeywordLoc = readSourceLocation(); |
| E->Kind = Record.readInt(); |
| } |
| |
| void ASTStmtReader::VisitCastExpr(CastExpr *E) { |
| VisitExpr(E); |
| unsigned NumBaseSpecs = Record.readInt(); |
| assert(NumBaseSpecs == E->path_size()); |
| unsigned HasFPFeatures = Record.readInt(); |
| assert(E->hasStoredFPFeatures() == HasFPFeatures); |
| E->setSubExpr(Record.readSubExpr()); |
| E->setCastKind((CastKind)Record.readInt()); |
| CastExpr::path_iterator BaseI = E->path_begin(); |
| while (NumBaseSpecs--) { |
| auto *BaseSpec = new (Record.getContext()) CXXBaseSpecifier; |
| *BaseSpec = Record.readCXXBaseSpecifier(); |
| *BaseI++ = BaseSpec; |
| } |
| if (HasFPFeatures) |
| *E->getTrailingFPFeatures() = |
| FPOptionsOverride::getFromOpaqueInt(Record.readInt()); |
| } |
| |
| void ASTStmtReader::VisitBinaryOperator(BinaryOperator *E) { |
| bool hasFP_Features; |
| VisitExpr(E); |
| E->setHasStoredFPFeatures(hasFP_Features = Record.readInt()); |
| E->setOpcode((BinaryOperator::Opcode)Record.readInt()); |
| E->setLHS(Record.readSubExpr()); |
| E->setRHS(Record.readSubExpr()); |
| E->setOperatorLoc(readSourceLocation()); |
| if (hasFP_Features) |
| E->setStoredFPFeatures( |
| FPOptionsOverride::getFromOpaqueInt(Record.readInt())); |
| } |
| |
| void ASTStmtReader::VisitCompoundAssignOperator(CompoundAssignOperator *E) { |
| VisitBinaryOperator(E); |
| E->setComputationLHSType(Record.readType()); |
| E->setComputationResultType(Record.readType()); |
| } |
| |
| void ASTStmtReader::VisitConditionalOperator(ConditionalOperator *E) { |
| VisitExpr(E); |
| E->SubExprs[ConditionalOperator::COND] = Record.readSubExpr(); |
| E->SubExprs[ConditionalOperator::LHS] = Record.readSubExpr(); |
| E->SubExprs[ConditionalOperator::RHS] = Record.readSubExpr(); |
| E->QuestionLoc = readSourceLocation(); |
| E->ColonLoc = readSourceLocation(); |
| } |
| |
| void |
| ASTStmtReader::VisitBinaryConditionalOperator(BinaryConditionalOperator *E) { |
| VisitExpr(E); |
| E->OpaqueValue = cast<OpaqueValueExpr>(Record.readSubExpr()); |
| E->SubExprs[BinaryConditionalOperator::COMMON] = Record.readSubExpr(); |
| E->SubExprs[BinaryConditionalOperator::COND] = Record.readSubExpr(); |
| E->SubExprs[BinaryConditionalOperator::LHS] = Record.readSubExpr(); |
| E->SubExprs[BinaryConditionalOperator::RHS] = Record.readSubExpr(); |
| E->QuestionLoc = readSourceLocation(); |
| E->ColonLoc = readSourceLocation(); |
| } |
| |
| void ASTStmtReader::VisitImplicitCastExpr(ImplicitCastExpr *E) { |
| VisitCastExpr(E); |
| E->setIsPartOfExplicitCast(Record.readInt()); |
| } |
| |
| void ASTStmtReader::VisitExplicitCastExpr(ExplicitCastExpr *E) { |
| VisitCastExpr(E); |
| E->setTypeInfoAsWritten(readTypeSourceInfo()); |
| } |
| |
| void ASTStmtReader::VisitCStyleCastExpr(CStyleCastExpr *E) { |
| VisitExplicitCastExpr(E); |
| E->setLParenLoc(readSourceLocation()); |
| E->setRParenLoc(readSourceLocation()); |
| } |
| |
| void ASTStmtReader::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) { |
| VisitExpr(E); |
| E->setLParenLoc(readSourceLocation()); |
| E->setTypeSourceInfo(readTypeSourceInfo()); |
| E->setInitializer(Record.readSubExpr()); |
| E->setFileScope(Record.readInt()); |
| } |
| |
| void ASTStmtReader::VisitExtVectorElementExpr(ExtVectorElementExpr *E) { |
| VisitExpr(E); |
| E->setBase(Record.readSubExpr()); |
| E->setAccessor(Record.readIdentifier()); |
| E->setAccessorLoc(readSourceLocation()); |
| } |
| |
| void ASTStmtReader::VisitInitListExpr(InitListExpr *E) { |
| VisitExpr(E); |
| if (auto *SyntForm = cast_or_null<InitListExpr>(Record.readSubStmt())) |
| E->setSyntacticForm(SyntForm); |
| E->setLBraceLoc(readSourceLocation()); |
| E->setRBraceLoc(readSourceLocation()); |
| bool isArrayFiller = Record.readInt(); |
| Expr *filler = nullptr; |
| if (isArrayFiller) { |
| filler = Record.readSubExpr(); |
| E->ArrayFillerOrUnionFieldInit = filler; |
| } else |
| E->ArrayFillerOrUnionFieldInit = readDeclAs<FieldDecl>(); |
| E->sawArrayRangeDesignator(Record.readInt()); |
| unsigned NumInits = Record.readInt(); |
| E->reserveInits(Record.getContext(), NumInits); |
| if (isArrayFiller) { |
| for (unsigned I = 0; I != NumInits; ++I) { |
| Expr *init = Record.readSubExpr(); |
| E->updateInit(Record.getContext(), I, init ? init : filler); |
| } |
| } else { |
| for (unsigned I = 0; I != NumInits; ++I) |
| E->updateInit(Record.getContext(), I, Record.readSubExpr()); |
| } |
| } |
| |
| void ASTStmtReader::VisitDesignatedInitExpr(DesignatedInitExpr *E) { |
| using Designator = DesignatedInitExpr::Designator; |
| |
| VisitExpr(E); |
| unsigned NumSubExprs = Record.readInt(); |
| assert(NumSubExprs == E->getNumSubExprs() && "Wrong number of subexprs"); |
| for (unsigned I = 0; I != NumSubExprs; ++I) |
| E->setSubExpr(I, Record.readSubExpr()); |
| E->setEqualOrColonLoc(readSourceLocation()); |
| E->setGNUSyntax(Record.readInt()); |
| |
| SmallVector<Designator, 4> Designators; |
| while (Record.getIdx() < Record.size()) { |
| switch ((DesignatorTypes)Record.readInt()) { |
| case DESIG_FIELD_DECL: { |
| auto *Field = readDeclAs<FieldDecl>(); |
| SourceLocation DotLoc = readSourceLocation(); |
| SourceLocation FieldLoc = readSourceLocation(); |
| Designators.push_back(Designator(Field->getIdentifier(), DotLoc, |
| FieldLoc)); |
| Designators.back().setField(Field); |
| break; |
| } |
| |
| case DESIG_FIELD_NAME: { |
| const IdentifierInfo *Name = Record.readIdentifier(); |
| SourceLocation DotLoc = readSourceLocation(); |
| SourceLocation FieldLoc = readSourceLocation(); |
| Designators.push_back(Designator(Name, DotLoc, FieldLoc)); |
| break; |
| } |
| |
| case DESIG_ARRAY: { |
| unsigned Index = Record.readInt(); |
| SourceLocation LBracketLoc = readSourceLocation(); |
| SourceLocation RBracketLoc = readSourceLocation(); |
| Designators.push_back(Designator(Index, LBracketLoc, RBracketLoc)); |
| break; |
| } |
| |
| case DESIG_ARRAY_RANGE: { |
| unsigned Index = Record.readInt(); |
| SourceLocation LBracketLoc = readSourceLocation(); |
| SourceLocation EllipsisLoc = readSourceLocation(); |
| SourceLocation RBracketLoc = readSourceLocation(); |
| Designators.push_back(Designator(Index, LBracketLoc, EllipsisLoc, |
| RBracketLoc)); |
| break; |
| } |
| } |
| } |
| E->setDesignators(Record.getContext(), |
| Designators.data(), Designators.size()); |
| } |
| |
| void ASTStmtReader::VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E) { |
| VisitExpr(E); |
| E->setBase(Record.readSubExpr()); |
| E->setUpdater(Record.readSubExpr()); |
| } |
| |
| void ASTStmtReader::VisitNoInitExpr(NoInitExpr *E) { |
| VisitExpr(E); |
| } |
| |
| void ASTStmtReader::VisitArrayInitLoopExpr(ArrayInitLoopExpr *E) { |
| VisitExpr(E); |
| E->SubExprs[0] = Record.readSubExpr(); |
| E->SubExprs[1] = Record.readSubExpr(); |
| } |
| |
| void ASTStmtReader::VisitArrayInitIndexExpr(ArrayInitIndexExpr *E) { |
| VisitExpr(E); |
| } |
| |
| void ASTStmtReader::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) { |
| VisitExpr(E); |
| } |
| |
| void ASTStmtReader::VisitVAArgExpr(VAArgExpr *E) { |
| VisitExpr(E); |
| E->setSubExpr(Record.readSubExpr()); |
| E->setWrittenTypeInfo(readTypeSourceInfo()); |
| E->setBuiltinLoc(readSourceLocation()); |
| E->setRParenLoc(readSourceLocation()); |
| E->setIsMicrosoftABI(Record.readInt()); |
| } |
| |
| void ASTStmtReader::VisitSourceLocExpr(SourceLocExpr *E) { |
| VisitExpr(E); |
| E->ParentContext = readDeclAs<DeclContext>(); |
| E->BuiltinLoc = readSourceLocation(); |
| E->RParenLoc = readSourceLocation(); |
| E->SourceLocExprBits.Kind = |
| static_cast<SourceLocExpr::IdentKind>(Record.readInt()); |
| } |
| |
| void ASTStmtReader::VisitAddrLabelExpr(AddrLabelExpr *E) { |
| VisitExpr(E); |
| E->setAmpAmpLoc(readSourceLocation()); |
| E->setLabelLoc(readSourceLocation()); |
| E->setLabel(readDeclAs<LabelDecl>()); |
| } |
| |
| void ASTStmtReader::VisitStmtExpr(StmtExpr *E) { |
| VisitExpr(E); |
| E->setLParenLoc(readSourceLocation()); |
| E->setRParenLoc(readSourceLocation()); |
| E->setSubStmt(cast_or_null<CompoundStmt>(Record.readSubStmt())); |
| E->StmtExprBits.TemplateDepth = Record.readInt(); |
| } |
| |
| void ASTStmtReader::VisitChooseExpr(ChooseExpr *E) { |
| VisitExpr(E); |
| E->setCond(Record.readSubExpr()); |
| E->setLHS(Record.readSubExpr()); |
| E->setRHS(Record.readSubExpr()); |
| E->setBuiltinLoc(readSourceLocation()); |
| E->setRParenLoc(readSourceLocation()); |
| E->setIsConditionTrue(Record.readInt()); |
| } |
| |
| void ASTStmtReader::VisitGNUNullExpr(GNUNullExpr *E) { |
| VisitExpr(E); |
| E->setTokenLocation(readSourceLocation()); |
| } |
| |
| void ASTStmtReader::VisitShuffleVectorExpr(ShuffleVectorExpr *E) { |
| VisitExpr(E); |
| SmallVector<Expr *, 16> Exprs; |
| unsigned NumExprs = Record.readInt(); |
| while (NumExprs--) |
| Exprs.push_back(Record.readSubExpr()); |
| E->setExprs(Record.getContext(), Exprs); |
| E->setBuiltinLoc(readSourceLocation()); |
| E->setRParenLoc(readSourceLocation()); |
| } |
| |
| void ASTStmtReader::VisitConvertVectorExpr(ConvertVectorExpr *E) { |
| VisitExpr(E); |
| E->BuiltinLoc = readSourceLocation(); |
| E->RParenLoc = readSourceLocation(); |
| E->TInfo = readTypeSourceInfo(); |
| E->SrcExpr = Record.readSubExpr(); |
| } |
| |
| void ASTStmtReader::VisitBlockExpr(BlockExpr *E) { |
| VisitExpr(E); |
| E->setBlockDecl(readDeclAs<BlockDecl>()); |
| } |
| |
| void ASTStmtReader::VisitGenericSelectionExpr(GenericSelectionExpr *E) { |
| VisitExpr(E); |
| |
| unsigned NumAssocs = Record.readInt(); |
| assert(NumAssocs == E->getNumAssocs() && "Wrong NumAssocs!"); |
| E->ResultIndex = Record.readInt(); |
| E->GenericSelectionExprBits.GenericLoc = readSourceLocation(); |
| E->DefaultLoc = readSourceLocation(); |
| E->RParenLoc = readSourceLocation(); |
| |
| Stmt **Stmts = E->getTrailingObjects<Stmt *>(); |
| // Add 1 to account for the controlling expression which is the first |
| // expression in the trailing array of Stmt *. This is not needed for |
| // the trailing array of TypeSourceInfo *. |
| for (unsigned I = 0, N = NumAssocs + 1; I < N; ++I) |
| Stmts[I] = Record.readSubExpr(); |
| |
| TypeSourceInfo **TSIs = E->getTrailingObjects<TypeSourceInfo *>(); |
| for (unsigned I = 0, N = NumAssocs; I < N; ++I) |
| TSIs[I] = readTypeSourceInfo(); |
| } |
| |
| void ASTStmtReader::VisitPseudoObjectExpr(PseudoObjectExpr *E) { |
| VisitExpr(E); |
| unsigned numSemanticExprs = Record.readInt(); |
| assert(numSemanticExprs + 1 == E->PseudoObjectExprBits.NumSubExprs); |
| E->PseudoObjectExprBits.ResultIndex = Record.readInt(); |
| |
| // Read the syntactic expression. |
| E->getSubExprsBuffer()[0] = Record.readSubExpr(); |
| |
| // Read all the semantic expressions. |
| for (unsigned i = 0; i != numSemanticExprs; ++i) { |
| Expr *subExpr = Record.readSubExpr(); |
| E->getSubExprsBuffer()[i+1] = subExpr; |
| } |
| } |
| |
| void ASTStmtReader::VisitAtomicExpr(AtomicExpr *E) { |
| VisitExpr(E); |
| E->Op = AtomicExpr::AtomicOp(Record.readInt()); |
| E->NumSubExprs = AtomicExpr::getNumSubExprs(E->Op); |
| for (unsigned I = 0; I != E->NumSubExprs; ++I) |
| E->SubExprs[I] = Record.readSubExpr(); |
| E->BuiltinLoc = readSourceLocation(); |
| E->RParenLoc = readSourceLocation(); |
| } |
| |
| //===----------------------------------------------------------------------===// |
| // Objective-C Expressions and Statements |
| |
| void ASTStmtReader::VisitObjCStringLiteral(ObjCStringLiteral *E) { |
| VisitExpr(E); |
| E->setString(cast<StringLiteral>(Record.readSubStmt())); |
| E->setAtLoc(readSourceLocation()); |
| } |
| |
| void ASTStmtReader::VisitObjCBoxedExpr(ObjCBoxedExpr *E) { |
| VisitExpr(E); |
| // could be one of several IntegerLiteral, FloatLiteral, etc. |
| E->SubExpr = Record.readSubStmt(); |
| E->BoxingMethod = readDeclAs<ObjCMethodDecl>(); |
| E->Range = readSourceRange(); |
| } |
| |
| void ASTStmtReader::VisitObjCArrayLiteral(ObjCArrayLiteral *E) { |
| VisitExpr(E); |
| unsigned NumElements = Record.readInt(); |
| assert(NumElements == E->getNumElements() && "Wrong number of elements"); |
| Expr **Elements = E->getElements(); |
| for (unsigned I = 0, N = NumElements; I != N; ++I) |
| Elements[I] = Record.readSubExpr(); |
| E->ArrayWithObjectsMethod = readDeclAs<ObjCMethodDecl>(); |
| E->Range = readSourceRange(); |
| } |
| |
| void ASTStmtReader::VisitObjCDictionaryLiteral(ObjCDictionaryLiteral *E) { |
| VisitExpr(E); |
| unsigned NumElements = Record.readInt(); |
| assert(NumElements == E->getNumElements() && "Wrong number of elements"); |
| bool HasPackExpansions = Record.readInt(); |
| assert(HasPackExpansions == E->HasPackExpansions &&"Pack expansion mismatch"); |
| auto *KeyValues = |
| E->getTrailingObjects<ObjCDictionaryLiteral::KeyValuePair>(); |
| auto *Expansions = |
| E->getTrailingObjects<ObjCDictionaryLiteral::ExpansionData>(); |
| for (unsigned I = 0; I != NumElements; ++I) { |
| KeyValues[I].Key = Record.readSubExpr(); |
| KeyValues[I].Value = Record.readSubExpr(); |
| if (HasPackExpansions) { |
| Expansions[I].EllipsisLoc = readSourceLocation(); |
| Expansions[I].NumExpansionsPlusOne = Record.readInt(); |
| } |
| } |
| E->DictWithObjectsMethod = readDeclAs<ObjCMethodDecl>(); |
| E->Range = readSourceRange(); |
| } |
| |
| void ASTStmtReader::VisitObjCEncodeExpr(ObjCEncodeExpr *E) { |
| VisitExpr(E); |
| E->setEncodedTypeSourceInfo(readTypeSourceInfo()); |
| E->setAtLoc(readSourceLocation()); |
| E->setRParenLoc(readSourceLocation()); |
| } |
| |
| void ASTStmtReader::VisitObjCSelectorExpr(ObjCSelectorExpr *E) { |
| VisitExpr(E); |
| E->setSelector(Record.readSelector()); |
| E->setAtLoc(readSourceLocation()); |
| E->setRParenLoc(readSourceLocation()); |
| } |
| |
| void ASTStmtReader::VisitObjCProtocolExpr(ObjCProtocolExpr *E) { |
| VisitExpr(E); |
| E->setProtocol(readDeclAs<ObjCProtocolDecl>()); |
| E->setAtLoc(readSourceLocation()); |
| E->ProtoLoc = readSourceLocation(); |
| E->setRParenLoc(readSourceLocation()); |
| } |
| |
| void ASTStmtReader::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) { |
| VisitExpr(E); |
| E->setDecl(readDeclAs<ObjCIvarDecl>()); |
| E->setLocation(readSourceLocation()); |
| E->setOpLoc(readSourceLocation()); |
| E->setBase(Record.readSubExpr()); |
| E->setIsArrow(Record.readInt()); |
| E->setIsFreeIvar(Record.readInt()); |
| } |
| |
| void ASTStmtReader::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) { |
| VisitExpr(E); |
| unsigned MethodRefFlags = Record.readInt(); |
| bool Implicit = Record.readInt() != 0; |
| if (Implicit) { |
| auto *Getter = readDeclAs<ObjCMethodDecl>(); |
| auto *Setter = readDeclAs<ObjCMethodDecl>(); |
| E->setImplicitProperty(Getter, Setter, MethodRefFlags); |
| } else { |
| E->setExplicitProperty(readDeclAs<ObjCPropertyDecl>(), MethodRefFlags); |
| } |
| E->setLocation(readSourceLocation()); |
| E->setReceiverLocation(readSourceLocation()); |
| switch (Record.readInt()) { |
| case 0: |
| E->setBase(Record.readSubExpr()); |
| break; |
| case 1: |
| E->setSuperReceiver(Record.readType()); |
| break; |
| case 2: |
| E->setClassReceiver(readDeclAs<ObjCInterfaceDecl>()); |
| break; |
| } |
| } |
| |
| void ASTStmtReader::VisitObjCSubscriptRefExpr(ObjCSubscriptRefExpr *E) { |
| VisitExpr(E); |
| E->setRBracket(readSourceLocation()); |
| E->setBaseExpr(Record.readSubExpr()); |
| E->setKeyExpr(Record.readSubExpr()); |
| E->GetAtIndexMethodDecl = readDeclAs<ObjCMethodDecl>(); |
| E->SetAtIndexMethodDecl = readDeclAs<ObjCMethodDecl>(); |
| } |
| |
| void ASTStmtReader::VisitObjCMessageExpr(ObjCMessageExpr *E) { |
| VisitExpr(E); |
| assert(Record.peekInt() == E->getNumArgs()); |
| Record.skipInts(1); |
| unsigned NumStoredSelLocs = Record.readInt(); |
| E->SelLocsKind = Record.readInt(); |
| E->setDelegateInitCall(Record.readInt()); |
| E->IsImplicit = Record.readInt(); |
| auto Kind = static_cast<ObjCMessageExpr::ReceiverKind>(Record.readInt()); |
| switch (Kind) { |
| case ObjCMessageExpr::Instance: |
| E->setInstanceReceiver(Record.readSubExpr()); |
| break; |
| |
| case ObjCMessageExpr::Class: |
| E->setClassReceiver(readTypeSourceInfo()); |
| break; |
| |
| case ObjCMessageExpr::SuperClass: |
| case ObjCMessageExpr::SuperInstance: { |
| QualType T = Record.readType(); |
| SourceLocation SuperLoc = readSourceLocation(); |
| E->setSuper(SuperLoc, T, Kind == ObjCMessageExpr::SuperInstance); |
| break; |
| } |
| } |
| |
| assert(Kind == E->getReceiverKind()); |
| |
| if (Record.readInt()) |
| E->setMethodDecl(readDeclAs<ObjCMethodDecl>()); |
| else |
| E->setSelector(Record.readSelector()); |
| |
| E->LBracLoc = readSourceLocation(); |
| E->RBracLoc = readSourceLocation(); |
| |
| for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) |
| E->setArg(I, Record.readSubExpr()); |
| |
| SourceLocation *Locs = E->getStoredSelLocs(); |
| for (unsigned I = 0; I != NumStoredSelLocs; ++I) |
| Locs[I] = readSourceLocation(); |
| } |
| |
| void ASTStmtReader::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) { |
| VisitStmt(S); |
| S->setElement(Record.readSubStmt()); |
| S->setCollection(Record.readSubExpr()); |
| S->setBody(Record.readSubStmt()); |
| S->setForLoc(readSourceLocation()); |
| S->setRParenLoc(readSourceLocation()); |
| } |
| |
| void ASTStmtReader::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) { |
| VisitStmt(S); |
| S->setCatchBody(Record.readSubStmt()); |
| S->setCatchParamDecl(readDeclAs<VarDecl>()); |
| S->setAtCatchLoc(readSourceLocation()); |
| S->setRParenLoc(readSourceLocation()); |
| } |
| |
| void ASTStmtReader::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) { |
| VisitStmt(S); |
| S->setFinallyBody(Record.readSubStmt()); |
| S->setAtFinallyLoc(readSourceLocation()); |
| } |
| |
| void ASTStmtReader::VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S) { |
| VisitStmt(S); // FIXME: no test coverage. |
| S->setSubStmt(Record.readSubStmt()); |
| S->setAtLoc(readSourceLocation()); |
| } |
| |
| void ASTStmtReader::VisitObjCAtTryStmt(ObjCAtTryStmt *S) { |
| VisitStmt(S); |
| assert(Record.peekInt() == S->getNumCatchStmts()); |
| Record.skipInts(1); |
| bool HasFinally = Record.readInt(); |
| S->setTryBody(Record.readSubStmt()); |
| for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I) |
| S->setCatchStmt(I, cast_or_null<ObjCAtCatchStmt>(Record.readSubStmt())); |
| |
| if (HasFinally) |
| S->setFinallyStmt(Record.readSubStmt()); |
| S->setAtTryLoc(readSourceLocation()); |
| } |
| |
| void ASTStmtReader::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) { |
| VisitStmt(S); // FIXME: no test coverage. |
| S->setSynchExpr(Record.readSubStmt()); |
| S->setSynchBody(Record.readSubStmt()); |
| S->setAtSynchronizedLoc(readSourceLocation()); |
| } |
| |
| void ASTStmtReader::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) { |
| VisitStmt(S); // FIXME: no test coverage. |
| S->setThrowExpr(Record.readSubStmt()); |
| S->setThrowLoc(readSourceLocation()); |
| } |
| |
| void ASTStmtReader::VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) { |
| VisitExpr(E); |
| E->setValue(Record.readInt()); |
| E->setLocation(readSourceLocation()); |
| } |
| |
| void ASTStmtReader::VisitObjCAvailabilityCheckExpr(ObjCAvailabilityCheckExpr *E) { |
| VisitExpr(E); |
| SourceRange R = Record.readSourceRange(); |
| E->AtLoc = R.getBegin(); |
| E->RParen = R.getEnd(); |
| E->VersionToCheck = Record.readVersionTuple(); |
| } |
| |
| //===----------------------------------------------------------------------===// |
| // C++ Expressions and Statements |
| //===----------------------------------------------------------------------===// |
| |
| void ASTStmtReader::VisitCXXCatchStmt(CXXCatchStmt *S) { |
| VisitStmt(S); |
| S->CatchLoc = readSourceLocation(); |
| S->ExceptionDecl = readDeclAs<VarDecl>(); |
| S->HandlerBlock = Record.readSubStmt(); |
| } |
| |
| void ASTStmtReader::VisitCXXTryStmt(CXXTryStmt *S) { |
| VisitStmt(S); |
| assert(Record.peekInt() == S->getNumHandlers() && "NumStmtFields is wrong ?"); |
| Record.skipInts(1); |
| S->TryLoc = readSourceLocation(); |
| S->getStmts()[0] = Record.readSubStmt(); |
| for (unsigned i = 0, e = S->getNumHandlers(); i != e; ++i) |
| S->getStmts()[i + 1] = Record.readSubStmt(); |
| } |
| |
| void ASTStmtReader::VisitCXXForRangeStmt(CXXForRangeStmt *S) { |
| VisitStmt(S); |
| S->ForLoc = readSourceLocation(); |
| S->CoawaitLoc = readSourceLocation(); |
| S->ColonLoc = readSourceLocation(); |
| S->RParenLoc = readSourceLocation(); |
| S->setInit(Record.readSubStmt()); |
| S->setRangeStmt(Record.readSubStmt()); |
| S->setBeginStmt(Record.readSubStmt()); |
| S->setEndStmt(Record.readSubStmt()); |
| S->setCond(Record.readSubExpr()); |
| S->setInc(Record.readSubExpr()); |
| S->setLoopVarStmt(Record.readSubStmt()); |
| S->setBody(Record.readSubStmt()); |
| } |
| |
| void ASTStmtReader::VisitMSDependentExistsStmt(MSDependentExistsStmt *S) { |
| VisitStmt(S); |
| S->KeywordLoc = readSourceLocation(); |
| S->IsIfExists = Record.readInt(); |
| S->QualifierLoc = Record.readNestedNameSpecifierLoc(); |
| S->NameInfo = Record.readDeclarationNameInfo(); |
| S->SubStmt = Record.readSubStmt(); |
| } |
| |
| void ASTStmtReader::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) { |
| VisitCallExpr(E); |
| E->CXXOperatorCallExprBits.OperatorKind = Record.readInt(); |
| E->Range = Record.readSourceRange(); |
| } |
| |
| void ASTStmtReader::VisitCXXRewrittenBinaryOperator( |
| CXXRewrittenBinaryOperator *E) { |
| VisitExpr(E); |
| E->CXXRewrittenBinaryOperatorBits.IsReversed = Record.readInt(); |
| E->SemanticForm = Record.readSubExpr(); |
| } |
| |
| void ASTStmtReader::VisitCXXConstructExpr(CXXConstructExpr *E) { |
| VisitExpr(E); |
| |
| unsigned NumArgs = Record.readInt(); |
| assert((NumArgs == E->getNumArgs()) && "Wrong NumArgs!"); |
| |
| E->CXXConstructExprBits.Elidable = Record.readInt(); |
| E->CXXConstructExprBits.HadMultipleCandidates = Record.readInt(); |
| E->CXXConstructExprBits.ListInitialization = Record.readInt(); |
| E->CXXConstructExprBits.StdInitListInitialization = Record.readInt(); |
| E->CXXConstructExprBits.ZeroInitialization = Record.readInt(); |
| E->CXXConstructExprBits.ConstructionKind = Record.readInt(); |
| E->CXXConstructExprBits.Loc = readSourceLocation(); |
| E->Constructor = readDeclAs<CXXConstructorDecl>(); |
| E->ParenOrBraceRange = readSourceRange(); |
| |
| for (unsigned I = 0; I != NumArgs; ++I) |
| E->setArg(I, Record.readSubExpr()); |
| } |
| |
| void ASTStmtReader::VisitCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr *E) { |
| VisitExpr(E); |
| E->Constructor = readDeclAs<CXXConstructorDecl>(); |
| E->Loc = readSourceLocation(); |
| E->ConstructsVirtualBase = Record.readInt(); |
| E->InheritedFromVirtualBase = Record.readInt(); |
| } |
| |
| void ASTStmtReader::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) { |
| VisitCXXConstructExpr(E); |
| E->TSI = readTypeSourceInfo(); |
| } |
| |
| void ASTStmtReader::VisitLambdaExpr(LambdaExpr *E) { |
| VisitExpr(E); |
| unsigned NumCaptures = Record.readInt(); |
| (void)NumCaptures; |
| assert(NumCaptures == E->LambdaExprBits.NumCaptures); |
| E->IntroducerRange = readSourceRange(); |
| E->LambdaExprBits.CaptureDefault = Record.readInt(); |
| E->CaptureDefaultLoc = readSourceLocation(); |
| E->LambdaExprBits.ExplicitParams = Record.readInt(); |
| E->LambdaExprBits.ExplicitResultType = Record.readInt(); |
| E->ClosingBrace = readSourceLocation(); |
| |
| // Read capture initializers. |
| for (LambdaExpr::capture_init_iterator C = E->capture_init_begin(), |
| CEnd = E->capture_init_end(); |
| C != CEnd; ++C) |
| *C = Record.readSubExpr(); |
| |
| // The body will be lazily deserialized when needed from the call operator |
| // declaration. |
| } |
| |
| void |
| ASTStmtReader::VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) { |
| VisitExpr(E); |
| E->SubExpr = Record.readSubExpr(); |
| } |
| |
| void ASTStmtReader::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) { |
| VisitExplicitCastExpr(E); |
| SourceRange R = readSourceRange(); |
| E->Loc = R.getBegin(); |
| E->RParenLoc = R.getEnd(); |
| R = readSourceRange(); |
| E->AngleBrackets = R; |
| } |
| |
| void ASTStmtReader::VisitCXXStaticCastExpr(CXXStaticCastExpr *E) { |
| return VisitCXXNamedCastExpr(E); |
| } |
| |
| void ASTStmtReader::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E) { |
| return VisitCXXNamedCastExpr(E); |
| } |
| |
| void ASTStmtReader::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E) { |
| return VisitCXXNamedCastExpr(E); |
| } |
| |
| void ASTStmtReader::VisitCXXAddrspaceCastExpr(CXXAddrspaceCastExpr *E) { |
| return VisitCXXNamedCastExpr(E); |
| } |
| |
| void ASTStmtReader::VisitCXXConstCastExpr(CXXConstCastExpr *E) { |
| return VisitCXXNamedCastExpr(E); |
| } |
| |
| void ASTStmtReader::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) { |
| VisitExplicitCastExpr(E); |
| E->setLParenLoc(readSourceLocation()); |
| E->setRParenLoc(readSourceLocation()); |
| } |
| |
| void ASTStmtReader::VisitBuiltinBitCastExpr(BuiltinBitCastExpr *E) { |
| VisitExplicitCastExpr(E); |
| E->KWLoc = readSourceLocation(); |
| E->RParenLoc = readSourceLocation(); |
| } |
| |
| void ASTStmtReader::VisitUserDefinedLiteral(UserDefinedLiteral *E) { |
| VisitCallExpr(E); |
| E->UDSuffixLoc = readSourceLocation(); |
| } |
| |
| void ASTStmtReader::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) { |
| VisitExpr(E); |
| E->setValue(Record.readInt()); |
| E->setLocation(readSourceLocation()); |
| } |
| |
| void ASTStmtReader::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) { |
| VisitExpr(E); |
| E->setLocation(readSourceLocation()); |
| } |
| |
| void ASTStmtReader::VisitCXXTypeidExpr(CXXTypeidExpr *E) { |
| VisitExpr(E); |
| E->setSourceRange(readSourceRange()); |
| if (E->isTypeOperand()) |
| E->Operand = readTypeSourceInfo(); |
| else |
| E->Operand = Record.readSubExpr(); |
| } |
| |
| void ASTStmtReader::VisitCXXThisExpr(CXXThisExpr *E) { |
| VisitExpr(E); |
| E->setLocation(readSourceLocation()); |
| E->setImplicit(Record.readInt()); |
| } |
| |
| void ASTStmtReader::VisitCXXThrowExpr(CXXThrowExpr *E) { |
| VisitExpr(E); |
| E->CXXThrowExprBits.ThrowLoc = readSourceLocation(); |
| E->Operand = Record.readSubExpr(); |
| E->CXXThrowExprBits.IsThrownVariableInScope = Record.readInt(); |
| } |
| |
| void ASTStmtReader::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) { |
| VisitExpr(E); |
| E->Param = readDeclAs<ParmVarDecl>(); |
| E->UsedContext = readDeclAs<DeclContext>(); |
| E->CXXDefaultArgExprBits.Loc = readSourceLocation(); |
| } |
| |
| void ASTStmtReader::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) { |
| VisitExpr(E); |
| E->Field = readDeclAs<FieldDecl>(); |
| E->UsedContext = readDeclAs<DeclContext>(); |
| E->CXXDefaultInitExprBits.Loc = readSourceLocation(); |
| } |
| |
| void ASTStmtReader::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) { |
| VisitExpr(E); |
| E->setTemporary(Record.readCXXTemporary()); |
| E->setSubExpr(Record.readSubExpr()); |
| } |
| |
| void ASTStmtReader::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) { |
| VisitExpr(E); |
| E->TypeInfo = readTypeSourceInfo(); |
| E->CXXScalarValueInitExprBits.RParenLoc = readSourceLocation(); |
| } |
| |
| void ASTStmtReader::VisitCXXNewExpr(CXXNewExpr *E) { |
| VisitExpr(E); |
| |
| bool IsArray = Record.readInt(); |
| bool HasInit = Record.readInt(); |
| unsigned NumPlacementArgs = Record.readInt(); |
| bool IsParenTypeId = Record.readInt(); |
| |
| E->CXXNewExprBits.IsGlobalNew = Record.readInt(); |
| E->CXXNewExprBits.ShouldPassAlignment = Record.readInt(); |
| E->CXXNewExprBits.UsualArrayDeleteWantsSize = Record.readInt(); |
| E->CXXNewExprBits.StoredInitializationStyle = Record.readInt(); |
| |
| assert((IsArray == E->isArray()) && "Wrong IsArray!"); |
| assert((HasInit == E->hasInitializer()) && "Wrong HasInit!"); |
| assert((NumPlacementArgs == E->getNumPlacementArgs()) && |
| "Wrong NumPlacementArgs!"); |
| assert((IsParenTypeId == E->isParenTypeId()) && "Wrong IsParenTypeId!"); |
| (void)IsArray; |
| (void)HasInit; |
| (void)NumPlacementArgs; |
| |
| E->setOperatorNew(readDeclAs<FunctionDecl>()); |
| E->setOperatorDelete(readDeclAs<FunctionDecl>()); |
| E->AllocatedTypeInfo = readTypeSourceInfo(); |
| if (IsParenTypeId) |
| E->getTrailingObjects<SourceRange>()[0] = readSourceRange(); |
| E->Range = readSourceRange(); |
| E->DirectInitRange = readSourceRange(); |
| |
| // Install all the subexpressions. |
| for (CXXNewExpr::raw_arg_iterator I = E->raw_arg_begin(), |
| N = E->raw_arg_end(); |
| I != N; ++I) |
| *I = Record.readSubStmt(); |
| } |
| |
| void ASTStmtReader::VisitCXXDeleteExpr(CXXDeleteExpr *E) { |
| VisitExpr(E); |
| E->CXXDeleteExprBits.GlobalDelete = Record.readInt(); |
| E->CXXDeleteExprBits.ArrayForm = Record.readInt(); |
| E->CXXDeleteExprBits.ArrayFormAsWritten = Record.readInt(); |
| E->CXXDeleteExprBits.UsualArrayDeleteWantsSize = Record.readInt(); |
| E->OperatorDelete = readDeclAs<FunctionDecl>(); |
| E->Argument = Record.readSubExpr(); |
| E->CXXDeleteExprBits.Loc = readSourceLocation(); |
| } |
| |
| void ASTStmtReader::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) { |
| VisitExpr(E); |
| |
| E->Base = Record.readSubExpr(); |
| E->IsArrow = Record.readInt(); |
| E->OperatorLoc = readSourceLocation(); |
| E->QualifierLoc = Record.readNestedNameSpecifierLoc(); |
| E->ScopeType = readTypeSourceInfo(); |
| E->ColonColonLoc = readSourceLocation(); |
| E->TildeLoc = readSourceLocation(); |
| |
| IdentifierInfo *II = Record.readIdentifier(); |
| if (II) |
| E->setDestroyedType(II, readSourceLocation()); |
| else |
| E->setDestroyedType(readTypeSourceInfo()); |
| } |
| |
| void ASTStmtReader::VisitExprWithCleanups(ExprWithCleanups *E) { |
| VisitExpr(E); |
| |
| unsigned NumObjects = Record.readInt(); |
| assert(NumObjects == E->getNumObjects()); |
| for (unsigned i = 0; i != NumObjects; ++i) { |
| unsigned CleanupKind = Record.readInt(); |
| ExprWithCleanups::CleanupObject Obj; |
| if (CleanupKind == COK_Block) |
| Obj = readDeclAs<BlockDecl>(); |
| else if (CleanupKind == COK_CompoundLiteral) |
| Obj = cast<CompoundLiteralExpr>(Record.readSubExpr()); |
| else |
| llvm_unreachable("unexpected cleanup object type"); |
| E->getTrailingObjects<ExprWithCleanups::CleanupObject>()[i] = Obj; |
| } |
| |
| E->ExprWithCleanupsBits.CleanupsHaveSideEffects = Record.readInt(); |
| E->SubExpr = Record.readSubExpr(); |
| } |
| |
| void ASTStmtReader::VisitCXXDependentScopeMemberExpr( |
| CXXDependentScopeMemberExpr *E) { |
| VisitExpr(E); |
| |
| bool HasTemplateKWAndArgsInfo = Record.readInt(); |
| unsigned NumTemplateArgs = Record.readInt(); |
| bool HasFirstQualifierFoundInScope = Record.readInt(); |
| |
| assert((HasTemplateKWAndArgsInfo == E->hasTemplateKWAndArgsInfo()) && |
| "Wrong HasTemplateKWAndArgsInfo!"); |
| assert( |
| (HasFirstQualifierFoundInScope == E->hasFirstQualifierFoundInScope()) && |
| "Wrong HasFirstQualifierFoundInScope!"); |
| |
| if (HasTemplateKWAndArgsInfo) |
| ReadTemplateKWAndArgsInfo( |
| *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(), |
| E->getTrailingObjects<TemplateArgumentLoc>(), NumTemplateArgs); |
| |
| assert((NumTemplateArgs == E->getNumTemplateArgs()) && |
| "Wrong NumTemplateArgs!"); |
| |
| E->CXXDependentScopeMemberExprBits.IsArrow = Record.readInt(); |
| E->CXXDependentScopeMemberExprBits.OperatorLoc = readSourceLocation(); |
| E->BaseType = Record.readType(); |
| E->QualifierLoc = Record.readNestedNameSpecifierLoc(); |
| E->Base = Record.readSubExpr(); |
| |
| if (HasFirstQualifierFoundInScope) |
| *E->getTrailingObjects<NamedDecl *>() = readDeclAs<NamedDecl>(); |
| |
| E->MemberNameInfo = Record.readDeclarationNameInfo(); |
| } |
| |
| void |
| ASTStmtReader::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) { |
| VisitExpr(E); |
| |
| if (Record.readInt()) // HasTemplateKWAndArgsInfo |
| ReadTemplateKWAndArgsInfo( |
| *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(), |
| E->getTrailingObjects<TemplateArgumentLoc>(), |
| /*NumTemplateArgs=*/Record.readInt()); |
| |
| E->QualifierLoc = Record.readNestedNameSpecifierLoc(); |
| E->NameInfo = Record.readDeclarationNameInfo(); |
| } |
| |
| void |
| ASTStmtReader::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) { |
| VisitExpr(E); |
| assert(Record.peekInt() == E->getNumArgs() && |
| "Read wrong record during creation ?"); |
| Record.skipInts(1); |
| for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) |
| E->setArg(I, Record.readSubExpr()); |
| E->TSI = readTypeSourceInfo(); |
| E->setLParenLoc(readSourceLocation()); |
| E->setRParenLoc(readSourceLocation()); |
| } |
| |
| void ASTStmtReader::VisitOverloadExpr(OverloadExpr *E) { |
| VisitExpr(E); |
| |
| unsigned NumResults = Record.readInt(); |
| bool HasTemplateKWAndArgsInfo = Record.readInt(); |
| assert((E->getNumDecls() == NumResults) && "Wrong NumResults!"); |
| assert((E->hasTemplateKWAndArgsInfo() == HasTemplateKWAndArgsInfo) && |
| "Wrong HasTemplateKWAndArgsInfo!"); |
| |
| if (HasTemplateKWAndArgsInfo) { |
| unsigned NumTemplateArgs = Record.readInt(); |
| ReadTemplateKWAndArgsInfo(*E->getTrailingASTTemplateKWAndArgsInfo(), |
| E->getTrailingTemplateArgumentLoc(), |
| NumTemplateArgs); |
| assert((E->getNumTemplateArgs() == NumTemplateArgs) && |
| "Wrong NumTemplateArgs!"); |
| } |
| |
| UnresolvedSet<8> Decls; |
| for (unsigned I = 0; I != NumResults; ++I) { |
| auto *D = readDeclAs<NamedDecl>(); |
| auto AS = (AccessSpecifier)Record.readInt(); |
| Decls.addDecl(D, AS); |
| } |
| |
| DeclAccessPair *Results = E->getTrailingResults(); |
| UnresolvedSetIterator Iter = Decls.begin(); |
| for (unsigned I = 0; I != NumResults; ++I) { |
| Results[I] = (Iter + I).getPair(); |
| } |
| |
| E->NameInfo = Record.readDeclarationNameInfo(); |
| E->QualifierLoc = Record.readNestedNameSpecifierLoc(); |
| } |
| |
| void ASTStmtReader::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) { |
| VisitOverloadExpr(E); |
| E->UnresolvedMemberExprBits.IsArrow = Record.readInt(); |
| E->UnresolvedMemberExprBits.HasUnresolvedUsing = Record.readInt(); |
| E->Base = Record.readSubExpr(); |
| E->BaseType = Record.readType(); |
| E->OperatorLoc = readSourceLocation(); |
| } |
| |
| void ASTStmtReader::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) { |
| VisitOverloadExpr(E); |
| E->UnresolvedLookupExprBits.RequiresADL = Record.readInt(); |
| E->UnresolvedLookupExprBits.Overloaded = Record.readInt(); |
| E->NamingClass = readDeclAs<CXXRecordDecl>(); |
| } |
| |
| void ASTStmtReader::VisitTypeTraitExpr(TypeTraitExpr *E) { |
| VisitExpr(E); |
| E->TypeTraitExprBits.NumArgs = Record.readInt(); |
| E->TypeTraitExprBits.Kind = Record.readInt(); |
| E->TypeTraitExprBits.Value = Record.readInt(); |
| SourceRange Range = readSourceRange(); |
| E->Loc = Range.getBegin(); |
| E->RParenLoc = Range.getEnd(); |
| |
| auto **Args = E->getTrailingObjects<TypeSourceInfo *>(); |
| for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) |
| Args[I] = readTypeSourceInfo(); |
| } |
| |
| void ASTStmtReader::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) { |
| VisitExpr(E); |
| E->ATT = (ArrayTypeTrait)Record.readInt(); |
| E->Value = (unsigned int)Record.readInt(); |
| SourceRange Range = readSourceRange(); |
| E->Loc = Range.getBegin(); |
| E->RParen = Range.getEnd(); |
| E->QueriedType = readTypeSourceInfo(); |
| E->Dimension = Record.readSubExpr(); |
| } |
| |
| void ASTStmtReader::VisitExpressionTraitExpr(ExpressionTraitExpr *E) { |
| VisitExpr(E); |
| E->ET = (ExpressionTrait)Record.readInt(); |
| E->Value = (bool)Record.readInt(); |
| SourceRange Range = readSourceRange(); |
| E->QueriedExpression = Record.readSubExpr(); |
| E->Loc = Range.getBegin(); |
| E->RParen = Range.getEnd(); |
| } |
| |
| void ASTStmtReader::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) { |
| VisitExpr(E); |
| E->CXXNoexceptExprBits.Value = Record.readInt(); |
| E->Range = readSourceRange(); |
| E->Operand = Record.readSubExpr(); |
| } |
| |
| void ASTStmtReader::VisitPackExpansionExpr(PackExpansionExpr *E) { |
| VisitExpr(E); |
| E->EllipsisLoc = readSourceLocation(); |
| E->NumExpansions = Record.readInt(); |
| E->Pattern = Record.readSubExpr(); |
| } |
| |
| void ASTStmtReader::VisitSizeOfPackExpr(SizeOfPackExpr *E) { |
| VisitExpr(E); |
| unsigned NumPartialArgs = Record.readInt(); |
| E->OperatorLoc = readSourceLocation(); |
| E->PackLoc = readSourceLocation(); |
| E->RParenLoc = readSourceLocation(); |
| E->Pack = Record.readDeclAs<NamedDecl>(); |
| if (E->isPartiallySubstituted()) { |
| assert(E->Length == NumPartialArgs); |
| for (auto *I = E->getTrailingObjects<TemplateArgument>(), |
| *E = I + NumPartialArgs; |
| I != E; ++I) |
| new (I) TemplateArgument(Record.readTemplateArgument()); |
| } else if (!E->isValueDependent()) { |
| E->Length = Record.readInt(); |
| } |
| } |
| |
| void ASTStmtReader::VisitSubstNonTypeTemplateParmExpr( |
| SubstNonTypeTemplateParmExpr *E) { |
| VisitExpr(E); |
| E->ParamAndRef.setPointer(readDeclAs<NonTypeTemplateParmDecl>()); |
| E->ParamAndRef.setInt(Record.readInt()); |
| E->SubstNonTypeTemplateParmExprBits.NameLoc = readSourceLocation(); |
| E->Replacement = Record.readSubExpr(); |
| } |
| |
| void ASTStmtReader::VisitSubstNonTypeTemplateParmPackExpr( |
| SubstNonTypeTemplateParmPackExpr *E) { |
| VisitExpr(E); |
| E->Param = readDeclAs<NonTypeTemplateParmDecl>(); |
| TemplateArgument ArgPack = Record.readTemplateArgument(); |
| if (ArgPack.getKind() != TemplateArgument::Pack) |
| return; |
| |
| E->Arguments = ArgPack.pack_begin(); |
| E->NumArguments = ArgPack.pack_size(); |
| E->NameLoc = readSourceLocation(); |
| } |
| |
| void ASTStmtReader::VisitFunctionParmPackExpr(FunctionParmPackExpr *E) { |
| VisitExpr(E); |
| E->NumParameters = Record.readInt(); |
| E->ParamPack = readDeclAs<ParmVarDecl>(); |
| E->NameLoc = readSourceLocation(); |
| auto **Parms = E->getTrailingObjects<VarDecl *>(); |
| for (unsigned i = 0, n = E->NumParameters; i != n; ++i) |
| Parms[i] = readDeclAs<VarDecl>(); |
| } |
| |
| void ASTStmtReader::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) { |
| VisitExpr(E); |
| bool HasMaterialzedDecl = Record.readInt(); |
| if (HasMaterialzedDecl) |
| E->State = cast<LifetimeExtendedTemporaryDecl>(Record.readDecl()); |
| else |
| E->State = Record.readSubExpr(); |
| } |
| |
| void ASTStmtReader::VisitCXXFoldExpr(CXXFoldExpr *E) { |
| VisitExpr(E); |
| E->LParenLoc = readSourceLocation(); |
| E->EllipsisLoc = readSourceLocation(); |
| E->RParenLoc = readSourceLocation(); |
| E->NumExpansions = Record.readInt(); |
| E->SubExprs[0] = Record.readSubExpr(); |
| E->SubExprs[1] = Record.readSubExpr(); |
| E->SubExprs[2] = Record.readSubExpr(); |
| E->Opcode = (BinaryOperatorKind)Record.readInt(); |
| } |
| |
| void ASTStmtReader::VisitOpaqueValueExpr(OpaqueValueExpr *E) { |
| VisitExpr(E); |
| E->SourceExpr = Record.readSubExpr(); |
| E->OpaqueValueExprBits.Loc = readSourceLocation(); |
| E->setIsUnique(Record.readInt()); |
| } |
| |
| void ASTStmtReader::VisitTypoExpr(TypoExpr *E) { |
| llvm_unreachable("Cannot read TypoExpr nodes"); |
| } |
| |
| void ASTStmtReader::VisitRecoveryExpr(RecoveryExpr *E) { |
| VisitExpr(E); |
| unsigned NumArgs = Record.readInt(); |
| E->BeginLoc = readSourceLocation(); |
| E->EndLoc = readSourceLocation(); |
| assert((NumArgs + 0LL == |
| std::distance(E->children().begin(), E->children().end())) && |
| "Wrong NumArgs!"); |
| (void)NumArgs; |
| for (Stmt *&Child : E->children()) |
| Child = Record.readSubStmt(); |
| } |
| |
| //===----------------------------------------------------------------------===// |
| // Microsoft Expressions and Statements |
| //===----------------------------------------------------------------------===// |
| void ASTStmtReader::VisitMSPropertyRefExpr(MSPropertyRefExpr *E) { |
| VisitExpr(E); |
| E->IsArrow = (Record.readInt() != 0); |
| E->BaseExpr = Record.readSubExpr(); |
| E->QualifierLoc = Record.readNestedNameSpecifierLoc(); |
| E->MemberLoc = readSourceLocation(); |
| E->TheDecl = readDeclAs<MSPropertyDecl>(); |
| } |
| |
| void ASTStmtReader::VisitMSPropertySubscriptExpr(MSPropertySubscriptExpr *E) { |
| VisitExpr(E); |
| E->setBase(Record.readSubExpr()); |
| E->setIdx(Record.readSubExpr()); |
| E->setRBracketLoc(readSourceLocation()); |
| } |
| |
| void ASTStmtReader::VisitCXXUuidofExpr(CXXUuidofExpr *E) { |
| VisitExpr(E); |
| E->setSourceRange(readSourceRange()); |
| E->Guid = readDeclAs<MSGuidDecl>(); |
| if (E->isTypeOperand()) |
| E->Operand = readTypeSourceInfo(); |
| else |
| E->Operand = Record.readSubExpr(); |
| } |
| |
| void ASTStmtReader::VisitSEHLeaveStmt(SEHLeaveStmt *S) { |
| VisitStmt(S); |
| S->setLeaveLoc(readSourceLocation()); |
| } |
| |
| void ASTStmtReader::VisitSEHExceptStmt(SEHExceptStmt *S) { |
| VisitStmt(S); |
| S->Loc = readSourceLocation(); |
| S->Children[SEHExceptStmt::FILTER_EXPR] = Record.readSubStmt(); |
| S->Children[SEHExceptStmt::BLOCK] = Record.readSubStmt(); |
| } |
| |
| void ASTStmtReader::VisitSEHFinallyStmt(SEHFinallyStmt *S) { |
| VisitStmt(S); |
| S->Loc = readSourceLocation(); |
| S->Block = Record.readSubStmt(); |
| } |
| |
| void ASTStmtReader::VisitSEHTryStmt(SEHTryStmt *S) { |
| VisitStmt(S); |
| S->IsCXXTry = Record.readInt(); |
| S->TryLoc = readSourceLocation(); |
| S->Children[SEHTryStmt::TRY] = Record.readSubStmt(); |
| S->Children[SEHTryStmt::HANDLER] = Record.readSubStmt(); |
| } |
| |
| //===----------------------------------------------------------------------===// |
| // CUDA Expressions and Statements |
| //===----------------------------------------------------------------------===// |
| |
| void ASTStmtReader::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *E) { |
| VisitCallExpr(E); |
| E->setPreArg(CUDAKernelCallExpr::CONFIG, Record.readSubExpr()); |
| } |
| |
| //===----------------------------------------------------------------------===// |
| // OpenCL Expressions and Statements. |
| //===----------------------------------------------------------------------===// |
| void ASTStmtReader::VisitAsTypeExpr(AsTypeExpr *E) { |
| VisitExpr(E); |
| E->BuiltinLoc = readSourceLocation(); |
| E->RParenLoc = readSourceLocation(); |
| E->SrcExpr = Record.readSubExpr(); |
| } |
| |
| //===----------------------------------------------------------------------===// |
| // OpenMP Directives. |
| //===----------------------------------------------------------------------===// |
| |
| void ASTStmtReader::VisitOMPCanonicalLoop(OMPCanonicalLoop *S) { |
| VisitStmt(S); |
| for (Stmt *&SubStmt : S->SubStmts) |
| SubStmt = Record.readSubStmt(); |
| } |
| |
| void ASTStmtReader::VisitOMPExecutableDirective(OMPExecutableDirective *E) { |
| Record.readOMPChildren(E->Data); |
| E->setLocStart(readSourceLocation()); |
| E->setLocEnd(readSourceLocation()); |
| } |
| |
| void ASTStmtReader::VisitOMPLoopBasedDirective(OMPLoopBasedDirective *D) { |
| VisitStmt(D); |
| // Field CollapsedNum was read in ReadStmtFromStream. |
| Record.skipInts(1); |
| VisitOMPExecutableDirective(D); |
| } |
| |
| void ASTStmtReader::VisitOMPLoopDirective(OMPLoopDirective *D) { |
| VisitOMPLoopBasedDirective(D); |
| } |
| |
| void ASTStmtReader::VisitOMPMetaDirective(OMPMetaDirective *D) { |
| VisitStmt(D); |
| // The NumClauses field was read in ReadStmtFromStream. |
| Record.skipInts(1); |
| VisitOMPExecutableDirective(D); |
| } |
| |
| void ASTStmtReader::VisitOMPParallelDirective(OMPParallelDirective *D) { |
| VisitStmt(D); |
| VisitOMPExecutableDirective(D); |
| D->setHasCancel(Record.readBool()); |
| } |
| |
| void ASTStmtReader::VisitOMPSimdDirective(OMPSimdDirective *D) { |
| VisitOMPLoopDirective(D); |
| } |
| |
| void ASTStmtReader::VisitOMPLoopTransformationDirective( |
| OMPLoopTransformationDirective *D) { |
| VisitOMPLoopBasedDirective(D); |
| D->setNumGeneratedLoops(Record.readUInt32()); |
| } |
| |
| void ASTStmtReader::VisitOMPTileDirective(OMPTileDirective *D) { |
| VisitOMPLoopTransformationDirective(D); |
| } |
| |
| void ASTStmtReader::VisitOMPUnrollDirective(OMPUnrollDirective *D) { |
| VisitOMPLoopTransformationDirective(D); |
| } |
| |
| void ASTStmtReader::VisitOMPForDirective(OMPForDirective *D) { |
| VisitOMPLoopDirective(D); |
| D->setHasCancel(Record.readBool()); |
| } |
| |
| void ASTStmtReader::VisitOMPForSimdDirective(OMPForSimdDirective *D) { |
| VisitOMPLoopDirective(D); |
| } |
| |
| void ASTStmtReader::VisitOMPSectionsDirective(OMPSectionsDirective *D) { |
| VisitStmt(D); |
| VisitOMPExecutableDirective(D); |
| D->setHasCancel(Record.readBool()); |
| } |
| |
| void ASTStmtReader::VisitOMPSectionDirective(OMPSectionDirective *D) { |
| VisitStmt(D); |
| VisitOMPExecutableDirective(D); |
| D->setHasCancel(Record.readBool()); |
| } |
| |
| void ASTStmtReader::VisitOMPSingleDirective(OMPSingleDirective *D) { |
| VisitStmt(D); |
| VisitOMPExecutableDirective(D); |
| } |
| |
| void ASTStmtReader::VisitOMPMasterDirective(OMPMasterDirective *D) { |
| VisitStmt(D); |
| VisitOMPExecutableDirective(D); |
| } |
| |
| void ASTStmtReader::VisitOMPCriticalDirective(OMPCriticalDirective *D) { |
| VisitStmt(D); |
| VisitOMPExecutableDirective(D); |
| D->DirName = Record.readDeclarationNameInfo(); |
| } |
| |
| void ASTStmtReader::VisitOMPParallelForDirective(OMPParallelForDirective *D) { |
| VisitOMPLoopDirective(D); |
| D->setHasCancel(Record.readBool()); |
| } |
| |
| void ASTStmtReader::VisitOMPParallelForSimdDirective( |
| OMPParallelForSimdDirective *D) { |
| VisitOMPLoopDirective(D); |
| } |
| |
| void ASTStmtReader::VisitOMPParallelMasterDirective( |
| OMPParallelMasterDirective *D) { |
| VisitStmt(D); |
| VisitOMPExecutableDirective(D); |
| } |
| |
| void ASTStmtReader::VisitOMPParallelSectionsDirective( |
| OMPParallelSectionsDirective *D) { |
| VisitStmt(D); |
| VisitOMPExecutableDirective(D); |
| D->setHasCancel(Record.readBool()); |
| } |
| |
| void ASTStmtReader::VisitOMPTaskDirective(OMPTaskDirective *D) { |
| VisitStmt(D); |
| VisitOMPExecutableDirective(D); |
| D->setHasCancel(Record.readBool()); |
| } |
| |
| void ASTStmtReader::VisitOMPTaskyieldDirective(OMPTaskyieldDirective *D) { |
| VisitStmt(D); |
| VisitOMPExecutableDirective(D); |
| } |
| |
| void ASTStmtReader::VisitOMPBarrierDirective(OMPBarrierDirective *D) { |
| VisitStmt(D); |
| VisitOMPExecutableDirective(D); |
| } |
| |
| void ASTStmtReader::VisitOMPTaskwaitDirective(OMPTaskwaitDirective *D) { |
| VisitStmt(D); |
| // The NumClauses field was read in ReadStmtFromStream. |
| Record.skipInts(1); |
| VisitOMPExecutableDirective(D); |
| } |
| |
| void ASTStmtReader::VisitOMPTaskgroupDirective(OMPTaskgroupDirective *D) { |
| VisitStmt(D); |
| VisitOMPExecutableDirective(D); |
| } |
| |
| void ASTStmtReader::VisitOMPFlushDirective(OMPFlushDirective *D) { |
| VisitStmt(D); |
| VisitOMPExecutableDirective(D); |
| } |
| |
| void ASTStmtReader::VisitOMPDepobjDirective(OMPDepobjDirective *D) { |
| VisitStmt(D); |
| VisitOMPExecutableDirective(D); |
| } |
| |
| void ASTStmtReader::VisitOMPScanDirective(OMPScanDirective *D) { |
| VisitStmt(D); |
| VisitOMPExecutableDirective(D); |
| } |
| |
| void ASTStmtReader::VisitOMPOrderedDirective(OMPOrderedDirective *D) { |
| VisitStmt(D); |
| VisitOMPExecutableDirective(D); |
| } |
| |
| void ASTStmtReader::VisitOMPAtomicDirective(OMPAtomicDirective *D) { |
| VisitStmt(D); |
| VisitOMPExecutableDirective(D); |
| D->IsXLHSInRHSPart = Record.readBool(); |
| D->IsPostfixUpdate = Record.readBool(); |
| } |
| |
| void ASTStmtReader::VisitOMPTargetDirective(OMPTargetDirective *D) { |
| VisitStmt(D); |
| VisitOMPExecutableDirective(D); |
| } |
| |
| void ASTStmtReader::VisitOMPTargetDataDirective(OMPTargetDataDirective *D) { |
| VisitStmt(D); |
| VisitOMPExecutableDirective(D); |
| } |
| |
| void ASTStmtReader::VisitOMPTargetEnterDataDirective( |
| OMPTargetEnterDataDirective *D) { |
| VisitStmt(D); |
| VisitOMPExecutableDirective(D); |
| } |
| |
| void ASTStmtReader::VisitOMPTargetExitDataDirective( |
| OMPTargetExitDataDirective *D) { |
| VisitStmt(D); |
| VisitOMPExecutableDirective(D); |
| } |
| |
| void ASTStmtReader::VisitOMPTargetParallelDirective( |
| OMPTargetParallelDirective *D) { |
| VisitStmt(D); |
| VisitOMPExecutableDirective(D); |
| D->setHasCancel(Record.readBool()); |
| } |
| |
| void ASTStmtReader::VisitOMPTargetParallelForDirective( |
| OMPTargetParallelForDirective *D) { |
| VisitOMPLoopDirective(D); |
| D->setHasCancel(Record.readBool()); |
| } |
| |
| void ASTStmtReader::VisitOMPTeamsDirective(OMPTeamsDirective *D) { |
| VisitStmt(D); |
| VisitOMPExecutableDirective(D); |
| } |
| |
| void ASTStmtReader::VisitOMPCancellationPointDirective( |
| OMPCancellationPointDirective *D) { |
| VisitStmt(D); |
| VisitOMPExecutableDirective(D); |
| D->setCancelRegion(Record.readEnum<OpenMPDirectiveKind>()); |
| } |
| |
| void ASTStmtReader::VisitOMPCancelDirective(OMPCancelDirective *D) { |
| VisitStmt(D); |
| VisitOMPExecutableDirective(D); |
| D->setCancelRegion(Record.readEnum<OpenMPDirectiveKind>()); |
| } |
| |
| void ASTStmtReader::VisitOMPTaskLoopDirective(OMPTaskLoopDirective *D) { |
| VisitOMPLoopDirective(D); |
| D->setHasCancel(Record.readBool()); |
| } |
| |
| void ASTStmtReader::VisitOMPTaskLoopSimdDirective(OMPTaskLoopSimdDirective *D) { |
| VisitOMPLoopDirective(D); |
| } |
| |
| void ASTStmtReader::VisitOMPMasterTaskLoopDirective( |
| OMPMasterTaskLoopDirective *D) { |
| VisitOMPLoopDirective(D); |
| D->setHasCancel(Record.readBool()); |
| } |
| |
| void ASTStmtReader::VisitOMPMasterTaskLoopSimdDirective( |
| OMPMasterTaskLoopSimdDirective *D) { |
| VisitOMPLoopDirective(D); |
| } |
| |
| void ASTStmtReader::VisitOMPParallelMasterTaskLoopDirective( |
| OMPParallelMasterTaskLoopDirective *D) { |
| VisitOMPLoopDirective(D); |
| D->setHasCancel(Record.readBool()); |
| } |
| |
| void ASTStmtReader::VisitOMPParallelMasterTaskLoopSimdDirective( |
| OMPParallelMasterTaskLoopSimdDirective *D) { |
| VisitOMPLoopDirective(D); |
| } |
| |
| void ASTStmtReader::VisitOMPDistributeDirective(OMPDistributeDirective *D) { |
| VisitOMPLoopDirective(D); |
| } |
| |
| void ASTStmtReader::VisitOMPTargetUpdateDirective(OMPTargetUpdateDirective *D) { |
| VisitStmt(D); |
| VisitOMPExecutableDirective(D); |
| } |
| |
| void ASTStmtReader::VisitOMPDistributeParallelForDirective( |
| OMPDistributeParallelForDirective *D) { |
| VisitOMPLoopDirective(D); |
| D->setHasCancel(Record.readBool()); |
| } |
| |
| void ASTStmtReader::VisitOMPDistributeParallelForSimdDirective( |
| OMPDistributeParallelForSimdDirective *D) { |
| VisitOMPLoopDirective(D); |
| } |
| |
| void ASTStmtReader::VisitOMPDistributeSimdDirective( |
| OMPDistributeSimdDirective *D) { |
| VisitOMPLoopDirective(D); |
| } |
| |
| void ASTStmtReader::VisitOMPTargetParallelForSimdDirective( |
| OMPTargetParallelForSimdDirective *D) { |
| VisitOMPLoopDirective(D); |
| } |
| |
| void ASTStmtReader::VisitOMPTargetSimdDirective(OMPTargetSimdDirective *D) { |
| VisitOMPLoopDirective(D); |
| } |
| |
| void ASTStmtReader::VisitOMPTeamsDistributeDirective( |
| OMPTeamsDistributeDirective *D) { |
| VisitOMPLoopDirective(D); |
| } |
| |
| void ASTStmtReader::VisitOMPTeamsDistributeSimdDirective( |
| OMPTeamsDistributeSimdDirective *D) { |
| VisitOMPLoopDirective(D); |
| } |
| |
| void ASTStmtReader::VisitOMPTeamsDistributeParallelForSimdDirective( |
| OMPTeamsDistributeParallelForSimdDirective *D) { |
| VisitOMPLoopDirective(D); |
| } |
| |
| void ASTStmtReader::VisitOMPTeamsDistributeParallelForDirective( |
| OMPTeamsDistributeParallelForDirective *D) { |
| VisitOMPLoopDirective(D); |
| D->setHasCancel(Record.readBool()); |
| } |
| |
| void ASTStmtReader::VisitOMPTargetTeamsDirective(OMPTargetTeamsDirective *D) { |
| VisitStmt(D); |
| VisitOMPExecutableDirective(D); |
| } |
| |
| void ASTStmtReader::VisitOMPTargetTeamsDistributeDirective( |
| OMPTargetTeamsDistributeDirective *D) { |
| VisitOMPLoopDirective(D); |
| } |
| |
| void ASTStmtReader::VisitOMPTargetTeamsDistributeParallelForDirective( |
| OMPTargetTeamsDistributeParallelForDirective *D) { |
| VisitOMPLoopDirective(D); |
| D->setHasCancel(Record.readBool()); |
| } |
| |
| void ASTStmtReader::VisitOMPTargetTeamsDistributeParallelForSimdDirective( |
| OMPTargetTeamsDistributeParallelForSimdDirective *D) { |
| VisitOMPLoopDirective(D); |
| } |
| |
| void ASTStmtReader::VisitOMPTargetTeamsDistributeSimdDirective( |
| OMPTargetTeamsDistributeSimdDirective *D) { |
| VisitOMPLoopDirective(D); |
| } |
| |
| void ASTStmtReader::VisitOMPInteropDirective(OMPInteropDirective *D) { |
| VisitStmt(D); |
| VisitOMPExecutableDirective(D); |
| } |
| |
| void ASTStmtReader::VisitOMPDispatchDirective(OMPDispatchDirective *D) { |
| VisitStmt(D); |
| VisitOMPExecutableDirective(D); |
| D->setTargetCallLoc(Record.readSourceLocation()); |
| } |
| |
| void ASTStmtReader::VisitOMPMaskedDirective(OMPMaskedDirective *D) { |
| VisitStmt(D); |
| VisitOMPExecutableDirective(D); |
| } |
| |
| void ASTStmtReader::VisitOMPGenericLoopDirective(OMPGenericLoopDirective *D) { |
| VisitOMPLoopDirective(D); |
| } |
| |
| //===----------------------------------------------------------------------===// |
| // ASTReader Implementation |
| //===----------------------------------------------------------------------===// |
| |
| Stmt *ASTReader::ReadStmt(ModuleFile &F) { |
| switch (ReadingKind) { |
| case Read_None: |
| llvm_unreachable("should not call this when not reading anything"); |
| case Read_Decl: |
| case Read_Type: |
| return ReadStmtFromStream(F); |
| case Read_Stmt: |
| return ReadSubStmt(); |
| } |
| |
| llvm_unreachable("ReadingKind not set ?"); |
| } |
| |
| Expr *ASTReader::ReadExpr(ModuleFile &F) { |
| return cast_or_null<Expr>(ReadStmt(F)); |
| } |
| |
| Expr *ASTReader::ReadSubExpr() { |
| return cast_or_null<Expr>(ReadSubStmt()); |
| } |
| |
| // Within the bitstream, expressions are stored in Reverse Polish |
| // Notation, with each of the subexpressions preceding the |
| // expression they are stored in. Subexpressions are stored from last to first. |
| // To evaluate expressions, we continue reading expressions and placing them on |
| // the stack, with expressions having operands removing those operands from the |
| // stack. Evaluation terminates when we see a STMT_STOP record, and |
| // the single remaining expression on the stack is our result. |
| Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) { |
| ReadingKindTracker ReadingKind(Read_Stmt, *this); |
| llvm::BitstreamCursor &Cursor = F.DeclsCursor; |
| |
| // Map of offset to previously deserialized stmt. The offset points |
| // just after the stmt record. |
| llvm::DenseMap<uint64_t, Stmt *> StmtEntries; |
| |
| #ifndef NDEBUG |
| unsigned PrevNumStmts = StmtStack.size(); |
| #endif |
| |
| ASTRecordReader Record(*this, F); |
| ASTStmtReader Reader(Record, Cursor); |
| Stmt::EmptyShell Empty; |
| |
| while (true) { |
| llvm::Expected<llvm::BitstreamEntry> MaybeEntry = |
| Cursor.advanceSkippingSubblocks(); |
| if (!MaybeEntry) { |
| Error(toString(MaybeEntry.takeError())); |
| return nullptr; |
| } |
| llvm::BitstreamEntry Entry = MaybeEntry.get(); |
| |
| switch (Entry.Kind) { |
| case llvm::BitstreamEntry::SubBlock: // Handled for us already. |
| case llvm::BitstreamEntry::Error: |
| Error("malformed block record in AST file"); |
| return nullptr; |
| case llvm::BitstreamEntry::EndBlock: |
| goto Done; |
| case llvm::BitstreamEntry::Record: |
| // The interesting case. |
| break; |
| } |
| |
| ASTContext &Context = getContext(); |
| Stmt *S = nullptr; |
| bool Finished = false; |
| bool IsStmtReference = false; |
| Expected<unsigned> MaybeStmtCode = Record.readRecord(Cursor, Entry.ID); |
| if (!MaybeStmtCode) { |
|
|
