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