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