From 919e693e80632d214c1f3110f6ee5d1c0b61f06b Mon Sep 17 00:00:00 2001 From: Argyrios Kyrtzidis Date: Mon, 28 Jun 2010 22:28:35 +0000 Subject: [PATCH] Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@107087 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/clang/Frontend/PCHReader.h | 69 +-- include/clang/Frontend/PCHWriter.h | 18 +- lib/Frontend/PCHReader.cpp | 71 +-- lib/Frontend/PCHReaderDecl.cpp | 16 +- lib/Frontend/PCHReaderStmt.cpp | 820 ++++++++++++----------------- lib/Frontend/PCHWriter.cpp | 4 +- lib/Frontend/PCHWriterStmt.cpp | 253 ++++----- test/PCH/exprs.c | 2 + test/PCH/exprs.h | 2 + 9 files changed, 529 insertions(+), 726 deletions(-) diff --git a/include/clang/Frontend/PCHReader.h b/include/clang/Frontend/PCHReader.h index ff966b005f..22625dc508 100644 --- a/include/clang/Frontend/PCHReader.h +++ b/include/clang/Frontend/PCHReader.h @@ -449,6 +449,34 @@ private: /// Objective-C protocols. llvm::SmallVector InterestingDecls; + /// \brief When reading a Stmt tree, Stmt operands are placed in this stack. + llvm::SmallVector StmtStack; + + /// \brief What kind of records we are reading. + enum ReadingKind { + Read_Decl, Read_Type, Read_Stmt + }; + + /// \brief What kind of records we are reading. + ReadingKind ReadingKind; + + /// \brief RAII object to change the reading kind. + class ReadingKindTracker { + PCHReader &Reader; + enum ReadingKind PrevKind; + + ReadingKindTracker(const ReadingKindTracker&); // do not implement + ReadingKindTracker &operator=(const ReadingKindTracker&);// do not implement + + public: + ReadingKindTracker(enum ReadingKind newKind, PCHReader &reader) + : Reader(reader), PrevKind(Reader.ReadingKind) { + Reader.ReadingKind = newKind; + } + + ~ReadingKindTracker() { Reader.ReadingKind = PrevKind; } + }; + /// \brief The file ID for the predefines buffer in the PCH file. FileID PCHPredefinesBufferID; @@ -469,6 +497,9 @@ private: /// predefines buffer may contain additional definitions. std::string SuggestedPredefines; + /// \brief Reads a statement from the specified cursor. + Stmt *ReadStmtFromStream(llvm::BitstreamCursor &Cursor); + void MaybeAddSystemRootToFilename(std::string &Filename); PCHReadResult ReadPCHBlock(); @@ -563,30 +594,12 @@ public: /// \brief Read preprocessed entities into the virtual void ReadPreprocessedEntities(); - /// \brief Abstract interface for reading expressions. - class ExprReader { - public: - virtual Expr *Read(); - }; - - /// \brief Reads a TemplateArgumentLocInfo appropriate for the - /// given TemplateArgument kind. - TemplateArgumentLocInfo - GetTemplateArgumentLocInfo(TemplateArgument::ArgKind Kind, - const RecordData &Record, unsigned &Idx, - ExprReader &ExprRdr); - /// \brief Reads a TemplateArgumentLocInfo appropriate for the /// given TemplateArgument kind. TemplateArgumentLocInfo GetTemplateArgumentLocInfo(TemplateArgument::ArgKind Kind, const RecordData &Record, unsigned &Idx); - /// \brief Reads a TemplateArgumentLoc. - TemplateArgumentLoc ReadTemplateArgumentLoc(const RecordData &Record, - unsigned &Idx, - ExprReader &ExprRdr); - /// \brief Reads a TemplateArgumentLoc. TemplateArgumentLoc ReadTemplateArgumentLoc(const RecordData &Record, unsigned &Idx); @@ -718,10 +731,6 @@ public: /// \brief Read a template name. TemplateName ReadTemplateName(const RecordData &Record, unsigned &Idx); - /// \brief Read a template argument. - TemplateArgument ReadTemplateArgument(const RecordData &Record,unsigned &Idx, - ExprReader &ExprRdr); - /// \brief Read a template argument. TemplateArgument ReadTemplateArgument(const RecordData &Record,unsigned &Idx); @@ -759,19 +768,11 @@ public: /// \brief Reads attributes from the current stream position. Attr *ReadAttributes(); - /// \brief ReadDeclExpr - Reads an expression from the current decl cursor. - Expr *ReadDeclExpr(); - - /// \brief ReadTypeExpr - Reads an expression from the current type cursor. - Expr *ReadTypeExpr(); + /// \brief Reads a statement. + Stmt *ReadStmt(); - /// \brief Reads a statement from the specified cursor. - Stmt *ReadStmt(llvm::BitstreamCursor &Cursor); - - /// \brief Read a statement from the current DeclCursor. - Stmt *ReadDeclStmt() { - return ReadStmt(DeclsCursor); - } + /// \brief Reads an expression. + Expr *ReadExpr(); /// \brief Reads the macro record located at the given offset. void ReadMacroRecord(uint64_t Offset); diff --git a/include/clang/Frontend/PCHWriter.h b/include/clang/Frontend/PCHWriter.h index dffda371b4..dddbf85b29 100644 --- a/include/clang/Frontend/PCHWriter.h +++ b/include/clang/Frontend/PCHWriter.h @@ -189,7 +189,11 @@ private: /// \brief Statements that we've encountered while serializing a /// declaration or type. - llvm::SmallVector StmtsToEmit; + llvm::SmallVector StmtsToEmit; + + /// \brief Statements collection to use for PCHWriter::AddStmt(). + /// It will point to StmtsToEmit unless it is overriden. + llvm::SmallVector *CollectedStmts; /// \brief Mapping from SwitchCase statements to IDs. std::map SwitchCaseIDs; @@ -211,8 +215,8 @@ private: /// file. unsigned NumVisibleDeclContexts; - /// \brief True when we are in Stmts emitting mode. - bool EmittingStmts; + /// \brief Write the given subexpression to the bitstream. + void WriteSubStmt(Stmt *S); void WriteBlockInfoBlock(); void WriteMetadata(ASTContext &Context, const char *isysroot); @@ -359,15 +363,9 @@ public: /// the corresponding statements just after the type or /// declaration. void AddStmt(Stmt *S) { - if (EmittingStmts) - WriteSubStmt(S); - else - StmtsToEmit.push_back(S); + CollectedStmts->push_back(S); } - /// \brief Write the given subexpression to the bitstream. - void WriteSubStmt(Stmt *S); - /// \brief Flush all of the statements and expressions that have /// been added to the queue via AddStmt(). void FlushStmts(); diff --git a/lib/Frontend/PCHReader.cpp b/lib/Frontend/PCHReader.cpp index 5628de3829..a526fd6dc5 100644 --- a/lib/Frontend/PCHReader.cpp +++ b/lib/Frontend/PCHReader.cpp @@ -321,18 +321,6 @@ void PCHValidator::ReadCounter(unsigned Value) { // PCH reader implementation //===----------------------------------------------------------------------===// -// Give ExprReader's VTable a home. -Expr *PCHReader::ExprReader::Read() { return 0; } - -namespace { - class DeclExprReader : public PCHReader::ExprReader { - PCHReader &Reader; - public: - DeclExprReader(PCHReader &reader) : Reader(reader) { } - virtual Expr *Read() { return Reader.ReadDeclExpr(); } - }; -} // anonymous namespace - PCHReader::PCHReader(Preprocessor &PP, ASTContext *Context, const char *isysroot) : Listener(new PCHValidator(PP, *this)), SourceMgr(PP.getSourceManager()), @@ -372,14 +360,6 @@ PCHReader::PCHReader(SourceManager &SourceMgr, FileManager &FileMgr, PCHReader::~PCHReader() {} -Expr *PCHReader::ReadDeclExpr() { - return dyn_cast_or_null(ReadStmt(DeclsCursor)); -} - -Expr *PCHReader::ReadTypeExpr() { - return dyn_cast_or_null(ReadStmt(DeclsCursor)); -} - namespace { class PCHMethodPoolLookupTrait { @@ -1969,6 +1949,8 @@ QualType PCHReader::ReadTypeRecord(uint64_t Offset) { // after reading this type. SavedStreamPosition SavedPosition(DeclsCursor); + ReadingKindTracker ReadingKind(Read_Type, *this); + // Note that we are loading a type record. LoadingTypeOrDecl Loading(*this); @@ -2064,7 +2046,7 @@ QualType PCHReader::ReadTypeRecord(uint64_t Offset) { unsigned IndexTypeQuals = Record[2]; SourceLocation LBLoc = SourceLocation::getFromRawEncoding(Record[3]); SourceLocation RBLoc = SourceLocation::getFromRawEncoding(Record[4]); - return Context->getVariableArrayType(ElementType, ReadTypeExpr(), + return Context->getVariableArrayType(ElementType, ReadExpr(), ASM, IndexTypeQuals, SourceRange(LBLoc, RBLoc)); } @@ -2141,7 +2123,7 @@ QualType PCHReader::ReadTypeRecord(uint64_t Offset) { return Context->getTypeDeclType(cast(GetDecl(Record[0]))); case pch::TYPE_TYPEOF_EXPR: - return Context->getTypeOfExprType(ReadTypeExpr()); + return Context->getTypeOfExprType(ReadExpr()); case pch::TYPE_TYPEOF: { if (Record.size() != 1) { @@ -2153,7 +2135,7 @@ QualType PCHReader::ReadTypeRecord(uint64_t Offset) { } case pch::TYPE_DECLTYPE: - return Context->getDecltypeType(ReadTypeExpr()); + return Context->getDecltypeType(ReadExpr()); case pch::TYPE_RECORD: if (Record.size() != 1) { @@ -2319,7 +2301,7 @@ void TypeLocReader::VisitArrayTypeLoc(ArrayTypeLoc TL) { TL.setLBracketLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); TL.setRBracketLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); if (Record[Idx++]) - TL.setSizeExpr(Reader.ReadDeclExpr()); + TL.setSizeExpr(Reader.ReadExpr()); else TL.setSizeExpr(0); } @@ -2511,10 +2493,10 @@ QualType PCHReader::GetType(pch::TypeID ID) { TemplateArgumentLocInfo PCHReader::GetTemplateArgumentLocInfo(TemplateArgument::ArgKind Kind, const RecordData &Record, - unsigned &Index, ExprReader &ExprRdr) { + unsigned &Index) { switch (Kind) { case TemplateArgument::Expression: - return ExprRdr.Read(); + return ReadExpr(); case TemplateArgument::Type: return GetTypeSourceInfo(Record, Index); case TemplateArgument::Template: { @@ -2532,32 +2514,16 @@ PCHReader::GetTemplateArgumentLocInfo(TemplateArgument::ArgKind Kind, return TemplateArgumentLocInfo(); } -TemplateArgumentLocInfo -PCHReader::GetTemplateArgumentLocInfo(TemplateArgument::ArgKind Kind, - const RecordData &Record, - unsigned &Index) { - DeclExprReader DeclExprReader(*this); - return GetTemplateArgumentLocInfo(Kind, Record, Index, DeclExprReader); -} - TemplateArgumentLoc -PCHReader::ReadTemplateArgumentLoc(const RecordData &Record, unsigned &Index, - ExprReader &ExprRdr) { - TemplateArgument Arg = ReadTemplateArgument(Record, Index, ExprRdr); +PCHReader::ReadTemplateArgumentLoc(const RecordData &Record, unsigned &Index) { + TemplateArgument Arg = ReadTemplateArgument(Record, Index); if (Arg.getKind() == TemplateArgument::Expression) { if (Record[Index++]) // bool InfoHasSameExpr. return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo(Arg.getAsExpr())); } return TemplateArgumentLoc(Arg, GetTemplateArgumentLocInfo(Arg.getKind(), - Record, Index, - ExprRdr)); -} - -TemplateArgumentLoc -PCHReader::ReadTemplateArgumentLoc(const RecordData &Record, unsigned &Index) { - DeclExprReader DeclExprReader(*this); - return ReadTemplateArgumentLoc(Record, Index, DeclExprReader); + Record, Index)); } Decl *PCHReader::GetExternalDecl(uint32_t ID) { @@ -2589,7 +2555,7 @@ Stmt *PCHReader::GetExternalDeclStmt(uint64_t Offset) { // Since we know tha this statement is part of a decl, make sure to use the // decl cursor to read it. DeclsCursor.JumpToBit(Offset); - return ReadStmt(DeclsCursor); + return ReadStmtFromStream(DeclsCursor); } bool PCHReader::FindExternalLexicalDecls(const DeclContext *DC, @@ -3034,8 +3000,7 @@ PCHReader::ReadTemplateName(const RecordData &Record, unsigned &Idx) { } TemplateArgument -PCHReader::ReadTemplateArgument(const RecordData &Record, unsigned &Idx, - ExprReader &ExprRdr) { +PCHReader::ReadTemplateArgument(const RecordData &Record, unsigned &Idx) { switch ((TemplateArgument::ArgKind)Record[Idx++]) { case TemplateArgument::Null: return TemplateArgument(); @@ -3051,13 +3016,13 @@ PCHReader::ReadTemplateArgument(const RecordData &Record, unsigned &Idx, case TemplateArgument::Template: return TemplateArgument(ReadTemplateName(Record, Idx)); case TemplateArgument::Expression: - return TemplateArgument(ExprRdr.Read()); + return TemplateArgument(ReadExpr()); case TemplateArgument::Pack: { unsigned NumArgs = Record[Idx++]; llvm::SmallVector Args; Args.reserve(NumArgs); while (NumArgs--) - Args.push_back(ReadTemplateArgument(Record, Idx, ExprRdr)); + Args.push_back(ReadTemplateArgument(Record, Idx)); TemplateArgument TemplArg; TemplArg.setArgumentPack(Args.data(), Args.size(), /*CopyArgs=*/true); return TemplArg; @@ -3068,12 +3033,6 @@ PCHReader::ReadTemplateArgument(const RecordData &Record, unsigned &Idx, return TemplateArgument(); } -TemplateArgument -PCHReader::ReadTemplateArgument(const RecordData &Record, unsigned &Idx) { - DeclExprReader DeclExprReader(*this); - return ReadTemplateArgument(Record, Idx, DeclExprReader); -} - TemplateParameterList * PCHReader::ReadTemplateParameterList(const RecordData &Record, unsigned &Idx) { SourceLocation TemplateLoc = ReadSourceLocation(Record, Idx); diff --git a/lib/Frontend/PCHReaderDecl.cpp b/lib/Frontend/PCHReaderDecl.cpp index d7c5d77eb9..05cefa9ffe 100644 --- a/lib/Frontend/PCHReaderDecl.cpp +++ b/lib/Frontend/PCHReaderDecl.cpp @@ -184,7 +184,7 @@ void PCHDeclReader::VisitValueDecl(ValueDecl *VD) { void PCHDeclReader::VisitEnumConstantDecl(EnumConstantDecl *ECD) { VisitValueDecl(ECD); if (Record[Idx++]) - ECD->setInitExpr(Reader.ReadDeclExpr()); + ECD->setInitExpr(Reader.ReadExpr()); ECD->setInitVal(Reader.ReadAPSInt(Record, Idx)); } @@ -299,7 +299,7 @@ void PCHDeclReader::VisitObjCMethodDecl(ObjCMethodDecl *MD) { if (Record[Idx++]) { // In practice, this won't be executed (since method definitions // don't occur in header files). - MD->setBody(Reader.ReadDeclStmt()); + MD->setBody(Reader.ReadStmt()); MD->setSelfDecl(cast(Reader.GetDecl(Record[Idx++]))); MD->setCmdDecl(cast(Reader.GetDecl(Record[Idx++]))); } @@ -493,7 +493,7 @@ void PCHDeclReader::VisitFieldDecl(FieldDecl *FD) { VisitDeclaratorDecl(FD); FD->setMutable(Record[Idx++]); if (Record[Idx++]) - FD->setBitWidth(Reader.ReadDeclExpr()); + FD->setBitWidth(Reader.ReadExpr()); } void PCHDeclReader::VisitVarDecl(VarDecl *VD) { @@ -508,7 +508,7 @@ void PCHDeclReader::VisitVarDecl(VarDecl *VD) { VD->setPreviousDeclaration( cast_or_null(Reader.GetDecl(Record[Idx++]))); if (Record[Idx++]) - VD->setInit(Reader.ReadDeclExpr()); + VD->setInit(Reader.ReadExpr()); } void PCHDeclReader::VisitImplicitParamDecl(ImplicitParamDecl *PD) { @@ -523,12 +523,12 @@ void PCHDeclReader::VisitParmVarDecl(ParmVarDecl *PD) { void PCHDeclReader::VisitFileScopeAsmDecl(FileScopeAsmDecl *AD) { VisitDecl(AD); - AD->setAsmString(cast(Reader.ReadDeclExpr())); + AD->setAsmString(cast(Reader.ReadExpr())); } void PCHDeclReader::VisitBlockDecl(BlockDecl *BD) { VisitDecl(BD); - BD->setBody(cast_or_null(Reader.ReadDeclStmt())); + BD->setBody(cast_or_null(Reader.ReadStmt())); BD->setSignatureAsWritten(Reader.GetTypeSourceInfo(Record, Idx)); unsigned NumParams = Record[Idx++]; llvm::SmallVector Params; @@ -861,7 +861,7 @@ void PCHDeclReader::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) { D->setPosition(Record[Idx++]); // Rest of NonTypeTemplateParmDecl. if (Record[Idx++]) { - Expr *DefArg = Reader.ReadDeclExpr(); + Expr *DefArg = Reader.ReadExpr(); bool Inherited = Record[Idx++]; D->setDefaultArgument(DefArg, Inherited); } @@ -1106,6 +1106,8 @@ Decl *PCHReader::ReadDeclRecord(uint64_t Offset, unsigned Index) { // after reading this declaration. SavedStreamPosition SavedPosition(DeclsCursor); + ReadingKindTracker ReadingKind(Read_Decl, *this); + // Note that we are loading a declaration record. LoadingTypeOrDecl Loading(*this); diff --git a/lib/Frontend/PCHReaderStmt.cpp b/lib/Frontend/PCHReaderStmt.cpp index 5f27a7da9a..e3ad266350 100644 --- a/lib/Frontend/PCHReaderStmt.cpp +++ b/lib/Frontend/PCHReaderStmt.cpp @@ -19,16 +19,15 @@ using namespace clang; namespace { - class PCHStmtReader : public StmtVisitor { + class PCHStmtReader : public StmtVisitor { PCHReader &Reader; const PCHReader::RecordData &Record; unsigned &Idx; - llvm::SmallVectorImpl &StmtStack; public: PCHStmtReader(PCHReader &Reader, const PCHReader::RecordData &Record, - unsigned &Idx, llvm::SmallVectorImpl &StmtStack) - : Reader(Reader), Record(Record), Idx(Idx), StmtStack(StmtStack) { } + unsigned &Idx) + : Reader(Reader), Record(Record), Idx(Idx) { } /// \brief The number of record fields required for the Stmt class /// itself. @@ -39,225 +38,194 @@ namespace { static const unsigned NumExprFields = NumStmtFields + 3; /// \brief Read and initialize a ExplicitTemplateArgumentList structure. - /// \return the number of Exprs that were read. - unsigned - ReadExplicitTemplateArgumentList(ExplicitTemplateArgumentList &ArgList, - unsigned NumTemplateArgs, - llvm::SmallVectorImpl::iterator EndOfExprs); - - // Each of the Visit* functions reads in part of the expression - // from the given record and the current expression stack, then - // return the total number of operands that it read from the - // expression stack. - - unsigned VisitStmt(Stmt *S); - unsigned VisitNullStmt(NullStmt *S); - unsigned VisitCompoundStmt(CompoundStmt *S); - unsigned VisitSwitchCase(SwitchCase *S); - unsigned VisitCaseStmt(CaseStmt *S); - unsigned VisitDefaultStmt(DefaultStmt *S); - unsigned VisitLabelStmt(LabelStmt *S); - unsigned VisitIfStmt(IfStmt *S); - unsigned VisitSwitchStmt(SwitchStmt *S); - unsigned VisitWhileStmt(WhileStmt *S); - unsigned VisitDoStmt(DoStmt *S); - unsigned VisitForStmt(ForStmt *S); - unsigned VisitGotoStmt(GotoStmt *S); - unsigned VisitIndirectGotoStmt(IndirectGotoStmt *S); - unsigned VisitContinueStmt(ContinueStmt *S); - unsigned VisitBreakStmt(BreakStmt *S); - unsigned VisitReturnStmt(ReturnStmt *S); - unsigned VisitDeclStmt(DeclStmt *S); - unsigned VisitAsmStmt(AsmStmt *S); - unsigned VisitExpr(Expr *E); - unsigned VisitPredefinedExpr(PredefinedExpr *E); - unsigned VisitDeclRefExpr(DeclRefExpr *E); - unsigned VisitIntegerLiteral(IntegerLiteral *E); - unsigned VisitFloatingLiteral(FloatingLiteral *E); - unsigned VisitImaginaryLiteral(ImaginaryLiteral *E); - unsigned VisitStringLiteral(StringLiteral *E); - unsigned VisitCharacterLiteral(CharacterLiteral *E); - unsigned VisitParenExpr(ParenExpr *E); - unsigned VisitUnaryOperator(UnaryOperator *E); - unsigned VisitOffsetOfExpr(OffsetOfExpr *E); - unsigned VisitSizeOfAlignOfExpr(SizeOfAlignOfExpr *E); - unsigned VisitArraySubscriptExpr(ArraySubscriptExpr *E); - unsigned VisitCallExpr(CallExpr *E); - unsigned VisitMemberExpr(MemberExpr *E); - unsigned VisitCastExpr(CastExpr *E); - unsigned VisitBinaryOperator(BinaryOperator *E); - unsigned VisitCompoundAssignOperator(CompoundAssignOperator *E); - unsigned VisitConditionalOperator(ConditionalOperator *E); - unsigned VisitImplicitCastExpr(ImplicitCastExpr *E); - unsigned VisitExplicitCastExpr(ExplicitCastExpr *E); - unsigned VisitCStyleCastExpr(CStyleCastExpr *E); - unsigned VisitCompoundLiteralExpr(CompoundLiteralExpr *E); - unsigned VisitExtVectorElementExpr(ExtVectorElementExpr *E); - unsigned VisitInitListExpr(InitListExpr *E); - unsigned VisitDesignatedInitExpr(DesignatedInitExpr *E); - unsigned VisitImplicitValueInitExpr(ImplicitValueInitExpr *E); - unsigned VisitVAArgExpr(VAArgExpr *E); - unsigned VisitAddrLabelExpr(AddrLabelExpr *E); - unsigned VisitStmtExpr(StmtExpr *E); - unsigned VisitTypesCompatibleExpr(TypesCompatibleExpr *E); - unsigned VisitChooseExpr(ChooseExpr *E); - unsigned VisitGNUNullExpr(GNUNullExpr *E); - unsigned VisitShuffleVectorExpr(ShuffleVectorExpr *E); - unsigned VisitBlockExpr(BlockExpr *E); - unsigned VisitBlockDeclRefExpr(BlockDeclRefExpr *E); - unsigned VisitObjCStringLiteral(ObjCStringLiteral *E); - unsigned VisitObjCEncodeExpr(ObjCEncodeExpr *E); - unsigned VisitObjCSelectorExpr(ObjCSelectorExpr *E); - unsigned VisitObjCProtocolExpr(ObjCProtocolExpr *E); - unsigned VisitObjCIvarRefExpr(ObjCIvarRefExpr *E); - unsigned VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E); - unsigned VisitObjCImplicitSetterGetterRefExpr( + void ReadExplicitTemplateArgumentList(ExplicitTemplateArgumentList &ArgList, + unsigned NumTemplateArgs); + + void VisitStmt(Stmt *S); + void VisitNullStmt(NullStmt *S); + void VisitCompoundStmt(CompoundStmt *S); + void VisitSwitchCase(SwitchCase *S); + void VisitCaseStmt(CaseStmt *S); + void VisitDefaultStmt(DefaultStmt *S); + void VisitLabelStmt(LabelStmt *S); + void VisitIfStmt(IfStmt *S); + void VisitSwitchStmt(SwitchStmt *S); + void VisitWhileStmt(WhileStmt *S); + void VisitDoStmt(DoStmt *S); + void VisitForStmt(ForStmt *S); + void VisitGotoStmt(GotoStmt *S); + void VisitIndirectGotoStmt(IndirectGotoStmt *S); + void VisitContinueStmt(ContinueStmt *S); + void VisitBreakStmt(BreakStmt *S); + void VisitReturnStmt(ReturnStmt *S); + void VisitDeclStmt(DeclStmt *S); + void VisitAsmStmt(AsmStmt *S); + void VisitExpr(Expr *E); + void VisitPredefinedExpr(PredefinedExpr *E); + void VisitDeclRefExpr(DeclRefExpr *E); + void VisitIntegerLiteral(IntegerLiteral *E); + void VisitFloatingLiteral(FloatingLiteral *E); + void VisitImaginaryLiteral(ImaginaryLiteral *E); + void VisitStringLiteral(StringLiteral *E); + void VisitCharacterLiteral(CharacterLiteral *E); + void VisitParenExpr(ParenExpr *E); + void VisitUnaryOperator(UnaryOperator *E); + void VisitOffsetOfExpr(OffsetOfExpr *E); + void VisitSizeOfAlignOfExpr(SizeOfAlignOfExpr *E); + void VisitArraySubscriptExpr(ArraySubscriptExpr *E); + void VisitCallExpr(CallExpr *E); + void VisitMemberExpr(MemberExpr *E); + void VisitCastExpr(CastExpr *E); + void VisitBinaryOperator(BinaryOperator *E); + void VisitCompoundAssignOperator(CompoundAssignOperator *E); + void VisitConditionalOperator(ConditionalOperator *E); + void VisitImplicitCastExpr(ImplicitCastExpr *E); + void VisitExplicitCastExpr(ExplicitCastExpr *E); + void VisitCStyleCastExpr(CStyleCastExpr *E); + void VisitCompoundLiteralExpr(CompoundLiteralExpr *E); + void VisitExtVectorElementExpr(ExtVectorElementExpr *E); + void VisitInitListExpr(InitListExpr *E); + void VisitDesignatedInitExpr(DesignatedInitExpr *E); + void VisitImplicitValueInitExpr(ImplicitValueInitExpr *E); + void VisitVAArgExpr(VAArgExpr *E); + void VisitAddrLabelExpr(AddrLabelExpr *E); + void VisitStmtExpr(StmtExpr *E); + void VisitTypesCompatibleExpr(TypesCompatibleExpr *E); + void VisitChooseExpr(ChooseExpr *E); + void VisitGNUNullExpr(GNUNullExpr *E); + void VisitShuffleVectorExpr(ShuffleVectorExpr *E); + void VisitBlockExpr(BlockExpr *E); + void VisitBlockDeclRefExpr(BlockDeclRefExpr *E); + void VisitObjCStringLiteral(ObjCStringLiteral *E); + void VisitObjCEncodeExpr(ObjCEncodeExpr *E); + void VisitObjCSelectorExpr(ObjCSelectorExpr *E); + void VisitObjCProtocolExpr(ObjCProtocolExpr *E); + void VisitObjCIvarRefExpr(ObjCIvarRefExpr *E); + void VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E); + void VisitObjCImplicitSetterGetterRefExpr( ObjCImplicitSetterGetterRefExpr *E); - unsigned VisitObjCMessageExpr(ObjCMessageExpr *E); - unsigned VisitObjCSuperExpr(ObjCSuperExpr *E); - unsigned VisitObjCIsaExpr(ObjCIsaExpr *E); - - unsigned VisitObjCForCollectionStmt(ObjCForCollectionStmt *); - unsigned VisitObjCAtCatchStmt(ObjCAtCatchStmt *); - unsigned VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *); - unsigned VisitObjCAtTryStmt(ObjCAtTryStmt *); - unsigned VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *); - unsigned VisitObjCAtThrowStmt(ObjCAtThrowStmt *); - - unsigned VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E); - unsigned VisitCXXConstructExpr(CXXConstructExpr *E); - unsigned VisitCXXNamedCastExpr(CXXNamedCastExpr *E); - unsigned VisitCXXStaticCastExpr(CXXStaticCastExpr *E); - unsigned VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E); - unsigned VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E); - unsigned VisitCXXConstCastExpr(CXXConstCastExpr *E); - unsigned VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E); - unsigned VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E); - unsigned VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E); - unsigned VisitCXXTypeidExpr(CXXTypeidExpr *E); - unsigned VisitCXXThisExpr(CXXThisExpr *E); - unsigned VisitCXXThrowExpr(CXXThrowExpr *E); - unsigned VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E); - unsigned VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E); + void VisitObjCMessageExpr(ObjCMessageExpr *E); + void VisitObjCSuperExpr(ObjCSuperExpr *E); + void VisitObjCIsaExpr(ObjCIsaExpr *E); + + void VisitObjCForCollectionStmt(ObjCForCollectionStmt *); + void VisitObjCAtCatchStmt(ObjCAtCatchStmt *); + void VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *); + void VisitObjCAtTryStmt(ObjCAtTryStmt *); + void VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *); + void VisitObjCAtThrowStmt(ObjCAtThrowStmt *); + + void VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E); + void VisitCXXConstructExpr(CXXConstructExpr *E); + void VisitCXXNamedCastExpr(CXXNamedCastExpr *E); + void VisitCXXStaticCastExpr(CXXStaticCastExpr *E); + void VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E); + void VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E); + void VisitCXXConstCastExpr(CXXConstCastExpr *E); + void VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E); + void VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E); + void VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E); + void VisitCXXTypeidExpr(CXXTypeidExpr *E); + void VisitCXXThisExpr(CXXThisExpr *E); + void VisitCXXThrowExpr(CXXThrowExpr *E); + void VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E); + void VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E); - unsigned VisitCXXZeroInitValueExpr(CXXZeroInitValueExpr *E); - unsigned VisitCXXNewExpr(CXXNewExpr *E); - unsigned VisitCXXDeleteExpr(CXXDeleteExpr *E); - unsigned VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E); + void VisitCXXZeroInitValueExpr(CXXZeroInitValueExpr *E); + void VisitCXXNewExpr(CXXNewExpr *E); + void VisitCXXDeleteExpr(CXXDeleteExpr *E); + void VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E); - unsigned VisitCXXExprWithTemporaries(CXXExprWithTemporaries *E); + void VisitCXXExprWithTemporaries(CXXExprWithTemporaries *E); - unsigned VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E); - unsigned VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E); - unsigned VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E); + void VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E); + void VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E); + void VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E); - unsigned VisitOverloadExpr(OverloadExpr *E); - unsigned VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E); - unsigned VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E); + void VisitOverloadExpr(OverloadExpr *E); + void VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E); + void VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E); }; } -unsigned PCHStmtReader:: +void PCHStmtReader:: ReadExplicitTemplateArgumentList(ExplicitTemplateArgumentList &ArgList, - unsigned NumTemplateArgs, - llvm::SmallVectorImpl::iterator EndOfExprs) { - - class StmtStackExprReader : public PCHReader::ExprReader { - llvm::SmallVectorImpl::iterator StmtI; - public: - StmtStackExprReader(const llvm::SmallVectorImpl::iterator &stmtI) - : StmtI(stmtI) { } - virtual Expr *Read() { return cast_or_null(*StmtI++); } - }; - - unsigned NumExprs = Record[Idx++]; - + unsigned NumTemplateArgs) { TemplateArgumentListInfo ArgInfo; ArgInfo.setLAngleLoc(Reader.ReadSourceLocation(Record, Idx)); ArgInfo.setRAngleLoc(Reader.ReadSourceLocation(Record, Idx)); - - StmtStackExprReader ExprReader(EndOfExprs - NumExprs); for (unsigned i = 0; i != NumTemplateArgs; ++i) - ArgInfo.addArgument(Reader.ReadTemplateArgumentLoc(Record, Idx, - ExprReader)); + ArgInfo.addArgument(Reader.ReadTemplateArgumentLoc(Record, Idx)); ArgList.initializeFrom(ArgInfo); - - return NumExprs; } -unsigned PCHStmtReader::VisitStmt(Stmt *S) { +void PCHStmtReader::VisitStmt(Stmt *S) { assert(Idx == NumStmtFields && "Incorrect statement field count"); - return 0; } -unsigned PCHStmtReader::VisitNullStmt(NullStmt *S) { +void PCHStmtReader::VisitNullStmt(NullStmt *S) { VisitStmt(S); S->setSemiLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); - return 0; } -unsigned PCHStmtReader::VisitCompoundStmt(CompoundStmt *S) { +void PCHStmtReader::VisitCompoundStmt(CompoundStmt *S) { VisitStmt(S); + llvm::SmallVector Stmts; unsigned NumStmts = Record[Idx++]; - S->setStmts(*Reader.getContext(), - StmtStack.data() + StmtStack.size() - NumStmts, NumStmts); + while (NumStmts--) + Stmts.push_back(Reader.ReadStmt()); + S->setStmts(*Reader.getContext(), Stmts.data(), Stmts.size()); S->setLBracLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); S->setRBracLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); - return NumStmts; } -unsigned PCHStmtReader::VisitSwitchCase(SwitchCase *S) { +void PCHStmtReader::VisitSwitchCase(SwitchCase *S) { VisitStmt(S); Reader.RecordSwitchCaseID(S, Record[Idx++]); - return 0; } -unsigned PCHStmtReader::VisitCaseStmt(CaseStmt *S) { +void PCHStmtReader::VisitCaseStmt(CaseStmt *S) { VisitSwitchCase(S); - S->setLHS(cast(StmtStack[StmtStack.size() - 3])); - S->setRHS(cast_or_null(StmtStack[StmtStack.size() - 2])); - S->setSubStmt(StmtStack.back()); + S->setLHS(Reader.ReadExpr()); + S->setRHS(Reader.ReadExpr()); + S->setSubStmt(Reader.ReadStmt()); S->setCaseLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); S->setEllipsisLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); S->setColonLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); - return 3; } -unsigned PCHStmtReader::VisitDefaultStmt(DefaultStmt *S) { +void PCHStmtReader::VisitDefaultStmt(DefaultStmt *S) { VisitSwitchCase(S); - S->setSubStmt(StmtStack.back()); + S->setSubStmt(Reader.ReadStmt()); S->setDefaultLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); S->setColonLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); - return 1; } -unsigned PCHStmtReader::VisitLabelStmt(LabelStmt *S) { +void PCHStmtReader::VisitLabelStmt(LabelStmt *S) { VisitStmt(S); S->setID(Reader.GetIdentifierInfo(Record, Idx)); - S->setSubStmt(StmtStack.back()); + S->setSubStmt(Reader.ReadStmt()); S->setIdentLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); Reader.RecordLabelStmt(S, Record[Idx++]); - return 1; } -unsigned PCHStmtReader::VisitIfStmt(IfStmt *S) { +void PCHStmtReader::VisitIfStmt(IfStmt *S) { VisitStmt(S); S->setConditionVariable(*Reader.getContext(), cast_or_null(Reader.GetDecl(Record[Idx++]))); - S->setCond(cast(StmtStack[StmtStack.size() - 3])); - S->setThen(StmtStack[StmtStack.size() - 2]); - S->setElse(StmtStack[StmtStack.size() - 1]); + S->setCond(Reader.ReadExpr()); + S->setThen(Reader.ReadStmt()); + S->setElse(Reader.ReadStmt()); S->setIfLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); S->setElseLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); - return 3; } -unsigned PCHStmtReader::VisitSwitchStmt(SwitchStmt *S) { +void PCHStmtReader::VisitSwitchStmt(SwitchStmt *S) { VisitStmt(S); S->setConditionVariable(*Reader.getContext(), cast_or_null(Reader.GetDecl(Record[Idx++]))); - S->setCond(cast(StmtStack[StmtStack.size() - 2])); - S->setBody(StmtStack.back()); + S->setCond(Reader.ReadExpr()); + S->setBody(Reader.ReadStmt()); S->setSwitchLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); SwitchCase *PrevSC = 0; for (unsigned N = Record.size(); Idx != N; ++Idx) { @@ -272,80 +240,71 @@ unsigned PCHStmtReader::VisitSwitchStmt(SwitchStmt *S) { SC->Retain(); PrevSC = SC; } - return 2; } -unsigned PCHStmtReader::VisitWhileStmt(WhileStmt *S) { +void PCHStmtReader::VisitWhileStmt(WhileStmt *S) { VisitStmt(S); S->setConditionVariable(*Reader.getContext(), cast_or_null(Reader.GetDecl(Record[Idx++]))); - S->setCond(cast_or_null(StmtStack[StmtStack.size() - 2])); - S->setBody(StmtStack.back()); + S->setCond(Reader.ReadExpr()); + S->setBody(Reader.ReadStmt()); S->setWhileLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); - return 2; } -unsigned PCHStmtReader::VisitDoStmt(DoStmt *S) { +void PCHStmtReader::VisitDoStmt(DoStmt *S) { VisitStmt(S); - S->setCond(cast_or_null(StmtStack[StmtStack.size() - 2])); - S->setBody(StmtStack.back()); + S->setCond(Reader.ReadExpr()); + S->setBody(Reader.ReadStmt()); S->setDoLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); S->setWhileLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); S->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); - return 2; } -unsigned PCHStmtReader::VisitForStmt(ForStmt *S) { +void PCHStmtReader::VisitForStmt(ForStmt *S) { VisitStmt(S); - S->setInit(StmtStack[StmtStack.size() - 4]); - S->setCond(cast_or_null(StmtStack[StmtStack.size() - 3])); + S->setInit(Reader.ReadStmt()); + S->setCond(Reader.ReadExpr()); S->setConditionVariable(*Reader.getContext(), cast_or_null(Reader.GetDecl(Record[Idx++]))); - S->setInc(cast_or_null(StmtStack[StmtStack.size() - 2])); - S->setBody(StmtStack.back()); + S->setInc(Reader.ReadExpr()); + S->setBody(Reader.ReadStmt()); S->setForLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); S->setLParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); S->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); - return 4; } -unsigned PCHStmtReader::VisitGotoStmt(GotoStmt *S) { +void PCHStmtReader::VisitGotoStmt(GotoStmt *S) { VisitStmt(S); Reader.SetLabelOf(S, Record[Idx++]); S->setGotoLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); S->setLabelLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); - return 0; } -unsigned PCHStmtReader::VisitIndirectGotoStmt(IndirectGotoStmt *S) { +void PCHStmtReader::VisitIndirectGotoStmt(IndirectGotoStmt *S) { VisitStmt(S); S->setGotoLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); S->setStarLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); - S->setTarget(cast_or_null(StmtStack.back())); - return 1; + S->setTarget(Reader.ReadExpr()); } -unsigned PCHStmtReader::VisitContinueStmt(ContinueStmt *S) { +void PCHStmtReader::VisitContinueStmt(ContinueStmt *S) { VisitStmt(S); S->setContinueLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); - return 0; } -unsigned PCHStmtReader::VisitBreakStmt(BreakStmt *S) { +void PCHStmtReader::VisitBreakStmt(BreakStmt *S) { VisitStmt(S); S->setBreakLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); - return 0; } -unsigned PCHStmtReader::VisitReturnStmt(ReturnStmt *S) { +void PCHStmtReader::VisitReturnStmt(ReturnStmt *S) { VisitStmt(S); - S->setRetValue(cast_or_null(StmtStack.back())); + S->setRetValue(Reader.ReadExpr()); S->setReturnLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); S->setNRVOCandidate(cast_or_null(Reader.GetDecl(Record[Idx++]))); - return 1; } -unsigned PCHStmtReader::VisitDeclStmt(DeclStmt *S) { +void PCHStmtReader::VisitDeclStmt(DeclStmt *S) { VisitStmt(S); S->setStartLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); S->setEndLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); @@ -362,10 +321,9 @@ unsigned PCHStmtReader::VisitDeclStmt(DeclStmt *S) { Decls.data(), Decls.size()))); } - return 0; } -unsigned PCHStmtReader::VisitAsmStmt(AsmStmt *S) { +void PCHStmtReader::VisitAsmStmt(AsmStmt *S) { VisitStmt(S); unsigned NumOutputs = Record[Idx++]; unsigned NumInputs = Record[Idx++]; @@ -376,9 +334,7 @@ unsigned PCHStmtReader::VisitAsmStmt(AsmStmt *S) { S->setSimple(Record[Idx++]); S->setMSAsm(Record[Idx++]); - unsigned StackIdx - = StmtStack.size() - (NumOutputs*2 + NumInputs*2 + NumClobbers + 1); - S->setAsmString(cast_or_null(StmtStack[StackIdx++])); + S->setAsmString(cast_or_null(Reader.ReadStmt())); // Outputs and inputs llvm::SmallVector Names; @@ -386,71 +342,62 @@ unsigned PCHStmtReader::VisitAsmStmt(AsmStmt *S) { llvm::SmallVector Exprs; for (unsigned I = 0, N = NumOutputs + NumInputs; I != N; ++I) { Names.push_back(Reader.GetIdentifierInfo(Record, Idx)); - Constraints.push_back(cast_or_null(StmtStack[StackIdx++])); - Exprs.push_back(StmtStack[StackIdx++]); + Constraints.push_back(cast_or_null(Reader.ReadStmt())); + Exprs.push_back(Reader.ReadStmt()); } // Constraints llvm::SmallVector Clobbers; for (unsigned I = 0; I != NumClobbers; ++I) - Clobbers.push_back(cast_or_null(StmtStack[StackIdx++])); + Clobbers.push_back(cast_or_null(Reader.ReadStmt())); S->setOutputsAndInputsAndClobbers(*Reader.getContext(), Names.data(), Constraints.data(), Exprs.data(), NumOutputs, NumInputs, Clobbers.data(), NumClobbers); - - assert(StackIdx == StmtStack.size() && "Error deserializing AsmStmt"); - return NumOutputs*2 + NumInputs*2 + NumClobbers + 1; } -unsigned PCHStmtReader::VisitExpr(Expr *E) { +void PCHStmtReader::VisitExpr(Expr *E) { VisitStmt(E); E->setType(Reader.GetType(Record[Idx++])); E->setTypeDependent(Record[Idx++]); E->setValueDependent(Record[Idx++]); assert(Idx == NumExprFields && "Incorrect expression field count"); - return 0; } -unsigned PCHStmtReader::VisitPredefinedExpr(PredefinedExpr *E) { +void PCHStmtReader::VisitPredefinedExpr(PredefinedExpr *E) { VisitExpr(E); E->setLocation(SourceLocation::getFromRawEncoding(Record[Idx++])); E->setIdentType((PredefinedExpr::IdentType)Record[Idx++]); - return 0; } -unsigned PCHStmtReader::VisitDeclRefExpr(DeclRefExpr *E) { +void PCHStmtReader::VisitDeclRefExpr(DeclRefExpr *E) { VisitExpr(E); E->setDecl(cast(Reader.GetDecl(Record[Idx++]))); E->setLocation(SourceLocation::getFromRawEncoding(Record[Idx++])); // FIXME: read qualifier // FIXME: read explicit template arguments - return 0; } -unsigned PCHStmtReader::VisitIntegerLiteral(IntegerLiteral *E) { +void PCHStmtReader::VisitIntegerLiteral(IntegerLiteral *E) { VisitExpr(E); E->setLocation(SourceLocation::getFromRawEncoding(Record[Idx++])); E->setValue(Reader.ReadAPInt(Record, Idx)); - return 0; } -unsigned PCHStmtReader::VisitFloatingLiteral(FloatingLiteral *E) { +void PCHStmtReader::VisitFloatingLiteral(FloatingLiteral *E) { VisitExpr(E); E->setValue(Reader.ReadAPFloat(Record, Idx)); E->setExact(Record[Idx++]); E->setLocation(SourceLocation::getFromRawEncoding(Record[Idx++])); - return 0; } -unsigned PCHStmtReader::VisitImaginaryLiteral(ImaginaryLiteral *E) { +void PCHStmtReader::VisitImaginaryLiteral(ImaginaryLiteral *E) { VisitExpr(E); - E->setSubExpr(cast(StmtStack.back())); - return 1; + E->setSubExpr(Reader.ReadExpr()); } -unsigned PCHStmtReader::VisitStringLiteral(StringLiteral *E) { +void PCHStmtReader::VisitStringLiteral(StringLiteral *E) { VisitExpr(E); unsigned Len = Record[Idx++]; assert(Record[Idx] == E->getNumConcatenated() && @@ -466,35 +413,30 @@ unsigned PCHStmtReader::VisitStringLiteral(StringLiteral *E) { // Read source locations for (unsigned I = 0, N = E->getNumConcatenated(); I != N; ++I) E->setStrTokenLoc(I, SourceLocation::getFromRawEncoding(Record[Idx++])); - - return 0; } -unsigned PCHStmtReader::VisitCharacterLiteral(CharacterLiteral *E) { +void PCHStmtReader::VisitCharacterLiteral(CharacterLiteral *E) { VisitExpr(E); E->setValue(Record[Idx++]); E->setLocation(SourceLocation::getFromRawEncoding(Record[Idx++])); E->setWide(Record[Idx++]); - return 0; } -unsigned PCHStmtReader::VisitParenExpr(ParenExpr *E) { +void PCHStmtReader::VisitParenExpr(ParenExpr *E) { VisitExpr(E); E->setLParen(SourceLocation::getFromRawEncoding(Record[Idx++])); E->setRParen(SourceLocation::getFromRawEncoding(Record[Idx++])); - E->setSubExpr(cast(StmtStack.back())); - return 1; + E->setSubExpr(Reader.ReadExpr()); } -unsigned PCHStmtReader::VisitUnaryOperator(UnaryOperator *E) { +void PCHStmtReader::VisitUnaryOperator(UnaryOperator *E) { VisitExpr(E); - E->setSubExpr(cast(StmtStack.back())); + E->setSubExpr(Reader.ReadExpr()); E->setOpcode((UnaryOperator::Opcode)Record[Idx++]); E->setOperatorLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); - return 1; } -unsigned PCHStmtReader::VisitOffsetOfExpr(OffsetOfExpr *E) { +void PCHStmtReader::VisitOffsetOfExpr(OffsetOfExpr *E) { typedef OffsetOfExpr::OffsetOfNode Node; VisitExpr(E); assert(E->getNumComponents() == Record[Idx]); @@ -532,153 +474,135 @@ unsigned PCHStmtReader::VisitOffsetOfExpr(OffsetOfExpr *E) { } for (unsigned I = 0, N = E->getNumExpressions(); I != N; ++I) - E->setIndexExpr(I, cast_or_null(StmtStack[StmtStack.size() - N + I])); - - return E->getNumExpressions(); + E->setIndexExpr(I, Reader.ReadExpr()); } -unsigned PCHStmtReader::VisitSizeOfAlignOfExpr(SizeOfAlignOfExpr *E) { +void PCHStmtReader::VisitSizeOfAlignOfExpr(SizeOfAlignOfExpr *E) { VisitExpr(E); E->setSizeof(Record[Idx++]); if (Record[Idx] == 0) { - E->setArgument(cast(StmtStack.back())); + E->setArgument(Reader.ReadExpr()); ++Idx; } else { E->setArgument(Reader.GetTypeSourceInfo(Record, Idx)); } E->setOperatorLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); E->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); - return E->isArgumentType()? 0 : 1; } -unsigned PCHStmtReader::VisitArraySubscriptExpr(ArraySubscriptExpr *E) { +void PCHStmtReader::VisitArraySubscriptExpr(ArraySubscriptExpr *E) { VisitExpr(E); - E->setLHS(cast(StmtStack[StmtStack.size() - 2])); - E->setRHS(cast(StmtStack[StmtStack.size() - 1])); + E->setLHS(Reader.ReadExpr()); + E->setRHS(Reader.ReadExpr()); E->setRBracketLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); - return 2; } -unsigned PCHStmtReader::VisitCallExpr(CallExpr *E) { +void PCHStmtReader::VisitCallExpr(CallExpr *E) { VisitExpr(E); E->setNumArgs(*Reader.getContext(), Record[Idx++]); E->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); - E->setCallee(cast(StmtStack[StmtStack.size() - E->getNumArgs() - 1])); + E->setCallee(Reader.ReadExpr()); for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) - E->setArg(I, cast(StmtStack[StmtStack.size() - N + I])); - return E->getNumArgs() + 1; + E->setArg(I, Reader.ReadExpr()); } -unsigned PCHStmtReader::VisitMemberExpr(MemberExpr *E) { +void PCHStmtReader::VisitMemberExpr(MemberExpr *E) { VisitExpr(E); - E->setBase(cast(StmtStack.back())); + E->setBase(Reader.ReadExpr()); E->setMemberDecl(cast(Reader.GetDecl(Record[Idx++]))); E->setMemberLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); E->setArrow(Record[Idx++]); - return 1; } -unsigned PCHStmtReader::VisitObjCIsaExpr(ObjCIsaExpr *E) { +void PCHStmtReader::VisitObjCIsaExpr(ObjCIsaExpr *E) { VisitExpr(E); - E->setBase(cast(StmtStack.back())); + E->setBase(Reader.ReadExpr()); E->setIsaMemberLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); E->setArrow(Record[Idx++]); - return 1; } -unsigned PCHStmtReader::VisitCastExpr(CastExpr *E) { +void PCHStmtReader::VisitCastExpr(CastExpr *E) { VisitExpr(E); - E->setSubExpr(cast(StmtStack.back())); + E->setSubExpr(Reader.ReadExpr()); E->setCastKind((CastExpr::CastKind)Record[Idx++]); - return 1; } -unsigned PCHStmtReader::VisitBinaryOperator(BinaryOperator *E) { +void PCHStmtReader::VisitBinaryOperator(BinaryOperator *E) { VisitExpr(E); - E->setLHS(cast(StmtStack.end()[-2])); - E->setRHS(cast(StmtStack.end()[-1])); + E->setLHS(Reader.ReadExpr()); + E->setRHS(Reader.ReadExpr()); E->setOpcode((BinaryOperator::Opcode)Record[Idx++]); E->setOperatorLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); - return 2; } -unsigned PCHStmtReader::VisitCompoundAssignOperator(CompoundAssignOperator *E) { +void PCHStmtReader::VisitCompoundAssignOperator(CompoundAssignOperator *E) { VisitBinaryOperator(E); E->setComputationLHSType(Reader.GetType(Record[Idx++])); E->setComputationResultType(Reader.GetType(Record[Idx++])); - return 2; } -unsigned PCHStmtReader::VisitConditionalOperator(ConditionalOperator *E) { +void PCHStmtReader::VisitConditionalOperator(ConditionalOperator *E) { VisitExpr(E); - E->setCond(cast(StmtStack[StmtStack.size() - 3])); - E->setLHS(cast_or_null(StmtStack[StmtStack.size() - 2])); - E->setRHS(cast_or_null(StmtStack[StmtStack.size() - 1])); + E->setCond(Reader.ReadExpr()); + E->setLHS(Reader.ReadExpr()); + E->setRHS(Reader.ReadExpr()); E->setQuestionLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); E->setColonLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); - return 3; } -unsigned PCHStmtReader::VisitImplicitCastExpr(ImplicitCastExpr *E) { +void PCHStmtReader::VisitImplicitCastExpr(ImplicitCastExpr *E) { VisitCastExpr(E); E->setLvalueCast(Record[Idx++]); - return 1; } -unsigned PCHStmtReader::VisitExplicitCastExpr(ExplicitCastExpr *E) { +void PCHStmtReader::VisitExplicitCastExpr(ExplicitCastExpr *E) { VisitCastExpr(E); E->setTypeInfoAsWritten(Reader.GetTypeSourceInfo(Record, Idx)); - return 1; } -unsigned PCHStmtReader::VisitCStyleCastExpr(CStyleCastExpr *E) { +void PCHStmtReader::VisitCStyleCastExpr(CStyleCastExpr *E) { VisitExplicitCastExpr(E); E->setLParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); E->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); - return 1; } -unsigned PCHStmtReader::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) { +void PCHStmtReader::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) { VisitExpr(E); E->setLParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); E->setTypeSourceInfo(Reader.GetTypeSourceInfo(Record, Idx)); - E->setInitializer(cast(StmtStack.back())); + E->setInitializer(Reader.ReadExpr()); E->setFileScope(Record[Idx++]); - return 1; } -unsigned PCHStmtReader::VisitExtVectorElementExpr(ExtVectorElementExpr *E) { +void PCHStmtReader::VisitExtVectorElementExpr(ExtVectorElementExpr *E) { VisitExpr(E); - E->setBase(cast(StmtStack.back())); + E->setBase(Reader.ReadExpr()); E->setAccessor(Reader.GetIdentifierInfo(Record, Idx)); E->setAccessorLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); - return 1; } -unsigned PCHStmtReader::VisitInitListExpr(InitListExpr *E) { +void PCHStmtReader::VisitInitListExpr(InitListExpr *E) { VisitExpr(E); unsigned NumInits = Record[Idx++]; E->reserveInits(*Reader.getContext(), NumInits); for (unsigned I = 0; I != NumInits; ++I) - E->updateInit(*Reader.getContext(), I, - cast(StmtStack[StmtStack.size() - NumInits - 1 + I])); - E->setSyntacticForm(cast_or_null(StmtStack.back())); + E->updateInit(*Reader.getContext(), I, Reader.ReadExpr()); + E->setSyntacticForm(cast_or_null(Reader.ReadStmt())); E->setLBraceLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); E->setRBraceLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); E->setInitializedFieldInUnion( cast_or_null(Reader.GetDecl(Record[Idx++]))); E->sawArrayRangeDesignator(Record[Idx++]); - return NumInits + 1; } -unsigned PCHStmtReader::VisitDesignatedInitExpr(DesignatedInitExpr *E) { +void PCHStmtReader::VisitDesignatedInitExpr(DesignatedInitExpr *E) { typedef DesignatedInitExpr::Designator Designator; VisitExpr(E); unsigned NumSubExprs = Record[Idx++]; assert(NumSubExprs == E->getNumSubExprs() && "Wrong number of subexprs"); for (unsigned I = 0; I != NumSubExprs; ++I) - E->setSubExpr(I, cast(StmtStack[StmtStack.size() - NumSubExprs + I])); + E->setSubExpr(I, Reader.ReadExpr()); E->setEqualOrColonLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); E->setGNUSyntax(Record[Idx++]); @@ -733,144 +657,128 @@ unsigned PCHStmtReader::VisitDesignatedInitExpr(DesignatedInitExpr *E) { } E->setDesignators(*Reader.getContext(), Designators.data(), Designators.size()); - - return NumSubExprs; } -unsigned PCHStmtReader::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) { +void PCHStmtReader::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) { VisitExpr(E); - return 0; } -unsigned PCHStmtReader::VisitVAArgExpr(VAArgExpr *E) { +void PCHStmtReader::VisitVAArgExpr(VAArgExpr *E) { VisitExpr(E); - E->setSubExpr(cast(StmtStack.back())); + E->setSubExpr(Reader.ReadExpr()); E->setBuiltinLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); E->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); - return 1; } -unsigned PCHStmtReader::VisitAddrLabelExpr(AddrLabelExpr *E) { +void PCHStmtReader::VisitAddrLabelExpr(AddrLabelExpr *E) { VisitExpr(E); E->setAmpAmpLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); E->setLabelLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); Reader.SetLabelOf(E, Record[Idx++]); - return 0; } -unsigned PCHStmtReader::VisitStmtExpr(StmtExpr *E) { +void PCHStmtReader::VisitStmtExpr(StmtExpr *E) { VisitExpr(E); E->setLParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); E->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); - E->setSubStmt(cast_or_null(StmtStack.back())); - return 1; + E->setSubStmt(cast_or_null(Reader.ReadStmt())); } -unsigned PCHStmtReader::VisitTypesCompatibleExpr(TypesCompatibleExpr *E) { +void PCHStmtReader::VisitTypesCompatibleExpr(TypesCompatibleExpr *E) { VisitExpr(E); E->setArgType1(Reader.GetType(Record[Idx++])); E->setArgType2(Reader.GetType(Record[Idx++])); E->setBuiltinLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); E->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); - return 0; } -unsigned PCHStmtReader::VisitChooseExpr(ChooseExpr *E) { +void PCHStmtReader::VisitChooseExpr(ChooseExpr *E) { VisitExpr(E); - E->setCond(cast(StmtStack[StmtStack.size() - 3])); - E->setLHS(cast_or_null(StmtStack[StmtStack.size() - 2])); - E->setRHS(cast_or_null(StmtStack[StmtStack.size() - 1])); + E->setCond(Reader.ReadExpr()); + E->setLHS(Reader.ReadExpr()); + E->setRHS(Reader.ReadExpr()); E->setBuiltinLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); E->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); - return 3; } -unsigned PCHStmtReader::VisitGNUNullExpr(GNUNullExpr *E) { +void PCHStmtReader::VisitGNUNullExpr(GNUNullExpr *E) { VisitExpr(E); E->setTokenLocation(SourceLocation::getFromRawEncoding(Record[Idx++])); - return 0; } -unsigned PCHStmtReader::VisitShuffleVectorExpr(ShuffleVectorExpr *E) { +void PCHStmtReader::VisitShuffleVectorExpr(ShuffleVectorExpr *E) { VisitExpr(E); + llvm::SmallVector Exprs; unsigned NumExprs = Record[Idx++]; - E->setExprs(*Reader.getContext(), - (Expr **)&StmtStack[StmtStack.size() - NumExprs], NumExprs); + while (NumExprs--) + Exprs.push_back(Reader.ReadExpr()); + E->setExprs(*Reader.getContext(), Exprs.data(), Exprs.size()); E->setBuiltinLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); E->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); - return NumExprs; } -unsigned PCHStmtReader::VisitBlockExpr(BlockExpr *E) { +void PCHStmtReader::VisitBlockExpr(BlockExpr *E) { VisitExpr(E); E->setBlockDecl(cast_or_null(Reader.GetDecl(Record[Idx++]))); E->setHasBlockDeclRefExprs(Record[Idx++]); - return 0; } -unsigned PCHStmtReader::VisitBlockDeclRefExpr(BlockDeclRefExpr *E) { +void PCHStmtReader::VisitBlockDeclRefExpr(BlockDeclRefExpr *E) { VisitExpr(E); E->setDecl(cast(Reader.GetDecl(Record[Idx++]))); E->setLocation(SourceLocation::getFromRawEncoding(Record[Idx++])); E->setByRef(Record[Idx++]); E->setConstQualAdded(Record[Idx++]); - E->setCopyConstructorExpr(cast_or_null(StmtStack.back())); - return 1; + E->setCopyConstructorExpr(Reader.ReadExpr()); } //===----------------------------------------------------------------------===// // Objective-C Expressions and Statements -unsigned PCHStmtReader::VisitObjCStringLiteral(ObjCStringLiteral *E) { +void PCHStmtReader::VisitObjCStringLiteral(ObjCStringLiteral *E) { VisitExpr(E); - E->setString(cast(StmtStack.back())); + E->setString(cast(Reader.ReadStmt())); E->setAtLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); - return 1; } -unsigned PCHStmtReader::VisitObjCEncodeExpr(ObjCEncodeExpr *E) { +void PCHStmtReader::VisitObjCEncodeExpr(ObjCEncodeExpr *E) { VisitExpr(E); E->setEncodedTypeSourceInfo(Reader.GetTypeSourceInfo(Record, Idx)); E->setAtLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); E->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); - return 0; } -unsigned PCHStmtReader::VisitObjCSelectorExpr(ObjCSelectorExpr *E) { +void PCHStmtReader::VisitObjCSelectorExpr(ObjCSelectorExpr *E) { VisitExpr(E); E->setSelector(Reader.GetSelector(Record, Idx)); E->setAtLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); E->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); - return 0; } -unsigned PCHStmtReader::VisitObjCProtocolExpr(ObjCProtocolExpr *E) { +void PCHStmtReader::VisitObjCProtocolExpr(ObjCProtocolExpr *E) { VisitExpr(E); E->setProtocol(cast(Reader.GetDecl(Record[Idx++]))); E->setAtLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); E->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); - return 0; } -unsigned PCHStmtReader::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) { +void PCHStmtReader::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) { VisitExpr(E); E->setDecl(cast(Reader.GetDecl(Record[Idx++]))); E->setLocation(SourceLocation::getFromRawEncoding(Record[Idx++])); - E->setBase(cast(StmtStack.back())); + E->setBase(Reader.ReadExpr()); E->setIsArrow(Record[Idx++]); E->setIsFreeIvar(Record[Idx++]); - return 1; } -unsigned PCHStmtReader::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) { +void PCHStmtReader::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) { VisitExpr(E); E->setProperty(cast(Reader.GetDecl(Record[Idx++]))); E->setLocation(SourceLocation::getFromRawEncoding(Record[Idx++])); - E->setBase(cast(StmtStack.back())); - return 1; + E->setBase(Reader.ReadExpr()); } -unsigned PCHStmtReader::VisitObjCImplicitSetterGetterRefExpr( +void PCHStmtReader::VisitObjCImplicitSetterGetterRefExpr( ObjCImplicitSetterGetterRefExpr *E) { VisitExpr(E); E->setGetterMethod( @@ -879,13 +787,12 @@ unsigned PCHStmtReader::VisitObjCImplicitSetterGetterRefExpr( cast_or_null(Reader.GetDecl(Record[Idx++]))); E->setInterfaceDecl( cast_or_null(Reader.GetDecl(Record[Idx++]))); - E->setBase(cast_or_null(StmtStack.back())); + E->setBase(Reader.ReadExpr()); E->setLocation(SourceLocation::getFromRawEncoding(Record[Idx++])); E->setClassLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); - return 1; } -unsigned PCHStmtReader::VisitObjCMessageExpr(ObjCMessageExpr *E) { +void PCHStmtReader::VisitObjCMessageExpr(ObjCMessageExpr *E) { VisitExpr(E); assert(Record[Idx] == E->getNumArgs()); ++Idx; @@ -893,8 +800,7 @@ unsigned PCHStmtReader::VisitObjCMessageExpr(ObjCMessageExpr *E) { = static_cast(Record[Idx++]); switch (Kind) { case ObjCMessageExpr::Instance: - E->setInstanceReceiver( - cast_or_null(StmtStack[StmtStack.size() - E->getNumArgs() - 1])); + E->setInstanceReceiver(Reader.ReadExpr()); break; case ObjCMessageExpr::Class: @@ -921,193 +827,168 @@ unsigned PCHStmtReader::VisitObjCMessageExpr(ObjCMessageExpr *E) { E->setRightLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) - E->setArg(I, cast(StmtStack[StmtStack.size() - N + I])); - return E->getNumArgs() + (Kind == ObjCMessageExpr::Instance); + E->setArg(I, Reader.ReadExpr()); } -unsigned PCHStmtReader::VisitObjCSuperExpr(ObjCSuperExpr *E) { +void PCHStmtReader::VisitObjCSuperExpr(ObjCSuperExpr *E) { VisitExpr(E); E->setLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); - return 0; } -unsigned PCHStmtReader::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) { +void PCHStmtReader::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) { VisitStmt(S); - S->setElement(cast_or_null(StmtStack[StmtStack.size() - 3])); - S->setCollection(cast_or_null(StmtStack[StmtStack.size() - 2])); - S->setBody(cast_or_null(StmtStack[StmtStack.size() - 1])); + S->setElement(Reader.ReadStmt()); + S->setCollection(Reader.ReadExpr()); + S->setBody(Reader.ReadStmt()); S->setForLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); S->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); - return 3; } -unsigned PCHStmtReader::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) { +void PCHStmtReader::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) { VisitStmt(S); - S->setCatchBody(cast_or_null(StmtStack.back())); + S->setCatchBody(Reader.ReadStmt()); S->setCatchParamDecl(cast_or_null(Reader.GetDecl(Record[Idx++]))); S->setAtCatchLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); S->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); - return 1; } -unsigned PCHStmtReader::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) { +void PCHStmtReader::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) { VisitStmt(S); - S->setFinallyBody(StmtStack.back()); + S->setFinallyBody(Reader.ReadStmt()); S->setAtFinallyLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); - return 1; } -unsigned PCHStmtReader::VisitObjCAtTryStmt(ObjCAtTryStmt *S) { +void PCHStmtReader::VisitObjCAtTryStmt(ObjCAtTryStmt *S) { VisitStmt(S); assert(Record[Idx] == S->getNumCatchStmts()); ++Idx; bool HasFinally = Record[Idx++]; - for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I) { - unsigned Offset = StmtStack.size() - N - HasFinally + I; - S->setCatchStmt(I, cast_or_null(StmtStack[Offset])); - } + S->setTryBody(Reader.ReadStmt()); + for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I) + S->setCatchStmt(I, cast_or_null(Reader.ReadStmt())); - unsigned TryOffset - = StmtStack.size() - S->getNumCatchStmts() - HasFinally - 1; - S->setTryBody(cast_or_null(StmtStack[TryOffset])); if (HasFinally) - S->setFinallyStmt(cast_or_null(StmtStack[StmtStack.size() - 1])); + S->setFinallyStmt(Reader.ReadStmt()); S->setAtTryLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); - return 1 + S->getNumCatchStmts() + HasFinally; } -unsigned PCHStmtReader::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) { +void PCHStmtReader::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) { VisitStmt(S); - S->setSynchExpr(cast_or_null(StmtStack[StmtStack.size() - 2])); - S->setSynchBody(cast_or_null(StmtStack[StmtStack.size() - 1])); + S->setSynchExpr(Reader.ReadStmt()); + S->setSynchBody(Reader.ReadStmt()); S->setAtSynchronizedLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); - return 2; } -unsigned PCHStmtReader::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) { +void PCHStmtReader::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) { VisitStmt(S); - S->setThrowExpr(StmtStack.back()); + S->setThrowExpr(Reader.ReadStmt()); S->setThrowLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); - return 1; } //===----------------------------------------------------------------------===// // C++ Expressions and Statements -unsigned PCHStmtReader::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) { - unsigned num = VisitCallExpr(E); +void PCHStmtReader::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) { + VisitCallExpr(E); E->setOperator((OverloadedOperatorKind)Record[Idx++]); - return num; } -unsigned PCHStmtReader::VisitCXXConstructExpr(CXXConstructExpr *E) { +void PCHStmtReader::VisitCXXConstructExpr(CXXConstructExpr *E) { VisitExpr(E); - assert(Record[Idx] == E->getNumArgs() && - "Read wrong record during creation ?"); + assert(Record[Idx] == E->getNumArgs() &&"Read wrong record during creation?"); ++Idx; // NumArgs; for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) - E->setArg(I, cast(StmtStack[StmtStack.size() - N + I])); + E->setArg(I, Reader.ReadExpr()); E->setConstructor(cast(Reader.GetDecl(Record[Idx++]))); E->setLocation(SourceLocation::getFromRawEncoding(Record[Idx++])); E->setElidable(Record[Idx++]); E->setRequiresZeroInitialization(Record[Idx++]); E->setConstructionKind((CXXConstructExpr::ConstructionKind)Record[Idx++]); - return E->getNumArgs(); } -unsigned PCHStmtReader::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) { - unsigned num = VisitExplicitCastExpr(E); +void PCHStmtReader::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) { + VisitExplicitCastExpr(E); E->setOperatorLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); - return num; } -unsigned PCHStmtReader::VisitCXXStaticCastExpr(CXXStaticCastExpr *E) { +void PCHStmtReader::VisitCXXStaticCastExpr(CXXStaticCastExpr *E) { return VisitCXXNamedCastExpr(E); } -unsigned PCHStmtReader::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E) { +void PCHStmtReader::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E) { return VisitCXXNamedCastExpr(E); } -unsigned PCHStmtReader::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E) { +void PCHStmtReader::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E) { return VisitCXXNamedCastExpr(E); } -unsigned PCHStmtReader::VisitCXXConstCastExpr(CXXConstCastExpr *E) { +void PCHStmtReader::VisitCXXConstCastExpr(CXXConstCastExpr *E) { return VisitCXXNamedCastExpr(E); } -unsigned PCHStmtReader::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) { - unsigned num = VisitExplicitCastExpr(E); +void PCHStmtReader::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) { + VisitExplicitCastExpr(E); E->setTypeBeginLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); E->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); - return num; } -unsigned PCHStmtReader::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) { +void PCHStmtReader::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) { VisitExpr(E); E->setValue(Record[Idx++]); E->setLocation(SourceLocation::getFromRawEncoding(Record[Idx++])); - return 0; } -unsigned PCHStmtReader::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) { +void PCHStmtReader::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) { VisitExpr(E); E->setLocation(SourceLocation::getFromRawEncoding(Record[Idx++])); - return 0; } -unsigned PCHStmtReader::VisitCXXTypeidExpr(CXXTypeidExpr *E) { +void PCHStmtReader::VisitCXXTypeidExpr(CXXTypeidExpr *E) { VisitExpr(E); E->setSourceRange(Reader.ReadSourceRange(Record, Idx)); if (E->isTypeOperand()) { // typeid(int) E->setTypeOperandSourceInfo(Reader.GetTypeSourceInfo(Record, Idx)); - return 0; + return; } // typeid(42+2) - E->setExprOperand(cast(StmtStack.back())); - return 1; + E->setExprOperand(Reader.ReadExpr()); } -unsigned PCHStmtReader::VisitCXXThisExpr(CXXThisExpr *E) { +void PCHStmtReader::VisitCXXThisExpr(CXXThisExpr *E) { VisitExpr(E); E->setLocation(SourceLocation::getFromRawEncoding(Record[Idx++])); E->setImplicit(Record[Idx++]); - return 0; } -unsigned PCHStmtReader::VisitCXXThrowExpr(CXXThrowExpr *E) { +void PCHStmtReader::VisitCXXThrowExpr(CXXThrowExpr *E) { VisitExpr(E); E->setThrowLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); - E->setSubExpr(cast_or_null(StmtStack.back())); - return 1; + E->setSubExpr(Reader.ReadExpr()); } -unsigned PCHStmtReader::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) { +void PCHStmtReader::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) { VisitExpr(E); E->setUsedLocation(SourceLocation::getFromRawEncoding(Record[Idx++])); bool HasStoredExpr = Record[Idx++]; - if (!HasStoredExpr) return 0; - E->setExpr(cast(StmtStack.back())); - return 1; + if (!HasStoredExpr) return; + E->setExpr(Reader.ReadExpr()); } -unsigned PCHStmtReader::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) { +void PCHStmtReader::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) { VisitExpr(E); E->setTemporary(Reader.ReadCXXTemporary(Record, Idx)); - E->setSubExpr(cast(StmtStack.back())); - return 1; + E->setSubExpr(Reader.ReadExpr()); } -unsigned PCHStmtReader::VisitCXXZeroInitValueExpr(CXXZeroInitValueExpr *E) { +void PCHStmtReader::VisitCXXZeroInitValueExpr(CXXZeroInitValueExpr *E) { VisitExpr(E); E->setTypeBeginLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); E->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); - return 0; } -unsigned PCHStmtReader::VisitCXXNewExpr(CXXNewExpr *E) { +void PCHStmtReader::VisitCXXNewExpr(CXXNewExpr *E) { VisitExpr(E); E->setGlobalNew(Record[Idx++]); E->setParenTypeId(Record[Idx++]); @@ -1127,31 +1008,25 @@ unsigned PCHStmtReader::VisitCXXNewExpr(CXXNewExpr *E) { NumCtorArgs); // Install all the subexpressions. - unsigned TotalSubExprs = E->raw_arg_end()-E->raw_arg_begin(); - unsigned SSIdx = StmtStack.size()-TotalSubExprs; for (CXXNewExpr::raw_arg_iterator I = E->raw_arg_begin(),e = E->raw_arg_end(); I != e; ++I) - *I = StmtStack[SSIdx++]; - - return TotalSubExprs; + *I = Reader.ReadStmt(); } -unsigned PCHStmtReader::VisitCXXDeleteExpr(CXXDeleteExpr *E) { +void PCHStmtReader::VisitCXXDeleteExpr(CXXDeleteExpr *E) { VisitExpr(E); E->setGlobalDelete(Record[Idx++]); E->setArrayForm(Record[Idx++]); E->setOperatorDelete( cast_or_null(Reader.GetDecl(Record[Idx++]))); - E->setArgument(cast_or_null(StmtStack.back())); + E->setArgument(Reader.ReadExpr()); E->setStartLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); - return 1; } -unsigned -PCHStmtReader::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) { +void PCHStmtReader::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) { VisitExpr(E); - E->setBase(cast_or_null(StmtStack.back())); + E->setBase(Reader.ReadExpr()); E->setArrow(Record[Idx++]); E->setOperatorLoc(Reader.ReadSourceLocation(Record, Idx)); E->setQualifier(Reader.ReadNestedNameSpecifier(Record, Idx)); @@ -1165,11 +1040,9 @@ PCHStmtReader::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) { E->setDestroyedType(II, Reader.ReadSourceLocation(Record, Idx)); else E->setDestroyedType(Reader.GetTypeSourceInfo(Record, Idx)); - - return 1; } -unsigned PCHStmtReader::VisitCXXExprWithTemporaries(CXXExprWithTemporaries *E) { +void PCHStmtReader::VisitCXXExprWithTemporaries(CXXExprWithTemporaries *E) { VisitExpr(E); unsigned NumTemps = Record[Idx++]; if (NumTemps) { @@ -1177,24 +1050,21 @@ unsigned PCHStmtReader::VisitCXXExprWithTemporaries(CXXExprWithTemporaries *E) { for (unsigned i = 0; i != NumTemps; ++i) E->setTemporary(i, Reader.ReadCXXTemporary(Record, Idx)); } - E->setSubExpr(cast(StmtStack.back())); - return 1; + E->setSubExpr(Reader.ReadExpr()); } -unsigned +void PCHStmtReader::VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E){ VisitExpr(E); - unsigned NumExprs = 0; unsigned NumTemplateArgs = Record[Idx++]; assert((NumTemplateArgs != 0) == E->hasExplicitTemplateArgs() && "Read wrong record during creation ?"); if (E->hasExplicitTemplateArgs()) - NumExprs - = ReadExplicitTemplateArgumentList(*E->getExplicitTemplateArgumentList(), - NumTemplateArgs, StmtStack.end()); + ReadExplicitTemplateArgumentList(*E->getExplicitTemplateArgumentList(), + NumTemplateArgs); - E->setBase(cast_or_null(StmtStack.back())); + E->setBase(Reader.ReadExpr()); E->setBaseType(Reader.GetType(Record[Idx++])); E->setArrow(Record[Idx++]); E->setOperatorLoc(Reader.ReadSourceLocation(Record, Idx)); @@ -1204,58 +1074,47 @@ PCHStmtReader::VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E){ cast_or_null(Reader.GetDecl(Record[Idx++]))); E->setMember(Reader.ReadDeclarationName(Record, Idx)); E->setMemberLoc(Reader.ReadSourceLocation(Record, Idx)); - - return NumExprs + 1; } -unsigned +void PCHStmtReader::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) { VisitExpr(E); - unsigned NumExprs = 0; unsigned NumTemplateArgs = Record[Idx++]; assert((NumTemplateArgs != 0) == E->hasExplicitTemplateArgs() && "Read wrong record during creation ?"); if (E->hasExplicitTemplateArgs()) - NumExprs - = ReadExplicitTemplateArgumentList(E->getExplicitTemplateArgs(), - NumTemplateArgs, StmtStack.end()); + ReadExplicitTemplateArgumentList(E->getExplicitTemplateArgs(), + NumTemplateArgs); E->setDeclName(Reader.ReadDeclarationName(Record, Idx)); E->setLocation(Reader.ReadSourceLocation(Record, Idx)); E->setQualifierRange(Reader.ReadSourceRange(Record, Idx)); E->setQualifier(Reader.ReadNestedNameSpecifier(Record, Idx)); - return NumExprs; } -unsigned +void PCHStmtReader::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) { VisitExpr(E); assert(Record[Idx] == E->arg_size() && "Read wrong record during creation ?"); ++Idx; // NumArgs; for (unsigned I = 0, N = E->arg_size(); I != N; ++I) - E->setArg(I, cast(StmtStack[StmtStack.size() - N + I])); + E->setArg(I, Reader.ReadExpr()); E->setTypeBeginLoc(Reader.ReadSourceLocation(Record, Idx)); E->setTypeAsWritten(Reader.GetType(Record[Idx++])); E->setLParenLoc(Reader.ReadSourceLocation(Record, Idx)); E->setRParenLoc(Reader.ReadSourceLocation(Record, Idx)); - return E->arg_size(); } -unsigned PCHStmtReader::VisitOverloadExpr(OverloadExpr *E) { +void PCHStmtReader::VisitOverloadExpr(OverloadExpr *E) { VisitExpr(E); - unsigned NumExprs = 0; unsigned NumTemplateArgs = Record[Idx++]; assert((NumTemplateArgs != 0) == E->hasExplicitTemplateArgs() && "Read wrong record during creation ?"); - if (E->hasExplicitTemplateArgs()) { - llvm::SmallVectorImpl::iterator EndOfExprs = StmtStack.end(); - if (isa(E)) - --EndOfExprs; // UnresolvedMemberExpr contains an Expr. - NumExprs = ReadExplicitTemplateArgumentList(E->getExplicitTemplateArgs(), - NumTemplateArgs, EndOfExprs); - } + if (E->hasExplicitTemplateArgs()) + ReadExplicitTemplateArgumentList(E->getExplicitTemplateArgs(), + NumTemplateArgs); unsigned NumDecls = Record[Idx++]; UnresolvedSet<8> Decls; @@ -1270,40 +1129,63 @@ unsigned PCHStmtReader::VisitOverloadExpr(OverloadExpr *E) { E->setQualifier(Reader.ReadNestedNameSpecifier(Record, Idx)); E->setQualifierRange(Reader.ReadSourceRange(Record, Idx)); E->setNameLoc(Reader.ReadSourceLocation(Record, Idx)); - return NumExprs; } -unsigned PCHStmtReader::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) { - unsigned NumExprs = VisitOverloadExpr(E); +void PCHStmtReader::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) { + VisitOverloadExpr(E); E->setArrow(Record[Idx++]); E->setHasUnresolvedUsing(Record[Idx++]); - E->setBase(cast_or_null(StmtStack.back())); + E->setBase(Reader.ReadExpr()); E->setBaseType(Reader.GetType(Record[Idx++])); E->setOperatorLoc(Reader.ReadSourceLocation(Record, Idx)); - return NumExprs + 1; } -unsigned PCHStmtReader::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) { - unsigned NumExprs = VisitOverloadExpr(E); +void PCHStmtReader::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) { + VisitOverloadExpr(E); E->setRequiresADL(Record[Idx++]); E->setOverloaded(Record[Idx++]); E->setNamingClass(cast_or_null(Reader.GetDecl(Record[Idx++]))); - return NumExprs; } +Stmt *PCHReader::ReadStmt() { + switch (ReadingKind) { + case Read_Decl: + case Read_Type: + // Read a statement from the current DeclCursor. + return ReadStmtFromStream(DeclsCursor); + case Read_Stmt: + // Subexpressions are stored from last to first, so the next Stmt we need + // will be at the back of the stack. + assert(!StmtStack.empty() && "Read too many sub statements!"); + return StmtStack.pop_back_val(); + } + + llvm_unreachable("ReadingKind not set ?"); + return 0; +} + +Expr *PCHReader::ReadExpr() { + return cast_or_null(ReadStmt()); +} // Within the bitstream, expressions are stored in Reverse Polish // Notation, with each of the subexpressions preceding the -// expression they are stored in. To evaluate expressions, we -// continue reading expressions and placing them on the stack, with -// expressions having operands removing those operands from the +// expression they are stored in. Subexpressions are stored from last to first. +// To evaluate expressions, we continue reading expressions and placing them on +// the stack, with expressions having operands removing those operands from the // stack. Evaluation terminates when we see a STMT_STOP record, and // the single remaining expression on the stack is our result. -Stmt *PCHReader::ReadStmt(llvm::BitstreamCursor &Cursor) { +Stmt *PCHReader::ReadStmtFromStream(llvm::BitstreamCursor &Cursor) { + + ReadingKindTracker ReadingKind(Read_Stmt, *this); + +#ifndef NDEBUG + unsigned PrevNumStmts = StmtStack.size(); +#endif + RecordData Record; unsigned Idx; - llvm::SmallVector StmtStack; - PCHStmtReader Reader(*this, Record, Idx, StmtStack); + PCHStmtReader Reader(*this, Record, Idx); Stmt::EmptyShell Empty; while (true) { @@ -1709,17 +1591,17 @@ Stmt *PCHReader::ReadStmt(llvm::BitstreamCursor &Cursor) { ++NumStatementsRead; - if (S) { - unsigned NumSubStmts = Reader.Visit(S); - while (NumSubStmts > 0) { - StmtStack.pop_back(); - --NumSubStmts; - } - } + if (S) + Reader.Visit(S); assert(Idx == Record.size() && "Invalid deserialization of statement"); StmtStack.push_back(S); } - assert(StmtStack.size() == 1 && "Extra expressions on stack!"); - return StmtStack.back(); + +#ifndef NDEBUG + assert(StmtStack.size() > PrevNumStmts && "Read too many sub stmts!"); + assert(StmtStack.size() == PrevNumStmts + 1 && "Extra expressions on stack!"); +#endif + + return StmtStack.pop_back_val(); } diff --git a/lib/Frontend/PCHWriter.cpp b/lib/Frontend/PCHWriter.cpp index ebaba14e56..8b714386c1 100644 --- a/lib/Frontend/PCHWriter.cpp +++ b/lib/Frontend/PCHWriter.cpp @@ -2056,8 +2056,8 @@ void PCHWriter::SetSelectorOffset(Selector Sel, uint32_t Offset) { PCHWriter::PCHWriter(llvm::BitstreamWriter &Stream) : Stream(Stream), NextTypeID(pch::NUM_PREDEF_TYPE_IDS), - NumStatements(0), NumMacros(0), NumLexicalDeclContexts(0), - NumVisibleDeclContexts(0), EmittingStmts(false) { } + CollectedStmts(&StmtsToEmit), NumStatements(0), NumMacros(0), + NumLexicalDeclContexts(0), NumVisibleDeclContexts(0) { } void PCHWriter::WritePCH(Sema &SemaRef, MemorizeStatCalls *StatCalls, const char *isysroot) { diff --git a/lib/Frontend/PCHWriterStmt.cpp b/lib/Frontend/PCHWriterStmt.cpp index fdc54072a9..5b45cb473f 100644 --- a/lib/Frontend/PCHWriterStmt.cpp +++ b/lib/Frontend/PCHWriterStmt.cpp @@ -147,43 +147,8 @@ namespace { }; } -/// \brief Return the number of Exprs contained in the given TemplateArgument. -static unsigned NumExprsContainedIn(const TemplateArgument &Arg) { - switch (Arg.getKind()) { - default: break; - case TemplateArgument::Expression: - return 1; - case TemplateArgument::Pack: { - unsigned Count = 0; - for (TemplateArgument::pack_iterator I=Arg.pack_begin(), E=Arg.pack_end(); - I != E; ++I) - Count += NumExprsContainedIn(*I); - return Count; - } - } - - return 0; -} - -/// \brief Return the number of Exprs contained in the given -/// ExplicitTemplateArgumentList. -static unsigned NumExprsContainedIn(const ExplicitTemplateArgumentList &Args) { - unsigned Count = 0; - for (unsigned i=0; i != Args.NumTemplateArgs; ++i) { - const TemplateArgumentLoc &ArgLoc = Args.getTemplateArgs()[i]; - const TemplateArgument &TemplA = ArgLoc.getArgument(); - Count += NumExprsContainedIn(TemplA); - if (TemplA.getKind() == TemplateArgument::Expression && - TemplA.getAsExpr() != ArgLoc.getLocInfo().getAsExpr()) - ++Count; // 1 in TemplateArgumentLocInfo. - } - - return Count; -} - void PCHStmtWriter:: AddExplicitTemplateArgumentList(const ExplicitTemplateArgumentList &Args) { - Record.push_back(NumExprsContainedIn(Args)); Writer.AddSourceLocation(Args.LAngleLoc, Record); Writer.AddSourceLocation(Args.RAngleLoc, Record); for (unsigned i=0; i != Args.NumTemplateArgs; ++i) @@ -204,7 +169,7 @@ void PCHStmtWriter::VisitCompoundStmt(CompoundStmt *S) { Record.push_back(S->size()); for (CompoundStmt::body_iterator CS = S->body_begin(), CSEnd = S->body_end(); CS != CSEnd; ++CS) - Writer.WriteSubStmt(*CS); + Writer.AddStmt(*CS); Writer.AddSourceLocation(S->getLBracLoc(), Record); Writer.AddSourceLocation(S->getRBracLoc(), Record); Code = pch::STMT_COMPOUND; @@ -212,14 +177,14 @@ void PCHStmtWriter::VisitCompoundStmt(CompoundStmt *S) { void PCHStmtWriter::VisitSwitchCase(SwitchCase *S) { VisitStmt(S); - Record.push_back(Writer.RecordSwitchCaseID(S)); + Record.push_back(Writer.getSwitchCaseID(S)); } void PCHStmtWriter::VisitCaseStmt(CaseStmt *S) { VisitSwitchCase(S); - Writer.WriteSubStmt(S->getLHS()); - Writer.WriteSubStmt(S->getRHS()); - Writer.WriteSubStmt(S->getSubStmt()); + Writer.AddStmt(S->getLHS()); + Writer.AddStmt(S->getRHS()); + Writer.AddStmt(S->getSubStmt()); Writer.AddSourceLocation(S->getCaseLoc(), Record); Writer.AddSourceLocation(S->getEllipsisLoc(), Record); Writer.AddSourceLocation(S->getColonLoc(), Record); @@ -228,7 +193,7 @@ void PCHStmtWriter::VisitCaseStmt(CaseStmt *S) { void PCHStmtWriter::VisitDefaultStmt(DefaultStmt *S) { VisitSwitchCase(S); - Writer.WriteSubStmt(S->getSubStmt()); + Writer.AddStmt(S->getSubStmt()); Writer.AddSourceLocation(S->getDefaultLoc(), Record); Writer.AddSourceLocation(S->getColonLoc(), Record); Code = pch::STMT_DEFAULT; @@ -237,7 +202,7 @@ void PCHStmtWriter::VisitDefaultStmt(DefaultStmt *S) { void PCHStmtWriter::VisitLabelStmt(LabelStmt *S) { VisitStmt(S); Writer.AddIdentifierRef(S->getID(), Record); - Writer.WriteSubStmt(S->getSubStmt()); + Writer.AddStmt(S->getSubStmt()); Writer.AddSourceLocation(S->getIdentLoc(), Record); Record.push_back(Writer.GetLabelID(S)); Code = pch::STMT_LABEL; @@ -246,9 +211,9 @@ void PCHStmtWriter::VisitLabelStmt(LabelStmt *S) { void PCHStmtWriter::VisitIfStmt(IfStmt *S) { VisitStmt(S); Writer.AddDeclRef(S->getConditionVariable(), Record); - Writer.WriteSubStmt(S->getCond()); - Writer.WriteSubStmt(S->getThen()); - Writer.WriteSubStmt(S->getElse()); + Writer.AddStmt(S->getCond()); + Writer.AddStmt(S->getThen()); + Writer.AddStmt(S->getElse()); Writer.AddSourceLocation(S->getIfLoc(), Record); Writer.AddSourceLocation(S->getElseLoc(), Record); Code = pch::STMT_IF; @@ -257,28 +222,28 @@ void PCHStmtWriter::VisitIfStmt(IfStmt *S) { void PCHStmtWriter::VisitSwitchStmt(SwitchStmt *S) { VisitStmt(S); Writer.AddDeclRef(S->getConditionVariable(), Record); - Writer.WriteSubStmt(S->getCond()); - Writer.WriteSubStmt(S->getBody()); + Writer.AddStmt(S->getCond()); + Writer.AddStmt(S->getBody()); Writer.AddSourceLocation(S->getSwitchLoc(), Record); for (SwitchCase *SC = S->getSwitchCaseList(); SC; SC = SC->getNextSwitchCase()) - Record.push_back(Writer.getSwitchCaseID(SC)); + Record.push_back(Writer.RecordSwitchCaseID(SC)); Code = pch::STMT_SWITCH; } void PCHStmtWriter::VisitWhileStmt(WhileStmt *S) { VisitStmt(S); Writer.AddDeclRef(S->getConditionVariable(), Record); - Writer.WriteSubStmt(S->getCond()); - Writer.WriteSubStmt(S->getBody()); + Writer.AddStmt(S->getCond()); + Writer.AddStmt(S->getBody()); Writer.AddSourceLocation(S->getWhileLoc(), Record); Code = pch::STMT_WHILE; } void PCHStmtWriter::VisitDoStmt(DoStmt *S) { VisitStmt(S); - Writer.WriteSubStmt(S->getCond()); - Writer.WriteSubStmt(S->getBody()); + Writer.AddStmt(S->getCond()); + Writer.AddStmt(S->getBody()); Writer.AddSourceLocation(S->getDoLoc(), Record); Writer.AddSourceLocation(S->getWhileLoc(), Record); Writer.AddSourceLocation(S->getRParenLoc(), Record); @@ -287,11 +252,11 @@ void PCHStmtWriter::VisitDoStmt(DoStmt *S) { void PCHStmtWriter::VisitForStmt(ForStmt *S) { VisitStmt(S); - Writer.WriteSubStmt(S->getInit()); - Writer.WriteSubStmt(S->getCond()); + Writer.AddStmt(S->getInit()); + Writer.AddStmt(S->getCond()); Writer.AddDeclRef(S->getConditionVariable(), Record); - Writer.WriteSubStmt(S->getInc()); - Writer.WriteSubStmt(S->getBody()); + Writer.AddStmt(S->getInc()); + Writer.AddStmt(S->getBody()); Writer.AddSourceLocation(S->getForLoc(), Record); Writer.AddSourceLocation(S->getLParenLoc(), Record); Writer.AddSourceLocation(S->getRParenLoc(), Record); @@ -310,7 +275,7 @@ void PCHStmtWriter::VisitIndirectGotoStmt(IndirectGotoStmt *S) { VisitStmt(S); Writer.AddSourceLocation(S->getGotoLoc(), Record); Writer.AddSourceLocation(S->getStarLoc(), Record); - Writer.WriteSubStmt(S->getTarget()); + Writer.AddStmt(S->getTarget()); Code = pch::STMT_INDIRECT_GOTO; } @@ -328,7 +293,7 @@ void PCHStmtWriter::VisitBreakStmt(BreakStmt *S) { void PCHStmtWriter::VisitReturnStmt(ReturnStmt *S) { VisitStmt(S); - Writer.WriteSubStmt(S->getRetValue()); + Writer.AddStmt(S->getRetValue()); Writer.AddSourceLocation(S->getReturnLoc(), Record); Writer.AddDeclRef(S->getNRVOCandidate(), Record); Code = pch::STMT_RETURN; @@ -354,25 +319,25 @@ void PCHStmtWriter::VisitAsmStmt(AsmStmt *S) { Record.push_back(S->isVolatile()); Record.push_back(S->isSimple()); Record.push_back(S->isMSAsm()); - Writer.WriteSubStmt(S->getAsmString()); + Writer.AddStmt(S->getAsmString()); // Outputs for (unsigned I = 0, N = S->getNumOutputs(); I != N; ++I) { Writer.AddIdentifierRef(S->getOutputIdentifier(I), Record); - Writer.WriteSubStmt(S->getOutputConstraintLiteral(I)); - Writer.WriteSubStmt(S->getOutputExpr(I)); + Writer.AddStmt(S->getOutputConstraintLiteral(I)); + Writer.AddStmt(S->getOutputExpr(I)); } // Inputs for (unsigned I = 0, N = S->getNumInputs(); I != N; ++I) { Writer.AddIdentifierRef(S->getInputIdentifier(I), Record); - Writer.WriteSubStmt(S->getInputConstraintLiteral(I)); - Writer.WriteSubStmt(S->getInputExpr(I)); + Writer.AddStmt(S->getInputConstraintLiteral(I)); + Writer.AddStmt(S->getInputExpr(I)); } // Clobbers for (unsigned I = 0, N = S->getNumClobbers(); I != N; ++I) - Writer.WriteSubStmt(S->getClobber(I)); + Writer.AddStmt(S->getClobber(I)); Code = pch::STMT_ASM; } @@ -417,7 +382,7 @@ void PCHStmtWriter::VisitFloatingLiteral(FloatingLiteral *E) { void PCHStmtWriter::VisitImaginaryLiteral(ImaginaryLiteral *E) { VisitExpr(E); - Writer.WriteSubStmt(E->getSubExpr()); + Writer.AddStmt(E->getSubExpr()); Code = pch::EXPR_IMAGINARY_LITERAL; } @@ -449,13 +414,13 @@ void PCHStmtWriter::VisitParenExpr(ParenExpr *E) { VisitExpr(E); Writer.AddSourceLocation(E->getLParen(), Record); Writer.AddSourceLocation(E->getRParen(), Record); - Writer.WriteSubStmt(E->getSubExpr()); + Writer.AddStmt(E->getSubExpr()); Code = pch::EXPR_PAREN; } void PCHStmtWriter::VisitUnaryOperator(UnaryOperator *E) { VisitExpr(E); - Writer.WriteSubStmt(E->getSubExpr()); + Writer.AddStmt(E->getSubExpr()); Record.push_back(E->getOpcode()); // FIXME: stable encoding Writer.AddSourceLocation(E->getOperatorLoc(), Record); Code = pch::EXPR_UNARY_OPERATOR; @@ -493,7 +458,7 @@ void PCHStmtWriter::VisitOffsetOfExpr(OffsetOfExpr *E) { } } for (unsigned I = 0, N = E->getNumExpressions(); I != N; ++I) - Writer.WriteSubStmt(E->getIndexExpr(I)); + Writer.AddStmt(E->getIndexExpr(I)); Code = pch::EXPR_OFFSETOF; } @@ -504,7 +469,7 @@ void PCHStmtWriter::VisitSizeOfAlignOfExpr(SizeOfAlignOfExpr *E) { Writer.AddTypeSourceInfo(E->getArgumentTypeInfo(), Record); else { Record.push_back(0); - Writer.WriteSubStmt(E->getArgumentExpr()); + Writer.AddStmt(E->getArgumentExpr()); } Writer.AddSourceLocation(E->getOperatorLoc(), Record); Writer.AddSourceLocation(E->getRParenLoc(), Record); @@ -513,8 +478,8 @@ void PCHStmtWriter::VisitSizeOfAlignOfExpr(SizeOfAlignOfExpr *E) { void PCHStmtWriter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) { VisitExpr(E); - Writer.WriteSubStmt(E->getLHS()); - Writer.WriteSubStmt(E->getRHS()); + Writer.AddStmt(E->getLHS()); + Writer.AddStmt(E->getRHS()); Writer.AddSourceLocation(E->getRBracketLoc(), Record); Code = pch::EXPR_ARRAY_SUBSCRIPT; } @@ -523,16 +488,16 @@ void PCHStmtWriter::VisitCallExpr(CallExpr *E) { VisitExpr(E); Record.push_back(E->getNumArgs()); Writer.AddSourceLocation(E->getRParenLoc(), Record); - Writer.WriteSubStmt(E->getCallee()); + Writer.AddStmt(E->getCallee()); for (CallExpr::arg_iterator Arg = E->arg_begin(), ArgEnd = E->arg_end(); Arg != ArgEnd; ++Arg) - Writer.WriteSubStmt(*Arg); + Writer.AddStmt(*Arg); Code = pch::EXPR_CALL; } void PCHStmtWriter::VisitMemberExpr(MemberExpr *E) { VisitExpr(E); - Writer.WriteSubStmt(E->getBase()); + Writer.AddStmt(E->getBase()); Writer.AddDeclRef(E->getMemberDecl(), Record); Writer.AddSourceLocation(E->getMemberLoc(), Record); Record.push_back(E->isArrow()); @@ -543,7 +508,7 @@ void PCHStmtWriter::VisitMemberExpr(MemberExpr *E) { void PCHStmtWriter::VisitObjCIsaExpr(ObjCIsaExpr *E) { VisitExpr(E); - Writer.WriteSubStmt(E->getBase()); + Writer.AddStmt(E->getBase()); Writer.AddSourceLocation(E->getIsaMemberLoc(), Record); Record.push_back(E->isArrow()); Code = pch::EXPR_OBJC_ISA; @@ -551,14 +516,14 @@ void PCHStmtWriter::VisitObjCIsaExpr(ObjCIsaExpr *E) { void PCHStmtWriter::VisitCastExpr(CastExpr *E) { VisitExpr(E); - Writer.WriteSubStmt(E->getSubExpr()); + Writer.AddStmt(E->getSubExpr()); Record.push_back(E->getCastKind()); // FIXME: stable encoding } void PCHStmtWriter::VisitBinaryOperator(BinaryOperator *E) { VisitExpr(E); - Writer.WriteSubStmt(E->getLHS()); - Writer.WriteSubStmt(E->getRHS()); + Writer.AddStmt(E->getLHS()); + Writer.AddStmt(E->getRHS()); Record.push_back(E->getOpcode()); // FIXME: stable encoding Writer.AddSourceLocation(E->getOperatorLoc(), Record); Code = pch::EXPR_BINARY_OPERATOR; @@ -573,9 +538,9 @@ void PCHStmtWriter::VisitCompoundAssignOperator(CompoundAssignOperator *E) { void PCHStmtWriter::VisitConditionalOperator(ConditionalOperator *E) { VisitExpr(E); - Writer.WriteSubStmt(E->getCond()); - Writer.WriteSubStmt(E->getLHS()); - Writer.WriteSubStmt(E->getRHS()); + Writer.AddStmt(E->getCond()); + Writer.AddStmt(E->getLHS()); + Writer.AddStmt(E->getRHS()); Writer.AddSourceLocation(E->getQuestionLoc(), Record); Writer.AddSourceLocation(E->getColonLoc(), Record); Code = pch::EXPR_CONDITIONAL_OPERATOR; @@ -603,14 +568,14 @@ void PCHStmtWriter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) { VisitExpr(E); Writer.AddSourceLocation(E->getLParenLoc(), Record); Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record); - Writer.WriteSubStmt(E->getInitializer()); + Writer.AddStmt(E->getInitializer()); Record.push_back(E->isFileScope()); Code = pch::EXPR_COMPOUND_LITERAL; } void PCHStmtWriter::VisitExtVectorElementExpr(ExtVectorElementExpr *E) { VisitExpr(E); - Writer.WriteSubStmt(E->getBase()); + Writer.AddStmt(E->getBase()); Writer.AddIdentifierRef(&E->getAccessor(), Record); Writer.AddSourceLocation(E->getAccessorLoc(), Record); Code = pch::EXPR_EXT_VECTOR_ELEMENT; @@ -620,8 +585,8 @@ void PCHStmtWriter::VisitInitListExpr(InitListExpr *E) { VisitExpr(E); Record.push_back(E->getNumInits()); for (unsigned I = 0, N = E->getNumInits(); I != N; ++I) - Writer.WriteSubStmt(E->getInit(I)); - Writer.WriteSubStmt(E->getSyntacticForm()); + Writer.AddStmt(E->getInit(I)); + Writer.AddStmt(E->getSyntacticForm()); Writer.AddSourceLocation(E->getLBraceLoc(), Record); Writer.AddSourceLocation(E->getRBraceLoc(), Record); Writer.AddDeclRef(E->getInitializedFieldInUnion(), Record); @@ -633,7 +598,7 @@ void PCHStmtWriter::VisitDesignatedInitExpr(DesignatedInitExpr *E) { VisitExpr(E); Record.push_back(E->getNumSubExprs()); for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I) - Writer.WriteSubStmt(E->getSubExpr(I)); + Writer.AddStmt(E->getSubExpr(I)); Writer.AddSourceLocation(E->getEqualOrColonLoc(), Record); Record.push_back(E->usesGNUSyntax()); for (DesignatedInitExpr::designators_iterator D = E->designators_begin(), @@ -673,7 +638,7 @@ void PCHStmtWriter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) { void PCHStmtWriter::VisitVAArgExpr(VAArgExpr *E) { VisitExpr(E); - Writer.WriteSubStmt(E->getSubExpr()); + Writer.AddStmt(E->getSubExpr()); Writer.AddSourceLocation(E->getBuiltinLoc(), Record); Writer.AddSourceLocation(E->getRParenLoc(), Record); Code = pch::EXPR_VA_ARG; @@ -689,7 +654,7 @@ void PCHStmtWriter::VisitAddrLabelExpr(AddrLabelExpr *E) { void PCHStmtWriter::VisitStmtExpr(StmtExpr *E) { VisitExpr(E); - Writer.WriteSubStmt(E->getSubStmt()); + Writer.AddStmt(E->getSubStmt()); Writer.AddSourceLocation(E->getLParenLoc(), Record); Writer.AddSourceLocation(E->getRParenLoc(), Record); Code = pch::EXPR_STMT; @@ -706,9 +671,9 @@ void PCHStmtWriter::VisitTypesCompatibleExpr(TypesCompatibleExpr *E) { void PCHStmtWriter::VisitChooseExpr(ChooseExpr *E) { VisitExpr(E); - Writer.WriteSubStmt(E->getCond()); - Writer.WriteSubStmt(E->getLHS()); - Writer.WriteSubStmt(E->getRHS()); + Writer.AddStmt(E->getCond()); + Writer.AddStmt(E->getLHS()); + Writer.AddStmt(E->getRHS()); Writer.AddSourceLocation(E->getBuiltinLoc(), Record); Writer.AddSourceLocation(E->getRParenLoc(), Record); Code = pch::EXPR_CHOOSE; @@ -724,7 +689,7 @@ void PCHStmtWriter::VisitShuffleVectorExpr(ShuffleVectorExpr *E) { VisitExpr(E); Record.push_back(E->getNumSubExprs()); for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I) - Writer.WriteSubStmt(E->getExpr(I)); + Writer.AddStmt(E->getExpr(I)); Writer.AddSourceLocation(E->getBuiltinLoc(), Record); Writer.AddSourceLocation(E->getRParenLoc(), Record); Code = pch::EXPR_SHUFFLE_VECTOR; @@ -743,7 +708,7 @@ void PCHStmtWriter::VisitBlockDeclRefExpr(BlockDeclRefExpr *E) { Writer.AddSourceLocation(E->getLocation(), Record); Record.push_back(E->isByRef()); Record.push_back(E->isConstQualAdded()); - Writer.WriteSubStmt(E->getCopyConstructorExpr()); + Writer.AddStmt(E->getCopyConstructorExpr()); Code = pch::EXPR_BLOCK_DECL_REF; } @@ -753,7 +718,7 @@ void PCHStmtWriter::VisitBlockDeclRefExpr(BlockDeclRefExpr *E) { void PCHStmtWriter::VisitObjCStringLiteral(ObjCStringLiteral *E) { VisitExpr(E); - Writer.WriteSubStmt(E->getString()); + Writer.AddStmt(E->getString()); Writer.AddSourceLocation(E->getAtLoc(), Record); Code = pch::EXPR_OBJC_STRING_LITERAL; } @@ -786,7 +751,7 @@ void PCHStmtWriter::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) { VisitExpr(E); Writer.AddDeclRef(E->getDecl(), Record); Writer.AddSourceLocation(E->getLocation(), Record); - Writer.WriteSubStmt(E->getBase()); + Writer.AddStmt(E->getBase()); Record.push_back(E->isArrow()); Record.push_back(E->isFreeIvar()); Code = pch::EXPR_OBJC_IVAR_REF_EXPR; @@ -796,7 +761,7 @@ void PCHStmtWriter::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) { VisitExpr(E); Writer.AddDeclRef(E->getProperty(), Record); Writer.AddSourceLocation(E->getLocation(), Record); - Writer.WriteSubStmt(E->getBase()); + Writer.AddStmt(E->getBase()); Code = pch::EXPR_OBJC_PROPERTY_REF_EXPR; } @@ -808,7 +773,7 @@ void PCHStmtWriter::VisitObjCImplicitSetterGetterRefExpr( // NOTE: InterfaceDecl and Base are mutually exclusive. Writer.AddDeclRef(E->getInterfaceDecl(), Record); - Writer.WriteSubStmt(E->getBase()); + Writer.AddStmt(E->getBase()); Writer.AddSourceLocation(E->getLocation(), Record); Writer.AddSourceLocation(E->getClassLoc(), Record); Code = pch::EXPR_OBJC_KVC_REF_EXPR; @@ -820,7 +785,7 @@ void PCHStmtWriter::VisitObjCMessageExpr(ObjCMessageExpr *E) { Record.push_back((unsigned)E->getReceiverKind()); // FIXME: stable encoding switch (E->getReceiverKind()) { case ObjCMessageExpr::Instance: - Writer.WriteSubStmt(E->getInstanceReceiver()); + Writer.AddStmt(E->getInstanceReceiver()); break; case ObjCMessageExpr::Class: @@ -847,7 +812,7 @@ void PCHStmtWriter::VisitObjCMessageExpr(ObjCMessageExpr *E) { for (CallExpr::arg_iterator Arg = E->arg_begin(), ArgEnd = E->arg_end(); Arg != ArgEnd; ++Arg) - Writer.WriteSubStmt(*Arg); + Writer.AddStmt(*Arg); Code = pch::EXPR_OBJC_MESSAGE_EXPR; } @@ -859,16 +824,16 @@ void PCHStmtWriter::VisitObjCSuperExpr(ObjCSuperExpr *E) { void PCHStmtWriter::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) { VisitStmt(S); - Writer.WriteSubStmt(S->getElement()); - Writer.WriteSubStmt(S->getCollection()); - Writer.WriteSubStmt(S->getBody()); + Writer.AddStmt(S->getElement()); + Writer.AddStmt(S->getCollection()); + Writer.AddStmt(S->getBody()); Writer.AddSourceLocation(S->getForLoc(), Record); Writer.AddSourceLocation(S->getRParenLoc(), Record); Code = pch::STMT_OBJC_FOR_COLLECTION; } void PCHStmtWriter::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) { - Writer.WriteSubStmt(S->getCatchBody()); + Writer.AddStmt(S->getCatchBody()); Writer.AddDeclRef(S->getCatchParamDecl(), Record); Writer.AddSourceLocation(S->getAtCatchLoc(), Record); Writer.AddSourceLocation(S->getRParenLoc(), Record); @@ -876,7 +841,7 @@ void PCHStmtWriter::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) { } void PCHStmtWriter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) { - Writer.WriteSubStmt(S->getFinallyBody()); + Writer.AddStmt(S->getFinallyBody()); Writer.AddSourceLocation(S->getAtFinallyLoc(), Record); Code = pch::STMT_OBJC_FINALLY; } @@ -884,24 +849,24 @@ void PCHStmtWriter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) { void PCHStmtWriter::VisitObjCAtTryStmt(ObjCAtTryStmt *S) { Record.push_back(S->getNumCatchStmts()); Record.push_back(S->getFinallyStmt() != 0); - Writer.WriteSubStmt(S->getTryBody()); + Writer.AddStmt(S->getTryBody()); for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I) - Writer.WriteSubStmt(S->getCatchStmt(I)); + Writer.AddStmt(S->getCatchStmt(I)); if (S->getFinallyStmt()) - Writer.WriteSubStmt(S->getFinallyStmt()); + Writer.AddStmt(S->getFinallyStmt()); Writer.AddSourceLocation(S->getAtTryLoc(), Record); Code = pch::STMT_OBJC_AT_TRY; } void PCHStmtWriter::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) { - Writer.WriteSubStmt(S->getSynchExpr()); - Writer.WriteSubStmt(S->getSynchBody()); + Writer.AddStmt(S->getSynchExpr()); + Writer.AddStmt(S->getSynchBody()); Writer.AddSourceLocation(S->getAtSynchronizedLoc(), Record); Code = pch::STMT_OBJC_AT_SYNCHRONIZED; } void PCHStmtWriter::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) { - Writer.WriteSubStmt(S->getThrowExpr()); + Writer.AddStmt(S->getThrowExpr()); Writer.AddSourceLocation(S->getThrowLoc(), Record); Code = pch::STMT_OBJC_AT_THROW; } @@ -925,7 +890,7 @@ void PCHStmtWriter::VisitCXXConstructExpr(CXXConstructExpr *E) { VisitExpr(E); Record.push_back(E->getNumArgs()); for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) - Writer.WriteSubStmt(E->getArg(I)); + Writer.AddStmt(E->getArg(I)); Writer.AddDeclRef(E->getConstructor(), Record); Writer.AddSourceLocation(E->getLocation(), Record); Record.push_back(E->isElidable()); @@ -986,7 +951,7 @@ void PCHStmtWriter::VisitCXXTypeidExpr(CXXTypeidExpr *E) { Writer.AddTypeSourceInfo(E->getTypeOperandSourceInfo(), Record); Code = pch::EXPR_CXX_TYPEID_TYPE; } else { - Writer.WriteSubStmt(E->getExprOperand()); + Writer.AddStmt(E->getExprOperand()); Code = pch::EXPR_CXX_TYPEID_EXPR; } } @@ -1001,7 +966,7 @@ void PCHStmtWriter::VisitCXXThisExpr(CXXThisExpr *E) { void PCHStmtWriter::VisitCXXThrowExpr(CXXThrowExpr *E) { VisitExpr(E); Writer.AddSourceLocation(E->getThrowLoc(), Record); - Writer.WriteSubStmt(E->getSubExpr()); + Writer.AddStmt(E->getSubExpr()); Code = pch::EXPR_CXX_THROW; } @@ -1010,7 +975,7 @@ void PCHStmtWriter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) { Writer.AddSourceLocation(E->getUsedLocation(), Record); if (E->isExprStored()) { Record.push_back(1); - Writer.WriteSubStmt(E->getExpr()); + Writer.AddStmt(E->getExpr()); } else { Record.push_back(0); } @@ -1021,7 +986,7 @@ void PCHStmtWriter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) { void PCHStmtWriter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) { VisitExpr(E); Writer.AddCXXTemporary(E->getTemporary(), Record); - Writer.WriteSubStmt(E->getSubExpr()); + Writer.AddStmt(E->getSubExpr()); Code = pch::EXPR_CXX_BIND_TEMPORARY; } @@ -1047,7 +1012,7 @@ void PCHStmtWriter::VisitCXXNewExpr(CXXNewExpr *E) { Writer.AddSourceLocation(E->getEndLoc(), Record); for (CXXNewExpr::arg_iterator I = E->raw_arg_begin(), e = E->raw_arg_end(); I != e; ++I) - Writer.WriteSubStmt(*I); + Writer.AddStmt(*I); Code = pch::EXPR_CXX_NEW; } @@ -1057,7 +1022,7 @@ void PCHStmtWriter::VisitCXXDeleteExpr(CXXDeleteExpr *E) { Record.push_back(E->isGlobalDelete()); Record.push_back(E->isArrayForm()); Writer.AddDeclRef(E->getOperatorDelete(), Record); - Writer.WriteSubStmt(E->getArgument()); + Writer.AddStmt(E->getArgument()); Writer.AddSourceLocation(E->getSourceRange().getBegin(), Record); Code = pch::EXPR_CXX_DELETE; @@ -1091,7 +1056,7 @@ void PCHStmtWriter::VisitCXXExprWithTemporaries(CXXExprWithTemporaries *E) { for (unsigned i = 0, e = E->getNumTemporaries(); i != e; ++i) Writer.AddCXXTemporary(E->getTemporary(i), Record); - Writer.WriteSubStmt(E->getSubExpr()); + Writer.AddStmt(E->getSubExpr()); Code = pch::EXPR_CXX_EXPR_WITH_TEMPORARIES; } @@ -1113,9 +1078,9 @@ PCHStmtWriter::VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E){ } if (!E->isImplicitAccess()) - Writer.WriteSubStmt(E->getBase()); + Writer.AddStmt(E->getBase()); else - Writer.WriteSubStmt(0); + Writer.AddStmt(0); Writer.AddTypeRef(E->getBaseType(), Record); Record.push_back(E->isArrow()); Writer.AddSourceLocation(E->getOperatorLoc(), Record); @@ -1156,7 +1121,7 @@ PCHStmtWriter::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) { Record.push_back(E->arg_size()); for (CXXUnresolvedConstructExpr::arg_iterator ArgI = E->arg_begin(), ArgE = E->arg_end(); ArgI != ArgE; ++ArgI) - Writer.WriteSubStmt(*ArgI); + Writer.AddStmt(*ArgI); Writer.AddSourceLocation(E->getTypeBeginLoc(), Record); Writer.AddTypeRef(E->getTypeAsWritten(), Record); Writer.AddSourceLocation(E->getLParenLoc(), Record); @@ -1196,7 +1161,7 @@ void PCHStmtWriter::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) { VisitOverloadExpr(E); Record.push_back(E->isArrow()); Record.push_back(E->hasUnresolvedUsing()); - Writer.WriteSubStmt(!E->isImplicitAccess() ? E->getBase() : 0); + Writer.AddStmt(!E->isImplicitAccess() ? E->getBase() : 0); Writer.AddTypeRef(E->getBaseType(), Record); Writer.AddSourceLocation(E->getOperatorLoc(), Record); Code = pch::EXPR_CXX_UNRESOLVED_MEMBER; @@ -1246,12 +1211,16 @@ void PCHWriter::WriteSubStmt(Stmt *S) { RecordData Record; PCHStmtWriter Writer(*this, Record); ++NumStatements; - + if (!S) { Stream.EmitRecord(pch::STMT_NULL_PTR, Record); return; } + // Redirect PCHWriter::AddStmt to collect sub stmts. + llvm::SmallVector SubStmts; + CollectedStmts = &SubStmts; + Writer.Code = pch::STMT_NULL_PTR; Writer.Visit(S); @@ -1263,6 +1232,17 @@ void PCHWriter::WriteSubStmt(Stmt *S) { assert(0 && "Unhandled sub statement writing PCH file"); } #endif + + // Revert PCHWriter::AddStmt. + CollectedStmts = &StmtsToEmit; + + // Write the sub stmts in reverse order, last to first. When reading them back + // we will read them in correct order by "pop"ing them from the Stmts stack. + // This simplifies reading and allows to store a variable number of sub stmts + // without knowing it in advance. + while (!SubStmts.empty()) + WriteSubStmt(SubStmts.pop_back_val()); + Stream.EmitRecord(Writer.Code, Record); } @@ -1270,41 +1250,18 @@ void PCHWriter::WriteSubStmt(Stmt *S) { /// queue via AddStmt(). void PCHWriter::FlushStmts() { RecordData Record; - PCHStmtWriter Writer(*this, Record); - - EmittingStmts = true; for (unsigned I = 0, N = StmtsToEmit.size(); I != N; ++I) { - ++NumStatements; - Stmt *S = StmtsToEmit[I]; - - if (!S) { - Stream.EmitRecord(pch::STMT_NULL_PTR, Record); - Stream.EmitRecord(pch::STMT_STOP, Record); - continue; - } - - Writer.Code = pch::STMT_NULL_PTR; - Writer.Visit(S); -#ifndef NDEBUG - if (Writer.Code == pch::STMT_NULL_PTR) { - S->dump(); - assert(0 && "Unhandled expression writing PCH file"); - } -#endif - Stream.EmitRecord(Writer.Code, Record); - + WriteSubStmt(StmtsToEmit[I]); + assert(N == StmtsToEmit.size() && "Substatement writen via AddStmt rather than WriteSubStmt!"); // Note that we are at the end of a full expression. Any // expression records that follow this one are part of a different // expression. - Record.clear(); Stream.EmitRecord(pch::STMT_STOP, Record); } - EmittingStmts = false; - StmtsToEmit.clear(); } diff --git a/test/PCH/exprs.c b/test/PCH/exprs.c index 038a18ba5b..d855defe7e 100644 --- a/test/PCH/exprs.c +++ b/test/PCH/exprs.c @@ -59,6 +59,8 @@ add_result *int_ptr5 = &integer; // CompoundAssignOperator addeq_result *int_ptr6 = &integer; +add_result_with_typeinfo *int_typeinfo_ptr6; + // ConditionalOperator conditional_operator *double_ptr4 = &floating; diff --git a/test/PCH/exprs.h b/test/PCH/exprs.h index 5af8c7c1a9..80768f8df2 100644 --- a/test/PCH/exprs.h +++ b/test/PCH/exprs.h @@ -72,6 +72,8 @@ typedef typeof((void *)0) void_ptr; // CompoundLiteral typedef typeof((struct S){.x = 3.5}) compound_literal; +typedef typeof(i + sizeof(int[i + Enumerator])) add_result_with_typeinfo; + // ExtVectorElementExpr typedef __attribute__(( ext_vector_type(2) )) double double2; extern double2 vec2, vec2b; -- 2.40.0