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