ASTWriterStmt.cpp revision 4b9c2d235fb9449e249d74f48ecfec601650de93 
1//===--- ASTWriterStmt.cpp - Statement and Expression Serialization -------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10//  This file implements serialization for Statements and Expressions.
11//
12//===----------------------------------------------------------------------===//
13
14#include "clang/Serialization/ASTWriter.h"
15#include "clang/AST/DeclCXX.h"
16#include "clang/AST/DeclObjC.h"
17#include "clang/AST/DeclTemplate.h"
18#include "clang/AST/StmtVisitor.h"
19#include "llvm/Bitcode/BitstreamWriter.h"
20using namespace clang;
21
22//===----------------------------------------------------------------------===//
23// Statement/expression serialization
24//===----------------------------------------------------------------------===//
25
26namespace clang {
27  class ASTStmtWriter : public StmtVisitor<ASTStmtWriter, void> {
28    ASTWriter &Writer;
29    ASTWriter::RecordData &Record;
30
31  public:
32    serialization::StmtCode Code;
33    unsigned AbbrevToUse;
34
35    ASTStmtWriter(ASTWriter &Writer, ASTWriter::RecordData &Record)
36      : Writer(Writer), Record(Record) { }
37
38    void
39    AddExplicitTemplateArgumentList(const ASTTemplateArgumentListInfo &Args);
40
41    void VisitStmt(Stmt *S);
42#define STMT(Type, Base) \
43    void Visit##Type(Type *);
44#include "clang/AST/StmtNodes.inc"
45  };
46}
47
48void ASTStmtWriter::
49AddExplicitTemplateArgumentList(const ASTTemplateArgumentListInfo &Args) {
50  Writer.AddSourceLocation(Args.LAngleLoc, Record);
51  Writer.AddSourceLocation(Args.RAngleLoc, Record);
52  for (unsigned i=0; i != Args.NumTemplateArgs; ++i)
53    Writer.AddTemplateArgumentLoc(Args.getTemplateArgs()[i], Record);
54}
55
56void ASTStmtWriter::VisitStmt(Stmt *S) {
57}
58
59void ASTStmtWriter::VisitNullStmt(NullStmt *S) {
60  VisitStmt(S);
61  Writer.AddSourceLocation(S->getSemiLoc(), Record);
62  Record.push_back(S->HasLeadingEmptyMacro);
63  Code = serialization::STMT_NULL;
64}
65
66void ASTStmtWriter::VisitCompoundStmt(CompoundStmt *S) {
67  VisitStmt(S);
68  Record.push_back(S->size());
69  for (CompoundStmt::body_iterator CS = S->body_begin(), CSEnd = S->body_end();
70       CS != CSEnd; ++CS)
71    Writer.AddStmt(*CS);
72  Writer.AddSourceLocation(S->getLBracLoc(), Record);
73  Writer.AddSourceLocation(S->getRBracLoc(), Record);
74  Code = serialization::STMT_COMPOUND;
75}
76
77void ASTStmtWriter::VisitSwitchCase(SwitchCase *S) {
78  VisitStmt(S);
79  Record.push_back(Writer.getSwitchCaseID(S));
80}
81
82void ASTStmtWriter::VisitCaseStmt(CaseStmt *S) {
83  VisitSwitchCase(S);
84  Writer.AddStmt(S->getLHS());
85  Writer.AddStmt(S->getRHS());
86  Writer.AddStmt(S->getSubStmt());
87  Writer.AddSourceLocation(S->getCaseLoc(), Record);
88  Writer.AddSourceLocation(S->getEllipsisLoc(), Record);
89  Writer.AddSourceLocation(S->getColonLoc(), Record);
90  Code = serialization::STMT_CASE;
91}
92
93void ASTStmtWriter::VisitDefaultStmt(DefaultStmt *S) {
94  VisitSwitchCase(S);
95  Writer.AddStmt(S->getSubStmt());
96  Writer.AddSourceLocation(S->getDefaultLoc(), Record);
97  Writer.AddSourceLocation(S->getColonLoc(), Record);
98  Code = serialization::STMT_DEFAULT;
99}
100
101void ASTStmtWriter::VisitLabelStmt(LabelStmt *S) {
102  VisitStmt(S);
103  Writer.AddDeclRef(S->getDecl(), Record);
104  Writer.AddStmt(S->getSubStmt());
105  Writer.AddSourceLocation(S->getIdentLoc(), Record);
106  Code = serialization::STMT_LABEL;
107}
108
109void ASTStmtWriter::VisitIfStmt(IfStmt *S) {
110  VisitStmt(S);
111  Writer.AddDeclRef(S->getConditionVariable(), Record);
112  Writer.AddStmt(S->getCond());
113  Writer.AddStmt(S->getThen());
114  Writer.AddStmt(S->getElse());
115  Writer.AddSourceLocation(S->getIfLoc(), Record);
116  Writer.AddSourceLocation(S->getElseLoc(), Record);
117  Code = serialization::STMT_IF;
118}
119
120void ASTStmtWriter::VisitSwitchStmt(SwitchStmt *S) {
121  VisitStmt(S);
122  Writer.AddDeclRef(S->getConditionVariable(), Record);
123  Writer.AddStmt(S->getCond());
124  Writer.AddStmt(S->getBody());
125  Writer.AddSourceLocation(S->getSwitchLoc(), Record);
126  Record.push_back(S->isAllEnumCasesCovered());
127  for (SwitchCase *SC = S->getSwitchCaseList(); SC;
128       SC = SC->getNextSwitchCase())
129    Record.push_back(Writer.RecordSwitchCaseID(SC));
130  Code = serialization::STMT_SWITCH;
131}
132
133void ASTStmtWriter::VisitWhileStmt(WhileStmt *S) {
134  VisitStmt(S);
135  Writer.AddDeclRef(S->getConditionVariable(), Record);
136  Writer.AddStmt(S->getCond());
137  Writer.AddStmt(S->getBody());
138  Writer.AddSourceLocation(S->getWhileLoc(), Record);
139  Code = serialization::STMT_WHILE;
140}
141
142void ASTStmtWriter::VisitDoStmt(DoStmt *S) {
143  VisitStmt(S);
144  Writer.AddStmt(S->getCond());
145  Writer.AddStmt(S->getBody());
146  Writer.AddSourceLocation(S->getDoLoc(), Record);
147  Writer.AddSourceLocation(S->getWhileLoc(), Record);
148  Writer.AddSourceLocation(S->getRParenLoc(), Record);
149  Code = serialization::STMT_DO;
150}
151
152void ASTStmtWriter::VisitForStmt(ForStmt *S) {
153  VisitStmt(S);
154  Writer.AddStmt(S->getInit());
155  Writer.AddStmt(S->getCond());
156  Writer.AddDeclRef(S->getConditionVariable(), Record);
157  Writer.AddStmt(S->getInc());
158  Writer.AddStmt(S->getBody());
159  Writer.AddSourceLocation(S->getForLoc(), Record);
160  Writer.AddSourceLocation(S->getLParenLoc(), Record);
161  Writer.AddSourceLocation(S->getRParenLoc(), Record);
162  Code = serialization::STMT_FOR;
163}
164
165void ASTStmtWriter::VisitGotoStmt(GotoStmt *S) {
166  VisitStmt(S);
167  Writer.AddDeclRef(S->getLabel(), Record);
168  Writer.AddSourceLocation(S->getGotoLoc(), Record);
169  Writer.AddSourceLocation(S->getLabelLoc(), Record);
170  Code = serialization::STMT_GOTO;
171}
172
173void ASTStmtWriter::VisitIndirectGotoStmt(IndirectGotoStmt *S) {
174  VisitStmt(S);
175  Writer.AddSourceLocation(S->getGotoLoc(), Record);
176  Writer.AddSourceLocation(S->getStarLoc(), Record);
177  Writer.AddStmt(S->getTarget());
178  Code = serialization::STMT_INDIRECT_GOTO;
179}
180
181void ASTStmtWriter::VisitContinueStmt(ContinueStmt *S) {
182  VisitStmt(S);
183  Writer.AddSourceLocation(S->getContinueLoc(), Record);
184  Code = serialization::STMT_CONTINUE;
185}
186
187void ASTStmtWriter::VisitBreakStmt(BreakStmt *S) {
188  VisitStmt(S);
189  Writer.AddSourceLocation(S->getBreakLoc(), Record);
190  Code = serialization::STMT_BREAK;
191}
192
193void ASTStmtWriter::VisitReturnStmt(ReturnStmt *S) {
194  VisitStmt(S);
195  Writer.AddStmt(S->getRetValue());
196  Writer.AddSourceLocation(S->getReturnLoc(), Record);
197  Writer.AddDeclRef(S->getNRVOCandidate(), Record);
198  Code = serialization::STMT_RETURN;
199}
200
201void ASTStmtWriter::VisitDeclStmt(DeclStmt *S) {
202  VisitStmt(S);
203  Writer.AddSourceLocation(S->getStartLoc(), Record);
204  Writer.AddSourceLocation(S->getEndLoc(), Record);
205  DeclGroupRef DG = S->getDeclGroup();
206  for (DeclGroupRef::iterator D = DG.begin(), DEnd = DG.end(); D != DEnd; ++D)
207    Writer.AddDeclRef(*D, Record);
208  Code = serialization::STMT_DECL;
209}
210
211void ASTStmtWriter::VisitAsmStmt(AsmStmt *S) {
212  VisitStmt(S);
213  Record.push_back(S->getNumOutputs());
214  Record.push_back(S->getNumInputs());
215  Record.push_back(S->getNumClobbers());
216  Writer.AddSourceLocation(S->getAsmLoc(), Record);
217  Writer.AddSourceLocation(S->getRParenLoc(), Record);
218  Record.push_back(S->isVolatile());
219  Record.push_back(S->isSimple());
220  Record.push_back(S->isMSAsm());
221  Writer.AddStmt(S->getAsmString());
222
223  // Outputs
224  for (unsigned I = 0, N = S->getNumOutputs(); I != N; ++I) {
225    Writer.AddIdentifierRef(S->getOutputIdentifier(I), Record);
226    Writer.AddStmt(S->getOutputConstraintLiteral(I));
227    Writer.AddStmt(S->getOutputExpr(I));
228  }
229
230  // Inputs
231  for (unsigned I = 0, N = S->getNumInputs(); I != N; ++I) {
232    Writer.AddIdentifierRef(S->getInputIdentifier(I), Record);
233    Writer.AddStmt(S->getInputConstraintLiteral(I));
234    Writer.AddStmt(S->getInputExpr(I));
235  }
236
237  // Clobbers
238  for (unsigned I = 0, N = S->getNumClobbers(); I != N; ++I)
239    Writer.AddStmt(S->getClobber(I));
240
241  Code = serialization::STMT_ASM;
242}
243
244void ASTStmtWriter::VisitExpr(Expr *E) {
245  VisitStmt(E);
246  Writer.AddTypeRef(E->getType(), Record);
247  Record.push_back(E->isTypeDependent());
248  Record.push_back(E->isValueDependent());
249  Record.push_back(E->isInstantiationDependent());
250  Record.push_back(E->containsUnexpandedParameterPack());
251  Record.push_back(E->getValueKind());
252  Record.push_back(E->getObjectKind());
253}
254
255void ASTStmtWriter::VisitPredefinedExpr(PredefinedExpr *E) {
256  VisitExpr(E);
257  Writer.AddSourceLocation(E->getLocation(), Record);
258  Record.push_back(E->getIdentType()); // FIXME: stable encoding
259  Code = serialization::EXPR_PREDEFINED;
260}
261
262void ASTStmtWriter::VisitDeclRefExpr(DeclRefExpr *E) {
263  VisitExpr(E);
264
265  Record.push_back(E->hasQualifier());
266  Record.push_back(E->getDecl() != E->getFoundDecl());
267  Record.push_back(E->hasExplicitTemplateArgs());
268  Record.push_back(E->hadMultipleCandidates());
269
270  if (E->hasExplicitTemplateArgs()) {
271    unsigned NumTemplateArgs = E->getNumTemplateArgs();
272    Record.push_back(NumTemplateArgs);
273  }
274
275  DeclarationName::NameKind nk = (E->getDecl()->getDeclName().getNameKind());
276
277  if ((!E->hasExplicitTemplateArgs()) && (!E->hasQualifier()) &&
278      (E->getDecl() == E->getFoundDecl()) &&
279      nk == DeclarationName::Identifier) {
280    AbbrevToUse = Writer.getDeclRefExprAbbrev();
281  }
282
283  if (E->hasQualifier())
284    Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record);
285
286  if (E->getDecl() != E->getFoundDecl())
287    Writer.AddDeclRef(E->getFoundDecl(), Record);
288
289  if (E->hasExplicitTemplateArgs())
290    AddExplicitTemplateArgumentList(E->getExplicitTemplateArgs());
291
292  Writer.AddDeclRef(E->getDecl(), Record);
293  Writer.AddSourceLocation(E->getLocation(), Record);
294  Writer.AddDeclarationNameLoc(E->DNLoc, E->getDecl()->getDeclName(), Record);
295  Code = serialization::EXPR_DECL_REF;
296}
297
298void ASTStmtWriter::VisitIntegerLiteral(IntegerLiteral *E) {
299  VisitExpr(E);
300  Writer.AddSourceLocation(E->getLocation(), Record);
301  Writer.AddAPInt(E->getValue(), Record);
302
303  if (E->getValue().getBitWidth() == 32) {
304    AbbrevToUse = Writer.getIntegerLiteralAbbrev();
305  }
306
307  Code = serialization::EXPR_INTEGER_LITERAL;
308}
309
310void ASTStmtWriter::VisitFloatingLiteral(FloatingLiteral *E) {
311  VisitExpr(E);
312  Writer.AddAPFloat(E->getValue(), Record);
313  Record.push_back(E->isExact());
314  Writer.AddSourceLocation(E->getLocation(), Record);
315  Code = serialization::EXPR_FLOATING_LITERAL;
316}
317
318void ASTStmtWriter::VisitImaginaryLiteral(ImaginaryLiteral *E) {
319  VisitExpr(E);
320  Writer.AddStmt(E->getSubExpr());
321  Code = serialization::EXPR_IMAGINARY_LITERAL;
322}
323
324void ASTStmtWriter::VisitStringLiteral(StringLiteral *E) {
325  VisitExpr(E);
326  Record.push_back(E->getByteLength());
327  Record.push_back(E->getNumConcatenated());
328  Record.push_back(E->getKind());
329  Record.push_back(E->isPascal());
330  // FIXME: String data should be stored as a blob at the end of the
331  // StringLiteral. However, we can't do so now because we have no
332  // provision for coping with abbreviations when we're jumping around
333  // the AST file during deserialization.
334  Record.append(E->getBytes().begin(), E->getBytes().end());
335  for (unsigned I = 0, N = E->getNumConcatenated(); I != N; ++I)
336    Writer.AddSourceLocation(E->getStrTokenLoc(I), Record);
337  Code = serialization::EXPR_STRING_LITERAL;
338}
339
340void ASTStmtWriter::VisitCharacterLiteral(CharacterLiteral *E) {
341  VisitExpr(E);
342  Record.push_back(E->getValue());
343  Writer.AddSourceLocation(E->getLocation(), Record);
344  Record.push_back(E->getKind());
345
346  AbbrevToUse = Writer.getCharacterLiteralAbbrev();
347
348  Code = serialization::EXPR_CHARACTER_LITERAL;
349}
350
351void ASTStmtWriter::VisitParenExpr(ParenExpr *E) {
352  VisitExpr(E);
353  Writer.AddSourceLocation(E->getLParen(), Record);
354  Writer.AddSourceLocation(E->getRParen(), Record);
355  Writer.AddStmt(E->getSubExpr());
356  Code = serialization::EXPR_PAREN;
357}
358
359void ASTStmtWriter::VisitParenListExpr(ParenListExpr *E) {
360  VisitExpr(E);
361  Record.push_back(E->NumExprs);
362  for (unsigned i=0; i != E->NumExprs; ++i)
363    Writer.AddStmt(E->Exprs[i]);
364  Writer.AddSourceLocation(E->LParenLoc, Record);
365  Writer.AddSourceLocation(E->RParenLoc, Record);
366  Code = serialization::EXPR_PAREN_LIST;
367}
368
369void ASTStmtWriter::VisitUnaryOperator(UnaryOperator *E) {
370  VisitExpr(E);
371  Writer.AddStmt(E->getSubExpr());
372  Record.push_back(E->getOpcode()); // FIXME: stable encoding
373  Writer.AddSourceLocation(E->getOperatorLoc(), Record);
374  Code = serialization::EXPR_UNARY_OPERATOR;
375}
376
377void ASTStmtWriter::VisitOffsetOfExpr(OffsetOfExpr *E) {
378  VisitExpr(E);
379  Record.push_back(E->getNumComponents());
380  Record.push_back(E->getNumExpressions());
381  Writer.AddSourceLocation(E->getOperatorLoc(), Record);
382  Writer.AddSourceLocation(E->getRParenLoc(), Record);
383  Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record);
384  for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) {
385    const OffsetOfExpr::OffsetOfNode &ON = E->getComponent(I);
386    Record.push_back(ON.getKind()); // FIXME: Stable encoding
387    Writer.AddSourceLocation(ON.getSourceRange().getBegin(), Record);
388    Writer.AddSourceLocation(ON.getSourceRange().getEnd(), Record);
389    switch (ON.getKind()) {
390    case OffsetOfExpr::OffsetOfNode::Array:
391      Record.push_back(ON.getArrayExprIndex());
392      break;
393
394    case OffsetOfExpr::OffsetOfNode::Field:
395      Writer.AddDeclRef(ON.getField(), Record);
396      break;
397
398    case OffsetOfExpr::OffsetOfNode::Identifier:
399      Writer.AddIdentifierRef(ON.getFieldName(), Record);
400      break;
401
402    case OffsetOfExpr::OffsetOfNode::Base:
403      Writer.AddCXXBaseSpecifier(*ON.getBase(), Record);
404      break;
405    }
406  }
407  for (unsigned I = 0, N = E->getNumExpressions(); I != N; ++I)
408    Writer.AddStmt(E->getIndexExpr(I));
409  Code = serialization::EXPR_OFFSETOF;
410}
411
412void ASTStmtWriter::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) {
413  VisitExpr(E);
414  Record.push_back(E->getKind());
415  if (E->isArgumentType())
416    Writer.AddTypeSourceInfo(E->getArgumentTypeInfo(), Record);
417  else {
418    Record.push_back(0);
419    Writer.AddStmt(E->getArgumentExpr());
420  }
421  Writer.AddSourceLocation(E->getOperatorLoc(), Record);
422  Writer.AddSourceLocation(E->getRParenLoc(), Record);
423  Code = serialization::EXPR_SIZEOF_ALIGN_OF;
424}
425
426void ASTStmtWriter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
427  VisitExpr(E);
428  Writer.AddStmt(E->getLHS());
429  Writer.AddStmt(E->getRHS());
430  Writer.AddSourceLocation(E->getRBracketLoc(), Record);
431  Code = serialization::EXPR_ARRAY_SUBSCRIPT;
432}
433
434void ASTStmtWriter::VisitCallExpr(CallExpr *E) {
435  VisitExpr(E);
436  Record.push_back(E->getNumArgs());
437  Writer.AddSourceLocation(E->getRParenLoc(), Record);
438  Writer.AddStmt(E->getCallee());
439  for (CallExpr::arg_iterator Arg = E->arg_begin(), ArgEnd = E->arg_end();
440       Arg != ArgEnd; ++Arg)
441    Writer.AddStmt(*Arg);
442  Code = serialization::EXPR_CALL;
443}
444
445void ASTStmtWriter::VisitMemberExpr(MemberExpr *E) {
446  // Don't call VisitExpr, we'll write everything here.
447
448  Record.push_back(E->hasQualifier());
449  if (E->hasQualifier())
450    Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record);
451
452  Record.push_back(E->hasExplicitTemplateArgs());
453  if (E->hasExplicitTemplateArgs()) {
454    unsigned NumTemplateArgs = E->getNumTemplateArgs();
455    Record.push_back(NumTemplateArgs);
456    Writer.AddSourceLocation(E->getLAngleLoc(), Record);
457    Writer.AddSourceLocation(E->getRAngleLoc(), Record);
458    for (unsigned i=0; i != NumTemplateArgs; ++i)
459      Writer.AddTemplateArgumentLoc(E->getTemplateArgs()[i], Record);
460  }
461
462  Record.push_back(E->hadMultipleCandidates());
463
464  DeclAccessPair FoundDecl = E->getFoundDecl();
465  Writer.AddDeclRef(FoundDecl.getDecl(), Record);
466  Record.push_back(FoundDecl.getAccess());
467
468  Writer.AddTypeRef(E->getType(), Record);
469  Record.push_back(E->getValueKind());
470  Record.push_back(E->getObjectKind());
471  Writer.AddStmt(E->getBase());
472  Writer.AddDeclRef(E->getMemberDecl(), Record);
473  Writer.AddSourceLocation(E->getMemberLoc(), Record);
474  Record.push_back(E->isArrow());
475  Writer.AddDeclarationNameLoc(E->MemberDNLoc,
476                               E->getMemberDecl()->getDeclName(), Record);
477  Code = serialization::EXPR_MEMBER;
478}
479
480void ASTStmtWriter::VisitObjCIsaExpr(ObjCIsaExpr *E) {
481  VisitExpr(E);
482  Writer.AddStmt(E->getBase());
483  Writer.AddSourceLocation(E->getIsaMemberLoc(), Record);
484  Record.push_back(E->isArrow());
485  Code = serialization::EXPR_OBJC_ISA;
486}
487
488void ASTStmtWriter::
489VisitObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) {
490  VisitExpr(E);
491  Writer.AddStmt(E->getSubExpr());
492  Record.push_back(E->shouldCopy());
493  Code = serialization::EXPR_OBJC_INDIRECT_COPY_RESTORE;
494}
495
496void ASTStmtWriter::VisitObjCBridgedCastExpr(ObjCBridgedCastExpr *E) {
497  VisitExplicitCastExpr(E);
498  Writer.AddSourceLocation(E->getLParenLoc(), Record);
499  Writer.AddSourceLocation(E->getBridgeKeywordLoc(), Record);
500  Record.push_back(E->getBridgeKind()); // FIXME: Stable encoding
501  Code = serialization::EXPR_OBJC_BRIDGED_CAST;
502}
503
504void ASTStmtWriter::VisitCastExpr(CastExpr *E) {
505  VisitExpr(E);
506  Record.push_back(E->path_size());
507  Writer.AddStmt(E->getSubExpr());
508  Record.push_back(E->getCastKind()); // FIXME: stable encoding
509
510  for (CastExpr::path_iterator
511         PI = E->path_begin(), PE = E->path_end(); PI != PE; ++PI)
512    Writer.AddCXXBaseSpecifier(**PI, Record);
513}
514
515void ASTStmtWriter::VisitBinaryOperator(BinaryOperator *E) {
516  VisitExpr(E);
517  Writer.AddStmt(E->getLHS());
518  Writer.AddStmt(E->getRHS());
519  Record.push_back(E->getOpcode()); // FIXME: stable encoding
520  Writer.AddSourceLocation(E->getOperatorLoc(), Record);
521  Code = serialization::EXPR_BINARY_OPERATOR;
522}
523
524void ASTStmtWriter::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
525  VisitBinaryOperator(E);
526  Writer.AddTypeRef(E->getComputationLHSType(), Record);
527  Writer.AddTypeRef(E->getComputationResultType(), Record);
528  Code = serialization::EXPR_COMPOUND_ASSIGN_OPERATOR;
529}
530
531void ASTStmtWriter::VisitConditionalOperator(ConditionalOperator *E) {
532  VisitExpr(E);
533  Writer.AddStmt(E->getCond());
534  Writer.AddStmt(E->getLHS());
535  Writer.AddStmt(E->getRHS());
536  Writer.AddSourceLocation(E->getQuestionLoc(), Record);
537  Writer.AddSourceLocation(E->getColonLoc(), Record);
538  Code = serialization::EXPR_CONDITIONAL_OPERATOR;
539}
540
541void
542ASTStmtWriter::VisitBinaryConditionalOperator(BinaryConditionalOperator *E) {
543  VisitExpr(E);
544  Writer.AddStmt(E->getOpaqueValue());
545  Writer.AddStmt(E->getCommon());
546  Writer.AddStmt(E->getCond());
547  Writer.AddStmt(E->getTrueExpr());
548  Writer.AddStmt(E->getFalseExpr());
549  Writer.AddSourceLocation(E->getQuestionLoc(), Record);
550  Writer.AddSourceLocation(E->getColonLoc(), Record);
551  Code = serialization::EXPR_BINARY_CONDITIONAL_OPERATOR;
552}
553
554void ASTStmtWriter::VisitImplicitCastExpr(ImplicitCastExpr *E) {
555  VisitCastExpr(E);
556  Code = serialization::EXPR_IMPLICIT_CAST;
557}
558
559void ASTStmtWriter::VisitExplicitCastExpr(ExplicitCastExpr *E) {
560  VisitCastExpr(E);
561  Writer.AddTypeSourceInfo(E->getTypeInfoAsWritten(), Record);
562}
563
564void ASTStmtWriter::VisitCStyleCastExpr(CStyleCastExpr *E) {
565  VisitExplicitCastExpr(E);
566  Writer.AddSourceLocation(E->getLParenLoc(), Record);
567  Writer.AddSourceLocation(E->getRParenLoc(), Record);
568  Code = serialization::EXPR_CSTYLE_CAST;
569}
570
571void ASTStmtWriter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
572  VisitExpr(E);
573  Writer.AddSourceLocation(E->getLParenLoc(), Record);
574  Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record);
575  Writer.AddStmt(E->getInitializer());
576  Record.push_back(E->isFileScope());
577  Code = serialization::EXPR_COMPOUND_LITERAL;
578}
579
580void ASTStmtWriter::VisitExtVectorElementExpr(ExtVectorElementExpr *E) {
581  VisitExpr(E);
582  Writer.AddStmt(E->getBase());
583  Writer.AddIdentifierRef(&E->getAccessor(), Record);
584  Writer.AddSourceLocation(E->getAccessorLoc(), Record);
585  Code = serialization::EXPR_EXT_VECTOR_ELEMENT;
586}
587
588void ASTStmtWriter::VisitInitListExpr(InitListExpr *E) {
589  VisitExpr(E);
590  Writer.AddStmt(E->getSyntacticForm());
591  Writer.AddSourceLocation(E->getLBraceLoc(), Record);
592  Writer.AddSourceLocation(E->getRBraceLoc(), Record);
593  bool isArrayFiller = E->ArrayFillerOrUnionFieldInit.is<Expr*>();
594  Record.push_back(isArrayFiller);
595  if (isArrayFiller)
596    Writer.AddStmt(E->getArrayFiller());
597  else
598    Writer.AddDeclRef(E->getInitializedFieldInUnion(), Record);
599  Record.push_back(E->hadArrayRangeDesignator());
600  Record.push_back(E->getNumInits());
601  if (isArrayFiller) {
602    // ArrayFiller may have filled "holes" due to designated initializer.
603    // Replace them by 0 to indicate that the filler goes in that place.
604    Expr *filler = E->getArrayFiller();
605    for (unsigned I = 0, N = E->getNumInits(); I != N; ++I)
606      Writer.AddStmt(E->getInit(I) != filler ? E->getInit(I) : 0);
607  } else {
608    for (unsigned I = 0, N = E->getNumInits(); I != N; ++I)
609      Writer.AddStmt(E->getInit(I));
610  }
611  Code = serialization::EXPR_INIT_LIST;
612}
613
614void ASTStmtWriter::VisitDesignatedInitExpr(DesignatedInitExpr *E) {
615  VisitExpr(E);
616  Record.push_back(E->getNumSubExprs());
617  for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I)
618    Writer.AddStmt(E->getSubExpr(I));
619  Writer.AddSourceLocation(E->getEqualOrColonLoc(), Record);
620  Record.push_back(E->usesGNUSyntax());
621  for (DesignatedInitExpr::designators_iterator D = E->designators_begin(),
622                                             DEnd = E->designators_end();
623       D != DEnd; ++D) {
624    if (D->isFieldDesignator()) {
625      if (FieldDecl *Field = D->getField()) {
626        Record.push_back(serialization::DESIG_FIELD_DECL);
627        Writer.AddDeclRef(Field, Record);
628      } else {
629        Record.push_back(serialization::DESIG_FIELD_NAME);
630        Writer.AddIdentifierRef(D->getFieldName(), Record);
631      }
632      Writer.AddSourceLocation(D->getDotLoc(), Record);
633      Writer.AddSourceLocation(D->getFieldLoc(), Record);
634    } else if (D->isArrayDesignator()) {
635      Record.push_back(serialization::DESIG_ARRAY);
636      Record.push_back(D->getFirstExprIndex());
637      Writer.AddSourceLocation(D->getLBracketLoc(), Record);
638      Writer.AddSourceLocation(D->getRBracketLoc(), Record);
639    } else {
640      assert(D->isArrayRangeDesignator() && "Unknown designator");
641      Record.push_back(serialization::DESIG_ARRAY_RANGE);
642      Record.push_back(D->getFirstExprIndex());
643      Writer.AddSourceLocation(D->getLBracketLoc(), Record);
644      Writer.AddSourceLocation(D->getEllipsisLoc(), Record);
645      Writer.AddSourceLocation(D->getRBracketLoc(), Record);
646    }
647  }
648  Code = serialization::EXPR_DESIGNATED_INIT;
649}
650
651void ASTStmtWriter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
652  VisitExpr(E);
653  Code = serialization::EXPR_IMPLICIT_VALUE_INIT;
654}
655
656void ASTStmtWriter::VisitVAArgExpr(VAArgExpr *E) {
657  VisitExpr(E);
658  Writer.AddStmt(E->getSubExpr());
659  Writer.AddTypeSourceInfo(E->getWrittenTypeInfo(), Record);
660  Writer.AddSourceLocation(E->getBuiltinLoc(), Record);
661  Writer.AddSourceLocation(E->getRParenLoc(), Record);
662  Code = serialization::EXPR_VA_ARG;
663}
664
665void ASTStmtWriter::VisitAddrLabelExpr(AddrLabelExpr *E) {
666  VisitExpr(E);
667  Writer.AddSourceLocation(E->getAmpAmpLoc(), Record);
668  Writer.AddSourceLocation(E->getLabelLoc(), Record);
669  Writer.AddDeclRef(E->getLabel(), Record);
670  Code = serialization::EXPR_ADDR_LABEL;
671}
672
673void ASTStmtWriter::VisitStmtExpr(StmtExpr *E) {
674  VisitExpr(E);
675  Writer.AddStmt(E->getSubStmt());
676  Writer.AddSourceLocation(E->getLParenLoc(), Record);
677  Writer.AddSourceLocation(E->getRParenLoc(), Record);
678  Code = serialization::EXPR_STMT;
679}
680
681void ASTStmtWriter::VisitChooseExpr(ChooseExpr *E) {
682  VisitExpr(E);
683  Writer.AddStmt(E->getCond());
684  Writer.AddStmt(E->getLHS());
685  Writer.AddStmt(E->getRHS());
686  Writer.AddSourceLocation(E->getBuiltinLoc(), Record);
687  Writer.AddSourceLocation(E->getRParenLoc(), Record);
688  Code = serialization::EXPR_CHOOSE;
689}
690
691void ASTStmtWriter::VisitGNUNullExpr(GNUNullExpr *E) {
692  VisitExpr(E);
693  Writer.AddSourceLocation(E->getTokenLocation(), Record);
694  Code = serialization::EXPR_GNU_NULL;
695}
696
697void ASTStmtWriter::VisitShuffleVectorExpr(ShuffleVectorExpr *E) {
698  VisitExpr(E);
699  Record.push_back(E->getNumSubExprs());
700  for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I)
701    Writer.AddStmt(E->getExpr(I));
702  Writer.AddSourceLocation(E->getBuiltinLoc(), Record);
703  Writer.AddSourceLocation(E->getRParenLoc(), Record);
704  Code = serialization::EXPR_SHUFFLE_VECTOR;
705}
706
707void ASTStmtWriter::VisitBlockExpr(BlockExpr *E) {
708  VisitExpr(E);
709  Writer.AddDeclRef(E->getBlockDecl(), Record);
710  Code = serialization::EXPR_BLOCK;
711}
712
713void ASTStmtWriter::VisitBlockDeclRefExpr(BlockDeclRefExpr *E) {
714  VisitExpr(E);
715  Writer.AddDeclRef(E->getDecl(), Record);
716  Writer.AddSourceLocation(E->getLocation(), Record);
717  Record.push_back(E->isByRef());
718  Record.push_back(E->isConstQualAdded());
719  Code = serialization::EXPR_BLOCK_DECL_REF;
720}
721
722void ASTStmtWriter::VisitGenericSelectionExpr(GenericSelectionExpr *E) {
723  VisitExpr(E);
724  Record.push_back(E->getNumAssocs());
725
726  Writer.AddStmt(E->getControllingExpr());
727  for (unsigned I = 0, N = E->getNumAssocs(); I != N; ++I) {
728    Writer.AddTypeSourceInfo(E->getAssocTypeSourceInfo(I), Record);
729    Writer.AddStmt(E->getAssocExpr(I));
730  }
731  Record.push_back(E->isResultDependent() ? -1U : E->getResultIndex());
732
733  Writer.AddSourceLocation(E->getGenericLoc(), Record);
734  Writer.AddSourceLocation(E->getDefaultLoc(), Record);
735  Writer.AddSourceLocation(E->getRParenLoc(), Record);
736  Code = serialization::EXPR_GENERIC_SELECTION;
737}
738
739void ASTStmtWriter::VisitPseudoObjectExpr(PseudoObjectExpr *E) {
740  VisitExpr(E);
741  Record.push_back(E->getNumSemanticExprs());
742
743  // Push the result index.  Currently, this needs to exactly match
744  // the encoding used internally for ResultIndex.
745  unsigned result = E->getResultExprIndex();
746  result = (result == PseudoObjectExpr::NoResult ? 0 : result + 1);
747  Record.push_back(result);
748
749  Writer.AddStmt(E->getSyntacticForm());
750  for (PseudoObjectExpr::semantics_iterator
751         i = E->semantics_begin(), e = E->semantics_end(); i != e; ++i) {
752    Writer.AddStmt(*i);
753    if (OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(*i))
754      Writer.AddStmt(OVE->getSourceExpr());
755  }
756}
757
758void ASTStmtWriter::VisitAtomicExpr(AtomicExpr *E) {
759  VisitExpr(E);
760  Record.push_back(E->getOp());
761  Writer.AddStmt(E->getPtr());
762  Writer.AddStmt(E->getOrder());
763  if (E->getOp() != AtomicExpr::Load)
764    Writer.AddStmt(E->getVal1());
765  if (E->isCmpXChg()) {
766    Writer.AddStmt(E->getOrderFail());
767    Writer.AddStmt(E->getVal2());
768  }
769  Writer.AddSourceLocation(E->getBuiltinLoc(), Record);
770  Writer.AddSourceLocation(E->getRParenLoc(), Record);
771}
772
773//===----------------------------------------------------------------------===//
774// Objective-C Expressions and Statements.
775//===----------------------------------------------------------------------===//
776
777void ASTStmtWriter::VisitObjCStringLiteral(ObjCStringLiteral *E) {
778  VisitExpr(E);
779  Writer.AddStmt(E->getString());
780  Writer.AddSourceLocation(E->getAtLoc(), Record);
781  Code = serialization::EXPR_OBJC_STRING_LITERAL;
782}
783
784void ASTStmtWriter::VisitObjCEncodeExpr(ObjCEncodeExpr *E) {
785  VisitExpr(E);
786  Writer.AddTypeSourceInfo(E->getEncodedTypeSourceInfo(), Record);
787  Writer.AddSourceLocation(E->getAtLoc(), Record);
788  Writer.AddSourceLocation(E->getRParenLoc(), Record);
789  Code = serialization::EXPR_OBJC_ENCODE;
790}
791
792void ASTStmtWriter::VisitObjCSelectorExpr(ObjCSelectorExpr *E) {
793  VisitExpr(E);
794  Writer.AddSelectorRef(E->getSelector(), Record);
795  Writer.AddSourceLocation(E->getAtLoc(), Record);
796  Writer.AddSourceLocation(E->getRParenLoc(), Record);
797  Code = serialization::EXPR_OBJC_SELECTOR_EXPR;
798}
799
800void ASTStmtWriter::VisitObjCProtocolExpr(ObjCProtocolExpr *E) {
801  VisitExpr(E);
802  Writer.AddDeclRef(E->getProtocol(), Record);
803  Writer.AddSourceLocation(E->getAtLoc(), Record);
804  Writer.AddSourceLocation(E->getRParenLoc(), Record);
805  Code = serialization::EXPR_OBJC_PROTOCOL_EXPR;
806}
807
808void ASTStmtWriter::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
809  VisitExpr(E);
810  Writer.AddDeclRef(E->getDecl(), Record);
811  Writer.AddSourceLocation(E->getLocation(), Record);
812  Writer.AddStmt(E->getBase());
813  Record.push_back(E->isArrow());
814  Record.push_back(E->isFreeIvar());
815  Code = serialization::EXPR_OBJC_IVAR_REF_EXPR;
816}
817
818void ASTStmtWriter::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
819  VisitExpr(E);
820  Record.push_back(E->isImplicitProperty());
821  if (E->isImplicitProperty()) {
822    Writer.AddDeclRef(E->getImplicitPropertyGetter(), Record);
823    Writer.AddDeclRef(E->getImplicitPropertySetter(), Record);
824  } else {
825    Writer.AddDeclRef(E->getExplicitProperty(), Record);
826  }
827  Writer.AddSourceLocation(E->getLocation(), Record);
828  Writer.AddSourceLocation(E->getReceiverLocation(), Record);
829  if (E->isObjectReceiver()) {
830    Record.push_back(0);
831    Writer.AddStmt(E->getBase());
832  } else if (E->isSuperReceiver()) {
833    Record.push_back(1);
834    Writer.AddTypeRef(E->getSuperReceiverType(), Record);
835  } else {
836    Record.push_back(2);
837    Writer.AddDeclRef(E->getClassReceiver(), Record);
838  }
839
840  Code = serialization::EXPR_OBJC_PROPERTY_REF_EXPR;
841}
842
843void ASTStmtWriter::VisitObjCMessageExpr(ObjCMessageExpr *E) {
844  VisitExpr(E);
845  Record.push_back(E->getNumArgs());
846  Record.push_back(E->getNumStoredSelLocs());
847  Record.push_back(E->SelLocsKind);
848  Record.push_back(E->isDelegateInitCall());
849  Record.push_back((unsigned)E->getReceiverKind()); // FIXME: stable encoding
850  switch (E->getReceiverKind()) {
851  case ObjCMessageExpr::Instance:
852    Writer.AddStmt(E->getInstanceReceiver());
853    break;
854
855  case ObjCMessageExpr::Class:
856    Writer.AddTypeSourceInfo(E->getClassReceiverTypeInfo(), Record);
857    break;
858
859  case ObjCMessageExpr::SuperClass:
860  case ObjCMessageExpr::SuperInstance:
861    Writer.AddTypeRef(E->getSuperType(), Record);
862    Writer.AddSourceLocation(E->getSuperLoc(), Record);
863    break;
864  }
865
866  if (E->getMethodDecl()) {
867    Record.push_back(1);
868    Writer.AddDeclRef(E->getMethodDecl(), Record);
869  } else {
870    Record.push_back(0);
871    Writer.AddSelectorRef(E->getSelector(), Record);
872  }
873
874  Writer.AddSourceLocation(E->getLeftLoc(), Record);
875  Writer.AddSourceLocation(E->getRightLoc(), Record);
876
877  for (CallExpr::arg_iterator Arg = E->arg_begin(), ArgEnd = E->arg_end();
878       Arg != ArgEnd; ++Arg)
879    Writer.AddStmt(*Arg);
880
881  SourceLocation *Locs = E->getStoredSelLocs();
882  for (unsigned i = 0, e = E->getNumStoredSelLocs(); i != e; ++i)
883    Writer.AddSourceLocation(Locs[i], Record);
884
885  Code = serialization::EXPR_OBJC_MESSAGE_EXPR;
886}
887
888void ASTStmtWriter::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
889  VisitStmt(S);
890  Writer.AddStmt(S->getElement());
891  Writer.AddStmt(S->getCollection());
892  Writer.AddStmt(S->getBody());
893  Writer.AddSourceLocation(S->getForLoc(), Record);
894  Writer.AddSourceLocation(S->getRParenLoc(), Record);
895  Code = serialization::STMT_OBJC_FOR_COLLECTION;
896}
897
898void ASTStmtWriter::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {
899  Writer.AddStmt(S->getCatchBody());
900  Writer.AddDeclRef(S->getCatchParamDecl(), Record);
901  Writer.AddSourceLocation(S->getAtCatchLoc(), Record);
902  Writer.AddSourceLocation(S->getRParenLoc(), Record);
903  Code = serialization::STMT_OBJC_CATCH;
904}
905
906void ASTStmtWriter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
907  Writer.AddStmt(S->getFinallyBody());
908  Writer.AddSourceLocation(S->getAtFinallyLoc(), Record);
909  Code = serialization::STMT_OBJC_FINALLY;
910}
911
912void ASTStmtWriter::VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S) {
913  Writer.AddStmt(S->getSubStmt());
914  Writer.AddSourceLocation(S->getAtLoc(), Record);
915  Code = serialization::STMT_OBJC_AUTORELEASE_POOL;
916}
917
918void ASTStmtWriter::VisitObjCAtTryStmt(ObjCAtTryStmt *S) {
919  Record.push_back(S->getNumCatchStmts());
920  Record.push_back(S->getFinallyStmt() != 0);
921  Writer.AddStmt(S->getTryBody());
922  for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I)
923    Writer.AddStmt(S->getCatchStmt(I));
924  if (S->getFinallyStmt())
925    Writer.AddStmt(S->getFinallyStmt());
926  Writer.AddSourceLocation(S->getAtTryLoc(), Record);
927  Code = serialization::STMT_OBJC_AT_TRY;
928}
929
930void ASTStmtWriter::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) {
931  Writer.AddStmt(S->getSynchExpr());
932  Writer.AddStmt(S->getSynchBody());
933  Writer.AddSourceLocation(S->getAtSynchronizedLoc(), Record);
934  Code = serialization::STMT_OBJC_AT_SYNCHRONIZED;
935}
936
937void ASTStmtWriter::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {
938  Writer.AddStmt(S->getThrowExpr());
939  Writer.AddSourceLocation(S->getThrowLoc(), Record);
940  Code = serialization::STMT_OBJC_AT_THROW;
941}
942
943//===----------------------------------------------------------------------===//
944// C++ Expressions and Statements.
945//===----------------------------------------------------------------------===//
946
947void ASTStmtWriter::VisitCXXCatchStmt(CXXCatchStmt *S) {
948  VisitStmt(S);
949  Writer.AddSourceLocation(S->getCatchLoc(), Record);
950  Writer.AddDeclRef(S->getExceptionDecl(), Record);
951  Writer.AddStmt(S->getHandlerBlock());
952  Code = serialization::STMT_CXX_CATCH;
953}
954
955void ASTStmtWriter::VisitCXXTryStmt(CXXTryStmt *S) {
956  VisitStmt(S);
957  Record.push_back(S->getNumHandlers());
958  Writer.AddSourceLocation(S->getTryLoc(), Record);
959  Writer.AddStmt(S->getTryBlock());
960  for (unsigned i = 0, e = S->getNumHandlers(); i != e; ++i)
961    Writer.AddStmt(S->getHandler(i));
962  Code = serialization::STMT_CXX_TRY;
963}
964
965void ASTStmtWriter::VisitCXXForRangeStmt(CXXForRangeStmt *S) {
966  VisitStmt(S);
967  Writer.AddSourceLocation(S->getForLoc(), Record);
968  Writer.AddSourceLocation(S->getColonLoc(), Record);
969  Writer.AddSourceLocation(S->getRParenLoc(), Record);
970  Writer.AddStmt(S->getRangeStmt());
971  Writer.AddStmt(S->getBeginEndStmt());
972  Writer.AddStmt(S->getCond());
973  Writer.AddStmt(S->getInc());
974  Writer.AddStmt(S->getLoopVarStmt());
975  Writer.AddStmt(S->getBody());
976  Code = serialization::STMT_CXX_FOR_RANGE;
977}
978
979void ASTStmtWriter::VisitMSDependentExistsStmt(MSDependentExistsStmt *S) {
980  VisitStmt(S);
981  Writer.AddSourceLocation(S->getKeywordLoc(), Record);
982  Record.push_back(S->isIfExists());
983  Writer.AddNestedNameSpecifierLoc(S->getQualifierLoc(), Record);
984  Writer.AddDeclarationNameInfo(S->getNameInfo(), Record);
985  Writer.AddStmt(S->getSubStmt());
986  Code = serialization::STMT_MS_DEPENDENT_EXISTS;
987}
988
989void ASTStmtWriter::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
990  VisitCallExpr(E);
991  Record.push_back(E->getOperator());
992  Code = serialization::EXPR_CXX_OPERATOR_CALL;
993}
994
995void ASTStmtWriter::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
996  VisitCallExpr(E);
997  Code = serialization::EXPR_CXX_MEMBER_CALL;
998}
999
1000void ASTStmtWriter::VisitCXXConstructExpr(CXXConstructExpr *E) {
1001  VisitExpr(E);
1002  Record.push_back(E->getNumArgs());
1003  for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
1004    Writer.AddStmt(E->getArg(I));
1005  Writer.AddDeclRef(E->getConstructor(), Record);
1006  Writer.AddSourceLocation(E->getLocation(), Record);
1007  Record.push_back(E->isElidable());
1008  Record.push_back(E->hadMultipleCandidates());
1009  Record.push_back(E->requiresZeroInitialization());
1010  Record.push_back(E->getConstructionKind()); // FIXME: stable encoding
1011  Writer.AddSourceRange(E->getParenRange(), Record);
1012  Code = serialization::EXPR_CXX_CONSTRUCT;
1013}
1014
1015void ASTStmtWriter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) {
1016  VisitCXXConstructExpr(E);
1017  Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record);
1018  Code = serialization::EXPR_CXX_TEMPORARY_OBJECT;
1019}
1020
1021void ASTStmtWriter::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
1022  VisitExplicitCastExpr(E);
1023  Writer.AddSourceRange(SourceRange(E->getOperatorLoc(), E->getRParenLoc()),
1024                        Record);
1025}
1026
1027void ASTStmtWriter::VisitCXXStaticCastExpr(CXXStaticCastExpr *E) {
1028  VisitCXXNamedCastExpr(E);
1029  Code = serialization::EXPR_CXX_STATIC_CAST;
1030}
1031
1032void ASTStmtWriter::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E) {
1033  VisitCXXNamedCastExpr(E);
1034  Code = serialization::EXPR_CXX_DYNAMIC_CAST;
1035}
1036
1037void ASTStmtWriter::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E) {
1038  VisitCXXNamedCastExpr(E);
1039  Code = serialization::EXPR_CXX_REINTERPRET_CAST;
1040}
1041
1042void ASTStmtWriter::VisitCXXConstCastExpr(CXXConstCastExpr *E) {
1043  VisitCXXNamedCastExpr(E);
1044  Code = serialization::EXPR_CXX_CONST_CAST;
1045}
1046
1047void ASTStmtWriter::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) {
1048  VisitExplicitCastExpr(E);
1049  Writer.AddSourceLocation(E->getTypeBeginLoc(), Record);
1050  Writer.AddSourceLocation(E->getRParenLoc(), Record);
1051  Code = serialization::EXPR_CXX_FUNCTIONAL_CAST;
1052}
1053
1054void ASTStmtWriter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
1055  VisitExpr(E);
1056  Record.push_back(E->getValue());
1057  Writer.AddSourceLocation(E->getLocation(), Record);
1058  Code = serialization::EXPR_CXX_BOOL_LITERAL;
1059}
1060
1061void ASTStmtWriter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {
1062  VisitExpr(E);
1063  Writer.AddSourceLocation(E->getLocation(), Record);
1064  Code = serialization::EXPR_CXX_NULL_PTR_LITERAL;
1065}
1066
1067void ASTStmtWriter::VisitCXXTypeidExpr(CXXTypeidExpr *E) {
1068  VisitExpr(E);
1069  Writer.AddSourceRange(E->getSourceRange(), Record);
1070  if (E->isTypeOperand()) {
1071    Writer.AddTypeSourceInfo(E->getTypeOperandSourceInfo(), Record);
1072    Code = serialization::EXPR_CXX_TYPEID_TYPE;
1073  } else {
1074    Writer.AddStmt(E->getExprOperand());
1075    Code = serialization::EXPR_CXX_TYPEID_EXPR;
1076  }
1077}
1078
1079void ASTStmtWriter::VisitCXXThisExpr(CXXThisExpr *E) {
1080  VisitExpr(E);
1081  Writer.AddSourceLocation(E->getLocation(), Record);
1082  Record.push_back(E->isImplicit());
1083  Code = serialization::EXPR_CXX_THIS;
1084}
1085
1086void ASTStmtWriter::VisitCXXThrowExpr(CXXThrowExpr *E) {
1087  VisitExpr(E);
1088  Writer.AddSourceLocation(E->getThrowLoc(), Record);
1089  Writer.AddStmt(E->getSubExpr());
1090  Record.push_back(E->isThrownVariableInScope());
1091  Code = serialization::EXPR_CXX_THROW;
1092}
1093
1094void ASTStmtWriter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
1095  VisitExpr(E);
1096
1097  bool HasOtherExprStored = E->Param.getInt();
1098  // Store these first, the reader reads them before creation.
1099  Record.push_back(HasOtherExprStored);
1100  if (HasOtherExprStored)
1101    Writer.AddStmt(E->getExpr());
1102  Writer.AddDeclRef(E->getParam(), Record);
1103  Writer.AddSourceLocation(E->getUsedLocation(), Record);
1104
1105  Code = serialization::EXPR_CXX_DEFAULT_ARG;
1106}
1107
1108void ASTStmtWriter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
1109  VisitExpr(E);
1110  Writer.AddCXXTemporary(E->getTemporary(), Record);
1111  Writer.AddStmt(E->getSubExpr());
1112  Code = serialization::EXPR_CXX_BIND_TEMPORARY;
1113}
1114
1115void ASTStmtWriter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
1116  VisitExpr(E);
1117  Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record);
1118  Writer.AddSourceLocation(E->getRParenLoc(), Record);
1119  Code = serialization::EXPR_CXX_SCALAR_VALUE_INIT;
1120}
1121
1122void ASTStmtWriter::VisitCXXNewExpr(CXXNewExpr *E) {
1123  VisitExpr(E);
1124  Record.push_back(E->isGlobalNew());
1125  Record.push_back(E->hasInitializer());
1126  Record.push_back(E->doesUsualArrayDeleteWantSize());
1127  Record.push_back(E->isArray());
1128  Record.push_back(E->hadMultipleCandidates());
1129  Record.push_back(E->getNumPlacementArgs());
1130  Record.push_back(E->getNumConstructorArgs());
1131  Writer.AddDeclRef(E->getOperatorNew(), Record);
1132  Writer.AddDeclRef(E->getOperatorDelete(), Record);
1133  Writer.AddDeclRef(E->getConstructor(), Record);
1134  Writer.AddTypeSourceInfo(E->getAllocatedTypeSourceInfo(), Record);
1135  Writer.AddSourceRange(E->getTypeIdParens(), Record);
1136  Writer.AddSourceLocation(E->getStartLoc(), Record);
1137  Writer.AddSourceLocation(E->getEndLoc(), Record);
1138  Writer.AddSourceLocation(E->getConstructorLParen(), Record);
1139  Writer.AddSourceLocation(E->getConstructorRParen(), Record);
1140  for (CXXNewExpr::arg_iterator I = E->raw_arg_begin(), e = E->raw_arg_end();
1141       I != e; ++I)
1142    Writer.AddStmt(*I);
1143
1144  Code = serialization::EXPR_CXX_NEW;
1145}
1146
1147void ASTStmtWriter::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
1148  VisitExpr(E);
1149  Record.push_back(E->isGlobalDelete());
1150  Record.push_back(E->isArrayForm());
1151  Record.push_back(E->isArrayFormAsWritten());
1152  Record.push_back(E->doesUsualArrayDeleteWantSize());
1153  Writer.AddDeclRef(E->getOperatorDelete(), Record);
1154  Writer.AddStmt(E->getArgument());
1155  Writer.AddSourceLocation(E->getSourceRange().getBegin(), Record);
1156
1157  Code = serialization::EXPR_CXX_DELETE;
1158}
1159
1160void ASTStmtWriter::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) {
1161  VisitExpr(E);
1162
1163  Writer.AddStmt(E->getBase());
1164  Record.push_back(E->isArrow());
1165  Writer.AddSourceLocation(E->getOperatorLoc(), Record);
1166  Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record);
1167  Writer.AddTypeSourceInfo(E->getScopeTypeInfo(), Record);
1168  Writer.AddSourceLocation(E->getColonColonLoc(), Record);
1169  Writer.AddSourceLocation(E->getTildeLoc(), Record);
1170
1171  // PseudoDestructorTypeStorage.
1172  Writer.AddIdentifierRef(E->getDestroyedTypeIdentifier(), Record);
1173  if (E->getDestroyedTypeIdentifier())
1174    Writer.AddSourceLocation(E->getDestroyedTypeLoc(), Record);
1175  else
1176    Writer.AddTypeSourceInfo(E->getDestroyedTypeInfo(), Record);
1177
1178  Code = serialization::EXPR_CXX_PSEUDO_DESTRUCTOR;
1179}
1180
1181void ASTStmtWriter::VisitExprWithCleanups(ExprWithCleanups *E) {
1182  VisitExpr(E);
1183  Record.push_back(E->getNumTemporaries());
1184  for (unsigned i = 0, e = E->getNumTemporaries(); i != e; ++i)
1185    Writer.AddCXXTemporary(E->getTemporary(i), Record);
1186
1187  Writer.AddStmt(E->getSubExpr());
1188  Code = serialization::EXPR_EXPR_WITH_CLEANUPS;
1189}
1190
1191void
1192ASTStmtWriter::VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E){
1193  VisitExpr(E);
1194
1195  // Don't emit anything here, hasExplicitTemplateArgs() must be
1196  // emitted first.
1197
1198  Record.push_back(E->hasExplicitTemplateArgs());
1199  if (E->hasExplicitTemplateArgs()) {
1200    const ASTTemplateArgumentListInfo &Args = E->getExplicitTemplateArgs();
1201    Record.push_back(Args.NumTemplateArgs);
1202    AddExplicitTemplateArgumentList(Args);
1203  }
1204
1205  if (!E->isImplicitAccess())
1206    Writer.AddStmt(E->getBase());
1207  else
1208    Writer.AddStmt(0);
1209  Writer.AddTypeRef(E->getBaseType(), Record);
1210  Record.push_back(E->isArrow());
1211  Writer.AddSourceLocation(E->getOperatorLoc(), Record);
1212  Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record);
1213  Writer.AddDeclRef(E->getFirstQualifierFoundInScope(), Record);
1214  Writer.AddDeclarationNameInfo(E->MemberNameInfo, Record);
1215  Code = serialization::EXPR_CXX_DEPENDENT_SCOPE_MEMBER;
1216}
1217
1218void
1219ASTStmtWriter::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
1220  VisitExpr(E);
1221
1222  // Don't emit anything here, hasExplicitTemplateArgs() must be
1223  // emitted first.
1224  Record.push_back(E->hasExplicitTemplateArgs());
1225  if (E->hasExplicitTemplateArgs()) {
1226    const ASTTemplateArgumentListInfo &Args = E->getExplicitTemplateArgs();
1227    Record.push_back(Args.NumTemplateArgs);
1228    AddExplicitTemplateArgumentList(Args);
1229  }
1230
1231  Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record);
1232  Writer.AddDeclarationNameInfo(E->NameInfo, Record);
1233  Code = serialization::EXPR_CXX_DEPENDENT_SCOPE_DECL_REF;
1234}
1235
1236void
1237ASTStmtWriter::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) {
1238  VisitExpr(E);
1239  Record.push_back(E->arg_size());
1240  for (CXXUnresolvedConstructExpr::arg_iterator
1241         ArgI = E->arg_begin(), ArgE = E->arg_end(); ArgI != ArgE; ++ArgI)
1242    Writer.AddStmt(*ArgI);
1243  Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record);
1244  Writer.AddSourceLocation(E->getLParenLoc(), Record);
1245  Writer.AddSourceLocation(E->getRParenLoc(), Record);
1246  Code = serialization::EXPR_CXX_UNRESOLVED_CONSTRUCT;
1247}
1248
1249void ASTStmtWriter::VisitOverloadExpr(OverloadExpr *E) {
1250  VisitExpr(E);
1251
1252  // Don't emit anything here, hasExplicitTemplateArgs() must be emitted first.
1253  Record.push_back(E->hasExplicitTemplateArgs());
1254  if (E->hasExplicitTemplateArgs()) {
1255    const ASTTemplateArgumentListInfo &Args = E->getExplicitTemplateArgs();
1256    Record.push_back(Args.NumTemplateArgs);
1257    AddExplicitTemplateArgumentList(Args);
1258  }
1259
1260  Record.push_back(E->getNumDecls());
1261  for (OverloadExpr::decls_iterator
1262         OvI = E->decls_begin(), OvE = E->decls_end(); OvI != OvE; ++OvI) {
1263    Writer.AddDeclRef(OvI.getDecl(), Record);
1264    Record.push_back(OvI.getAccess());
1265  }
1266
1267  Writer.AddDeclarationNameInfo(E->NameInfo, Record);
1268  Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record);
1269}
1270
1271void ASTStmtWriter::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) {
1272  VisitOverloadExpr(E);
1273  Record.push_back(E->isArrow());
1274  Record.push_back(E->hasUnresolvedUsing());
1275  Writer.AddStmt(!E->isImplicitAccess() ? E->getBase() : 0);
1276  Writer.AddTypeRef(E->getBaseType(), Record);
1277  Writer.AddSourceLocation(E->getOperatorLoc(), Record);
1278  Code = serialization::EXPR_CXX_UNRESOLVED_MEMBER;
1279}
1280
1281void ASTStmtWriter::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
1282  VisitOverloadExpr(E);
1283  Record.push_back(E->requiresADL());
1284  if (E->requiresADL())
1285    Record.push_back(E->isStdAssociatedNamespace());
1286  Record.push_back(E->isOverloaded());
1287  Writer.AddDeclRef(E->getNamingClass(), Record);
1288  Code = serialization::EXPR_CXX_UNRESOLVED_LOOKUP;
1289}
1290
1291void ASTStmtWriter::VisitUnaryTypeTraitExpr(UnaryTypeTraitExpr *E) {
1292  VisitExpr(E);
1293  Record.push_back(E->getTrait());
1294  Record.push_back(E->getValue());
1295  Writer.AddSourceRange(E->getSourceRange(), Record);
1296  Writer.AddTypeSourceInfo(E->getQueriedTypeSourceInfo(), Record);
1297  Code = serialization::EXPR_CXX_UNARY_TYPE_TRAIT;
1298}
1299
1300void ASTStmtWriter::VisitBinaryTypeTraitExpr(BinaryTypeTraitExpr *E) {
1301  VisitExpr(E);
1302  Record.push_back(E->getTrait());
1303  Record.push_back(E->getValue());
1304  Writer.AddSourceRange(E->getSourceRange(), Record);
1305  Writer.AddTypeSourceInfo(E->getLhsTypeSourceInfo(), Record);
1306  Writer.AddTypeSourceInfo(E->getRhsTypeSourceInfo(), Record);
1307  Code = serialization::EXPR_BINARY_TYPE_TRAIT;
1308}
1309
1310void ASTStmtWriter::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
1311  VisitExpr(E);
1312  Record.push_back(E->getTrait());
1313  Record.push_back(E->getValue());
1314  Writer.AddSourceRange(E->getSourceRange(), Record);
1315  Writer.AddTypeSourceInfo(E->getQueriedTypeSourceInfo(), Record);
1316  Code = serialization::EXPR_ARRAY_TYPE_TRAIT;
1317}
1318
1319void ASTStmtWriter::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
1320  VisitExpr(E);
1321  Record.push_back(E->getTrait());
1322  Record.push_back(E->getValue());
1323  Writer.AddSourceRange(E->getSourceRange(), Record);
1324  Writer.AddStmt(E->getQueriedExpression());
1325  Code = serialization::EXPR_CXX_EXPRESSION_TRAIT;
1326}
1327
1328void ASTStmtWriter::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
1329  VisitExpr(E);
1330  Record.push_back(E->getValue());
1331  Writer.AddSourceRange(E->getSourceRange(), Record);
1332  Writer.AddStmt(E->getOperand());
1333  Code = serialization::EXPR_CXX_NOEXCEPT;
1334}
1335
1336void ASTStmtWriter::VisitPackExpansionExpr(PackExpansionExpr *E) {
1337  VisitExpr(E);
1338  Writer.AddSourceLocation(E->getEllipsisLoc(), Record);
1339  Record.push_back(E->NumExpansions);
1340  Writer.AddStmt(E->getPattern());
1341  Code = serialization::EXPR_PACK_EXPANSION;
1342}
1343
1344void ASTStmtWriter::VisitSizeOfPackExpr(SizeOfPackExpr *E) {
1345  VisitExpr(E);
1346  Writer.AddSourceLocation(E->OperatorLoc, Record);
1347  Writer.AddSourceLocation(E->PackLoc, Record);
1348  Writer.AddSourceLocation(E->RParenLoc, Record);
1349  Record.push_back(E->Length);
1350  Writer.AddDeclRef(E->Pack, Record);
1351  Code = serialization::EXPR_SIZEOF_PACK;
1352}
1353
1354void ASTStmtWriter::VisitSubstNonTypeTemplateParmExpr(
1355                                              SubstNonTypeTemplateParmExpr *E) {
1356  VisitExpr(E);
1357  Writer.AddDeclRef(E->getParameter(), Record);
1358  Writer.AddSourceLocation(E->getNameLoc(), Record);
1359  Writer.AddStmt(E->getReplacement());
1360  Code = serialization::EXPR_SUBST_NON_TYPE_TEMPLATE_PARM;
1361}
1362
1363void ASTStmtWriter::VisitSubstNonTypeTemplateParmPackExpr(
1364                                          SubstNonTypeTemplateParmPackExpr *E) {
1365  VisitExpr(E);
1366  Writer.AddDeclRef(E->getParameterPack(), Record);
1367  Writer.AddTemplateArgument(E->getArgumentPack(), Record);
1368  Writer.AddSourceLocation(E->getParameterPackLocation(), Record);
1369  Code = serialization::EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK;
1370}
1371
1372void ASTStmtWriter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
1373  VisitExpr(E);
1374  Writer.AddStmt(E->Temporary);
1375  Code = serialization::EXPR_MATERIALIZE_TEMPORARY;
1376}
1377
1378void ASTStmtWriter::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
1379  VisitExpr(E);
1380  Record.push_back(Writer.getOpaqueValueID(E));
1381  Writer.AddSourceLocation(E->getLocation(), Record);
1382  Code = serialization::EXPR_OPAQUE_VALUE;
1383}
1384
1385//===----------------------------------------------------------------------===//
1386// CUDA Expressions and Statements.
1387//===----------------------------------------------------------------------===//
1388
1389void ASTStmtWriter::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *E) {
1390  VisitCallExpr(E);
1391  Writer.AddStmt(E->getConfig());
1392  Code = serialization::EXPR_CUDA_KERNEL_CALL;
1393}
1394
1395//===----------------------------------------------------------------------===//
1396// OpenCL Expressions and Statements.
1397//===----------------------------------------------------------------------===//
1398void ASTStmtWriter::VisitAsTypeExpr(AsTypeExpr *E) {
1399  VisitExpr(E);
1400  Writer.AddSourceLocation(E->getBuiltinLoc(), Record);
1401  Writer.AddSourceLocation(E->getRParenLoc(), Record);
1402  Writer.AddStmt(E->getSrcExpr());
1403  Code = serialization::EXPR_ASTYPE;
1404}
1405
1406//===----------------------------------------------------------------------===//
1407// Microsoft Expressions and Statements.
1408//===----------------------------------------------------------------------===//
1409void ASTStmtWriter::VisitCXXUuidofExpr(CXXUuidofExpr *E) {
1410  VisitExpr(E);
1411  Writer.AddSourceRange(E->getSourceRange(), Record);
1412  if (E->isTypeOperand()) {
1413    Writer.AddTypeSourceInfo(E->getTypeOperandSourceInfo(), Record);
1414    Code = serialization::EXPR_CXX_UUIDOF_TYPE;
1415  } else {
1416    Writer.AddStmt(E->getExprOperand());
1417    Code = serialization::EXPR_CXX_UUIDOF_EXPR;
1418  }
1419}
1420
1421void ASTStmtWriter::VisitSEHExceptStmt(SEHExceptStmt *S) {
1422  VisitStmt(S);
1423  Writer.AddSourceLocation(S->getExceptLoc(), Record);
1424  Writer.AddStmt(S->getFilterExpr());
1425  Writer.AddStmt(S->getBlock());
1426  Code = serialization::STMT_SEH_EXCEPT;
1427}
1428
1429void ASTStmtWriter::VisitSEHFinallyStmt(SEHFinallyStmt *S) {
1430  VisitStmt(S);
1431  Writer.AddSourceLocation(S->getFinallyLoc(), Record);
1432  Writer.AddStmt(S->getBlock());
1433  Code = serialization::STMT_SEH_FINALLY;
1434}
1435
1436void ASTStmtWriter::VisitSEHTryStmt(SEHTryStmt *S) {
1437  VisitStmt(S);
1438  Record.push_back(S->getIsCXXTry());
1439  Writer.AddSourceLocation(S->getTryLoc(), Record);
1440  Writer.AddStmt(S->getTryBlock());
1441  Writer.AddStmt(S->getHandler());
1442  Code = serialization::STMT_SEH_TRY;
1443}
1444
1445//===----------------------------------------------------------------------===//
1446// ASTWriter Implementation
1447//===----------------------------------------------------------------------===//
1448
1449unsigned ASTWriter::RecordSwitchCaseID(SwitchCase *S) {
1450  assert(SwitchCaseIDs.find(S) == SwitchCaseIDs.end() &&
1451         "SwitchCase recorded twice");
1452  unsigned NextID = SwitchCaseIDs.size();
1453  SwitchCaseIDs[S] = NextID;
1454  return NextID;
1455}
1456
1457unsigned ASTWriter::getSwitchCaseID(SwitchCase *S) {
1458  assert(SwitchCaseIDs.find(S) != SwitchCaseIDs.end() &&
1459         "SwitchCase hasn't been seen yet");
1460  return SwitchCaseIDs[S];
1461}
1462
1463void ASTWriter::ClearSwitchCaseIDs() {
1464  SwitchCaseIDs.clear();
1465}
1466
1467unsigned ASTWriter::getOpaqueValueID(OpaqueValueExpr *e) {
1468  unsigned &entry = OpaqueValues[e];
1469  if (!entry) entry = OpaqueValues.size();
1470  return entry;
1471}
1472
1473/// \brief Write the given substatement or subexpression to the
1474/// bitstream.
1475void ASTWriter::WriteSubStmt(Stmt *S,
1476                             llvm::DenseMap<Stmt *, uint64_t> &SubStmtEntries,
1477                             llvm::DenseSet<Stmt *> &ParentStmts) {
1478  RecordData Record;
1479  ASTStmtWriter Writer(*this, Record);
1480  ++NumStatements;
1481
1482  if (!S) {
1483    Stream.EmitRecord(serialization::STMT_NULL_PTR, Record);
1484    return;
1485  }
1486
1487  llvm::DenseMap<Stmt *, uint64_t>::iterator I = SubStmtEntries.find(S);
1488  if (I != SubStmtEntries.end()) {
1489    Record.push_back(I->second);
1490    Stream.EmitRecord(serialization::STMT_REF_PTR, Record);
1491    return;
1492  }
1493
1494#ifndef NDEBUG
1495  assert(!ParentStmts.count(S) && "There is a Stmt cycle!");
1496
1497  struct ParentStmtInserterRAII {
1498    Stmt *S;
1499    llvm::DenseSet<Stmt *> &ParentStmts;
1500
1501    ParentStmtInserterRAII(Stmt *S, llvm::DenseSet<Stmt *> &ParentStmts)
1502      : S(S), ParentStmts(ParentStmts) {
1503      ParentStmts.insert(S);
1504    }
1505    ~ParentStmtInserterRAII() {
1506      ParentStmts.erase(S);
1507    }
1508  };
1509
1510  ParentStmtInserterRAII ParentStmtInserter(S, ParentStmts);
1511#endif
1512
1513  // Redirect ASTWriter::AddStmt to collect sub stmts.
1514  SmallVector<Stmt *, 16> SubStmts;
1515  CollectedStmts = &SubStmts;
1516
1517  Writer.Code = serialization::STMT_NULL_PTR;
1518  Writer.AbbrevToUse = 0;
1519  Writer.Visit(S);
1520
1521#ifndef NDEBUG
1522  if (Writer.Code == serialization::STMT_NULL_PTR) {
1523    SourceManager &SrcMgr
1524      = DeclIDs.begin()->first->getASTContext().getSourceManager();
1525    S->dump(SrcMgr);
1526    llvm_unreachable("Unhandled sub statement writing AST file");
1527  }
1528#endif
1529
1530  // Revert ASTWriter::AddStmt.
1531  CollectedStmts = &StmtsToEmit;
1532
1533  // Write the sub stmts in reverse order, last to first. When reading them back
1534  // we will read them in correct order by "pop"ing them from the Stmts stack.
1535  // This simplifies reading and allows to store a variable number of sub stmts
1536  // without knowing it in advance.
1537  while (!SubStmts.empty())
1538    WriteSubStmt(SubStmts.pop_back_val(), SubStmtEntries, ParentStmts);
1539
1540  Stream.EmitRecord(Writer.Code, Record, Writer.AbbrevToUse);
1541
1542  SubStmtEntries[S] = Stream.GetCurrentBitNo();
1543}
1544
1545/// \brief Flush all of the statements that have been added to the
1546/// queue via AddStmt().
1547void ASTWriter::FlushStmts() {
1548  RecordData Record;
1549
1550  /// \brief Set of parent Stmts for the currently serializing sub stmt.
1551  llvm::DenseSet<Stmt *> ParentStmts;
1552  /// \brief Offsets of sub stmts already serialized. The offset points
1553  /// just after the stmt record.
1554  llvm::DenseMap<Stmt *, uint64_t> SubStmtEntries;
1555
1556  for (unsigned I = 0, N = StmtsToEmit.size(); I != N; ++I) {
1557    WriteSubStmt(StmtsToEmit[I], SubStmtEntries, ParentStmts);
1558
1559    assert(N == StmtsToEmit.size() &&
1560           "Substatement written via AddStmt rather than WriteSubStmt!");
1561
1562    // Note that we are at the end of a full expression. Any
1563    // expression records that follow this one are part of a different
1564    // expression.
1565    Stream.EmitRecord(serialization::STMT_STOP, Record);
1566
1567    SubStmtEntries.clear();
1568    ParentStmts.clear();
1569  }
1570
1571  StmtsToEmit.clear();
1572}
1573