[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

Ted Kremenek kremenek at apple.com
Mon Jun 28 16:03:45 PDT 2010


Interesting.  Does this have a noticeable impact on PCH read/write times?

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