diff options
Diffstat (limited to 'contrib/llvm/tools/clang/lib/Serialization/ASTReaderStmt.cpp')
| -rw-r--r-- | contrib/llvm/tools/clang/lib/Serialization/ASTReaderStmt.cpp | 2222 |
1 files changed, 1200 insertions, 1022 deletions
diff --git a/contrib/llvm/tools/clang/lib/Serialization/ASTReaderStmt.cpp b/contrib/llvm/tools/clang/lib/Serialization/ASTReaderStmt.cpp index 395da42..686a69b 100644 --- a/contrib/llvm/tools/clang/lib/Serialization/ASTReaderStmt.cpp +++ b/contrib/llvm/tools/clang/lib/Serialization/ASTReaderStmt.cpp @@ -26,62 +26,47 @@ namespace clang { class ASTStmtReader : public StmtVisitor<ASTStmtReader> { friend class OMPClauseReader; - typedef ASTReader::RecordData RecordData; - - ASTReader &Reader; - ModuleFile &F; + + ASTRecordReader &Record; llvm::BitstreamCursor &DeclsCursor; - const ASTReader::RecordData &Record; - unsigned &Idx; - Token ReadToken(const RecordData &R, unsigned &I) { - return Reader.ReadToken(F, R, I); + SourceLocation ReadSourceLocation() { + return Record.readSourceLocation(); } - SourceLocation ReadSourceLocation(const RecordData &R, unsigned &I) { - return Reader.ReadSourceLocation(F, R, I); + SourceRange ReadSourceRange() { + return Record.readSourceRange(); } - SourceRange ReadSourceRange(const RecordData &R, unsigned &I) { - return Reader.ReadSourceRange(F, R, I); + std::string ReadString() { + return Record.readString(); } - std::string ReadString(const RecordData &R, unsigned &I) { - return Reader.ReadString(R, I); - } - - TypeSourceInfo *GetTypeSourceInfo(const RecordData &R, unsigned &I) { - return Reader.GetTypeSourceInfo(F, R, I); - } - - serialization::DeclID ReadDeclID(const RecordData &R, unsigned &I) { - return Reader.ReadDeclID(F, R, I); + TypeSourceInfo *GetTypeSourceInfo() { + return Record.getTypeSourceInfo(); } - - Decl *ReadDecl(const RecordData &R, unsigned &I) { - return Reader.ReadDecl(F, R, I); + + Decl *ReadDecl() { + return Record.readDecl(); } - + template<typename T> - T *ReadDeclAs(const RecordData &R, unsigned &I) { - return Reader.ReadDeclAs<T>(F, R, I); + T *ReadDeclAs() { + return Record.readDeclAs<T>(); } - void ReadDeclarationNameLoc(DeclarationNameLoc &DNLoc, DeclarationName Name, - const ASTReader::RecordData &R, unsigned &I) { - Reader.ReadDeclarationNameLoc(F, DNLoc, Name, R, I); + void ReadDeclarationNameLoc(DeclarationNameLoc &DNLoc, + DeclarationName Name) { + Record.readDeclarationNameLoc(DNLoc, Name); } - - void ReadDeclarationNameInfo(DeclarationNameInfo &NameInfo, - const ASTReader::RecordData &R, unsigned &I) { - Reader.ReadDeclarationNameInfo(F, NameInfo, R, I); + + void ReadDeclarationNameInfo(DeclarationNameInfo &NameInfo) { + Record.readDeclarationNameInfo(NameInfo); } public: - ASTStmtReader(ASTReader &Reader, ModuleFile &F, - llvm::BitstreamCursor &Cursor, - const ASTReader::RecordData &Record, unsigned &Idx) - : Reader(Reader), F(F), DeclsCursor(Cursor), Record(Record), Idx(Idx) { } + ASTStmtReader(ASTRecordReader &Record, llvm::BitstreamCursor &Cursor) + : Record(Record), DeclsCursor(Cursor) {} /// \brief The number of record fields required for the Stmt class /// itself. @@ -109,106 +94,103 @@ namespace clang { void ASTStmtReader::ReadTemplateKWAndArgsInfo(ASTTemplateKWAndArgsInfo &Args, TemplateArgumentLoc *ArgsLocArray, unsigned NumTemplateArgs) { - SourceLocation TemplateKWLoc = ReadSourceLocation(Record, Idx); + SourceLocation TemplateKWLoc = ReadSourceLocation(); TemplateArgumentListInfo ArgInfo; - ArgInfo.setLAngleLoc(ReadSourceLocation(Record, Idx)); - ArgInfo.setRAngleLoc(ReadSourceLocation(Record, Idx)); + ArgInfo.setLAngleLoc(ReadSourceLocation()); + ArgInfo.setRAngleLoc(ReadSourceLocation()); for (unsigned i = 0; i != NumTemplateArgs; ++i) - ArgInfo.addArgument( - Reader.ReadTemplateArgumentLoc(F, Record, Idx)); + ArgInfo.addArgument(Record.readTemplateArgumentLoc()); Args.initializeFrom(TemplateKWLoc, ArgInfo, ArgsLocArray); } void ASTStmtReader::VisitStmt(Stmt *S) { - assert(Idx == NumStmtFields && "Incorrect statement field count"); + assert(Record.getIdx() == NumStmtFields && "Incorrect statement field count"); } void ASTStmtReader::VisitNullStmt(NullStmt *S) { VisitStmt(S); - S->setSemiLoc(ReadSourceLocation(Record, Idx)); - S->HasLeadingEmptyMacro = Record[Idx++]; + S->setSemiLoc(ReadSourceLocation()); + S->HasLeadingEmptyMacro = Record.readInt(); } void ASTStmtReader::VisitCompoundStmt(CompoundStmt *S) { VisitStmt(S); SmallVector<Stmt *, 16> Stmts; - unsigned NumStmts = Record[Idx++]; + unsigned NumStmts = Record.readInt(); while (NumStmts--) - Stmts.push_back(Reader.ReadSubStmt()); - S->setStmts(Reader.getContext(), Stmts); - S->LBraceLoc = ReadSourceLocation(Record, Idx); - S->RBraceLoc = ReadSourceLocation(Record, Idx); + Stmts.push_back(Record.readSubStmt()); + S->setStmts(Record.getContext(), Stmts); + S->LBraceLoc = ReadSourceLocation(); + S->RBraceLoc = ReadSourceLocation(); } void ASTStmtReader::VisitSwitchCase(SwitchCase *S) { VisitStmt(S); - Reader.RecordSwitchCaseID(S, Record[Idx++]); - S->setKeywordLoc(ReadSourceLocation(Record, Idx)); - S->setColonLoc(ReadSourceLocation(Record, Idx)); + Record.recordSwitchCaseID(S, Record.readInt()); + S->setKeywordLoc(ReadSourceLocation()); + S->setColonLoc(ReadSourceLocation()); } void ASTStmtReader::VisitCaseStmt(CaseStmt *S) { VisitSwitchCase(S); - S->setLHS(Reader.ReadSubExpr()); - S->setRHS(Reader.ReadSubExpr()); - S->setSubStmt(Reader.ReadSubStmt()); - S->setEllipsisLoc(ReadSourceLocation(Record, Idx)); + S->setLHS(Record.readSubExpr()); + S->setRHS(Record.readSubExpr()); + S->setSubStmt(Record.readSubStmt()); + S->setEllipsisLoc(ReadSourceLocation()); } void ASTStmtReader::VisitDefaultStmt(DefaultStmt *S) { VisitSwitchCase(S); - S->setSubStmt(Reader.ReadSubStmt()); + S->setSubStmt(Record.readSubStmt()); } void ASTStmtReader::VisitLabelStmt(LabelStmt *S) { VisitStmt(S); - LabelDecl *LD = ReadDeclAs<LabelDecl>(Record, Idx); + LabelDecl *LD = ReadDeclAs<LabelDecl>(); LD->setStmt(S); S->setDecl(LD); - S->setSubStmt(Reader.ReadSubStmt()); - S->setIdentLoc(ReadSourceLocation(Record, Idx)); + S->setSubStmt(Record.readSubStmt()); + S->setIdentLoc(ReadSourceLocation()); } void ASTStmtReader::VisitAttributedStmt(AttributedStmt *S) { VisitStmt(S); - uint64_t NumAttrs = Record[Idx++]; + uint64_t NumAttrs = Record.readInt(); AttrVec Attrs; - Reader.ReadAttributes(F, Attrs, Record, Idx); + Record.readAttributes(Attrs); (void)NumAttrs; assert(NumAttrs == S->NumAttrs); assert(NumAttrs == Attrs.size()); std::copy(Attrs.begin(), Attrs.end(), S->getAttrArrayPtr()); - S->SubStmt = Reader.ReadSubStmt(); - S->AttrLoc = ReadSourceLocation(Record, Idx); + S->SubStmt = Record.readSubStmt(); + S->AttrLoc = ReadSourceLocation(); } void ASTStmtReader::VisitIfStmt(IfStmt *S) { VisitStmt(S); - S->setConstexpr(Record[Idx++]); - S->setInit(Reader.ReadSubStmt()); - S->setConditionVariable(Reader.getContext(), - ReadDeclAs<VarDecl>(Record, Idx)); - S->setCond(Reader.ReadSubExpr()); - S->setThen(Reader.ReadSubStmt()); - S->setElse(Reader.ReadSubStmt()); - S->setIfLoc(ReadSourceLocation(Record, Idx)); - S->setElseLoc(ReadSourceLocation(Record, Idx)); + S->setConstexpr(Record.readInt()); + S->setInit(Record.readSubStmt()); + S->setConditionVariable(Record.getContext(), ReadDeclAs<VarDecl>()); + S->setCond(Record.readSubExpr()); + S->setThen(Record.readSubStmt()); + S->setElse(Record.readSubStmt()); + S->setIfLoc(ReadSourceLocation()); + S->setElseLoc(ReadSourceLocation()); } void ASTStmtReader::VisitSwitchStmt(SwitchStmt *S) { VisitStmt(S); - S->setInit(Reader.ReadSubStmt()); - S->setConditionVariable(Reader.getContext(), - ReadDeclAs<VarDecl>(Record, Idx)); - S->setCond(Reader.ReadSubExpr()); - S->setBody(Reader.ReadSubStmt()); - S->setSwitchLoc(ReadSourceLocation(Record, Idx)); - if (Record[Idx++]) + S->setInit(Record.readSubStmt()); + S->setConditionVariable(Record.getContext(), ReadDeclAs<VarDecl>()); + S->setCond(Record.readSubExpr()); + S->setBody(Record.readSubStmt()); + S->setSwitchLoc(ReadSourceLocation()); + if (Record.readInt()) S->setAllEnumCasesCovered(); SwitchCase *PrevSC = nullptr; - for (unsigned N = Record.size(); Idx != N; ++Idx) { - SwitchCase *SC = Reader.getSwitchCaseWithID(Record[Idx]); + for (auto E = Record.size(); Record.getIdx() != E; ) { + SwitchCase *SC = Record.getSwitchCaseWithID(Record.readInt()); if (PrevSC) PrevSC->setNextSwitchCase(SC); else @@ -220,81 +202,80 @@ void ASTStmtReader::VisitSwitchStmt(SwitchStmt *S) { void ASTStmtReader::VisitWhileStmt(WhileStmt *S) { VisitStmt(S); - S->setConditionVariable(Reader.getContext(), - ReadDeclAs<VarDecl>(Record, Idx)); + S->setConditionVariable(Record.getContext(), ReadDeclAs<VarDecl>()); - S->setCond(Reader.ReadSubExpr()); - S->setBody(Reader.ReadSubStmt()); - S->setWhileLoc(ReadSourceLocation(Record, Idx)); + S->setCond(Record.readSubExpr()); + S->setBody(Record.readSubStmt()); + S->setWhileLoc(ReadSourceLocation()); } void ASTStmtReader::VisitDoStmt(DoStmt *S) { VisitStmt(S); - S->setCond(Reader.ReadSubExpr()); - S->setBody(Reader.ReadSubStmt()); - S->setDoLoc(ReadSourceLocation(Record, Idx)); - S->setWhileLoc(ReadSourceLocation(Record, Idx)); - S->setRParenLoc(ReadSourceLocation(Record, Idx)); + 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(Reader.ReadSubStmt()); - S->setCond(Reader.ReadSubExpr()); - S->setConditionVariable(Reader.getContext(), - ReadDeclAs<VarDecl>(Record, Idx)); - S->setInc(Reader.ReadSubExpr()); - S->setBody(Reader.ReadSubStmt()); - S->setForLoc(ReadSourceLocation(Record, Idx)); - S->setLParenLoc(ReadSourceLocation(Record, Idx)); - S->setRParenLoc(ReadSourceLocation(Record, Idx)); + 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>(Record, Idx)); - S->setGotoLoc(ReadSourceLocation(Record, Idx)); - S->setLabelLoc(ReadSourceLocation(Record, Idx)); + S->setLabel(ReadDeclAs<LabelDecl>()); + S->setGotoLoc(ReadSourceLocation()); + S->setLabelLoc(ReadSourceLocation()); } void ASTStmtReader::VisitIndirectGotoStmt(IndirectGotoStmt *S) { VisitStmt(S); - S->setGotoLoc(ReadSourceLocation(Record, Idx)); - S->setStarLoc(ReadSourceLocation(Record, Idx)); - S->setTarget(Reader.ReadSubExpr()); + S->setGotoLoc(ReadSourceLocation()); + S->setStarLoc(ReadSourceLocation()); + S->setTarget(Record.readSubExpr()); } void ASTStmtReader::VisitContinueStmt(ContinueStmt *S) { VisitStmt(S); - S->setContinueLoc(ReadSourceLocation(Record, Idx)); + S->setContinueLoc(ReadSourceLocation()); } void ASTStmtReader::VisitBreakStmt(BreakStmt *S) { VisitStmt(S); - S->setBreakLoc(ReadSourceLocation(Record, Idx)); + S->setBreakLoc(ReadSourceLocation()); } void ASTStmtReader::VisitReturnStmt(ReturnStmt *S) { VisitStmt(S); - S->setRetValue(Reader.ReadSubExpr()); - S->setReturnLoc(ReadSourceLocation(Record, Idx)); - S->setNRVOCandidate(ReadDeclAs<VarDecl>(Record, Idx)); + S->setRetValue(Record.readSubExpr()); + S->setReturnLoc(ReadSourceLocation()); + S->setNRVOCandidate(ReadDeclAs<VarDecl>()); } void ASTStmtReader::VisitDeclStmt(DeclStmt *S) { VisitStmt(S); - S->setStartLoc(ReadSourceLocation(Record, Idx)); - S->setEndLoc(ReadSourceLocation(Record, Idx)); + S->setStartLoc(ReadSourceLocation()); + S->setEndLoc(ReadSourceLocation()); - if (Idx + 1 == Record.size()) { + if (Record.size() - Record.getIdx() == 1) { // Single declaration - S->setDeclGroup(DeclGroupRef(ReadDecl(Record, Idx))); + S->setDeclGroup(DeclGroupRef(ReadDecl())); } else { SmallVector<Decl *, 16> Decls; - Decls.reserve(Record.size() - Idx); - for (unsigned N = Record.size(); Idx != N; ) - Decls.push_back(ReadDecl(Record, Idx)); - S->setDeclGroup(DeclGroupRef(DeclGroup::Create(Reader.getContext(), + 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()))); } @@ -302,18 +283,18 @@ void ASTStmtReader::VisitDeclStmt(DeclStmt *S) { void ASTStmtReader::VisitAsmStmt(AsmStmt *S) { VisitStmt(S); - S->NumOutputs = Record[Idx++]; - S->NumInputs = Record[Idx++]; - S->NumClobbers = Record[Idx++]; - S->setAsmLoc(ReadSourceLocation(Record, Idx)); - S->setVolatile(Record[Idx++]); - S->setSimple(Record[Idx++]); + 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->setRParenLoc(ReadSourceLocation(Record, Idx)); - S->setAsmString(cast_or_null<StringLiteral>(Reader.ReadSubStmt())); + S->setRParenLoc(ReadSourceLocation()); + S->setAsmString(cast_or_null<StringLiteral>(Record.readSubStmt())); unsigned NumOutputs = S->getNumOutputs(); unsigned NumInputs = S->getNumInputs(); @@ -324,34 +305,34 @@ void ASTStmtReader::VisitGCCAsmStmt(GCCAsmStmt *S) { SmallVector<StringLiteral*, 16> Constraints; SmallVector<Stmt*, 16> Exprs; for (unsigned I = 0, N = NumOutputs + NumInputs; I != N; ++I) { - Names.push_back(Reader.GetIdentifierInfo(F, Record, Idx)); - Constraints.push_back(cast_or_null<StringLiteral>(Reader.ReadSubStmt())); - Exprs.push_back(Reader.ReadSubStmt()); + Names.push_back(Record.getIdentifierInfo()); + 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>(Reader.ReadSubStmt())); + Clobbers.push_back(cast_or_null<StringLiteral>(Record.readSubStmt())); - S->setOutputsAndInputsAndClobbers(Reader.getContext(), - Names.data(), Constraints.data(), - Exprs.data(), NumOutputs, NumInputs, + S->setOutputsAndInputsAndClobbers(Record.getContext(), + Names.data(), Constraints.data(), + Exprs.data(), NumOutputs, NumInputs, Clobbers.data(), NumClobbers); } void ASTStmtReader::VisitMSAsmStmt(MSAsmStmt *S) { VisitAsmStmt(S); - S->LBraceLoc = ReadSourceLocation(Record, Idx); - S->EndLoc = ReadSourceLocation(Record, Idx); - S->NumAsmToks = Record[Idx++]; - std::string AsmStr = ReadString(Record, Idx); + 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(ReadToken(Record, Idx)); + AsmToks.push_back(Record.readToken()); } // The calls to reserve() for the FooData vectors are mandatory to @@ -363,7 +344,7 @@ void ASTStmtReader::VisitMSAsmStmt(MSAsmStmt *S) { ClobbersData.reserve(S->NumClobbers); Clobbers.reserve(S->NumClobbers); for (unsigned i = 0, e = S->NumClobbers; i != e; ++i) { - ClobbersData.push_back(ReadString(Record, Idx)); + ClobbersData.push_back(ReadString()); Clobbers.push_back(ClobbersData.back()); } @@ -376,12 +357,12 @@ void ASTStmtReader::VisitMSAsmStmt(MSAsmStmt *S) { ConstraintsData.reserve(NumOperands); Constraints.reserve(NumOperands); for (unsigned i = 0; i != NumOperands; ++i) { - Exprs.push_back(cast<Expr>(Reader.ReadSubStmt())); - ConstraintsData.push_back(ReadString(Record, Idx)); + Exprs.push_back(cast<Expr>(Record.readSubStmt())); + ConstraintsData.push_back(ReadString()); Constraints.push_back(ConstraintsData.back()); } - S->initialize(Reader.getContext(), AsmStr, AsmToks, + S->initialize(Record.getContext(), AsmStr, AsmToks, Constraints, Exprs, Clobbers); } @@ -407,229 +388,229 @@ void ASTStmtReader::VisitCoyieldExpr(CoyieldExpr *S) { void ASTStmtReader::VisitCapturedStmt(CapturedStmt *S) { VisitStmt(S); - ++Idx; - S->setCapturedDecl(ReadDeclAs<CapturedDecl>(Record, Idx)); - S->setCapturedRegionKind(static_cast<CapturedRegionKind>(Record[Idx++])); - S->setCapturedRecordDecl(ReadDeclAs<RecordDecl>(Record, Idx)); + 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 = Reader.ReadSubExpr(); + *I = Record.readSubExpr(); // Body - S->setCapturedStmt(Reader.ReadSubStmt()); + S->setCapturedStmt(Record.readSubStmt()); S->getCapturedDecl()->setBody(S->getCapturedStmt()); // Captures for (auto &I : S->captures()) { - I.VarAndKind.setPointer(ReadDeclAs<VarDecl>(Record, Idx)); - I.VarAndKind - .setInt(static_cast<CapturedStmt::VariableCaptureKind>(Record[Idx++])); - I.Loc = ReadSourceLocation(Record, Idx); + 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(Reader.readType(F, Record, Idx)); - E->setTypeDependent(Record[Idx++]); - E->setValueDependent(Record[Idx++]); - E->setInstantiationDependent(Record[Idx++]); - E->ExprBits.ContainsUnexpandedParameterPack = Record[Idx++]; - E->setValueKind(static_cast<ExprValueKind>(Record[Idx++])); - E->setObjectKind(static_cast<ExprObjectKind>(Record[Idx++])); - assert(Idx == NumExprFields && "Incorrect expression field count"); + E->setType(Record.readType()); + E->setTypeDependent(Record.readInt()); + E->setValueDependent(Record.readInt()); + E->setInstantiationDependent(Record.readInt()); + E->ExprBits.ContainsUnexpandedParameterPack = Record.readInt(); + E->setValueKind(static_cast<ExprValueKind>(Record.readInt())); + E->setObjectKind(static_cast<ExprObjectKind>(Record.readInt())); + assert(Record.getIdx() == NumExprFields && + "Incorrect expression field count"); } void ASTStmtReader::VisitPredefinedExpr(PredefinedExpr *E) { VisitExpr(E); - E->setLocation(ReadSourceLocation(Record, Idx)); - E->Type = (PredefinedExpr::IdentType)Record[Idx++]; - E->FnName = cast_or_null<StringLiteral>(Reader.ReadSubExpr()); + E->setLocation(ReadSourceLocation()); + E->Type = (PredefinedExpr::IdentType)Record.readInt(); + E->FnName = cast_or_null<StringLiteral>(Record.readSubExpr()); } void ASTStmtReader::VisitDeclRefExpr(DeclRefExpr *E) { VisitExpr(E); - E->DeclRefExprBits.HasQualifier = Record[Idx++]; - E->DeclRefExprBits.HasFoundDecl = Record[Idx++]; - E->DeclRefExprBits.HasTemplateKWAndArgsInfo = Record[Idx++]; - E->DeclRefExprBits.HadMultipleCandidates = Record[Idx++]; - E->DeclRefExprBits.RefersToEnclosingVariableOrCapture = Record[Idx++]; + 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(); unsigned NumTemplateArgs = 0; if (E->hasTemplateKWAndArgsInfo()) - NumTemplateArgs = Record[Idx++]; + NumTemplateArgs = Record.readInt(); if (E->hasQualifier()) new (E->getTrailingObjects<NestedNameSpecifierLoc>()) - NestedNameSpecifierLoc( - Reader.ReadNestedNameSpecifierLoc(F, Record, Idx)); + NestedNameSpecifierLoc(Record.readNestedNameSpecifierLoc()); if (E->hasFoundDecl()) - *E->getTrailingObjects<NamedDecl *>() = ReadDeclAs<NamedDecl>(Record, Idx); + *E->getTrailingObjects<NamedDecl *>() = ReadDeclAs<NamedDecl>(); if (E->hasTemplateKWAndArgsInfo()) ReadTemplateKWAndArgsInfo( *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(), E->getTrailingObjects<TemplateArgumentLoc>(), NumTemplateArgs); - E->setDecl(ReadDeclAs<ValueDecl>(Record, Idx)); - E->setLocation(ReadSourceLocation(Record, Idx)); - ReadDeclarationNameLoc(E->DNLoc, E->getDecl()->getDeclName(), Record, Idx); + E->setDecl(ReadDeclAs<ValueDecl>()); + E->setLocation(ReadSourceLocation()); + ReadDeclarationNameLoc(E->DNLoc, E->getDecl()->getDeclName()); } void ASTStmtReader::VisitIntegerLiteral(IntegerLiteral *E) { VisitExpr(E); - E->setLocation(ReadSourceLocation(Record, Idx)); - E->setValue(Reader.getContext(), Reader.ReadAPInt(Record, Idx)); + E->setLocation(ReadSourceLocation()); + E->setValue(Record.getContext(), Record.readAPInt()); } void ASTStmtReader::VisitFloatingLiteral(FloatingLiteral *E) { VisitExpr(E); - E->setRawSemantics(static_cast<Stmt::APFloatSemantics>(Record[Idx++])); - E->setExact(Record[Idx++]); - E->setValue(Reader.getContext(), - Reader.ReadAPFloat(Record, E->getSemantics(), Idx)); - E->setLocation(ReadSourceLocation(Record, Idx)); + E->setRawSemantics(static_cast<Stmt::APFloatSemantics>(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(Reader.ReadSubExpr()); + E->setSubExpr(Record.readSubExpr()); } void ASTStmtReader::VisitStringLiteral(StringLiteral *E) { VisitExpr(E); - unsigned Len = Record[Idx++]; - assert(Record[Idx] == E->getNumConcatenated() && + unsigned Len = Record.readInt(); + assert(Record.peekInt() == E->getNumConcatenated() && "Wrong number of concatenated tokens!"); - ++Idx; + Record.skipInts(1); StringLiteral::StringKind kind = - static_cast<StringLiteral::StringKind>(Record[Idx++]); - bool isPascal = Record[Idx++]; + static_cast<StringLiteral::StringKind>(Record.readInt()); + bool isPascal = Record.readInt(); // Read string data - SmallString<16> Str(&Record[Idx], &Record[Idx] + Len); - E->setString(Reader.getContext(), Str, kind, isPascal); - Idx += Len; + auto B = &Record.peekInt(); + SmallString<16> Str(B, B + Len); + E->setString(Record.getContext(), Str, kind, isPascal); + Record.skipInts(Len); // Read source locations for (unsigned I = 0, N = E->getNumConcatenated(); I != N; ++I) - E->setStrTokenLoc(I, ReadSourceLocation(Record, Idx)); + E->setStrTokenLoc(I, ReadSourceLocation()); } void ASTStmtReader::VisitCharacterLiteral(CharacterLiteral *E) { VisitExpr(E); - E->setValue(Record[Idx++]); - E->setLocation(ReadSourceLocation(Record, Idx)); - E->setKind(static_cast<CharacterLiteral::CharacterKind>(Record[Idx++])); + 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(Record, Idx)); - E->setRParen(ReadSourceLocation(Record, Idx)); - E->setSubExpr(Reader.ReadSubExpr()); + E->setLParen(ReadSourceLocation()); + E->setRParen(ReadSourceLocation()); + E->setSubExpr(Record.readSubExpr()); } void ASTStmtReader::VisitParenListExpr(ParenListExpr *E) { VisitExpr(E); - unsigned NumExprs = Record[Idx++]; - E->Exprs = new (Reader.getContext()) Stmt*[NumExprs]; + unsigned NumExprs = Record.readInt(); + E->Exprs = new (Record.getContext()) Stmt*[NumExprs]; for (unsigned i = 0; i != NumExprs; ++i) - E->Exprs[i] = Reader.ReadSubStmt(); + E->Exprs[i] = Record.readSubStmt(); E->NumExprs = NumExprs; - E->LParenLoc = ReadSourceLocation(Record, Idx); - E->RParenLoc = ReadSourceLocation(Record, Idx); + E->LParenLoc = ReadSourceLocation(); + E->RParenLoc = ReadSourceLocation(); } void ASTStmtReader::VisitUnaryOperator(UnaryOperator *E) { VisitExpr(E); - E->setSubExpr(Reader.ReadSubExpr()); - E->setOpcode((UnaryOperator::Opcode)Record[Idx++]); - E->setOperatorLoc(ReadSourceLocation(Record, Idx)); + E->setSubExpr(Record.readSubExpr()); + E->setOpcode((UnaryOperator::Opcode)Record.readInt()); + E->setOperatorLoc(ReadSourceLocation()); } void ASTStmtReader::VisitOffsetOfExpr(OffsetOfExpr *E) { VisitExpr(E); - assert(E->getNumComponents() == Record[Idx]); - ++Idx; - assert(E->getNumExpressions() == Record[Idx]); - ++Idx; - E->setOperatorLoc(ReadSourceLocation(Record, Idx)); - E->setRParenLoc(ReadSourceLocation(Record, Idx)); - E->setTypeSourceInfo(GetTypeSourceInfo(Record, Idx)); + assert(E->getNumComponents() == Record.peekInt()); + Record.skipInts(1); + assert(E->getNumExpressions() == Record.peekInt()); + Record.skipInts(1); + E->setOperatorLoc(ReadSourceLocation()); + E->setRParenLoc(ReadSourceLocation()); + E->setTypeSourceInfo(GetTypeSourceInfo()); for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) { - OffsetOfNode::Kind Kind = static_cast<OffsetOfNode::Kind>(Record[Idx++]); - SourceLocation Start = ReadSourceLocation(Record, Idx); - SourceLocation End = ReadSourceLocation(Record, Idx); + OffsetOfNode::Kind Kind = static_cast<OffsetOfNode::Kind>(Record.readInt()); + SourceLocation Start = ReadSourceLocation(); + SourceLocation End = ReadSourceLocation(); switch (Kind) { case OffsetOfNode::Array: - E->setComponent(I, OffsetOfNode(Start, Record[Idx++], End)); + E->setComponent(I, OffsetOfNode(Start, Record.readInt(), End)); break; case OffsetOfNode::Field: E->setComponent( - I, OffsetOfNode(Start, ReadDeclAs<FieldDecl>(Record, Idx), End)); + I, OffsetOfNode(Start, ReadDeclAs<FieldDecl>(), End)); break; case OffsetOfNode::Identifier: E->setComponent( I, - OffsetOfNode(Start, Reader.GetIdentifierInfo(F, Record, Idx), End)); + OffsetOfNode(Start, Record.getIdentifierInfo(), End)); break; case OffsetOfNode::Base: { - CXXBaseSpecifier *Base = new (Reader.getContext()) CXXBaseSpecifier(); - *Base = Reader.ReadCXXBaseSpecifier(F, Record, Idx); + CXXBaseSpecifier *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, Reader.ReadSubExpr()); + E->setIndexExpr(I, Record.readSubExpr()); } void ASTStmtReader::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) { VisitExpr(E); - E->setKind(static_cast<UnaryExprOrTypeTrait>(Record[Idx++])); - if (Record[Idx] == 0) { - E->setArgument(Reader.ReadSubExpr()); - ++Idx; + E->setKind(static_cast<UnaryExprOrTypeTrait>(Record.readInt())); + if (Record.peekInt() == 0) { + E->setArgument(Record.readSubExpr()); + Record.skipInts(1); } else { - E->setArgument(GetTypeSourceInfo(Record, Idx)); + E->setArgument(GetTypeSourceInfo()); } - E->setOperatorLoc(ReadSourceLocation(Record, Idx)); - E->setRParenLoc(ReadSourceLocation(Record, Idx)); + E->setOperatorLoc(ReadSourceLocation()); + E->setRParenLoc(ReadSourceLocation()); } void ASTStmtReader::VisitArraySubscriptExpr(ArraySubscriptExpr *E) { VisitExpr(E); - E->setLHS(Reader.ReadSubExpr()); - E->setRHS(Reader.ReadSubExpr()); - E->setRBracketLoc(ReadSourceLocation(Record, Idx)); + E->setLHS(Record.readSubExpr()); + E->setRHS(Record.readSubExpr()); + E->setRBracketLoc(ReadSourceLocation()); } void ASTStmtReader::VisitOMPArraySectionExpr(OMPArraySectionExpr *E) { VisitExpr(E); - E->setBase(Reader.ReadSubExpr()); - E->setLowerBound(Reader.ReadSubExpr()); - E->setLength(Reader.ReadSubExpr()); - E->setColonLoc(ReadSourceLocation(Record, Idx)); - E->setRBracketLoc(ReadSourceLocation(Record, Idx)); + E->setBase(Record.readSubExpr()); + E->setLowerBound(Record.readSubExpr()); + E->setLength(Record.readSubExpr()); + E->setColonLoc(ReadSourceLocation()); + E->setRBracketLoc(ReadSourceLocation()); } void ASTStmtReader::VisitCallExpr(CallExpr *E) { VisitExpr(E); - E->setNumArgs(Reader.getContext(), Record[Idx++]); - E->setRParenLoc(ReadSourceLocation(Record, Idx)); - E->setCallee(Reader.ReadSubExpr()); + E->setNumArgs(Record.getContext(), Record.readInt()); + E->setRParenLoc(ReadSourceLocation()); + E->setCallee(Record.readSubExpr()); for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) - E->setArg(I, Reader.ReadSubExpr()); + E->setArg(I, Record.readSubExpr()); } void ASTStmtReader::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) { @@ -644,74 +625,74 @@ void ASTStmtReader::VisitMemberExpr(MemberExpr *E) { void ASTStmtReader::VisitObjCIsaExpr(ObjCIsaExpr *E) { VisitExpr(E); - E->setBase(Reader.ReadSubExpr()); - E->setIsaMemberLoc(ReadSourceLocation(Record, Idx)); - E->setOpLoc(ReadSourceLocation(Record, Idx)); - E->setArrow(Record[Idx++]); + E->setBase(Record.readSubExpr()); + E->setIsaMemberLoc(ReadSourceLocation()); + E->setOpLoc(ReadSourceLocation()); + E->setArrow(Record.readInt()); } void ASTStmtReader:: VisitObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) { VisitExpr(E); - E->Operand = Reader.ReadSubExpr(); - E->setShouldCopy(Record[Idx++]); + E->Operand = Record.readSubExpr(); + E->setShouldCopy(Record.readInt()); } void ASTStmtReader::VisitObjCBridgedCastExpr(ObjCBridgedCastExpr *E) { VisitExplicitCastExpr(E); - E->LParenLoc = ReadSourceLocation(Record, Idx); - E->BridgeKeywordLoc = ReadSourceLocation(Record, Idx); - E->Kind = Record[Idx++]; + E->LParenLoc = ReadSourceLocation(); + E->BridgeKeywordLoc = ReadSourceLocation(); + E->Kind = Record.readInt(); } void ASTStmtReader::VisitCastExpr(CastExpr *E) { VisitExpr(E); - unsigned NumBaseSpecs = Record[Idx++]; + unsigned NumBaseSpecs = Record.readInt(); assert(NumBaseSpecs == E->path_size()); - E->setSubExpr(Reader.ReadSubExpr()); - E->setCastKind((CastKind)Record[Idx++]); + E->setSubExpr(Record.readSubExpr()); + E->setCastKind((CastKind)Record.readInt()); CastExpr::path_iterator BaseI = E->path_begin(); while (NumBaseSpecs--) { - CXXBaseSpecifier *BaseSpec = new (Reader.getContext()) CXXBaseSpecifier; - *BaseSpec = Reader.ReadCXXBaseSpecifier(F, Record, Idx); + CXXBaseSpecifier *BaseSpec = new (Record.getContext()) CXXBaseSpecifier; + *BaseSpec = Record.readCXXBaseSpecifier(); *BaseI++ = BaseSpec; } } void ASTStmtReader::VisitBinaryOperator(BinaryOperator *E) { VisitExpr(E); - E->setLHS(Reader.ReadSubExpr()); - E->setRHS(Reader.ReadSubExpr()); - E->setOpcode((BinaryOperator::Opcode)Record[Idx++]); - E->setOperatorLoc(ReadSourceLocation(Record, Idx)); - E->setFPContractable((bool)Record[Idx++]); + E->setLHS(Record.readSubExpr()); + E->setRHS(Record.readSubExpr()); + E->setOpcode((BinaryOperator::Opcode)Record.readInt()); + E->setOperatorLoc(ReadSourceLocation()); + E->setFPContractable((bool)Record.readInt()); } void ASTStmtReader::VisitCompoundAssignOperator(CompoundAssignOperator *E) { VisitBinaryOperator(E); - E->setComputationLHSType(Reader.readType(F, Record, Idx)); - E->setComputationResultType(Reader.readType(F, Record, Idx)); + E->setComputationLHSType(Record.readType()); + E->setComputationResultType(Record.readType()); } void ASTStmtReader::VisitConditionalOperator(ConditionalOperator *E) { VisitExpr(E); - E->SubExprs[ConditionalOperator::COND] = Reader.ReadSubExpr(); - E->SubExprs[ConditionalOperator::LHS] = Reader.ReadSubExpr(); - E->SubExprs[ConditionalOperator::RHS] = Reader.ReadSubExpr(); - E->QuestionLoc = ReadSourceLocation(Record, Idx); - E->ColonLoc = ReadSourceLocation(Record, Idx); + 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>(Reader.ReadSubExpr()); - E->SubExprs[BinaryConditionalOperator::COMMON] = Reader.ReadSubExpr(); - E->SubExprs[BinaryConditionalOperator::COND] = Reader.ReadSubExpr(); - E->SubExprs[BinaryConditionalOperator::LHS] = Reader.ReadSubExpr(); - E->SubExprs[BinaryConditionalOperator::RHS] = Reader.ReadSubExpr(); - E->QuestionLoc = ReadSourceLocation(Record, Idx); - E->ColonLoc = ReadSourceLocation(Record, Idx); + 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) { @@ -720,54 +701,54 @@ void ASTStmtReader::VisitImplicitCastExpr(ImplicitCastExpr *E) { void ASTStmtReader::VisitExplicitCastExpr(ExplicitCastExpr *E) { VisitCastExpr(E); - E->setTypeInfoAsWritten(GetTypeSourceInfo(Record, Idx)); + E->setTypeInfoAsWritten(GetTypeSourceInfo()); } void ASTStmtReader::VisitCStyleCastExpr(CStyleCastExpr *E) { VisitExplicitCastExpr(E); - E->setLParenLoc(ReadSourceLocation(Record, Idx)); - E->setRParenLoc(ReadSourceLocation(Record, Idx)); + E->setLParenLoc(ReadSourceLocation()); + E->setRParenLoc(ReadSourceLocation()); } void ASTStmtReader::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) { VisitExpr(E); - E->setLParenLoc(ReadSourceLocation(Record, Idx)); - E->setTypeSourceInfo(GetTypeSourceInfo(Record, Idx)); - E->setInitializer(Reader.ReadSubExpr()); - E->setFileScope(Record[Idx++]); + E->setLParenLoc(ReadSourceLocation()); + E->setTypeSourceInfo(GetTypeSourceInfo()); + E->setInitializer(Record.readSubExpr()); + E->setFileScope(Record.readInt()); } void ASTStmtReader::VisitExtVectorElementExpr(ExtVectorElementExpr *E) { VisitExpr(E); - E->setBase(Reader.ReadSubExpr()); - E->setAccessor(Reader.GetIdentifierInfo(F, Record, Idx)); - E->setAccessorLoc(ReadSourceLocation(Record, Idx)); + E->setBase(Record.readSubExpr()); + E->setAccessor(Record.getIdentifierInfo()); + E->setAccessorLoc(ReadSourceLocation()); } void ASTStmtReader::VisitInitListExpr(InitListExpr *E) { VisitExpr(E); - if (InitListExpr *SyntForm = cast_or_null<InitListExpr>(Reader.ReadSubStmt())) + if (InitListExpr *SyntForm = cast_or_null<InitListExpr>(Record.readSubStmt())) E->setSyntacticForm(SyntForm); - E->setLBraceLoc(ReadSourceLocation(Record, Idx)); - E->setRBraceLoc(ReadSourceLocation(Record, Idx)); - bool isArrayFiller = Record[Idx++]; + E->setLBraceLoc(ReadSourceLocation()); + E->setRBraceLoc(ReadSourceLocation()); + bool isArrayFiller = Record.readInt(); Expr *filler = nullptr; if (isArrayFiller) { - filler = Reader.ReadSubExpr(); + filler = Record.readSubExpr(); E->ArrayFillerOrUnionFieldInit = filler; } else - E->ArrayFillerOrUnionFieldInit = ReadDeclAs<FieldDecl>(Record, Idx); - E->sawArrayRangeDesignator(Record[Idx++]); - unsigned NumInits = Record[Idx++]; - E->reserveInits(Reader.getContext(), NumInits); + 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 = Reader.ReadSubExpr(); - E->updateInit(Reader.getContext(), I, init ? init : filler); + Expr *init = Record.readSubExpr(); + E->updateInit(Record.getContext(), I, init ? init : filler); } } else { for (unsigned I = 0; I != NumInits; ++I) - E->updateInit(Reader.getContext(), I, Reader.ReadSubExpr()); + E->updateInit(Record.getContext(), I, Record.readSubExpr()); } } @@ -775,22 +756,20 @@ void ASTStmtReader::VisitDesignatedInitExpr(DesignatedInitExpr *E) { typedef DesignatedInitExpr::Designator Designator; VisitExpr(E); - unsigned NumSubExprs = Record[Idx++]; + unsigned NumSubExprs = Record.readInt(); assert(NumSubExprs == E->getNumSubExprs() && "Wrong number of subexprs"); for (unsigned I = 0; I != NumSubExprs; ++I) - E->setSubExpr(I, Reader.ReadSubExpr()); - E->setEqualOrColonLoc(ReadSourceLocation(Record, Idx)); - E->setGNUSyntax(Record[Idx++]); + E->setSubExpr(I, Record.readSubExpr()); + E->setEqualOrColonLoc(ReadSourceLocation()); + E->setGNUSyntax(Record.readInt()); SmallVector<Designator, 4> Designators; - while (Idx < Record.size()) { - switch ((DesignatorTypes)Record[Idx++]) { + while (Record.getIdx() < Record.size()) { + switch ((DesignatorTypes)Record.readInt()) { case DESIG_FIELD_DECL: { - FieldDecl *Field = ReadDeclAs<FieldDecl>(Record, Idx); - SourceLocation DotLoc - = ReadSourceLocation(Record, Idx); - SourceLocation FieldLoc - = ReadSourceLocation(Record, Idx); + FieldDecl *Field = ReadDeclAs<FieldDecl>(); + SourceLocation DotLoc = ReadSourceLocation(); + SourceLocation FieldLoc = ReadSourceLocation(); Designators.push_back(Designator(Field->getIdentifier(), DotLoc, FieldLoc)); Designators.back().setField(Field); @@ -798,162 +777,165 @@ void ASTStmtReader::VisitDesignatedInitExpr(DesignatedInitExpr *E) { } case DESIG_FIELD_NAME: { - const IdentifierInfo *Name = Reader.GetIdentifierInfo(F, Record, Idx); - SourceLocation DotLoc - = ReadSourceLocation(Record, Idx); - SourceLocation FieldLoc - = ReadSourceLocation(Record, Idx); + const IdentifierInfo *Name = Record.getIdentifierInfo(); + SourceLocation DotLoc = ReadSourceLocation(); + SourceLocation FieldLoc = ReadSourceLocation(); Designators.push_back(Designator(Name, DotLoc, FieldLoc)); break; } case DESIG_ARRAY: { - unsigned Index = Record[Idx++]; - SourceLocation LBracketLoc - = ReadSourceLocation(Record, Idx); - SourceLocation RBracketLoc - = ReadSourceLocation(Record, Idx); + 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[Idx++]; - SourceLocation LBracketLoc - = ReadSourceLocation(Record, Idx); - SourceLocation EllipsisLoc - = ReadSourceLocation(Record, Idx); - SourceLocation RBracketLoc - = ReadSourceLocation(Record, Idx); + unsigned Index = Record.readInt(); + SourceLocation LBracketLoc = ReadSourceLocation(); + SourceLocation EllipsisLoc = ReadSourceLocation(); + SourceLocation RBracketLoc = ReadSourceLocation(); Designators.push_back(Designator(Index, LBracketLoc, EllipsisLoc, RBracketLoc)); break; } } } - E->setDesignators(Reader.getContext(), + E->setDesignators(Record.getContext(), Designators.data(), Designators.size()); } void ASTStmtReader::VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E) { VisitExpr(E); - E->setBase(Reader.ReadSubExpr()); - E->setUpdater(Reader.ReadSubExpr()); + 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(Reader.ReadSubExpr()); - E->setWrittenTypeInfo(GetTypeSourceInfo(Record, Idx)); - E->setBuiltinLoc(ReadSourceLocation(Record, Idx)); - E->setRParenLoc(ReadSourceLocation(Record, Idx)); - E->setIsMicrosoftABI(Record[Idx++]); + E->setSubExpr(Record.readSubExpr()); + E->setWrittenTypeInfo(GetTypeSourceInfo()); + E->setBuiltinLoc(ReadSourceLocation()); + E->setRParenLoc(ReadSourceLocation()); + E->setIsMicrosoftABI(Record.readInt()); } void ASTStmtReader::VisitAddrLabelExpr(AddrLabelExpr *E) { VisitExpr(E); - E->setAmpAmpLoc(ReadSourceLocation(Record, Idx)); - E->setLabelLoc(ReadSourceLocation(Record, Idx)); - E->setLabel(ReadDeclAs<LabelDecl>(Record, Idx)); + E->setAmpAmpLoc(ReadSourceLocation()); + E->setLabelLoc(ReadSourceLocation()); + E->setLabel(ReadDeclAs<LabelDecl>()); } void ASTStmtReader::VisitStmtExpr(StmtExpr *E) { VisitExpr(E); - E->setLParenLoc(ReadSourceLocation(Record, Idx)); - E->setRParenLoc(ReadSourceLocation(Record, Idx)); - E->setSubStmt(cast_or_null<CompoundStmt>(Reader.ReadSubStmt())); + E->setLParenLoc(ReadSourceLocation()); + E->setRParenLoc(ReadSourceLocation()); + E->setSubStmt(cast_or_null<CompoundStmt>(Record.readSubStmt())); } void ASTStmtReader::VisitChooseExpr(ChooseExpr *E) { VisitExpr(E); - E->setCond(Reader.ReadSubExpr()); - E->setLHS(Reader.ReadSubExpr()); - E->setRHS(Reader.ReadSubExpr()); - E->setBuiltinLoc(ReadSourceLocation(Record, Idx)); - E->setRParenLoc(ReadSourceLocation(Record, Idx)); - E->setIsConditionTrue(Record[Idx++]); + 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(Record, Idx)); + E->setTokenLocation(ReadSourceLocation()); } void ASTStmtReader::VisitShuffleVectorExpr(ShuffleVectorExpr *E) { VisitExpr(E); SmallVector<Expr *, 16> Exprs; - unsigned NumExprs = Record[Idx++]; + unsigned NumExprs = Record.readInt(); while (NumExprs--) - Exprs.push_back(Reader.ReadSubExpr()); - E->setExprs(Reader.getContext(), Exprs); - E->setBuiltinLoc(ReadSourceLocation(Record, Idx)); - E->setRParenLoc(ReadSourceLocation(Record, Idx)); + 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(Record, Idx); - E->RParenLoc = ReadSourceLocation(Record, Idx); - E->TInfo = GetTypeSourceInfo(Record, Idx); - E->SrcExpr = Reader.ReadSubExpr(); + E->BuiltinLoc = ReadSourceLocation(); + E->RParenLoc = ReadSourceLocation(); + E->TInfo = GetTypeSourceInfo(); + E->SrcExpr = Record.readSubExpr(); } void ASTStmtReader::VisitBlockExpr(BlockExpr *E) { VisitExpr(E); - E->setBlockDecl(ReadDeclAs<BlockDecl>(Record, Idx)); + E->setBlockDecl(ReadDeclAs<BlockDecl>()); } void ASTStmtReader::VisitGenericSelectionExpr(GenericSelectionExpr *E) { VisitExpr(E); - E->NumAssocs = Record[Idx++]; - E->AssocTypes = new (Reader.getContext()) TypeSourceInfo*[E->NumAssocs]; + E->NumAssocs = Record.readInt(); + E->AssocTypes = new (Record.getContext()) TypeSourceInfo*[E->NumAssocs]; E->SubExprs = - new(Reader.getContext()) Stmt*[GenericSelectionExpr::END_EXPR+E->NumAssocs]; + new(Record.getContext()) Stmt*[GenericSelectionExpr::END_EXPR+E->NumAssocs]; - E->SubExprs[GenericSelectionExpr::CONTROLLING] = Reader.ReadSubExpr(); + E->SubExprs[GenericSelectionExpr::CONTROLLING] = Record.readSubExpr(); for (unsigned I = 0, N = E->getNumAssocs(); I != N; ++I) { - E->AssocTypes[I] = GetTypeSourceInfo(Record, Idx); - E->SubExprs[GenericSelectionExpr::END_EXPR+I] = Reader.ReadSubExpr(); + E->AssocTypes[I] = GetTypeSourceInfo(); + E->SubExprs[GenericSelectionExpr::END_EXPR+I] = Record.readSubExpr(); } - E->ResultIndex = Record[Idx++]; + E->ResultIndex = Record.readInt(); - E->GenericLoc = ReadSourceLocation(Record, Idx); - E->DefaultLoc = ReadSourceLocation(Record, Idx); - E->RParenLoc = ReadSourceLocation(Record, Idx); + E->GenericLoc = ReadSourceLocation(); + E->DefaultLoc = ReadSourceLocation(); + E->RParenLoc = ReadSourceLocation(); } void ASTStmtReader::VisitPseudoObjectExpr(PseudoObjectExpr *E) { VisitExpr(E); - unsigned numSemanticExprs = Record[Idx++]; + unsigned numSemanticExprs = Record.readInt(); assert(numSemanticExprs + 1 == E->PseudoObjectExprBits.NumSubExprs); - E->PseudoObjectExprBits.ResultIndex = Record[Idx++]; + E->PseudoObjectExprBits.ResultIndex = Record.readInt(); // Read the syntactic expression. - E->getSubExprsBuffer()[0] = Reader.ReadSubExpr(); + E->getSubExprsBuffer()[0] = Record.readSubExpr(); // Read all the semantic expressions. for (unsigned i = 0; i != numSemanticExprs; ++i) { - Expr *subExpr = Reader.ReadSubExpr(); + Expr *subExpr = Record.readSubExpr(); E->getSubExprsBuffer()[i+1] = subExpr; } } void ASTStmtReader::VisitAtomicExpr(AtomicExpr *E) { VisitExpr(E); - E->Op = AtomicExpr::AtomicOp(Record[Idx++]); + E->Op = AtomicExpr::AtomicOp(Record.readInt()); E->NumSubExprs = AtomicExpr::getNumSubExprs(E->Op); for (unsigned I = 0; I != E->NumSubExprs; ++I) - E->SubExprs[I] = Reader.ReadSubExpr(); - E->BuiltinLoc = ReadSourceLocation(Record, Idx); - E->RParenLoc = ReadSourceLocation(Record, Idx); + E->SubExprs[I] = Record.readSubExpr(); + E->BuiltinLoc = ReadSourceLocation(); + E->RParenLoc = ReadSourceLocation(); } //===----------------------------------------------------------------------===// @@ -961,142 +943,141 @@ void ASTStmtReader::VisitAtomicExpr(AtomicExpr *E) { void ASTStmtReader::VisitObjCStringLiteral(ObjCStringLiteral *E) { VisitExpr(E); - E->setString(cast<StringLiteral>(Reader.ReadSubStmt())); - E->setAtLoc(ReadSourceLocation(Record, Idx)); + 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 = Reader.ReadSubStmt(); - E->BoxingMethod = ReadDeclAs<ObjCMethodDecl>(Record, Idx); - E->Range = ReadSourceRange(Record, Idx); + E->SubExpr = Record.readSubStmt(); + E->BoxingMethod = ReadDeclAs<ObjCMethodDecl>(); + E->Range = ReadSourceRange(); } void ASTStmtReader::VisitObjCArrayLiteral(ObjCArrayLiteral *E) { VisitExpr(E); - unsigned NumElements = Record[Idx++]; + 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] = Reader.ReadSubExpr(); - E->ArrayWithObjectsMethod = ReadDeclAs<ObjCMethodDecl>(Record, Idx); - E->Range = ReadSourceRange(Record, Idx); + Elements[I] = Record.readSubExpr(); + E->ArrayWithObjectsMethod = ReadDeclAs<ObjCMethodDecl>(); + E->Range = ReadSourceRange(); } void ASTStmtReader::VisitObjCDictionaryLiteral(ObjCDictionaryLiteral *E) { VisitExpr(E); - unsigned NumElements = Record[Idx++]; + unsigned NumElements = Record.readInt(); assert(NumElements == E->getNumElements() && "Wrong number of elements"); - bool HasPackExpansions = Record[Idx++]; + bool HasPackExpansions = Record.readInt(); assert(HasPackExpansions == E->HasPackExpansions &&"Pack expansion mismatch"); ObjCDictionaryLiteral::KeyValuePair *KeyValues = E->getTrailingObjects<ObjCDictionaryLiteral::KeyValuePair>(); ObjCDictionaryLiteral::ExpansionData *Expansions = E->getTrailingObjects<ObjCDictionaryLiteral::ExpansionData>(); for (unsigned I = 0; I != NumElements; ++I) { - KeyValues[I].Key = Reader.ReadSubExpr(); - KeyValues[I].Value = Reader.ReadSubExpr(); + KeyValues[I].Key = Record.readSubExpr(); + KeyValues[I].Value = Record.readSubExpr(); if (HasPackExpansions) { - Expansions[I].EllipsisLoc = ReadSourceLocation(Record, Idx); - Expansions[I].NumExpansionsPlusOne = Record[Idx++]; + Expansions[I].EllipsisLoc = ReadSourceLocation(); + Expansions[I].NumExpansionsPlusOne = Record.readInt(); } } - E->DictWithObjectsMethod = ReadDeclAs<ObjCMethodDecl>(Record, Idx); - E->Range = ReadSourceRange(Record, Idx); + E->DictWithObjectsMethod = ReadDeclAs<ObjCMethodDecl>(); + E->Range = ReadSourceRange(); } void ASTStmtReader::VisitObjCEncodeExpr(ObjCEncodeExpr *E) { VisitExpr(E); - E->setEncodedTypeSourceInfo(GetTypeSourceInfo(Record, Idx)); - E->setAtLoc(ReadSourceLocation(Record, Idx)); - E->setRParenLoc(ReadSourceLocation(Record, Idx)); + E->setEncodedTypeSourceInfo(GetTypeSourceInfo()); + E->setAtLoc(ReadSourceLocation()); + E->setRParenLoc(ReadSourceLocation()); } void ASTStmtReader::VisitObjCSelectorExpr(ObjCSelectorExpr *E) { VisitExpr(E); - E->setSelector(Reader.ReadSelector(F, Record, Idx)); - E->setAtLoc(ReadSourceLocation(Record, Idx)); - E->setRParenLoc(ReadSourceLocation(Record, Idx)); + E->setSelector(Record.readSelector()); + E->setAtLoc(ReadSourceLocation()); + E->setRParenLoc(ReadSourceLocation()); } void ASTStmtReader::VisitObjCProtocolExpr(ObjCProtocolExpr *E) { VisitExpr(E); - E->setProtocol(ReadDeclAs<ObjCProtocolDecl>(Record, Idx)); - E->setAtLoc(ReadSourceLocation(Record, Idx)); - E->ProtoLoc = ReadSourceLocation(Record, Idx); - E->setRParenLoc(ReadSourceLocation(Record, Idx)); + E->setProtocol(ReadDeclAs<ObjCProtocolDecl>()); + E->setAtLoc(ReadSourceLocation()); + E->ProtoLoc = ReadSourceLocation(); + E->setRParenLoc(ReadSourceLocation()); } void ASTStmtReader::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) { VisitExpr(E); - E->setDecl(ReadDeclAs<ObjCIvarDecl>(Record, Idx)); - E->setLocation(ReadSourceLocation(Record, Idx)); - E->setOpLoc(ReadSourceLocation(Record, Idx)); - E->setBase(Reader.ReadSubExpr()); - E->setIsArrow(Record[Idx++]); - E->setIsFreeIvar(Record[Idx++]); + 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[Idx++]; - bool Implicit = Record[Idx++] != 0; + unsigned MethodRefFlags = Record.readInt(); + bool Implicit = Record.readInt() != 0; if (Implicit) { - ObjCMethodDecl *Getter = ReadDeclAs<ObjCMethodDecl>(Record, Idx); - ObjCMethodDecl *Setter = ReadDeclAs<ObjCMethodDecl>(Record, Idx); + ObjCMethodDecl *Getter = ReadDeclAs<ObjCMethodDecl>(); + ObjCMethodDecl *Setter = ReadDeclAs<ObjCMethodDecl>(); E->setImplicitProperty(Getter, Setter, MethodRefFlags); } else { - E->setExplicitProperty(ReadDeclAs<ObjCPropertyDecl>(Record, Idx), - MethodRefFlags); + E->setExplicitProperty(ReadDeclAs<ObjCPropertyDecl>(), MethodRefFlags); } - E->setLocation(ReadSourceLocation(Record, Idx)); - E->setReceiverLocation(ReadSourceLocation(Record, Idx)); - switch (Record[Idx++]) { + E->setLocation(ReadSourceLocation()); + E->setReceiverLocation(ReadSourceLocation()); + switch (Record.readInt()) { case 0: - E->setBase(Reader.ReadSubExpr()); + E->setBase(Record.readSubExpr()); break; case 1: - E->setSuperReceiver(Reader.readType(F, Record, Idx)); + E->setSuperReceiver(Record.readType()); break; case 2: - E->setClassReceiver(ReadDeclAs<ObjCInterfaceDecl>(Record, Idx)); + E->setClassReceiver(ReadDeclAs<ObjCInterfaceDecl>()); break; } } void ASTStmtReader::VisitObjCSubscriptRefExpr(ObjCSubscriptRefExpr *E) { VisitExpr(E); - E->setRBracket(ReadSourceLocation(Record, Idx)); - E->setBaseExpr(Reader.ReadSubExpr()); - E->setKeyExpr(Reader.ReadSubExpr()); - E->GetAtIndexMethodDecl = ReadDeclAs<ObjCMethodDecl>(Record, Idx); - E->SetAtIndexMethodDecl = ReadDeclAs<ObjCMethodDecl>(Record, Idx); + 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[Idx] == E->getNumArgs()); - ++Idx; - unsigned NumStoredSelLocs = Record[Idx++]; - E->SelLocsKind = Record[Idx++]; - E->setDelegateInitCall(Record[Idx++]); - E->IsImplicit = Record[Idx++]; + assert(Record.peekInt() == E->getNumArgs()); + Record.skipInts(1); + unsigned NumStoredSelLocs = Record.readInt(); + E->SelLocsKind = Record.readInt(); + E->setDelegateInitCall(Record.readInt()); + E->IsImplicit = Record.readInt(); ObjCMessageExpr::ReceiverKind Kind - = static_cast<ObjCMessageExpr::ReceiverKind>(Record[Idx++]); + = static_cast<ObjCMessageExpr::ReceiverKind>(Record.readInt()); switch (Kind) { case ObjCMessageExpr::Instance: - E->setInstanceReceiver(Reader.ReadSubExpr()); + E->setInstanceReceiver(Record.readSubExpr()); break; case ObjCMessageExpr::Class: - E->setClassReceiver(GetTypeSourceInfo(Record, Idx)); + E->setClassReceiver(GetTypeSourceInfo()); break; case ObjCMessageExpr::SuperClass: case ObjCMessageExpr::SuperInstance: { - QualType T = Reader.readType(F, Record, Idx); - SourceLocation SuperLoc = ReadSourceLocation(Record, Idx); + QualType T = Record.readType(); + SourceLocation SuperLoc = ReadSourceLocation(); E->setSuper(SuperLoc, T, Kind == ObjCMessageExpr::SuperInstance); break; } @@ -1104,90 +1085,90 @@ void ASTStmtReader::VisitObjCMessageExpr(ObjCMessageExpr *E) { assert(Kind == E->getReceiverKind()); - if (Record[Idx++]) - E->setMethodDecl(ReadDeclAs<ObjCMethodDecl>(Record, Idx)); + if (Record.readInt()) + E->setMethodDecl(ReadDeclAs<ObjCMethodDecl>()); else - E->setSelector(Reader.ReadSelector(F, Record, Idx)); + E->setSelector(Record.readSelector()); - E->LBracLoc = ReadSourceLocation(Record, Idx); - E->RBracLoc = ReadSourceLocation(Record, Idx); + E->LBracLoc = ReadSourceLocation(); + E->RBracLoc = ReadSourceLocation(); for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) - E->setArg(I, Reader.ReadSubExpr()); + E->setArg(I, Record.readSubExpr()); SourceLocation *Locs = E->getStoredSelLocs(); for (unsigned I = 0; I != NumStoredSelLocs; ++I) - Locs[I] = ReadSourceLocation(Record, Idx); + Locs[I] = ReadSourceLocation(); } void ASTStmtReader::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) { VisitStmt(S); - S->setElement(Reader.ReadSubStmt()); - S->setCollection(Reader.ReadSubExpr()); - S->setBody(Reader.ReadSubStmt()); - S->setForLoc(ReadSourceLocation(Record, Idx)); - S->setRParenLoc(ReadSourceLocation(Record, Idx)); + 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(Reader.ReadSubStmt()); - S->setCatchParamDecl(ReadDeclAs<VarDecl>(Record, Idx)); - S->setAtCatchLoc(ReadSourceLocation(Record, Idx)); - S->setRParenLoc(ReadSourceLocation(Record, Idx)); + S->setCatchBody(Record.readSubStmt()); + S->setCatchParamDecl(ReadDeclAs<VarDecl>()); + S->setAtCatchLoc(ReadSourceLocation()); + S->setRParenLoc(ReadSourceLocation()); } void ASTStmtReader::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) { VisitStmt(S); - S->setFinallyBody(Reader.ReadSubStmt()); - S->setAtFinallyLoc(ReadSourceLocation(Record, Idx)); + S->setFinallyBody(Record.readSubStmt()); + S->setAtFinallyLoc(ReadSourceLocation()); } void ASTStmtReader::VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S) { VisitStmt(S); - S->setSubStmt(Reader.ReadSubStmt()); - S->setAtLoc(ReadSourceLocation(Record, Idx)); + S->setSubStmt(Record.readSubStmt()); + S->setAtLoc(ReadSourceLocation()); } void ASTStmtReader::VisitObjCAtTryStmt(ObjCAtTryStmt *S) { VisitStmt(S); - assert(Record[Idx] == S->getNumCatchStmts()); - ++Idx; - bool HasFinally = Record[Idx++]; - S->setTryBody(Reader.ReadSubStmt()); + 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>(Reader.ReadSubStmt())); + S->setCatchStmt(I, cast_or_null<ObjCAtCatchStmt>(Record.readSubStmt())); if (HasFinally) - S->setFinallyStmt(Reader.ReadSubStmt()); - S->setAtTryLoc(ReadSourceLocation(Record, Idx)); + S->setFinallyStmt(Record.readSubStmt()); + S->setAtTryLoc(ReadSourceLocation()); } void ASTStmtReader::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) { VisitStmt(S); - S->setSynchExpr(Reader.ReadSubStmt()); - S->setSynchBody(Reader.ReadSubStmt()); - S->setAtSynchronizedLoc(ReadSourceLocation(Record, Idx)); + S->setSynchExpr(Record.readSubStmt()); + S->setSynchBody(Record.readSubStmt()); + S->setAtSynchronizedLoc(ReadSourceLocation()); } void ASTStmtReader::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) { VisitStmt(S); - S->setThrowExpr(Reader.ReadSubStmt()); - S->setThrowLoc(ReadSourceLocation(Record, Idx)); + S->setThrowExpr(Record.readSubStmt()); + S->setThrowLoc(ReadSourceLocation()); } void ASTStmtReader::VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) { VisitExpr(E); - E->setValue(Record[Idx++]); - E->setLocation(ReadSourceLocation(Record, Idx)); + E->setValue(Record.readInt()); + E->setLocation(ReadSourceLocation()); } void ASTStmtReader::VisitObjCAvailabilityCheckExpr(ObjCAvailabilityCheckExpr *E) { VisitExpr(E); - SourceRange R = Reader.ReadSourceRange(F, Record, Idx); + SourceRange R = Record.readSourceRange(); E->AtLoc = R.getBegin(); E->RParen = R.getEnd(); - E->VersionToCheck = Reader.ReadVersionTuple(Record, Idx); + E->VersionToCheck = Record.readVersionTuple(); } //===----------------------------------------------------------------------===// @@ -1196,125 +1177,113 @@ void ASTStmtReader::VisitObjCAvailabilityCheckExpr(ObjCAvailabilityCheckExpr *E) void ASTStmtReader::VisitCXXCatchStmt(CXXCatchStmt *S) { VisitStmt(S); - S->CatchLoc = ReadSourceLocation(Record, Idx); - S->ExceptionDecl = ReadDeclAs<VarDecl>(Record, Idx); - S->HandlerBlock = Reader.ReadSubStmt(); + S->CatchLoc = ReadSourceLocation(); + S->ExceptionDecl = ReadDeclAs<VarDecl>(); + S->HandlerBlock = Record.readSubStmt(); } void ASTStmtReader::VisitCXXTryStmt(CXXTryStmt *S) { VisitStmt(S); - assert(Record[Idx] == S->getNumHandlers() && "NumStmtFields is wrong ?"); - ++Idx; - S->TryLoc = ReadSourceLocation(Record, Idx); - S->getStmts()[0] = Reader.ReadSubStmt(); + 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] = Reader.ReadSubStmt(); + S->getStmts()[i + 1] = Record.readSubStmt(); } void ASTStmtReader::VisitCXXForRangeStmt(CXXForRangeStmt *S) { VisitStmt(S); - S->ForLoc = ReadSourceLocation(Record, Idx); - S->CoawaitLoc = ReadSourceLocation(Record, Idx); - S->ColonLoc = ReadSourceLocation(Record, Idx); - S->RParenLoc = ReadSourceLocation(Record, Idx); - S->setRangeStmt(Reader.ReadSubStmt()); - S->setBeginStmt(Reader.ReadSubStmt()); - S->setEndStmt(Reader.ReadSubStmt()); - S->setCond(Reader.ReadSubExpr()); - S->setInc(Reader.ReadSubExpr()); - S->setLoopVarStmt(Reader.ReadSubStmt()); - S->setBody(Reader.ReadSubStmt()); + S->ForLoc = ReadSourceLocation(); + S->CoawaitLoc = ReadSourceLocation(); + S->ColonLoc = ReadSourceLocation(); + S->RParenLoc = ReadSourceLocation(); + 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(Record, Idx); - S->IsIfExists = Record[Idx++]; - S->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx); - ReadDeclarationNameInfo(S->NameInfo, Record, Idx); - S->SubStmt = Reader.ReadSubStmt(); + S->KeywordLoc = ReadSourceLocation(); + S->IsIfExists = Record.readInt(); + S->QualifierLoc = Record.readNestedNameSpecifierLoc(); + ReadDeclarationNameInfo(S->NameInfo); + S->SubStmt = Record.readSubStmt(); } void ASTStmtReader::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) { VisitCallExpr(E); - E->Operator = (OverloadedOperatorKind)Record[Idx++]; - E->Range = Reader.ReadSourceRange(F, Record, Idx); - E->setFPContractable((bool)Record[Idx++]); + E->Operator = (OverloadedOperatorKind)Record.readInt(); + E->Range = Record.readSourceRange(); + E->setFPContractable((bool)Record.readInt()); } void ASTStmtReader::VisitCXXConstructExpr(CXXConstructExpr *E) { VisitExpr(E); - E->NumArgs = Record[Idx++]; + E->NumArgs = Record.readInt(); if (E->NumArgs) - E->Args = new (Reader.getContext()) Stmt*[E->NumArgs]; + E->Args = new (Record.getContext()) Stmt*[E->NumArgs]; for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) - E->setArg(I, Reader.ReadSubExpr()); - E->setConstructor(ReadDeclAs<CXXConstructorDecl>(Record, Idx)); - E->setLocation(ReadSourceLocation(Record, Idx)); - E->setElidable(Record[Idx++]); - E->setHadMultipleCandidates(Record[Idx++]); - E->setListInitialization(Record[Idx++]); - E->setStdInitListInitialization(Record[Idx++]); - E->setRequiresZeroInitialization(Record[Idx++]); - E->setConstructionKind((CXXConstructExpr::ConstructionKind)Record[Idx++]); - E->ParenOrBraceRange = ReadSourceRange(Record, Idx); + E->setArg(I, Record.readSubExpr()); + E->setConstructor(ReadDeclAs<CXXConstructorDecl>()); + E->setLocation(ReadSourceLocation()); + E->setElidable(Record.readInt()); + E->setHadMultipleCandidates(Record.readInt()); + E->setListInitialization(Record.readInt()); + E->setStdInitListInitialization(Record.readInt()); + E->setRequiresZeroInitialization(Record.readInt()); + E->setConstructionKind((CXXConstructExpr::ConstructionKind)Record.readInt()); + E->ParenOrBraceRange = ReadSourceRange(); } void ASTStmtReader::VisitCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr *E) { VisitExpr(E); - E->Constructor = ReadDeclAs<CXXConstructorDecl>(Record, Idx); - E->Loc = ReadSourceLocation(Record, Idx); - E->ConstructsVirtualBase = Record[Idx++]; - E->InheritedFromVirtualBase = Record[Idx++]; + E->Constructor = ReadDeclAs<CXXConstructorDecl>(); + E->Loc = ReadSourceLocation(); + E->ConstructsVirtualBase = Record.readInt(); + E->InheritedFromVirtualBase = Record.readInt(); } void ASTStmtReader::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) { VisitCXXConstructExpr(E); - E->Type = GetTypeSourceInfo(Record, Idx); + E->Type = GetTypeSourceInfo(); } void ASTStmtReader::VisitLambdaExpr(LambdaExpr *E) { VisitExpr(E); - unsigned NumCaptures = Record[Idx++]; + unsigned NumCaptures = Record.readInt(); assert(NumCaptures == E->NumCaptures);(void)NumCaptures; - unsigned NumArrayIndexVars = Record[Idx++]; - E->IntroducerRange = ReadSourceRange(Record, Idx); - E->CaptureDefault = static_cast<LambdaCaptureDefault>(Record[Idx++]); - E->CaptureDefaultLoc = ReadSourceLocation(Record, Idx); - E->ExplicitParams = Record[Idx++]; - E->ExplicitResultType = Record[Idx++]; - E->ClosingBrace = ReadSourceLocation(Record, Idx); - + E->IntroducerRange = ReadSourceRange(); + E->CaptureDefault = static_cast<LambdaCaptureDefault>(Record.readInt()); + E->CaptureDefaultLoc = ReadSourceLocation(); + E->ExplicitParams = Record.readInt(); + E->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 = Reader.ReadSubExpr(); - - // Read array capture index variables. - if (NumArrayIndexVars > 0) { - unsigned *ArrayIndexStarts = E->getArrayIndexStarts(); - for (unsigned I = 0; I != NumCaptures + 1; ++I) - ArrayIndexStarts[I] = Record[Idx++]; - - VarDecl **ArrayIndexVars = E->getArrayIndexVars(); - for (unsigned I = 0; I != NumArrayIndexVars; ++I) - ArrayIndexVars[I] = ReadDeclAs<VarDecl>(Record, Idx); - } + *C = Record.readSubExpr(); } void ASTStmtReader::VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) { VisitExpr(E); - E->SubExpr = Reader.ReadSubExpr(); + E->SubExpr = Record.readSubExpr(); } void ASTStmtReader::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) { VisitExplicitCastExpr(E); - SourceRange R = ReadSourceRange(Record, Idx); + SourceRange R = ReadSourceRange(); E->Loc = R.getBegin(); E->RParenLoc = R.getEnd(); - R = ReadSourceRange(Record, Idx); + R = ReadSourceRange(); E->AngleBrackets = R; } @@ -1336,342 +1305,345 @@ void ASTStmtReader::VisitCXXConstCastExpr(CXXConstCastExpr *E) { void ASTStmtReader::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) { VisitExplicitCastExpr(E); - E->setLParenLoc(ReadSourceLocation(Record, Idx)); - E->setRParenLoc(ReadSourceLocation(Record, Idx)); + E->setLParenLoc(ReadSourceLocation()); + E->setRParenLoc(ReadSourceLocation()); } void ASTStmtReader::VisitUserDefinedLiteral(UserDefinedLiteral *E) { VisitCallExpr(E); - E->UDSuffixLoc = ReadSourceLocation(Record, Idx); + E->UDSuffixLoc = ReadSourceLocation(); } void ASTStmtReader::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) { VisitExpr(E); - E->setValue(Record[Idx++]); - E->setLocation(ReadSourceLocation(Record, Idx)); + E->setValue(Record.readInt()); + E->setLocation(ReadSourceLocation()); } void ASTStmtReader::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) { VisitExpr(E); - E->setLocation(ReadSourceLocation(Record, Idx)); + E->setLocation(ReadSourceLocation()); } void ASTStmtReader::VisitCXXTypeidExpr(CXXTypeidExpr *E) { VisitExpr(E); - E->setSourceRange(ReadSourceRange(Record, Idx)); + E->setSourceRange(ReadSourceRange()); if (E->isTypeOperand()) { // typeid(int) E->setTypeOperandSourceInfo( - GetTypeSourceInfo(Record, Idx)); + GetTypeSourceInfo()); return; } - + // typeid(42+2) - E->setExprOperand(Reader.ReadSubExpr()); + E->setExprOperand(Record.readSubExpr()); } void ASTStmtReader::VisitCXXThisExpr(CXXThisExpr *E) { VisitExpr(E); - E->setLocation(ReadSourceLocation(Record, Idx)); - E->setImplicit(Record[Idx++]); + E->setLocation(ReadSourceLocation()); + E->setImplicit(Record.readInt()); } void ASTStmtReader::VisitCXXThrowExpr(CXXThrowExpr *E) { VisitExpr(E); - E->ThrowLoc = ReadSourceLocation(Record, Idx); - E->Op = Reader.ReadSubExpr(); - E->IsThrownVariableInScope = Record[Idx++]; + E->ThrowLoc = ReadSourceLocation(); + E->Op = Record.readSubExpr(); + E->IsThrownVariableInScope = Record.readInt(); } void ASTStmtReader::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) { VisitExpr(E); - E->Param = ReadDeclAs<ParmVarDecl>(Record, Idx); - E->Loc = ReadSourceLocation(Record, Idx); + E->Param = ReadDeclAs<ParmVarDecl>(); + E->Loc = ReadSourceLocation(); } void ASTStmtReader::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) { VisitExpr(E); - E->Field = ReadDeclAs<FieldDecl>(Record, Idx); - E->Loc = ReadSourceLocation(Record, Idx); + E->Field = ReadDeclAs<FieldDecl>(); + E->Loc = ReadSourceLocation(); } void ASTStmtReader::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) { VisitExpr(E); - E->setTemporary(Reader.ReadCXXTemporary(F, Record, Idx)); - E->setSubExpr(Reader.ReadSubExpr()); + E->setTemporary(Record.readCXXTemporary()); + E->setSubExpr(Record.readSubExpr()); } void ASTStmtReader::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) { VisitExpr(E); - E->TypeInfo = GetTypeSourceInfo(Record, Idx); - E->RParenLoc = ReadSourceLocation(Record, Idx); + E->TypeInfo = GetTypeSourceInfo(); + E->RParenLoc = ReadSourceLocation(); } void ASTStmtReader::VisitCXXNewExpr(CXXNewExpr *E) { VisitExpr(E); - E->GlobalNew = Record[Idx++]; - bool isArray = Record[Idx++]; - E->UsualArrayDeleteWantsSize = Record[Idx++]; - unsigned NumPlacementArgs = Record[Idx++]; - E->StoredInitializationStyle = Record[Idx++]; - E->setOperatorNew(ReadDeclAs<FunctionDecl>(Record, Idx)); - E->setOperatorDelete(ReadDeclAs<FunctionDecl>(Record, Idx)); - E->AllocatedTypeInfo = GetTypeSourceInfo(Record, Idx); - E->TypeIdParens = ReadSourceRange(Record, Idx); - E->Range = ReadSourceRange(Record, Idx); - E->DirectInitRange = ReadSourceRange(Record, Idx); - - E->AllocateArgsArray(Reader.getContext(), isArray, NumPlacementArgs, + E->GlobalNew = Record.readInt(); + bool isArray = Record.readInt(); + E->PassAlignment = Record.readInt(); + E->UsualArrayDeleteWantsSize = Record.readInt(); + unsigned NumPlacementArgs = Record.readInt(); + E->StoredInitializationStyle = Record.readInt(); + E->setOperatorNew(ReadDeclAs<FunctionDecl>()); + E->setOperatorDelete(ReadDeclAs<FunctionDecl>()); + E->AllocatedTypeInfo = GetTypeSourceInfo(); + E->TypeIdParens = ReadSourceRange(); + E->Range = ReadSourceRange(); + E->DirectInitRange = ReadSourceRange(); + + E->AllocateArgsArray(Record.getContext(), isArray, NumPlacementArgs, E->StoredInitializationStyle != 0); // Install all the subexpressions. for (CXXNewExpr::raw_arg_iterator I = E->raw_arg_begin(),e = E->raw_arg_end(); I != e; ++I) - *I = Reader.ReadSubStmt(); + *I = Record.readSubStmt(); } void ASTStmtReader::VisitCXXDeleteExpr(CXXDeleteExpr *E) { VisitExpr(E); - E->GlobalDelete = Record[Idx++]; - E->ArrayForm = Record[Idx++]; - E->ArrayFormAsWritten = Record[Idx++]; - E->UsualArrayDeleteWantsSize = Record[Idx++]; - E->OperatorDelete = ReadDeclAs<FunctionDecl>(Record, Idx); - E->Argument = Reader.ReadSubExpr(); - E->Loc = ReadSourceLocation(Record, Idx); + E->GlobalDelete = Record.readInt(); + E->ArrayForm = Record.readInt(); + E->ArrayFormAsWritten = Record.readInt(); + E->UsualArrayDeleteWantsSize = Record.readInt(); + E->OperatorDelete = ReadDeclAs<FunctionDecl>(); + E->Argument = Record.readSubExpr(); + E->Loc = ReadSourceLocation(); } void ASTStmtReader::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) { VisitExpr(E); - E->Base = Reader.ReadSubExpr(); - E->IsArrow = Record[Idx++]; - E->OperatorLoc = ReadSourceLocation(Record, Idx); - E->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx); - E->ScopeType = GetTypeSourceInfo(Record, Idx); - E->ColonColonLoc = ReadSourceLocation(Record, Idx); - E->TildeLoc = ReadSourceLocation(Record, Idx); - - IdentifierInfo *II = Reader.GetIdentifierInfo(F, Record, Idx); + E->Base = Record.readSubExpr(); + E->IsArrow = Record.readInt(); + E->OperatorLoc = ReadSourceLocation(); + E->QualifierLoc = Record.readNestedNameSpecifierLoc(); + E->ScopeType = GetTypeSourceInfo(); + E->ColonColonLoc = ReadSourceLocation(); + E->TildeLoc = ReadSourceLocation(); + + IdentifierInfo *II = Record.getIdentifierInfo(); if (II) - E->setDestroyedType(II, ReadSourceLocation(Record, Idx)); + E->setDestroyedType(II, ReadSourceLocation()); else - E->setDestroyedType(GetTypeSourceInfo(Record, Idx)); + E->setDestroyedType(GetTypeSourceInfo()); } void ASTStmtReader::VisitExprWithCleanups(ExprWithCleanups *E) { VisitExpr(E); - unsigned NumObjects = Record[Idx++]; + unsigned NumObjects = Record.readInt(); assert(NumObjects == E->getNumObjects()); for (unsigned i = 0; i != NumObjects; ++i) E->getTrailingObjects<BlockDecl *>()[i] = - ReadDeclAs<BlockDecl>(Record, Idx); + ReadDeclAs<BlockDecl>(); - E->ExprWithCleanupsBits.CleanupsHaveSideEffects = Record[Idx++]; - E->SubExpr = Reader.ReadSubExpr(); + E->ExprWithCleanupsBits.CleanupsHaveSideEffects = Record.readInt(); + E->SubExpr = Record.readSubExpr(); } void ASTStmtReader::VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E){ VisitExpr(E); - if (Record[Idx++]) // HasTemplateKWAndArgsInfo + if (Record.readInt()) // HasTemplateKWAndArgsInfo ReadTemplateKWAndArgsInfo( *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(), E->getTrailingObjects<TemplateArgumentLoc>(), - /*NumTemplateArgs=*/Record[Idx++]); + /*NumTemplateArgs=*/Record.readInt()); - E->Base = Reader.ReadSubExpr(); - E->BaseType = Reader.readType(F, Record, Idx); - E->IsArrow = Record[Idx++]; - E->OperatorLoc = ReadSourceLocation(Record, Idx); - E->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx); - E->FirstQualifierFoundInScope = ReadDeclAs<NamedDecl>(Record, Idx); - ReadDeclarationNameInfo(E->MemberNameInfo, Record, Idx); + E->Base = Record.readSubExpr(); + E->BaseType = Record.readType(); + E->IsArrow = Record.readInt(); + E->OperatorLoc = ReadSourceLocation(); + E->QualifierLoc = Record.readNestedNameSpecifierLoc(); + E->FirstQualifierFoundInScope = ReadDeclAs<NamedDecl>(); + ReadDeclarationNameInfo(E->MemberNameInfo); } void ASTStmtReader::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) { VisitExpr(E); - if (Record[Idx++]) // HasTemplateKWAndArgsInfo + if (Record.readInt()) // HasTemplateKWAndArgsInfo ReadTemplateKWAndArgsInfo( *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(), E->getTrailingObjects<TemplateArgumentLoc>(), - /*NumTemplateArgs=*/Record[Idx++]); + /*NumTemplateArgs=*/Record.readInt()); - E->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx); - ReadDeclarationNameInfo(E->NameInfo, Record, Idx); + E->QualifierLoc = Record.readNestedNameSpecifierLoc(); + ReadDeclarationNameInfo(E->NameInfo); } void ASTStmtReader::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) { VisitExpr(E); - assert(Record[Idx] == E->arg_size() && "Read wrong record during creation ?"); - ++Idx; // NumArgs; + assert(Record.peekInt() == E->arg_size() && + "Read wrong record during creation ?"); + Record.skipInts(1); for (unsigned I = 0, N = E->arg_size(); I != N; ++I) - E->setArg(I, Reader.ReadSubExpr()); - E->Type = GetTypeSourceInfo(Record, Idx); - E->setLParenLoc(ReadSourceLocation(Record, Idx)); - E->setRParenLoc(ReadSourceLocation(Record, Idx)); + E->setArg(I, Record.readSubExpr()); + E->Type = GetTypeSourceInfo(); + E->setLParenLoc(ReadSourceLocation()); + E->setRParenLoc(ReadSourceLocation()); } void ASTStmtReader::VisitOverloadExpr(OverloadExpr *E) { VisitExpr(E); - if (Record[Idx++]) // HasTemplateKWAndArgsInfo + if (Record.readInt()) // HasTemplateKWAndArgsInfo ReadTemplateKWAndArgsInfo(*E->getTrailingASTTemplateKWAndArgsInfo(), E->getTrailingTemplateArgumentLoc(), - /*NumTemplateArgs=*/Record[Idx++]); + /*NumTemplateArgs=*/Record.readInt()); - unsigned NumDecls = Record[Idx++]; + unsigned NumDecls = Record.readInt(); UnresolvedSet<8> Decls; for (unsigned i = 0; i != NumDecls; ++i) { - NamedDecl *D = ReadDeclAs<NamedDecl>(Record, Idx); - AccessSpecifier AS = (AccessSpecifier)Record[Idx++]; + NamedDecl *D = ReadDeclAs<NamedDecl>(); + AccessSpecifier AS = (AccessSpecifier)Record.readInt(); Decls.addDecl(D, AS); } - E->initializeResults(Reader.getContext(), Decls.begin(), Decls.end()); + E->initializeResults(Record.getContext(), Decls.begin(), Decls.end()); - ReadDeclarationNameInfo(E->NameInfo, Record, Idx); - E->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx); + ReadDeclarationNameInfo(E->NameInfo); + E->QualifierLoc = Record.readNestedNameSpecifierLoc(); } void ASTStmtReader::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) { VisitOverloadExpr(E); - E->IsArrow = Record[Idx++]; - E->HasUnresolvedUsing = Record[Idx++]; - E->Base = Reader.ReadSubExpr(); - E->BaseType = Reader.readType(F, Record, Idx); - E->OperatorLoc = ReadSourceLocation(Record, Idx); + E->IsArrow = Record.readInt(); + E->HasUnresolvedUsing = Record.readInt(); + E->Base = Record.readSubExpr(); + E->BaseType = Record.readType(); + E->OperatorLoc = ReadSourceLocation(); } void ASTStmtReader::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) { VisitOverloadExpr(E); - E->RequiresADL = Record[Idx++]; - E->Overloaded = Record[Idx++]; - E->NamingClass = ReadDeclAs<CXXRecordDecl>(Record, Idx); + E->RequiresADL = Record.readInt(); + E->Overloaded = Record.readInt(); + E->NamingClass = ReadDeclAs<CXXRecordDecl>(); } void ASTStmtReader::VisitTypeTraitExpr(TypeTraitExpr *E) { VisitExpr(E); - E->TypeTraitExprBits.NumArgs = Record[Idx++]; - E->TypeTraitExprBits.Kind = Record[Idx++]; - E->TypeTraitExprBits.Value = Record[Idx++]; - SourceRange Range = ReadSourceRange(Record, Idx); + 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(); TypeSourceInfo **Args = E->getTrailingObjects<TypeSourceInfo *>(); for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) - Args[I] = GetTypeSourceInfo(Record, Idx); + Args[I] = GetTypeSourceInfo(); } void ASTStmtReader::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) { VisitExpr(E); - E->ATT = (ArrayTypeTrait)Record[Idx++]; - E->Value = (unsigned int)Record[Idx++]; - SourceRange Range = ReadSourceRange(Record, Idx); + E->ATT = (ArrayTypeTrait)Record.readInt(); + E->Value = (unsigned int)Record.readInt(); + SourceRange Range = ReadSourceRange(); E->Loc = Range.getBegin(); E->RParen = Range.getEnd(); - E->QueriedType = GetTypeSourceInfo(Record, Idx); + E->QueriedType = GetTypeSourceInfo(); + E->Dimension = Record.readSubExpr(); } void ASTStmtReader::VisitExpressionTraitExpr(ExpressionTraitExpr *E) { VisitExpr(E); - E->ET = (ExpressionTrait)Record[Idx++]; - E->Value = (bool)Record[Idx++]; - SourceRange Range = ReadSourceRange(Record, Idx); - E->QueriedExpression = Reader.ReadSubExpr(); + 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->Value = (bool)Record[Idx++]; - E->Range = ReadSourceRange(Record, Idx); - E->Operand = Reader.ReadSubExpr(); + E->Value = (bool)Record.readInt(); + E->Range = ReadSourceRange(); + E->Operand = Record.readSubExpr(); } void ASTStmtReader::VisitPackExpansionExpr(PackExpansionExpr *E) { VisitExpr(E); - E->EllipsisLoc = ReadSourceLocation(Record, Idx); - E->NumExpansions = Record[Idx++]; - E->Pattern = Reader.ReadSubExpr(); + E->EllipsisLoc = ReadSourceLocation(); + E->NumExpansions = Record.readInt(); + E->Pattern = Record.readSubExpr(); } void ASTStmtReader::VisitSizeOfPackExpr(SizeOfPackExpr *E) { VisitExpr(E); - unsigned NumPartialArgs = Record[Idx++]; - E->OperatorLoc = ReadSourceLocation(Record, Idx); - E->PackLoc = ReadSourceLocation(Record, Idx); - E->RParenLoc = ReadSourceLocation(Record, Idx); - E->Pack = Reader.ReadDeclAs<NamedDecl>(F, Record, Idx); + 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(Reader.ReadTemplateArgument(F, Record, Idx)); + new (I) TemplateArgument(Record.readTemplateArgument()); } else if (!E->isValueDependent()) { - E->Length = Record[Idx++]; + E->Length = Record.readInt(); } } void ASTStmtReader::VisitSubstNonTypeTemplateParmExpr( SubstNonTypeTemplateParmExpr *E) { VisitExpr(E); - E->Param = ReadDeclAs<NonTypeTemplateParmDecl>(Record, Idx); - E->NameLoc = ReadSourceLocation(Record, Idx); - E->Replacement = Reader.ReadSubExpr(); + E->Param = ReadDeclAs<NonTypeTemplateParmDecl>(); + E->NameLoc = ReadSourceLocation(); + E->Replacement = Record.readSubExpr(); } void ASTStmtReader::VisitSubstNonTypeTemplateParmPackExpr( SubstNonTypeTemplateParmPackExpr *E) { VisitExpr(E); - E->Param = ReadDeclAs<NonTypeTemplateParmDecl>(Record, Idx); - TemplateArgument ArgPack = Reader.ReadTemplateArgument(F, Record, Idx); + 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(Record, Idx); + E->NameLoc = ReadSourceLocation(); } void ASTStmtReader::VisitFunctionParmPackExpr(FunctionParmPackExpr *E) { VisitExpr(E); - E->NumParameters = Record[Idx++]; - E->ParamPack = ReadDeclAs<ParmVarDecl>(Record, Idx); - E->NameLoc = ReadSourceLocation(Record, Idx); + E->NumParameters = Record.readInt(); + E->ParamPack = ReadDeclAs<ParmVarDecl>(); + E->NameLoc = ReadSourceLocation(); ParmVarDecl **Parms = E->getTrailingObjects<ParmVarDecl *>(); for (unsigned i = 0, n = E->NumParameters; i != n; ++i) - Parms[i] = ReadDeclAs<ParmVarDecl>(Record, Idx); + Parms[i] = ReadDeclAs<ParmVarDecl>(); } void ASTStmtReader::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) { VisitExpr(E); - E->State = Reader.ReadSubExpr(); - auto VD = ReadDeclAs<ValueDecl>(Record, Idx); - unsigned ManglingNumber = Record[Idx++]; + E->State = Record.readSubExpr(); + auto VD = ReadDeclAs<ValueDecl>(); + unsigned ManglingNumber = Record.readInt(); E->setExtendingDecl(VD, ManglingNumber); } void ASTStmtReader::VisitCXXFoldExpr(CXXFoldExpr *E) { VisitExpr(E); - E->LParenLoc = ReadSourceLocation(Record, Idx); - E->EllipsisLoc = ReadSourceLocation(Record, Idx); - E->RParenLoc = ReadSourceLocation(Record, Idx); - E->SubExprs[0] = Reader.ReadSubExpr(); - E->SubExprs[1] = Reader.ReadSubExpr(); - E->Opcode = (BinaryOperatorKind)Record[Idx++]; + E->LParenLoc = ReadSourceLocation(); + E->EllipsisLoc = ReadSourceLocation(); + E->RParenLoc = ReadSourceLocation(); + E->SubExprs[0] = Record.readSubExpr(); + E->SubExprs[1] = Record.readSubExpr(); + E->Opcode = (BinaryOperatorKind)Record.readInt(); } void ASTStmtReader::VisitOpaqueValueExpr(OpaqueValueExpr *E) { VisitExpr(E); - E->SourceExpr = Reader.ReadSubExpr(); - E->Loc = ReadSourceLocation(Record, Idx); + E->SourceExpr = Record.readSubExpr(); + E->Loc = ReadSourceLocation(); } void ASTStmtReader::VisitTypoExpr(TypoExpr *E) { @@ -1683,59 +1655,59 @@ void ASTStmtReader::VisitTypoExpr(TypoExpr *E) { //===----------------------------------------------------------------------===// void ASTStmtReader::VisitMSPropertyRefExpr(MSPropertyRefExpr *E) { VisitExpr(E); - E->IsArrow = (Record[Idx++] != 0); - E->BaseExpr = Reader.ReadSubExpr(); - E->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx); - E->MemberLoc = ReadSourceLocation(Record, Idx); - E->TheDecl = ReadDeclAs<MSPropertyDecl>(Record, Idx); + 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(Reader.ReadSubExpr()); - E->setIdx(Reader.ReadSubExpr()); - E->setRBracketLoc(ReadSourceLocation(Record, Idx)); + E->setBase(Record.readSubExpr()); + E->setIdx(Record.readSubExpr()); + E->setRBracketLoc(ReadSourceLocation()); } void ASTStmtReader::VisitCXXUuidofExpr(CXXUuidofExpr *E) { VisitExpr(E); - E->setSourceRange(ReadSourceRange(Record, Idx)); - std::string UuidStr = ReadString(Record, Idx); - E->setUuidStr(StringRef(UuidStr).copy(Reader.getContext())); + E->setSourceRange(ReadSourceRange()); + std::string UuidStr = ReadString(); + E->setUuidStr(StringRef(UuidStr).copy(Record.getContext())); if (E->isTypeOperand()) { // __uuidof(ComType) E->setTypeOperandSourceInfo( - GetTypeSourceInfo(Record, Idx)); + GetTypeSourceInfo()); return; } - + // __uuidof(expr) - E->setExprOperand(Reader.ReadSubExpr()); + E->setExprOperand(Record.readSubExpr()); } void ASTStmtReader::VisitSEHLeaveStmt(SEHLeaveStmt *S) { VisitStmt(S); - S->setLeaveLoc(ReadSourceLocation(Record, Idx)); + S->setLeaveLoc(ReadSourceLocation()); } void ASTStmtReader::VisitSEHExceptStmt(SEHExceptStmt *S) { VisitStmt(S); - S->Loc = ReadSourceLocation(Record, Idx); - S->Children[SEHExceptStmt::FILTER_EXPR] = Reader.ReadSubStmt(); - S->Children[SEHExceptStmt::BLOCK] = Reader.ReadSubStmt(); + 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(Record, Idx); - S->Block = Reader.ReadSubStmt(); + S->Loc = ReadSourceLocation(); + S->Block = Record.readSubStmt(); } void ASTStmtReader::VisitSEHTryStmt(SEHTryStmt *S) { VisitStmt(S); - S->IsCXXTry = Record[Idx++]; - S->TryLoc = ReadSourceLocation(Record, Idx); - S->Children[SEHTryStmt::TRY] = Reader.ReadSubStmt(); - S->Children[SEHTryStmt::HANDLER] = Reader.ReadSubStmt(); + S->IsCXXTry = Record.readInt(); + S->TryLoc = ReadSourceLocation(); + S->Children[SEHTryStmt::TRY] = Record.readSubStmt(); + S->Children[SEHTryStmt::HANDLER] = Record.readSubStmt(); } //===----------------------------------------------------------------------===// @@ -1744,7 +1716,7 @@ void ASTStmtReader::VisitSEHTryStmt(SEHTryStmt *S) { void ASTStmtReader::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *E) { VisitCallExpr(E); - E->setConfig(cast<CallExpr>(Reader.ReadSubExpr())); + E->setConfig(cast<CallExpr>(Record.readSubExpr())); } //===----------------------------------------------------------------------===// @@ -1752,9 +1724,9 @@ void ASTStmtReader::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *E) { //===----------------------------------------------------------------------===// void ASTStmtReader::VisitAsTypeExpr(AsTypeExpr *E) { VisitExpr(E); - E->BuiltinLoc = ReadSourceLocation(Record, Idx); - E->RParenLoc = ReadSourceLocation(Record, Idx); - E->SrcExpr = Reader.ReadSubExpr(); + E->BuiltinLoc = ReadSourceLocation(); + E->RParenLoc = ReadSourceLocation(); + E->SrcExpr = Record.readSubExpr(); } //===----------------------------------------------------------------------===// @@ -1765,12 +1737,9 @@ namespace clang { class OMPClauseReader : public OMPClauseVisitor<OMPClauseReader> { ASTStmtReader *Reader; ASTContext &Context; - const ASTReader::RecordData &Record; - unsigned &Idx; public: - OMPClauseReader(ASTStmtReader *R, ASTContext &C, - const ASTReader::RecordData &Record, unsigned &Idx) - : Reader(R), Context(C), Record(Record), Idx(Idx) { } + OMPClauseReader(ASTStmtReader *R, ASTRecordReader &Record) + : Reader(R), Context(Record.getContext()) {} #define OPENMP_CLAUSE(Name, Class) void Visit##Class(Class *C); #include "clang/Basic/OpenMPKinds.def" OMPClause *readClause(); @@ -1781,7 +1750,7 @@ public: OMPClause *OMPClauseReader::readClause() { OMPClause *C; - switch (Record[Idx++]) { + switch (Reader->Record.readInt()) { case OMPC_if: C = new (Context) OMPIfClause(); break; @@ -1846,46 +1815,46 @@ OMPClause *OMPClauseReader::readClause() { C = new (Context) OMPNogroupClause(); break; case OMPC_private: - C = OMPPrivateClause::CreateEmpty(Context, Record[Idx++]); + C = OMPPrivateClause::CreateEmpty(Context, Reader->Record.readInt()); break; case OMPC_firstprivate: - C = OMPFirstprivateClause::CreateEmpty(Context, Record[Idx++]); + C = OMPFirstprivateClause::CreateEmpty(Context, Reader->Record.readInt()); break; case OMPC_lastprivate: - C = OMPLastprivateClause::CreateEmpty(Context, Record[Idx++]); + C = OMPLastprivateClause::CreateEmpty(Context, Reader->Record.readInt()); break; case OMPC_shared: - C = OMPSharedClause::CreateEmpty(Context, Record[Idx++]); + C = OMPSharedClause::CreateEmpty(Context, Reader->Record.readInt()); break; case OMPC_reduction: - C = OMPReductionClause::CreateEmpty(Context, Record[Idx++]); + C = OMPReductionClause::CreateEmpty(Context, Reader->Record.readInt()); break; case OMPC_linear: - C = OMPLinearClause::CreateEmpty(Context, Record[Idx++]); + C = OMPLinearClause::CreateEmpty(Context, Reader->Record.readInt()); break; case OMPC_aligned: - C = OMPAlignedClause::CreateEmpty(Context, Record[Idx++]); + C = OMPAlignedClause::CreateEmpty(Context, Reader->Record.readInt()); break; case OMPC_copyin: - C = OMPCopyinClause::CreateEmpty(Context, Record[Idx++]); + C = OMPCopyinClause::CreateEmpty(Context, Reader->Record.readInt()); break; case OMPC_copyprivate: - C = OMPCopyprivateClause::CreateEmpty(Context, Record[Idx++]); + C = OMPCopyprivateClause::CreateEmpty(Context, Reader->Record.readInt()); break; case OMPC_flush: - C = OMPFlushClause::CreateEmpty(Context, Record[Idx++]); + C = OMPFlushClause::CreateEmpty(Context, Reader->Record.readInt()); break; case OMPC_depend: - C = OMPDependClause::CreateEmpty(Context, Record[Idx++]); + C = OMPDependClause::CreateEmpty(Context, Reader->Record.readInt()); break; case OMPC_device: C = new (Context) OMPDeviceClause(); break; case OMPC_map: { - unsigned NumVars = Record[Idx++]; - unsigned NumDeclarations = Record[Idx++]; - unsigned NumLists = Record[Idx++]; - unsigned NumComponents = Record[Idx++]; + unsigned NumVars = Reader->Record.readInt(); + unsigned NumDeclarations = Reader->Record.readInt(); + unsigned NumLists = Reader->Record.readInt(); + unsigned NumComponents = Reader->Record.readInt(); C = OMPMapClause::CreateEmpty(Context, NumVars, NumDeclarations, NumLists, NumComponents); break; @@ -1915,112 +1884,124 @@ OMPClause *OMPClauseReader::readClause() { C = new (Context) OMPDefaultmapClause(); break; case OMPC_to: { - unsigned NumVars = Record[Idx++]; - unsigned NumDeclarations = Record[Idx++]; - unsigned NumLists = Record[Idx++]; - unsigned NumComponents = Record[Idx++]; + unsigned NumVars = Reader->Record.readInt(); + unsigned NumDeclarations = Reader->Record.readInt(); + unsigned NumLists = Reader->Record.readInt(); + unsigned NumComponents = Reader->Record.readInt(); C = OMPToClause::CreateEmpty(Context, NumVars, NumDeclarations, NumLists, NumComponents); break; } case OMPC_from: { - unsigned NumVars = Record[Idx++]; - unsigned NumDeclarations = Record[Idx++]; - unsigned NumLists = Record[Idx++]; - unsigned NumComponents = Record[Idx++]; + unsigned NumVars = Reader->Record.readInt(); + unsigned NumDeclarations = Reader->Record.readInt(); + unsigned NumLists = Reader->Record.readInt(); + unsigned NumComponents = Reader->Record.readInt(); C = OMPFromClause::CreateEmpty(Context, NumVars, NumDeclarations, NumLists, NumComponents); break; } - case OMPC_use_device_ptr: - C = OMPUseDevicePtrClause::CreateEmpty(Context, Record[Idx++]); + case OMPC_use_device_ptr: { + unsigned NumVars = Reader->Record.readInt(); + unsigned NumDeclarations = Reader->Record.readInt(); + unsigned NumLists = Reader->Record.readInt(); + unsigned NumComponents = Reader->Record.readInt(); + C = OMPUseDevicePtrClause::CreateEmpty(Context, NumVars, NumDeclarations, + NumLists, NumComponents); break; - case OMPC_is_device_ptr: - C = OMPIsDevicePtrClause::CreateEmpty(Context, Record[Idx++]); + } + case OMPC_is_device_ptr: { + unsigned NumVars = Reader->Record.readInt(); + unsigned NumDeclarations = Reader->Record.readInt(); + unsigned NumLists = Reader->Record.readInt(); + unsigned NumComponents = Reader->Record.readInt(); + C = OMPIsDevicePtrClause::CreateEmpty(Context, NumVars, NumDeclarations, + NumLists, NumComponents); break; } + } Visit(C); - C->setLocStart(Reader->ReadSourceLocation(Record, Idx)); - C->setLocEnd(Reader->ReadSourceLocation(Record, Idx)); + C->setLocStart(Reader->ReadSourceLocation()); + C->setLocEnd(Reader->ReadSourceLocation()); return C; } void OMPClauseReader::VisitOMPClauseWithPreInit(OMPClauseWithPreInit *C) { - C->setPreInitStmt(Reader->Reader.ReadSubStmt()); + C->setPreInitStmt(Reader->Record.readSubStmt()); } void OMPClauseReader::VisitOMPClauseWithPostUpdate(OMPClauseWithPostUpdate *C) { VisitOMPClauseWithPreInit(C); - C->setPostUpdateExpr(Reader->Reader.ReadSubExpr()); + C->setPostUpdateExpr(Reader->Record.readSubExpr()); } void OMPClauseReader::VisitOMPIfClause(OMPIfClause *C) { - C->setNameModifier(static_cast<OpenMPDirectiveKind>(Record[Idx++])); - C->setNameModifierLoc(Reader->ReadSourceLocation(Record, Idx)); - C->setColonLoc(Reader->ReadSourceLocation(Record, Idx)); - C->setCondition(Reader->Reader.ReadSubExpr()); - C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx)); + C->setNameModifier(static_cast<OpenMPDirectiveKind>(Reader->Record.readInt())); + C->setNameModifierLoc(Reader->ReadSourceLocation()); + C->setColonLoc(Reader->ReadSourceLocation()); + C->setCondition(Reader->Record.readSubExpr()); + C->setLParenLoc(Reader->ReadSourceLocation()); } void OMPClauseReader::VisitOMPFinalClause(OMPFinalClause *C) { - C->setCondition(Reader->Reader.ReadSubExpr()); - C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx)); + C->setCondition(Reader->Record.readSubExpr()); + C->setLParenLoc(Reader->ReadSourceLocation()); } void OMPClauseReader::VisitOMPNumThreadsClause(OMPNumThreadsClause *C) { - C->setNumThreads(Reader->Reader.ReadSubExpr()); - C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx)); + C->setNumThreads(Reader->Record.readSubExpr()); + C->setLParenLoc(Reader->ReadSourceLocation()); } void OMPClauseReader::VisitOMPSafelenClause(OMPSafelenClause *C) { - C->setSafelen(Reader->Reader.ReadSubExpr()); - C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx)); + C->setSafelen(Reader->Record.readSubExpr()); + C->setLParenLoc(Reader->ReadSourceLocation()); } void OMPClauseReader::VisitOMPSimdlenClause(OMPSimdlenClause *C) { - C->setSimdlen(Reader->Reader.ReadSubExpr()); - C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx)); + C->setSimdlen(Reader->Record.readSubExpr()); + C->setLParenLoc(Reader->ReadSourceLocation()); } void OMPClauseReader::VisitOMPCollapseClause(OMPCollapseClause *C) { - C->setNumForLoops(Reader->Reader.ReadSubExpr()); - C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx)); + C->setNumForLoops(Reader->Record.readSubExpr()); + C->setLParenLoc(Reader->ReadSourceLocation()); } void OMPClauseReader::VisitOMPDefaultClause(OMPDefaultClause *C) { C->setDefaultKind( - static_cast<OpenMPDefaultClauseKind>(Record[Idx++])); - C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx)); - C->setDefaultKindKwLoc(Reader->ReadSourceLocation(Record, Idx)); + static_cast<OpenMPDefaultClauseKind>(Reader->Record.readInt())); + C->setLParenLoc(Reader->ReadSourceLocation()); + C->setDefaultKindKwLoc(Reader->ReadSourceLocation()); } void OMPClauseReader::VisitOMPProcBindClause(OMPProcBindClause *C) { C->setProcBindKind( - static_cast<OpenMPProcBindClauseKind>(Record[Idx++])); - C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx)); - C->setProcBindKindKwLoc(Reader->ReadSourceLocation(Record, Idx)); + static_cast<OpenMPProcBindClauseKind>(Reader->Record.readInt())); + C->setLParenLoc(Reader->ReadSourceLocation()); + C->setProcBindKindKwLoc(Reader->ReadSourceLocation()); } void OMPClauseReader::VisitOMPScheduleClause(OMPScheduleClause *C) { VisitOMPClauseWithPreInit(C); C->setScheduleKind( - static_cast<OpenMPScheduleClauseKind>(Record[Idx++])); + static_cast<OpenMPScheduleClauseKind>(Reader->Record.readInt())); C->setFirstScheduleModifier( - static_cast<OpenMPScheduleClauseModifier>(Record[Idx++])); + static_cast<OpenMPScheduleClauseModifier>(Reader->Record.readInt())); C->setSecondScheduleModifier( - static_cast<OpenMPScheduleClauseModifier>(Record[Idx++])); - C->setChunkSize(Reader->Reader.ReadSubExpr()); - C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx)); - C->setFirstScheduleModifierLoc(Reader->ReadSourceLocation(Record, Idx)); - C->setSecondScheduleModifierLoc(Reader->ReadSourceLocation(Record, Idx)); - C->setScheduleKindLoc(Reader->ReadSourceLocation(Record, Idx)); - C->setCommaLoc(Reader->ReadSourceLocation(Record, Idx)); + static_cast<OpenMPScheduleClauseModifier>(Reader->Record.readInt())); + C->setChunkSize(Reader->Record.readSubExpr()); + C->setLParenLoc(Reader->ReadSourceLocation()); + C->setFirstScheduleModifierLoc(Reader->ReadSourceLocation()); + C->setSecondScheduleModifierLoc(Reader->ReadSourceLocation()); + C->setScheduleKindLoc(Reader->ReadSourceLocation()); + C->setCommaLoc(Reader->ReadSourceLocation()); } void OMPClauseReader::VisitOMPOrderedClause(OMPOrderedClause *C) { - C->setNumForLoops(Reader->Reader.ReadSubExpr()); - C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx)); + C->setNumForLoops(Reader->Record.readSubExpr()); + C->setLParenLoc(Reader->ReadSourceLocation()); } void OMPClauseReader::VisitOMPNowaitClause(OMPNowaitClause *) {} @@ -2046,83 +2027,82 @@ void OMPClauseReader::VisitOMPSIMDClause(OMPSIMDClause *) {} void OMPClauseReader::VisitOMPNogroupClause(OMPNogroupClause *) {} void OMPClauseReader::VisitOMPPrivateClause(OMPPrivateClause *C) { - C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx)); + C->setLParenLoc(Reader->ReadSourceLocation()); unsigned NumVars = C->varlist_size(); SmallVector<Expr *, 16> Vars; Vars.reserve(NumVars); for (unsigned i = 0; i != NumVars; ++i) - Vars.push_back(Reader->Reader.ReadSubExpr()); + Vars.push_back(Reader->Record.readSubExpr()); C->setVarRefs(Vars); Vars.clear(); for (unsigned i = 0; i != NumVars; ++i) - Vars.push_back(Reader->Reader.ReadSubExpr()); + Vars.push_back(Reader->Record.readSubExpr()); C->setPrivateCopies(Vars); } void OMPClauseReader::VisitOMPFirstprivateClause(OMPFirstprivateClause *C) { VisitOMPClauseWithPreInit(C); - C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx)); + C->setLParenLoc(Reader->ReadSourceLocation()); unsigned NumVars = C->varlist_size(); SmallVector<Expr *, 16> Vars; Vars.reserve(NumVars); for (unsigned i = 0; i != NumVars; ++i) - Vars.push_back(Reader->Reader.ReadSubExpr()); + Vars.push_back(Reader->Record.readSubExpr()); C->setVarRefs(Vars); Vars.clear(); for (unsigned i = 0; i != NumVars; ++i) - Vars.push_back(Reader->Reader.ReadSubExpr()); + Vars.push_back(Reader->Record.readSubExpr()); C->setPrivateCopies(Vars); Vars.clear(); for (unsigned i = 0; i != NumVars; ++i) - Vars.push_back(Reader->Reader.ReadSubExpr()); + Vars.push_back(Reader->Record.readSubExpr()); C->setInits(Vars); } void OMPClauseReader::VisitOMPLastprivateClause(OMPLastprivateClause *C) { VisitOMPClauseWithPostUpdate(C); - C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx)); + C->setLParenLoc(Reader->ReadSourceLocation()); unsigned NumVars = C->varlist_size(); SmallVector<Expr *, 16> Vars; Vars.reserve(NumVars); for (unsigned i = 0; i != NumVars; ++i) - Vars.push_back(Reader->Reader.ReadSubExpr()); + Vars.push_back(Reader->Record.readSubExpr()); C->setVarRefs(Vars); Vars.clear(); for (unsigned i = 0; i != NumVars; ++i) - Vars.push_back(Reader->Reader.ReadSubExpr()); + Vars.push_back(Reader->Record.readSubExpr()); C->setPrivateCopies(Vars); Vars.clear(); for (unsigned i = 0; i != NumVars; ++i) - Vars.push_back(Reader->Reader.ReadSubExpr()); + Vars.push_back(Reader->Record.readSubExpr()); C->setSourceExprs(Vars); Vars.clear(); for (unsigned i = 0; i != NumVars; ++i) - Vars.push_back(Reader->Reader.ReadSubExpr()); + Vars.push_back(Reader->Record.readSubExpr()); C->setDestinationExprs(Vars); Vars.clear(); for (unsigned i = 0; i != NumVars; ++i) - Vars.push_back(Reader->Reader.ReadSubExpr()); + Vars.push_back(Reader->Record.readSubExpr()); C->setAssignmentOps(Vars); } void OMPClauseReader::VisitOMPSharedClause(OMPSharedClause *C) { - C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx)); + C->setLParenLoc(Reader->ReadSourceLocation()); unsigned NumVars = C->varlist_size(); SmallVector<Expr *, 16> Vars; Vars.reserve(NumVars); for (unsigned i = 0; i != NumVars; ++i) - Vars.push_back(Reader->Reader.ReadSubExpr()); + Vars.push_back(Reader->Record.readSubExpr()); C->setVarRefs(Vars); } void OMPClauseReader::VisitOMPReductionClause(OMPReductionClause *C) { VisitOMPClauseWithPostUpdate(C); - C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx)); - C->setColonLoc(Reader->ReadSourceLocation(Record, Idx)); - NestedNameSpecifierLoc NNSL = - Reader->Reader.ReadNestedNameSpecifierLoc(Reader->F, Record, Idx); + C->setLParenLoc(Reader->ReadSourceLocation()); + C->setColonLoc(Reader->ReadSourceLocation()); + NestedNameSpecifierLoc NNSL = Reader->Record.readNestedNameSpecifierLoc(); DeclarationNameInfo DNI; - Reader->ReadDeclarationNameInfo(DNI, Record, Idx); + Reader->ReadDeclarationNameInfo(DNI); C->setQualifierLoc(NNSL); C->setNameInfo(DNI); @@ -2130,151 +2110,152 @@ void OMPClauseReader::VisitOMPReductionClause(OMPReductionClause *C) { SmallVector<Expr *, 16> Vars; Vars.reserve(NumVars); for (unsigned i = 0; i != NumVars; ++i) - Vars.push_back(Reader->Reader.ReadSubExpr()); + Vars.push_back(Reader->Record.readSubExpr()); C->setVarRefs(Vars); Vars.clear(); for (unsigned i = 0; i != NumVars; ++i) - Vars.push_back(Reader->Reader.ReadSubExpr()); + Vars.push_back(Reader->Record.readSubExpr()); C->setPrivates(Vars); Vars.clear(); for (unsigned i = 0; i != NumVars; ++i) - Vars.push_back(Reader->Reader.ReadSubExpr()); + Vars.push_back(Reader->Record.readSubExpr()); C->setLHSExprs(Vars); Vars.clear(); for (unsigned i = 0; i != NumVars; ++i) - Vars.push_back(Reader->Reader.ReadSubExpr()); + Vars.push_back(Reader->Record.readSubExpr()); C->setRHSExprs(Vars); Vars.clear(); for (unsigned i = 0; i != NumVars; ++i) - Vars.push_back(Reader->Reader.ReadSubExpr()); + Vars.push_back(Reader->Record.readSubExpr()); C->setReductionOps(Vars); } void OMPClauseReader::VisitOMPLinearClause(OMPLinearClause *C) { VisitOMPClauseWithPostUpdate(C); - C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx)); - C->setColonLoc(Reader->ReadSourceLocation(Record, Idx)); - C->setModifier(static_cast<OpenMPLinearClauseKind>(Record[Idx++])); - C->setModifierLoc(Reader->ReadSourceLocation(Record, Idx)); + C->setLParenLoc(Reader->ReadSourceLocation()); + C->setColonLoc(Reader->ReadSourceLocation()); + C->setModifier(static_cast<OpenMPLinearClauseKind>(Reader->Record.readInt())); + C->setModifierLoc(Reader->ReadSourceLocation()); unsigned NumVars = C->varlist_size(); SmallVector<Expr *, 16> Vars; Vars.reserve(NumVars); for (unsigned i = 0; i != NumVars; ++i) - Vars.push_back(Reader->Reader.ReadSubExpr()); + Vars.push_back(Reader->Record.readSubExpr()); C->setVarRefs(Vars); Vars.clear(); for (unsigned i = 0; i != NumVars; ++i) - Vars.push_back(Reader->Reader.ReadSubExpr()); + Vars.push_back(Reader->Record.readSubExpr()); C->setPrivates(Vars); Vars.clear(); for (unsigned i = 0; i != NumVars; ++i) - Vars.push_back(Reader->Reader.ReadSubExpr()); + Vars.push_back(Reader->Record.readSubExpr()); C->setInits(Vars); Vars.clear(); for (unsigned i = 0; i != NumVars; ++i) - Vars.push_back(Reader->Reader.ReadSubExpr()); + Vars.push_back(Reader->Record.readSubExpr()); C->setUpdates(Vars); Vars.clear(); for (unsigned i = 0; i != NumVars; ++i) - Vars.push_back(Reader->Reader.ReadSubExpr()); + Vars.push_back(Reader->Record.readSubExpr()); C->setFinals(Vars); - C->setStep(Reader->Reader.ReadSubExpr()); - C->setCalcStep(Reader->Reader.ReadSubExpr()); + C->setStep(Reader->Record.readSubExpr()); + C->setCalcStep(Reader->Record.readSubExpr()); } void OMPClauseReader::VisitOMPAlignedClause(OMPAlignedClause *C) { - C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx)); - C->setColonLoc(Reader->ReadSourceLocation(Record, Idx)); + C->setLParenLoc(Reader->ReadSourceLocation()); + C->setColonLoc(Reader->ReadSourceLocation()); unsigned NumVars = C->varlist_size(); SmallVector<Expr *, 16> Vars; Vars.reserve(NumVars); for (unsigned i = 0; i != NumVars; ++i) - Vars.push_back(Reader->Reader.ReadSubExpr()); + Vars.push_back(Reader->Record.readSubExpr()); C->setVarRefs(Vars); - C->setAlignment(Reader->Reader.ReadSubExpr()); + C->setAlignment(Reader->Record.readSubExpr()); } void OMPClauseReader::VisitOMPCopyinClause(OMPCopyinClause *C) { - C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx)); + C->setLParenLoc(Reader->ReadSourceLocation()); unsigned NumVars = C->varlist_size(); SmallVector<Expr *, 16> Exprs; Exprs.reserve(NumVars); for (unsigned i = 0; i != NumVars; ++i) - Exprs.push_back(Reader->Reader.ReadSubExpr()); + Exprs.push_back(Reader->Record.readSubExpr()); C->setVarRefs(Exprs); Exprs.clear(); for (unsigned i = 0; i != NumVars; ++i) - Exprs.push_back(Reader->Reader.ReadSubExpr()); + Exprs.push_back(Reader->Record.readSubExpr()); C->setSourceExprs(Exprs); Exprs.clear(); for (unsigned i = 0; i != NumVars; ++i) - Exprs.push_back(Reader->Reader.ReadSubExpr()); + Exprs.push_back(Reader->Record.readSubExpr()); C->setDestinationExprs(Exprs); Exprs.clear(); for (unsigned i = 0; i != NumVars; ++i) - Exprs.push_back(Reader->Reader.ReadSubExpr()); + Exprs.push_back(Reader->Record.readSubExpr()); C->setAssignmentOps(Exprs); } void OMPClauseReader::VisitOMPCopyprivateClause(OMPCopyprivateClause *C) { - C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx)); + C->setLParenLoc(Reader->ReadSourceLocation()); unsigned NumVars = C->varlist_size(); SmallVector<Expr *, 16> Exprs; Exprs.reserve(NumVars); for (unsigned i = 0; i != NumVars; ++i) - Exprs.push_back(Reader->Reader.ReadSubExpr()); + Exprs.push_back(Reader->Record.readSubExpr()); C->setVarRefs(Exprs); Exprs.clear(); for (unsigned i = 0; i != NumVars; ++i) - Exprs.push_back(Reader->Reader.ReadSubExpr()); + Exprs.push_back(Reader->Record.readSubExpr()); C->setSourceExprs(Exprs); Exprs.clear(); for (unsigned i = 0; i != NumVars; ++i) - Exprs.push_back(Reader->Reader.ReadSubExpr()); + Exprs.push_back(Reader->Record.readSubExpr()); C->setDestinationExprs(Exprs); Exprs.clear(); for (unsigned i = 0; i != NumVars; ++i) - Exprs.push_back(Reader->Reader.ReadSubExpr()); + Exprs.push_back(Reader->Record.readSubExpr()); C->setAssignmentOps(Exprs); } void OMPClauseReader::VisitOMPFlushClause(OMPFlushClause *C) { - C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx)); + C->setLParenLoc(Reader->ReadSourceLocation()); unsigned NumVars = C->varlist_size(); SmallVector<Expr *, 16> Vars; Vars.reserve(NumVars); for (unsigned i = 0; i != NumVars; ++i) - Vars.push_back(Reader->Reader.ReadSubExpr()); + Vars.push_back(Reader->Record.readSubExpr()); C->setVarRefs(Vars); } void OMPClauseReader::VisitOMPDependClause(OMPDependClause *C) { - C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx)); - C->setDependencyKind(static_cast<OpenMPDependClauseKind>(Record[Idx++])); - C->setDependencyLoc(Reader->ReadSourceLocation(Record, Idx)); - C->setColonLoc(Reader->ReadSourceLocation(Record, Idx)); + C->setLParenLoc(Reader->ReadSourceLocation()); + C->setDependencyKind( + static_cast<OpenMPDependClauseKind>(Reader->Record.readInt())); + C->setDependencyLoc(Reader->ReadSourceLocation()); + C->setColonLoc(Reader->ReadSourceLocation()); unsigned NumVars = C->varlist_size(); SmallVector<Expr *, 16> Vars; Vars.reserve(NumVars); for (unsigned i = 0; i != NumVars; ++i) - Vars.push_back(Reader->Reader.ReadSubExpr()); + Vars.push_back(Reader->Record.readSubExpr()); C->setVarRefs(Vars); - C->setCounterValue(Reader->Reader.ReadSubExpr()); + C->setCounterValue(Reader->Record.readSubExpr()); } void OMPClauseReader::VisitOMPDeviceClause(OMPDeviceClause *C) { - C->setDevice(Reader->Reader.ReadSubExpr()); - C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx)); + C->setDevice(Reader->Record.readSubExpr()); + C->setLParenLoc(Reader->ReadSourceLocation()); } void OMPClauseReader::VisitOMPMapClause(OMPMapClause *C) { - C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx)); + C->setLParenLoc(Reader->ReadSourceLocation()); C->setMapTypeModifier( - static_cast<OpenMPMapClauseKind>(Record[Idx++])); + static_cast<OpenMPMapClauseKind>(Reader->Record.readInt())); C->setMapType( - static_cast<OpenMPMapClauseKind>(Record[Idx++])); - C->setMapLoc(Reader->ReadSourceLocation(Record, Idx)); - C->setColonLoc(Reader->ReadSourceLocation(Record, Idx)); + static_cast<OpenMPMapClauseKind>(Reader->Record.readInt())); + C->setMapLoc(Reader->ReadSourceLocation()); + C->setColonLoc(Reader->ReadSourceLocation()); auto NumVars = C->varlist_size(); auto UniqueDecls = C->getUniqueDeclarationsNum(); auto TotalLists = C->getTotalComponentListNum(); @@ -2283,34 +2264,32 @@ void OMPClauseReader::VisitOMPMapClause(OMPMapClause *C) { SmallVector<Expr *, 16> Vars; Vars.reserve(NumVars); for (unsigned i = 0; i != NumVars; ++i) - Vars.push_back(Reader->Reader.ReadSubExpr()); + Vars.push_back(Reader->Record.readSubExpr()); C->setVarRefs(Vars); SmallVector<ValueDecl *, 16> Decls; Decls.reserve(UniqueDecls); for (unsigned i = 0; i < UniqueDecls; ++i) - Decls.push_back( - Reader->Reader.ReadDeclAs<ValueDecl>(Reader->F, Record, Idx)); + Decls.push_back(Reader->Record.readDeclAs<ValueDecl>()); C->setUniqueDecls(Decls); SmallVector<unsigned, 16> ListsPerDecl; ListsPerDecl.reserve(UniqueDecls); for (unsigned i = 0; i < UniqueDecls; ++i) - ListsPerDecl.push_back(Record[Idx++]); + ListsPerDecl.push_back(Reader->Record.readInt()); C->setDeclNumLists(ListsPerDecl); SmallVector<unsigned, 32> ListSizes; ListSizes.reserve(TotalLists); for (unsigned i = 0; i < TotalLists; ++i) - ListSizes.push_back(Record[Idx++]); + ListSizes.push_back(Reader->Record.readInt()); C->setComponentListSizes(ListSizes); SmallVector<OMPClauseMappableExprCommon::MappableComponent, 32> Components; Components.reserve(TotalComponents); for (unsigned i = 0; i < TotalComponents; ++i) { - Expr *AssociatedExpr = Reader->Reader.ReadSubExpr(); - ValueDecl *AssociatedDecl = - Reader->Reader.ReadDeclAs<ValueDecl>(Reader->F, Record, Idx); + Expr *AssociatedExpr = Reader->Record.readSubExpr(); + ValueDecl *AssociatedDecl = Reader->Record.readDeclAs<ValueDecl>(); Components.push_back(OMPClauseMappableExprCommon::MappableComponent( AssociatedExpr, AssociatedDecl)); } @@ -2318,57 +2297,57 @@ void OMPClauseReader::VisitOMPMapClause(OMPMapClause *C) { } void OMPClauseReader::VisitOMPNumTeamsClause(OMPNumTeamsClause *C) { - C->setNumTeams(Reader->Reader.ReadSubExpr()); - C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx)); + C->setNumTeams(Reader->Record.readSubExpr()); + C->setLParenLoc(Reader->ReadSourceLocation()); } void OMPClauseReader::VisitOMPThreadLimitClause(OMPThreadLimitClause *C) { - C->setThreadLimit(Reader->Reader.ReadSubExpr()); - C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx)); + C->setThreadLimit(Reader->Record.readSubExpr()); + C->setLParenLoc(Reader->ReadSourceLocation()); } void OMPClauseReader::VisitOMPPriorityClause(OMPPriorityClause *C) { - C->setPriority(Reader->Reader.ReadSubExpr()); - C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx)); + C->setPriority(Reader->Record.readSubExpr()); + C->setLParenLoc(Reader->ReadSourceLocation()); } void OMPClauseReader::VisitOMPGrainsizeClause(OMPGrainsizeClause *C) { - C->setGrainsize(Reader->Reader.ReadSubExpr()); - C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx)); + C->setGrainsize(Reader->Record.readSubExpr()); + C->setLParenLoc(Reader->ReadSourceLocation()); } void OMPClauseReader::VisitOMPNumTasksClause(OMPNumTasksClause *C) { - C->setNumTasks(Reader->Reader.ReadSubExpr()); - C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx)); + C->setNumTasks(Reader->Record.readSubExpr()); + C->setLParenLoc(Reader->ReadSourceLocation()); } void OMPClauseReader::VisitOMPHintClause(OMPHintClause *C) { - C->setHint(Reader->Reader.ReadSubExpr()); - C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx)); + C->setHint(Reader->Record.readSubExpr()); + C->setLParenLoc(Reader->ReadSourceLocation()); } void OMPClauseReader::VisitOMPDistScheduleClause(OMPDistScheduleClause *C) { VisitOMPClauseWithPreInit(C); C->setDistScheduleKind( - static_cast<OpenMPDistScheduleClauseKind>(Record[Idx++])); - C->setChunkSize(Reader->Reader.ReadSubExpr()); - C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx)); - C->setDistScheduleKindLoc(Reader->ReadSourceLocation(Record, Idx)); - C->setCommaLoc(Reader->ReadSourceLocation(Record, Idx)); + static_cast<OpenMPDistScheduleClauseKind>(Reader->Record.readInt())); + C->setChunkSize(Reader->Record.readSubExpr()); + C->setLParenLoc(Reader->ReadSourceLocation()); + C->setDistScheduleKindLoc(Reader->ReadSourceLocation()); + C->setCommaLoc(Reader->ReadSourceLocation()); } void OMPClauseReader::VisitOMPDefaultmapClause(OMPDefaultmapClause *C) { C->setDefaultmapKind( - static_cast<OpenMPDefaultmapClauseKind>(Record[Idx++])); + static_cast<OpenMPDefaultmapClauseKind>(Reader->Record.readInt())); C->setDefaultmapModifier( - static_cast<OpenMPDefaultmapClauseModifier>(Record[Idx++])); - C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx)); - C->setDefaultmapModifierLoc(Reader->ReadSourceLocation(Record, Idx)); - C->setDefaultmapKindLoc(Reader->ReadSourceLocation(Record, Idx)); + static_cast<OpenMPDefaultmapClauseModifier>(Reader->Record.readInt())); + C->setLParenLoc(Reader->ReadSourceLocation()); + C->setDefaultmapModifierLoc(Reader->ReadSourceLocation()); + C->setDefaultmapKindLoc(Reader->ReadSourceLocation()); } void OMPClauseReader::VisitOMPToClause(OMPToClause *C) { - C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx)); + C->setLParenLoc(Reader->ReadSourceLocation()); auto NumVars = C->varlist_size(); auto UniqueDecls = C->getUniqueDeclarationsNum(); auto TotalLists = C->getTotalComponentListNum(); @@ -2377,34 +2356,32 @@ void OMPClauseReader::VisitOMPToClause(OMPToClause *C) { SmallVector<Expr *, 16> Vars; Vars.reserve(NumVars); for (unsigned i = 0; i != NumVars; ++i) - Vars.push_back(Reader->Reader.ReadSubExpr()); + Vars.push_back(Reader->Record.readSubExpr()); C->setVarRefs(Vars); SmallVector<ValueDecl *, 16> Decls; Decls.reserve(UniqueDecls); for (unsigned i = 0; i < UniqueDecls; ++i) - Decls.push_back( - Reader->Reader.ReadDeclAs<ValueDecl>(Reader->F, Record, Idx)); + Decls.push_back(Reader->Record.readDeclAs<ValueDecl>()); C->setUniqueDecls(Decls); SmallVector<unsigned, 16> ListsPerDecl; ListsPerDecl.reserve(UniqueDecls); for (unsigned i = 0; i < UniqueDecls; ++i) - ListsPerDecl.push_back(Record[Idx++]); + ListsPerDecl.push_back(Reader->Record.readInt()); C->setDeclNumLists(ListsPerDecl); SmallVector<unsigned, 32> ListSizes; ListSizes.reserve(TotalLists); for (unsigned i = 0; i < TotalLists; ++i) - ListSizes.push_back(Record[Idx++]); + ListSizes.push_back(Reader->Record.readInt()); C->setComponentListSizes(ListSizes); SmallVector<OMPClauseMappableExprCommon::MappableComponent, 32> Components; Components.reserve(TotalComponents); for (unsigned i = 0; i < TotalComponents; ++i) { - Expr *AssociatedExpr = Reader->Reader.ReadSubExpr(); - ValueDecl *AssociatedDecl = - Reader->Reader.ReadDeclAs<ValueDecl>(Reader->F, Record, Idx); + Expr *AssociatedExpr = Reader->Record.readSubExpr(); + ValueDecl *AssociatedDecl = Reader->Record.readDeclAs<ValueDecl>(); Components.push_back(OMPClauseMappableExprCommon::MappableComponent( AssociatedExpr, AssociatedDecl)); } @@ -2412,7 +2389,7 @@ void OMPClauseReader::VisitOMPToClause(OMPToClause *C) { } void OMPClauseReader::VisitOMPFromClause(OMPFromClause *C) { - C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx)); + C->setLParenLoc(Reader->ReadSourceLocation()); auto NumVars = C->varlist_size(); auto UniqueDecls = C->getUniqueDeclarationsNum(); auto TotalLists = C->getTotalComponentListNum(); @@ -2421,34 +2398,32 @@ void OMPClauseReader::VisitOMPFromClause(OMPFromClause *C) { SmallVector<Expr *, 16> Vars; Vars.reserve(NumVars); for (unsigned i = 0; i != NumVars; ++i) - Vars.push_back(Reader->Reader.ReadSubExpr()); + Vars.push_back(Reader->Record.readSubExpr()); C->setVarRefs(Vars); SmallVector<ValueDecl *, 16> Decls; Decls.reserve(UniqueDecls); for (unsigned i = 0; i < UniqueDecls; ++i) - Decls.push_back( - Reader->Reader.ReadDeclAs<ValueDecl>(Reader->F, Record, Idx)); + Decls.push_back(Reader->Record.readDeclAs<ValueDecl>()); C->setUniqueDecls(Decls); SmallVector<unsigned, 16> ListsPerDecl; ListsPerDecl.reserve(UniqueDecls); for (unsigned i = 0; i < UniqueDecls; ++i) - ListsPerDecl.push_back(Record[Idx++]); + ListsPerDecl.push_back(Reader->Record.readInt()); C->setDeclNumLists(ListsPerDecl); SmallVector<unsigned, 32> ListSizes; ListSizes.reserve(TotalLists); for (unsigned i = 0; i < TotalLists; ++i) - ListSizes.push_back(Record[Idx++]); + ListSizes.push_back(Reader->Record.readInt()); C->setComponentListSizes(ListSizes); SmallVector<OMPClauseMappableExprCommon::MappableComponent, 32> Components; Components.reserve(TotalComponents); for (unsigned i = 0; i < TotalComponents; ++i) { - Expr *AssociatedExpr = Reader->Reader.ReadSubExpr(); - ValueDecl *AssociatedDecl = - Reader->Reader.ReadDeclAs<ValueDecl>(Reader->F, Record, Idx); + Expr *AssociatedExpr = Reader->Record.readSubExpr(); + ValueDecl *AssociatedDecl = Reader->Record.readDeclAs<ValueDecl>(); Components.push_back(OMPClauseMappableExprCommon::MappableComponent( AssociatedExpr, AssociatedDecl)); } @@ -2456,101 +2431,172 @@ void OMPClauseReader::VisitOMPFromClause(OMPFromClause *C) { } void OMPClauseReader::VisitOMPUseDevicePtrClause(OMPUseDevicePtrClause *C) { - C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx)); - unsigned NumVars = C->varlist_size(); + C->setLParenLoc(Reader->ReadSourceLocation()); + auto NumVars = C->varlist_size(); + auto UniqueDecls = C->getUniqueDeclarationsNum(); + auto TotalLists = C->getTotalComponentListNum(); + auto TotalComponents = C->getTotalComponentsNum(); + SmallVector<Expr *, 16> Vars; Vars.reserve(NumVars); for (unsigned i = 0; i != NumVars; ++i) - Vars.push_back(Reader->Reader.ReadSubExpr()); + Vars.push_back(Reader->Record.readSubExpr()); C->setVarRefs(Vars); Vars.clear(); + for (unsigned i = 0; i != NumVars; ++i) + Vars.push_back(Reader->Record.readSubExpr()); + C->setPrivateCopies(Vars); + Vars.clear(); + for (unsigned i = 0; i != NumVars; ++i) + Vars.push_back(Reader->Record.readSubExpr()); + C->setInits(Vars); + + SmallVector<ValueDecl *, 16> Decls; + Decls.reserve(UniqueDecls); + for (unsigned i = 0; i < UniqueDecls; ++i) + Decls.push_back(Reader->Record.readDeclAs<ValueDecl>()); + C->setUniqueDecls(Decls); + + SmallVector<unsigned, 16> ListsPerDecl; + ListsPerDecl.reserve(UniqueDecls); + for (unsigned i = 0; i < UniqueDecls; ++i) + ListsPerDecl.push_back(Reader->Record.readInt()); + C->setDeclNumLists(ListsPerDecl); + + SmallVector<unsigned, 32> ListSizes; + ListSizes.reserve(TotalLists); + for (unsigned i = 0; i < TotalLists; ++i) + ListSizes.push_back(Reader->Record.readInt()); + C->setComponentListSizes(ListSizes); + + SmallVector<OMPClauseMappableExprCommon::MappableComponent, 32> Components; + Components.reserve(TotalComponents); + for (unsigned i = 0; i < TotalComponents; ++i) { + Expr *AssociatedExpr = Reader->Record.readSubExpr(); + ValueDecl *AssociatedDecl = Reader->Record.readDeclAs<ValueDecl>(); + Components.push_back(OMPClauseMappableExprCommon::MappableComponent( + AssociatedExpr, AssociatedDecl)); + } + C->setComponents(Components, ListSizes); } void OMPClauseReader::VisitOMPIsDevicePtrClause(OMPIsDevicePtrClause *C) { - C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx)); - unsigned NumVars = C->varlist_size(); + C->setLParenLoc(Reader->ReadSourceLocation()); + auto NumVars = C->varlist_size(); + auto UniqueDecls = C->getUniqueDeclarationsNum(); + auto TotalLists = C->getTotalComponentListNum(); + auto TotalComponents = C->getTotalComponentsNum(); + SmallVector<Expr *, 16> Vars; Vars.reserve(NumVars); for (unsigned i = 0; i != NumVars; ++i) - Vars.push_back(Reader->Reader.ReadSubExpr()); + Vars.push_back(Reader->Record.readSubExpr()); C->setVarRefs(Vars); Vars.clear(); + + SmallVector<ValueDecl *, 16> Decls; + Decls.reserve(UniqueDecls); + for (unsigned i = 0; i < UniqueDecls; ++i) + Decls.push_back(Reader->Record.readDeclAs<ValueDecl>()); + C->setUniqueDecls(Decls); + + SmallVector<unsigned, 16> ListsPerDecl; + ListsPerDecl.reserve(UniqueDecls); + for (unsigned i = 0; i < UniqueDecls; ++i) + ListsPerDecl.push_back(Reader->Record.readInt()); + C->setDeclNumLists(ListsPerDecl); + + SmallVector<unsigned, 32> ListSizes; + ListSizes.reserve(TotalLists); + for (unsigned i = 0; i < TotalLists; ++i) + ListSizes.push_back(Reader->Record.readInt()); + C->setComponentListSizes(ListSizes); + + SmallVector<OMPClauseMappableExprCommon::MappableComponent, 32> Components; + Components.reserve(TotalComponents); + for (unsigned i = 0; i < TotalComponents; ++i) { + Expr *AssociatedExpr = Reader->Record.readSubExpr(); + ValueDecl *AssociatedDecl = Reader->Record.readDeclAs<ValueDecl>(); + Components.push_back(OMPClauseMappableExprCommon::MappableComponent( + AssociatedExpr, AssociatedDecl)); + } + C->setComponents(Components, ListSizes); } //===----------------------------------------------------------------------===// // OpenMP Directives. //===----------------------------------------------------------------------===// void ASTStmtReader::VisitOMPExecutableDirective(OMPExecutableDirective *E) { - E->setLocStart(ReadSourceLocation(Record, Idx)); - E->setLocEnd(ReadSourceLocation(Record, Idx)); - OMPClauseReader ClauseReader(this, Reader.getContext(), Record, Idx); + E->setLocStart(ReadSourceLocation()); + E->setLocEnd(ReadSourceLocation()); + OMPClauseReader ClauseReader(this, Record); SmallVector<OMPClause *, 5> Clauses; for (unsigned i = 0; i < E->getNumClauses(); ++i) Clauses.push_back(ClauseReader.readClause()); E->setClauses(Clauses); if (E->hasAssociatedStmt()) - E->setAssociatedStmt(Reader.ReadSubStmt()); + E->setAssociatedStmt(Record.readSubStmt()); } void ASTStmtReader::VisitOMPLoopDirective(OMPLoopDirective *D) { VisitStmt(D); // Two fields (NumClauses and CollapsedNum) were read in ReadStmtFromStream. - Idx += 2; + Record.skipInts(2); VisitOMPExecutableDirective(D); - D->setIterationVariable(Reader.ReadSubExpr()); - D->setLastIteration(Reader.ReadSubExpr()); - D->setCalcLastIteration(Reader.ReadSubExpr()); - D->setPreCond(Reader.ReadSubExpr()); - D->setCond(Reader.ReadSubExpr()); - D->setInit(Reader.ReadSubExpr()); - D->setInc(Reader.ReadSubExpr()); - D->setPreInits(Reader.ReadSubStmt()); + D->setIterationVariable(Record.readSubExpr()); + D->setLastIteration(Record.readSubExpr()); + D->setCalcLastIteration(Record.readSubExpr()); + D->setPreCond(Record.readSubExpr()); + D->setCond(Record.readSubExpr()); + D->setInit(Record.readSubExpr()); + D->setInc(Record.readSubExpr()); + D->setPreInits(Record.readSubStmt()); if (isOpenMPWorksharingDirective(D->getDirectiveKind()) || isOpenMPTaskLoopDirective(D->getDirectiveKind()) || isOpenMPDistributeDirective(D->getDirectiveKind())) { - D->setIsLastIterVariable(Reader.ReadSubExpr()); - D->setLowerBoundVariable(Reader.ReadSubExpr()); - D->setUpperBoundVariable(Reader.ReadSubExpr()); - D->setStrideVariable(Reader.ReadSubExpr()); - D->setEnsureUpperBound(Reader.ReadSubExpr()); - D->setNextLowerBound(Reader.ReadSubExpr()); - D->setNextUpperBound(Reader.ReadSubExpr()); - D->setNumIterations(Reader.ReadSubExpr()); + D->setIsLastIterVariable(Record.readSubExpr()); + D->setLowerBoundVariable(Record.readSubExpr()); + D->setUpperBoundVariable(Record.readSubExpr()); + D->setStrideVariable(Record.readSubExpr()); + D->setEnsureUpperBound(Record.readSubExpr()); + D->setNextLowerBound(Record.readSubExpr()); + D->setNextUpperBound(Record.readSubExpr()); + D->setNumIterations(Record.readSubExpr()); } if (isOpenMPLoopBoundSharingDirective(D->getDirectiveKind())) { - D->setPrevLowerBoundVariable(Reader.ReadSubExpr()); - D->setPrevUpperBoundVariable(Reader.ReadSubExpr()); + D->setPrevLowerBoundVariable(Record.readSubExpr()); + D->setPrevUpperBoundVariable(Record.readSubExpr()); } SmallVector<Expr *, 4> Sub; unsigned CollapsedNum = D->getCollapsedNumber(); Sub.reserve(CollapsedNum); for (unsigned i = 0; i < CollapsedNum; ++i) - Sub.push_back(Reader.ReadSubExpr()); + Sub.push_back(Record.readSubExpr()); D->setCounters(Sub); Sub.clear(); for (unsigned i = 0; i < CollapsedNum; ++i) - Sub.push_back(Reader.ReadSubExpr()); + Sub.push_back(Record.readSubExpr()); D->setPrivateCounters(Sub); Sub.clear(); for (unsigned i = 0; i < CollapsedNum; ++i) - Sub.push_back(Reader.ReadSubExpr()); + Sub.push_back(Record.readSubExpr()); D->setInits(Sub); Sub.clear(); for (unsigned i = 0; i < CollapsedNum; ++i) - Sub.push_back(Reader.ReadSubExpr()); + Sub.push_back(Record.readSubExpr()); D->setUpdates(Sub); Sub.clear(); for (unsigned i = 0; i < CollapsedNum; ++i) - Sub.push_back(Reader.ReadSubExpr()); + Sub.push_back(Record.readSubExpr()); D->setFinals(Sub); } void ASTStmtReader::VisitOMPParallelDirective(OMPParallelDirective *D) { VisitStmt(D); // The NumClauses field was read in ReadStmtFromStream. - ++Idx; + Record.skipInts(1); VisitOMPExecutableDirective(D); - D->setHasCancel(Record[Idx++]); + D->setHasCancel(Record.readInt()); } void ASTStmtReader::VisitOMPSimdDirective(OMPSimdDirective *D) { @@ -2559,7 +2605,7 @@ void ASTStmtReader::VisitOMPSimdDirective(OMPSimdDirective *D) { void ASTStmtReader::VisitOMPForDirective(OMPForDirective *D) { VisitOMPLoopDirective(D); - D->setHasCancel(Record[Idx++]); + D->setHasCancel(Record.readInt()); } void ASTStmtReader::VisitOMPForSimdDirective(OMPForSimdDirective *D) { @@ -2569,21 +2615,21 @@ void ASTStmtReader::VisitOMPForSimdDirective(OMPForSimdDirective *D) { void ASTStmtReader::VisitOMPSectionsDirective(OMPSectionsDirective *D) { VisitStmt(D); // The NumClauses field was read in ReadStmtFromStream. - ++Idx; + Record.skipInts(1); VisitOMPExecutableDirective(D); - D->setHasCancel(Record[Idx++]); + D->setHasCancel(Record.readInt()); } void ASTStmtReader::VisitOMPSectionDirective(OMPSectionDirective *D) { VisitStmt(D); VisitOMPExecutableDirective(D); - D->setHasCancel(Record[Idx++]); + D->setHasCancel(Record.readInt()); } void ASTStmtReader::VisitOMPSingleDirective(OMPSingleDirective *D) { VisitStmt(D); // The NumClauses field was read in ReadStmtFromStream. - ++Idx; + Record.skipInts(1); VisitOMPExecutableDirective(D); } @@ -2595,14 +2641,14 @@ void ASTStmtReader::VisitOMPMasterDirective(OMPMasterDirective *D) { void ASTStmtReader::VisitOMPCriticalDirective(OMPCriticalDirective *D) { VisitStmt(D); // The NumClauses field was read in ReadStmtFromStream. - ++Idx; + Record.skipInts(1); VisitOMPExecutableDirective(D); - ReadDeclarationNameInfo(D->DirName, Record, Idx); + ReadDeclarationNameInfo(D->DirName); } void ASTStmtReader::VisitOMPParallelForDirective(OMPParallelForDirective *D) { VisitOMPLoopDirective(D); - D->setHasCancel(Record[Idx++]); + D->setHasCancel(Record.readInt()); } void ASTStmtReader::VisitOMPParallelForSimdDirective( @@ -2614,17 +2660,17 @@ void ASTStmtReader::VisitOMPParallelSectionsDirective( OMPParallelSectionsDirective *D) { VisitStmt(D); // The NumClauses field was read in ReadStmtFromStream. - ++Idx; + Record.skipInts(1); VisitOMPExecutableDirective(D); - D->setHasCancel(Record[Idx++]); + D->setHasCancel(Record.readInt()); } void ASTStmtReader::VisitOMPTaskDirective(OMPTaskDirective *D) { VisitStmt(D); // The NumClauses field was read in ReadStmtFromStream. - ++Idx; + Record.skipInts(1); VisitOMPExecutableDirective(D); - D->setHasCancel(Record[Idx++]); + D->setHasCancel(Record.readInt()); } void ASTStmtReader::VisitOMPTaskyieldDirective(OMPTaskyieldDirective *D) { @@ -2650,74 +2696,74 @@ void ASTStmtReader::VisitOMPTaskgroupDirective(OMPTaskgroupDirective *D) { void ASTStmtReader::VisitOMPFlushDirective(OMPFlushDirective *D) { VisitStmt(D); // The NumClauses field was read in ReadStmtFromStream. - ++Idx; + Record.skipInts(1); VisitOMPExecutableDirective(D); } void ASTStmtReader::VisitOMPOrderedDirective(OMPOrderedDirective *D) { VisitStmt(D); // The NumClauses field was read in ReadStmtFromStream. - ++Idx; + Record.skipInts(1); VisitOMPExecutableDirective(D); } void ASTStmtReader::VisitOMPAtomicDirective(OMPAtomicDirective *D) { VisitStmt(D); // The NumClauses field was read in ReadStmtFromStream. - ++Idx; + Record.skipInts(1); VisitOMPExecutableDirective(D); - D->setX(Reader.ReadSubExpr()); - D->setV(Reader.ReadSubExpr()); - D->setExpr(Reader.ReadSubExpr()); - D->setUpdateExpr(Reader.ReadSubExpr()); - D->IsXLHSInRHSPart = Record[Idx++] != 0; - D->IsPostfixUpdate = Record[Idx++] != 0; + D->setX(Record.readSubExpr()); + D->setV(Record.readSubExpr()); + D->setExpr(Record.readSubExpr()); + D->setUpdateExpr(Record.readSubExpr()); + D->IsXLHSInRHSPart = Record.readInt() != 0; + D->IsPostfixUpdate = Record.readInt() != 0; } void ASTStmtReader::VisitOMPTargetDirective(OMPTargetDirective *D) { VisitStmt(D); // The NumClauses field was read in ReadStmtFromStream. - ++Idx; + Record.skipInts(1); VisitOMPExecutableDirective(D); } void ASTStmtReader::VisitOMPTargetDataDirective(OMPTargetDataDirective *D) { VisitStmt(D); - ++Idx; + Record.skipInts(1); VisitOMPExecutableDirective(D); } void ASTStmtReader::VisitOMPTargetEnterDataDirective( OMPTargetEnterDataDirective *D) { VisitStmt(D); - ++Idx; + Record.skipInts(1); VisitOMPExecutableDirective(D); } void ASTStmtReader::VisitOMPTargetExitDataDirective( OMPTargetExitDataDirective *D) { VisitStmt(D); - ++Idx; + Record.skipInts(1); VisitOMPExecutableDirective(D); } void ASTStmtReader::VisitOMPTargetParallelDirective( OMPTargetParallelDirective *D) { VisitStmt(D); - ++Idx; + Record.skipInts(1); VisitOMPExecutableDirective(D); } void ASTStmtReader::VisitOMPTargetParallelForDirective( OMPTargetParallelForDirective *D) { VisitOMPLoopDirective(D); - D->setHasCancel(Record[Idx++]); + D->setHasCancel(Record.readInt()); } void ASTStmtReader::VisitOMPTeamsDirective(OMPTeamsDirective *D) { VisitStmt(D); // The NumClauses field was read in ReadStmtFromStream. - ++Idx; + Record.skipInts(1); VisitOMPExecutableDirective(D); } @@ -2725,15 +2771,15 @@ void ASTStmtReader::VisitOMPCancellationPointDirective( OMPCancellationPointDirective *D) { VisitStmt(D); VisitOMPExecutableDirective(D); - D->setCancelRegion(static_cast<OpenMPDirectiveKind>(Record[Idx++])); + D->setCancelRegion(static_cast<OpenMPDirectiveKind>(Record.readInt())); } void ASTStmtReader::VisitOMPCancelDirective(OMPCancelDirective *D) { VisitStmt(D); // The NumClauses field was read in ReadStmtFromStream. - ++Idx; + Record.skipInts(1); VisitOMPExecutableDirective(D); - D->setCancelRegion(static_cast<OpenMPDirectiveKind>(Record[Idx++])); + D->setCancelRegion(static_cast<OpenMPDirectiveKind>(Record.readInt())); } void ASTStmtReader::VisitOMPTaskLoopDirective(OMPTaskLoopDirective *D) { @@ -2750,7 +2796,7 @@ void ASTStmtReader::VisitOMPDistributeDirective(OMPDistributeDirective *D) { void ASTStmtReader::VisitOMPTargetUpdateDirective(OMPTargetUpdateDirective *D) { VisitStmt(D); - ++Idx; + Record.skipInts(1); VisitOMPExecutableDirective(D); } void ASTStmtReader::VisitOMPDistributeParallelForDirective( @@ -2773,6 +2819,57 @@ void ASTStmtReader::VisitOMPTargetParallelForSimdDirective( 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); +} + +void ASTStmtReader::VisitOMPTargetTeamsDirective(OMPTargetTeamsDirective *D) { + VisitStmt(D); + // The NumClauses field was read in ReadStmtFromStream. + Record.skipInts(1); + VisitOMPExecutableDirective(D); +} + +void ASTStmtReader::VisitOMPTargetTeamsDistributeDirective( + OMPTargetTeamsDistributeDirective *D) { + VisitOMPLoopDirective(D); +} + +void ASTStmtReader::VisitOMPTargetTeamsDistributeParallelForDirective( + OMPTargetTeamsDistributeParallelForDirective *D) { + VisitOMPLoopDirective(D); +} + +void ASTStmtReader::VisitOMPTargetTeamsDistributeParallelForSimdDirective( + OMPTargetTeamsDistributeParallelForSimdDirective *D) { + VisitOMPLoopDirective(D); +} + +void ASTStmtReader::VisitOMPTargetTeamsDistributeSimdDirective( + OMPTargetTeamsDistributeSimdDirective *D) { + VisitOMPLoopDirective(D); +} + //===----------------------------------------------------------------------===// // ASTReader Implementation //===----------------------------------------------------------------------===// @@ -2810,7 +2907,7 @@ 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; @@ -2819,14 +2916,13 @@ Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) { unsigned PrevNumStmts = StmtStack.size(); #endif - RecordData Record; - unsigned Idx; - ASTStmtReader Reader(*this, F, Cursor, Record, Idx); + ASTRecordReader Record(*this, F); + ASTStmtReader Reader(Record, Cursor); Stmt::EmptyShell Empty; while (true) { llvm::BitstreamEntry Entry = Cursor.advanceSkippingSubblocks(); - + switch (Entry.Kind) { case llvm::BitstreamEntry::SubBlock: // Handled for us already. case llvm::BitstreamEntry::Error: @@ -2840,11 +2936,9 @@ Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) { } Stmt *S = nullptr; - Idx = 0; - Record.clear(); bool Finished = false; bool IsStmtReference = false; - switch ((StmtCode)Cursor.readRecord(Entry.ID, Record)) { + switch ((StmtCode)Record.readRecord(Cursor, Entry.ID)) { case STMT_STOP: Finished = true; break; @@ -2853,7 +2947,7 @@ Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) { IsStmtReference = true; assert(StmtEntries.find(Record[0]) != StmtEntries.end() && "No stmt was recorded for this offset reference!"); - S = StmtEntries[Record[Idx++]]; + S = StmtEntries[Record.readInt()]; break; case STMT_NULL_PTR: @@ -2991,11 +3085,11 @@ Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) { break; case EXPR_OFFSETOF: - S = OffsetOfExpr::CreateEmpty(Context, + S = OffsetOfExpr::CreateEmpty(Context, Record[ASTStmtReader::NumExprFields], Record[ASTStmtReader::NumExprFields + 1]); break; - + case EXPR_SIZEOF_ALIGN_OF: S = new (Context) UnaryExprOrTypeTraitExpr(Empty); break; @@ -3017,46 +3111,46 @@ Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) { // That way we can use MemberExpr::Create and don't have to duplicate its // logic with a MemberExpr::CreateEmpty. - assert(Idx == 0); + assert(Record.getIdx() == 0); NestedNameSpecifierLoc QualifierLoc; - if (Record[Idx++]) { // HasQualifier. - QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, Idx); + if (Record.readInt()) { // HasQualifier. + QualifierLoc = Record.readNestedNameSpecifierLoc(); } SourceLocation TemplateKWLoc; TemplateArgumentListInfo ArgInfo; - bool HasTemplateKWAndArgsInfo = Record[Idx++]; + bool HasTemplateKWAndArgsInfo = Record.readInt(); if (HasTemplateKWAndArgsInfo) { - TemplateKWLoc = ReadSourceLocation(F, Record, Idx); - unsigned NumTemplateArgs = Record[Idx++]; - ArgInfo.setLAngleLoc(ReadSourceLocation(F, Record, Idx)); - ArgInfo.setRAngleLoc(ReadSourceLocation(F, Record, Idx)); + TemplateKWLoc = Record.readSourceLocation(); + unsigned NumTemplateArgs = Record.readInt(); + ArgInfo.setLAngleLoc(Record.readSourceLocation()); + ArgInfo.setRAngleLoc(Record.readSourceLocation()); for (unsigned i = 0; i != NumTemplateArgs; ++i) - ArgInfo.addArgument(ReadTemplateArgumentLoc(F, Record, Idx)); + ArgInfo.addArgument(Record.readTemplateArgumentLoc()); } - bool HadMultipleCandidates = Record[Idx++]; + bool HadMultipleCandidates = Record.readInt(); - NamedDecl *FoundD = ReadDeclAs<NamedDecl>(F, Record, Idx); - AccessSpecifier AS = (AccessSpecifier)Record[Idx++]; + NamedDecl *FoundD = Record.readDeclAs<NamedDecl>(); + AccessSpecifier AS = (AccessSpecifier)Record.readInt(); DeclAccessPair FoundDecl = DeclAccessPair::make(FoundD, AS); - QualType T = readType(F, Record, Idx); - ExprValueKind VK = static_cast<ExprValueKind>(Record[Idx++]); - ExprObjectKind OK = static_cast<ExprObjectKind>(Record[Idx++]); + QualType T = Record.readType(); + ExprValueKind VK = static_cast<ExprValueKind>(Record.readInt()); + ExprObjectKind OK = static_cast<ExprObjectKind>(Record.readInt()); Expr *Base = ReadSubExpr(); - ValueDecl *MemberD = ReadDeclAs<ValueDecl>(F, Record, Idx); - SourceLocation MemberLoc = ReadSourceLocation(F, Record, Idx); + ValueDecl *MemberD = Record.readDeclAs<ValueDecl>(); + SourceLocation MemberLoc = Record.readSourceLocation(); DeclarationNameInfo MemberNameInfo(MemberD->getDeclName(), MemberLoc); - bool IsArrow = Record[Idx++]; - SourceLocation OperatorLoc = ReadSourceLocation(F, Record, Idx); + bool IsArrow = Record.readInt(); + SourceLocation OperatorLoc = Record.readSourceLocation(); S = MemberExpr::Create(Context, Base, IsArrow, OperatorLoc, QualifierLoc, TemplateKWLoc, MemberD, FoundDecl, MemberNameInfo, HasTemplateKWAndArgsInfo ? &ArgInfo : nullptr, T, VK, OK); - ReadDeclarationNameLoc(F, cast<MemberExpr>(S)->MemberDNLoc, - MemberD->getDeclName(), Record, Idx); + Record.readDeclarationNameLoc(cast<MemberExpr>(S)->MemberDNLoc, + MemberD->getDeclName()); if (HadMultipleCandidates) cast<MemberExpr>(S)->setHadMultipleCandidates(true); break; @@ -3118,6 +3212,14 @@ Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) { S = new (Context) NoInitExpr(Empty); break; + case EXPR_ARRAY_INIT_LOOP: + S = new (Context) ArrayInitLoopExpr(Empty); + break; + + case EXPR_ARRAY_INIT_INDEX: + S = new (Context) ArrayInitIndexExpr(Empty); + break; + case EXPR_VA_ARG: S = new (Context) VAArgExpr(Empty); break; @@ -3213,7 +3315,7 @@ Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) { S = new (Context) ObjCAtFinallyStmt(Empty); break; case STMT_OBJC_AT_TRY: - S = ObjCAtTryStmt::CreateEmpty(Context, + S = ObjCAtTryStmt::CreateEmpty(Context, Record[ASTStmtReader::NumStmtFields], Record[ASTStmtReader::NumStmtFields + 1]); break; @@ -3484,6 +3586,84 @@ Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) { break; } + case STMT_OMP_TARGET_SIMD_DIRECTIVE: { + auto NumClauses = Record[ASTStmtReader::NumStmtFields]; + auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1]; + S = OMPTargetSimdDirective::CreateEmpty(Context, NumClauses, CollapsedNum, + Empty); + break; + } + + case STMT_OMP_TEAMS_DISTRIBUTE_DIRECTIVE: { + auto NumClauses = Record[ASTStmtReader::NumStmtFields]; + auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1]; + S = OMPTeamsDistributeDirective::CreateEmpty(Context, NumClauses, + CollapsedNum, Empty); + break; + } + + case STMT_OMP_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE: { + unsigned NumClauses = Record[ASTStmtReader::NumStmtFields]; + unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1]; + S = OMPTeamsDistributeSimdDirective::CreateEmpty(Context, NumClauses, + CollapsedNum, Empty); + break; + } + + case STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE: { + auto NumClauses = Record[ASTStmtReader::NumStmtFields]; + auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1]; + S = OMPTeamsDistributeParallelForSimdDirective::CreateEmpty( + Context, NumClauses, CollapsedNum, Empty); + break; + } + + case STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE: { + auto NumClauses = Record[ASTStmtReader::NumStmtFields]; + auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1]; + S = OMPTeamsDistributeParallelForDirective::CreateEmpty( + Context, NumClauses, CollapsedNum, Empty); + break; + } + + case STMT_OMP_TARGET_TEAMS_DIRECTIVE: { + S = OMPTargetTeamsDirective::CreateEmpty( + Context, Record[ASTStmtReader::NumStmtFields], Empty); + break; + } + + case STMT_OMP_TARGET_TEAMS_DISTRIBUTE_DIRECTIVE: { + auto NumClauses = Record[ASTStmtReader::NumStmtFields]; + auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1]; + S = OMPTargetTeamsDistributeDirective::CreateEmpty(Context, NumClauses, + CollapsedNum, Empty); + break; + } + + case STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE: { + auto NumClauses = Record[ASTStmtReader::NumStmtFields]; + auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1]; + S = OMPTargetTeamsDistributeParallelForDirective::CreateEmpty( + Context, NumClauses, CollapsedNum, Empty); + break; + } + + case STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE: { + auto NumClauses = Record[ASTStmtReader::NumStmtFields]; + auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1]; + S = OMPTargetTeamsDistributeParallelForSimdDirective::CreateEmpty( + Context, NumClauses, CollapsedNum, Empty); + break; + } + + case STMT_OMP_TARGET_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE: { + auto NumClauses = Record[ASTStmtReader::NumStmtFields]; + auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1]; + S = OMPTargetTeamsDistributeSimdDirective::CreateEmpty( + Context, NumClauses, CollapsedNum, Empty); + break; + } + case EXPR_CXX_OPERATOR_CALL: S = new (Context) CXXOperatorCallExpr(Context, Empty); break; @@ -3576,7 +3756,7 @@ Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) { case EXPR_CXX_BIND_TEMPORARY: S = new (Context) CXXBindTemporaryExpr(Empty); break; - + case EXPR_CXX_SCALAR_VALUE_INIT: S = new (Context) CXXScalarValueInitExpr(Empty); break; @@ -3589,54 +3769,54 @@ Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) { case EXPR_CXX_PSEUDO_DESTRUCTOR: S = new (Context) CXXPseudoDestructorExpr(Empty); break; - + case EXPR_EXPR_WITH_CLEANUPS: S = ExprWithCleanups::Create(Context, Empty, Record[ASTStmtReader::NumExprFields]); break; - + case EXPR_CXX_DEPENDENT_SCOPE_MEMBER: S = CXXDependentScopeMemberExpr::CreateEmpty(Context, /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields], /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields] - ? Record[ASTStmtReader::NumExprFields + 1] + ? Record[ASTStmtReader::NumExprFields + 1] : 0); break; - + case EXPR_CXX_DEPENDENT_SCOPE_DECL_REF: S = DependentScopeDeclRefExpr::CreateEmpty(Context, /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields], /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields] - ? Record[ASTStmtReader::NumExprFields + 1] + ? Record[ASTStmtReader::NumExprFields + 1] : 0); break; - + case EXPR_CXX_UNRESOLVED_CONSTRUCT: S = CXXUnresolvedConstructExpr::CreateEmpty(Context, /*NumArgs=*/Record[ASTStmtReader::NumExprFields]); break; - + case EXPR_CXX_UNRESOLVED_MEMBER: S = UnresolvedMemberExpr::CreateEmpty(Context, /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields], /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields] - ? Record[ASTStmtReader::NumExprFields + 1] + ? Record[ASTStmtReader::NumExprFields + 1] : 0); break; - + case EXPR_CXX_UNRESOLVED_LOOKUP: S = UnresolvedLookupExpr::CreateEmpty(Context, /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields], /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields] - ? Record[ASTStmtReader::NumExprFields + 1] + ? Record[ASTStmtReader::NumExprFields + 1] : 0); break; case EXPR_TYPE_TRAIT: - S = TypeTraitExpr::CreateDeserialized(Context, + S = TypeTraitExpr::CreateDeserialized(Context, Record[ASTStmtReader::NumExprFields]); break; - + case EXPR_ARRAY_TYPE_TRAIT: S = new (Context) ArrayTypeTraitExpr(Empty); break; @@ -3652,17 +3832,17 @@ Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) { case EXPR_PACK_EXPANSION: S = new (Context) PackExpansionExpr(Empty); break; - + case EXPR_SIZEOF_PACK: S = SizeOfPackExpr::CreateDeserialized( Context, /*NumPartialArgs=*/Record[ASTStmtReader::NumExprFields]); break; - + case EXPR_SUBST_NON_TYPE_TEMPLATE_PARM: S = new (Context) SubstNonTypeTemplateParmExpr(Empty); break; - + case EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK: S = new (Context) SubstNonTypeTemplateParmPackExpr(Empty); break; @@ -3671,7 +3851,7 @@ Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) { S = FunctionParmPackExpr::CreateEmpty(Context, Record[ASTStmtReader::NumExprFields]); break; - + case EXPR_MATERIALIZE_TEMPORARY: S = new (Context) MaterializeTemporaryExpr(Empty); break; @@ -3687,7 +3867,7 @@ Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) { case EXPR_CUDA_KERNEL_CALL: S = new (Context) CUDAKernelCallExpr(Context, Empty); break; - + case EXPR_ASTYPE: S = new (Context) AsTypeExpr(Empty); break; @@ -3701,16 +3881,14 @@ Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) { case EXPR_ATOMIC: S = new (Context) AtomicExpr(Empty); break; - + case EXPR_LAMBDA: { unsigned NumCaptures = Record[ASTStmtReader::NumExprFields]; - unsigned NumArrayIndexVars = Record[ASTStmtReader::NumExprFields + 1]; - S = LambdaExpr::CreateDeserialized(Context, NumCaptures, - NumArrayIndexVars); + S = LambdaExpr::CreateDeserialized(Context, NumCaptures); break; } } - + // We hit a STMT_STOP, so we're done with this expression. if (Finished) break; @@ -3722,8 +3900,8 @@ Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) { StmtEntries[Cursor.GetCurrentBitNo()] = S; } - - assert(Idx == Record.size() && "Invalid deserialization of statement"); + assert(Record.getIdx() == Record.size() && + "Invalid deserialization of statement"); StmtStack.push_back(S); } Done: |
