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