Modify the way sub-statements are stored and retrieved from PCH.

Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index
each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g.

x = sizeof(int[1]);

would crash PCH.

Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just
need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and
 PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs.

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@107087 91177308-0d34-0410-b5e6-96231b3b80d8

1 files changed, 105 insertions, 148 deletions

diff --git a/lib/Frontend/PCHWriterStmt.cpp b/lib/Frontend/PCHWriterStmt.cpp
index fdc54072a9..5b45cb473f 100644
--- a/lib/Frontend/PCHWriterStmt.cpp
+++ b/lib/Frontend/PCHWriterStmt.cpp
@@ -147,43 +147,8 @@ namespace {
   };
 }
 
-/// \brief Return the number of Exprs contained in the given TemplateArgument.
-static unsigned NumExprsContainedIn(const TemplateArgument &Arg) {
-  switch (Arg.getKind()) {
-  default: break;
-  case TemplateArgument::Expression:
-    return 1;
-  case TemplateArgument::Pack: {
-    unsigned Count = 0;
-    for (TemplateArgument::pack_iterator I=Arg.pack_begin(), E=Arg.pack_end();
-           I != E; ++I)
-      Count += NumExprsContainedIn(*I);
-    return Count;
-  }
-  }
-  
-  return 0;
-}
-
-/// \brief Return the number of Exprs contained in the given
-/// ExplicitTemplateArgumentList.
-static unsigned NumExprsContainedIn(const ExplicitTemplateArgumentList &Args) {
-  unsigned Count = 0;
-  for (unsigned i=0; i != Args.NumTemplateArgs; ++i) {
-    const TemplateArgumentLoc &ArgLoc = Args.getTemplateArgs()[i];
-    const TemplateArgument &TemplA = ArgLoc.getArgument();
-    Count += NumExprsContainedIn(TemplA);
-    if (TemplA.getKind() == TemplateArgument::Expression &&
-        TemplA.getAsExpr() != ArgLoc.getLocInfo().getAsExpr())
-      ++Count; // 1 in TemplateArgumentLocInfo.
-  }
-  
-  return Count;
-}
-
 void PCHStmtWriter::
 AddExplicitTemplateArgumentList(const ExplicitTemplateArgumentList &Args) {
-  Record.push_back(NumExprsContainedIn(Args));
   Writer.AddSourceLocation(Args.LAngleLoc, Record);
   Writer.AddSourceLocation(Args.RAngleLoc, Record);
   for (unsigned i=0; i != Args.NumTemplateArgs; ++i)
@@ -204,7 +169,7 @@ void PCHStmtWriter::VisitCompoundStmt(CompoundStmt *S) {
   Record.push_back(S->size());
   for (CompoundStmt::body_iterator CS = S->body_begin(), CSEnd = S->body_end();
        CS != CSEnd; ++CS)
-    Writer.WriteSubStmt(*CS);
+    Writer.AddStmt(*CS);
   Writer.AddSourceLocation(S->getLBracLoc(), Record);
   Writer.AddSourceLocation(S->getRBracLoc(), Record);
   Code = pch::STMT_COMPOUND;
@@ -212,14 +177,14 @@ void PCHStmtWriter::VisitCompoundStmt(CompoundStmt *S) {
 
 void PCHStmtWriter::VisitSwitchCase(SwitchCase *S) {
   VisitStmt(S);
-  Record.push_back(Writer.RecordSwitchCaseID(S));
+  Record.push_back(Writer.getSwitchCaseID(S));
 }
 
 void PCHStmtWriter::VisitCaseStmt(CaseStmt *S) {
   VisitSwitchCase(S);
-  Writer.WriteSubStmt(S->getLHS());
-  Writer.WriteSubStmt(S->getRHS());
-  Writer.WriteSubStmt(S->getSubStmt());
+  Writer.AddStmt(S->getLHS());
+  Writer.AddStmt(S->getRHS());
+  Writer.AddStmt(S->getSubStmt());
   Writer.AddSourceLocation(S->getCaseLoc(), Record);
   Writer.AddSourceLocation(S->getEllipsisLoc(), Record);
   Writer.AddSourceLocation(S->getColonLoc(), Record);
@@ -228,7 +193,7 @@ void PCHStmtWriter::VisitCaseStmt(CaseStmt *S) {
 
 void PCHStmtWriter::VisitDefaultStmt(DefaultStmt *S) {
   VisitSwitchCase(S);
-  Writer.WriteSubStmt(S->getSubStmt());
+  Writer.AddStmt(S->getSubStmt());
   Writer.AddSourceLocation(S->getDefaultLoc(), Record);
   Writer.AddSourceLocation(S->getColonLoc(), Record);
   Code = pch::STMT_DEFAULT;
@@ -237,7 +202,7 @@ void PCHStmtWriter::VisitDefaultStmt(DefaultStmt *S) {
 void PCHStmtWriter::VisitLabelStmt(LabelStmt *S) {
   VisitStmt(S);
   Writer.AddIdentifierRef(S->getID(), Record);
-  Writer.WriteSubStmt(S->getSubStmt());
+  Writer.AddStmt(S->getSubStmt());
   Writer.AddSourceLocation(S->getIdentLoc(), Record);
   Record.push_back(Writer.GetLabelID(S));
   Code = pch::STMT_LABEL;
@@ -246,9 +211,9 @@ void PCHStmtWriter::VisitLabelStmt(LabelStmt *S) {
 void PCHStmtWriter::VisitIfStmt(IfStmt *S) {
   VisitStmt(S);
   Writer.AddDeclRef(S->getConditionVariable(), Record);
-  Writer.WriteSubStmt(S->getCond());
-  Writer.WriteSubStmt(S->getThen());
-  Writer.WriteSubStmt(S->getElse());
+  Writer.AddStmt(S->getCond());
+  Writer.AddStmt(S->getThen());
+  Writer.AddStmt(S->getElse());
   Writer.AddSourceLocation(S->getIfLoc(), Record);
   Writer.AddSourceLocation(S->getElseLoc(), Record);
   Code = pch::STMT_IF;
@@ -257,28 +222,28 @@ void PCHStmtWriter::VisitIfStmt(IfStmt *S) {
 void PCHStmtWriter::VisitSwitchStmt(SwitchStmt *S) {
   VisitStmt(S);
   Writer.AddDeclRef(S->getConditionVariable(), Record);
-  Writer.WriteSubStmt(S->getCond());
-  Writer.WriteSubStmt(S->getBody());
+  Writer.AddStmt(S->getCond());
+  Writer.AddStmt(S->getBody());
   Writer.AddSourceLocation(S->getSwitchLoc(), Record);
   for (SwitchCase *SC = S->getSwitchCaseList(); SC;
        SC = SC->getNextSwitchCase())
-    Record.push_back(Writer.getSwitchCaseID(SC));
+    Record.push_back(Writer.RecordSwitchCaseID(SC));
   Code = pch::STMT_SWITCH;
 }
 
 void PCHStmtWriter::VisitWhileStmt(WhileStmt *S) {
   VisitStmt(S);
   Writer.AddDeclRef(S->getConditionVariable(), Record);
-  Writer.WriteSubStmt(S->getCond());
-  Writer.WriteSubStmt(S->getBody());
+  Writer.AddStmt(S->getCond());
+  Writer.AddStmt(S->getBody());
   Writer.AddSourceLocation(S->getWhileLoc(), Record);
   Code = pch::STMT_WHILE;
 }
 
 void PCHStmtWriter::VisitDoStmt(DoStmt *S) {
   VisitStmt(S);
-  Writer.WriteSubStmt(S->getCond());
-  Writer.WriteSubStmt(S->getBody());
+  Writer.AddStmt(S->getCond());
+  Writer.AddStmt(S->getBody());
   Writer.AddSourceLocation(S->getDoLoc(), Record);
   Writer.AddSourceLocation(S->getWhileLoc(), Record);
   Writer.AddSourceLocation(S->getRParenLoc(), Record);
@@ -287,11 +252,11 @@ void PCHStmtWriter::VisitDoStmt(DoStmt *S) {
 
 void PCHStmtWriter::VisitForStmt(ForStmt *S) {
   VisitStmt(S);
-  Writer.WriteSubStmt(S->getInit());
-  Writer.WriteSubStmt(S->getCond());
+  Writer.AddStmt(S->getInit());
+  Writer.AddStmt(S->getCond());
   Writer.AddDeclRef(S->getConditionVariable(), Record);
-  Writer.WriteSubStmt(S->getInc());
-  Writer.WriteSubStmt(S->getBody());
+  Writer.AddStmt(S->getInc());
+  Writer.AddStmt(S->getBody());
   Writer.AddSourceLocation(S->getForLoc(), Record);
   Writer.AddSourceLocation(S->getLParenLoc(), Record);
   Writer.AddSourceLocation(S->getRParenLoc(), Record);
@@ -310,7 +275,7 @@ void PCHStmtWriter::VisitIndirectGotoStmt(IndirectGotoStmt *S) {
   VisitStmt(S);
   Writer.AddSourceLocation(S->getGotoLoc(), Record);
   Writer.AddSourceLocation(S->getStarLoc(), Record);
-  Writer.WriteSubStmt(S->getTarget());
+  Writer.AddStmt(S->getTarget());
   Code = pch::STMT_INDIRECT_GOTO;
 }
 
@@ -328,7 +293,7 @@ void PCHStmtWriter::VisitBreakStmt(BreakStmt *S) {
 
 void PCHStmtWriter::VisitReturnStmt(ReturnStmt *S) {
   VisitStmt(S);
-  Writer.WriteSubStmt(S->getRetValue());
+  Writer.AddStmt(S->getRetValue());
   Writer.AddSourceLocation(S->getReturnLoc(), Record);
   Writer.AddDeclRef(S->getNRVOCandidate(), Record);
   Code = pch::STMT_RETURN;
@@ -354,25 +319,25 @@ void PCHStmtWriter::VisitAsmStmt(AsmStmt *S) {
   Record.push_back(S->isVolatile());
   Record.push_back(S->isSimple());
   Record.push_back(S->isMSAsm());
-  Writer.WriteSubStmt(S->getAsmString());
+  Writer.AddStmt(S->getAsmString());
 
   // Outputs
   for (unsigned I = 0, N = S->getNumOutputs(); I != N; ++I) {      
     Writer.AddIdentifierRef(S->getOutputIdentifier(I), Record);
-    Writer.WriteSubStmt(S->getOutputConstraintLiteral(I));
-    Writer.WriteSubStmt(S->getOutputExpr(I));
+    Writer.AddStmt(S->getOutputConstraintLiteral(I));
+    Writer.AddStmt(S->getOutputExpr(I));
   }
 
   // Inputs
   for (unsigned I = 0, N = S->getNumInputs(); I != N; ++I) {
     Writer.AddIdentifierRef(S->getInputIdentifier(I), Record);
-    Writer.WriteSubStmt(S->getInputConstraintLiteral(I));
-    Writer.WriteSubStmt(S->getInputExpr(I));
+    Writer.AddStmt(S->getInputConstraintLiteral(I));
+    Writer.AddStmt(S->getInputExpr(I));
   }
 
   // Clobbers
   for (unsigned I = 0, N = S->getNumClobbers(); I != N; ++I)
-    Writer.WriteSubStmt(S->getClobber(I));
+    Writer.AddStmt(S->getClobber(I));
 
   Code = pch::STMT_ASM;
 }
@@ -417,7 +382,7 @@ void PCHStmtWriter::VisitFloatingLiteral(FloatingLiteral *E) {
 
 void PCHStmtWriter::VisitImaginaryLiteral(ImaginaryLiteral *E) {
   VisitExpr(E);
-  Writer.WriteSubStmt(E->getSubExpr());
+  Writer.AddStmt(E->getSubExpr());
   Code = pch::EXPR_IMAGINARY_LITERAL;
 }
 
@@ -449,13 +414,13 @@ void PCHStmtWriter::VisitParenExpr(ParenExpr *E) {
   VisitExpr(E);
   Writer.AddSourceLocation(E->getLParen(), Record);
   Writer.AddSourceLocation(E->getRParen(), Record);
-  Writer.WriteSubStmt(E->getSubExpr());
+  Writer.AddStmt(E->getSubExpr());
   Code = pch::EXPR_PAREN;
 }
 
 void PCHStmtWriter::VisitUnaryOperator(UnaryOperator *E) {
   VisitExpr(E);
-  Writer.WriteSubStmt(E->getSubExpr());
+  Writer.AddStmt(E->getSubExpr());
   Record.push_back(E->getOpcode()); // FIXME: stable encoding
   Writer.AddSourceLocation(E->getOperatorLoc(), Record);
   Code = pch::EXPR_UNARY_OPERATOR;
@@ -493,7 +458,7 @@ void PCHStmtWriter::VisitOffsetOfExpr(OffsetOfExpr *E) {
     }
   }
   for (unsigned I = 0, N = E->getNumExpressions(); I != N; ++I)
-    Writer.WriteSubStmt(E->getIndexExpr(I));
+    Writer.AddStmt(E->getIndexExpr(I));
   Code = pch::EXPR_OFFSETOF;
 }
 
@@ -504,7 +469,7 @@ void PCHStmtWriter::VisitSizeOfAlignOfExpr(SizeOfAlignOfExpr *E) {
     Writer.AddTypeSourceInfo(E->getArgumentTypeInfo(), Record);
   else {
     Record.push_back(0);
-    Writer.WriteSubStmt(E->getArgumentExpr());
+    Writer.AddStmt(E->getArgumentExpr());
   }
   Writer.AddSourceLocation(E->getOperatorLoc(), Record);
   Writer.AddSourceLocation(E->getRParenLoc(), Record);
@@ -513,8 +478,8 @@ void PCHStmtWriter::VisitSizeOfAlignOfExpr(SizeOfAlignOfExpr *E) {
 
 void PCHStmtWriter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
   VisitExpr(E);
-  Writer.WriteSubStmt(E->getLHS());
-  Writer.WriteSubStmt(E->getRHS());
+  Writer.AddStmt(E->getLHS());
+  Writer.AddStmt(E->getRHS());
   Writer.AddSourceLocation(E->getRBracketLoc(), Record);
   Code = pch::EXPR_ARRAY_SUBSCRIPT;
 }
@@ -523,16 +488,16 @@ void PCHStmtWriter::VisitCallExpr(CallExpr *E) {
   VisitExpr(E);
   Record.push_back(E->getNumArgs());
   Writer.AddSourceLocation(E->getRParenLoc(), Record);
-  Writer.WriteSubStmt(E->getCallee());
+  Writer.AddStmt(E->getCallee());
   for (CallExpr::arg_iterator Arg = E->arg_begin(), ArgEnd = E->arg_end();
        Arg != ArgEnd; ++Arg)
-    Writer.WriteSubStmt(*Arg);
+    Writer.AddStmt(*Arg);
   Code = pch::EXPR_CALL;
 }
 
 void PCHStmtWriter::VisitMemberExpr(MemberExpr *E) {
   VisitExpr(E);
-  Writer.WriteSubStmt(E->getBase());
+  Writer.AddStmt(E->getBase());
   Writer.AddDeclRef(E->getMemberDecl(), Record);
   Writer.AddSourceLocation(E->getMemberLoc(), Record);
   Record.push_back(E->isArrow());
@@ -543,7 +508,7 @@ void PCHStmtWriter::VisitMemberExpr(MemberExpr *E) {
 
 void PCHStmtWriter::VisitObjCIsaExpr(ObjCIsaExpr *E) {
   VisitExpr(E);
-  Writer.WriteSubStmt(E->getBase());
+  Writer.AddStmt(E->getBase());
   Writer.AddSourceLocation(E->getIsaMemberLoc(), Record);
   Record.push_back(E->isArrow());
   Code = pch::EXPR_OBJC_ISA;
@@ -551,14 +516,14 @@ void PCHStmtWriter::VisitObjCIsaExpr(ObjCIsaExpr *E) {
 
 void PCHStmtWriter::VisitCastExpr(CastExpr *E) {
   VisitExpr(E);
-  Writer.WriteSubStmt(E->getSubExpr());
+  Writer.AddStmt(E->getSubExpr());
   Record.push_back(E->getCastKind()); // FIXME: stable encoding
 }
 
 void PCHStmtWriter::VisitBinaryOperator(BinaryOperator *E) {
   VisitExpr(E);
-  Writer.WriteSubStmt(E->getLHS());
-  Writer.WriteSubStmt(E->getRHS());
+  Writer.AddStmt(E->getLHS());
+  Writer.AddStmt(E->getRHS());
   Record.push_back(E->getOpcode()); // FIXME: stable encoding
   Writer.AddSourceLocation(E->getOperatorLoc(), Record);
   Code = pch::EXPR_BINARY_OPERATOR;
@@ -573,9 +538,9 @@ void PCHStmtWriter::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
 
 void PCHStmtWriter::VisitConditionalOperator(ConditionalOperator *E) {
   VisitExpr(E);
-  Writer.WriteSubStmt(E->getCond());
-  Writer.WriteSubStmt(E->getLHS());
-  Writer.WriteSubStmt(E->getRHS());
+  Writer.AddStmt(E->getCond());
+  Writer.AddStmt(E->getLHS());
+  Writer.AddStmt(E->getRHS());
   Writer.AddSourceLocation(E->getQuestionLoc(), Record);
   Writer.AddSourceLocation(E->getColonLoc(), Record);
   Code = pch::EXPR_CONDITIONAL_OPERATOR;
@@ -603,14 +568,14 @@ void PCHStmtWriter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
   VisitExpr(E);
   Writer.AddSourceLocation(E->getLParenLoc(), Record);
   Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record);
-  Writer.WriteSubStmt(E->getInitializer());
+  Writer.AddStmt(E->getInitializer());
   Record.push_back(E->isFileScope());
   Code = pch::EXPR_COMPOUND_LITERAL;
 }
 
 void PCHStmtWriter::VisitExtVectorElementExpr(ExtVectorElementExpr *E) {
   VisitExpr(E);
-  Writer.WriteSubStmt(E->getBase());
+  Writer.AddStmt(E->getBase());
   Writer.AddIdentifierRef(&E->getAccessor(), Record);
   Writer.AddSourceLocation(E->getAccessorLoc(), Record);
   Code = pch::EXPR_EXT_VECTOR_ELEMENT;
@@ -620,8 +585,8 @@ void PCHStmtWriter::VisitInitListExpr(InitListExpr *E) {
   VisitExpr(E);
   Record.push_back(E->getNumInits());
   for (unsigned I = 0, N = E->getNumInits(); I != N; ++I)
-    Writer.WriteSubStmt(E->getInit(I));
-  Writer.WriteSubStmt(E->getSyntacticForm());
+    Writer.AddStmt(E->getInit(I));
+  Writer.AddStmt(E->getSyntacticForm());
   Writer.AddSourceLocation(E->getLBraceLoc(), Record);
   Writer.AddSourceLocation(E->getRBraceLoc(), Record);
   Writer.AddDeclRef(E->getInitializedFieldInUnion(), Record);
@@ -633,7 +598,7 @@ void PCHStmtWriter::VisitDesignatedInitExpr(DesignatedInitExpr *E) {
   VisitExpr(E);
   Record.push_back(E->getNumSubExprs());
   for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I)
-    Writer.WriteSubStmt(E->getSubExpr(I));
+    Writer.AddStmt(E->getSubExpr(I));
   Writer.AddSourceLocation(E->getEqualOrColonLoc(), Record);
   Record.push_back(E->usesGNUSyntax());
   for (DesignatedInitExpr::designators_iterator D = E->designators_begin(),
@@ -673,7 +638,7 @@ void PCHStmtWriter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
 
 void PCHStmtWriter::VisitVAArgExpr(VAArgExpr *E) {
   VisitExpr(E);
-  Writer.WriteSubStmt(E->getSubExpr());
+  Writer.AddStmt(E->getSubExpr());
   Writer.AddSourceLocation(E->getBuiltinLoc(), Record);
   Writer.AddSourceLocation(E->getRParenLoc(), Record);
   Code = pch::EXPR_VA_ARG;
@@ -689,7 +654,7 @@ void PCHStmtWriter::VisitAddrLabelExpr(AddrLabelExpr *E) {
 
 void PCHStmtWriter::VisitStmtExpr(StmtExpr *E) {
   VisitExpr(E);
-  Writer.WriteSubStmt(E->getSubStmt());
+  Writer.AddStmt(E->getSubStmt());
   Writer.AddSourceLocation(E->getLParenLoc(), Record);
   Writer.AddSourceLocation(E->getRParenLoc(), Record);
   Code = pch::EXPR_STMT;
@@ -706,9 +671,9 @@ void PCHStmtWriter::VisitTypesCompatibleExpr(TypesCompatibleExpr *E) {
 
 void PCHStmtWriter::VisitChooseExpr(ChooseExpr *E) {
   VisitExpr(E);
-  Writer.WriteSubStmt(E->getCond());
-  Writer.WriteSubStmt(E->getLHS());
-  Writer.WriteSubStmt(E->getRHS());
+  Writer.AddStmt(E->getCond());
+  Writer.AddStmt(E->getLHS());
+  Writer.AddStmt(E->getRHS());
   Writer.AddSourceLocation(E->getBuiltinLoc(), Record);
   Writer.AddSourceLocation(E->getRParenLoc(), Record);
   Code = pch::EXPR_CHOOSE;
@@ -724,7 +689,7 @@ void PCHStmtWriter::VisitShuffleVectorExpr(ShuffleVectorExpr *E) {
   VisitExpr(E);
   Record.push_back(E->getNumSubExprs());
   for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I)
-    Writer.WriteSubStmt(E->getExpr(I));
+    Writer.AddStmt(E->getExpr(I));
   Writer.AddSourceLocation(E->getBuiltinLoc(), Record);
   Writer.AddSourceLocation(E->getRParenLoc(), Record);
   Code = pch::EXPR_SHUFFLE_VECTOR;
@@ -743,7 +708,7 @@ void PCHStmtWriter::VisitBlockDeclRefExpr(BlockDeclRefExpr *E) {
   Writer.AddSourceLocation(E->getLocation(), Record);
   Record.push_back(E->isByRef());
   Record.push_back(E->isConstQualAdded());
-  Writer.WriteSubStmt(E->getCopyConstructorExpr());
+  Writer.AddStmt(E->getCopyConstructorExpr());
   Code = pch::EXPR_BLOCK_DECL_REF;
 }
 
@@ -753,7 +718,7 @@ void PCHStmtWriter::VisitBlockDeclRefExpr(BlockDeclRefExpr *E) {
 
 void PCHStmtWriter::VisitObjCStringLiteral(ObjCStringLiteral *E) {
   VisitExpr(E);
-  Writer.WriteSubStmt(E->getString());
+  Writer.AddStmt(E->getString());
   Writer.AddSourceLocation(E->getAtLoc(), Record);
   Code = pch::EXPR_OBJC_STRING_LITERAL;
 }
@@ -786,7 +751,7 @@ void PCHStmtWriter::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
   VisitExpr(E);
   Writer.AddDeclRef(E->getDecl(), Record);
   Writer.AddSourceLocation(E->getLocation(), Record);
-  Writer.WriteSubStmt(E->getBase());
+  Writer.AddStmt(E->getBase());
   Record.push_back(E->isArrow());
   Record.push_back(E->isFreeIvar());
   Code = pch::EXPR_OBJC_IVAR_REF_EXPR;
@@ -796,7 +761,7 @@ void PCHStmtWriter::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
   VisitExpr(E);
   Writer.AddDeclRef(E->getProperty(), Record);
   Writer.AddSourceLocation(E->getLocation(), Record);
-  Writer.WriteSubStmt(E->getBase());
+  Writer.AddStmt(E->getBase());
   Code = pch::EXPR_OBJC_PROPERTY_REF_EXPR;
 }
 
@@ -808,7 +773,7 @@ void PCHStmtWriter::VisitObjCImplicitSetterGetterRefExpr(
 
   // NOTE: InterfaceDecl and Base are mutually exclusive.
   Writer.AddDeclRef(E->getInterfaceDecl(), Record);
-  Writer.WriteSubStmt(E->getBase());
+  Writer.AddStmt(E->getBase());
   Writer.AddSourceLocation(E->getLocation(), Record);
   Writer.AddSourceLocation(E->getClassLoc(), Record);
   Code = pch::EXPR_OBJC_KVC_REF_EXPR;
@@ -820,7 +785,7 @@ void PCHStmtWriter::VisitObjCMessageExpr(ObjCMessageExpr *E) {
   Record.push_back((unsigned)E->getReceiverKind()); // FIXME: stable encoding
   switch (E->getReceiverKind()) {
   case ObjCMessageExpr::Instance:
-    Writer.WriteSubStmt(E->getInstanceReceiver());
+    Writer.AddStmt(E->getInstanceReceiver());
     break;
 
   case ObjCMessageExpr::Class:
@@ -847,7 +812,7 @@ void PCHStmtWriter::VisitObjCMessageExpr(ObjCMessageExpr *E) {
 
   for (CallExpr::arg_iterator Arg = E->arg_begin(), ArgEnd = E->arg_end();
        Arg != ArgEnd; ++Arg)
-    Writer.WriteSubStmt(*Arg);
+    Writer.AddStmt(*Arg);
   Code = pch::EXPR_OBJC_MESSAGE_EXPR;
 }
 
@@ -859,16 +824,16 @@ void PCHStmtWriter::VisitObjCSuperExpr(ObjCSuperExpr *E) {
 
 void PCHStmtWriter::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
   VisitStmt(S);
-  Writer.WriteSubStmt(S->getElement());
-  Writer.WriteSubStmt(S->getCollection());
-  Writer.WriteSubStmt(S->getBody());
+  Writer.AddStmt(S->getElement());
+  Writer.AddStmt(S->getCollection());
+  Writer.AddStmt(S->getBody());
   Writer.AddSourceLocation(S->getForLoc(), Record);
   Writer.AddSourceLocation(S->getRParenLoc(), Record);
   Code = pch::STMT_OBJC_FOR_COLLECTION;
 }
 
 void PCHStmtWriter::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {
-  Writer.WriteSubStmt(S->getCatchBody());
+  Writer.AddStmt(S->getCatchBody());
   Writer.AddDeclRef(S->getCatchParamDecl(), Record);
   Writer.AddSourceLocation(S->getAtCatchLoc(), Record);
   Writer.AddSourceLocation(S->getRParenLoc(), Record);
@@ -876,7 +841,7 @@ void PCHStmtWriter::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {
 }
 
 void PCHStmtWriter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
-  Writer.WriteSubStmt(S->getFinallyBody());
+  Writer.AddStmt(S->getFinallyBody());
   Writer.AddSourceLocation(S->getAtFinallyLoc(), Record);
   Code = pch::STMT_OBJC_FINALLY;
 }
@@ -884,24 +849,24 @@ void PCHStmtWriter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
 void PCHStmtWriter::VisitObjCAtTryStmt(ObjCAtTryStmt *S) {
   Record.push_back(S->getNumCatchStmts());
   Record.push_back(S->getFinallyStmt() != 0);
-  Writer.WriteSubStmt(S->getTryBody());
+  Writer.AddStmt(S->getTryBody());
   for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I)
-    Writer.WriteSubStmt(S->getCatchStmt(I));
+    Writer.AddStmt(S->getCatchStmt(I));
   if (S->getFinallyStmt())
-    Writer.WriteSubStmt(S->getFinallyStmt());
+    Writer.AddStmt(S->getFinallyStmt());
   Writer.AddSourceLocation(S->getAtTryLoc(), Record);
   Code = pch::STMT_OBJC_AT_TRY;
 }
 
 void PCHStmtWriter::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) {
-  Writer.WriteSubStmt(S->getSynchExpr());
-  Writer.WriteSubStmt(S->getSynchBody());
+  Writer.AddStmt(S->getSynchExpr());
+  Writer.AddStmt(S->getSynchBody());
   Writer.AddSourceLocation(S->getAtSynchronizedLoc(), Record);
   Code = pch::STMT_OBJC_AT_SYNCHRONIZED;
 }
 
 void PCHStmtWriter::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {
-  Writer.WriteSubStmt(S->getThrowExpr());
+  Writer.AddStmt(S->getThrowExpr());
   Writer.AddSourceLocation(S->getThrowLoc(), Record);
   Code = pch::STMT_OBJC_AT_THROW;
 }
@@ -925,7 +890,7 @@ void PCHStmtWriter::VisitCXXConstructExpr(CXXConstructExpr *E) {
   VisitExpr(E);
   Record.push_back(E->getNumArgs());
   for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
-    Writer.WriteSubStmt(E->getArg(I));
+    Writer.AddStmt(E->getArg(I));
   Writer.AddDeclRef(E->getConstructor(), Record);
   Writer.AddSourceLocation(E->getLocation(), Record);
   Record.push_back(E->isElidable());
@@ -986,7 +951,7 @@ void PCHStmtWriter::VisitCXXTypeidExpr(CXXTypeidExpr *E) {
     Writer.AddTypeSourceInfo(E->getTypeOperandSourceInfo(), Record);
     Code = pch::EXPR_CXX_TYPEID_TYPE;
   } else {
-    Writer.WriteSubStmt(E->getExprOperand());
+    Writer.AddStmt(E->getExprOperand());
     Code = pch::EXPR_CXX_TYPEID_EXPR;
   }
 }
@@ -1001,7 +966,7 @@ void PCHStmtWriter::VisitCXXThisExpr(CXXThisExpr *E) {
 void PCHStmtWriter::VisitCXXThrowExpr(CXXThrowExpr *E) {
   VisitExpr(E);
   Writer.AddSourceLocation(E->getThrowLoc(), Record);
-  Writer.WriteSubStmt(E->getSubExpr());
+  Writer.AddStmt(E->getSubExpr());
   Code = pch::EXPR_CXX_THROW;
 }
 
@@ -1010,7 +975,7 @@ void PCHStmtWriter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
   Writer.AddSourceLocation(E->getUsedLocation(), Record);
   if (E->isExprStored()) {
     Record.push_back(1);
-    Writer.WriteSubStmt(E->getExpr());
+    Writer.AddStmt(E->getExpr());
   } else {
     Record.push_back(0);
   }
@@ -1021,7 +986,7 @@ void PCHStmtWriter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
 void PCHStmtWriter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
   VisitExpr(E);
   Writer.AddCXXTemporary(E->getTemporary(), Record);
-  Writer.WriteSubStmt(E->getSubExpr());
+  Writer.AddStmt(E->getSubExpr());
   Code = pch::EXPR_CXX_BIND_TEMPORARY;
 }
 
@@ -1047,7 +1012,7 @@ void PCHStmtWriter::VisitCXXNewExpr(CXXNewExpr *E) {
   Writer.AddSourceLocation(E->getEndLoc(), Record);
   for (CXXNewExpr::arg_iterator I = E->raw_arg_begin(), e = E->raw_arg_end();
        I != e; ++I)
-    Writer.WriteSubStmt(*I);
+    Writer.AddStmt(*I);
   
   Code = pch::EXPR_CXX_NEW;
 }
@@ -1057,7 +1022,7 @@ void PCHStmtWriter::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
   Record.push_back(E->isGlobalDelete());
   Record.push_back(E->isArrayForm());
   Writer.AddDeclRef(E->getOperatorDelete(), Record);
-  Writer.WriteSubStmt(E->getArgument());
+  Writer.AddStmt(E->getArgument());
   Writer.AddSourceLocation(E->getSourceRange().getBegin(), Record);
   
   Code = pch::EXPR_CXX_DELETE;
@@ -1091,7 +1056,7 @@ void PCHStmtWriter::VisitCXXExprWithTemporaries(CXXExprWithTemporaries *E) {
   for (unsigned i = 0, e = E->getNumTemporaries(); i != e; ++i)
     Writer.AddCXXTemporary(E->getTemporary(i), Record);
   
-  Writer.WriteSubStmt(E->getSubExpr());
+  Writer.AddStmt(E->getSubExpr());
   Code = pch::EXPR_CXX_EXPR_WITH_TEMPORARIES;
 }
 
@@ -1113,9 +1078,9 @@ PCHStmtWriter::VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E){
   }
   
   if (!E->isImplicitAccess())
-    Writer.WriteSubStmt(E->getBase());
+    Writer.AddStmt(E->getBase());
   else
-    Writer.WriteSubStmt(0);
+    Writer.AddStmt(0);
   Writer.AddTypeRef(E->getBaseType(), Record);
   Record.push_back(E->isArrow());
   Writer.AddSourceLocation(E->getOperatorLoc(), Record);
@@ -1156,7 +1121,7 @@ PCHStmtWriter::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) {
   Record.push_back(E->arg_size());
   for (CXXUnresolvedConstructExpr::arg_iterator
          ArgI = E->arg_begin(), ArgE = E->arg_end(); ArgI != ArgE; ++ArgI)
-    Writer.WriteSubStmt(*ArgI);
+    Writer.AddStmt(*ArgI);
   Writer.AddSourceLocation(E->getTypeBeginLoc(), Record);
   Writer.AddTypeRef(E->getTypeAsWritten(), Record);
   Writer.AddSourceLocation(E->getLParenLoc(), Record);
@@ -1196,7 +1161,7 @@ void PCHStmtWriter::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) {
   VisitOverloadExpr(E);
   Record.push_back(E->isArrow());
   Record.push_back(E->hasUnresolvedUsing());
-  Writer.WriteSubStmt(!E->isImplicitAccess() ? E->getBase() : 0);
+  Writer.AddStmt(!E->isImplicitAccess() ? E->getBase() : 0);
   Writer.AddTypeRef(E->getBaseType(), Record);
   Writer.AddSourceLocation(E->getOperatorLoc(), Record);
   Code = pch::EXPR_CXX_UNRESOLVED_MEMBER;
@@ -1246,12 +1211,16 @@ void PCHWriter::WriteSubStmt(Stmt *S) {
   RecordData Record;
   PCHStmtWriter Writer(*this, Record);
   ++NumStatements;
-
+  
   if (!S) {
     Stream.EmitRecord(pch::STMT_NULL_PTR, Record);
     return;
   }
 
+  // Redirect PCHWriter::AddStmt to collect sub stmts.
+  llvm::SmallVector<Stmt *, 16> SubStmts;
+  CollectedStmts = &SubStmts;
+
   Writer.Code = pch::STMT_NULL_PTR;
   Writer.Visit(S);
   
@@ -1263,6 +1232,17 @@ void PCHWriter::WriteSubStmt(Stmt *S) {
     assert(0 && "Unhandled sub statement writing PCH file");
   }
 #endif
+
+  // Revert PCHWriter::AddStmt.
+  CollectedStmts = &StmtsToEmit;
+
+  // Write the sub stmts in reverse order, last to first. When reading them back
+  // we will read them in correct order by "pop"ing them from the Stmts stack.
+  // This simplifies reading and allows to store a variable number of sub stmts
+  // without knowing it in advance.
+  while (!SubStmts.empty())
+    WriteSubStmt(SubStmts.pop_back_val());
+  
   Stream.EmitRecord(Writer.Code, Record);
 }
 
@@ -1270,41 +1250,18 @@ void PCHWriter::WriteSubStmt(Stmt *S) {
 /// queue via AddStmt().
 void PCHWriter::FlushStmts() {
   RecordData Record;
-  PCHStmtWriter Writer(*this, Record);
-  
-  EmittingStmts = true;
 
   for (unsigned I = 0, N = StmtsToEmit.size(); I != N; ++I) {
-    ++NumStatements;
-    Stmt *S = StmtsToEmit[I];
-
-    if (!S) {
-      Stream.EmitRecord(pch::STMT_NULL_PTR, Record);
-      Stream.EmitRecord(pch::STMT_STOP, Record);
-      continue;
-    }
-
-    Writer.Code = pch::STMT_NULL_PTR;
-    Writer.Visit(S);
-#ifndef NDEBUG
-    if (Writer.Code == pch::STMT_NULL_PTR) {
-      S->dump();
-      assert(0 && "Unhandled expression writing PCH file");
-    }
-#endif
-    Stream.EmitRecord(Writer.Code, Record);
-
+    WriteSubStmt(StmtsToEmit[I]);
+    
     assert(N == StmtsToEmit.size() &&
            "Substatement writen via AddStmt rather than WriteSubStmt!");
 
     // Note that we are at the end of a full expression. Any
     // expression records that follow this one are part of a different
     // expression.
-    Record.clear();
     Stream.EmitRecord(pch::STMT_STOP, Record);
   }
 
-  EmittingStmts = false;
-
   StmtsToEmit.clear();
 }