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 /// \file
11 /// \brief Implements serialization for Statements and Expressions.
12 ///
13 //===----------------------------------------------------------------------===//
14 
15 #include "clang/Serialization/ASTWriter.h"
16 #include "clang/AST/ASTContext.h"
17 #include "clang/AST/DeclCXX.h"
18 #include "clang/AST/DeclObjC.h"
19 #include "clang/AST/DeclTemplate.h"
20 #include "clang/AST/StmtVisitor.h"
21 #include "clang/Lex/Token.h"
22 #include "llvm/Bitcode/BitstreamWriter.h"
23 using namespace clang;
24 
25 //===----------------------------------------------------------------------===//
26 // Statement/expression serialization
27 //===----------------------------------------------------------------------===//
28 
29 namespace clang {
30 
31   class ASTStmtWriter : public StmtVisitor<ASTStmtWriter, void> {
32     friend class OMPClauseWriter;
33     ASTWriter &Writer;
34     ASTWriter::RecordData &Record;
35 
36   public:
37     serialization::StmtCode Code;
38     unsigned AbbrevToUse;
39 
40     ASTStmtWriter(ASTWriter &Writer, ASTWriter::RecordData &Record)
41       : Writer(Writer), Record(Record) { }
42 
43     void AddTemplateKWAndArgsInfo(const ASTTemplateKWAndArgsInfo &ArgInfo,
44                                   const TemplateArgumentLoc *Args);
45 
46     void VisitStmt(Stmt *S);
47 #define STMT(Type, Base) \
48     void Visit##Type(Type *);
49 #include "clang/AST/StmtNodes.inc"
50   };
51 }
52 
53 void ASTStmtWriter::AddTemplateKWAndArgsInfo(
54     const ASTTemplateKWAndArgsInfo &ArgInfo, const TemplateArgumentLoc *Args) {
55   Writer.AddSourceLocation(ArgInfo.TemplateKWLoc, Record);
56   Writer.AddSourceLocation(ArgInfo.LAngleLoc, Record);
57   Writer.AddSourceLocation(ArgInfo.RAngleLoc, Record);
58   for (unsigned i = 0; i != ArgInfo.NumTemplateArgs; ++i)
59     Writer.AddTemplateArgumentLoc(Args[i], Record);
60 }
61 
62 void ASTStmtWriter::VisitStmt(Stmt *S) {
63 }
64 
65 void ASTStmtWriter::VisitNullStmt(NullStmt *S) {
66   VisitStmt(S);
67   Writer.AddSourceLocation(S->getSemiLoc(), Record);
68   Record.push_back(S->HasLeadingEmptyMacro);
69   Code = serialization::STMT_NULL;
70 }
71 
72 void ASTStmtWriter::VisitCompoundStmt(CompoundStmt *S) {
73   VisitStmt(S);
74   Record.push_back(S->size());
75   for (auto *CS : S->body())
76     Writer.AddStmt(CS);
77   Writer.AddSourceLocation(S->getLBracLoc(), Record);
78   Writer.AddSourceLocation(S->getRBracLoc(), Record);
79   Code = serialization::STMT_COMPOUND;
80 }
81 
82 void ASTStmtWriter::VisitSwitchCase(SwitchCase *S) {
83   VisitStmt(S);
84   Record.push_back(Writer.getSwitchCaseID(S));
85   Writer.AddSourceLocation(S->getKeywordLoc(), Record);
86   Writer.AddSourceLocation(S->getColonLoc(), Record);
87 }
88 
89 void ASTStmtWriter::VisitCaseStmt(CaseStmt *S) {
90   VisitSwitchCase(S);
91   Writer.AddStmt(S->getLHS());
92   Writer.AddStmt(S->getRHS());
93   Writer.AddStmt(S->getSubStmt());
94   Writer.AddSourceLocation(S->getEllipsisLoc(), Record);
95   Code = serialization::STMT_CASE;
96 }
97 
98 void ASTStmtWriter::VisitDefaultStmt(DefaultStmt *S) {
99   VisitSwitchCase(S);
100   Writer.AddStmt(S->getSubStmt());
101   Code = serialization::STMT_DEFAULT;
102 }
103 
104 void ASTStmtWriter::VisitLabelStmt(LabelStmt *S) {
105   VisitStmt(S);
106   Writer.AddDeclRef(S->getDecl(), Record);
107   Writer.AddStmt(S->getSubStmt());
108   Writer.AddSourceLocation(S->getIdentLoc(), Record);
109   Code = serialization::STMT_LABEL;
110 }
111 
112 void ASTStmtWriter::VisitAttributedStmt(AttributedStmt *S) {
113   VisitStmt(S);
114   Record.push_back(S->getAttrs().size());
115   Writer.WriteAttributes(S->getAttrs(), Record);
116   Writer.AddStmt(S->getSubStmt());
117   Writer.AddSourceLocation(S->getAttrLoc(), Record);
118   Code = serialization::STMT_ATTRIBUTED;
119 }
120 
121 void ASTStmtWriter::VisitIfStmt(IfStmt *S) {
122   VisitStmt(S);
123   Writer.AddDeclRef(S->getConditionVariable(), Record);
124   Writer.AddStmt(S->getCond());
125   Writer.AddStmt(S->getThen());
126   Writer.AddStmt(S->getElse());
127   Writer.AddSourceLocation(S->getIfLoc(), Record);
128   Writer.AddSourceLocation(S->getElseLoc(), Record);
129   Code = serialization::STMT_IF;
130 }
131 
132 void ASTStmtWriter::VisitSwitchStmt(SwitchStmt *S) {
133   VisitStmt(S);
134   Writer.AddDeclRef(S->getConditionVariable(), Record);
135   Writer.AddStmt(S->getCond());
136   Writer.AddStmt(S->getBody());
137   Writer.AddSourceLocation(S->getSwitchLoc(), Record);
138   Record.push_back(S->isAllEnumCasesCovered());
139   for (SwitchCase *SC = S->getSwitchCaseList(); SC;
140        SC = SC->getNextSwitchCase())
141     Record.push_back(Writer.RecordSwitchCaseID(SC));
142   Code = serialization::STMT_SWITCH;
143 }
144 
145 void ASTStmtWriter::VisitWhileStmt(WhileStmt *S) {
146   VisitStmt(S);
147   Writer.AddDeclRef(S->getConditionVariable(), Record);
148   Writer.AddStmt(S->getCond());
149   Writer.AddStmt(S->getBody());
150   Writer.AddSourceLocation(S->getWhileLoc(), Record);
151   Code = serialization::STMT_WHILE;
152 }
153 
154 void ASTStmtWriter::VisitDoStmt(DoStmt *S) {
155   VisitStmt(S);
156   Writer.AddStmt(S->getCond());
157   Writer.AddStmt(S->getBody());
158   Writer.AddSourceLocation(S->getDoLoc(), Record);
159   Writer.AddSourceLocation(S->getWhileLoc(), Record);
160   Writer.AddSourceLocation(S->getRParenLoc(), Record);
161   Code = serialization::STMT_DO;
162 }
163 
164 void ASTStmtWriter::VisitForStmt(ForStmt *S) {
165   VisitStmt(S);
166   Writer.AddStmt(S->getInit());
167   Writer.AddStmt(S->getCond());
168   Writer.AddDeclRef(S->getConditionVariable(), Record);
169   Writer.AddStmt(S->getInc());
170   Writer.AddStmt(S->getBody());
171   Writer.AddSourceLocation(S->getForLoc(), Record);
172   Writer.AddSourceLocation(S->getLParenLoc(), Record);
173   Writer.AddSourceLocation(S->getRParenLoc(), Record);
174   Code = serialization::STMT_FOR;
175 }
176 
177 void ASTStmtWriter::VisitGotoStmt(GotoStmt *S) {
178   VisitStmt(S);
179   Writer.AddDeclRef(S->getLabel(), Record);
180   Writer.AddSourceLocation(S->getGotoLoc(), Record);
181   Writer.AddSourceLocation(S->getLabelLoc(), Record);
182   Code = serialization::STMT_GOTO;
183 }
184 
185 void ASTStmtWriter::VisitIndirectGotoStmt(IndirectGotoStmt *S) {
186   VisitStmt(S);
187   Writer.AddSourceLocation(S->getGotoLoc(), Record);
188   Writer.AddSourceLocation(S->getStarLoc(), Record);
189   Writer.AddStmt(S->getTarget());
190   Code = serialization::STMT_INDIRECT_GOTO;
191 }
192 
193 void ASTStmtWriter::VisitContinueStmt(ContinueStmt *S) {
194   VisitStmt(S);
195   Writer.AddSourceLocation(S->getContinueLoc(), Record);
196   Code = serialization::STMT_CONTINUE;
197 }
198 
199 void ASTStmtWriter::VisitBreakStmt(BreakStmt *S) {
200   VisitStmt(S);
201   Writer.AddSourceLocation(S->getBreakLoc(), Record);
202   Code = serialization::STMT_BREAK;
203 }
204 
205 void ASTStmtWriter::VisitReturnStmt(ReturnStmt *S) {
206   VisitStmt(S);
207   Writer.AddStmt(S->getRetValue());
208   Writer.AddSourceLocation(S->getReturnLoc(), Record);
209   Writer.AddDeclRef(S->getNRVOCandidate(), Record);
210   Code = serialization::STMT_RETURN;
211 }
212 
213 void ASTStmtWriter::VisitDeclStmt(DeclStmt *S) {
214   VisitStmt(S);
215   Writer.AddSourceLocation(S->getStartLoc(), Record);
216   Writer.AddSourceLocation(S->getEndLoc(), Record);
217   DeclGroupRef DG = S->getDeclGroup();
218   for (DeclGroupRef::iterator D = DG.begin(), DEnd = DG.end(); D != DEnd; ++D)
219     Writer.AddDeclRef(*D, Record);
220   Code = serialization::STMT_DECL;
221 }
222 
223 void ASTStmtWriter::VisitAsmStmt(AsmStmt *S) {
224   VisitStmt(S);
225   Record.push_back(S->getNumOutputs());
226   Record.push_back(S->getNumInputs());
227   Record.push_back(S->getNumClobbers());
228   Writer.AddSourceLocation(S->getAsmLoc(), Record);
229   Record.push_back(S->isVolatile());
230   Record.push_back(S->isSimple());
231 }
232 
233 void ASTStmtWriter::VisitGCCAsmStmt(GCCAsmStmt *S) {
234   VisitAsmStmt(S);
235   Writer.AddSourceLocation(S->getRParenLoc(), Record);
236   Writer.AddStmt(S->getAsmString());
237 
238   // Outputs
239   for (unsigned I = 0, N = S->getNumOutputs(); I != N; ++I) {
240     Writer.AddIdentifierRef(S->getOutputIdentifier(I), Record);
241     Writer.AddStmt(S->getOutputConstraintLiteral(I));
242     Writer.AddStmt(S->getOutputExpr(I));
243   }
244 
245   // Inputs
246   for (unsigned I = 0, N = S->getNumInputs(); I != N; ++I) {
247     Writer.AddIdentifierRef(S->getInputIdentifier(I), Record);
248     Writer.AddStmt(S->getInputConstraintLiteral(I));
249     Writer.AddStmt(S->getInputExpr(I));
250   }
251 
252   // Clobbers
253   for (unsigned I = 0, N = S->getNumClobbers(); I != N; ++I)
254     Writer.AddStmt(S->getClobberStringLiteral(I));
255 
256   Code = serialization::STMT_GCCASM;
257 }
258 
259 void ASTStmtWriter::VisitMSAsmStmt(MSAsmStmt *S) {
260   VisitAsmStmt(S);
261   Writer.AddSourceLocation(S->getLBraceLoc(), Record);
262   Writer.AddSourceLocation(S->getEndLoc(), Record);
263   Record.push_back(S->getNumAsmToks());
264   Writer.AddString(S->getAsmString(), Record);
265 
266   // Tokens
267   for (unsigned I = 0, N = S->getNumAsmToks(); I != N; ++I) {
268     Writer.AddToken(S->getAsmToks()[I], Record);
269   }
270 
271   // Clobbers
272   for (unsigned I = 0, N = S->getNumClobbers(); I != N; ++I) {
273     Writer.AddString(S->getClobber(I), Record);
274   }
275 
276   // Outputs
277   for (unsigned I = 0, N = S->getNumOutputs(); I != N; ++I) {
278     Writer.AddStmt(S->getOutputExpr(I));
279     Writer.AddString(S->getOutputConstraint(I), Record);
280   }
281 
282   // Inputs
283   for (unsigned I = 0, N = S->getNumInputs(); I != N; ++I) {
284     Writer.AddStmt(S->getInputExpr(I));
285     Writer.AddString(S->getInputConstraint(I), Record);
286   }
287 
288   Code = serialization::STMT_MSASM;
289 }
290 
291 void ASTStmtWriter::VisitCoroutineBodyStmt(CoroutineBodyStmt *S) {
292   // FIXME: Implement coroutine serialization.
293   llvm_unreachable("unimplemented");
294 }
295 
296 void ASTStmtWriter::VisitCoreturnStmt(CoreturnStmt *S) {
297   // FIXME: Implement coroutine serialization.
298   llvm_unreachable("unimplemented");
299 }
300 
301 void ASTStmtWriter::VisitCoawaitExpr(CoawaitExpr *S) {
302   // FIXME: Implement coroutine serialization.
303   llvm_unreachable("unimplemented");
304 }
305 
306 void ASTStmtWriter::VisitCoyieldExpr(CoyieldExpr *S) {
307   // FIXME: Implement coroutine serialization.
308   llvm_unreachable("unimplemented");
309 }
310 
311 void ASTStmtWriter::VisitCapturedStmt(CapturedStmt *S) {
312   VisitStmt(S);
313   // NumCaptures
314   Record.push_back(std::distance(S->capture_begin(), S->capture_end()));
315 
316   // CapturedDecl and captured region kind
317   Writer.AddDeclRef(S->getCapturedDecl(), Record);
318   Record.push_back(S->getCapturedRegionKind());
319 
320   Writer.AddDeclRef(S->getCapturedRecordDecl(), Record);
321 
322   // Capture inits
323   for (auto *I : S->capture_inits())
324     Writer.AddStmt(I);
325 
326   // Body
327   Writer.AddStmt(S->getCapturedStmt());
328 
329   // Captures
330   for (const auto &I : S->captures()) {
331     if (I.capturesThis() || I.capturesVariableArrayType())
332       Writer.AddDeclRef(nullptr, Record);
333     else
334       Writer.AddDeclRef(I.getCapturedVar(), Record);
335     Record.push_back(I.getCaptureKind());
336     Writer.AddSourceLocation(I.getLocation(), Record);
337   }
338 
339   Code = serialization::STMT_CAPTURED;
340 }
341 
342 void ASTStmtWriter::VisitExpr(Expr *E) {
343   VisitStmt(E);
344   Writer.AddTypeRef(E->getType(), Record);
345   Record.push_back(E->isTypeDependent());
346   Record.push_back(E->isValueDependent());
347   Record.push_back(E->isInstantiationDependent());
348   Record.push_back(E->containsUnexpandedParameterPack());
349   Record.push_back(E->getValueKind());
350   Record.push_back(E->getObjectKind());
351 }
352 
353 void ASTStmtWriter::VisitPredefinedExpr(PredefinedExpr *E) {
354   VisitExpr(E);
355   Writer.AddSourceLocation(E->getLocation(), Record);
356   Record.push_back(E->getIdentType()); // FIXME: stable encoding
357   Writer.AddStmt(E->getFunctionName());
358   Code = serialization::EXPR_PREDEFINED;
359 }
360 
361 void ASTStmtWriter::VisitDeclRefExpr(DeclRefExpr *E) {
362   VisitExpr(E);
363 
364   Record.push_back(E->hasQualifier());
365   Record.push_back(E->getDecl() != E->getFoundDecl());
366   Record.push_back(E->hasTemplateKWAndArgsInfo());
367   Record.push_back(E->hadMultipleCandidates());
368   Record.push_back(E->refersToEnclosingVariableOrCapture());
369 
370   if (E->hasTemplateKWAndArgsInfo()) {
371     unsigned NumTemplateArgs = E->getNumTemplateArgs();
372     Record.push_back(NumTemplateArgs);
373   }
374 
375   DeclarationName::NameKind nk = (E->getDecl()->getDeclName().getNameKind());
376 
377   if ((!E->hasTemplateKWAndArgsInfo()) && (!E->hasQualifier()) &&
378       (E->getDecl() == E->getFoundDecl()) &&
379       nk == DeclarationName::Identifier) {
380     AbbrevToUse = Writer.getDeclRefExprAbbrev();
381   }
382 
383   if (E->hasQualifier())
384     Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record);
385 
386   if (E->getDecl() != E->getFoundDecl())
387     Writer.AddDeclRef(E->getFoundDecl(), Record);
388 
389   if (E->hasTemplateKWAndArgsInfo())
390     AddTemplateKWAndArgsInfo(*E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
391                              E->getTrailingObjects<TemplateArgumentLoc>());
392 
393   Writer.AddDeclRef(E->getDecl(), Record);
394   Writer.AddSourceLocation(E->getLocation(), Record);
395   Writer.AddDeclarationNameLoc(E->DNLoc, E->getDecl()->getDeclName(), Record);
396   Code = serialization::EXPR_DECL_REF;
397 }
398 
399 void ASTStmtWriter::VisitIntegerLiteral(IntegerLiteral *E) {
400   VisitExpr(E);
401   Writer.AddSourceLocation(E->getLocation(), Record);
402   Writer.AddAPInt(E->getValue(), Record);
403 
404   if (E->getValue().getBitWidth() == 32) {
405     AbbrevToUse = Writer.getIntegerLiteralAbbrev();
406   }
407 
408   Code = serialization::EXPR_INTEGER_LITERAL;
409 }
410 
411 void ASTStmtWriter::VisitFloatingLiteral(FloatingLiteral *E) {
412   VisitExpr(E);
413   Record.push_back(E->getRawSemantics());
414   Record.push_back(E->isExact());
415   Writer.AddAPFloat(E->getValue(), Record);
416   Writer.AddSourceLocation(E->getLocation(), Record);
417   Code = serialization::EXPR_FLOATING_LITERAL;
418 }
419 
420 void ASTStmtWriter::VisitImaginaryLiteral(ImaginaryLiteral *E) {
421   VisitExpr(E);
422   Writer.AddStmt(E->getSubExpr());
423   Code = serialization::EXPR_IMAGINARY_LITERAL;
424 }
425 
426 void ASTStmtWriter::VisitStringLiteral(StringLiteral *E) {
427   VisitExpr(E);
428   Record.push_back(E->getByteLength());
429   Record.push_back(E->getNumConcatenated());
430   Record.push_back(E->getKind());
431   Record.push_back(E->isPascal());
432   // FIXME: String data should be stored as a blob at the end of the
433   // StringLiteral. However, we can't do so now because we have no
434   // provision for coping with abbreviations when we're jumping around
435   // the AST file during deserialization.
436   Record.append(E->getBytes().begin(), E->getBytes().end());
437   for (unsigned I = 0, N = E->getNumConcatenated(); I != N; ++I)
438     Writer.AddSourceLocation(E->getStrTokenLoc(I), Record);
439   Code = serialization::EXPR_STRING_LITERAL;
440 }
441 
442 void ASTStmtWriter::VisitCharacterLiteral(CharacterLiteral *E) {
443   VisitExpr(E);
444   Record.push_back(E->getValue());
445   Writer.AddSourceLocation(E->getLocation(), Record);
446   Record.push_back(E->getKind());
447 
448   AbbrevToUse = Writer.getCharacterLiteralAbbrev();
449 
450   Code = serialization::EXPR_CHARACTER_LITERAL;
451 }
452 
453 void ASTStmtWriter::VisitParenExpr(ParenExpr *E) {
454   VisitExpr(E);
455   Writer.AddSourceLocation(E->getLParen(), Record);
456   Writer.AddSourceLocation(E->getRParen(), Record);
457   Writer.AddStmt(E->getSubExpr());
458   Code = serialization::EXPR_PAREN;
459 }
460 
461 void ASTStmtWriter::VisitParenListExpr(ParenListExpr *E) {
462   VisitExpr(E);
463   Record.push_back(E->NumExprs);
464   for (unsigned i=0; i != E->NumExprs; ++i)
465     Writer.AddStmt(E->Exprs[i]);
466   Writer.AddSourceLocation(E->LParenLoc, Record);
467   Writer.AddSourceLocation(E->RParenLoc, Record);
468   Code = serialization::EXPR_PAREN_LIST;
469 }
470 
471 void ASTStmtWriter::VisitUnaryOperator(UnaryOperator *E) {
472   VisitExpr(E);
473   Writer.AddStmt(E->getSubExpr());
474   Record.push_back(E->getOpcode()); // FIXME: stable encoding
475   Writer.AddSourceLocation(E->getOperatorLoc(), Record);
476   Code = serialization::EXPR_UNARY_OPERATOR;
477 }
478 
479 void ASTStmtWriter::VisitOffsetOfExpr(OffsetOfExpr *E) {
480   VisitExpr(E);
481   Record.push_back(E->getNumComponents());
482   Record.push_back(E->getNumExpressions());
483   Writer.AddSourceLocation(E->getOperatorLoc(), Record);
484   Writer.AddSourceLocation(E->getRParenLoc(), Record);
485   Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record);
486   for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) {
487     const OffsetOfNode &ON = E->getComponent(I);
488     Record.push_back(ON.getKind()); // FIXME: Stable encoding
489     Writer.AddSourceLocation(ON.getSourceRange().getBegin(), Record);
490     Writer.AddSourceLocation(ON.getSourceRange().getEnd(), Record);
491     switch (ON.getKind()) {
492     case OffsetOfNode::Array:
493       Record.push_back(ON.getArrayExprIndex());
494       break;
495 
496     case OffsetOfNode::Field:
497       Writer.AddDeclRef(ON.getField(), Record);
498       break;
499 
500     case OffsetOfNode::Identifier:
501       Writer.AddIdentifierRef(ON.getFieldName(), Record);
502       break;
503 
504     case OffsetOfNode::Base:
505       Writer.AddCXXBaseSpecifier(*ON.getBase(), Record);
506       break;
507     }
508   }
509   for (unsigned I = 0, N = E->getNumExpressions(); I != N; ++I)
510     Writer.AddStmt(E->getIndexExpr(I));
511   Code = serialization::EXPR_OFFSETOF;
512 }
513 
514 void ASTStmtWriter::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) {
515   VisitExpr(E);
516   Record.push_back(E->getKind());
517   if (E->isArgumentType())
518     Writer.AddTypeSourceInfo(E->getArgumentTypeInfo(), Record);
519   else {
520     Record.push_back(0);
521     Writer.AddStmt(E->getArgumentExpr());
522   }
523   Writer.AddSourceLocation(E->getOperatorLoc(), Record);
524   Writer.AddSourceLocation(E->getRParenLoc(), Record);
525   Code = serialization::EXPR_SIZEOF_ALIGN_OF;
526 }
527 
528 void ASTStmtWriter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
529   VisitExpr(E);
530   Writer.AddStmt(E->getLHS());
531   Writer.AddStmt(E->getRHS());
532   Writer.AddSourceLocation(E->getRBracketLoc(), Record);
533   Code = serialization::EXPR_ARRAY_SUBSCRIPT;
534 }
535 
536 void ASTStmtWriter::VisitOMPArraySectionExpr(OMPArraySectionExpr *E) {
537   VisitExpr(E);
538   Writer.AddStmt(E->getBase());
539   Writer.AddStmt(E->getLowerBound());
540   Writer.AddStmt(E->getLength());
541   Writer.AddSourceLocation(E->getColonLoc(), Record);
542   Writer.AddSourceLocation(E->getRBracketLoc(), Record);
543   Code = serialization::EXPR_OMP_ARRAY_SECTION;
544 }
545 
546 void ASTStmtWriter::VisitCallExpr(CallExpr *E) {
547   VisitExpr(E);
548   Record.push_back(E->getNumArgs());
549   Writer.AddSourceLocation(E->getRParenLoc(), Record);
550   Writer.AddStmt(E->getCallee());
551   for (CallExpr::arg_iterator Arg = E->arg_begin(), ArgEnd = E->arg_end();
552        Arg != ArgEnd; ++Arg)
553     Writer.AddStmt(*Arg);
554   Code = serialization::EXPR_CALL;
555 }
556 
557 void ASTStmtWriter::VisitMemberExpr(MemberExpr *E) {
558   // Don't call VisitExpr, we'll write everything here.
559 
560   Record.push_back(E->hasQualifier());
561   if (E->hasQualifier())
562     Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record);
563 
564   Record.push_back(E->HasTemplateKWAndArgsInfo);
565   if (E->HasTemplateKWAndArgsInfo) {
566     Writer.AddSourceLocation(E->getTemplateKeywordLoc(), Record);
567     unsigned NumTemplateArgs = E->getNumTemplateArgs();
568     Record.push_back(NumTemplateArgs);
569     Writer.AddSourceLocation(E->getLAngleLoc(), Record);
570     Writer.AddSourceLocation(E->getRAngleLoc(), Record);
571     for (unsigned i=0; i != NumTemplateArgs; ++i)
572       Writer.AddTemplateArgumentLoc(E->getTemplateArgs()[i], Record);
573   }
574 
575   Record.push_back(E->hadMultipleCandidates());
576 
577   DeclAccessPair FoundDecl = E->getFoundDecl();
578   Writer.AddDeclRef(FoundDecl.getDecl(), Record);
579   Record.push_back(FoundDecl.getAccess());
580 
581   Writer.AddTypeRef(E->getType(), Record);
582   Record.push_back(E->getValueKind());
583   Record.push_back(E->getObjectKind());
584   Writer.AddStmt(E->getBase());
585   Writer.AddDeclRef(E->getMemberDecl(), Record);
586   Writer.AddSourceLocation(E->getMemberLoc(), Record);
587   Record.push_back(E->isArrow());
588   Writer.AddSourceLocation(E->getOperatorLoc(), Record);
589   Writer.AddDeclarationNameLoc(E->MemberDNLoc,
590                                E->getMemberDecl()->getDeclName(), Record);
591   Code = serialization::EXPR_MEMBER;
592 }
593 
594 void ASTStmtWriter::VisitObjCIsaExpr(ObjCIsaExpr *E) {
595   VisitExpr(E);
596   Writer.AddStmt(E->getBase());
597   Writer.AddSourceLocation(E->getIsaMemberLoc(), Record);
598   Writer.AddSourceLocation(E->getOpLoc(), Record);
599   Record.push_back(E->isArrow());
600   Code = serialization::EXPR_OBJC_ISA;
601 }
602 
603 void ASTStmtWriter::
604 VisitObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) {
605   VisitExpr(E);
606   Writer.AddStmt(E->getSubExpr());
607   Record.push_back(E->shouldCopy());
608   Code = serialization::EXPR_OBJC_INDIRECT_COPY_RESTORE;
609 }
610 
611 void ASTStmtWriter::VisitObjCBridgedCastExpr(ObjCBridgedCastExpr *E) {
612   VisitExplicitCastExpr(E);
613   Writer.AddSourceLocation(E->getLParenLoc(), Record);
614   Writer.AddSourceLocation(E->getBridgeKeywordLoc(), Record);
615   Record.push_back(E->getBridgeKind()); // FIXME: Stable encoding
616   Code = serialization::EXPR_OBJC_BRIDGED_CAST;
617 }
618 
619 void ASTStmtWriter::VisitCastExpr(CastExpr *E) {
620   VisitExpr(E);
621   Record.push_back(E->path_size());
622   Writer.AddStmt(E->getSubExpr());
623   Record.push_back(E->getCastKind()); // FIXME: stable encoding
624 
625   for (CastExpr::path_iterator
626          PI = E->path_begin(), PE = E->path_end(); PI != PE; ++PI)
627     Writer.AddCXXBaseSpecifier(**PI, Record);
628 }
629 
630 void ASTStmtWriter::VisitBinaryOperator(BinaryOperator *E) {
631   VisitExpr(E);
632   Writer.AddStmt(E->getLHS());
633   Writer.AddStmt(E->getRHS());
634   Record.push_back(E->getOpcode()); // FIXME: stable encoding
635   Writer.AddSourceLocation(E->getOperatorLoc(), Record);
636   Record.push_back(E->isFPContractable());
637   Code = serialization::EXPR_BINARY_OPERATOR;
638 }
639 
640 void ASTStmtWriter::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
641   VisitBinaryOperator(E);
642   Writer.AddTypeRef(E->getComputationLHSType(), Record);
643   Writer.AddTypeRef(E->getComputationResultType(), Record);
644   Code = serialization::EXPR_COMPOUND_ASSIGN_OPERATOR;
645 }
646 
647 void ASTStmtWriter::VisitConditionalOperator(ConditionalOperator *E) {
648   VisitExpr(E);
649   Writer.AddStmt(E->getCond());
650   Writer.AddStmt(E->getLHS());
651   Writer.AddStmt(E->getRHS());
652   Writer.AddSourceLocation(E->getQuestionLoc(), Record);
653   Writer.AddSourceLocation(E->getColonLoc(), Record);
654   Code = serialization::EXPR_CONDITIONAL_OPERATOR;
655 }
656 
657 void
658 ASTStmtWriter::VisitBinaryConditionalOperator(BinaryConditionalOperator *E) {
659   VisitExpr(E);
660   Writer.AddStmt(E->getOpaqueValue());
661   Writer.AddStmt(E->getCommon());
662   Writer.AddStmt(E->getCond());
663   Writer.AddStmt(E->getTrueExpr());
664   Writer.AddStmt(E->getFalseExpr());
665   Writer.AddSourceLocation(E->getQuestionLoc(), Record);
666   Writer.AddSourceLocation(E->getColonLoc(), Record);
667   Code = serialization::EXPR_BINARY_CONDITIONAL_OPERATOR;
668 }
669 
670 void ASTStmtWriter::VisitImplicitCastExpr(ImplicitCastExpr *E) {
671   VisitCastExpr(E);
672 
673   if (E->path_size() == 0)
674     AbbrevToUse = Writer.getExprImplicitCastAbbrev();
675 
676   Code = serialization::EXPR_IMPLICIT_CAST;
677 }
678 
679 void ASTStmtWriter::VisitExplicitCastExpr(ExplicitCastExpr *E) {
680   VisitCastExpr(E);
681   Writer.AddTypeSourceInfo(E->getTypeInfoAsWritten(), Record);
682 }
683 
684 void ASTStmtWriter::VisitCStyleCastExpr(CStyleCastExpr *E) {
685   VisitExplicitCastExpr(E);
686   Writer.AddSourceLocation(E->getLParenLoc(), Record);
687   Writer.AddSourceLocation(E->getRParenLoc(), Record);
688   Code = serialization::EXPR_CSTYLE_CAST;
689 }
690 
691 void ASTStmtWriter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
692   VisitExpr(E);
693   Writer.AddSourceLocation(E->getLParenLoc(), Record);
694   Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record);
695   Writer.AddStmt(E->getInitializer());
696   Record.push_back(E->isFileScope());
697   Code = serialization::EXPR_COMPOUND_LITERAL;
698 }
699 
700 void ASTStmtWriter::VisitExtVectorElementExpr(ExtVectorElementExpr *E) {
701   VisitExpr(E);
702   Writer.AddStmt(E->getBase());
703   Writer.AddIdentifierRef(&E->getAccessor(), Record);
704   Writer.AddSourceLocation(E->getAccessorLoc(), Record);
705   Code = serialization::EXPR_EXT_VECTOR_ELEMENT;
706 }
707 
708 void ASTStmtWriter::VisitInitListExpr(InitListExpr *E) {
709   VisitExpr(E);
710   // NOTE: only add the (possibly null) syntactic form.
711   // No need to serialize the isSemanticForm flag and the semantic form.
712   Writer.AddStmt(E->getSyntacticForm());
713   Writer.AddSourceLocation(E->getLBraceLoc(), Record);
714   Writer.AddSourceLocation(E->getRBraceLoc(), Record);
715   bool isArrayFiller = E->ArrayFillerOrUnionFieldInit.is<Expr*>();
716   Record.push_back(isArrayFiller);
717   if (isArrayFiller)
718     Writer.AddStmt(E->getArrayFiller());
719   else
720     Writer.AddDeclRef(E->getInitializedFieldInUnion(), Record);
721   Record.push_back(E->hadArrayRangeDesignator());
722   Record.push_back(E->getNumInits());
723   if (isArrayFiller) {
724     // ArrayFiller may have filled "holes" due to designated initializer.
725     // Replace them by 0 to indicate that the filler goes in that place.
726     Expr *filler = E->getArrayFiller();
727     for (unsigned I = 0, N = E->getNumInits(); I != N; ++I)
728       Writer.AddStmt(E->getInit(I) != filler ? E->getInit(I) : nullptr);
729   } else {
730     for (unsigned I = 0, N = E->getNumInits(); I != N; ++I)
731       Writer.AddStmt(E->getInit(I));
732   }
733   Code = serialization::EXPR_INIT_LIST;
734 }
735 
736 void ASTStmtWriter::VisitDesignatedInitExpr(DesignatedInitExpr *E) {
737   VisitExpr(E);
738   Record.push_back(E->getNumSubExprs());
739   for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I)
740     Writer.AddStmt(E->getSubExpr(I));
741   Writer.AddSourceLocation(E->getEqualOrColonLoc(), Record);
742   Record.push_back(E->usesGNUSyntax());
743   for (DesignatedInitExpr::designators_iterator D = E->designators_begin(),
744                                              DEnd = E->designators_end();
745        D != DEnd; ++D) {
746     if (D->isFieldDesignator()) {
747       if (FieldDecl *Field = D->getField()) {
748         Record.push_back(serialization::DESIG_FIELD_DECL);
749         Writer.AddDeclRef(Field, Record);
750       } else {
751         Record.push_back(serialization::DESIG_FIELD_NAME);
752         Writer.AddIdentifierRef(D->getFieldName(), Record);
753       }
754       Writer.AddSourceLocation(D->getDotLoc(), Record);
755       Writer.AddSourceLocation(D->getFieldLoc(), Record);
756     } else if (D->isArrayDesignator()) {
757       Record.push_back(serialization::DESIG_ARRAY);
758       Record.push_back(D->getFirstExprIndex());
759       Writer.AddSourceLocation(D->getLBracketLoc(), Record);
760       Writer.AddSourceLocation(D->getRBracketLoc(), Record);
761     } else {
762       assert(D->isArrayRangeDesignator() && "Unknown designator");
763       Record.push_back(serialization::DESIG_ARRAY_RANGE);
764       Record.push_back(D->getFirstExprIndex());
765       Writer.AddSourceLocation(D->getLBracketLoc(), Record);
766       Writer.AddSourceLocation(D->getEllipsisLoc(), Record);
767       Writer.AddSourceLocation(D->getRBracketLoc(), Record);
768     }
769   }
770   Code = serialization::EXPR_DESIGNATED_INIT;
771 }
772 
773 void ASTStmtWriter::VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E) {
774   VisitExpr(E);
775   Writer.AddStmt(E->getBase());
776   Writer.AddStmt(E->getUpdater());
777   Code = serialization::EXPR_DESIGNATED_INIT_UPDATE;
778 }
779 
780 void ASTStmtWriter::VisitNoInitExpr(NoInitExpr *E) {
781   VisitExpr(E);
782   Code = serialization::EXPR_NO_INIT;
783 }
784 
785 void ASTStmtWriter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
786   VisitExpr(E);
787   Code = serialization::EXPR_IMPLICIT_VALUE_INIT;
788 }
789 
790 void ASTStmtWriter::VisitVAArgExpr(VAArgExpr *E) {
791   VisitExpr(E);
792   Writer.AddStmt(E->getSubExpr());
793   Writer.AddTypeSourceInfo(E->getWrittenTypeInfo(), Record);
794   Writer.AddSourceLocation(E->getBuiltinLoc(), Record);
795   Writer.AddSourceLocation(E->getRParenLoc(), Record);
796   Record.push_back(E->isMicrosoftABI());
797   Code = serialization::EXPR_VA_ARG;
798 }
799 
800 void ASTStmtWriter::VisitAddrLabelExpr(AddrLabelExpr *E) {
801   VisitExpr(E);
802   Writer.AddSourceLocation(E->getAmpAmpLoc(), Record);
803   Writer.AddSourceLocation(E->getLabelLoc(), Record);
804   Writer.AddDeclRef(E->getLabel(), Record);
805   Code = serialization::EXPR_ADDR_LABEL;
806 }
807 
808 void ASTStmtWriter::VisitStmtExpr(StmtExpr *E) {
809   VisitExpr(E);
810   Writer.AddStmt(E->getSubStmt());
811   Writer.AddSourceLocation(E->getLParenLoc(), Record);
812   Writer.AddSourceLocation(E->getRParenLoc(), Record);
813   Code = serialization::EXPR_STMT;
814 }
815 
816 void ASTStmtWriter::VisitChooseExpr(ChooseExpr *E) {
817   VisitExpr(E);
818   Writer.AddStmt(E->getCond());
819   Writer.AddStmt(E->getLHS());
820   Writer.AddStmt(E->getRHS());
821   Writer.AddSourceLocation(E->getBuiltinLoc(), Record);
822   Writer.AddSourceLocation(E->getRParenLoc(), Record);
823   Record.push_back(E->isConditionDependent() ? false : E->isConditionTrue());
824   Code = serialization::EXPR_CHOOSE;
825 }
826 
827 void ASTStmtWriter::VisitGNUNullExpr(GNUNullExpr *E) {
828   VisitExpr(E);
829   Writer.AddSourceLocation(E->getTokenLocation(), Record);
830   Code = serialization::EXPR_GNU_NULL;
831 }
832 
833 void ASTStmtWriter::VisitShuffleVectorExpr(ShuffleVectorExpr *E) {
834   VisitExpr(E);
835   Record.push_back(E->getNumSubExprs());
836   for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I)
837     Writer.AddStmt(E->getExpr(I));
838   Writer.AddSourceLocation(E->getBuiltinLoc(), Record);
839   Writer.AddSourceLocation(E->getRParenLoc(), Record);
840   Code = serialization::EXPR_SHUFFLE_VECTOR;
841 }
842 
843 void ASTStmtWriter::VisitConvertVectorExpr(ConvertVectorExpr *E) {
844   VisitExpr(E);
845   Writer.AddSourceLocation(E->getBuiltinLoc(), Record);
846   Writer.AddSourceLocation(E->getRParenLoc(), Record);
847   Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record);
848   Writer.AddStmt(E->getSrcExpr());
849   Code = serialization::EXPR_CONVERT_VECTOR;
850 }
851 
852 void ASTStmtWriter::VisitBlockExpr(BlockExpr *E) {
853   VisitExpr(E);
854   Writer.AddDeclRef(E->getBlockDecl(), Record);
855   Code = serialization::EXPR_BLOCK;
856 }
857 
858 void ASTStmtWriter::VisitGenericSelectionExpr(GenericSelectionExpr *E) {
859   VisitExpr(E);
860   Record.push_back(E->getNumAssocs());
861 
862   Writer.AddStmt(E->getControllingExpr());
863   for (unsigned I = 0, N = E->getNumAssocs(); I != N; ++I) {
864     Writer.AddTypeSourceInfo(E->getAssocTypeSourceInfo(I), Record);
865     Writer.AddStmt(E->getAssocExpr(I));
866   }
867   Record.push_back(E->isResultDependent() ? -1U : E->getResultIndex());
868 
869   Writer.AddSourceLocation(E->getGenericLoc(), Record);
870   Writer.AddSourceLocation(E->getDefaultLoc(), Record);
871   Writer.AddSourceLocation(E->getRParenLoc(), Record);
872   Code = serialization::EXPR_GENERIC_SELECTION;
873 }
874 
875 void ASTStmtWriter::VisitPseudoObjectExpr(PseudoObjectExpr *E) {
876   VisitExpr(E);
877   Record.push_back(E->getNumSemanticExprs());
878 
879   // Push the result index.  Currently, this needs to exactly match
880   // the encoding used internally for ResultIndex.
881   unsigned result = E->getResultExprIndex();
882   result = (result == PseudoObjectExpr::NoResult ? 0 : result + 1);
883   Record.push_back(result);
884 
885   Writer.AddStmt(E->getSyntacticForm());
886   for (PseudoObjectExpr::semantics_iterator
887          i = E->semantics_begin(), e = E->semantics_end(); i != e; ++i) {
888     Writer.AddStmt(*i);
889   }
890   Code = serialization::EXPR_PSEUDO_OBJECT;
891 }
892 
893 void ASTStmtWriter::VisitAtomicExpr(AtomicExpr *E) {
894   VisitExpr(E);
895   Record.push_back(E->getOp());
896   for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I)
897     Writer.AddStmt(E->getSubExprs()[I]);
898   Writer.AddSourceLocation(E->getBuiltinLoc(), Record);
899   Writer.AddSourceLocation(E->getRParenLoc(), Record);
900   Code = serialization::EXPR_ATOMIC;
901 }
902 
903 //===----------------------------------------------------------------------===//
904 // Objective-C Expressions and Statements.
905 //===----------------------------------------------------------------------===//
906 
907 void ASTStmtWriter::VisitObjCStringLiteral(ObjCStringLiteral *E) {
908   VisitExpr(E);
909   Writer.AddStmt(E->getString());
910   Writer.AddSourceLocation(E->getAtLoc(), Record);
911   Code = serialization::EXPR_OBJC_STRING_LITERAL;
912 }
913 
914 void ASTStmtWriter::VisitObjCBoxedExpr(ObjCBoxedExpr *E) {
915   VisitExpr(E);
916   Writer.AddStmt(E->getSubExpr());
917   Writer.AddDeclRef(E->getBoxingMethod(), Record);
918   Writer.AddSourceRange(E->getSourceRange(), Record);
919   Code = serialization::EXPR_OBJC_BOXED_EXPRESSION;
920 }
921 
922 void ASTStmtWriter::VisitObjCArrayLiteral(ObjCArrayLiteral *E) {
923   VisitExpr(E);
924   Record.push_back(E->getNumElements());
925   for (unsigned i = 0; i < E->getNumElements(); i++)
926     Writer.AddStmt(E->getElement(i));
927   Writer.AddDeclRef(E->getArrayWithObjectsMethod(), Record);
928   Writer.AddSourceRange(E->getSourceRange(), Record);
929   Code = serialization::EXPR_OBJC_ARRAY_LITERAL;
930 }
931 
932 void ASTStmtWriter::VisitObjCDictionaryLiteral(ObjCDictionaryLiteral *E) {
933   VisitExpr(E);
934   Record.push_back(E->getNumElements());
935   Record.push_back(E->HasPackExpansions);
936   for (unsigned i = 0; i < E->getNumElements(); i++) {
937     ObjCDictionaryElement Element = E->getKeyValueElement(i);
938     Writer.AddStmt(Element.Key);
939     Writer.AddStmt(Element.Value);
940     if (E->HasPackExpansions) {
941       Writer.AddSourceLocation(Element.EllipsisLoc, Record);
942       unsigned NumExpansions = 0;
943       if (Element.NumExpansions)
944         NumExpansions = *Element.NumExpansions + 1;
945       Record.push_back(NumExpansions);
946     }
947   }
948 
949   Writer.AddDeclRef(E->getDictWithObjectsMethod(), Record);
950   Writer.AddSourceRange(E->getSourceRange(), Record);
951   Code = serialization::EXPR_OBJC_DICTIONARY_LITERAL;
952 }
953 
954 void ASTStmtWriter::VisitObjCEncodeExpr(ObjCEncodeExpr *E) {
955   VisitExpr(E);
956   Writer.AddTypeSourceInfo(E->getEncodedTypeSourceInfo(), Record);
957   Writer.AddSourceLocation(E->getAtLoc(), Record);
958   Writer.AddSourceLocation(E->getRParenLoc(), Record);
959   Code = serialization::EXPR_OBJC_ENCODE;
960 }
961 
962 void ASTStmtWriter::VisitObjCSelectorExpr(ObjCSelectorExpr *E) {
963   VisitExpr(E);
964   Writer.AddSelectorRef(E->getSelector(), Record);
965   Writer.AddSourceLocation(E->getAtLoc(), Record);
966   Writer.AddSourceLocation(E->getRParenLoc(), Record);
967   Code = serialization::EXPR_OBJC_SELECTOR_EXPR;
968 }
969 
970 void ASTStmtWriter::VisitObjCProtocolExpr(ObjCProtocolExpr *E) {
971   VisitExpr(E);
972   Writer.AddDeclRef(E->getProtocol(), Record);
973   Writer.AddSourceLocation(E->getAtLoc(), Record);
974   Writer.AddSourceLocation(E->ProtoLoc, Record);
975   Writer.AddSourceLocation(E->getRParenLoc(), Record);
976   Code = serialization::EXPR_OBJC_PROTOCOL_EXPR;
977 }
978 
979 void ASTStmtWriter::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
980   VisitExpr(E);
981   Writer.AddDeclRef(E->getDecl(), Record);
982   Writer.AddSourceLocation(E->getLocation(), Record);
983   Writer.AddSourceLocation(E->getOpLoc(), Record);
984   Writer.AddStmt(E->getBase());
985   Record.push_back(E->isArrow());
986   Record.push_back(E->isFreeIvar());
987   Code = serialization::EXPR_OBJC_IVAR_REF_EXPR;
988 }
989 
990 void ASTStmtWriter::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
991   VisitExpr(E);
992   Record.push_back(E->SetterAndMethodRefFlags.getInt());
993   Record.push_back(E->isImplicitProperty());
994   if (E->isImplicitProperty()) {
995     Writer.AddDeclRef(E->getImplicitPropertyGetter(), Record);
996     Writer.AddDeclRef(E->getImplicitPropertySetter(), Record);
997   } else {
998     Writer.AddDeclRef(E->getExplicitProperty(), Record);
999   }
1000   Writer.AddSourceLocation(E->getLocation(), Record);
1001   Writer.AddSourceLocation(E->getReceiverLocation(), Record);
1002   if (E->isObjectReceiver()) {
1003     Record.push_back(0);
1004     Writer.AddStmt(E->getBase());
1005   } else if (E->isSuperReceiver()) {
1006     Record.push_back(1);
1007     Writer.AddTypeRef(E->getSuperReceiverType(), Record);
1008   } else {
1009     Record.push_back(2);
1010     Writer.AddDeclRef(E->getClassReceiver(), Record);
1011   }
1012 
1013   Code = serialization::EXPR_OBJC_PROPERTY_REF_EXPR;
1014 }
1015 
1016 void ASTStmtWriter::VisitObjCSubscriptRefExpr(ObjCSubscriptRefExpr *E) {
1017   VisitExpr(E);
1018   Writer.AddSourceLocation(E->getRBracket(), Record);
1019   Writer.AddStmt(E->getBaseExpr());
1020   Writer.AddStmt(E->getKeyExpr());
1021   Writer.AddDeclRef(E->getAtIndexMethodDecl(), Record);
1022   Writer.AddDeclRef(E->setAtIndexMethodDecl(), Record);
1023 
1024   Code = serialization::EXPR_OBJC_SUBSCRIPT_REF_EXPR;
1025 }
1026 
1027 void ASTStmtWriter::VisitObjCMessageExpr(ObjCMessageExpr *E) {
1028   VisitExpr(E);
1029   Record.push_back(E->getNumArgs());
1030   Record.push_back(E->getNumStoredSelLocs());
1031   Record.push_back(E->SelLocsKind);
1032   Record.push_back(E->isDelegateInitCall());
1033   Record.push_back(E->IsImplicit);
1034   Record.push_back((unsigned)E->getReceiverKind()); // FIXME: stable encoding
1035   switch (E->getReceiverKind()) {
1036   case ObjCMessageExpr::Instance:
1037     Writer.AddStmt(E->getInstanceReceiver());
1038     break;
1039 
1040   case ObjCMessageExpr::Class:
1041     Writer.AddTypeSourceInfo(E->getClassReceiverTypeInfo(), Record);
1042     break;
1043 
1044   case ObjCMessageExpr::SuperClass:
1045   case ObjCMessageExpr::SuperInstance:
1046     Writer.AddTypeRef(E->getSuperType(), Record);
1047     Writer.AddSourceLocation(E->getSuperLoc(), Record);
1048     break;
1049   }
1050 
1051   if (E->getMethodDecl()) {
1052     Record.push_back(1);
1053     Writer.AddDeclRef(E->getMethodDecl(), Record);
1054   } else {
1055     Record.push_back(0);
1056     Writer.AddSelectorRef(E->getSelector(), Record);
1057   }
1058 
1059   Writer.AddSourceLocation(E->getLeftLoc(), Record);
1060   Writer.AddSourceLocation(E->getRightLoc(), Record);
1061 
1062   for (CallExpr::arg_iterator Arg = E->arg_begin(), ArgEnd = E->arg_end();
1063        Arg != ArgEnd; ++Arg)
1064     Writer.AddStmt(*Arg);
1065 
1066   SourceLocation *Locs = E->getStoredSelLocs();
1067   for (unsigned i = 0, e = E->getNumStoredSelLocs(); i != e; ++i)
1068     Writer.AddSourceLocation(Locs[i], Record);
1069 
1070   Code = serialization::EXPR_OBJC_MESSAGE_EXPR;
1071 }
1072 
1073 void ASTStmtWriter::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
1074   VisitStmt(S);
1075   Writer.AddStmt(S->getElement());
1076   Writer.AddStmt(S->getCollection());
1077   Writer.AddStmt(S->getBody());
1078   Writer.AddSourceLocation(S->getForLoc(), Record);
1079   Writer.AddSourceLocation(S->getRParenLoc(), Record);
1080   Code = serialization::STMT_OBJC_FOR_COLLECTION;
1081 }
1082 
1083 void ASTStmtWriter::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {
1084   Writer.AddStmt(S->getCatchBody());
1085   Writer.AddDeclRef(S->getCatchParamDecl(), Record);
1086   Writer.AddSourceLocation(S->getAtCatchLoc(), Record);
1087   Writer.AddSourceLocation(S->getRParenLoc(), Record);
1088   Code = serialization::STMT_OBJC_CATCH;
1089 }
1090 
1091 void ASTStmtWriter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
1092   Writer.AddStmt(S->getFinallyBody());
1093   Writer.AddSourceLocation(S->getAtFinallyLoc(), Record);
1094   Code = serialization::STMT_OBJC_FINALLY;
1095 }
1096 
1097 void ASTStmtWriter::VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S) {
1098   Writer.AddStmt(S->getSubStmt());
1099   Writer.AddSourceLocation(S->getAtLoc(), Record);
1100   Code = serialization::STMT_OBJC_AUTORELEASE_POOL;
1101 }
1102 
1103 void ASTStmtWriter::VisitObjCAtTryStmt(ObjCAtTryStmt *S) {
1104   Record.push_back(S->getNumCatchStmts());
1105   Record.push_back(S->getFinallyStmt() != nullptr);
1106   Writer.AddStmt(S->getTryBody());
1107   for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I)
1108     Writer.AddStmt(S->getCatchStmt(I));
1109   if (S->getFinallyStmt())
1110     Writer.AddStmt(S->getFinallyStmt());
1111   Writer.AddSourceLocation(S->getAtTryLoc(), Record);
1112   Code = serialization::STMT_OBJC_AT_TRY;
1113 }
1114 
1115 void ASTStmtWriter::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) {
1116   Writer.AddStmt(S->getSynchExpr());
1117   Writer.AddStmt(S->getSynchBody());
1118   Writer.AddSourceLocation(S->getAtSynchronizedLoc(), Record);
1119   Code = serialization::STMT_OBJC_AT_SYNCHRONIZED;
1120 }
1121 
1122 void ASTStmtWriter::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {
1123   Writer.AddStmt(S->getThrowExpr());
1124   Writer.AddSourceLocation(S->getThrowLoc(), Record);
1125   Code = serialization::STMT_OBJC_AT_THROW;
1126 }
1127 
1128 void ASTStmtWriter::VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) {
1129   VisitExpr(E);
1130   Record.push_back(E->getValue());
1131   Writer.AddSourceLocation(E->getLocation(), Record);
1132   Code = serialization::EXPR_OBJC_BOOL_LITERAL;
1133 }
1134 
1135 //===----------------------------------------------------------------------===//
1136 // C++ Expressions and Statements.
1137 //===----------------------------------------------------------------------===//
1138 
1139 void ASTStmtWriter::VisitCXXCatchStmt(CXXCatchStmt *S) {
1140   VisitStmt(S);
1141   Writer.AddSourceLocation(S->getCatchLoc(), Record);
1142   Writer.AddDeclRef(S->getExceptionDecl(), Record);
1143   Writer.AddStmt(S->getHandlerBlock());
1144   Code = serialization::STMT_CXX_CATCH;
1145 }
1146 
1147 void ASTStmtWriter::VisitCXXTryStmt(CXXTryStmt *S) {
1148   VisitStmt(S);
1149   Record.push_back(S->getNumHandlers());
1150   Writer.AddSourceLocation(S->getTryLoc(), Record);
1151   Writer.AddStmt(S->getTryBlock());
1152   for (unsigned i = 0, e = S->getNumHandlers(); i != e; ++i)
1153     Writer.AddStmt(S->getHandler(i));
1154   Code = serialization::STMT_CXX_TRY;
1155 }
1156 
1157 void ASTStmtWriter::VisitCXXForRangeStmt(CXXForRangeStmt *S) {
1158   VisitStmt(S);
1159   Writer.AddSourceLocation(S->getForLoc(), Record);
1160   Writer.AddSourceLocation(S->getCoawaitLoc(), Record);
1161   Writer.AddSourceLocation(S->getColonLoc(), Record);
1162   Writer.AddSourceLocation(S->getRParenLoc(), Record);
1163   Writer.AddStmt(S->getRangeStmt());
1164   Writer.AddStmt(S->getBeginEndStmt());
1165   Writer.AddStmt(S->getCond());
1166   Writer.AddStmt(S->getInc());
1167   Writer.AddStmt(S->getLoopVarStmt());
1168   Writer.AddStmt(S->getBody());
1169   Code = serialization::STMT_CXX_FOR_RANGE;
1170 }
1171 
1172 void ASTStmtWriter::VisitMSDependentExistsStmt(MSDependentExistsStmt *S) {
1173   VisitStmt(S);
1174   Writer.AddSourceLocation(S->getKeywordLoc(), Record);
1175   Record.push_back(S->isIfExists());
1176   Writer.AddNestedNameSpecifierLoc(S->getQualifierLoc(), Record);
1177   Writer.AddDeclarationNameInfo(S->getNameInfo(), Record);
1178   Writer.AddStmt(S->getSubStmt());
1179   Code = serialization::STMT_MS_DEPENDENT_EXISTS;
1180 }
1181 
1182 void ASTStmtWriter::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
1183   VisitCallExpr(E);
1184   Record.push_back(E->getOperator());
1185   Writer.AddSourceRange(E->Range, Record);
1186   Record.push_back(E->isFPContractable());
1187   Code = serialization::EXPR_CXX_OPERATOR_CALL;
1188 }
1189 
1190 void ASTStmtWriter::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
1191   VisitCallExpr(E);
1192   Code = serialization::EXPR_CXX_MEMBER_CALL;
1193 }
1194 
1195 void ASTStmtWriter::VisitCXXConstructExpr(CXXConstructExpr *E) {
1196   VisitExpr(E);
1197   Record.push_back(E->getNumArgs());
1198   for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
1199     Writer.AddStmt(E->getArg(I));
1200   Writer.AddDeclRef(E->getConstructor(), Record);
1201   Writer.AddSourceLocation(E->getLocation(), Record);
1202   Record.push_back(E->isElidable());
1203   Record.push_back(E->hadMultipleCandidates());
1204   Record.push_back(E->isListInitialization());
1205   Record.push_back(E->isStdInitListInitialization());
1206   Record.push_back(E->requiresZeroInitialization());
1207   Record.push_back(E->getConstructionKind()); // FIXME: stable encoding
1208   Writer.AddSourceRange(E->getParenOrBraceRange(), Record);
1209   Code = serialization::EXPR_CXX_CONSTRUCT;
1210 }
1211 
1212 void ASTStmtWriter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) {
1213   VisitCXXConstructExpr(E);
1214   Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record);
1215   Code = serialization::EXPR_CXX_TEMPORARY_OBJECT;
1216 }
1217 
1218 void ASTStmtWriter::VisitLambdaExpr(LambdaExpr *E) {
1219   VisitExpr(E);
1220   Record.push_back(E->NumCaptures);
1221   unsigned NumArrayIndexVars = 0;
1222   if (E->HasArrayIndexVars)
1223     NumArrayIndexVars = E->getArrayIndexStarts()[E->NumCaptures];
1224   Record.push_back(NumArrayIndexVars);
1225   Writer.AddSourceRange(E->IntroducerRange, Record);
1226   Record.push_back(E->CaptureDefault); // FIXME: stable encoding
1227   Writer.AddSourceLocation(E->CaptureDefaultLoc, Record);
1228   Record.push_back(E->ExplicitParams);
1229   Record.push_back(E->ExplicitResultType);
1230   Writer.AddSourceLocation(E->ClosingBrace, Record);
1231 
1232   // Add capture initializers.
1233   for (LambdaExpr::capture_init_iterator C = E->capture_init_begin(),
1234                                       CEnd = E->capture_init_end();
1235        C != CEnd; ++C) {
1236     Writer.AddStmt(*C);
1237   }
1238 
1239   // Add array index variables, if any.
1240   if (NumArrayIndexVars) {
1241     Record.append(E->getArrayIndexStarts(),
1242                   E->getArrayIndexStarts() + E->NumCaptures + 1);
1243     VarDecl **ArrayIndexVars = E->getArrayIndexVars();
1244     for (unsigned I = 0; I != NumArrayIndexVars; ++I)
1245       Writer.AddDeclRef(ArrayIndexVars[I], Record);
1246   }
1247 
1248   Code = serialization::EXPR_LAMBDA;
1249 }
1250 
1251 void ASTStmtWriter::VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) {
1252   VisitExpr(E);
1253   Writer.AddStmt(E->getSubExpr());
1254   Code = serialization::EXPR_CXX_STD_INITIALIZER_LIST;
1255 }
1256 
1257 void ASTStmtWriter::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
1258   VisitExplicitCastExpr(E);
1259   Writer.AddSourceRange(SourceRange(E->getOperatorLoc(), E->getRParenLoc()),
1260                         Record);
1261   Writer.AddSourceRange(E->getAngleBrackets(), Record);
1262 }
1263 
1264 void ASTStmtWriter::VisitCXXStaticCastExpr(CXXStaticCastExpr *E) {
1265   VisitCXXNamedCastExpr(E);
1266   Code = serialization::EXPR_CXX_STATIC_CAST;
1267 }
1268 
1269 void ASTStmtWriter::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E) {
1270   VisitCXXNamedCastExpr(E);
1271   Code = serialization::EXPR_CXX_DYNAMIC_CAST;
1272 }
1273 
1274 void ASTStmtWriter::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E) {
1275   VisitCXXNamedCastExpr(E);
1276   Code = serialization::EXPR_CXX_REINTERPRET_CAST;
1277 }
1278 
1279 void ASTStmtWriter::VisitCXXConstCastExpr(CXXConstCastExpr *E) {
1280   VisitCXXNamedCastExpr(E);
1281   Code = serialization::EXPR_CXX_CONST_CAST;
1282 }
1283 
1284 void ASTStmtWriter::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) {
1285   VisitExplicitCastExpr(E);
1286   Writer.AddSourceLocation(E->getLParenLoc(), Record);
1287   Writer.AddSourceLocation(E->getRParenLoc(), Record);
1288   Code = serialization::EXPR_CXX_FUNCTIONAL_CAST;
1289 }
1290 
1291 void ASTStmtWriter::VisitUserDefinedLiteral(UserDefinedLiteral *E) {
1292   VisitCallExpr(E);
1293   Writer.AddSourceLocation(E->UDSuffixLoc, Record);
1294   Code = serialization::EXPR_USER_DEFINED_LITERAL;
1295 }
1296 
1297 void ASTStmtWriter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
1298   VisitExpr(E);
1299   Record.push_back(E->getValue());
1300   Writer.AddSourceLocation(E->getLocation(), Record);
1301   Code = serialization::EXPR_CXX_BOOL_LITERAL;
1302 }
1303 
1304 void ASTStmtWriter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {
1305   VisitExpr(E);
1306   Writer.AddSourceLocation(E->getLocation(), Record);
1307   Code = serialization::EXPR_CXX_NULL_PTR_LITERAL;
1308 }
1309 
1310 void ASTStmtWriter::VisitCXXTypeidExpr(CXXTypeidExpr *E) {
1311   VisitExpr(E);
1312   Writer.AddSourceRange(E->getSourceRange(), Record);
1313   if (E->isTypeOperand()) {
1314     Writer.AddTypeSourceInfo(E->getTypeOperandSourceInfo(), Record);
1315     Code = serialization::EXPR_CXX_TYPEID_TYPE;
1316   } else {
1317     Writer.AddStmt(E->getExprOperand());
1318     Code = serialization::EXPR_CXX_TYPEID_EXPR;
1319   }
1320 }
1321 
1322 void ASTStmtWriter::VisitCXXThisExpr(CXXThisExpr *E) {
1323   VisitExpr(E);
1324   Writer.AddSourceLocation(E->getLocation(), Record);
1325   Record.push_back(E->isImplicit());
1326   Code = serialization::EXPR_CXX_THIS;
1327 }
1328 
1329 void ASTStmtWriter::VisitCXXThrowExpr(CXXThrowExpr *E) {
1330   VisitExpr(E);
1331   Writer.AddSourceLocation(E->getThrowLoc(), Record);
1332   Writer.AddStmt(E->getSubExpr());
1333   Record.push_back(E->isThrownVariableInScope());
1334   Code = serialization::EXPR_CXX_THROW;
1335 }
1336 
1337 void ASTStmtWriter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
1338   VisitExpr(E);
1339   Writer.AddDeclRef(E->getParam(), Record);
1340   Writer.AddSourceLocation(E->getUsedLocation(), Record);
1341   Code = serialization::EXPR_CXX_DEFAULT_ARG;
1342 }
1343 
1344 void ASTStmtWriter::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
1345   VisitExpr(E);
1346   Writer.AddDeclRef(E->getField(), Record);
1347   Writer.AddSourceLocation(E->getExprLoc(), Record);
1348   Code = serialization::EXPR_CXX_DEFAULT_INIT;
1349 }
1350 
1351 void ASTStmtWriter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
1352   VisitExpr(E);
1353   Writer.AddCXXTemporary(E->getTemporary(), Record);
1354   Writer.AddStmt(E->getSubExpr());
1355   Code = serialization::EXPR_CXX_BIND_TEMPORARY;
1356 }
1357 
1358 void ASTStmtWriter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
1359   VisitExpr(E);
1360   Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record);
1361   Writer.AddSourceLocation(E->getRParenLoc(), Record);
1362   Code = serialization::EXPR_CXX_SCALAR_VALUE_INIT;
1363 }
1364 
1365 void ASTStmtWriter::VisitCXXNewExpr(CXXNewExpr *E) {
1366   VisitExpr(E);
1367   Record.push_back(E->isGlobalNew());
1368   Record.push_back(E->isArray());
1369   Record.push_back(E->doesUsualArrayDeleteWantSize());
1370   Record.push_back(E->getNumPlacementArgs());
1371   Record.push_back(E->StoredInitializationStyle);
1372   Writer.AddDeclRef(E->getOperatorNew(), Record);
1373   Writer.AddDeclRef(E->getOperatorDelete(), Record);
1374   Writer.AddTypeSourceInfo(E->getAllocatedTypeSourceInfo(), Record);
1375   Writer.AddSourceRange(E->getTypeIdParens(), Record);
1376   Writer.AddSourceRange(E->getSourceRange(), Record);
1377   Writer.AddSourceRange(E->getDirectInitRange(), Record);
1378   for (CXXNewExpr::arg_iterator I = E->raw_arg_begin(), e = E->raw_arg_end();
1379        I != e; ++I)
1380     Writer.AddStmt(*I);
1381 
1382   Code = serialization::EXPR_CXX_NEW;
1383 }
1384 
1385 void ASTStmtWriter::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
1386   VisitExpr(E);
1387   Record.push_back(E->isGlobalDelete());
1388   Record.push_back(E->isArrayForm());
1389   Record.push_back(E->isArrayFormAsWritten());
1390   Record.push_back(E->doesUsualArrayDeleteWantSize());
1391   Writer.AddDeclRef(E->getOperatorDelete(), Record);
1392   Writer.AddStmt(E->getArgument());
1393   Writer.AddSourceLocation(E->getSourceRange().getBegin(), Record);
1394 
1395   Code = serialization::EXPR_CXX_DELETE;
1396 }
1397 
1398 void ASTStmtWriter::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) {
1399   VisitExpr(E);
1400 
1401   Writer.AddStmt(E->getBase());
1402   Record.push_back(E->isArrow());
1403   Writer.AddSourceLocation(E->getOperatorLoc(), Record);
1404   Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record);
1405   Writer.AddTypeSourceInfo(E->getScopeTypeInfo(), Record);
1406   Writer.AddSourceLocation(E->getColonColonLoc(), Record);
1407   Writer.AddSourceLocation(E->getTildeLoc(), Record);
1408 
1409   // PseudoDestructorTypeStorage.
1410   Writer.AddIdentifierRef(E->getDestroyedTypeIdentifier(), Record);
1411   if (E->getDestroyedTypeIdentifier())
1412     Writer.AddSourceLocation(E->getDestroyedTypeLoc(), Record);
1413   else
1414     Writer.AddTypeSourceInfo(E->getDestroyedTypeInfo(), Record);
1415 
1416   Code = serialization::EXPR_CXX_PSEUDO_DESTRUCTOR;
1417 }
1418 
1419 void ASTStmtWriter::VisitExprWithCleanups(ExprWithCleanups *E) {
1420   VisitExpr(E);
1421   Record.push_back(E->getNumObjects());
1422   for (unsigned i = 0, e = E->getNumObjects(); i != e; ++i)
1423     Writer.AddDeclRef(E->getObject(i), Record);
1424 
1425   Writer.AddStmt(E->getSubExpr());
1426   Code = serialization::EXPR_EXPR_WITH_CLEANUPS;
1427 }
1428 
1429 void
1430 ASTStmtWriter::VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E){
1431   VisitExpr(E);
1432 
1433   // Don't emit anything here, HasTemplateKWAndArgsInfo must be
1434   // emitted first.
1435 
1436   Record.push_back(E->HasTemplateKWAndArgsInfo);
1437   if (E->HasTemplateKWAndArgsInfo) {
1438     const ASTTemplateKWAndArgsInfo &ArgInfo =
1439         *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>();
1440     Record.push_back(ArgInfo.NumTemplateArgs);
1441     AddTemplateKWAndArgsInfo(ArgInfo,
1442                              E->getTrailingObjects<TemplateArgumentLoc>());
1443   }
1444 
1445   if (!E->isImplicitAccess())
1446     Writer.AddStmt(E->getBase());
1447   else
1448     Writer.AddStmt(nullptr);
1449   Writer.AddTypeRef(E->getBaseType(), Record);
1450   Record.push_back(E->isArrow());
1451   Writer.AddSourceLocation(E->getOperatorLoc(), Record);
1452   Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record);
1453   Writer.AddDeclRef(E->getFirstQualifierFoundInScope(), Record);
1454   Writer.AddDeclarationNameInfo(E->MemberNameInfo, Record);
1455   Code = serialization::EXPR_CXX_DEPENDENT_SCOPE_MEMBER;
1456 }
1457 
1458 void
1459 ASTStmtWriter::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
1460   VisitExpr(E);
1461 
1462   // Don't emit anything here, HasTemplateKWAndArgsInfo must be
1463   // emitted first.
1464 
1465   Record.push_back(E->HasTemplateKWAndArgsInfo);
1466   if (E->HasTemplateKWAndArgsInfo) {
1467     const ASTTemplateKWAndArgsInfo &ArgInfo =
1468         *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>();
1469     Record.push_back(ArgInfo.NumTemplateArgs);
1470     AddTemplateKWAndArgsInfo(ArgInfo,
1471                              E->getTrailingObjects<TemplateArgumentLoc>());
1472   }
1473 
1474   Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record);
1475   Writer.AddDeclarationNameInfo(E->NameInfo, Record);
1476   Code = serialization::EXPR_CXX_DEPENDENT_SCOPE_DECL_REF;
1477 }
1478 
1479 void
1480 ASTStmtWriter::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) {
1481   VisitExpr(E);
1482   Record.push_back(E->arg_size());
1483   for (CXXUnresolvedConstructExpr::arg_iterator
1484          ArgI = E->arg_begin(), ArgE = E->arg_end(); ArgI != ArgE; ++ArgI)
1485     Writer.AddStmt(*ArgI);
1486   Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record);
1487   Writer.AddSourceLocation(E->getLParenLoc(), Record);
1488   Writer.AddSourceLocation(E->getRParenLoc(), Record);
1489   Code = serialization::EXPR_CXX_UNRESOLVED_CONSTRUCT;
1490 }
1491 
1492 void ASTStmtWriter::VisitOverloadExpr(OverloadExpr *E) {
1493   VisitExpr(E);
1494 
1495   // Don't emit anything here, HasTemplateKWAndArgsInfo must be
1496   // emitted first.
1497 
1498   Record.push_back(E->HasTemplateKWAndArgsInfo);
1499   if (E->HasTemplateKWAndArgsInfo) {
1500     const ASTTemplateKWAndArgsInfo &ArgInfo =
1501         *E->getTrailingASTTemplateKWAndArgsInfo();
1502     Record.push_back(ArgInfo.NumTemplateArgs);
1503     AddTemplateKWAndArgsInfo(ArgInfo, E->getTrailingTemplateArgumentLoc());
1504   }
1505 
1506   Record.push_back(E->getNumDecls());
1507   for (OverloadExpr::decls_iterator
1508          OvI = E->decls_begin(), OvE = E->decls_end(); OvI != OvE; ++OvI) {
1509     Writer.AddDeclRef(OvI.getDecl(), Record);
1510     Record.push_back(OvI.getAccess());
1511   }
1512 
1513   Writer.AddDeclarationNameInfo(E->NameInfo, Record);
1514   Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record);
1515 }
1516 
1517 void ASTStmtWriter::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) {
1518   VisitOverloadExpr(E);
1519   Record.push_back(E->isArrow());
1520   Record.push_back(E->hasUnresolvedUsing());
1521   Writer.AddStmt(!E->isImplicitAccess() ? E->getBase() : nullptr);
1522   Writer.AddTypeRef(E->getBaseType(), Record);
1523   Writer.AddSourceLocation(E->getOperatorLoc(), Record);
1524   Code = serialization::EXPR_CXX_UNRESOLVED_MEMBER;
1525 }
1526 
1527 void ASTStmtWriter::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
1528   VisitOverloadExpr(E);
1529   Record.push_back(E->requiresADL());
1530   Record.push_back(E->isOverloaded());
1531   Writer.AddDeclRef(E->getNamingClass(), Record);
1532   Code = serialization::EXPR_CXX_UNRESOLVED_LOOKUP;
1533 }
1534 
1535 void ASTStmtWriter::VisitTypeTraitExpr(TypeTraitExpr *E) {
1536   VisitExpr(E);
1537   Record.push_back(E->TypeTraitExprBits.NumArgs);
1538   Record.push_back(E->TypeTraitExprBits.Kind); // FIXME: Stable encoding
1539   Record.push_back(E->TypeTraitExprBits.Value);
1540   Writer.AddSourceRange(E->getSourceRange(), Record);
1541   for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
1542     Writer.AddTypeSourceInfo(E->getArg(I), Record);
1543   Code = serialization::EXPR_TYPE_TRAIT;
1544 }
1545 
1546 void ASTStmtWriter::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
1547   VisitExpr(E);
1548   Record.push_back(E->getTrait());
1549   Record.push_back(E->getValue());
1550   Writer.AddSourceRange(E->getSourceRange(), Record);
1551   Writer.AddTypeSourceInfo(E->getQueriedTypeSourceInfo(), Record);
1552   Code = serialization::EXPR_ARRAY_TYPE_TRAIT;
1553 }
1554 
1555 void ASTStmtWriter::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
1556   VisitExpr(E);
1557   Record.push_back(E->getTrait());
1558   Record.push_back(E->getValue());
1559   Writer.AddSourceRange(E->getSourceRange(), Record);
1560   Writer.AddStmt(E->getQueriedExpression());
1561   Code = serialization::EXPR_CXX_EXPRESSION_TRAIT;
1562 }
1563 
1564 void ASTStmtWriter::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
1565   VisitExpr(E);
1566   Record.push_back(E->getValue());
1567   Writer.AddSourceRange(E->getSourceRange(), Record);
1568   Writer.AddStmt(E->getOperand());
1569   Code = serialization::EXPR_CXX_NOEXCEPT;
1570 }
1571 
1572 void ASTStmtWriter::VisitPackExpansionExpr(PackExpansionExpr *E) {
1573   VisitExpr(E);
1574   Writer.AddSourceLocation(E->getEllipsisLoc(), Record);
1575   Record.push_back(E->NumExpansions);
1576   Writer.AddStmt(E->getPattern());
1577   Code = serialization::EXPR_PACK_EXPANSION;
1578 }
1579 
1580 void ASTStmtWriter::VisitSizeOfPackExpr(SizeOfPackExpr *E) {
1581   VisitExpr(E);
1582   Record.push_back(E->isPartiallySubstituted() ? E->getPartialArguments().size()
1583                                                : 0);
1584   Writer.AddSourceLocation(E->OperatorLoc, Record);
1585   Writer.AddSourceLocation(E->PackLoc, Record);
1586   Writer.AddSourceLocation(E->RParenLoc, Record);
1587   Writer.AddDeclRef(E->Pack, Record);
1588   if (E->isPartiallySubstituted()) {
1589     for (const auto &TA : E->getPartialArguments())
1590       Writer.AddTemplateArgument(TA, Record);
1591   } else if (!E->isValueDependent()) {
1592     Record.push_back(E->getPackLength());
1593   }
1594   Code = serialization::EXPR_SIZEOF_PACK;
1595 }
1596 
1597 void ASTStmtWriter::VisitSubstNonTypeTemplateParmExpr(
1598                                               SubstNonTypeTemplateParmExpr *E) {
1599   VisitExpr(E);
1600   Writer.AddDeclRef(E->getParameter(), Record);
1601   Writer.AddSourceLocation(E->getNameLoc(), Record);
1602   Writer.AddStmt(E->getReplacement());
1603   Code = serialization::EXPR_SUBST_NON_TYPE_TEMPLATE_PARM;
1604 }
1605 
1606 void ASTStmtWriter::VisitSubstNonTypeTemplateParmPackExpr(
1607                                           SubstNonTypeTemplateParmPackExpr *E) {
1608   VisitExpr(E);
1609   Writer.AddDeclRef(E->getParameterPack(), Record);
1610   Writer.AddTemplateArgument(E->getArgumentPack(), Record);
1611   Writer.AddSourceLocation(E->getParameterPackLocation(), Record);
1612   Code = serialization::EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK;
1613 }
1614 
1615 void ASTStmtWriter::VisitFunctionParmPackExpr(FunctionParmPackExpr *E) {
1616   VisitExpr(E);
1617   Record.push_back(E->getNumExpansions());
1618   Writer.AddDeclRef(E->getParameterPack(), Record);
1619   Writer.AddSourceLocation(E->getParameterPackLocation(), Record);
1620   for (FunctionParmPackExpr::iterator I = E->begin(), End = E->end();
1621        I != End; ++I)
1622     Writer.AddDeclRef(*I, Record);
1623   Code = serialization::EXPR_FUNCTION_PARM_PACK;
1624 }
1625 
1626 void ASTStmtWriter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
1627   VisitExpr(E);
1628   Writer.AddStmt(E->getTemporary());
1629   Writer.AddDeclRef(E->getExtendingDecl(), Record);
1630   Record.push_back(E->getManglingNumber());
1631   Code = serialization::EXPR_MATERIALIZE_TEMPORARY;
1632 }
1633 
1634 void ASTStmtWriter::VisitCXXFoldExpr(CXXFoldExpr *E) {
1635   VisitExpr(E);
1636   Writer.AddSourceLocation(E->LParenLoc, Record);
1637   Writer.AddSourceLocation(E->EllipsisLoc, Record);
1638   Writer.AddSourceLocation(E->RParenLoc, Record);
1639   Writer.AddStmt(E->SubExprs[0]);
1640   Writer.AddStmt(E->SubExprs[1]);
1641   Record.push_back(E->Opcode);
1642   Code = serialization::EXPR_CXX_FOLD;
1643 }
1644 
1645 void ASTStmtWriter::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
1646   VisitExpr(E);
1647   Writer.AddStmt(E->getSourceExpr());
1648   Writer.AddSourceLocation(E->getLocation(), Record);
1649   Code = serialization::EXPR_OPAQUE_VALUE;
1650 }
1651 
1652 void ASTStmtWriter::VisitTypoExpr(TypoExpr *E) {
1653   VisitExpr(E);
1654   // TODO: Figure out sane writer behavior for a TypoExpr, if necessary
1655   llvm_unreachable("Cannot write TypoExpr nodes");
1656 }
1657 
1658 //===----------------------------------------------------------------------===//
1659 // CUDA Expressions and Statements.
1660 //===----------------------------------------------------------------------===//
1661 
1662 void ASTStmtWriter::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *E) {
1663   VisitCallExpr(E);
1664   Writer.AddStmt(E->getConfig());
1665   Code = serialization::EXPR_CUDA_KERNEL_CALL;
1666 }
1667 
1668 //===----------------------------------------------------------------------===//
1669 // OpenCL Expressions and Statements.
1670 //===----------------------------------------------------------------------===//
1671 void ASTStmtWriter::VisitAsTypeExpr(AsTypeExpr *E) {
1672   VisitExpr(E);
1673   Writer.AddSourceLocation(E->getBuiltinLoc(), Record);
1674   Writer.AddSourceLocation(E->getRParenLoc(), Record);
1675   Writer.AddStmt(E->getSrcExpr());
1676   Code = serialization::EXPR_ASTYPE;
1677 }
1678 
1679 //===----------------------------------------------------------------------===//
1680 // Microsoft Expressions and Statements.
1681 //===----------------------------------------------------------------------===//
1682 void ASTStmtWriter::VisitMSPropertyRefExpr(MSPropertyRefExpr *E) {
1683   VisitExpr(E);
1684   Record.push_back(E->isArrow());
1685   Writer.AddStmt(E->getBaseExpr());
1686   Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record);
1687   Writer.AddSourceLocation(E->getMemberLoc(), Record);
1688   Writer.AddDeclRef(E->getPropertyDecl(), Record);
1689   Code = serialization::EXPR_CXX_PROPERTY_REF_EXPR;
1690 }
1691 
1692 void ASTStmtWriter::VisitMSPropertySubscriptExpr(MSPropertySubscriptExpr *E) {
1693   VisitExpr(E);
1694   Writer.AddStmt(E->getBase());
1695   Writer.AddStmt(E->getIdx());
1696   Writer.AddSourceLocation(E->getRBracketLoc(), Record);
1697   Code = serialization::EXPR_CXX_PROPERTY_SUBSCRIPT_EXPR;
1698 }
1699 
1700 void ASTStmtWriter::VisitCXXUuidofExpr(CXXUuidofExpr *E) {
1701   VisitExpr(E);
1702   Writer.AddSourceRange(E->getSourceRange(), Record);
1703   if (E->isTypeOperand()) {
1704     Writer.AddTypeSourceInfo(E->getTypeOperandSourceInfo(), Record);
1705     Code = serialization::EXPR_CXX_UUIDOF_TYPE;
1706   } else {
1707     Writer.AddStmt(E->getExprOperand());
1708     Code = serialization::EXPR_CXX_UUIDOF_EXPR;
1709   }
1710 }
1711 
1712 void ASTStmtWriter::VisitSEHExceptStmt(SEHExceptStmt *S) {
1713   VisitStmt(S);
1714   Writer.AddSourceLocation(S->getExceptLoc(), Record);
1715   Writer.AddStmt(S->getFilterExpr());
1716   Writer.AddStmt(S->getBlock());
1717   Code = serialization::STMT_SEH_EXCEPT;
1718 }
1719 
1720 void ASTStmtWriter::VisitSEHFinallyStmt(SEHFinallyStmt *S) {
1721   VisitStmt(S);
1722   Writer.AddSourceLocation(S->getFinallyLoc(), Record);
1723   Writer.AddStmt(S->getBlock());
1724   Code = serialization::STMT_SEH_FINALLY;
1725 }
1726 
1727 void ASTStmtWriter::VisitSEHTryStmt(SEHTryStmt *S) {
1728   VisitStmt(S);
1729   Record.push_back(S->getIsCXXTry());
1730   Writer.AddSourceLocation(S->getTryLoc(), Record);
1731   Writer.AddStmt(S->getTryBlock());
1732   Writer.AddStmt(S->getHandler());
1733   Code = serialization::STMT_SEH_TRY;
1734 }
1735 
1736 void ASTStmtWriter::VisitSEHLeaveStmt(SEHLeaveStmt *S) {
1737   VisitStmt(S);
1738   Writer.AddSourceLocation(S->getLeaveLoc(), Record);
1739   Code = serialization::STMT_SEH_LEAVE;
1740 }
1741 
1742 //===----------------------------------------------------------------------===//
1743 // OpenMP Clauses.
1744 //===----------------------------------------------------------------------===//
1745 
1746 namespace clang {
1747 class OMPClauseWriter : public OMPClauseVisitor<OMPClauseWriter> {
1748   ASTStmtWriter *Writer;
1749   ASTWriter::RecordData &Record;
1750 public:
1751   OMPClauseWriter(ASTStmtWriter *W, ASTWriter::RecordData &Record)
1752     : Writer(W), Record(Record) { }
1753 #define OPENMP_CLAUSE(Name, Class)    \
1754   void Visit##Class(Class *S);
1755 #include "clang/Basic/OpenMPKinds.def"
1756   void writeClause(OMPClause *C);
1757   void VisitOMPClauseWithPreInit(OMPClauseWithPreInit *C);
1758 };
1759 }
1760 
1761 void OMPClauseWriter::writeClause(OMPClause *C) {
1762   Record.push_back(C->getClauseKind());
1763   Visit(C);
1764   Writer->Writer.AddSourceLocation(C->getLocStart(), Record);
1765   Writer->Writer.AddSourceLocation(C->getLocEnd(), Record);
1766 }
1767 
1768 void OMPClauseWriter::VisitOMPClauseWithPreInit(OMPClauseWithPreInit *C) {
1769   Writer->Writer.AddStmt(C->getPreInitStmt());
1770 }
1771 
1772 void OMPClauseWriter::VisitOMPIfClause(OMPIfClause *C) {
1773   Record.push_back(C->getNameModifier());
1774   Writer->Writer.AddSourceLocation(C->getNameModifierLoc(), Record);
1775   Writer->Writer.AddSourceLocation(C->getColonLoc(), Record);
1776   Writer->Writer.AddStmt(C->getCondition());
1777   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1778 }
1779 
1780 void OMPClauseWriter::VisitOMPFinalClause(OMPFinalClause *C) {
1781   Writer->Writer.AddStmt(C->getCondition());
1782   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1783 }
1784 
1785 void OMPClauseWriter::VisitOMPNumThreadsClause(OMPNumThreadsClause *C) {
1786   Writer->Writer.AddStmt(C->getNumThreads());
1787   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1788 }
1789 
1790 void OMPClauseWriter::VisitOMPSafelenClause(OMPSafelenClause *C) {
1791   Writer->Writer.AddStmt(C->getSafelen());
1792   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1793 }
1794 
1795 void OMPClauseWriter::VisitOMPSimdlenClause(OMPSimdlenClause *C) {
1796   Writer->Writer.AddStmt(C->getSimdlen());
1797   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1798 }
1799 
1800 void OMPClauseWriter::VisitOMPCollapseClause(OMPCollapseClause *C) {
1801   Writer->Writer.AddStmt(C->getNumForLoops());
1802   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1803 }
1804 
1805 void OMPClauseWriter::VisitOMPDefaultClause(OMPDefaultClause *C) {
1806   Record.push_back(C->getDefaultKind());
1807   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1808   Writer->Writer.AddSourceLocation(C->getDefaultKindKwLoc(), Record);
1809 }
1810 
1811 void OMPClauseWriter::VisitOMPProcBindClause(OMPProcBindClause *C) {
1812   Record.push_back(C->getProcBindKind());
1813   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1814   Writer->Writer.AddSourceLocation(C->getProcBindKindKwLoc(), Record);
1815 }
1816 
1817 void OMPClauseWriter::VisitOMPScheduleClause(OMPScheduleClause *C) {
1818   VisitOMPClauseWithPreInit(C);
1819   Record.push_back(C->getScheduleKind());
1820   Record.push_back(C->getFirstScheduleModifier());
1821   Record.push_back(C->getSecondScheduleModifier());
1822   Writer->Writer.AddStmt(C->getChunkSize());
1823   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1824   Writer->Writer.AddSourceLocation(C->getFirstScheduleModifierLoc(), Record);
1825   Writer->Writer.AddSourceLocation(C->getSecondScheduleModifierLoc(), Record);
1826   Writer->Writer.AddSourceLocation(C->getScheduleKindLoc(), Record);
1827   Writer->Writer.AddSourceLocation(C->getCommaLoc(), Record);
1828 }
1829 
1830 void OMPClauseWriter::VisitOMPOrderedClause(OMPOrderedClause *C) {
1831   Writer->Writer.AddStmt(C->getNumForLoops());
1832   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1833 }
1834 
1835 void OMPClauseWriter::VisitOMPNowaitClause(OMPNowaitClause *) {}
1836 
1837 void OMPClauseWriter::VisitOMPUntiedClause(OMPUntiedClause *) {}
1838 
1839 void OMPClauseWriter::VisitOMPMergeableClause(OMPMergeableClause *) {}
1840 
1841 void OMPClauseWriter::VisitOMPReadClause(OMPReadClause *) {}
1842 
1843 void OMPClauseWriter::VisitOMPWriteClause(OMPWriteClause *) {}
1844 
1845 void OMPClauseWriter::VisitOMPUpdateClause(OMPUpdateClause *) {}
1846 
1847 void OMPClauseWriter::VisitOMPCaptureClause(OMPCaptureClause *) {}
1848 
1849 void OMPClauseWriter::VisitOMPSeqCstClause(OMPSeqCstClause *) {}
1850 
1851 void OMPClauseWriter::VisitOMPThreadsClause(OMPThreadsClause *) {}
1852 
1853 void OMPClauseWriter::VisitOMPSIMDClause(OMPSIMDClause *) {}
1854 
1855 void OMPClauseWriter::VisitOMPNogroupClause(OMPNogroupClause *) {}
1856 
1857 void OMPClauseWriter::VisitOMPPrivateClause(OMPPrivateClause *C) {
1858   Record.push_back(C->varlist_size());
1859   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1860   for (auto *VE : C->varlists()) {
1861     Writer->Writer.AddStmt(VE);
1862   }
1863   for (auto *VE : C->private_copies()) {
1864     Writer->Writer.AddStmt(VE);
1865   }
1866 }
1867 
1868 void OMPClauseWriter::VisitOMPFirstprivateClause(OMPFirstprivateClause *C) {
1869   Record.push_back(C->varlist_size());
1870   VisitOMPClauseWithPreInit(C);
1871   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1872   for (auto *VE : C->varlists()) {
1873     Writer->Writer.AddStmt(VE);
1874   }
1875   for (auto *VE : C->private_copies()) {
1876     Writer->Writer.AddStmt(VE);
1877   }
1878   for (auto *VE : C->inits()) {
1879     Writer->Writer.AddStmt(VE);
1880   }
1881 }
1882 
1883 void OMPClauseWriter::VisitOMPLastprivateClause(OMPLastprivateClause *C) {
1884   Record.push_back(C->varlist_size());
1885   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1886   for (auto *VE : C->varlists())
1887     Writer->Writer.AddStmt(VE);
1888   for (auto *E : C->private_copies())
1889     Writer->Writer.AddStmt(E);
1890   for (auto *E : C->source_exprs())
1891     Writer->Writer.AddStmt(E);
1892   for (auto *E : C->destination_exprs())
1893     Writer->Writer.AddStmt(E);
1894   for (auto *E : C->assignment_ops())
1895     Writer->Writer.AddStmt(E);
1896 }
1897 
1898 void OMPClauseWriter::VisitOMPSharedClause(OMPSharedClause *C) {
1899   Record.push_back(C->varlist_size());
1900   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1901   for (auto *VE : C->varlists())
1902     Writer->Writer.AddStmt(VE);
1903 }
1904 
1905 void OMPClauseWriter::VisitOMPReductionClause(OMPReductionClause *C) {
1906   Record.push_back(C->varlist_size());
1907   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1908   Writer->Writer.AddSourceLocation(C->getColonLoc(), Record);
1909   Writer->Writer.AddNestedNameSpecifierLoc(C->getQualifierLoc(), Record);
1910   Writer->Writer.AddDeclarationNameInfo(C->getNameInfo(), Record);
1911   for (auto *VE : C->varlists())
1912     Writer->Writer.AddStmt(VE);
1913   for (auto *VE : C->privates())
1914     Writer->Writer.AddStmt(VE);
1915   for (auto *E : C->lhs_exprs())
1916     Writer->Writer.AddStmt(E);
1917   for (auto *E : C->rhs_exprs())
1918     Writer->Writer.AddStmt(E);
1919   for (auto *E : C->reduction_ops())
1920     Writer->Writer.AddStmt(E);
1921 }
1922 
1923 void OMPClauseWriter::VisitOMPLinearClause(OMPLinearClause *C) {
1924   Record.push_back(C->varlist_size());
1925   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1926   Writer->Writer.AddSourceLocation(C->getColonLoc(), Record);
1927   Record.push_back(C->getModifier());
1928   Writer->Writer.AddSourceLocation(C->getModifierLoc(), Record);
1929   for (auto *VE : C->varlists()) {
1930     Writer->Writer.AddStmt(VE);
1931   }
1932   for (auto *VE : C->privates()) {
1933     Writer->Writer.AddStmt(VE);
1934   }
1935   for (auto *VE : C->inits()) {
1936     Writer->Writer.AddStmt(VE);
1937   }
1938   for (auto *VE : C->updates()) {
1939     Writer->Writer.AddStmt(VE);
1940   }
1941   for (auto *VE : C->finals()) {
1942     Writer->Writer.AddStmt(VE);
1943   }
1944   Writer->Writer.AddStmt(C->getStep());
1945   Writer->Writer.AddStmt(C->getCalcStep());
1946 }
1947 
1948 void OMPClauseWriter::VisitOMPAlignedClause(OMPAlignedClause *C) {
1949   Record.push_back(C->varlist_size());
1950   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1951   Writer->Writer.AddSourceLocation(C->getColonLoc(), Record);
1952   for (auto *VE : C->varlists())
1953     Writer->Writer.AddStmt(VE);
1954   Writer->Writer.AddStmt(C->getAlignment());
1955 }
1956 
1957 void OMPClauseWriter::VisitOMPCopyinClause(OMPCopyinClause *C) {
1958   Record.push_back(C->varlist_size());
1959   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1960   for (auto *VE : C->varlists())
1961     Writer->Writer.AddStmt(VE);
1962   for (auto *E : C->source_exprs())
1963     Writer->Writer.AddStmt(E);
1964   for (auto *E : C->destination_exprs())
1965     Writer->Writer.AddStmt(E);
1966   for (auto *E : C->assignment_ops())
1967     Writer->Writer.AddStmt(E);
1968 }
1969 
1970 void OMPClauseWriter::VisitOMPCopyprivateClause(OMPCopyprivateClause *C) {
1971   Record.push_back(C->varlist_size());
1972   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1973   for (auto *VE : C->varlists())
1974     Writer->Writer.AddStmt(VE);
1975   for (auto *E : C->source_exprs())
1976     Writer->Writer.AddStmt(E);
1977   for (auto *E : C->destination_exprs())
1978     Writer->Writer.AddStmt(E);
1979   for (auto *E : C->assignment_ops())
1980     Writer->Writer.AddStmt(E);
1981 }
1982 
1983 void OMPClauseWriter::VisitOMPFlushClause(OMPFlushClause *C) {
1984   Record.push_back(C->varlist_size());
1985   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1986   for (auto *VE : C->varlists())
1987     Writer->Writer.AddStmt(VE);
1988 }
1989 
1990 void OMPClauseWriter::VisitOMPDependClause(OMPDependClause *C) {
1991   Record.push_back(C->varlist_size());
1992   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1993   Record.push_back(C->getDependencyKind());
1994   Writer->Writer.AddSourceLocation(C->getDependencyLoc(), Record);
1995   Writer->Writer.AddSourceLocation(C->getColonLoc(), Record);
1996   for (auto *VE : C->varlists())
1997     Writer->Writer.AddStmt(VE);
1998 }
1999 
2000 void OMPClauseWriter::VisitOMPDeviceClause(OMPDeviceClause *C) {
2001   Writer->Writer.AddStmt(C->getDevice());
2002   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
2003 }
2004 
2005 void OMPClauseWriter::VisitOMPMapClause(OMPMapClause *C) {
2006   Record.push_back(C->varlist_size());
2007   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
2008   Record.push_back(C->getMapTypeModifier());
2009   Record.push_back(C->getMapType());
2010   Writer->Writer.AddSourceLocation(C->getMapLoc(), Record);
2011   Writer->Writer.AddSourceLocation(C->getColonLoc(), Record);
2012   for (auto *VE : C->varlists())
2013     Writer->Writer.AddStmt(VE);
2014 }
2015 
2016 void OMPClauseWriter::VisitOMPNumTeamsClause(OMPNumTeamsClause *C) {
2017   Writer->Writer.AddStmt(C->getNumTeams());
2018   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
2019 }
2020 
2021 void OMPClauseWriter::VisitOMPThreadLimitClause(OMPThreadLimitClause *C) {
2022   Writer->Writer.AddStmt(C->getThreadLimit());
2023   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
2024 }
2025 
2026 void OMPClauseWriter::VisitOMPPriorityClause(OMPPriorityClause *C) {
2027   Writer->Writer.AddStmt(C->getPriority());
2028   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
2029 }
2030 
2031 void OMPClauseWriter::VisitOMPGrainsizeClause(OMPGrainsizeClause *C) {
2032   Writer->Writer.AddStmt(C->getGrainsize());
2033   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
2034 }
2035 
2036 void OMPClauseWriter::VisitOMPNumTasksClause(OMPNumTasksClause *C) {
2037   Writer->Writer.AddStmt(C->getNumTasks());
2038   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
2039 }
2040 
2041 void OMPClauseWriter::VisitOMPHintClause(OMPHintClause *C) {
2042   Writer->Writer.AddStmt(C->getHint());
2043   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
2044 }
2045 
2046 void OMPClauseWriter::VisitOMPDistScheduleClause(OMPDistScheduleClause *C) {
2047   VisitOMPClauseWithPreInit(C);
2048   Record.push_back(C->getDistScheduleKind());
2049   Writer->Writer.AddStmt(C->getChunkSize());
2050   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
2051   Writer->Writer.AddSourceLocation(C->getDistScheduleKindLoc(), Record);
2052   Writer->Writer.AddSourceLocation(C->getCommaLoc(), Record);
2053 }
2054 
2055 void OMPClauseWriter::VisitOMPDefaultmapClause(OMPDefaultmapClause *C) {
2056   Record.push_back(C->getDefaultmapKind());
2057   Record.push_back(C->getDefaultmapModifier());
2058   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
2059   Writer->Writer.AddSourceLocation(C->getDefaultmapModifierLoc(), Record);
2060   Writer->Writer.AddSourceLocation(C->getDefaultmapKindLoc(), Record);
2061 }
2062 
2063 //===----------------------------------------------------------------------===//
2064 // OpenMP Directives.
2065 //===----------------------------------------------------------------------===//
2066 void ASTStmtWriter::VisitOMPExecutableDirective(OMPExecutableDirective *E) {
2067   Writer.AddSourceLocation(E->getLocStart(), Record);
2068   Writer.AddSourceLocation(E->getLocEnd(), Record);
2069   OMPClauseWriter ClauseWriter(this, Record);
2070   for (unsigned i = 0; i < E->getNumClauses(); ++i) {
2071     ClauseWriter.writeClause(E->getClause(i));
2072   }
2073   if (E->hasAssociatedStmt())
2074     Writer.AddStmt(E->getAssociatedStmt());
2075 }
2076 
2077 void ASTStmtWriter::VisitOMPLoopDirective(OMPLoopDirective *D) {
2078   VisitStmt(D);
2079   Record.push_back(D->getNumClauses());
2080   Record.push_back(D->getCollapsedNumber());
2081   VisitOMPExecutableDirective(D);
2082   Writer.AddStmt(D->getIterationVariable());
2083   Writer.AddStmt(D->getLastIteration());
2084   Writer.AddStmt(D->getCalcLastIteration());
2085   Writer.AddStmt(D->getPreCond());
2086   Writer.AddStmt(D->getCond());
2087   Writer.AddStmt(D->getInit());
2088   Writer.AddStmt(D->getInc());
2089   if (isOpenMPWorksharingDirective(D->getDirectiveKind()) ||
2090       isOpenMPTaskLoopDirective(D->getDirectiveKind())) {
2091     Writer.AddStmt(D->getIsLastIterVariable());
2092     Writer.AddStmt(D->getLowerBoundVariable());
2093     Writer.AddStmt(D->getUpperBoundVariable());
2094     Writer.AddStmt(D->getStrideVariable());
2095     Writer.AddStmt(D->getEnsureUpperBound());
2096     Writer.AddStmt(D->getNextLowerBound());
2097     Writer.AddStmt(D->getNextUpperBound());
2098   }
2099   for (auto I : D->counters()) {
2100     Writer.AddStmt(I);
2101   }
2102   for (auto I : D->private_counters()) {
2103     Writer.AddStmt(I);
2104   }
2105   for (auto I : D->inits()) {
2106     Writer.AddStmt(I);
2107   }
2108   for (auto I : D->updates()) {
2109     Writer.AddStmt(I);
2110   }
2111   for (auto I : D->finals()) {
2112     Writer.AddStmt(I);
2113   }
2114 }
2115 
2116 void ASTStmtWriter::VisitOMPParallelDirective(OMPParallelDirective *D) {
2117   VisitStmt(D);
2118   Record.push_back(D->getNumClauses());
2119   VisitOMPExecutableDirective(D);
2120   Record.push_back(D->hasCancel() ? 1 : 0);
2121   Code = serialization::STMT_OMP_PARALLEL_DIRECTIVE;
2122 }
2123 
2124 void ASTStmtWriter::VisitOMPSimdDirective(OMPSimdDirective *D) {
2125   VisitOMPLoopDirective(D);
2126   Code = serialization::STMT_OMP_SIMD_DIRECTIVE;
2127 }
2128 
2129 void ASTStmtWriter::VisitOMPForDirective(OMPForDirective *D) {
2130   VisitOMPLoopDirective(D);
2131   Record.push_back(D->hasCancel() ? 1 : 0);
2132   Code = serialization::STMT_OMP_FOR_DIRECTIVE;
2133 }
2134 
2135 void ASTStmtWriter::VisitOMPForSimdDirective(OMPForSimdDirective *D) {
2136   VisitOMPLoopDirective(D);
2137   Code = serialization::STMT_OMP_FOR_SIMD_DIRECTIVE;
2138 }
2139 
2140 void ASTStmtWriter::VisitOMPSectionsDirective(OMPSectionsDirective *D) {
2141   VisitStmt(D);
2142   Record.push_back(D->getNumClauses());
2143   VisitOMPExecutableDirective(D);
2144   Record.push_back(D->hasCancel() ? 1 : 0);
2145   Code = serialization::STMT_OMP_SECTIONS_DIRECTIVE;
2146 }
2147 
2148 void ASTStmtWriter::VisitOMPSectionDirective(OMPSectionDirective *D) {
2149   VisitStmt(D);
2150   VisitOMPExecutableDirective(D);
2151   Record.push_back(D->hasCancel() ? 1 : 0);
2152   Code = serialization::STMT_OMP_SECTION_DIRECTIVE;
2153 }
2154 
2155 void ASTStmtWriter::VisitOMPSingleDirective(OMPSingleDirective *D) {
2156   VisitStmt(D);
2157   Record.push_back(D->getNumClauses());
2158   VisitOMPExecutableDirective(D);
2159   Code = serialization::STMT_OMP_SINGLE_DIRECTIVE;
2160 }
2161 
2162 void ASTStmtWriter::VisitOMPMasterDirective(OMPMasterDirective *D) {
2163   VisitStmt(D);
2164   VisitOMPExecutableDirective(D);
2165   Code = serialization::STMT_OMP_MASTER_DIRECTIVE;
2166 }
2167 
2168 void ASTStmtWriter::VisitOMPCriticalDirective(OMPCriticalDirective *D) {
2169   VisitStmt(D);
2170   Record.push_back(D->getNumClauses());
2171   VisitOMPExecutableDirective(D);
2172   Writer.AddDeclarationNameInfo(D->getDirectiveName(), Record);
2173   Code = serialization::STMT_OMP_CRITICAL_DIRECTIVE;
2174 }
2175 
2176 void ASTStmtWriter::VisitOMPParallelForDirective(OMPParallelForDirective *D) {
2177   VisitOMPLoopDirective(D);
2178   Record.push_back(D->hasCancel() ? 1 : 0);
2179   Code = serialization::STMT_OMP_PARALLEL_FOR_DIRECTIVE;
2180 }
2181 
2182 void ASTStmtWriter::VisitOMPParallelForSimdDirective(
2183     OMPParallelForSimdDirective *D) {
2184   VisitOMPLoopDirective(D);
2185   Code = serialization::STMT_OMP_PARALLEL_FOR_SIMD_DIRECTIVE;
2186 }
2187 
2188 void ASTStmtWriter::VisitOMPParallelSectionsDirective(
2189     OMPParallelSectionsDirective *D) {
2190   VisitStmt(D);
2191   Record.push_back(D->getNumClauses());
2192   VisitOMPExecutableDirective(D);
2193   Record.push_back(D->hasCancel() ? 1 : 0);
2194   Code = serialization::STMT_OMP_PARALLEL_SECTIONS_DIRECTIVE;
2195 }
2196 
2197 void ASTStmtWriter::VisitOMPTaskDirective(OMPTaskDirective *D) {
2198   VisitStmt(D);
2199   Record.push_back(D->getNumClauses());
2200   VisitOMPExecutableDirective(D);
2201   Record.push_back(D->hasCancel() ? 1 : 0);
2202   Code = serialization::STMT_OMP_TASK_DIRECTIVE;
2203 }
2204 
2205 void ASTStmtWriter::VisitOMPAtomicDirective(OMPAtomicDirective *D) {
2206   VisitStmt(D);
2207   Record.push_back(D->getNumClauses());
2208   VisitOMPExecutableDirective(D);
2209   Writer.AddStmt(D->getX());
2210   Writer.AddStmt(D->getV());
2211   Writer.AddStmt(D->getExpr());
2212   Writer.AddStmt(D->getUpdateExpr());
2213   Record.push_back(D->isXLHSInRHSPart() ? 1 : 0);
2214   Record.push_back(D->isPostfixUpdate() ? 1 : 0);
2215   Code = serialization::STMT_OMP_ATOMIC_DIRECTIVE;
2216 }
2217 
2218 void ASTStmtWriter::VisitOMPTargetDirective(OMPTargetDirective *D) {
2219   VisitStmt(D);
2220   Record.push_back(D->getNumClauses());
2221   VisitOMPExecutableDirective(D);
2222   Code = serialization::STMT_OMP_TARGET_DIRECTIVE;
2223 }
2224 
2225 void ASTStmtWriter::VisitOMPTargetDataDirective(OMPTargetDataDirective *D) {
2226   VisitStmt(D);
2227   Record.push_back(D->getNumClauses());
2228   VisitOMPExecutableDirective(D);
2229   Code = serialization::STMT_OMP_TARGET_DATA_DIRECTIVE;
2230 }
2231 
2232 void ASTStmtWriter::VisitOMPTargetEnterDataDirective(
2233     OMPTargetEnterDataDirective *D) {
2234   VisitStmt(D);
2235   Record.push_back(D->getNumClauses());
2236   VisitOMPExecutableDirective(D);
2237   Code = serialization::STMT_OMP_TARGET_ENTER_DATA_DIRECTIVE;
2238 }
2239 
2240 void ASTStmtWriter::VisitOMPTargetExitDataDirective(
2241     OMPTargetExitDataDirective *D) {
2242   VisitStmt(D);
2243   Record.push_back(D->getNumClauses());
2244   VisitOMPExecutableDirective(D);
2245   Code = serialization::STMT_OMP_TARGET_EXIT_DATA_DIRECTIVE;
2246 }
2247 
2248 void ASTStmtWriter::VisitOMPTargetParallelDirective(
2249     OMPTargetParallelDirective *D) {
2250   VisitStmt(D);
2251   Record.push_back(D->getNumClauses());
2252   VisitOMPExecutableDirective(D);
2253   Code = serialization::STMT_OMP_TARGET_PARALLEL_DIRECTIVE;
2254 }
2255 
2256 void ASTStmtWriter::VisitOMPTargetParallelForDirective(
2257     OMPTargetParallelForDirective *D) {
2258   VisitOMPLoopDirective(D);
2259   Record.push_back(D->hasCancel() ? 1 : 0);
2260   Code = serialization::STMT_OMP_TARGET_PARALLEL_FOR_DIRECTIVE;
2261 }
2262 
2263 void ASTStmtWriter::VisitOMPTaskyieldDirective(OMPTaskyieldDirective *D) {
2264   VisitStmt(D);
2265   VisitOMPExecutableDirective(D);
2266   Code = serialization::STMT_OMP_TASKYIELD_DIRECTIVE;
2267 }
2268 
2269 void ASTStmtWriter::VisitOMPBarrierDirective(OMPBarrierDirective *D) {
2270   VisitStmt(D);
2271   VisitOMPExecutableDirective(D);
2272   Code = serialization::STMT_OMP_BARRIER_DIRECTIVE;
2273 }
2274 
2275 void ASTStmtWriter::VisitOMPTaskwaitDirective(OMPTaskwaitDirective *D) {
2276   VisitStmt(D);
2277   VisitOMPExecutableDirective(D);
2278   Code = serialization::STMT_OMP_TASKWAIT_DIRECTIVE;
2279 }
2280 
2281 void ASTStmtWriter::VisitOMPTaskgroupDirective(OMPTaskgroupDirective *D) {
2282   VisitStmt(D);
2283   VisitOMPExecutableDirective(D);
2284   Code = serialization::STMT_OMP_TASKGROUP_DIRECTIVE;
2285 }
2286 
2287 void ASTStmtWriter::VisitOMPFlushDirective(OMPFlushDirective *D) {
2288   VisitStmt(D);
2289   Record.push_back(D->getNumClauses());
2290   VisitOMPExecutableDirective(D);
2291   Code = serialization::STMT_OMP_FLUSH_DIRECTIVE;
2292 }
2293 
2294 void ASTStmtWriter::VisitOMPOrderedDirective(OMPOrderedDirective *D) {
2295   VisitStmt(D);
2296   Record.push_back(D->getNumClauses());
2297   VisitOMPExecutableDirective(D);
2298   Code = serialization::STMT_OMP_ORDERED_DIRECTIVE;
2299 }
2300 
2301 void ASTStmtWriter::VisitOMPTeamsDirective(OMPTeamsDirective *D) {
2302   VisitStmt(D);
2303   Record.push_back(D->getNumClauses());
2304   VisitOMPExecutableDirective(D);
2305   Code = serialization::STMT_OMP_TEAMS_DIRECTIVE;
2306 }
2307 
2308 void ASTStmtWriter::VisitOMPCancellationPointDirective(
2309     OMPCancellationPointDirective *D) {
2310   VisitStmt(D);
2311   VisitOMPExecutableDirective(D);
2312   Record.push_back(D->getCancelRegion());
2313   Code = serialization::STMT_OMP_CANCELLATION_POINT_DIRECTIVE;
2314 }
2315 
2316 void ASTStmtWriter::VisitOMPCancelDirective(OMPCancelDirective *D) {
2317   VisitStmt(D);
2318   Record.push_back(D->getNumClauses());
2319   VisitOMPExecutableDirective(D);
2320   Record.push_back(D->getCancelRegion());
2321   Code = serialization::STMT_OMP_CANCEL_DIRECTIVE;
2322 }
2323 
2324 void ASTStmtWriter::VisitOMPTaskLoopDirective(OMPTaskLoopDirective *D) {
2325   VisitOMPLoopDirective(D);
2326   Code = serialization::STMT_OMP_TASKLOOP_DIRECTIVE;
2327 }
2328 
2329 void ASTStmtWriter::VisitOMPTaskLoopSimdDirective(OMPTaskLoopSimdDirective *D) {
2330   VisitOMPLoopDirective(D);
2331   Code = serialization::STMT_OMP_TASKLOOP_SIMD_DIRECTIVE;
2332 }
2333 
2334 void ASTStmtWriter::VisitOMPDistributeDirective(OMPDistributeDirective *D) {
2335   VisitOMPLoopDirective(D);
2336   Code = serialization::STMT_OMP_DISTRIBUTE_DIRECTIVE;
2337 }
2338 
2339 //===----------------------------------------------------------------------===//
2340 // ASTWriter Implementation
2341 //===----------------------------------------------------------------------===//
2342 
2343 unsigned ASTWriter::RecordSwitchCaseID(SwitchCase *S) {
2344   assert(SwitchCaseIDs.find(S) == SwitchCaseIDs.end() &&
2345          "SwitchCase recorded twice");
2346   unsigned NextID = SwitchCaseIDs.size();
2347   SwitchCaseIDs[S] = NextID;
2348   return NextID;
2349 }
2350 
2351 unsigned ASTWriter::getSwitchCaseID(SwitchCase *S) {
2352   assert(SwitchCaseIDs.find(S) != SwitchCaseIDs.end() &&
2353          "SwitchCase hasn't been seen yet");
2354   return SwitchCaseIDs[S];
2355 }
2356 
2357 void ASTWriter::ClearSwitchCaseIDs() {
2358   SwitchCaseIDs.clear();
2359 }
2360 
2361 /// \brief Write the given substatement or subexpression to the
2362 /// bitstream.
2363 void ASTWriter::WriteSubStmt(Stmt *S,
2364                              llvm::DenseMap<Stmt *, uint64_t> &SubStmtEntries,
2365                              llvm::DenseSet<Stmt *> &ParentStmts) {
2366   RecordData Record;
2367   ASTStmtWriter Writer(*this, Record);
2368   ++NumStatements;
2369 
2370   if (!S) {
2371     Stream.EmitRecord(serialization::STMT_NULL_PTR, Record);
2372     return;
2373   }
2374 
2375   llvm::DenseMap<Stmt *, uint64_t>::iterator I = SubStmtEntries.find(S);
2376   if (I != SubStmtEntries.end()) {
2377     Record.push_back(I->second);
2378     Stream.EmitRecord(serialization::STMT_REF_PTR, Record);
2379     return;
2380   }
2381 
2382 #ifndef NDEBUG
2383   assert(!ParentStmts.count(S) && "There is a Stmt cycle!");
2384 
2385   struct ParentStmtInserterRAII {
2386     Stmt *S;
2387     llvm::DenseSet<Stmt *> &ParentStmts;
2388 
2389     ParentStmtInserterRAII(Stmt *S, llvm::DenseSet<Stmt *> &ParentStmts)
2390       : S(S), ParentStmts(ParentStmts) {
2391       ParentStmts.insert(S);
2392     }
2393     ~ParentStmtInserterRAII() {
2394       ParentStmts.erase(S);
2395     }
2396   };
2397 
2398   ParentStmtInserterRAII ParentStmtInserter(S, ParentStmts);
2399 #endif
2400 
2401   // Redirect ASTWriter::AddStmt to collect sub-stmts.
2402   SmallVector<Stmt *, 16> SubStmts;
2403   CollectedStmts = &SubStmts;
2404 
2405   Writer.Code = serialization::STMT_NULL_PTR;
2406   Writer.AbbrevToUse = 0;
2407   Writer.Visit(S);
2408 
2409 #ifndef NDEBUG
2410   if (Writer.Code == serialization::STMT_NULL_PTR) {
2411     SourceManager &SrcMgr
2412       = DeclIDs.begin()->first->getASTContext().getSourceManager();
2413     S->dump(SrcMgr);
2414     llvm_unreachable("Unhandled sub-statement writing AST file");
2415   }
2416 #endif
2417 
2418   // Revert ASTWriter::AddStmt.
2419   CollectedStmts = &StmtsToEmit;
2420 
2421   // Write the sub-stmts in reverse order, last to first. When reading them back
2422   // we will read them in correct order by "pop"ing them from the Stmts stack.
2423   // This simplifies reading and allows to store a variable number of sub-stmts
2424   // without knowing it in advance.
2425   while (!SubStmts.empty())
2426     WriteSubStmt(SubStmts.pop_back_val(), SubStmtEntries, ParentStmts);
2427 
2428   Stream.EmitRecord(Writer.Code, Record, Writer.AbbrevToUse);
2429 
2430   SubStmtEntries[S] = Stream.GetCurrentBitNo();
2431 }
2432 
2433 /// \brief Flush all of the statements that have been added to the
2434 /// queue via AddStmt().
2435 void ASTWriter::FlushStmts() {
2436   RecordData Record;
2437 
2438   // We expect to be the only consumer of the two temporary statement maps,
2439   // assert that they are empty.
2440   assert(SubStmtEntries.empty() && "unexpected entries in sub-stmt map");
2441   assert(ParentStmts.empty() && "unexpected entries in parent stmt map");
2442 
2443   for (unsigned I = 0, N = StmtsToEmit.size(); I != N; ++I) {
2444     WriteSubStmt(StmtsToEmit[I], SubStmtEntries, ParentStmts);
2445 
2446     assert(N == StmtsToEmit.size() &&
2447            "Substatement written via AddStmt rather than WriteSubStmt!");
2448 
2449     // Note that we are at the end of a full expression. Any
2450     // expression records that follow this one are part of a different
2451     // expression.
2452     Stream.EmitRecord(serialization::STMT_STOP, Record);
2453 
2454     SubStmtEntries.clear();
2455     ParentStmts.clear();
2456   }
2457 
2458   StmtsToEmit.clear();
2459 }
2460