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