[cfe-commits] r107087 - in /cfe/trunk: include/clang/Frontend/PCHReader.h include/clang/Frontend/PCHWriter.h lib/Frontend/PCHReader.cpp lib/Frontend/PCHReaderDecl.cpp lib/Frontend/PCHReaderStmt.cpp lib/Frontend/PCHWriter.cpp lib/Frontend/PCHWriterStmt.cpp test/PCH/exprs.c test/PCH/exprs.h
Argyrios Kyrtzidis
akyrtzi at gmail.com
Tue Jun 29 00:39:20 PDT 2010
On Jun 29, 2010, at 12:03 AM, Ted Kremenek wrote:
> Interesting. Does this have a noticeable impact on PCH read/write times?
Good question; I checked and there's no impact.
-Argiris
>
> On Jun 28, 2010, at 3:28 PM, Argyrios Kyrtzidis wrote:
>
>> Author: akirtzidis
>> Date: Mon Jun 28 17:28:35 2010
>> New Revision: 107087
>>
>> URL: http://llvm.org/viewvc/llvm-project?rev=107087&view=rev
>> Log:
>> 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.
>>
>> Modified:
>> cfe/trunk/include/clang/Frontend/PCHReader.h
>> cfe/trunk/include/clang/Frontend/PCHWriter.h
>> cfe/trunk/lib/Frontend/PCHReader.cpp
>> cfe/trunk/lib/Frontend/PCHReaderDecl.cpp
>> cfe/trunk/lib/Frontend/PCHReaderStmt.cpp
>> cfe/trunk/lib/Frontend/PCHWriter.cpp
>> cfe/trunk/lib/Frontend/PCHWriterStmt.cpp
>> cfe/trunk/test/PCH/exprs.c
>> cfe/trunk/test/PCH/exprs.h
>>
>> Modified: cfe/trunk/include/clang/Frontend/PCHReader.h
>> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Frontend/PCHReader.h?rev=107087&r1=107086&r2=107087&view=diff
>> ==============================================================================
>> --- cfe/trunk/include/clang/Frontend/PCHReader.h (original)
>> +++ cfe/trunk/include/clang/Frontend/PCHReader.h Mon Jun 28 17:28:35 2010
>> @@ -449,6 +449,34 @@
>> /// Objective-C protocols.
>> llvm::SmallVector<Decl *, 16> InterestingDecls;
>>
>> + /// \brief When reading a Stmt tree, Stmt operands are placed in this stack.
>> + llvm::SmallVector<Stmt *, 16> 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 @@
>> /// 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,19 +594,6 @@
>> /// \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
>> @@ -584,11 +602,6 @@
>>
>> /// \brief Reads a TemplateArgumentLoc.
>> TemplateArgumentLoc ReadTemplateArgumentLoc(const RecordData &Record,
>> - unsigned &Idx,
>> - ExprReader &ExprRdr);
>> -
>> - /// \brief Reads a TemplateArgumentLoc.
>> - TemplateArgumentLoc ReadTemplateArgumentLoc(const RecordData &Record,
>> unsigned &Idx);
>>
>> /// \brief Reads a declarator info from the given record.
>> @@ -719,10 +732,6 @@
>> 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);
>>
>> /// \brief Read a template parameter list.
>> @@ -759,19 +768,11 @@
>> /// \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);
>>
>> Modified: cfe/trunk/include/clang/Frontend/PCHWriter.h
>> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Frontend/PCHWriter.h?rev=107087&r1=107086&r2=107087&view=diff
>> ==============================================================================
>> --- cfe/trunk/include/clang/Frontend/PCHWriter.h (original)
>> +++ cfe/trunk/include/clang/Frontend/PCHWriter.h Mon Jun 28 17:28:35 2010
>> @@ -189,7 +189,11 @@
>>
>> /// \brief Statements that we've encountered while serializing a
>> /// declaration or type.
>> - llvm::SmallVector<Stmt *, 8> StmtsToEmit;
>> + llvm::SmallVector<Stmt *, 16> StmtsToEmit;
>> +
>> + /// \brief Statements collection to use for PCHWriter::AddStmt().
>> + /// It will point to StmtsToEmit unless it is overriden.
>> + llvm::SmallVector<Stmt *, 16> *CollectedStmts;
>>
>> /// \brief Mapping from SwitchCase statements to IDs.
>> std::map<SwitchCase *, unsigned> SwitchCaseIDs;
>> @@ -211,8 +215,8 @@
>> /// 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 @@
>> /// 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();
>>
>> Modified: cfe/trunk/lib/Frontend/PCHReader.cpp
>> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Frontend/PCHReader.cpp?rev=107087&r1=107086&r2=107087&view=diff
>> ==============================================================================
>> --- cfe/trunk/lib/Frontend/PCHReader.cpp (original)
>> +++ cfe/trunk/lib/Frontend/PCHReader.cpp Mon Jun 28 17:28:35 2010
>> @@ -321,18 +321,6 @@
>> // 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() {}
>>
>> -Expr *PCHReader::ReadDeclExpr() {
>> - return dyn_cast_or_null<Expr>(ReadStmt(DeclsCursor));
>> -}
>> -
>> -Expr *PCHReader::ReadTypeExpr() {
>> - return dyn_cast_or_null<Expr>(ReadStmt(DeclsCursor));
>> -}
>> -
>>
>> namespace {
>> class PCHMethodPoolLookupTrait {
>> @@ -1969,6 +1949,8 @@
>> // 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 @@
>> 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 @@
>> return Context->getTypeDeclType(cast<TypedefDecl>(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 @@
>> }
>>
>> case pch::TYPE_DECLTYPE:
>> - return Context->getDecltypeType(ReadTypeExpr());
>> + return Context->getDecltypeType(ReadExpr());
>>
>> case pch::TYPE_RECORD:
>> if (Record.size() != 1) {
>> @@ -2319,7 +2301,7 @@
>> 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 @@
>> 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 @@
>> 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 @@
>> // 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 @@
>> }
>>
>> 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 @@
>> 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<TemplateArgument, 8> 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 @@
>> 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);
>>
>> Modified: cfe/trunk/lib/Frontend/PCHReaderDecl.cpp
>> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Frontend/PCHReaderDecl.cpp?rev=107087&r1=107086&r2=107087&view=diff
>> ==============================================================================
>> --- cfe/trunk/lib/Frontend/PCHReaderDecl.cpp (original)
>> +++ cfe/trunk/lib/Frontend/PCHReaderDecl.cpp Mon Jun 28 17:28:35 2010
>> @@ -184,7 +184,7 @@
>> 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 @@
>> 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<ImplicitParamDecl>(Reader.GetDecl(Record[Idx++])));
>> MD->setCmdDecl(cast<ImplicitParamDecl>(Reader.GetDecl(Record[Idx++])));
>> }
>> @@ -493,7 +493,7 @@
>> 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 @@
>> VD->setPreviousDeclaration(
>> cast_or_null<VarDecl>(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::VisitFileScopeAsmDecl(FileScopeAsmDecl *AD) {
>> VisitDecl(AD);
>> - AD->setAsmString(cast<StringLiteral>(Reader.ReadDeclExpr()));
>> + AD->setAsmString(cast<StringLiteral>(Reader.ReadExpr()));
>> }
>>
>> void PCHDeclReader::VisitBlockDecl(BlockDecl *BD) {
>> VisitDecl(BD);
>> - BD->setBody(cast_or_null<CompoundStmt>(Reader.ReadDeclStmt()));
>> + BD->setBody(cast_or_null<CompoundStmt>(Reader.ReadStmt()));
>> BD->setSignatureAsWritten(Reader.GetTypeSourceInfo(Record, Idx));
>> unsigned NumParams = Record[Idx++];
>> llvm::SmallVector<ParmVarDecl *, 16> Params;
>> @@ -861,7 +861,7 @@
>> 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 @@
>> // after reading this declaration.
>> SavedStreamPosition SavedPosition(DeclsCursor);
>>
>> + ReadingKindTracker ReadingKind(Read_Decl, *this);
>> +
>> // Note that we are loading a declaration record.
>> LoadingTypeOrDecl Loading(*this);
>>
>>
>> Modified: cfe/trunk/lib/Frontend/PCHReaderStmt.cpp
>> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Frontend/PCHReaderStmt.cpp?rev=107087&r1=107086&r2=107087&view=diff
>> ==============================================================================
>> --- cfe/trunk/lib/Frontend/PCHReaderStmt.cpp (original)
>> +++ cfe/trunk/lib/Frontend/PCHReaderStmt.cpp Mon Jun 28 17:28:35 2010
>> @@ -19,16 +19,15 @@
>>
>> namespace {
>>
>> - class PCHStmtReader : public StmtVisitor<PCHStmtReader, unsigned> {
>> + class PCHStmtReader : public StmtVisitor<PCHStmtReader> {
>> PCHReader &Reader;
>> const PCHReader::RecordData &Record;
>> unsigned &Idx;
>> - llvm::SmallVectorImpl<Stmt *> &StmtStack;
>>
>> public:
>> PCHStmtReader(PCHReader &Reader, const PCHReader::RecordData &Record,
>> - unsigned &Idx, llvm::SmallVectorImpl<Stmt *> &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 @@
>> 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<Stmt *>::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);
>> -
>> - unsigned VisitOverloadExpr(OverloadExpr *E);
>> - unsigned VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E);
>> - unsigned VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E);
>> + void VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E);
>> + void VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E);
>> + void VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E);
>> +
>> + void VisitOverloadExpr(OverloadExpr *E);
>> + void VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E);
>> + void VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E);
>> };
>> }
>>
>> -unsigned PCHStmtReader::
>> +void PCHStmtReader::
>> ReadExplicitTemplateArgumentList(ExplicitTemplateArgumentList &ArgList,
>> - unsigned NumTemplateArgs,
>> - llvm::SmallVectorImpl<Stmt *>::iterator EndOfExprs) {
>> -
>> - class StmtStackExprReader : public PCHReader::ExprReader {
>> - llvm::SmallVectorImpl<Stmt *>::iterator StmtI;
>> - public:
>> - StmtStackExprReader(const llvm::SmallVectorImpl<Stmt *>::iterator &stmtI)
>> - : StmtI(stmtI) { }
>> - virtual Expr *Read() { return cast_or_null<Expr>(*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<Stmt *, 16> 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<Expr>(StmtStack[StmtStack.size() - 3]));
>> - S->setRHS(cast_or_null<Expr>(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<VarDecl>(Reader.GetDecl(Record[Idx++])));
>> - S->setCond(cast<Expr>(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<VarDecl>(Reader.GetDecl(Record[Idx++])));
>> - S->setCond(cast<Expr>(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 @@
>> 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<VarDecl>(Reader.GetDecl(Record[Idx++])));
>> - S->setCond(cast_or_null<Expr>(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<Expr>(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<Expr>(StmtStack[StmtStack.size() - 3]));
>> + S->setInit(Reader.ReadStmt());
>> + S->setCond(Reader.ReadExpr());
>> S->setConditionVariable(*Reader.getContext(),
>> cast_or_null<VarDecl>(Reader.GetDecl(Record[Idx++])));
>> - S->setInc(cast_or_null<Expr>(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<Expr>(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<Expr>(StmtStack.back()));
>> + S->setRetValue(Reader.ReadExpr());
>> S->setReturnLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
>> S->setNRVOCandidate(cast_or_null<VarDecl>(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 @@
>> 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 @@
>> S->setSimple(Record[Idx++]);
>> S->setMSAsm(Record[Idx++]);
>>
>> - unsigned StackIdx
>> - = StmtStack.size() - (NumOutputs*2 + NumInputs*2 + NumClobbers + 1);
>> - S->setAsmString(cast_or_null<StringLiteral>(StmtStack[StackIdx++]));
>> + S->setAsmString(cast_or_null<StringLiteral>(Reader.ReadStmt()));
>>
>> // Outputs and inputs
>> llvm::SmallVector<IdentifierInfo *, 16> Names;
>> @@ -386,71 +342,62 @@
>> llvm::SmallVector<Stmt*, 16> Exprs;
>> for (unsigned I = 0, N = NumOutputs + NumInputs; I != N; ++I) {
>> Names.push_back(Reader.GetIdentifierInfo(Record, Idx));
>> - Constraints.push_back(cast_or_null<StringLiteral>(StmtStack[StackIdx++]));
>> - Exprs.push_back(StmtStack[StackIdx++]);
>> + Constraints.push_back(cast_or_null<StringLiteral>(Reader.ReadStmt()));
>> + Exprs.push_back(Reader.ReadStmt());
>> }
>>
>> // Constraints
>> llvm::SmallVector<StringLiteral*, 16> Clobbers;
>> for (unsigned I = 0; I != NumClobbers; ++I)
>> - Clobbers.push_back(cast_or_null<StringLiteral>(StmtStack[StackIdx++]));
>> + Clobbers.push_back(cast_or_null<StringLiteral>(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<ValueDecl>(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<Expr>(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 @@
>> // 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<Expr>(StmtStack.back()));
>> - return 1;
>> + E->setSubExpr(Reader.ReadExpr());
>> }
>>
>> -unsigned PCHStmtReader::VisitUnaryOperator(UnaryOperator *E) {
>> +void PCHStmtReader::VisitUnaryOperator(UnaryOperator *E) {
>> VisitExpr(E);
>> - E->setSubExpr(cast<Expr>(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 @@
>> }
>>
>> for (unsigned I = 0, N = E->getNumExpressions(); I != N; ++I)
>> - E->setIndexExpr(I, cast_or_null<Expr>(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<Expr>(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<Expr>(StmtStack[StmtStack.size() - 2]));
>> - E->setRHS(cast<Expr>(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<Expr>(StmtStack[StmtStack.size() - E->getNumArgs() - 1]));
>> + E->setCallee(Reader.ReadExpr());
>> for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
>> - E->setArg(I, cast<Expr>(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<Expr>(StmtStack.back()));
>> + E->setBase(Reader.ReadExpr());
>> E->setMemberDecl(cast<ValueDecl>(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<Expr>(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<Expr>(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<Expr>(StmtStack.end()[-2]));
>> - E->setRHS(cast<Expr>(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<Expr>(StmtStack[StmtStack.size() - 3]));
>> - E->setLHS(cast_or_null<Expr>(StmtStack[StmtStack.size() - 2]));
>> - E->setRHS(cast_or_null<Expr>(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<Expr>(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<Expr>(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<Expr>(StmtStack[StmtStack.size() - NumInits - 1 + I]));
>> - E->setSyntacticForm(cast_or_null<InitListExpr>(StmtStack.back()));
>> + E->updateInit(*Reader.getContext(), I, Reader.ReadExpr());
>> + E->setSyntacticForm(cast_or_null<InitListExpr>(Reader.ReadStmt()));
>> E->setLBraceLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
>> E->setRBraceLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
>> E->setInitializedFieldInUnion(
>> cast_or_null<FieldDecl>(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<Expr>(StmtStack[StmtStack.size() - NumSubExprs + I]));
>> + E->setSubExpr(I, Reader.ReadExpr());
>> E->setEqualOrColonLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
>> E->setGNUSyntax(Record[Idx++]);
>>
>> @@ -733,144 +657,128 @@
>> }
>> 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<Expr>(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<CompoundStmt>(StmtStack.back()));
>> - return 1;
>> + E->setSubStmt(cast_or_null<CompoundStmt>(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<Expr>(StmtStack[StmtStack.size() - 3]));
>> - E->setLHS(cast_or_null<Expr>(StmtStack[StmtStack.size() - 2]));
>> - E->setRHS(cast_or_null<Expr>(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<Expr *, 16> 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<BlockDecl>(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<ValueDecl>(Reader.GetDecl(Record[Idx++])));
>> E->setLocation(SourceLocation::getFromRawEncoding(Record[Idx++]));
>> E->setByRef(Record[Idx++]);
>> E->setConstQualAdded(Record[Idx++]);
>> - E->setCopyConstructorExpr(cast_or_null<Expr>(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<StringLiteral>(StmtStack.back()));
>> + E->setString(cast<StringLiteral>(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<ObjCProtocolDecl>(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<ObjCIvarDecl>(Reader.GetDecl(Record[Idx++])));
>> E->setLocation(SourceLocation::getFromRawEncoding(Record[Idx++]));
>> - E->setBase(cast<Expr>(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<ObjCPropertyDecl>(Reader.GetDecl(Record[Idx++])));
>> E->setLocation(SourceLocation::getFromRawEncoding(Record[Idx++]));
>> - E->setBase(cast<Expr>(StmtStack.back()));
>> - return 1;
>> + E->setBase(Reader.ReadExpr());
>> }
>>
>> -unsigned PCHStmtReader::VisitObjCImplicitSetterGetterRefExpr(
>> +void PCHStmtReader::VisitObjCImplicitSetterGetterRefExpr(
>> ObjCImplicitSetterGetterRefExpr *E) {
>> VisitExpr(E);
>> E->setGetterMethod(
>> @@ -879,13 +787,12 @@
>> cast_or_null<ObjCMethodDecl>(Reader.GetDecl(Record[Idx++])));
>> E->setInterfaceDecl(
>> cast_or_null<ObjCInterfaceDecl>(Reader.GetDecl(Record[Idx++])));
>> - E->setBase(cast_or_null<Expr>(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 @@
>> = static_cast<ObjCMessageExpr::ReceiverKind>(Record[Idx++]);
>> switch (Kind) {
>> case ObjCMessageExpr::Instance:
>> - E->setInstanceReceiver(
>> - cast_or_null<Expr>(StmtStack[StmtStack.size() - E->getNumArgs() - 1]));
>> + E->setInstanceReceiver(Reader.ReadExpr());
>> break;
>>
>> case ObjCMessageExpr::Class:
>> @@ -921,193 +827,168 @@
>> E->setRightLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
>>
>> for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
>> - E->setArg(I, cast<Expr>(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<Stmt>(StmtStack[StmtStack.size() - 3]));
>> - S->setCollection(cast_or_null<Expr>(StmtStack[StmtStack.size() - 2]));
>> - S->setBody(cast_or_null<Stmt>(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<Stmt>(StmtStack.back()));
>> + S->setCatchBody(Reader.ReadStmt());
>> S->setCatchParamDecl(cast_or_null<VarDecl>(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<ObjCAtCatchStmt>(StmtStack[Offset]));
>> - }
>> + S->setTryBody(Reader.ReadStmt());
>> + for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I)
>> + S->setCatchStmt(I, cast_or_null<ObjCAtCatchStmt>(Reader.ReadStmt()));
>>
>> - unsigned TryOffset
>> - = StmtStack.size() - S->getNumCatchStmts() - HasFinally - 1;
>> - S->setTryBody(cast_or_null<Stmt>(StmtStack[TryOffset]));
>> if (HasFinally)
>> - S->setFinallyStmt(cast_or_null<Stmt>(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<Stmt>(StmtStack[StmtStack.size() - 2]));
>> - S->setSynchBody(cast_or_null<Stmt>(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<Expr>(StmtStack[StmtStack.size() - N + I]));
>> + E->setArg(I, Reader.ReadExpr());
>> E->setConstructor(cast<CXXConstructorDecl>(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<Expr>(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<Expr>(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<Expr>(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<Expr>(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 @@
>> 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<FunctionDecl>(Reader.GetDecl(Record[Idx++])));
>> - E->setArgument(cast_or_null<Expr>(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<Expr>(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 @@
>> 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 @@
>> for (unsigned i = 0; i != NumTemps; ++i)
>> E->setTemporary(i, Reader.ReadCXXTemporary(Record, Idx));
>> }
>> - E->setSubExpr(cast<Expr>(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<Expr>(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 @@
>> cast_or_null<NamedDecl>(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<Expr>(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<Stmt *>::iterator EndOfExprs = StmtStack.end();
>> - if (isa<UnresolvedMemberExpr>(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 @@
>> 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<Expr>(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<CXXRecordDecl>(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<Expr>(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<Stmt *, 16> StmtStack;
>> - PCHStmtReader Reader(*this, Record, Idx, StmtStack);
>> + PCHStmtReader Reader(*this, Record, Idx);
>> Stmt::EmptyShell Empty;
>>
>> while (true) {
>> @@ -1709,17 +1591,17 @@
>>
>> ++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();
>> }
>>
>> Modified: cfe/trunk/lib/Frontend/PCHWriter.cpp
>> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Frontend/PCHWriter.cpp?rev=107087&r1=107086&r2=107087&view=diff
>> ==============================================================================
>> --- cfe/trunk/lib/Frontend/PCHWriter.cpp (original)
>> +++ cfe/trunk/lib/Frontend/PCHWriter.cpp Mon Jun 28 17:28:35 2010
>> @@ -2056,8 +2056,8 @@
>>
>> 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) {
>>
>> Modified: cfe/trunk/lib/Frontend/PCHWriterStmt.cpp
>> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Frontend/PCHWriterStmt.cpp?rev=107087&r1=107086&r2=107087&view=diff
>> ==============================================================================
>> --- cfe/trunk/lib/Frontend/PCHWriterStmt.cpp (original)
>> +++ cfe/trunk/lib/Frontend/PCHWriterStmt.cpp Mon Jun 28 17:28:35 2010
>> @@ -147,43 +147,8 @@
>> };
>> }
>>
>> -/// \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 @@
>> 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::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::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::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::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::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::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 @@
>> 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::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 @@
>> 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::VisitImaginaryLiteral(ImaginaryLiteral *E) {
>> VisitExpr(E);
>> - Writer.WriteSubStmt(E->getSubExpr());
>> + Writer.AddStmt(E->getSubExpr());
>> Code = pch::EXPR_IMAGINARY_LITERAL;
>> }
>>
>> @@ -449,13 +414,13 @@
>> 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 @@
>> }
>> }
>> 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 @@
>> 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::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 @@
>> 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::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::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::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 @@
>> 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 @@
>> 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 @@
>> 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::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::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::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 @@
>> 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 @@
>> 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::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 @@
>> 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 @@
>> 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 @@
>>
>> // 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 @@
>> 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 @@
>>
>> 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::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::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::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 @@
>> 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 @@
>> 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::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 @@
>> 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::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 @@
>> 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 @@
>> 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 @@
>> 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 @@
>> }
>>
>> 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 @@
>> 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 @@
>> 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 @@
>> 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<Stmt *, 16> SubStmts;
>> + CollectedStmts = &SubStmts;
>> +
>> Writer.Code = pch::STMT_NULL_PTR;
>> Writer.Visit(S);
>>
>> @@ -1263,6 +1232,17 @@
>> 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 @@
>> /// 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();
>> }
>>
>> Modified: cfe/trunk/test/PCH/exprs.c
>> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/test/PCH/exprs.c?rev=107087&r1=107086&r2=107087&view=diff
>> ==============================================================================
>> --- cfe/trunk/test/PCH/exprs.c (original)
>> +++ cfe/trunk/test/PCH/exprs.c Mon Jun 28 17:28:35 2010
>> @@ -59,6 +59,8 @@
>> // CompoundAssignOperator
>> addeq_result *int_ptr6 = &integer;
>>
>> +add_result_with_typeinfo *int_typeinfo_ptr6;
>> +
>> // ConditionalOperator
>> conditional_operator *double_ptr4 = &floating;
>>
>>
>> Modified: cfe/trunk/test/PCH/exprs.h
>> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/test/PCH/exprs.h?rev=107087&r1=107086&r2=107087&view=diff
>> ==============================================================================
>> --- cfe/trunk/test/PCH/exprs.h (original)
>> +++ cfe/trunk/test/PCH/exprs.h Mon Jun 28 17:28:35 2010
>> @@ -72,6 +72,8 @@
>> // 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;
>>
>>
>> _______________________________________________
>> cfe-commits mailing list
>> cfe-commits at cs.uiuc.edu
>> http://lists.cs.uiuc.edu/mailman/listinfo/cfe-commits
>
More information about the cfe-commits
mailing list