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