1 //===--- ASTReaderStmt.cpp - Stmt/Expr Deserialization ----------*- C++ -*-===//
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 // Statement/expression deserialization.  This implements the
11 // ASTReader::ReadStmt method.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #include "clang/Serialization/ASTReader.h"
16 #include "clang/AST/DeclCXX.h"
17 #include "clang/AST/DeclTemplate.h"
18 #include "clang/AST/StmtVisitor.h"
19 using namespace clang;
20 using namespace clang::serialization;
21 
22 namespace clang {
23 
24   class ASTStmtReader : public StmtVisitor<ASTStmtReader> {
25     ASTReader &Reader;
26     ASTReader::PerFileData &F;
27     llvm::BitstreamCursor &DeclsCursor;
28     const ASTReader::RecordData &Record;
29     unsigned &Idx;
30 
31     SourceLocation ReadSourceLocation(const ASTReader::RecordData &R,
32                                       unsigned &I) {
33       return Reader.ReadSourceLocation(F, R, I);
34     }
35     SourceRange ReadSourceRange(const ASTReader::RecordData &R, unsigned &I) {
36       return Reader.ReadSourceRange(F, R, I);
37     }
38     TypeSourceInfo *GetTypeSourceInfo(const ASTReader::RecordData &R,
39                                       unsigned &I) {
40       return Reader.GetTypeSourceInfo(F, R, I);
41     }
42     void ReadDeclarationNameLoc(DeclarationNameLoc &DNLoc, DeclarationName Name,
43                                 const ASTReader::RecordData &R, unsigned &I) {
44       Reader.ReadDeclarationNameLoc(F, DNLoc, Name, R, I);
45     }
46     void ReadDeclarationNameInfo(DeclarationNameInfo &NameInfo,
47                                 const ASTReader::RecordData &R, unsigned &I) {
48       Reader.ReadDeclarationNameInfo(F, NameInfo, R, I);
49     }
50 
51   public:
52     ASTStmtReader(ASTReader &Reader, ASTReader::PerFileData &F,
53                   llvm::BitstreamCursor &Cursor,
54                   const ASTReader::RecordData &Record, unsigned &Idx)
55       : Reader(Reader), F(F), DeclsCursor(Cursor), Record(Record), Idx(Idx) { }
56 
57     /// \brief The number of record fields required for the Stmt class
58     /// itself.
59     static const unsigned NumStmtFields = 0;
60 
61     /// \brief The number of record fields required for the Expr class
62     /// itself.
63     static const unsigned NumExprFields = NumStmtFields + 6;
64 
65     /// \brief Read and initialize a ExplicitTemplateArgumentList structure.
66     void ReadExplicitTemplateArgumentList(ExplicitTemplateArgumentList &ArgList,
67                                           unsigned NumTemplateArgs);
68 
69     void VisitStmt(Stmt *S);
70     void VisitNullStmt(NullStmt *S);
71     void VisitCompoundStmt(CompoundStmt *S);
72     void VisitSwitchCase(SwitchCase *S);
73     void VisitCaseStmt(CaseStmt *S);
74     void VisitDefaultStmt(DefaultStmt *S);
75     void VisitLabelStmt(LabelStmt *S);
76     void VisitIfStmt(IfStmt *S);
77     void VisitSwitchStmt(SwitchStmt *S);
78     void VisitWhileStmt(WhileStmt *S);
79     void VisitDoStmt(DoStmt *S);
80     void VisitForStmt(ForStmt *S);
81     void VisitGotoStmt(GotoStmt *S);
82     void VisitIndirectGotoStmt(IndirectGotoStmt *S);
83     void VisitContinueStmt(ContinueStmt *S);
84     void VisitBreakStmt(BreakStmt *S);
85     void VisitReturnStmt(ReturnStmt *S);
86     void VisitDeclStmt(DeclStmt *S);
87     void VisitAsmStmt(AsmStmt *S);
88     void VisitExpr(Expr *E);
89     void VisitPredefinedExpr(PredefinedExpr *E);
90     void VisitDeclRefExpr(DeclRefExpr *E);
91     void VisitIntegerLiteral(IntegerLiteral *E);
92     void VisitFloatingLiteral(FloatingLiteral *E);
93     void VisitImaginaryLiteral(ImaginaryLiteral *E);
94     void VisitStringLiteral(StringLiteral *E);
95     void VisitCharacterLiteral(CharacterLiteral *E);
96     void VisitParenExpr(ParenExpr *E);
97     void VisitParenListExpr(ParenListExpr *E);
98     void VisitUnaryOperator(UnaryOperator *E);
99     void VisitOffsetOfExpr(OffsetOfExpr *E);
100     void VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E);
101     void VisitArraySubscriptExpr(ArraySubscriptExpr *E);
102     void VisitCallExpr(CallExpr *E);
103     void VisitMemberExpr(MemberExpr *E);
104     void VisitCastExpr(CastExpr *E);
105     void VisitBinaryOperator(BinaryOperator *E);
106     void VisitCompoundAssignOperator(CompoundAssignOperator *E);
107     void VisitConditionalOperator(ConditionalOperator *E);
108     void VisitBinaryConditionalOperator(BinaryConditionalOperator *E);
109     void VisitImplicitCastExpr(ImplicitCastExpr *E);
110     void VisitExplicitCastExpr(ExplicitCastExpr *E);
111     void VisitCStyleCastExpr(CStyleCastExpr *E);
112     void VisitCompoundLiteralExpr(CompoundLiteralExpr *E);
113     void VisitExtVectorElementExpr(ExtVectorElementExpr *E);
114     void VisitInitListExpr(InitListExpr *E);
115     void VisitDesignatedInitExpr(DesignatedInitExpr *E);
116     void VisitImplicitValueInitExpr(ImplicitValueInitExpr *E);
117     void VisitVAArgExpr(VAArgExpr *E);
118     void VisitAddrLabelExpr(AddrLabelExpr *E);
119     void VisitStmtExpr(StmtExpr *E);
120     void VisitChooseExpr(ChooseExpr *E);
121     void VisitGNUNullExpr(GNUNullExpr *E);
122     void VisitShuffleVectorExpr(ShuffleVectorExpr *E);
123     void VisitBlockExpr(BlockExpr *E);
124     void VisitBlockDeclRefExpr(BlockDeclRefExpr *E);
125     void VisitGenericSelectionExpr(GenericSelectionExpr *E);
126     void VisitObjCStringLiteral(ObjCStringLiteral *E);
127     void VisitObjCEncodeExpr(ObjCEncodeExpr *E);
128     void VisitObjCSelectorExpr(ObjCSelectorExpr *E);
129     void VisitObjCProtocolExpr(ObjCProtocolExpr *E);
130     void VisitObjCIvarRefExpr(ObjCIvarRefExpr *E);
131     void VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E);
132     void VisitObjCMessageExpr(ObjCMessageExpr *E);
133     void VisitObjCIsaExpr(ObjCIsaExpr *E);
134 
135     void VisitObjCForCollectionStmt(ObjCForCollectionStmt *);
136     void VisitObjCAtCatchStmt(ObjCAtCatchStmt *);
137     void VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *);
138     void VisitObjCAtTryStmt(ObjCAtTryStmt *);
139     void VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *);
140     void VisitObjCAtThrowStmt(ObjCAtThrowStmt *);
141 
142     // C++ Statements
143     void VisitCXXCatchStmt(CXXCatchStmt *S);
144     void VisitCXXTryStmt(CXXTryStmt *S);
145     void VisitCXXForRangeStmt(CXXForRangeStmt *);
146 
147     void VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E);
148     void VisitCXXConstructExpr(CXXConstructExpr *E);
149     void VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E);
150     void VisitCXXNamedCastExpr(CXXNamedCastExpr *E);
151     void VisitCXXStaticCastExpr(CXXStaticCastExpr *E);
152     void VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E);
153     void VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E);
154     void VisitCXXConstCastExpr(CXXConstCastExpr *E);
155     void VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E);
156     void VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E);
157     void VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E);
158     void VisitCXXTypeidExpr(CXXTypeidExpr *E);
159     void VisitCXXUuidofExpr(CXXUuidofExpr *E);
160     void VisitCXXThisExpr(CXXThisExpr *E);
161     void VisitCXXThrowExpr(CXXThrowExpr *E);
162     void VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E);
163     void VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E);
164 
165     void VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E);
166     void VisitCXXNewExpr(CXXNewExpr *E);
167     void VisitCXXDeleteExpr(CXXDeleteExpr *E);
168     void VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E);
169 
170     void VisitExprWithCleanups(ExprWithCleanups *E);
171 
172     void VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E);
173     void VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E);
174     void VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E);
175 
176     void VisitOverloadExpr(OverloadExpr *E);
177     void VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E);
178     void VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E);
179 
180     void VisitUnaryTypeTraitExpr(UnaryTypeTraitExpr *E);
181     void VisitBinaryTypeTraitExpr(BinaryTypeTraitExpr *E);
182     void VisitCXXNoexceptExpr(CXXNoexceptExpr *E);
183     void VisitPackExpansionExpr(PackExpansionExpr *E);
184     void VisitSizeOfPackExpr(SizeOfPackExpr *E);
185     void VisitSubstNonTypeTemplateParmPackExpr(
186                                            SubstNonTypeTemplateParmPackExpr *E);
187     void VisitOpaqueValueExpr(OpaqueValueExpr *E);
188 
189     // CUDA Expressions
190     void VisitCUDAKernelCallExpr(CUDAKernelCallExpr *E);
191   };
192 }
193 
194 void ASTStmtReader::
195 ReadExplicitTemplateArgumentList(ExplicitTemplateArgumentList &ArgList,
196                                  unsigned NumTemplateArgs) {
197   TemplateArgumentListInfo ArgInfo;
198   ArgInfo.setLAngleLoc(ReadSourceLocation(Record, Idx));
199   ArgInfo.setRAngleLoc(ReadSourceLocation(Record, Idx));
200   for (unsigned i = 0; i != NumTemplateArgs; ++i)
201     ArgInfo.addArgument(
202         Reader.ReadTemplateArgumentLoc(F, Record, Idx));
203   ArgList.initializeFrom(ArgInfo);
204 }
205 
206 void ASTStmtReader::VisitStmt(Stmt *S) {
207   assert(Idx == NumStmtFields && "Incorrect statement field count");
208 }
209 
210 void ASTStmtReader::VisitNullStmt(NullStmt *S) {
211   VisitStmt(S);
212   S->setSemiLoc(ReadSourceLocation(Record, Idx));
213   S->LeadingEmptyMacro = Record[Idx++];
214 }
215 
216 void ASTStmtReader::VisitCompoundStmt(CompoundStmt *S) {
217   VisitStmt(S);
218   llvm::SmallVector<Stmt *, 16> Stmts;
219   unsigned NumStmts = Record[Idx++];
220   while (NumStmts--)
221     Stmts.push_back(Reader.ReadSubStmt());
222   S->setStmts(*Reader.getContext(), Stmts.data(), Stmts.size());
223   S->setLBracLoc(ReadSourceLocation(Record, Idx));
224   S->setRBracLoc(ReadSourceLocation(Record, Idx));
225 }
226 
227 void ASTStmtReader::VisitSwitchCase(SwitchCase *S) {
228   VisitStmt(S);
229   Reader.RecordSwitchCaseID(S, Record[Idx++]);
230 }
231 
232 void ASTStmtReader::VisitCaseStmt(CaseStmt *S) {
233   VisitSwitchCase(S);
234   S->setLHS(Reader.ReadSubExpr());
235   S->setRHS(Reader.ReadSubExpr());
236   S->setSubStmt(Reader.ReadSubStmt());
237   S->setCaseLoc(ReadSourceLocation(Record, Idx));
238   S->setEllipsisLoc(ReadSourceLocation(Record, Idx));
239   S->setColonLoc(ReadSourceLocation(Record, Idx));
240 }
241 
242 void ASTStmtReader::VisitDefaultStmt(DefaultStmt *S) {
243   VisitSwitchCase(S);
244   S->setSubStmt(Reader.ReadSubStmt());
245   S->setDefaultLoc(ReadSourceLocation(Record, Idx));
246   S->setColonLoc(ReadSourceLocation(Record, Idx));
247 }
248 
249 void ASTStmtReader::VisitLabelStmt(LabelStmt *S) {
250   VisitStmt(S);
251   LabelDecl *LD = cast<LabelDecl>(Reader.GetDecl(Record[Idx++]));
252   LD->setStmt(S);
253   S->setDecl(LD);
254   S->setSubStmt(Reader.ReadSubStmt());
255   S->setIdentLoc(ReadSourceLocation(Record, Idx));
256 }
257 
258 void ASTStmtReader::VisitIfStmt(IfStmt *S) {
259   VisitStmt(S);
260   S->setConditionVariable(*Reader.getContext(),
261                           cast_or_null<VarDecl>(Reader.GetDecl(Record[Idx++])));
262   S->setCond(Reader.ReadSubExpr());
263   S->setThen(Reader.ReadSubStmt());
264   S->setElse(Reader.ReadSubStmt());
265   S->setIfLoc(ReadSourceLocation(Record, Idx));
266   S->setElseLoc(ReadSourceLocation(Record, Idx));
267 }
268 
269 void ASTStmtReader::VisitSwitchStmt(SwitchStmt *S) {
270   VisitStmt(S);
271   S->setConditionVariable(*Reader.getContext(),
272                           cast_or_null<VarDecl>(Reader.GetDecl(Record[Idx++])));
273   S->setCond(Reader.ReadSubExpr());
274   S->setBody(Reader.ReadSubStmt());
275   S->setSwitchLoc(ReadSourceLocation(Record, Idx));
276   if (Record[Idx++])
277     S->setAllEnumCasesCovered();
278 
279   SwitchCase *PrevSC = 0;
280   for (unsigned N = Record.size(); Idx != N; ++Idx) {
281     SwitchCase *SC = Reader.getSwitchCaseWithID(Record[Idx]);
282     if (PrevSC)
283       PrevSC->setNextSwitchCase(SC);
284     else
285       S->setSwitchCaseList(SC);
286 
287     PrevSC = SC;
288   }
289 }
290 
291 void ASTStmtReader::VisitWhileStmt(WhileStmt *S) {
292   VisitStmt(S);
293   S->setConditionVariable(*Reader.getContext(),
294                           cast_or_null<VarDecl>(Reader.GetDecl(Record[Idx++])));
295   S->setCond(Reader.ReadSubExpr());
296   S->setBody(Reader.ReadSubStmt());
297   S->setWhileLoc(ReadSourceLocation(Record, Idx));
298 }
299 
300 void ASTStmtReader::VisitDoStmt(DoStmt *S) {
301   VisitStmt(S);
302   S->setCond(Reader.ReadSubExpr());
303   S->setBody(Reader.ReadSubStmt());
304   S->setDoLoc(ReadSourceLocation(Record, Idx));
305   S->setWhileLoc(ReadSourceLocation(Record, Idx));
306   S->setRParenLoc(ReadSourceLocation(Record, Idx));
307 }
308 
309 void ASTStmtReader::VisitForStmt(ForStmt *S) {
310   VisitStmt(S);
311   S->setInit(Reader.ReadSubStmt());
312   S->setCond(Reader.ReadSubExpr());
313   S->setConditionVariable(*Reader.getContext(),
314                           cast_or_null<VarDecl>(Reader.GetDecl(Record[Idx++])));
315   S->setInc(Reader.ReadSubExpr());
316   S->setBody(Reader.ReadSubStmt());
317   S->setForLoc(ReadSourceLocation(Record, Idx));
318   S->setLParenLoc(ReadSourceLocation(Record, Idx));
319   S->setRParenLoc(ReadSourceLocation(Record, Idx));
320 }
321 
322 void ASTStmtReader::VisitGotoStmt(GotoStmt *S) {
323   VisitStmt(S);
324   S->setLabel(cast<LabelDecl>(Reader.GetDecl(Record[Idx++])));
325   S->setGotoLoc(ReadSourceLocation(Record, Idx));
326   S->setLabelLoc(ReadSourceLocation(Record, Idx));
327 }
328 
329 void ASTStmtReader::VisitIndirectGotoStmt(IndirectGotoStmt *S) {
330   VisitStmt(S);
331   S->setGotoLoc(ReadSourceLocation(Record, Idx));
332   S->setStarLoc(ReadSourceLocation(Record, Idx));
333   S->setTarget(Reader.ReadSubExpr());
334 }
335 
336 void ASTStmtReader::VisitContinueStmt(ContinueStmt *S) {
337   VisitStmt(S);
338   S->setContinueLoc(ReadSourceLocation(Record, Idx));
339 }
340 
341 void ASTStmtReader::VisitBreakStmt(BreakStmt *S) {
342   VisitStmt(S);
343   S->setBreakLoc(ReadSourceLocation(Record, Idx));
344 }
345 
346 void ASTStmtReader::VisitReturnStmt(ReturnStmt *S) {
347   VisitStmt(S);
348   S->setRetValue(Reader.ReadSubExpr());
349   S->setReturnLoc(ReadSourceLocation(Record, Idx));
350   S->setNRVOCandidate(cast_or_null<VarDecl>(Reader.GetDecl(Record[Idx++])));
351 }
352 
353 void ASTStmtReader::VisitDeclStmt(DeclStmt *S) {
354   VisitStmt(S);
355   S->setStartLoc(ReadSourceLocation(Record, Idx));
356   S->setEndLoc(ReadSourceLocation(Record, Idx));
357 
358   if (Idx + 1 == Record.size()) {
359     // Single declaration
360     S->setDeclGroup(DeclGroupRef(Reader.GetDecl(Record[Idx++])));
361   } else {
362     llvm::SmallVector<Decl *, 16> Decls;
363     Decls.reserve(Record.size() - Idx);
364     for (unsigned N = Record.size(); Idx != N; ++Idx)
365       Decls.push_back(Reader.GetDecl(Record[Idx]));
366     S->setDeclGroup(DeclGroupRef(DeclGroup::Create(*Reader.getContext(),
367                                                    Decls.data(),
368                                                    Decls.size())));
369   }
370 }
371 
372 void ASTStmtReader::VisitAsmStmt(AsmStmt *S) {
373   VisitStmt(S);
374   unsigned NumOutputs = Record[Idx++];
375   unsigned NumInputs = Record[Idx++];
376   unsigned NumClobbers = Record[Idx++];
377   S->setAsmLoc(ReadSourceLocation(Record, Idx));
378   S->setRParenLoc(ReadSourceLocation(Record, Idx));
379   S->setVolatile(Record[Idx++]);
380   S->setSimple(Record[Idx++]);
381   S->setMSAsm(Record[Idx++]);
382 
383   S->setAsmString(cast_or_null<StringLiteral>(Reader.ReadSubStmt()));
384 
385   // Outputs and inputs
386   llvm::SmallVector<IdentifierInfo *, 16> Names;
387   llvm::SmallVector<StringLiteral*, 16> Constraints;
388   llvm::SmallVector<Stmt*, 16> Exprs;
389   for (unsigned I = 0, N = NumOutputs + NumInputs; I != N; ++I) {
390     Names.push_back(Reader.GetIdentifierInfo(Record, Idx));
391     Constraints.push_back(cast_or_null<StringLiteral>(Reader.ReadSubStmt()));
392     Exprs.push_back(Reader.ReadSubStmt());
393   }
394 
395   // Constraints
396   llvm::SmallVector<StringLiteral*, 16> Clobbers;
397   for (unsigned I = 0; I != NumClobbers; ++I)
398     Clobbers.push_back(cast_or_null<StringLiteral>(Reader.ReadSubStmt()));
399 
400   S->setOutputsAndInputsAndClobbers(*Reader.getContext(),
401                                     Names.data(), Constraints.data(),
402                                     Exprs.data(), NumOutputs, NumInputs,
403                                     Clobbers.data(), NumClobbers);
404 }
405 
406 void ASTStmtReader::VisitExpr(Expr *E) {
407   VisitStmt(E);
408   E->setType(Reader.GetType(Record[Idx++]));
409   E->setTypeDependent(Record[Idx++]);
410   E->setValueDependent(Record[Idx++]);
411   E->ExprBits.ContainsUnexpandedParameterPack = Record[Idx++];
412   E->setValueKind(static_cast<ExprValueKind>(Record[Idx++]));
413   E->setObjectKind(static_cast<ExprObjectKind>(Record[Idx++]));
414   assert(Idx == NumExprFields && "Incorrect expression field count");
415 }
416 
417 void ASTStmtReader::VisitPredefinedExpr(PredefinedExpr *E) {
418   VisitExpr(E);
419   E->setLocation(ReadSourceLocation(Record, Idx));
420   E->setIdentType((PredefinedExpr::IdentType)Record[Idx++]);
421 }
422 
423 void ASTStmtReader::VisitDeclRefExpr(DeclRefExpr *E) {
424   VisitExpr(E);
425 
426   bool HasQualifier = Record[Idx++];
427   bool HasExplicitTemplateArgs = Record[Idx++];
428   unsigned NumTemplateArgs = 0;
429   if (HasExplicitTemplateArgs)
430     NumTemplateArgs = Record[Idx++];
431 
432   E->DecoratedD.setInt((HasQualifier? DeclRefExpr::HasQualifierFlag : 0) |
433       (HasExplicitTemplateArgs
434          ? DeclRefExpr::HasExplicitTemplateArgumentListFlag : 0));
435 
436   if (HasQualifier)
437     E->getNameQualifier()->QualifierLoc
438       = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
439 
440   if (HasExplicitTemplateArgs)
441     ReadExplicitTemplateArgumentList(E->getExplicitTemplateArgs(),
442                                      NumTemplateArgs);
443 
444   E->setDecl(cast<ValueDecl>(Reader.GetDecl(Record[Idx++])));
445   E->setLocation(ReadSourceLocation(Record, Idx));
446   ReadDeclarationNameLoc(E->DNLoc, E->getDecl()->getDeclName(), Record, Idx);
447 }
448 
449 void ASTStmtReader::VisitIntegerLiteral(IntegerLiteral *E) {
450   VisitExpr(E);
451   E->setLocation(ReadSourceLocation(Record, Idx));
452   E->setValue(*Reader.getContext(), Reader.ReadAPInt(Record, Idx));
453 }
454 
455 void ASTStmtReader::VisitFloatingLiteral(FloatingLiteral *E) {
456   VisitExpr(E);
457   E->setValue(*Reader.getContext(), Reader.ReadAPFloat(Record, Idx));
458   E->setExact(Record[Idx++]);
459   E->setLocation(ReadSourceLocation(Record, Idx));
460 }
461 
462 void ASTStmtReader::VisitImaginaryLiteral(ImaginaryLiteral *E) {
463   VisitExpr(E);
464   E->setSubExpr(Reader.ReadSubExpr());
465 }
466 
467 void ASTStmtReader::VisitStringLiteral(StringLiteral *E) {
468   VisitExpr(E);
469   unsigned Len = Record[Idx++];
470   assert(Record[Idx] == E->getNumConcatenated() &&
471          "Wrong number of concatenated tokens!");
472   ++Idx;
473   E->IsWide = Record[Idx++];
474   E->IsPascal = Record[Idx++];
475 
476   // Read string data
477   llvm::SmallString<16> Str(&Record[Idx], &Record[Idx] + Len);
478   E->setString(*Reader.getContext(), Str.str());
479   Idx += Len;
480 
481   // Read source locations
482   for (unsigned I = 0, N = E->getNumConcatenated(); I != N; ++I)
483     E->setStrTokenLoc(I, ReadSourceLocation(Record, Idx));
484 }
485 
486 void ASTStmtReader::VisitCharacterLiteral(CharacterLiteral *E) {
487   VisitExpr(E);
488   E->setValue(Record[Idx++]);
489   E->setLocation(ReadSourceLocation(Record, Idx));
490   E->setWide(Record[Idx++]);
491 }
492 
493 void ASTStmtReader::VisitParenExpr(ParenExpr *E) {
494   VisitExpr(E);
495   E->setLParen(ReadSourceLocation(Record, Idx));
496   E->setRParen(ReadSourceLocation(Record, Idx));
497   E->setSubExpr(Reader.ReadSubExpr());
498 }
499 
500 void ASTStmtReader::VisitParenListExpr(ParenListExpr *E) {
501   VisitExpr(E);
502   unsigned NumExprs = Record[Idx++];
503   E->Exprs = new (*Reader.getContext()) Stmt*[NumExprs];
504   for (unsigned i = 0; i != NumExprs; ++i)
505     E->Exprs[i] = Reader.ReadSubStmt();
506   E->NumExprs = NumExprs;
507   E->LParenLoc = ReadSourceLocation(Record, Idx);
508   E->RParenLoc = ReadSourceLocation(Record, Idx);
509 }
510 
511 void ASTStmtReader::VisitUnaryOperator(UnaryOperator *E) {
512   VisitExpr(E);
513   E->setSubExpr(Reader.ReadSubExpr());
514   E->setOpcode((UnaryOperator::Opcode)Record[Idx++]);
515   E->setOperatorLoc(ReadSourceLocation(Record, Idx));
516 }
517 
518 void ASTStmtReader::VisitOffsetOfExpr(OffsetOfExpr *E) {
519   typedef OffsetOfExpr::OffsetOfNode Node;
520   VisitExpr(E);
521   assert(E->getNumComponents() == Record[Idx]);
522   ++Idx;
523   assert(E->getNumExpressions() == Record[Idx]);
524   ++Idx;
525   E->setOperatorLoc(ReadSourceLocation(Record, Idx));
526   E->setRParenLoc(ReadSourceLocation(Record, Idx));
527   E->setTypeSourceInfo(GetTypeSourceInfo(Record, Idx));
528   for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) {
529     Node::Kind Kind = static_cast<Node::Kind>(Record[Idx++]);
530     SourceLocation Start = ReadSourceLocation(Record, Idx);
531     SourceLocation End = ReadSourceLocation(Record, Idx);
532     switch (Kind) {
533     case Node::Array:
534       E->setComponent(I, Node(Start, Record[Idx++], End));
535       break;
536 
537     case Node::Field:
538       E->setComponent(I,
539              Node(Start,
540                   dyn_cast_or_null<FieldDecl>(Reader.GetDecl(Record[Idx++])),
541                   End));
542       break;
543 
544     case Node::Identifier:
545       E->setComponent(I, Node(Start, Reader.GetIdentifier(Record[Idx++]), End));
546       break;
547 
548     case Node::Base: {
549       CXXBaseSpecifier *Base = new (*Reader.getContext()) CXXBaseSpecifier();
550       *Base = Reader.ReadCXXBaseSpecifier(F, Record, Idx);
551       E->setComponent(I, Node(Base));
552       break;
553     }
554     }
555   }
556 
557   for (unsigned I = 0, N = E->getNumExpressions(); I != N; ++I)
558     E->setIndexExpr(I, Reader.ReadSubExpr());
559 }
560 
561 void ASTStmtReader::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) {
562   VisitExpr(E);
563   E->setKind(static_cast<UnaryExprOrTypeTrait>(Record[Idx++]));
564   if (Record[Idx] == 0) {
565     E->setArgument(Reader.ReadSubExpr());
566     ++Idx;
567   } else {
568     E->setArgument(GetTypeSourceInfo(Record, Idx));
569   }
570   E->setOperatorLoc(ReadSourceLocation(Record, Idx));
571   E->setRParenLoc(ReadSourceLocation(Record, Idx));
572 }
573 
574 void ASTStmtReader::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
575   VisitExpr(E);
576   E->setLHS(Reader.ReadSubExpr());
577   E->setRHS(Reader.ReadSubExpr());
578   E->setRBracketLoc(ReadSourceLocation(Record, Idx));
579 }
580 
581 void ASTStmtReader::VisitCallExpr(CallExpr *E) {
582   VisitExpr(E);
583   E->setNumArgs(*Reader.getContext(), Record[Idx++]);
584   E->setRParenLoc(ReadSourceLocation(Record, Idx));
585   E->setCallee(Reader.ReadSubExpr());
586   for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
587     E->setArg(I, Reader.ReadSubExpr());
588 }
589 
590 void ASTStmtReader::VisitMemberExpr(MemberExpr *E) {
591   // Don't call VisitExpr, this is fully initialized at creation.
592   assert(E->getStmtClass() == Stmt::MemberExprClass &&
593          "It's a subclass, we must advance Idx!");
594 }
595 
596 void ASTStmtReader::VisitObjCIsaExpr(ObjCIsaExpr *E) {
597   VisitExpr(E);
598   E->setBase(Reader.ReadSubExpr());
599   E->setIsaMemberLoc(ReadSourceLocation(Record, Idx));
600   E->setArrow(Record[Idx++]);
601 }
602 
603 void ASTStmtReader::VisitCastExpr(CastExpr *E) {
604   VisitExpr(E);
605   unsigned NumBaseSpecs = Record[Idx++];
606   assert(NumBaseSpecs == E->path_size());
607   E->setSubExpr(Reader.ReadSubExpr());
608   E->setCastKind((CastExpr::CastKind)Record[Idx++]);
609   CastExpr::path_iterator BaseI = E->path_begin();
610   while (NumBaseSpecs--) {
611     CXXBaseSpecifier *BaseSpec = new (*Reader.getContext()) CXXBaseSpecifier;
612     *BaseSpec = Reader.ReadCXXBaseSpecifier(F, Record, Idx);
613     *BaseI++ = BaseSpec;
614   }
615 }
616 
617 void ASTStmtReader::VisitBinaryOperator(BinaryOperator *E) {
618   VisitExpr(E);
619   E->setLHS(Reader.ReadSubExpr());
620   E->setRHS(Reader.ReadSubExpr());
621   E->setOpcode((BinaryOperator::Opcode)Record[Idx++]);
622   E->setOperatorLoc(ReadSourceLocation(Record, Idx));
623 }
624 
625 void ASTStmtReader::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
626   VisitBinaryOperator(E);
627   E->setComputationLHSType(Reader.GetType(Record[Idx++]));
628   E->setComputationResultType(Reader.GetType(Record[Idx++]));
629 }
630 
631 void ASTStmtReader::VisitConditionalOperator(ConditionalOperator *E) {
632   VisitExpr(E);
633   E->SubExprs[ConditionalOperator::COND] = Reader.ReadSubExpr();
634   E->SubExprs[ConditionalOperator::LHS] = Reader.ReadSubExpr();
635   E->SubExprs[ConditionalOperator::RHS] = Reader.ReadSubExpr();
636   E->QuestionLoc = ReadSourceLocation(Record, Idx);
637   E->ColonLoc = ReadSourceLocation(Record, Idx);
638 }
639 
640 void
641 ASTStmtReader::VisitBinaryConditionalOperator(BinaryConditionalOperator *E) {
642   VisitExpr(E);
643   E->OpaqueValue = cast<OpaqueValueExpr>(Reader.ReadSubExpr());
644   E->SubExprs[BinaryConditionalOperator::COMMON] = Reader.ReadSubExpr();
645   E->SubExprs[BinaryConditionalOperator::COND] = Reader.ReadSubExpr();
646   E->SubExprs[BinaryConditionalOperator::LHS] = Reader.ReadSubExpr();
647   E->SubExprs[BinaryConditionalOperator::RHS] = Reader.ReadSubExpr();
648   E->QuestionLoc = ReadSourceLocation(Record, Idx);
649   E->ColonLoc = ReadSourceLocation(Record, Idx);
650 
651   E->getOpaqueValue()->setSourceExpr(E->getCommon());
652 }
653 
654 void ASTStmtReader::VisitImplicitCastExpr(ImplicitCastExpr *E) {
655   VisitCastExpr(E);
656 }
657 
658 void ASTStmtReader::VisitExplicitCastExpr(ExplicitCastExpr *E) {
659   VisitCastExpr(E);
660   E->setTypeInfoAsWritten(GetTypeSourceInfo(Record, Idx));
661 }
662 
663 void ASTStmtReader::VisitCStyleCastExpr(CStyleCastExpr *E) {
664   VisitExplicitCastExpr(E);
665   E->setLParenLoc(ReadSourceLocation(Record, Idx));
666   E->setRParenLoc(ReadSourceLocation(Record, Idx));
667 }
668 
669 void ASTStmtReader::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
670   VisitExpr(E);
671   E->setLParenLoc(ReadSourceLocation(Record, Idx));
672   E->setTypeSourceInfo(GetTypeSourceInfo(Record, Idx));
673   E->setInitializer(Reader.ReadSubExpr());
674   E->setFileScope(Record[Idx++]);
675 }
676 
677 void ASTStmtReader::VisitExtVectorElementExpr(ExtVectorElementExpr *E) {
678   VisitExpr(E);
679   E->setBase(Reader.ReadSubExpr());
680   E->setAccessor(Reader.GetIdentifierInfo(Record, Idx));
681   E->setAccessorLoc(ReadSourceLocation(Record, Idx));
682 }
683 
684 void ASTStmtReader::VisitInitListExpr(InitListExpr *E) {
685   VisitExpr(E);
686   unsigned NumInits = Record[Idx++];
687   E->reserveInits(*Reader.getContext(), NumInits);
688   for (unsigned I = 0; I != NumInits; ++I)
689     E->updateInit(*Reader.getContext(), I, Reader.ReadSubExpr());
690   E->setSyntacticForm(cast_or_null<InitListExpr>(Reader.ReadSubStmt()));
691   E->setLBraceLoc(ReadSourceLocation(Record, Idx));
692   E->setRBraceLoc(ReadSourceLocation(Record, Idx));
693   E->setInitializedFieldInUnion(
694                       cast_or_null<FieldDecl>(Reader.GetDecl(Record[Idx++])));
695   E->sawArrayRangeDesignator(Record[Idx++]);
696 }
697 
698 void ASTStmtReader::VisitDesignatedInitExpr(DesignatedInitExpr *E) {
699   typedef DesignatedInitExpr::Designator Designator;
700 
701   VisitExpr(E);
702   unsigned NumSubExprs = Record[Idx++];
703   assert(NumSubExprs == E->getNumSubExprs() && "Wrong number of subexprs");
704   for (unsigned I = 0; I != NumSubExprs; ++I)
705     E->setSubExpr(I, Reader.ReadSubExpr());
706   E->setEqualOrColonLoc(ReadSourceLocation(Record, Idx));
707   E->setGNUSyntax(Record[Idx++]);
708 
709   llvm::SmallVector<Designator, 4> Designators;
710   while (Idx < Record.size()) {
711     switch ((DesignatorTypes)Record[Idx++]) {
712     case DESIG_FIELD_DECL: {
713       FieldDecl *Field = cast<FieldDecl>(Reader.GetDecl(Record[Idx++]));
714       SourceLocation DotLoc
715         = ReadSourceLocation(Record, Idx);
716       SourceLocation FieldLoc
717         = ReadSourceLocation(Record, Idx);
718       Designators.push_back(Designator(Field->getIdentifier(), DotLoc,
719                                        FieldLoc));
720       Designators.back().setField(Field);
721       break;
722     }
723 
724     case DESIG_FIELD_NAME: {
725       const IdentifierInfo *Name = Reader.GetIdentifierInfo(Record, Idx);
726       SourceLocation DotLoc
727         = ReadSourceLocation(Record, Idx);
728       SourceLocation FieldLoc
729         = ReadSourceLocation(Record, Idx);
730       Designators.push_back(Designator(Name, DotLoc, FieldLoc));
731       break;
732     }
733 
734     case DESIG_ARRAY: {
735       unsigned Index = Record[Idx++];
736       SourceLocation LBracketLoc
737         = ReadSourceLocation(Record, Idx);
738       SourceLocation RBracketLoc
739         = ReadSourceLocation(Record, Idx);
740       Designators.push_back(Designator(Index, LBracketLoc, RBracketLoc));
741       break;
742     }
743 
744     case DESIG_ARRAY_RANGE: {
745       unsigned Index = Record[Idx++];
746       SourceLocation LBracketLoc
747         = ReadSourceLocation(Record, Idx);
748       SourceLocation EllipsisLoc
749         = ReadSourceLocation(Record, Idx);
750       SourceLocation RBracketLoc
751         = ReadSourceLocation(Record, Idx);
752       Designators.push_back(Designator(Index, LBracketLoc, EllipsisLoc,
753                                        RBracketLoc));
754       break;
755     }
756     }
757   }
758   E->setDesignators(*Reader.getContext(),
759                     Designators.data(), Designators.size());
760 }
761 
762 void ASTStmtReader::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
763   VisitExpr(E);
764 }
765 
766 void ASTStmtReader::VisitVAArgExpr(VAArgExpr *E) {
767   VisitExpr(E);
768   E->setSubExpr(Reader.ReadSubExpr());
769   E->setWrittenTypeInfo(GetTypeSourceInfo(Record, Idx));
770   E->setBuiltinLoc(ReadSourceLocation(Record, Idx));
771   E->setRParenLoc(ReadSourceLocation(Record, Idx));
772 }
773 
774 void ASTStmtReader::VisitAddrLabelExpr(AddrLabelExpr *E) {
775   VisitExpr(E);
776   E->setAmpAmpLoc(ReadSourceLocation(Record, Idx));
777   E->setLabelLoc(ReadSourceLocation(Record, Idx));
778   E->setLabel(cast<LabelDecl>(Reader.GetDecl(Record[Idx++])));
779 }
780 
781 void ASTStmtReader::VisitStmtExpr(StmtExpr *E) {
782   VisitExpr(E);
783   E->setLParenLoc(ReadSourceLocation(Record, Idx));
784   E->setRParenLoc(ReadSourceLocation(Record, Idx));
785   E->setSubStmt(cast_or_null<CompoundStmt>(Reader.ReadSubStmt()));
786 }
787 
788 void ASTStmtReader::VisitChooseExpr(ChooseExpr *E) {
789   VisitExpr(E);
790   E->setCond(Reader.ReadSubExpr());
791   E->setLHS(Reader.ReadSubExpr());
792   E->setRHS(Reader.ReadSubExpr());
793   E->setBuiltinLoc(ReadSourceLocation(Record, Idx));
794   E->setRParenLoc(ReadSourceLocation(Record, Idx));
795 }
796 
797 void ASTStmtReader::VisitGNUNullExpr(GNUNullExpr *E) {
798   VisitExpr(E);
799   E->setTokenLocation(ReadSourceLocation(Record, Idx));
800 }
801 
802 void ASTStmtReader::VisitShuffleVectorExpr(ShuffleVectorExpr *E) {
803   VisitExpr(E);
804   llvm::SmallVector<Expr *, 16> Exprs;
805   unsigned NumExprs = Record[Idx++];
806   while (NumExprs--)
807     Exprs.push_back(Reader.ReadSubExpr());
808   E->setExprs(*Reader.getContext(), Exprs.data(), Exprs.size());
809   E->setBuiltinLoc(ReadSourceLocation(Record, Idx));
810   E->setRParenLoc(ReadSourceLocation(Record, Idx));
811 }
812 
813 void ASTStmtReader::VisitBlockExpr(BlockExpr *E) {
814   VisitExpr(E);
815   E->setBlockDecl(cast_or_null<BlockDecl>(Reader.GetDecl(Record[Idx++])));
816 }
817 
818 void ASTStmtReader::VisitBlockDeclRefExpr(BlockDeclRefExpr *E) {
819   VisitExpr(E);
820   E->setDecl(cast<VarDecl>(Reader.GetDecl(Record[Idx++])));
821   E->setLocation(ReadSourceLocation(Record, Idx));
822   E->setByRef(Record[Idx++]);
823   E->setConstQualAdded(Record[Idx++]);
824 }
825 
826 void ASTStmtReader::VisitGenericSelectionExpr(GenericSelectionExpr *E) {
827   VisitExpr(E);
828   E->NumAssocs = Record[Idx++];
829   E->AssocTypes = new (*Reader.getContext()) TypeSourceInfo*[E->NumAssocs];
830   E->SubExprs =
831    new(*Reader.getContext()) Stmt*[GenericSelectionExpr::END_EXPR+E->NumAssocs];
832 
833   E->SubExprs[GenericSelectionExpr::CONTROLLING] = Reader.ReadSubExpr();
834   for (unsigned I = 0, N = E->getNumAssocs(); I != N; ++I) {
835     E->AssocTypes[I] = GetTypeSourceInfo(Record, Idx);
836     E->SubExprs[GenericSelectionExpr::END_EXPR+I] = Reader.ReadSubExpr();
837   }
838   E->ResultIndex = Record[Idx++];
839 
840   E->GenericLoc = ReadSourceLocation(Record, Idx);
841   E->DefaultLoc = ReadSourceLocation(Record, Idx);
842   E->RParenLoc = ReadSourceLocation(Record, Idx);
843 }
844 
845 //===----------------------------------------------------------------------===//
846 // Objective-C Expressions and Statements
847 
848 void ASTStmtReader::VisitObjCStringLiteral(ObjCStringLiteral *E) {
849   VisitExpr(E);
850   E->setString(cast<StringLiteral>(Reader.ReadSubStmt()));
851   E->setAtLoc(ReadSourceLocation(Record, Idx));
852 }
853 
854 void ASTStmtReader::VisitObjCEncodeExpr(ObjCEncodeExpr *E) {
855   VisitExpr(E);
856   E->setEncodedTypeSourceInfo(GetTypeSourceInfo(Record, Idx));
857   E->setAtLoc(ReadSourceLocation(Record, Idx));
858   E->setRParenLoc(ReadSourceLocation(Record, Idx));
859 }
860 
861 void ASTStmtReader::VisitObjCSelectorExpr(ObjCSelectorExpr *E) {
862   VisitExpr(E);
863   E->setSelector(Reader.GetSelector(Record, Idx));
864   E->setAtLoc(ReadSourceLocation(Record, Idx));
865   E->setRParenLoc(ReadSourceLocation(Record, Idx));
866 }
867 
868 void ASTStmtReader::VisitObjCProtocolExpr(ObjCProtocolExpr *E) {
869   VisitExpr(E);
870   E->setProtocol(cast<ObjCProtocolDecl>(Reader.GetDecl(Record[Idx++])));
871   E->setAtLoc(ReadSourceLocation(Record, Idx));
872   E->setRParenLoc(ReadSourceLocation(Record, Idx));
873 }
874 
875 void ASTStmtReader::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
876   VisitExpr(E);
877   E->setDecl(cast<ObjCIvarDecl>(Reader.GetDecl(Record[Idx++])));
878   E->setLocation(ReadSourceLocation(Record, Idx));
879   E->setBase(Reader.ReadSubExpr());
880   E->setIsArrow(Record[Idx++]);
881   E->setIsFreeIvar(Record[Idx++]);
882 }
883 
884 void ASTStmtReader::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
885   VisitExpr(E);
886   bool Implicit = Record[Idx++] != 0;
887   if (Implicit) {
888     ObjCMethodDecl *Getter =
889       cast<ObjCMethodDecl>(Reader.GetDecl(Record[Idx++]));
890     ObjCMethodDecl *Setter =
891       cast<ObjCMethodDecl>(Reader.GetDecl(Record[Idx++]));
892     E->setImplicitProperty(Getter, Setter);
893   } else {
894     E->setExplicitProperty(
895                       cast<ObjCPropertyDecl>(Reader.GetDecl(Record[Idx++])));
896   }
897   E->setLocation(ReadSourceLocation(Record, Idx));
898   E->setReceiverLocation(ReadSourceLocation(Record, Idx));
899   switch (Record[Idx++]) {
900   case 0:
901     E->setBase(Reader.ReadSubExpr());
902     break;
903   case 1:
904     E->setSuperReceiver(Reader.GetType(Record[Idx++]));
905     break;
906   case 2:
907     E->setClassReceiver(
908                      cast<ObjCInterfaceDecl>(Reader.GetDecl(Record[Idx++])));
909     break;
910   }
911 }
912 
913 void ASTStmtReader::VisitObjCMessageExpr(ObjCMessageExpr *E) {
914   VisitExpr(E);
915   assert(Record[Idx] == E->getNumArgs());
916   ++Idx;
917   ObjCMessageExpr::ReceiverKind Kind
918     = static_cast<ObjCMessageExpr::ReceiverKind>(Record[Idx++]);
919   switch (Kind) {
920   case ObjCMessageExpr::Instance:
921     E->setInstanceReceiver(Reader.ReadSubExpr());
922     break;
923 
924   case ObjCMessageExpr::Class:
925     E->setClassReceiver(GetTypeSourceInfo(Record, Idx));
926     break;
927 
928   case ObjCMessageExpr::SuperClass:
929   case ObjCMessageExpr::SuperInstance: {
930     QualType T = Reader.GetType(Record[Idx++]);
931     SourceLocation SuperLoc = ReadSourceLocation(Record, Idx);
932     E->setSuper(SuperLoc, T, Kind == ObjCMessageExpr::SuperInstance);
933     break;
934   }
935   }
936 
937   assert(Kind == E->getReceiverKind());
938 
939   if (Record[Idx++])
940     E->setMethodDecl(cast_or_null<ObjCMethodDecl>(Reader.GetDecl(Record[Idx++])));
941   else
942     E->setSelector(Reader.GetSelector(Record, Idx));
943 
944   E->LBracLoc = ReadSourceLocation(Record, Idx);
945   E->RBracLoc = ReadSourceLocation(Record, Idx);
946   E->SelectorLoc = ReadSourceLocation(Record, Idx);
947 
948   for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
949     E->setArg(I, Reader.ReadSubExpr());
950 }
951 
952 void ASTStmtReader::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
953   VisitStmt(S);
954   S->setElement(Reader.ReadSubStmt());
955   S->setCollection(Reader.ReadSubExpr());
956   S->setBody(Reader.ReadSubStmt());
957   S->setForLoc(ReadSourceLocation(Record, Idx));
958   S->setRParenLoc(ReadSourceLocation(Record, Idx));
959 }
960 
961 void ASTStmtReader::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {
962   VisitStmt(S);
963   S->setCatchBody(Reader.ReadSubStmt());
964   S->setCatchParamDecl(cast_or_null<VarDecl>(Reader.GetDecl(Record[Idx++])));
965   S->setAtCatchLoc(ReadSourceLocation(Record, Idx));
966   S->setRParenLoc(ReadSourceLocation(Record, Idx));
967 }
968 
969 void ASTStmtReader::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
970   VisitStmt(S);
971   S->setFinallyBody(Reader.ReadSubStmt());
972   S->setAtFinallyLoc(ReadSourceLocation(Record, Idx));
973 }
974 
975 void ASTStmtReader::VisitObjCAtTryStmt(ObjCAtTryStmt *S) {
976   VisitStmt(S);
977   assert(Record[Idx] == S->getNumCatchStmts());
978   ++Idx;
979   bool HasFinally = Record[Idx++];
980   S->setTryBody(Reader.ReadSubStmt());
981   for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I)
982     S->setCatchStmt(I, cast_or_null<ObjCAtCatchStmt>(Reader.ReadSubStmt()));
983 
984   if (HasFinally)
985     S->setFinallyStmt(Reader.ReadSubStmt());
986   S->setAtTryLoc(ReadSourceLocation(Record, Idx));
987 }
988 
989 void ASTStmtReader::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) {
990   VisitStmt(S);
991   S->setSynchExpr(Reader.ReadSubStmt());
992   S->setSynchBody(Reader.ReadSubStmt());
993   S->setAtSynchronizedLoc(ReadSourceLocation(Record, Idx));
994 }
995 
996 void ASTStmtReader::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {
997   VisitStmt(S);
998   S->setThrowExpr(Reader.ReadSubStmt());
999   S->setThrowLoc(ReadSourceLocation(Record, Idx));
1000 }
1001 
1002 //===----------------------------------------------------------------------===//
1003 // C++ Expressions and Statements
1004 //===----------------------------------------------------------------------===//
1005 
1006 void ASTStmtReader::VisitCXXCatchStmt(CXXCatchStmt *S) {
1007   VisitStmt(S);
1008   S->CatchLoc = ReadSourceLocation(Record, Idx);
1009   S->ExceptionDecl = cast_or_null<VarDecl>(Reader.GetDecl(Record[Idx++]));
1010   S->HandlerBlock = Reader.ReadSubStmt();
1011 }
1012 
1013 void ASTStmtReader::VisitCXXTryStmt(CXXTryStmt *S) {
1014   VisitStmt(S);
1015   assert(Record[Idx] == S->getNumHandlers() && "NumStmtFields is wrong ?");
1016   ++Idx;
1017   S->TryLoc = ReadSourceLocation(Record, Idx);
1018   S->getStmts()[0] = Reader.ReadSubStmt();
1019   for (unsigned i = 0, e = S->getNumHandlers(); i != e; ++i)
1020     S->getStmts()[i + 1] = Reader.ReadSubStmt();
1021 }
1022 
1023 void ASTStmtReader::VisitCXXForRangeStmt(CXXForRangeStmt *S) {
1024   VisitStmt(S);
1025   S->setForLoc(ReadSourceLocation(Record, Idx));
1026   S->setColonLoc(ReadSourceLocation(Record, Idx));
1027   S->setRParenLoc(ReadSourceLocation(Record, Idx));
1028   S->setRangeStmt(Reader.ReadSubStmt());
1029   S->setBeginEndStmt(Reader.ReadSubStmt());
1030   S->setCond(Reader.ReadSubExpr());
1031   S->setInc(Reader.ReadSubExpr());
1032   S->setLoopVarStmt(Reader.ReadSubStmt());
1033   S->setBody(Reader.ReadSubStmt());
1034 }
1035 
1036 void ASTStmtReader::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
1037   VisitCallExpr(E);
1038   E->setOperator((OverloadedOperatorKind)Record[Idx++]);
1039 }
1040 
1041 void ASTStmtReader::VisitCXXConstructExpr(CXXConstructExpr *E) {
1042   VisitExpr(E);
1043   E->NumArgs = Record[Idx++];
1044   if (E->NumArgs)
1045     E->Args = new (*Reader.getContext()) Stmt*[E->NumArgs];
1046   for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
1047     E->setArg(I, Reader.ReadSubExpr());
1048   E->setConstructor(cast<CXXConstructorDecl>(Reader.GetDecl(Record[Idx++])));
1049   E->setLocation(ReadSourceLocation(Record, Idx));
1050   E->setElidable(Record[Idx++]);
1051   E->setRequiresZeroInitialization(Record[Idx++]);
1052   E->setConstructionKind((CXXConstructExpr::ConstructionKind)Record[Idx++]);
1053   E->ParenRange = ReadSourceRange(Record, Idx);
1054 }
1055 
1056 void ASTStmtReader::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) {
1057   VisitCXXConstructExpr(E);
1058   E->Type = GetTypeSourceInfo(Record, Idx);
1059 }
1060 
1061 void ASTStmtReader::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
1062   VisitExplicitCastExpr(E);
1063   SourceRange R = ReadSourceRange(Record, Idx);
1064   E->Loc = R.getBegin();
1065   E->RParenLoc = R.getEnd();
1066 }
1067 
1068 void ASTStmtReader::VisitCXXStaticCastExpr(CXXStaticCastExpr *E) {
1069   return VisitCXXNamedCastExpr(E);
1070 }
1071 
1072 void ASTStmtReader::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E) {
1073   return VisitCXXNamedCastExpr(E);
1074 }
1075 
1076 void ASTStmtReader::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E) {
1077   return VisitCXXNamedCastExpr(E);
1078 }
1079 
1080 void ASTStmtReader::VisitCXXConstCastExpr(CXXConstCastExpr *E) {
1081   return VisitCXXNamedCastExpr(E);
1082 }
1083 
1084 void ASTStmtReader::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) {
1085   VisitExplicitCastExpr(E);
1086   E->setTypeBeginLoc(ReadSourceLocation(Record, Idx));
1087   E->setRParenLoc(ReadSourceLocation(Record, Idx));
1088 }
1089 
1090 void ASTStmtReader::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
1091   VisitExpr(E);
1092   E->setValue(Record[Idx++]);
1093   E->setLocation(ReadSourceLocation(Record, Idx));
1094 }
1095 
1096 void ASTStmtReader::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {
1097   VisitExpr(E);
1098   E->setLocation(ReadSourceLocation(Record, Idx));
1099 }
1100 
1101 void ASTStmtReader::VisitCXXTypeidExpr(CXXTypeidExpr *E) {
1102   VisitExpr(E);
1103   E->setSourceRange(ReadSourceRange(Record, Idx));
1104   if (E->isTypeOperand()) { // typeid(int)
1105     E->setTypeOperandSourceInfo(
1106         GetTypeSourceInfo(Record, Idx));
1107     return;
1108   }
1109 
1110   // typeid(42+2)
1111   E->setExprOperand(Reader.ReadSubExpr());
1112 }
1113 void ASTStmtReader::VisitCXXUuidofExpr(CXXUuidofExpr *E) {
1114   VisitExpr(E);
1115   E->setSourceRange(ReadSourceRange(Record, Idx));
1116   if (E->isTypeOperand()) { // __uuidof(ComType)
1117     E->setTypeOperandSourceInfo(
1118         GetTypeSourceInfo(Record, Idx));
1119     return;
1120   }
1121 
1122   // __uuidof(expr)
1123   E->setExprOperand(Reader.ReadSubExpr());
1124 }
1125 
1126 void ASTStmtReader::VisitCXXThisExpr(CXXThisExpr *E) {
1127   VisitExpr(E);
1128   E->setLocation(ReadSourceLocation(Record, Idx));
1129   E->setImplicit(Record[Idx++]);
1130 }
1131 
1132 void ASTStmtReader::VisitCXXThrowExpr(CXXThrowExpr *E) {
1133   VisitExpr(E);
1134   E->setThrowLoc(ReadSourceLocation(Record, Idx));
1135   E->setSubExpr(Reader.ReadSubExpr());
1136 }
1137 
1138 void ASTStmtReader::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
1139   VisitExpr(E);
1140 
1141   assert(Record[Idx] == E->Param.getInt() && "We messed up at creation ?");
1142   ++Idx; // HasOtherExprStored and SubExpr was handled during creation.
1143   E->Param.setPointer(cast<ParmVarDecl>(Reader.GetDecl(Record[Idx++])));
1144   E->Loc = ReadSourceLocation(Record, Idx);
1145 }
1146 
1147 void ASTStmtReader::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
1148   VisitExpr(E);
1149   E->setTemporary(Reader.ReadCXXTemporary(Record, Idx));
1150   E->setSubExpr(Reader.ReadSubExpr());
1151 }
1152 
1153 void ASTStmtReader::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
1154   VisitExpr(E);
1155   E->TypeInfo = GetTypeSourceInfo(Record, Idx);
1156   E->RParenLoc = ReadSourceLocation(Record, Idx);
1157 }
1158 
1159 void ASTStmtReader::VisitCXXNewExpr(CXXNewExpr *E) {
1160   VisitExpr(E);
1161   E->GlobalNew = Record[Idx++];
1162   E->Initializer = Record[Idx++];
1163   E->UsualArrayDeleteWantsSize = Record[Idx++];
1164   bool isArray = Record[Idx++];
1165   unsigned NumPlacementArgs = Record[Idx++];
1166   unsigned NumCtorArgs = Record[Idx++];
1167   E->setOperatorNew(cast_or_null<FunctionDecl>(Reader.GetDecl(Record[Idx++])));
1168   E->setOperatorDelete(
1169                     cast_or_null<FunctionDecl>(Reader.GetDecl(Record[Idx++])));
1170   E->setConstructor(
1171                cast_or_null<CXXConstructorDecl>(Reader.GetDecl(Record[Idx++])));
1172   E->AllocatedTypeInfo = GetTypeSourceInfo(Record, Idx);
1173   SourceRange TypeIdParens;
1174   TypeIdParens.setBegin(ReadSourceLocation(Record, Idx));
1175   TypeIdParens.setEnd(ReadSourceLocation(Record, Idx));
1176   E->TypeIdParens = TypeIdParens;
1177   E->StartLoc = ReadSourceLocation(Record, Idx);
1178   E->EndLoc = ReadSourceLocation(Record, Idx);
1179   E->ConstructorLParen = ReadSourceLocation(Record, Idx);
1180   E->ConstructorRParen = ReadSourceLocation(Record, Idx);
1181 
1182   E->AllocateArgsArray(*Reader.getContext(), isArray, NumPlacementArgs,
1183                        NumCtorArgs);
1184 
1185   // Install all the subexpressions.
1186   for (CXXNewExpr::raw_arg_iterator I = E->raw_arg_begin(),e = E->raw_arg_end();
1187        I != e; ++I)
1188     *I = Reader.ReadSubStmt();
1189 }
1190 
1191 void ASTStmtReader::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
1192   VisitExpr(E);
1193   E->GlobalDelete = Record[Idx++];
1194   E->ArrayForm = Record[Idx++];
1195   E->ArrayFormAsWritten = Record[Idx++];
1196   E->UsualArrayDeleteWantsSize = Record[Idx++];
1197   E->OperatorDelete = cast_or_null<FunctionDecl>(Reader.GetDecl(Record[Idx++]));
1198   E->Argument = Reader.ReadSubExpr();
1199   E->Loc = ReadSourceLocation(Record, Idx);
1200 }
1201 
1202 void ASTStmtReader::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) {
1203   VisitExpr(E);
1204 
1205   E->Base = Reader.ReadSubExpr();
1206   E->IsArrow = Record[Idx++];
1207   E->OperatorLoc = ReadSourceLocation(Record, Idx);
1208   E->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1209   E->ScopeType = GetTypeSourceInfo(Record, Idx);
1210   E->ColonColonLoc = ReadSourceLocation(Record, Idx);
1211   E->TildeLoc = ReadSourceLocation(Record, Idx);
1212 
1213   IdentifierInfo *II = Reader.GetIdentifierInfo(Record, Idx);
1214   if (II)
1215     E->setDestroyedType(II, ReadSourceLocation(Record, Idx));
1216   else
1217     E->setDestroyedType(GetTypeSourceInfo(Record, Idx));
1218 }
1219 
1220 void ASTStmtReader::VisitExprWithCleanups(ExprWithCleanups *E) {
1221   VisitExpr(E);
1222   unsigned NumTemps = Record[Idx++];
1223   if (NumTemps) {
1224     E->setNumTemporaries(*Reader.getContext(), NumTemps);
1225     for (unsigned i = 0; i != NumTemps; ++i)
1226       E->setTemporary(i, Reader.ReadCXXTemporary(Record, Idx));
1227   }
1228   E->setSubExpr(Reader.ReadSubExpr());
1229 }
1230 
1231 void
1232 ASTStmtReader::VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E){
1233   VisitExpr(E);
1234 
1235   if (Record[Idx++])
1236     ReadExplicitTemplateArgumentList(E->getExplicitTemplateArgs(),
1237                                      Record[Idx++]);
1238 
1239   E->Base = Reader.ReadSubExpr();
1240   E->BaseType = Reader.GetType(Record[Idx++]);
1241   E->IsArrow = Record[Idx++];
1242   E->OperatorLoc = ReadSourceLocation(Record, Idx);
1243   E->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1244   E->FirstQualifierFoundInScope
1245                       = cast_or_null<NamedDecl>(Reader.GetDecl(Record[Idx++]));
1246   ReadDeclarationNameInfo(E->MemberNameInfo, Record, Idx);
1247 }
1248 
1249 void
1250 ASTStmtReader::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
1251   VisitExpr(E);
1252 
1253   if (Record[Idx++])
1254     ReadExplicitTemplateArgumentList(E->getExplicitTemplateArgs(),
1255                                      Record[Idx++]);
1256 
1257   E->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1258   ReadDeclarationNameInfo(E->NameInfo, Record, Idx);
1259 }
1260 
1261 void
1262 ASTStmtReader::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) {
1263   VisitExpr(E);
1264   assert(Record[Idx] == E->arg_size() && "Read wrong record during creation ?");
1265   ++Idx; // NumArgs;
1266   for (unsigned I = 0, N = E->arg_size(); I != N; ++I)
1267     E->setArg(I, Reader.ReadSubExpr());
1268   E->Type = GetTypeSourceInfo(Record, Idx);
1269   E->setLParenLoc(ReadSourceLocation(Record, Idx));
1270   E->setRParenLoc(ReadSourceLocation(Record, Idx));
1271 }
1272 
1273 void ASTStmtReader::VisitOverloadExpr(OverloadExpr *E) {
1274   VisitExpr(E);
1275 
1276   // Read the explicit template argument list, if available.
1277   if (Record[Idx++])
1278     ReadExplicitTemplateArgumentList(E->getExplicitTemplateArgs(),
1279                                      Record[Idx++]);
1280 
1281   unsigned NumDecls = Record[Idx++];
1282   UnresolvedSet<8> Decls;
1283   for (unsigned i = 0; i != NumDecls; ++i) {
1284     NamedDecl *D = cast<NamedDecl>(Reader.GetDecl(Record[Idx++]));
1285     AccessSpecifier AS = (AccessSpecifier)Record[Idx++];
1286     Decls.addDecl(D, AS);
1287   }
1288   E->initializeResults(*Reader.getContext(), Decls.begin(), Decls.end());
1289 
1290   ReadDeclarationNameInfo(E->NameInfo, Record, Idx);
1291   E->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1292 }
1293 
1294 void ASTStmtReader::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) {
1295   VisitOverloadExpr(E);
1296   E->IsArrow = Record[Idx++];
1297   E->HasUnresolvedUsing = Record[Idx++];
1298   E->Base = Reader.ReadSubExpr();
1299   E->BaseType = Reader.GetType(Record[Idx++]);
1300   E->OperatorLoc = ReadSourceLocation(Record, Idx);
1301 }
1302 
1303 void ASTStmtReader::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
1304   VisitOverloadExpr(E);
1305   E->RequiresADL = Record[Idx++];
1306   if (E->RequiresADL)
1307     E->StdIsAssociatedNamespace = Record[Idx++];
1308   E->Overloaded = Record[Idx++];
1309   E->NamingClass = cast_or_null<CXXRecordDecl>(Reader.GetDecl(Record[Idx++]));
1310 }
1311 
1312 void ASTStmtReader::VisitUnaryTypeTraitExpr(UnaryTypeTraitExpr *E) {
1313   VisitExpr(E);
1314   E->UTT = (UnaryTypeTrait)Record[Idx++];
1315   E->Value = (bool)Record[Idx++];
1316   SourceRange Range = ReadSourceRange(Record, Idx);
1317   E->Loc = Range.getBegin();
1318   E->RParen = Range.getEnd();
1319   E->QueriedType = GetTypeSourceInfo(Record, Idx);
1320 }
1321 
1322 void ASTStmtReader::VisitBinaryTypeTraitExpr(BinaryTypeTraitExpr *E) {
1323   VisitExpr(E);
1324   E->BTT = (BinaryTypeTrait)Record[Idx++];
1325   E->Value = (bool)Record[Idx++];
1326   SourceRange Range = ReadSourceRange(Record, Idx);
1327   E->Loc = Range.getBegin();
1328   E->RParen = Range.getEnd();
1329   E->LhsType = GetTypeSourceInfo(Record, Idx);
1330   E->RhsType = GetTypeSourceInfo(Record, Idx);
1331 }
1332 
1333 void ASTStmtReader::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
1334   VisitExpr(E);
1335   E->Value = (bool)Record[Idx++];
1336   E->Range = ReadSourceRange(Record, Idx);
1337   E->Operand = Reader.ReadSubExpr();
1338 }
1339 
1340 void ASTStmtReader::VisitPackExpansionExpr(PackExpansionExpr *E) {
1341   VisitExpr(E);
1342   E->EllipsisLoc = ReadSourceLocation(Record, Idx);
1343   E->NumExpansions = Record[Idx++];
1344   E->Pattern = Reader.ReadSubExpr();
1345 }
1346 
1347 void ASTStmtReader::VisitSizeOfPackExpr(SizeOfPackExpr *E) {
1348   VisitExpr(E);
1349   E->OperatorLoc = ReadSourceLocation(Record, Idx);
1350   E->PackLoc = ReadSourceLocation(Record, Idx);
1351   E->RParenLoc = ReadSourceLocation(Record, Idx);
1352   E->Length = Record[Idx++];
1353   E->Pack = cast_or_null<NamedDecl>(Reader.GetDecl(Record[Idx++]));
1354 }
1355 
1356 void ASTStmtReader::VisitSubstNonTypeTemplateParmPackExpr(
1357                                           SubstNonTypeTemplateParmPackExpr *E) {
1358   VisitExpr(E);
1359   E->Param
1360     = cast_or_null<NonTypeTemplateParmDecl>(Reader.GetDecl(Record[Idx++]));
1361   TemplateArgument ArgPack = Reader.ReadTemplateArgument(F, Record, Idx);
1362   if (ArgPack.getKind() != TemplateArgument::Pack)
1363     return;
1364 
1365   E->Arguments = ArgPack.pack_begin();
1366   E->NumArguments = ArgPack.pack_size();
1367   E->NameLoc = ReadSourceLocation(Record, Idx);
1368 }
1369 
1370 void ASTStmtReader::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
1371   VisitExpr(E);
1372   Idx++; // skip ID
1373   E->Loc = ReadSourceLocation(Record, Idx);
1374 }
1375 
1376 //===----------------------------------------------------------------------===//
1377 // CUDA Expressions and Statements
1378 //===----------------------------------------------------------------------===//
1379 
1380 void ASTStmtReader::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *E) {
1381   VisitCallExpr(E);
1382   E->setConfig(cast<CallExpr>(Reader.ReadSubExpr()));
1383 }
1384 
1385 Stmt *ASTReader::ReadStmt(PerFileData &F) {
1386   switch (ReadingKind) {
1387   case Read_Decl:
1388   case Read_Type:
1389     return ReadStmtFromStream(F);
1390   case Read_Stmt:
1391     return ReadSubStmt();
1392   }
1393 
1394   llvm_unreachable("ReadingKind not set ?");
1395   return 0;
1396 }
1397 
1398 Expr *ASTReader::ReadExpr(PerFileData &F) {
1399   return cast_or_null<Expr>(ReadStmt(F));
1400 }
1401 
1402 Expr *ASTReader::ReadSubExpr() {
1403   return cast_or_null<Expr>(ReadSubStmt());
1404 }
1405 
1406 // Within the bitstream, expressions are stored in Reverse Polish
1407 // Notation, with each of the subexpressions preceding the
1408 // expression they are stored in. Subexpressions are stored from last to first.
1409 // To evaluate expressions, we continue reading expressions and placing them on
1410 // the stack, with expressions having operands removing those operands from the
1411 // stack. Evaluation terminates when we see a STMT_STOP record, and
1412 // the single remaining expression on the stack is our result.
1413 Stmt *ASTReader::ReadStmtFromStream(PerFileData &F) {
1414 
1415   ReadingKindTracker ReadingKind(Read_Stmt, *this);
1416   llvm::BitstreamCursor &Cursor = F.DeclsCursor;
1417 
1418 #ifndef NDEBUG
1419   unsigned PrevNumStmts = StmtStack.size();
1420 #endif
1421 
1422   RecordData Record;
1423   unsigned Idx;
1424   ASTStmtReader Reader(*this, F, Cursor, Record, Idx);
1425   Stmt::EmptyShell Empty;
1426 
1427   while (true) {
1428     unsigned Code = Cursor.ReadCode();
1429     if (Code == llvm::bitc::END_BLOCK) {
1430       if (Cursor.ReadBlockEnd()) {
1431         Error("error at end of block in AST file");
1432         return 0;
1433       }
1434       break;
1435     }
1436 
1437     if (Code == llvm::bitc::ENTER_SUBBLOCK) {
1438       // No known subblocks, always skip them.
1439       Cursor.ReadSubBlockID();
1440       if (Cursor.SkipBlock()) {
1441         Error("malformed block record in AST file");
1442         return 0;
1443       }
1444       continue;
1445     }
1446 
1447     if (Code == llvm::bitc::DEFINE_ABBREV) {
1448       Cursor.ReadAbbrevRecord();
1449       continue;
1450     }
1451 
1452     Stmt *S = 0;
1453     Idx = 0;
1454     Record.clear();
1455     bool Finished = false;
1456     switch ((StmtCode)Cursor.ReadRecord(Code, Record)) {
1457     case STMT_STOP:
1458       Finished = true;
1459       break;
1460 
1461     case STMT_NULL_PTR:
1462       S = 0;
1463       break;
1464 
1465     case STMT_NULL:
1466       S = new (Context) NullStmt(Empty);
1467       break;
1468 
1469     case STMT_COMPOUND:
1470       S = new (Context) CompoundStmt(Empty);
1471       break;
1472 
1473     case STMT_CASE:
1474       S = new (Context) CaseStmt(Empty);
1475       break;
1476 
1477     case STMT_DEFAULT:
1478       S = new (Context) DefaultStmt(Empty);
1479       break;
1480 
1481     case STMT_LABEL:
1482       S = new (Context) LabelStmt(Empty);
1483       break;
1484 
1485     case STMT_IF:
1486       S = new (Context) IfStmt(Empty);
1487       break;
1488 
1489     case STMT_SWITCH:
1490       S = new (Context) SwitchStmt(Empty);
1491       break;
1492 
1493     case STMT_WHILE:
1494       S = new (Context) WhileStmt(Empty);
1495       break;
1496 
1497     case STMT_DO:
1498       S = new (Context) DoStmt(Empty);
1499       break;
1500 
1501     case STMT_FOR:
1502       S = new (Context) ForStmt(Empty);
1503       break;
1504 
1505     case STMT_GOTO:
1506       S = new (Context) GotoStmt(Empty);
1507       break;
1508 
1509     case STMT_INDIRECT_GOTO:
1510       S = new (Context) IndirectGotoStmt(Empty);
1511       break;
1512 
1513     case STMT_CONTINUE:
1514       S = new (Context) ContinueStmt(Empty);
1515       break;
1516 
1517     case STMT_BREAK:
1518       S = new (Context) BreakStmt(Empty);
1519       break;
1520 
1521     case STMT_RETURN:
1522       S = new (Context) ReturnStmt(Empty);
1523       break;
1524 
1525     case STMT_DECL:
1526       S = new (Context) DeclStmt(Empty);
1527       break;
1528 
1529     case STMT_ASM:
1530       S = new (Context) AsmStmt(Empty);
1531       break;
1532 
1533     case EXPR_PREDEFINED:
1534       S = new (Context) PredefinedExpr(Empty);
1535       break;
1536 
1537     case EXPR_DECL_REF:
1538       S = DeclRefExpr::CreateEmpty(*Context,
1539                          /*HasQualifier=*/Record[ASTStmtReader::NumExprFields],
1540           /*HasExplicitTemplateArgs=*/Record[ASTStmtReader::NumExprFields + 1],
1541                   /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields + 1]
1542                                    ? Record[ASTStmtReader::NumExprFields + 2]
1543                                    : 0);
1544       break;
1545 
1546     case EXPR_INTEGER_LITERAL:
1547       S = IntegerLiteral::Create(*Context, Empty);
1548       break;
1549 
1550     case EXPR_FLOATING_LITERAL:
1551       S = FloatingLiteral::Create(*Context, Empty);
1552       break;
1553 
1554     case EXPR_IMAGINARY_LITERAL:
1555       S = new (Context) ImaginaryLiteral(Empty);
1556       break;
1557 
1558     case EXPR_STRING_LITERAL:
1559       S = StringLiteral::CreateEmpty(*Context,
1560                                      Record[ASTStmtReader::NumExprFields + 1]);
1561       break;
1562 
1563     case EXPR_CHARACTER_LITERAL:
1564       S = new (Context) CharacterLiteral(Empty);
1565       break;
1566 
1567     case EXPR_PAREN:
1568       S = new (Context) ParenExpr(Empty);
1569       break;
1570 
1571     case EXPR_PAREN_LIST:
1572       S = new (Context) ParenListExpr(Empty);
1573       break;
1574 
1575     case EXPR_UNARY_OPERATOR:
1576       S = new (Context) UnaryOperator(Empty);
1577       break;
1578 
1579     case EXPR_OFFSETOF:
1580       S = OffsetOfExpr::CreateEmpty(*Context,
1581                                     Record[ASTStmtReader::NumExprFields],
1582                                     Record[ASTStmtReader::NumExprFields + 1]);
1583       break;
1584 
1585     case EXPR_SIZEOF_ALIGN_OF:
1586       S = new (Context) UnaryExprOrTypeTraitExpr(Empty);
1587       break;
1588 
1589     case EXPR_ARRAY_SUBSCRIPT:
1590       S = new (Context) ArraySubscriptExpr(Empty);
1591       break;
1592 
1593     case EXPR_CALL:
1594       S = new (Context) CallExpr(*Context, Stmt::CallExprClass, Empty);
1595       break;
1596 
1597     case EXPR_MEMBER: {
1598       // We load everything here and fully initialize it at creation.
1599       // That way we can use MemberExpr::Create and don't have to duplicate its
1600       // logic with a MemberExpr::CreateEmpty.
1601 
1602       assert(Idx == 0);
1603       NestedNameSpecifierLoc QualifierLoc;
1604       if (Record[Idx++]) { // HasQualifier.
1605         QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, Idx);
1606       }
1607 
1608       TemplateArgumentListInfo ArgInfo;
1609       bool HasExplicitTemplateArgs = Record[Idx++];
1610       if (HasExplicitTemplateArgs) {
1611         unsigned NumTemplateArgs = Record[Idx++];
1612         ArgInfo.setLAngleLoc(ReadSourceLocation(F, Record, Idx));
1613         ArgInfo.setRAngleLoc(ReadSourceLocation(F, Record, Idx));
1614         for (unsigned i = 0; i != NumTemplateArgs; ++i)
1615           ArgInfo.addArgument(ReadTemplateArgumentLoc(F, Record, Idx));
1616       }
1617 
1618       NamedDecl *FoundD = cast_or_null<NamedDecl>(GetDecl(Record[Idx++]));
1619       AccessSpecifier AS = (AccessSpecifier)Record[Idx++];
1620       DeclAccessPair FoundDecl = DeclAccessPair::make(FoundD, AS);
1621 
1622       QualType T = GetType(Record[Idx++]);
1623       ExprValueKind VK = static_cast<ExprValueKind>(Record[Idx++]);
1624       ExprObjectKind OK = static_cast<ExprObjectKind>(Record[Idx++]);
1625       Expr *Base = ReadSubExpr();
1626       ValueDecl *MemberD = cast<ValueDecl>(GetDecl(Record[Idx++]));
1627       SourceLocation MemberLoc = ReadSourceLocation(F, Record, Idx);
1628       DeclarationNameInfo MemberNameInfo(MemberD->getDeclName(), MemberLoc);
1629       bool IsArrow = Record[Idx++];
1630 
1631       S = MemberExpr::Create(*Context, Base, IsArrow, QualifierLoc,
1632                              MemberD, FoundDecl, MemberNameInfo,
1633                              HasExplicitTemplateArgs ? &ArgInfo : 0, T, VK, OK);
1634       ReadDeclarationNameLoc(F, cast<MemberExpr>(S)->MemberDNLoc,
1635                              MemberD->getDeclName(), Record, Idx);
1636       break;
1637     }
1638 
1639     case EXPR_BINARY_OPERATOR:
1640       S = new (Context) BinaryOperator(Empty);
1641       break;
1642 
1643     case EXPR_COMPOUND_ASSIGN_OPERATOR:
1644       S = new (Context) CompoundAssignOperator(Empty);
1645       break;
1646 
1647     case EXPR_CONDITIONAL_OPERATOR:
1648       S = new (Context) ConditionalOperator(Empty);
1649       break;
1650 
1651     case EXPR_BINARY_CONDITIONAL_OPERATOR:
1652       S = new (Context) BinaryConditionalOperator(Empty);
1653       break;
1654 
1655     case EXPR_IMPLICIT_CAST:
1656       S = ImplicitCastExpr::CreateEmpty(*Context,
1657                        /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
1658       break;
1659 
1660     case EXPR_CSTYLE_CAST:
1661       S = CStyleCastExpr::CreateEmpty(*Context,
1662                        /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
1663       break;
1664 
1665     case EXPR_COMPOUND_LITERAL:
1666       S = new (Context) CompoundLiteralExpr(Empty);
1667       break;
1668 
1669     case EXPR_EXT_VECTOR_ELEMENT:
1670       S = new (Context) ExtVectorElementExpr(Empty);
1671       break;
1672 
1673     case EXPR_INIT_LIST:
1674       S = new (Context) InitListExpr(*getContext(), Empty);
1675       break;
1676 
1677     case EXPR_DESIGNATED_INIT:
1678       S = DesignatedInitExpr::CreateEmpty(*Context,
1679                                      Record[ASTStmtReader::NumExprFields] - 1);
1680 
1681       break;
1682 
1683     case EXPR_IMPLICIT_VALUE_INIT:
1684       S = new (Context) ImplicitValueInitExpr(Empty);
1685       break;
1686 
1687     case EXPR_VA_ARG:
1688       S = new (Context) VAArgExpr(Empty);
1689       break;
1690 
1691     case EXPR_ADDR_LABEL:
1692       S = new (Context) AddrLabelExpr(Empty);
1693       break;
1694 
1695     case EXPR_STMT:
1696       S = new (Context) StmtExpr(Empty);
1697       break;
1698 
1699     case EXPR_CHOOSE:
1700       S = new (Context) ChooseExpr(Empty);
1701       break;
1702 
1703     case EXPR_GNU_NULL:
1704       S = new (Context) GNUNullExpr(Empty);
1705       break;
1706 
1707     case EXPR_SHUFFLE_VECTOR:
1708       S = new (Context) ShuffleVectorExpr(Empty);
1709       break;
1710 
1711     case EXPR_BLOCK:
1712       S = new (Context) BlockExpr(Empty);
1713       break;
1714 
1715     case EXPR_BLOCK_DECL_REF:
1716       S = new (Context) BlockDeclRefExpr(Empty);
1717       break;
1718 
1719     case EXPR_GENERIC_SELECTION:
1720       S = new (Context) GenericSelectionExpr(Empty);
1721       break;
1722 
1723     case EXPR_OBJC_STRING_LITERAL:
1724       S = new (Context) ObjCStringLiteral(Empty);
1725       break;
1726     case EXPR_OBJC_ENCODE:
1727       S = new (Context) ObjCEncodeExpr(Empty);
1728       break;
1729     case EXPR_OBJC_SELECTOR_EXPR:
1730       S = new (Context) ObjCSelectorExpr(Empty);
1731       break;
1732     case EXPR_OBJC_PROTOCOL_EXPR:
1733       S = new (Context) ObjCProtocolExpr(Empty);
1734       break;
1735     case EXPR_OBJC_IVAR_REF_EXPR:
1736       S = new (Context) ObjCIvarRefExpr(Empty);
1737       break;
1738     case EXPR_OBJC_PROPERTY_REF_EXPR:
1739       S = new (Context) ObjCPropertyRefExpr(Empty);
1740       break;
1741     case EXPR_OBJC_KVC_REF_EXPR:
1742       llvm_unreachable("mismatching AST file");
1743       break;
1744     case EXPR_OBJC_MESSAGE_EXPR:
1745       S = ObjCMessageExpr::CreateEmpty(*Context,
1746                                      Record[ASTStmtReader::NumExprFields]);
1747       break;
1748     case EXPR_OBJC_ISA:
1749       S = new (Context) ObjCIsaExpr(Empty);
1750       break;
1751     case STMT_OBJC_FOR_COLLECTION:
1752       S = new (Context) ObjCForCollectionStmt(Empty);
1753       break;
1754     case STMT_OBJC_CATCH:
1755       S = new (Context) ObjCAtCatchStmt(Empty);
1756       break;
1757     case STMT_OBJC_FINALLY:
1758       S = new (Context) ObjCAtFinallyStmt(Empty);
1759       break;
1760     case STMT_OBJC_AT_TRY:
1761       S = ObjCAtTryStmt::CreateEmpty(*Context,
1762                                      Record[ASTStmtReader::NumStmtFields],
1763                                      Record[ASTStmtReader::NumStmtFields + 1]);
1764       break;
1765     case STMT_OBJC_AT_SYNCHRONIZED:
1766       S = new (Context) ObjCAtSynchronizedStmt(Empty);
1767       break;
1768     case STMT_OBJC_AT_THROW:
1769       S = new (Context) ObjCAtThrowStmt(Empty);
1770       break;
1771 
1772     case STMT_CXX_CATCH:
1773       S = new (Context) CXXCatchStmt(Empty);
1774       break;
1775 
1776     case STMT_CXX_TRY:
1777       S = CXXTryStmt::Create(*Context, Empty,
1778              /*NumHandlers=*/Record[ASTStmtReader::NumStmtFields]);
1779       break;
1780 
1781     case STMT_CXX_FOR_RANGE:
1782       S = new (Context) CXXForRangeStmt(Empty);
1783       break;
1784 
1785     case EXPR_CXX_OPERATOR_CALL:
1786       S = new (Context) CXXOperatorCallExpr(*Context, Empty);
1787       break;
1788 
1789     case EXPR_CXX_MEMBER_CALL:
1790       S = new (Context) CXXMemberCallExpr(*Context, Empty);
1791       break;
1792 
1793     case EXPR_CXX_CONSTRUCT:
1794       S = new (Context) CXXConstructExpr(Empty);
1795       break;
1796 
1797     case EXPR_CXX_TEMPORARY_OBJECT:
1798       S = new (Context) CXXTemporaryObjectExpr(Empty);
1799       break;
1800 
1801     case EXPR_CXX_STATIC_CAST:
1802       S = CXXStaticCastExpr::CreateEmpty(*Context,
1803                        /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
1804       break;
1805 
1806     case EXPR_CXX_DYNAMIC_CAST:
1807       S = CXXDynamicCastExpr::CreateEmpty(*Context,
1808                        /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
1809       break;
1810 
1811     case EXPR_CXX_REINTERPRET_CAST:
1812       S = CXXReinterpretCastExpr::CreateEmpty(*Context,
1813                        /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
1814       break;
1815 
1816     case EXPR_CXX_CONST_CAST:
1817       S = CXXConstCastExpr::CreateEmpty(*Context);
1818       break;
1819 
1820     case EXPR_CXX_FUNCTIONAL_CAST:
1821       S = CXXFunctionalCastExpr::CreateEmpty(*Context,
1822                        /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
1823       break;
1824 
1825     case EXPR_CXX_BOOL_LITERAL:
1826       S = new (Context) CXXBoolLiteralExpr(Empty);
1827       break;
1828 
1829     case EXPR_CXX_NULL_PTR_LITERAL:
1830       S = new (Context) CXXNullPtrLiteralExpr(Empty);
1831       break;
1832     case EXPR_CXX_TYPEID_EXPR:
1833       S = new (Context) CXXTypeidExpr(Empty, true);
1834       break;
1835     case EXPR_CXX_TYPEID_TYPE:
1836       S = new (Context) CXXTypeidExpr(Empty, false);
1837       break;
1838     case EXPR_CXX_UUIDOF_EXPR:
1839       S = new (Context) CXXUuidofExpr(Empty, true);
1840       break;
1841     case EXPR_CXX_UUIDOF_TYPE:
1842       S = new (Context) CXXUuidofExpr(Empty, false);
1843       break;
1844     case EXPR_CXX_THIS:
1845       S = new (Context) CXXThisExpr(Empty);
1846       break;
1847     case EXPR_CXX_THROW:
1848       S = new (Context) CXXThrowExpr(Empty);
1849       break;
1850     case EXPR_CXX_DEFAULT_ARG: {
1851       bool HasOtherExprStored = Record[ASTStmtReader::NumExprFields];
1852       if (HasOtherExprStored) {
1853         Expr *SubExpr = ReadSubExpr();
1854         S = CXXDefaultArgExpr::Create(*Context, SourceLocation(), 0, SubExpr);
1855       } else
1856         S = new (Context) CXXDefaultArgExpr(Empty);
1857       break;
1858     }
1859     case EXPR_CXX_BIND_TEMPORARY:
1860       S = new (Context) CXXBindTemporaryExpr(Empty);
1861       break;
1862 
1863     case EXPR_CXX_SCALAR_VALUE_INIT:
1864       S = new (Context) CXXScalarValueInitExpr(Empty);
1865       break;
1866     case EXPR_CXX_NEW:
1867       S = new (Context) CXXNewExpr(Empty);
1868       break;
1869     case EXPR_CXX_DELETE:
1870       S = new (Context) CXXDeleteExpr(Empty);
1871       break;
1872     case EXPR_CXX_PSEUDO_DESTRUCTOR:
1873       S = new (Context) CXXPseudoDestructorExpr(Empty);
1874       break;
1875 
1876     case EXPR_EXPR_WITH_CLEANUPS:
1877       S = new (Context) ExprWithCleanups(Empty);
1878       break;
1879 
1880     case EXPR_CXX_DEPENDENT_SCOPE_MEMBER:
1881       S = CXXDependentScopeMemberExpr::CreateEmpty(*Context,
1882           /*HasExplicitTemplateArgs=*/Record[ASTStmtReader::NumExprFields],
1883                   /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]
1884                                    ? Record[ASTStmtReader::NumExprFields + 1]
1885                                    : 0);
1886       break;
1887 
1888     case EXPR_CXX_DEPENDENT_SCOPE_DECL_REF:
1889       S = DependentScopeDeclRefExpr::CreateEmpty(*Context,
1890           /*HasExplicitTemplateArgs=*/Record[ASTStmtReader::NumExprFields],
1891                   /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]
1892                                    ? Record[ASTStmtReader::NumExprFields + 1]
1893                                    : 0);
1894       break;
1895 
1896     case EXPR_CXX_UNRESOLVED_CONSTRUCT:
1897       S = CXXUnresolvedConstructExpr::CreateEmpty(*Context,
1898                               /*NumArgs=*/Record[ASTStmtReader::NumExprFields]);
1899       break;
1900 
1901     case EXPR_CXX_UNRESOLVED_MEMBER:
1902       S = UnresolvedMemberExpr::CreateEmpty(*Context,
1903           /*HasExplicitTemplateArgs=*/Record[ASTStmtReader::NumExprFields],
1904                   /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]
1905                                    ? Record[ASTStmtReader::NumExprFields + 1]
1906                                    : 0);
1907       break;
1908 
1909     case EXPR_CXX_UNRESOLVED_LOOKUP:
1910       S = UnresolvedLookupExpr::CreateEmpty(*Context,
1911           /*HasExplicitTemplateArgs=*/Record[ASTStmtReader::NumExprFields],
1912                   /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]
1913                                    ? Record[ASTStmtReader::NumExprFields + 1]
1914                                    : 0);
1915       break;
1916 
1917     case EXPR_CXX_UNARY_TYPE_TRAIT:
1918       S = new (Context) UnaryTypeTraitExpr(Empty);
1919       break;
1920 
1921     case EXPR_BINARY_TYPE_TRAIT:
1922       S = new (Context) BinaryTypeTraitExpr(Empty);
1923       break;
1924 
1925     case EXPR_CXX_NOEXCEPT:
1926       S = new (Context) CXXNoexceptExpr(Empty);
1927       break;
1928 
1929     case EXPR_PACK_EXPANSION:
1930       S = new (Context) PackExpansionExpr(Empty);
1931       break;
1932 
1933     case EXPR_SIZEOF_PACK:
1934       S = new (Context) SizeOfPackExpr(Empty);
1935       break;
1936 
1937     case EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK:
1938       S = new (Context) SubstNonTypeTemplateParmPackExpr(Empty);
1939       break;
1940 
1941     case EXPR_OPAQUE_VALUE: {
1942       unsigned key = Record[ASTStmtReader::NumExprFields];
1943       OpaqueValueExpr *&expr = OpaqueValueExprs[key];
1944 
1945       // If we already have an entry for this opaque value expression,
1946       // don't bother reading it again.
1947       if (expr) {
1948         StmtStack.push_back(expr);
1949         continue;
1950       }
1951 
1952       S = expr = new (Context) OpaqueValueExpr(Empty);
1953       break;
1954     }
1955 
1956     case EXPR_CUDA_KERNEL_CALL:
1957       S = new (Context) CUDAKernelCallExpr(*Context, Empty);
1958       break;
1959     }
1960 
1961     // We hit a STMT_STOP, so we're done with this expression.
1962     if (Finished)
1963       break;
1964 
1965     ++NumStatementsRead;
1966 
1967     if (S)
1968       Reader.Visit(S);
1969 
1970     assert(Idx == Record.size() && "Invalid deserialization of statement");
1971     StmtStack.push_back(S);
1972   }
1973 
1974 #ifndef NDEBUG
1975   assert(StmtStack.size() > PrevNumStmts && "Read too many sub stmts!");
1976   assert(StmtStack.size() == PrevNumStmts + 1 && "Extra expressions on stack!");
1977 #endif
1978 
1979   return StmtStack.pop_back_val();
1980 }
1981