contrib/llvm/tools/clang/lib/Serialization/ASTReaderStmt.cpp

   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/ASTContext.h"
  17 #include "clang/AST/DeclCXX.h"
  18 #include "clang/AST/DeclTemplate.h"
  19 #include "clang/AST/StmtVisitor.h"
  20 #include "clang/Lex/Token.h"
  21 #include "llvm/ADT/SmallString.h"
  22 using namespace clang;
  23 using namespace clang::serialization;
  24
  25 namespace clang {
  26
  27   class ASTStmtReader : public StmtVisitor<ASTStmtReader> {
  28     friend class OMPClauseReader;
  29     typedef ASTReader::RecordData RecordData;
  30
  31     ASTReader &Reader;
  32     ModuleFile &F;
  33     llvm::BitstreamCursor &DeclsCursor;
  34     const ASTReader::RecordData &Record;
  35     unsigned &Idx;
  36
  37     Token ReadToken(const RecordData &R, unsigned &I) {
  38       return Reader.ReadToken(F, R, I);
  39     }
  40
  41     SourceLocation ReadSourceLocation(const RecordData &R, unsigned &I) {
  42       return Reader.ReadSourceLocation(F, R, I);
  43     }
  44
  45     SourceRange ReadSourceRange(const RecordData &R, unsigned &I) {
  46       return Reader.ReadSourceRange(F, R, I);
  47     }
  48
  49     std::string ReadString(const RecordData &R, unsigned &I) {
  50       return Reader.ReadString(R, I);
  51     }
  52
  53     TypeSourceInfo *GetTypeSourceInfo(const RecordData &R, unsigned &I) {
  54       return Reader.GetTypeSourceInfo(F, R, I);
  55     }
  56
  57     serialization::DeclID ReadDeclID(const RecordData &R, unsigned &I) {
  58       return Reader.ReadDeclID(F, R, I);
  59     }
  60
  61     Decl *ReadDecl(const RecordData &R, unsigned &I) {
  62       return Reader.ReadDecl(F, R, I);
  63     }
  64
  65     template<typename T>
  66     T *ReadDeclAs(const RecordData &R, unsigned &I) {
  67       return Reader.ReadDeclAs<T>(F, R, I);
  68     }
  69
  70     void ReadDeclarationNameLoc(DeclarationNameLoc &DNLoc, DeclarationName Name,
  71                                 const ASTReader::RecordData &R, unsigned &I) {
  72       Reader.ReadDeclarationNameLoc(F, DNLoc, Name, R, I);
  73     }
  74
  75     void ReadDeclarationNameInfo(DeclarationNameInfo &NameInfo,
  76                                 const ASTReader::RecordData &R, unsigned &I) {
  77       Reader.ReadDeclarationNameInfo(F, NameInfo, R, I);
  78     }
  79
  80   public:
  81     ASTStmtReader(ASTReader &Reader, ModuleFile &F,
  82                   llvm::BitstreamCursor &Cursor,
  83                   const ASTReader::RecordData &Record, unsigned &Idx)
  84       : Reader(Reader), F(F), DeclsCursor(Cursor), Record(Record), Idx(Idx) { }
  85
  86     /// \brief The number of record fields required for the Stmt class
  87     /// itself.
  88     static const unsigned NumStmtFields = 0;
  89
  90     /// \brief The number of record fields required for the Expr class
  91     /// itself.
  92     static const unsigned NumExprFields = NumStmtFields + 7;
  93
  94     /// \brief Read and initialize a ExplicitTemplateArgumentList structure.
  95     void ReadTemplateKWAndArgsInfo(ASTTemplateKWAndArgsInfo &Args,
  96                                    TemplateArgumentLoc *ArgsLocArray,
  97                                    unsigned NumTemplateArgs);
  98     /// \brief Read and initialize a ExplicitTemplateArgumentList structure.
  99     void ReadExplicitTemplateArgumentList(ASTTemplateArgumentListInfo &ArgList,
 100                                           unsigned NumTemplateArgs);
 101
 102     void VisitStmt(Stmt *S);
 103 #define STMT(Type, Base) \
 104     void Visit##Type(Type *);
 105 #include "clang/AST/StmtNodes.inc"
 106   };
 107 }
 108
 109 void ASTStmtReader::ReadTemplateKWAndArgsInfo(ASTTemplateKWAndArgsInfo &Args,
 110                                               TemplateArgumentLoc *ArgsLocArray,
 111                                               unsigned NumTemplateArgs) {
 112   SourceLocation TemplateKWLoc = ReadSourceLocation(Record, Idx);
 113   TemplateArgumentListInfo ArgInfo;
 114   ArgInfo.setLAngleLoc(ReadSourceLocation(Record, Idx));
 115   ArgInfo.setRAngleLoc(ReadSourceLocation(Record, Idx));
 116   for (unsigned i = 0; i != NumTemplateArgs; ++i)
 117     ArgInfo.addArgument(
 118         Reader.ReadTemplateArgumentLoc(F, Record, Idx));
 119   Args.initializeFrom(TemplateKWLoc, ArgInfo, ArgsLocArray);
 120 }
 121
 122 void ASTStmtReader::VisitStmt(Stmt *S) {
 123   assert(Idx == NumStmtFields && "Incorrect statement field count");
 124 }
 125
 126 void ASTStmtReader::VisitNullStmt(NullStmt *S) {
 127   VisitStmt(S);
 128   S->setSemiLoc(ReadSourceLocation(Record, Idx));
 129   S->HasLeadingEmptyMacro = Record[Idx++];
 130 }
 131
 132 void ASTStmtReader::VisitCompoundStmt(CompoundStmt *S) {
 133   VisitStmt(S);
 134   SmallVector<Stmt *, 16> Stmts;
 135   unsigned NumStmts = Record[Idx++];
 136   while (NumStmts--)
 137     Stmts.push_back(Reader.ReadSubStmt());
 138   S->setStmts(Reader.getContext(), Stmts);
 139   S->LBraceLoc = ReadSourceLocation(Record, Idx);
 140   S->RBraceLoc = ReadSourceLocation(Record, Idx);
 141 }
 142
 143 void ASTStmtReader::VisitSwitchCase(SwitchCase *S) {
 144   VisitStmt(S);
 145   Reader.RecordSwitchCaseID(S, Record[Idx++]);
 146   S->setKeywordLoc(ReadSourceLocation(Record, Idx));
 147   S->setColonLoc(ReadSourceLocation(Record, Idx));
 148 }
 149
 150 void ASTStmtReader::VisitCaseStmt(CaseStmt *S) {
 151   VisitSwitchCase(S);
 152   S->setLHS(Reader.ReadSubExpr());
 153   S->setRHS(Reader.ReadSubExpr());
 154   S->setSubStmt(Reader.ReadSubStmt());
 155   S->setEllipsisLoc(ReadSourceLocation(Record, Idx));
 156 }
 157
 158 void ASTStmtReader::VisitDefaultStmt(DefaultStmt *S) {
 159   VisitSwitchCase(S);
 160   S->setSubStmt(Reader.ReadSubStmt());
 161 }
 162
 163 void ASTStmtReader::VisitLabelStmt(LabelStmt *S) {
 164   VisitStmt(S);
 165   LabelDecl *LD = ReadDeclAs<LabelDecl>(Record, Idx);
 166   LD->setStmt(S);
 167   S->setDecl(LD);
 168   S->setSubStmt(Reader.ReadSubStmt());
 169   S->setIdentLoc(ReadSourceLocation(Record, Idx));
 170 }
 171
 172 void ASTStmtReader::VisitAttributedStmt(AttributedStmt *S) {
 173   VisitStmt(S);
 174   uint64_t NumAttrs = Record[Idx++];
 175   AttrVec Attrs;
 176   Reader.ReadAttributes(F, Attrs, Record, Idx);
 177   (void)NumAttrs;
 178   assert(NumAttrs == S->NumAttrs);
 179   assert(NumAttrs == Attrs.size());
 180   std::copy(Attrs.begin(), Attrs.end(), S->getAttrArrayPtr());
 181   S->SubStmt = Reader.ReadSubStmt();
 182   S->AttrLoc = ReadSourceLocation(Record, Idx);
 183 }
 184
 185 void ASTStmtReader::VisitIfStmt(IfStmt *S) {
 186   VisitStmt(S);
 187   S->setConditionVariable(Reader.getContext(),
 188                           ReadDeclAs<VarDecl>(Record, Idx));
 189   S->setCond(Reader.ReadSubExpr());
 190   S->setThen(Reader.ReadSubStmt());
 191   S->setElse(Reader.ReadSubStmt());
 192   S->setIfLoc(ReadSourceLocation(Record, Idx));
 193   S->setElseLoc(ReadSourceLocation(Record, Idx));
 194 }
 195
 196 void ASTStmtReader::VisitSwitchStmt(SwitchStmt *S) {
 197   VisitStmt(S);
 198   S->setConditionVariable(Reader.getContext(),
 199                           ReadDeclAs<VarDecl>(Record, Idx));
 200   S->setCond(Reader.ReadSubExpr());
 201   S->setBody(Reader.ReadSubStmt());
 202   S->setSwitchLoc(ReadSourceLocation(Record, Idx));
 203   if (Record[Idx++])
 204     S->setAllEnumCasesCovered();
 205
 206   SwitchCase *PrevSC = nullptr;
 207   for (unsigned N = Record.size(); Idx != N; ++Idx) {
 208     SwitchCase *SC = Reader.getSwitchCaseWithID(Record[Idx]);
 209     if (PrevSC)
 210       PrevSC->setNextSwitchCase(SC);
 211     else
 212       S->setSwitchCaseList(SC);
 213
 214     PrevSC = SC;
 215   }
 216 }
 217
 218 void ASTStmtReader::VisitWhileStmt(WhileStmt *S) {
 219   VisitStmt(S);
 220   S->setConditionVariable(Reader.getContext(),
 221                           ReadDeclAs<VarDecl>(Record, Idx));
 222
 223   S->setCond(Reader.ReadSubExpr());
 224   S->setBody(Reader.ReadSubStmt());
 225   S->setWhileLoc(ReadSourceLocation(Record, Idx));
 226 }
 227
 228 void ASTStmtReader::VisitDoStmt(DoStmt *S) {
 229   VisitStmt(S);
 230   S->setCond(Reader.ReadSubExpr());
 231   S->setBody(Reader.ReadSubStmt());
 232   S->setDoLoc(ReadSourceLocation(Record, Idx));
 233   S->setWhileLoc(ReadSourceLocation(Record, Idx));
 234   S->setRParenLoc(ReadSourceLocation(Record, Idx));
 235 }
 236
 237 void ASTStmtReader::VisitForStmt(ForStmt *S) {
 238   VisitStmt(S);
 239   S->setInit(Reader.ReadSubStmt());
 240   S->setCond(Reader.ReadSubExpr());
 241   S->setConditionVariable(Reader.getContext(),
 242                           ReadDeclAs<VarDecl>(Record, Idx));
 243   S->setInc(Reader.ReadSubExpr());
 244   S->setBody(Reader.ReadSubStmt());
 245   S->setForLoc(ReadSourceLocation(Record, Idx));
 246   S->setLParenLoc(ReadSourceLocation(Record, Idx));
 247   S->setRParenLoc(ReadSourceLocation(Record, Idx));
 248 }
 249
 250 void ASTStmtReader::VisitGotoStmt(GotoStmt *S) {
 251   VisitStmt(S);
 252   S->setLabel(ReadDeclAs<LabelDecl>(Record, Idx));
 253   S->setGotoLoc(ReadSourceLocation(Record, Idx));
 254   S->setLabelLoc(ReadSourceLocation(Record, Idx));
 255 }
 256
 257 void ASTStmtReader::VisitIndirectGotoStmt(IndirectGotoStmt *S) {
 258   VisitStmt(S);
 259   S->setGotoLoc(ReadSourceLocation(Record, Idx));
 260   S->setStarLoc(ReadSourceLocation(Record, Idx));
 261   S->setTarget(Reader.ReadSubExpr());
 262 }
 263
 264 void ASTStmtReader::VisitContinueStmt(ContinueStmt *S) {
 265   VisitStmt(S);
 266   S->setContinueLoc(ReadSourceLocation(Record, Idx));
 267 }
 268
 269 void ASTStmtReader::VisitBreakStmt(BreakStmt *S) {
 270   VisitStmt(S);
 271   S->setBreakLoc(ReadSourceLocation(Record, Idx));
 272 }
 273
 274 void ASTStmtReader::VisitReturnStmt(ReturnStmt *S) {
 275   VisitStmt(S);
 276   S->setRetValue(Reader.ReadSubExpr());
 277   S->setReturnLoc(ReadSourceLocation(Record, Idx));
 278   S->setNRVOCandidate(ReadDeclAs<VarDecl>(Record, Idx));
 279 }
 280
 281 void ASTStmtReader::VisitDeclStmt(DeclStmt *S) {
 282   VisitStmt(S);
 283   S->setStartLoc(ReadSourceLocation(Record, Idx));
 284   S->setEndLoc(ReadSourceLocation(Record, Idx));
 285
 286   if (Idx + 1 == Record.size()) {
 287     // Single declaration
 288     S->setDeclGroup(DeclGroupRef(ReadDecl(Record, Idx)));
 289   } else {
 290     SmallVector<Decl *, 16> Decls;
 291     Decls.reserve(Record.size() - Idx);
 292     for (unsigned N = Record.size(); Idx != N; )
 293       Decls.push_back(ReadDecl(Record, Idx));
 294     S->setDeclGroup(DeclGroupRef(DeclGroup::Create(Reader.getContext(),
 295                                                    Decls.data(),
 296                                                    Decls.size())));
 297   }
 298 }
 299
 300 void ASTStmtReader::VisitAsmStmt(AsmStmt *S) {
 301   VisitStmt(S);
 302   S->NumOutputs = Record[Idx++];
 303   S->NumInputs = Record[Idx++];
 304   S->NumClobbers = Record[Idx++];
 305   S->setAsmLoc(ReadSourceLocation(Record, Idx));
 306   S->setVolatile(Record[Idx++]);
 307   S->setSimple(Record[Idx++]);
 308 }
 309
 310 void ASTStmtReader::VisitGCCAsmStmt(GCCAsmStmt *S) {
 311   VisitAsmStmt(S);
 312   S->setRParenLoc(ReadSourceLocation(Record, Idx));
 313   S->setAsmString(cast_or_null<StringLiteral>(Reader.ReadSubStmt()));
 314
 315   unsigned NumOutputs = S->getNumOutputs();
 316   unsigned NumInputs = S->getNumInputs();
 317   unsigned NumClobbers = S->getNumClobbers();
 318
 319   // Outputs and inputs
 320   SmallVector<IdentifierInfo *, 16> Names;
 321   SmallVector<StringLiteral*, 16> Constraints;
 322   SmallVector<Stmt*, 16> Exprs;
 323   for (unsigned I = 0, N = NumOutputs + NumInputs; I != N; ++I) {
 324     Names.push_back(Reader.GetIdentifierInfo(F, Record, Idx));
 325     Constraints.push_back(cast_or_null<StringLiteral>(Reader.ReadSubStmt()));
 326     Exprs.push_back(Reader.ReadSubStmt());
 327   }
 328
 329   // Constraints
 330   SmallVector<StringLiteral*, 16> Clobbers;
 331   for (unsigned I = 0; I != NumClobbers; ++I)
 332     Clobbers.push_back(cast_or_null<StringLiteral>(Reader.ReadSubStmt()));
 333
 334   S->setOutputsAndInputsAndClobbers(Reader.getContext(),
 335                                     Names.data(), Constraints.data(),
 336                                     Exprs.data(), NumOutputs, NumInputs,
 337                                     Clobbers.data(), NumClobbers);
 338 }
 339
 340 void ASTStmtReader::VisitMSAsmStmt(MSAsmStmt *S) {
 341   VisitAsmStmt(S);
 342   S->LBraceLoc = ReadSourceLocation(Record, Idx);
 343   S->EndLoc = ReadSourceLocation(Record, Idx);
 344   S->NumAsmToks = Record[Idx++];
 345   std::string AsmStr = ReadString(Record, Idx);
 346
 347   // Read the tokens.
 348   SmallVector<Token, 16> AsmToks;
 349   AsmToks.reserve(S->NumAsmToks);
 350   for (unsigned i = 0, e = S->NumAsmToks; i != e; ++i) {
 351     AsmToks.push_back(ReadToken(Record, Idx));
 352   }
 353
 354   // The calls to reserve() for the FooData vectors are mandatory to
 355   // prevent dead StringRefs in the Foo vectors.
 356
 357   // Read the clobbers.
 358   SmallVector<std::string, 16> ClobbersData;
 359   SmallVector<StringRef, 16> Clobbers;
 360   ClobbersData.reserve(S->NumClobbers);
 361   Clobbers.reserve(S->NumClobbers);
 362   for (unsigned i = 0, e = S->NumClobbers; i != e; ++i) {
 363     ClobbersData.push_back(ReadString(Record, Idx));
 364     Clobbers.push_back(ClobbersData.back());
 365   }
 366
 367   // Read the operands.
 368   unsigned NumOperands = S->NumOutputs + S->NumInputs;
 369   SmallVector<Expr*, 16> Exprs;
 370   SmallVector<std::string, 16> ConstraintsData;
 371   SmallVector<StringRef, 16> Constraints;
 372   Exprs.reserve(NumOperands);
 373   ConstraintsData.reserve(NumOperands);
 374   Constraints.reserve(NumOperands);
 375   for (unsigned i = 0; i != NumOperands; ++i) {
 376     Exprs.push_back(cast<Expr>(Reader.ReadSubStmt()));
 377     ConstraintsData.push_back(ReadString(Record, Idx));
 378     Constraints.push_back(ConstraintsData.back());
 379   }
 380
 381   S->initialize(Reader.getContext(), AsmStr, AsmToks,
 382                 Constraints, Exprs, Clobbers);
 383 }
 384
 385 void ASTStmtReader::VisitCoroutineBodyStmt(CoroutineBodyStmt *S) {
 386   // FIXME: Implement coroutine serialization.
 387   llvm_unreachable("unimplemented");
 388 }
 389
 390 void ASTStmtReader::VisitCoreturnStmt(CoreturnStmt *S) {
 391   // FIXME: Implement coroutine serialization.
 392   llvm_unreachable("unimplemented");
 393 }
 394
 395 void ASTStmtReader::VisitCoawaitExpr(CoawaitExpr *S) {
 396   // FIXME: Implement coroutine serialization.
 397   llvm_unreachable("unimplemented");
 398 }
 399
 400 void ASTStmtReader::VisitCoyieldExpr(CoyieldExpr *S) {
 401   // FIXME: Implement coroutine serialization.
 402   llvm_unreachable("unimplemented");
 403 }
 404
 405 void ASTStmtReader::VisitCapturedStmt(CapturedStmt *S) {
 406   VisitStmt(S);
 407   ++Idx;
 408   S->setCapturedDecl(ReadDeclAs<CapturedDecl>(Record, Idx));
 409   S->setCapturedRegionKind(static_cast<CapturedRegionKind>(Record[Idx++]));
 410   S->setCapturedRecordDecl(ReadDeclAs<RecordDecl>(Record, Idx));
 411
 412   // Capture inits
 413   for (CapturedStmt::capture_init_iterator I = S->capture_init_begin(),
 414                                            E = S->capture_init_end();
 415        I != E; ++I)
 416     *I = Reader.ReadSubExpr();
 417
 418   // Body
 419   S->setCapturedStmt(Reader.ReadSubStmt());
 420   S->getCapturedDecl()->setBody(S->getCapturedStmt());
 421
 422   // Captures
 423   for (auto &I : S->captures()) {
 424     I.VarAndKind.setPointer(ReadDeclAs<VarDecl>(Record, Idx));
 425     I.VarAndKind
 426         .setInt(static_cast<CapturedStmt::VariableCaptureKind>(Record[Idx++]));
 427     I.Loc = ReadSourceLocation(Record, Idx);
 428   }
 429 }
 430
 431 void ASTStmtReader::VisitExpr(Expr *E) {
 432   VisitStmt(E);
 433   E->setType(Reader.readType(F, Record, Idx));
 434   E->setTypeDependent(Record[Idx++]);
 435   E->setValueDependent(Record[Idx++]);
 436   E->setInstantiationDependent(Record[Idx++]);
 437   E->ExprBits.ContainsUnexpandedParameterPack = Record[Idx++];
 438   E->setValueKind(static_cast<ExprValueKind>(Record[Idx++]));
 439   E->setObjectKind(static_cast<ExprObjectKind>(Record[Idx++]));
 440   assert(Idx == NumExprFields && "Incorrect expression field count");
 441 }
 442
 443 void ASTStmtReader::VisitPredefinedExpr(PredefinedExpr *E) {
 444   VisitExpr(E);
 445   E->setLocation(ReadSourceLocation(Record, Idx));
 446   E->Type = (PredefinedExpr::IdentType)Record[Idx++];
 447   E->FnName = cast_or_null<StringLiteral>(Reader.ReadSubExpr());
 448 }
 449
 450 void ASTStmtReader::VisitDeclRefExpr(DeclRefExpr *E) {
 451   VisitExpr(E);
 452
 453   E->DeclRefExprBits.HasQualifier = Record[Idx++];
 454   E->DeclRefExprBits.HasFoundDecl = Record[Idx++];
 455   E->DeclRefExprBits.HasTemplateKWAndArgsInfo = Record[Idx++];
 456   E->DeclRefExprBits.HadMultipleCandidates = Record[Idx++];
 457   E->DeclRefExprBits.RefersToEnclosingVariableOrCapture = Record[Idx++];
 458   unsigned NumTemplateArgs = 0;
 459   if (E->hasTemplateKWAndArgsInfo())
 460     NumTemplateArgs = Record[Idx++];
 461
 462   if (E->hasQualifier())
 463     new (E->getTrailingObjects<NestedNameSpecifierLoc>())
 464         NestedNameSpecifierLoc(
 465             Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
 466
 467   if (E->hasFoundDecl())
 468     *E->getTrailingObjects<NamedDecl *>() = ReadDeclAs<NamedDecl>(Record, Idx);
 469
 470   if (E->hasTemplateKWAndArgsInfo())
 471     ReadTemplateKWAndArgsInfo(
 472         *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
 473         E->getTrailingObjects<TemplateArgumentLoc>(), NumTemplateArgs);
 474
 475   E->setDecl(ReadDeclAs<ValueDecl>(Record, Idx));
 476   E->setLocation(ReadSourceLocation(Record, Idx));
 477   ReadDeclarationNameLoc(E->DNLoc, E->getDecl()->getDeclName(), Record, Idx);
 478 }
 479
 480 void ASTStmtReader::VisitIntegerLiteral(IntegerLiteral *E) {
 481   VisitExpr(E);
 482   E->setLocation(ReadSourceLocation(Record, Idx));
 483   E->setValue(Reader.getContext(), Reader.ReadAPInt(Record, Idx));
 484 }
 485
 486 void ASTStmtReader::VisitFloatingLiteral(FloatingLiteral *E) {
 487   VisitExpr(E);
 488   E->setRawSemantics(static_cast<Stmt::APFloatSemantics>(Record[Idx++]));
 489   E->setExact(Record[Idx++]);
 490   E->setValue(Reader.getContext(),
 491               Reader.ReadAPFloat(Record, E->getSemantics(), Idx));
 492   E->setLocation(ReadSourceLocation(Record, Idx));
 493 }
 494
 495 void ASTStmtReader::VisitImaginaryLiteral(ImaginaryLiteral *E) {
 496   VisitExpr(E);
 497   E->setSubExpr(Reader.ReadSubExpr());
 498 }
 499
 500 void ASTStmtReader::VisitStringLiteral(StringLiteral *E) {
 501   VisitExpr(E);
 502   unsigned Len = Record[Idx++];
 503   assert(Record[Idx] == E->getNumConcatenated() &&
 504          "Wrong number of concatenated tokens!");
 505   ++Idx;
 506   StringLiteral::StringKind kind =
 507         static_cast<StringLiteral::StringKind>(Record[Idx++]);
 508   bool isPascal = Record[Idx++];
 509
 510   // Read string data
 511   SmallString<16> Str(&Record[Idx], &Record[Idx] + Len);
 512   E->setString(Reader.getContext(), Str, kind, isPascal);
 513   Idx += Len;
 514
 515   // Read source locations
 516   for (unsigned I = 0, N = E->getNumConcatenated(); I != N; ++I)
 517     E->setStrTokenLoc(I, ReadSourceLocation(Record, Idx));
 518 }
 519
 520 void ASTStmtReader::VisitCharacterLiteral(CharacterLiteral *E) {
 521   VisitExpr(E);
 522   E->setValue(Record[Idx++]);
 523   E->setLocation(ReadSourceLocation(Record, Idx));
 524   E->setKind(static_cast<CharacterLiteral::CharacterKind>(Record[Idx++]));
 525 }
 526
 527 void ASTStmtReader::VisitParenExpr(ParenExpr *E) {
 528   VisitExpr(E);
 529   E->setLParen(ReadSourceLocation(Record, Idx));
 530   E->setRParen(ReadSourceLocation(Record, Idx));
 531   E->setSubExpr(Reader.ReadSubExpr());
 532 }
 533
 534 void ASTStmtReader::VisitParenListExpr(ParenListExpr *E) {
 535   VisitExpr(E);
 536   unsigned NumExprs = Record[Idx++];
 537   E->Exprs = new (Reader.getContext()) Stmt*[NumExprs];
 538   for (unsigned i = 0; i != NumExprs; ++i)
 539     E->Exprs[i] = Reader.ReadSubStmt();
 540   E->NumExprs = NumExprs;
 541   E->LParenLoc = ReadSourceLocation(Record, Idx);
 542   E->RParenLoc = ReadSourceLocation(Record, Idx);
 543 }
 544
 545 void ASTStmtReader::VisitUnaryOperator(UnaryOperator *E) {
 546   VisitExpr(E);
 547   E->setSubExpr(Reader.ReadSubExpr());
 548   E->setOpcode((UnaryOperator::Opcode)Record[Idx++]);
 549   E->setOperatorLoc(ReadSourceLocation(Record, Idx));
 550 }
 551
 552 void ASTStmtReader::VisitOffsetOfExpr(OffsetOfExpr *E) {
 553   VisitExpr(E);
 554   assert(E->getNumComponents() == Record[Idx]);
 555   ++Idx;
 556   assert(E->getNumExpressions() == Record[Idx]);
 557   ++Idx;
 558   E->setOperatorLoc(ReadSourceLocation(Record, Idx));
 559   E->setRParenLoc(ReadSourceLocation(Record, Idx));
 560   E->setTypeSourceInfo(GetTypeSourceInfo(Record, Idx));
 561   for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) {
 562     OffsetOfNode::Kind Kind = static_cast<OffsetOfNode::Kind>(Record[Idx++]);
 563     SourceLocation Start = ReadSourceLocation(Record, Idx);
 564     SourceLocation End = ReadSourceLocation(Record, Idx);
 565     switch (Kind) {
 566     case OffsetOfNode::Array:
 567       E->setComponent(I, OffsetOfNode(Start, Record[Idx++], End));
 568       break;
 569
 570     case OffsetOfNode::Field:
 571       E->setComponent(
 572           I, OffsetOfNode(Start, ReadDeclAs<FieldDecl>(Record, Idx), End));
 573       break;
 574
 575     case OffsetOfNode::Identifier:
 576       E->setComponent(
 577           I,
 578           OffsetOfNode(Start, Reader.GetIdentifierInfo(F, Record, Idx), End));
 579       break;
 580
 581     case OffsetOfNode::Base: {
 582       CXXBaseSpecifier *Base = new (Reader.getContext()) CXXBaseSpecifier();
 583       *Base = Reader.ReadCXXBaseSpecifier(F, Record, Idx);
 584       E->setComponent(I, OffsetOfNode(Base));
 585       break;
 586     }
 587     }
 588   }
 589
 590   for (unsigned I = 0, N = E->getNumExpressions(); I != N; ++I)
 591     E->setIndexExpr(I, Reader.ReadSubExpr());
 592 }
 593
 594 void ASTStmtReader::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) {
 595   VisitExpr(E);
 596   E->setKind(static_cast<UnaryExprOrTypeTrait>(Record[Idx++]));
 597   if (Record[Idx] == 0) {
 598     E->setArgument(Reader.ReadSubExpr());
 599     ++Idx;
 600   } else {
 601     E->setArgument(GetTypeSourceInfo(Record, Idx));
 602   }
 603   E->setOperatorLoc(ReadSourceLocation(Record, Idx));
 604   E->setRParenLoc(ReadSourceLocation(Record, Idx));
 605 }
 606
 607 void ASTStmtReader::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
 608   VisitExpr(E);
 609   E->setLHS(Reader.ReadSubExpr());
 610   E->setRHS(Reader.ReadSubExpr());
 611   E->setRBracketLoc(ReadSourceLocation(Record, Idx));
 612 }
 613
 614 void ASTStmtReader::VisitOMPArraySectionExpr(OMPArraySectionExpr *E) {
 615   VisitExpr(E);
 616   E->setBase(Reader.ReadSubExpr());
 617   E->setLowerBound(Reader.ReadSubExpr());
 618   E->setLength(Reader.ReadSubExpr());
 619   E->setColonLoc(ReadSourceLocation(Record, Idx));
 620   E->setRBracketLoc(ReadSourceLocation(Record, Idx));
 621 }
 622
 623 void ASTStmtReader::VisitCallExpr(CallExpr *E) {
 624   VisitExpr(E);
 625   E->setNumArgs(Reader.getContext(), Record[Idx++]);
 626   E->setRParenLoc(ReadSourceLocation(Record, Idx));
 627   E->setCallee(Reader.ReadSubExpr());
 628   for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
 629     E->setArg(I, Reader.ReadSubExpr());
 630 }
 631
 632 void ASTStmtReader::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
 633   VisitCallExpr(E);
 634 }
 635
 636 void ASTStmtReader::VisitMemberExpr(MemberExpr *E) {
 637   // Don't call VisitExpr, this is fully initialized at creation.
 638   assert(E->getStmtClass() == Stmt::MemberExprClass &&
 639          "It's a subclass, we must advance Idx!");
 640 }
 641
 642 void ASTStmtReader::VisitObjCIsaExpr(ObjCIsaExpr *E) {
 643   VisitExpr(E);
 644   E->setBase(Reader.ReadSubExpr());
 645   E->setIsaMemberLoc(ReadSourceLocation(Record, Idx));
 646   E->setOpLoc(ReadSourceLocation(Record, Idx));
 647   E->setArrow(Record[Idx++]);
 648 }
 649
 650 void ASTStmtReader::
 651 VisitObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) {
 652   VisitExpr(E);
 653   E->Operand = Reader.ReadSubExpr();
 654   E->setShouldCopy(Record[Idx++]);
 655 }
 656
 657 void ASTStmtReader::VisitObjCBridgedCastExpr(ObjCBridgedCastExpr *E) {
 658   VisitExplicitCastExpr(E);
 659   E->LParenLoc = ReadSourceLocation(Record, Idx);
 660   E->BridgeKeywordLoc = ReadSourceLocation(Record, Idx);
 661   E->Kind = Record[Idx++];
 662 }
 663
 664 void ASTStmtReader::VisitCastExpr(CastExpr *E) {
 665   VisitExpr(E);
 666   unsigned NumBaseSpecs = Record[Idx++];
 667   assert(NumBaseSpecs == E->path_size());
 668   E->setSubExpr(Reader.ReadSubExpr());
 669   E->setCastKind((CastKind)Record[Idx++]);
 670   CastExpr::path_iterator BaseI = E->path_begin();
 671   while (NumBaseSpecs--) {
 672     CXXBaseSpecifier *BaseSpec = new (Reader.getContext()) CXXBaseSpecifier;
 673     *BaseSpec = Reader.ReadCXXBaseSpecifier(F, Record, Idx);
 674     *BaseI++ = BaseSpec;
 675   }
 676 }
 677
 678 void ASTStmtReader::VisitBinaryOperator(BinaryOperator *E) {
 679   VisitExpr(E);
 680   E->setLHS(Reader.ReadSubExpr());
 681   E->setRHS(Reader.ReadSubExpr());
 682   E->setOpcode((BinaryOperator::Opcode)Record[Idx++]);
 683   E->setOperatorLoc(ReadSourceLocation(Record, Idx));
 684   E->setFPContractable((bool)Record[Idx++]);
 685 }
 686
 687 void ASTStmtReader::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
 688   VisitBinaryOperator(E);
 689   E->setComputationLHSType(Reader.readType(F, Record, Idx));
 690   E->setComputationResultType(Reader.readType(F, Record, Idx));
 691 }
 692
 693 void ASTStmtReader::VisitConditionalOperator(ConditionalOperator *E) {
 694   VisitExpr(E);
 695   E->SubExprs[ConditionalOperator::COND] = Reader.ReadSubExpr();
 696   E->SubExprs[ConditionalOperator::LHS] = Reader.ReadSubExpr();
 697   E->SubExprs[ConditionalOperator::RHS] = Reader.ReadSubExpr();
 698   E->QuestionLoc = ReadSourceLocation(Record, Idx);
 699   E->ColonLoc = ReadSourceLocation(Record, Idx);
 700 }
 701
 702 void
 703 ASTStmtReader::VisitBinaryConditionalOperator(BinaryConditionalOperator *E) {
 704   VisitExpr(E);
 705   E->OpaqueValue = cast<OpaqueValueExpr>(Reader.ReadSubExpr());
 706   E->SubExprs[BinaryConditionalOperator::COMMON] = Reader.ReadSubExpr();
 707   E->SubExprs[BinaryConditionalOperator::COND] = Reader.ReadSubExpr();
 708   E->SubExprs[BinaryConditionalOperator::LHS] = Reader.ReadSubExpr();
 709   E->SubExprs[BinaryConditionalOperator::RHS] = Reader.ReadSubExpr();
 710   E->QuestionLoc = ReadSourceLocation(Record, Idx);
 711   E->ColonLoc = ReadSourceLocation(Record, Idx);
 712 }
 713
 714 void ASTStmtReader::VisitImplicitCastExpr(ImplicitCastExpr *E) {
 715   VisitCastExpr(E);
 716 }
 717
 718 void ASTStmtReader::VisitExplicitCastExpr(ExplicitCastExpr *E) {
 719   VisitCastExpr(E);
 720   E->setTypeInfoAsWritten(GetTypeSourceInfo(Record, Idx));
 721 }
 722
 723 void ASTStmtReader::VisitCStyleCastExpr(CStyleCastExpr *E) {
 724   VisitExplicitCastExpr(E);
 725   E->setLParenLoc(ReadSourceLocation(Record, Idx));
 726   E->setRParenLoc(ReadSourceLocation(Record, Idx));
 727 }
 728
 729 void ASTStmtReader::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
 730   VisitExpr(E);
 731   E->setLParenLoc(ReadSourceLocation(Record, Idx));
 732   E->setTypeSourceInfo(GetTypeSourceInfo(Record, Idx));
 733   E->setInitializer(Reader.ReadSubExpr());
 734   E->setFileScope(Record[Idx++]);
 735 }
 736
 737 void ASTStmtReader::VisitExtVectorElementExpr(ExtVectorElementExpr *E) {
 738   VisitExpr(E);
 739   E->setBase(Reader.ReadSubExpr());
 740   E->setAccessor(Reader.GetIdentifierInfo(F, Record, Idx));
 741   E->setAccessorLoc(ReadSourceLocation(Record, Idx));
 742 }
 743
 744 void ASTStmtReader::VisitInitListExpr(InitListExpr *E) {
 745   VisitExpr(E);
 746   if (InitListExpr *SyntForm = cast_or_null<InitListExpr>(Reader.ReadSubStmt()))
 747     E->setSyntacticForm(SyntForm);
 748   E->setLBraceLoc(ReadSourceLocation(Record, Idx));
 749   E->setRBraceLoc(ReadSourceLocation(Record, Idx));
 750   bool isArrayFiller = Record[Idx++];
 751   Expr *filler = nullptr;
 752   if (isArrayFiller) {
 753     filler = Reader.ReadSubExpr();
 754     E->ArrayFillerOrUnionFieldInit = filler;
 755   } else
 756     E->ArrayFillerOrUnionFieldInit = ReadDeclAs<FieldDecl>(Record, Idx);
 757   E->sawArrayRangeDesignator(Record[Idx++]);
 758   unsigned NumInits = Record[Idx++];
 759   E->reserveInits(Reader.getContext(), NumInits);
 760   if (isArrayFiller) {
 761     for (unsigned I = 0; I != NumInits; ++I) {
 762       Expr *init = Reader.ReadSubExpr();
 763       E->updateInit(Reader.getContext(), I, init ? init : filler);
 764     }
 765   } else {
 766     for (unsigned I = 0; I != NumInits; ++I)
 767       E->updateInit(Reader.getContext(), I, Reader.ReadSubExpr());
 768   }
 769 }
 770
 771 void ASTStmtReader::VisitDesignatedInitExpr(DesignatedInitExpr *E) {
 772   typedef DesignatedInitExpr::Designator Designator;
 773
 774   VisitExpr(E);
 775   unsigned NumSubExprs = Record[Idx++];
 776   assert(NumSubExprs == E->getNumSubExprs() && "Wrong number of subexprs");
 777   for (unsigned I = 0; I != NumSubExprs; ++I)
 778     E->setSubExpr(I, Reader.ReadSubExpr());
 779   E->setEqualOrColonLoc(ReadSourceLocation(Record, Idx));
 780   E->setGNUSyntax(Record[Idx++]);
 781
 782   SmallVector<Designator, 4> Designators;
 783   while (Idx < Record.size()) {
 784     switch ((DesignatorTypes)Record[Idx++]) {
 785     case DESIG_FIELD_DECL: {
 786       FieldDecl *Field = ReadDeclAs<FieldDecl>(Record, Idx);
 787       SourceLocation DotLoc
 788         = ReadSourceLocation(Record, Idx);
 789       SourceLocation FieldLoc
 790         = ReadSourceLocation(Record, Idx);
 791       Designators.push_back(Designator(Field->getIdentifier(), DotLoc,
 792                                        FieldLoc));
 793       Designators.back().setField(Field);
 794       break;
 795     }
 796
 797     case DESIG_FIELD_NAME: {
 798       const IdentifierInfo *Name = Reader.GetIdentifierInfo(F, Record, Idx);
 799       SourceLocation DotLoc
 800         = ReadSourceLocation(Record, Idx);
 801       SourceLocation FieldLoc
 802         = ReadSourceLocation(Record, Idx);
 803       Designators.push_back(Designator(Name, DotLoc, FieldLoc));
 804       break;
 805     }
 806
 807     case DESIG_ARRAY: {
 808       unsigned Index = Record[Idx++];
 809       SourceLocation LBracketLoc
 810         = ReadSourceLocation(Record, Idx);
 811       SourceLocation RBracketLoc
 812         = ReadSourceLocation(Record, Idx);
 813       Designators.push_back(Designator(Index, LBracketLoc, RBracketLoc));
 814       break;
 815     }
 816
 817     case DESIG_ARRAY_RANGE: {
 818       unsigned Index = Record[Idx++];
 819       SourceLocation LBracketLoc
 820         = ReadSourceLocation(Record, Idx);
 821       SourceLocation EllipsisLoc
 822         = ReadSourceLocation(Record, Idx);
 823       SourceLocation RBracketLoc
 824         = ReadSourceLocation(Record, Idx);
 825       Designators.push_back(Designator(Index, LBracketLoc, EllipsisLoc,
 826                                        RBracketLoc));
 827       break;
 828     }
 829     }
 830   }
 831   E->setDesignators(Reader.getContext(),
 832                     Designators.data(), Designators.size());
 833 }
 834
 835 void ASTStmtReader::VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E) {
 836   VisitExpr(E);
 837   E->setBase(Reader.ReadSubExpr());
 838   E->setUpdater(Reader.ReadSubExpr());
 839 }
 840
 841 void ASTStmtReader::VisitNoInitExpr(NoInitExpr *E) {
 842   VisitExpr(E);
 843 }
 844
 845 void ASTStmtReader::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
 846   VisitExpr(E);
 847 }
 848
 849 void ASTStmtReader::VisitVAArgExpr(VAArgExpr *E) {
 850   VisitExpr(E);
 851   E->setSubExpr(Reader.ReadSubExpr());
 852   E->setWrittenTypeInfo(GetTypeSourceInfo(Record, Idx));
 853   E->setBuiltinLoc(ReadSourceLocation(Record, Idx));
 854   E->setRParenLoc(ReadSourceLocation(Record, Idx));
 855   E->setIsMicrosoftABI(Record[Idx++]);
 856 }
 857
 858 void ASTStmtReader::VisitAddrLabelExpr(AddrLabelExpr *E) {
 859   VisitExpr(E);
 860   E->setAmpAmpLoc(ReadSourceLocation(Record, Idx));
 861   E->setLabelLoc(ReadSourceLocation(Record, Idx));
 862   E->setLabel(ReadDeclAs<LabelDecl>(Record, Idx));
 863 }
 864
 865 void ASTStmtReader::VisitStmtExpr(StmtExpr *E) {
 866   VisitExpr(E);
 867   E->setLParenLoc(ReadSourceLocation(Record, Idx));
 868   E->setRParenLoc(ReadSourceLocation(Record, Idx));
 869   E->setSubStmt(cast_or_null<CompoundStmt>(Reader.ReadSubStmt()));
 870 }
 871
 872 void ASTStmtReader::VisitChooseExpr(ChooseExpr *E) {
 873   VisitExpr(E);
 874   E->setCond(Reader.ReadSubExpr());
 875   E->setLHS(Reader.ReadSubExpr());
 876   E->setRHS(Reader.ReadSubExpr());
 877   E->setBuiltinLoc(ReadSourceLocation(Record, Idx));
 878   E->setRParenLoc(ReadSourceLocation(Record, Idx));
 879   E->setIsConditionTrue(Record[Idx++]);
 880 }
 881
 882 void ASTStmtReader::VisitGNUNullExpr(GNUNullExpr *E) {
 883   VisitExpr(E);
 884   E->setTokenLocation(ReadSourceLocation(Record, Idx));
 885 }
 886
 887 void ASTStmtReader::VisitShuffleVectorExpr(ShuffleVectorExpr *E) {
 888   VisitExpr(E);
 889   SmallVector<Expr *, 16> Exprs;
 890   unsigned NumExprs = Record[Idx++];
 891   while (NumExprs--)
 892     Exprs.push_back(Reader.ReadSubExpr());
 893   E->setExprs(Reader.getContext(), Exprs);
 894   E->setBuiltinLoc(ReadSourceLocation(Record, Idx));
 895   E->setRParenLoc(ReadSourceLocation(Record, Idx));
 896 }
 897
 898 void ASTStmtReader::VisitConvertVectorExpr(ConvertVectorExpr *E) {
 899   VisitExpr(E);
 900   E->BuiltinLoc = ReadSourceLocation(Record, Idx);
 901   E->RParenLoc = ReadSourceLocation(Record, Idx);
 902   E->TInfo = GetTypeSourceInfo(Record, Idx);
 903   E->SrcExpr = Reader.ReadSubExpr();
 904 }
 905
 906 void ASTStmtReader::VisitBlockExpr(BlockExpr *E) {
 907   VisitExpr(E);
 908   E->setBlockDecl(ReadDeclAs<BlockDecl>(Record, Idx));
 909 }
 910
 911 void ASTStmtReader::VisitGenericSelectionExpr(GenericSelectionExpr *E) {
 912   VisitExpr(E);
 913   E->NumAssocs = Record[Idx++];
 914   E->AssocTypes = new (Reader.getContext()) TypeSourceInfo*[E->NumAssocs];
 915   E->SubExprs =
 916    new(Reader.getContext()) Stmt*[GenericSelectionExpr::END_EXPR+E->NumAssocs];
 917
 918   E->SubExprs[GenericSelectionExpr::CONTROLLING] = Reader.ReadSubExpr();
 919   for (unsigned I = 0, N = E->getNumAssocs(); I != N; ++I) {
 920     E->AssocTypes[I] = GetTypeSourceInfo(Record, Idx);
 921     E->SubExprs[GenericSelectionExpr::END_EXPR+I] = Reader.ReadSubExpr();
 922   }
 923   E->ResultIndex = Record[Idx++];
 924
 925   E->GenericLoc = ReadSourceLocation(Record, Idx);
 926   E->DefaultLoc = ReadSourceLocation(Record, Idx);
 927   E->RParenLoc = ReadSourceLocation(Record, Idx);
 928 }
 929
 930 void ASTStmtReader::VisitPseudoObjectExpr(PseudoObjectExpr *E) {
 931   VisitExpr(E);
 932   unsigned numSemanticExprs = Record[Idx++];
 933   assert(numSemanticExprs + 1 == E->PseudoObjectExprBits.NumSubExprs);
 934   E->PseudoObjectExprBits.ResultIndex = Record[Idx++];
 935
 936   // Read the syntactic expression.
 937   E->getSubExprsBuffer()[0] = Reader.ReadSubExpr();
 938
 939   // Read all the semantic expressions.
 940   for (unsigned i = 0; i != numSemanticExprs; ++i) {
 941     Expr *subExpr = Reader.ReadSubExpr();
 942     E->getSubExprsBuffer()[i+1] = subExpr;
 943   }
 944 }
 945
 946 void ASTStmtReader::VisitAtomicExpr(AtomicExpr *E) {
 947   VisitExpr(E);
 948   E->Op = AtomicExpr::AtomicOp(Record[Idx++]);
 949   E->NumSubExprs = AtomicExpr::getNumSubExprs(E->Op);
 950   for (unsigned I = 0; I != E->NumSubExprs; ++I)
 951     E->SubExprs[I] = Reader.ReadSubExpr();
 952   E->BuiltinLoc = ReadSourceLocation(Record, Idx);
 953   E->RParenLoc = ReadSourceLocation(Record, Idx);
 954 }
 955
 956 //===----------------------------------------------------------------------===//
 957 // Objective-C Expressions and Statements
 958
 959 void ASTStmtReader::VisitObjCStringLiteral(ObjCStringLiteral *E) {
 960   VisitExpr(E);
 961   E->setString(cast<StringLiteral>(Reader.ReadSubStmt()));
 962   E->setAtLoc(ReadSourceLocation(Record, Idx));
 963 }
 964
 965 void ASTStmtReader::VisitObjCBoxedExpr(ObjCBoxedExpr *E) {
 966   VisitExpr(E);
 967   // could be one of several IntegerLiteral, FloatLiteral, etc.
 968   E->SubExpr = Reader.ReadSubStmt();
 969   E->BoxingMethod = ReadDeclAs<ObjCMethodDecl>(Record, Idx);
 970   E->Range = ReadSourceRange(Record, Idx);
 971 }
 972
 973 void ASTStmtReader::VisitObjCArrayLiteral(ObjCArrayLiteral *E) {
 974   VisitExpr(E);
 975   unsigned NumElements = Record[Idx++];
 976   assert(NumElements == E->getNumElements() && "Wrong number of elements");
 977   Expr **Elements = E->getElements();
 978   for (unsigned I = 0, N = NumElements; I != N; ++I)
 979     Elements[I] = Reader.ReadSubExpr();
 980   E->ArrayWithObjectsMethod = ReadDeclAs<ObjCMethodDecl>(Record, Idx);
 981   E->Range = ReadSourceRange(Record, Idx);
 982 }
 983
 984 void ASTStmtReader::VisitObjCDictionaryLiteral(ObjCDictionaryLiteral *E) {
 985   VisitExpr(E);
 986   unsigned NumElements = Record[Idx++];
 987   assert(NumElements == E->getNumElements() && "Wrong number of elements");
 988   bool HasPackExpansions = Record[Idx++];
 989   assert(HasPackExpansions == E->HasPackExpansions &&"Pack expansion mismatch");
 990   ObjCDictionaryLiteral::KeyValuePair *KeyValues =
 991       E->getTrailingObjects<ObjCDictionaryLiteral::KeyValuePair>();
 992   ObjCDictionaryLiteral::ExpansionData *Expansions =
 993       E->getTrailingObjects<ObjCDictionaryLiteral::ExpansionData>();
 994   for (unsigned I = 0; I != NumElements; ++I) {
 995     KeyValues[I].Key = Reader.ReadSubExpr();
 996     KeyValues[I].Value = Reader.ReadSubExpr();
 997     if (HasPackExpansions) {
 998       Expansions[I].EllipsisLoc = ReadSourceLocation(Record, Idx);
 999       Expansions[I].NumExpansionsPlusOne = Record[Idx++];
1000     }
1001   }
1002   E->DictWithObjectsMethod = ReadDeclAs<ObjCMethodDecl>(Record, Idx);
1003   E->Range = ReadSourceRange(Record, Idx);
1004 }
1005
1006 void ASTStmtReader::VisitObjCEncodeExpr(ObjCEncodeExpr *E) {
1007   VisitExpr(E);
1008   E->setEncodedTypeSourceInfo(GetTypeSourceInfo(Record, Idx));
1009   E->setAtLoc(ReadSourceLocation(Record, Idx));
1010   E->setRParenLoc(ReadSourceLocation(Record, Idx));
1011 }
1012
1013 void ASTStmtReader::VisitObjCSelectorExpr(ObjCSelectorExpr *E) {
1014   VisitExpr(E);
1015   E->setSelector(Reader.ReadSelector(F, Record, Idx));
1016   E->setAtLoc(ReadSourceLocation(Record, Idx));
1017   E->setRParenLoc(ReadSourceLocation(Record, Idx));
1018 }
1019
1020 void ASTStmtReader::VisitObjCProtocolExpr(ObjCProtocolExpr *E) {
1021   VisitExpr(E);
1022   E->setProtocol(ReadDeclAs<ObjCProtocolDecl>(Record, Idx));
1023   E->setAtLoc(ReadSourceLocation(Record, Idx));
1024   E->ProtoLoc = ReadSourceLocation(Record, Idx);
1025   E->setRParenLoc(ReadSourceLocation(Record, Idx));
1026 }
1027
1028 void ASTStmtReader::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
1029   VisitExpr(E);
1030   E->setDecl(ReadDeclAs<ObjCIvarDecl>(Record, Idx));
1031   E->setLocation(ReadSourceLocation(Record, Idx));
1032   E->setOpLoc(ReadSourceLocation(Record, Idx));
1033   E->setBase(Reader.ReadSubExpr());
1034   E->setIsArrow(Record[Idx++]);
1035   E->setIsFreeIvar(Record[Idx++]);
1036 }
1037
1038 void ASTStmtReader::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
1039   VisitExpr(E);
1040   unsigned MethodRefFlags = Record[Idx++];
1041   bool Implicit = Record[Idx++] != 0;
1042   if (Implicit) {
1043     ObjCMethodDecl *Getter = ReadDeclAs<ObjCMethodDecl>(Record, Idx);
1044     ObjCMethodDecl *Setter = ReadDeclAs<ObjCMethodDecl>(Record, Idx);
1045     E->setImplicitProperty(Getter, Setter, MethodRefFlags);
1046   } else {
1047     E->setExplicitProperty(ReadDeclAs<ObjCPropertyDecl>(Record, Idx),
1048                            MethodRefFlags);
1049   }
1050   E->setLocation(ReadSourceLocation(Record, Idx));
1051   E->setReceiverLocation(ReadSourceLocation(Record, Idx));
1052   switch (Record[Idx++]) {
1053   case 0:
1054     E->setBase(Reader.ReadSubExpr());
1055     break;
1056   case 1:
1057     E->setSuperReceiver(Reader.readType(F, Record, Idx));
1058     break;
1059   case 2:
1060     E->setClassReceiver(ReadDeclAs<ObjCInterfaceDecl>(Record, Idx));
1061     break;
1062   }
1063 }
1064
1065 void ASTStmtReader::VisitObjCSubscriptRefExpr(ObjCSubscriptRefExpr *E) {
1066   VisitExpr(E);
1067   E->setRBracket(ReadSourceLocation(Record, Idx));
1068   E->setBaseExpr(Reader.ReadSubExpr());
1069   E->setKeyExpr(Reader.ReadSubExpr());
1070   E->GetAtIndexMethodDecl = ReadDeclAs<ObjCMethodDecl>(Record, Idx);
1071   E->SetAtIndexMethodDecl = ReadDeclAs<ObjCMethodDecl>(Record, Idx);
1072 }
1073
1074 void ASTStmtReader::VisitObjCMessageExpr(ObjCMessageExpr *E) {
1075   VisitExpr(E);
1076   assert(Record[Idx] == E->getNumArgs());
1077   ++Idx;
1078   unsigned NumStoredSelLocs = Record[Idx++];
1079   E->SelLocsKind = Record[Idx++];
1080   E->setDelegateInitCall(Record[Idx++]);
1081   E->IsImplicit = Record[Idx++];
1082   ObjCMessageExpr::ReceiverKind Kind
1083     = static_cast<ObjCMessageExpr::ReceiverKind>(Record[Idx++]);
1084   switch (Kind) {
1085   case ObjCMessageExpr::Instance:
1086     E->setInstanceReceiver(Reader.ReadSubExpr());
1087     break;
1088
1089   case ObjCMessageExpr::Class:
1090     E->setClassReceiver(GetTypeSourceInfo(Record, Idx));
1091     break;
1092
1093   case ObjCMessageExpr::SuperClass:
1094   case ObjCMessageExpr::SuperInstance: {
1095     QualType T = Reader.readType(F, Record, Idx);
1096     SourceLocation SuperLoc = ReadSourceLocation(Record, Idx);
1097     E->setSuper(SuperLoc, T, Kind == ObjCMessageExpr::SuperInstance);
1098     break;
1099   }
1100   }
1101
1102   assert(Kind == E->getReceiverKind());
1103
1104   if (Record[Idx++])
1105     E->setMethodDecl(ReadDeclAs<ObjCMethodDecl>(Record, Idx));
1106   else
1107     E->setSelector(Reader.ReadSelector(F, Record, Idx));
1108
1109   E->LBracLoc = ReadSourceLocation(Record, Idx);
1110   E->RBracLoc = ReadSourceLocation(Record, Idx);
1111
1112   for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
1113     E->setArg(I, Reader.ReadSubExpr());
1114
1115   SourceLocation *Locs = E->getStoredSelLocs();
1116   for (unsigned I = 0; I != NumStoredSelLocs; ++I)
1117     Locs[I] = ReadSourceLocation(Record, Idx);
1118 }
1119
1120 void ASTStmtReader::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
1121   VisitStmt(S);
1122   S->setElement(Reader.ReadSubStmt());
1123   S->setCollection(Reader.ReadSubExpr());
1124   S->setBody(Reader.ReadSubStmt());
1125   S->setForLoc(ReadSourceLocation(Record, Idx));
1126   S->setRParenLoc(ReadSourceLocation(Record, Idx));
1127 }
1128
1129 void ASTStmtReader::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {
1130   VisitStmt(S);
1131   S->setCatchBody(Reader.ReadSubStmt());
1132   S->setCatchParamDecl(ReadDeclAs<VarDecl>(Record, Idx));
1133   S->setAtCatchLoc(ReadSourceLocation(Record, Idx));
1134   S->setRParenLoc(ReadSourceLocation(Record, Idx));
1135 }
1136
1137 void ASTStmtReader::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
1138   VisitStmt(S);
1139   S->setFinallyBody(Reader.ReadSubStmt());
1140   S->setAtFinallyLoc(ReadSourceLocation(Record, Idx));
1141 }
1142
1143 void ASTStmtReader::VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S) {
1144   VisitStmt(S);
1145   S->setSubStmt(Reader.ReadSubStmt());
1146   S->setAtLoc(ReadSourceLocation(Record, Idx));
1147 }
1148
1149 void ASTStmtReader::VisitObjCAtTryStmt(ObjCAtTryStmt *S) {
1150   VisitStmt(S);
1151   assert(Record[Idx] == S->getNumCatchStmts());
1152   ++Idx;
1153   bool HasFinally = Record[Idx++];
1154   S->setTryBody(Reader.ReadSubStmt());
1155   for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I)
1156     S->setCatchStmt(I, cast_or_null<ObjCAtCatchStmt>(Reader.ReadSubStmt()));
1157
1158   if (HasFinally)
1159     S->setFinallyStmt(Reader.ReadSubStmt());
1160   S->setAtTryLoc(ReadSourceLocation(Record, Idx));
1161 }
1162
1163 void ASTStmtReader::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) {
1164   VisitStmt(S);
1165   S->setSynchExpr(Reader.ReadSubStmt());
1166   S->setSynchBody(Reader.ReadSubStmt());
1167   S->setAtSynchronizedLoc(ReadSourceLocation(Record, Idx));
1168 }
1169
1170 void ASTStmtReader::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {
1171   VisitStmt(S);
1172   S->setThrowExpr(Reader.ReadSubStmt());
1173   S->setThrowLoc(ReadSourceLocation(Record, Idx));
1174 }
1175
1176 void ASTStmtReader::VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) {
1177   VisitExpr(E);
1178   E->setValue(Record[Idx++]);
1179   E->setLocation(ReadSourceLocation(Record, Idx));
1180 }
1181
1182 //===----------------------------------------------------------------------===//
1183 // C++ Expressions and Statements
1184 //===----------------------------------------------------------------------===//
1185
1186 void ASTStmtReader::VisitCXXCatchStmt(CXXCatchStmt *S) {
1187   VisitStmt(S);
1188   S->CatchLoc = ReadSourceLocation(Record, Idx);
1189   S->ExceptionDecl = ReadDeclAs<VarDecl>(Record, Idx);
1190   S->HandlerBlock = Reader.ReadSubStmt();
1191 }
1192
1193 void ASTStmtReader::VisitCXXTryStmt(CXXTryStmt *S) {
1194   VisitStmt(S);
1195   assert(Record[Idx] == S->getNumHandlers() && "NumStmtFields is wrong ?");
1196   ++Idx;
1197   S->TryLoc = ReadSourceLocation(Record, Idx);
1198   S->getStmts()[0] = Reader.ReadSubStmt();
1199   for (unsigned i = 0, e = S->getNumHandlers(); i != e; ++i)
1200     S->getStmts()[i + 1] = Reader.ReadSubStmt();
1201 }
1202
1203 void ASTStmtReader::VisitCXXForRangeStmt(CXXForRangeStmt *S) {
1204   VisitStmt(S);
1205   S->ForLoc = ReadSourceLocation(Record, Idx);
1206   S->CoawaitLoc = ReadSourceLocation(Record, Idx);
1207   S->ColonLoc = ReadSourceLocation(Record, Idx);
1208   S->RParenLoc = ReadSourceLocation(Record, Idx);
1209   S->setRangeStmt(Reader.ReadSubStmt());
1210   S->setBeginEndStmt(Reader.ReadSubStmt());
1211   S->setCond(Reader.ReadSubExpr());
1212   S->setInc(Reader.ReadSubExpr());
1213   S->setLoopVarStmt(Reader.ReadSubStmt());
1214   S->setBody(Reader.ReadSubStmt());
1215 }
1216
1217 void ASTStmtReader::VisitMSDependentExistsStmt(MSDependentExistsStmt *S) {
1218   VisitStmt(S);
1219   S->KeywordLoc = ReadSourceLocation(Record, Idx);
1220   S->IsIfExists = Record[Idx++];
1221   S->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1222   ReadDeclarationNameInfo(S->NameInfo, Record, Idx);
1223   S->SubStmt = Reader.ReadSubStmt();
1224 }
1225
1226 void ASTStmtReader::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
1227   VisitCallExpr(E);
1228   E->Operator = (OverloadedOperatorKind)Record[Idx++];
1229   E->Range = Reader.ReadSourceRange(F, Record, Idx);
1230   E->setFPContractable((bool)Record[Idx++]);
1231 }
1232
1233 void ASTStmtReader::VisitCXXConstructExpr(CXXConstructExpr *E) {
1234   VisitExpr(E);
1235   E->NumArgs = Record[Idx++];
1236   if (E->NumArgs)
1237     E->Args = new (Reader.getContext()) Stmt*[E->NumArgs];
1238   for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
1239     E->setArg(I, Reader.ReadSubExpr());
1240   E->setConstructor(ReadDeclAs<CXXConstructorDecl>(Record, Idx));
1241   E->setLocation(ReadSourceLocation(Record, Idx));
1242   E->setElidable(Record[Idx++]);
1243   E->setHadMultipleCandidates(Record[Idx++]);
1244   E->setListInitialization(Record[Idx++]);
1245   E->setStdInitListInitialization(Record[Idx++]);
1246   E->setRequiresZeroInitialization(Record[Idx++]);
1247   E->setConstructionKind((CXXConstructExpr::ConstructionKind)Record[Idx++]);
1248   E->ParenOrBraceRange = ReadSourceRange(Record, Idx);
1249 }
1250
1251 void ASTStmtReader::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) {
1252   VisitCXXConstructExpr(E);
1253   E->Type = GetTypeSourceInfo(Record, Idx);
1254 }
1255
1256 void ASTStmtReader::VisitLambdaExpr(LambdaExpr *E) {
1257   VisitExpr(E);
1258   unsigned NumCaptures = Record[Idx++];
1259   assert(NumCaptures == E->NumCaptures);(void)NumCaptures;
1260   unsigned NumArrayIndexVars = Record[Idx++];
1261   E->IntroducerRange = ReadSourceRange(Record, Idx);
1262   E->CaptureDefault = static_cast<LambdaCaptureDefault>(Record[Idx++]);
1263   E->CaptureDefaultLoc = ReadSourceLocation(Record, Idx);
1264   E->ExplicitParams = Record[Idx++];
1265   E->ExplicitResultType = Record[Idx++];
1266   E->ClosingBrace = ReadSourceLocation(Record, Idx);
1267
1268   // Read capture initializers.
1269   for (LambdaExpr::capture_init_iterator C = E->capture_init_begin(),
1270                                       CEnd = E->capture_init_end();
1271        C != CEnd; ++C)
1272     *C = Reader.ReadSubExpr();
1273
1274   // Read array capture index variables.
1275   if (NumArrayIndexVars > 0) {
1276     unsigned *ArrayIndexStarts = E->getArrayIndexStarts();
1277     for (unsigned I = 0; I != NumCaptures + 1; ++I)
1278       ArrayIndexStarts[I] = Record[Idx++];
1279
1280     VarDecl **ArrayIndexVars = E->getArrayIndexVars();
1281     for (unsigned I = 0; I != NumArrayIndexVars; ++I)
1282       ArrayIndexVars[I] = ReadDeclAs<VarDecl>(Record, Idx);
1283   }
1284 }
1285
1286 void
1287 ASTStmtReader::VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) {
1288   VisitExpr(E);
1289   E->SubExpr = Reader.ReadSubExpr();
1290 }
1291
1292 void ASTStmtReader::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
1293   VisitExplicitCastExpr(E);
1294   SourceRange R = ReadSourceRange(Record, Idx);
1295   E->Loc = R.getBegin();
1296   E->RParenLoc = R.getEnd();
1297   R = ReadSourceRange(Record, Idx);
1298   E->AngleBrackets = R;
1299 }
1300
1301 void ASTStmtReader::VisitCXXStaticCastExpr(CXXStaticCastExpr *E) {
1302   return VisitCXXNamedCastExpr(E);
1303 }
1304
1305 void ASTStmtReader::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E) {
1306   return VisitCXXNamedCastExpr(E);
1307 }
1308
1309 void ASTStmtReader::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E) {
1310   return VisitCXXNamedCastExpr(E);
1311 }
1312
1313 void ASTStmtReader::VisitCXXConstCastExpr(CXXConstCastExpr *E) {
1314   return VisitCXXNamedCastExpr(E);
1315 }
1316
1317 void ASTStmtReader::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) {
1318   VisitExplicitCastExpr(E);
1319   E->setLParenLoc(ReadSourceLocation(Record, Idx));
1320   E->setRParenLoc(ReadSourceLocation(Record, Idx));
1321 }
1322
1323 void ASTStmtReader::VisitUserDefinedLiteral(UserDefinedLiteral *E) {
1324   VisitCallExpr(E);
1325   E->UDSuffixLoc = ReadSourceLocation(Record, Idx);
1326 }
1327
1328 void ASTStmtReader::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
1329   VisitExpr(E);
1330   E->setValue(Record[Idx++]);
1331   E->setLocation(ReadSourceLocation(Record, Idx));
1332 }
1333
1334 void ASTStmtReader::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {
1335   VisitExpr(E);
1336   E->setLocation(ReadSourceLocation(Record, Idx));
1337 }
1338
1339 void ASTStmtReader::VisitCXXTypeidExpr(CXXTypeidExpr *E) {
1340   VisitExpr(E);
1341   E->setSourceRange(ReadSourceRange(Record, Idx));
1342   if (E->isTypeOperand()) { // typeid(int)
1343     E->setTypeOperandSourceInfo(
1344         GetTypeSourceInfo(Record, Idx));
1345     return;
1346   }
1347
1348   // typeid(42+2)
1349   E->setExprOperand(Reader.ReadSubExpr());
1350 }
1351
1352 void ASTStmtReader::VisitCXXThisExpr(CXXThisExpr *E) {
1353   VisitExpr(E);
1354   E->setLocation(ReadSourceLocation(Record, Idx));
1355   E->setImplicit(Record[Idx++]);
1356 }
1357
1358 void ASTStmtReader::VisitCXXThrowExpr(CXXThrowExpr *E) {
1359   VisitExpr(E);
1360   E->ThrowLoc = ReadSourceLocation(Record, Idx);
1361   E->Op = Reader.ReadSubExpr();
1362   E->IsThrownVariableInScope = Record[Idx++];
1363 }
1364
1365 void ASTStmtReader::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
1366   VisitExpr(E);
1367
1368   assert((bool)Record[Idx] == E->Param.getInt() && "We messed up at creation ?");
1369   ++Idx; // HasOtherExprStored and SubExpr was handled during creation.
1370   E->Param.setPointer(ReadDeclAs<ParmVarDecl>(Record, Idx));
1371   E->Loc = ReadSourceLocation(Record, Idx);
1372 }
1373
1374 void ASTStmtReader::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
1375   VisitExpr(E);
1376   E->Field = ReadDeclAs<FieldDecl>(Record, Idx);
1377   E->Loc = ReadSourceLocation(Record, Idx);
1378 }
1379
1380 void ASTStmtReader::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
1381   VisitExpr(E);
1382   E->setTemporary(Reader.ReadCXXTemporary(F, Record, Idx));
1383   E->setSubExpr(Reader.ReadSubExpr());
1384 }
1385
1386 void ASTStmtReader::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
1387   VisitExpr(E);
1388   E->TypeInfo = GetTypeSourceInfo(Record, Idx);
1389   E->RParenLoc = ReadSourceLocation(Record, Idx);
1390 }
1391
1392 void ASTStmtReader::VisitCXXNewExpr(CXXNewExpr *E) {
1393   VisitExpr(E);
1394   E->GlobalNew = Record[Idx++];
1395   bool isArray = Record[Idx++];
1396   E->UsualArrayDeleteWantsSize = Record[Idx++];
1397   unsigned NumPlacementArgs = Record[Idx++];
1398   E->StoredInitializationStyle = Record[Idx++];
1399   E->setOperatorNew(ReadDeclAs<FunctionDecl>(Record, Idx));
1400   E->setOperatorDelete(ReadDeclAs<FunctionDecl>(Record, Idx));
1401   E->AllocatedTypeInfo = GetTypeSourceInfo(Record, Idx);
1402   E->TypeIdParens = ReadSourceRange(Record, Idx);
1403   E->Range = ReadSourceRange(Record, Idx);
1404   E->DirectInitRange = ReadSourceRange(Record, Idx);
1405
1406   E->AllocateArgsArray(Reader.getContext(), isArray, NumPlacementArgs,
1407                        E->StoredInitializationStyle != 0);
1408
1409   // Install all the subexpressions.
1410   for (CXXNewExpr::raw_arg_iterator I = E->raw_arg_begin(),e = E->raw_arg_end();
1411        I != e; ++I)
1412     *I = Reader.ReadSubStmt();
1413 }
1414
1415 void ASTStmtReader::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
1416   VisitExpr(E);
1417   E->GlobalDelete = Record[Idx++];
1418   E->ArrayForm = Record[Idx++];
1419   E->ArrayFormAsWritten = Record[Idx++];
1420   E->UsualArrayDeleteWantsSize = Record[Idx++];
1421   E->OperatorDelete = ReadDeclAs<FunctionDecl>(Record, Idx);
1422   E->Argument = Reader.ReadSubExpr();
1423   E->Loc = ReadSourceLocation(Record, Idx);
1424 }
1425
1426 void ASTStmtReader::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) {
1427   VisitExpr(E);
1428
1429   E->Base = Reader.ReadSubExpr();
1430   E->IsArrow = Record[Idx++];
1431   E->OperatorLoc = ReadSourceLocation(Record, Idx);
1432   E->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1433   E->ScopeType = GetTypeSourceInfo(Record, Idx);
1434   E->ColonColonLoc = ReadSourceLocation(Record, Idx);
1435   E->TildeLoc = ReadSourceLocation(Record, Idx);
1436
1437   IdentifierInfo *II = Reader.GetIdentifierInfo(F, Record, Idx);
1438   if (II)
1439     E->setDestroyedType(II, ReadSourceLocation(Record, Idx));
1440   else
1441     E->setDestroyedType(GetTypeSourceInfo(Record, Idx));
1442 }
1443
1444 void ASTStmtReader::VisitExprWithCleanups(ExprWithCleanups *E) {
1445   VisitExpr(E);
1446
1447   unsigned NumObjects = Record[Idx++];
1448   assert(NumObjects == E->getNumObjects());
1449   for (unsigned i = 0; i != NumObjects; ++i)
1450     E->getTrailingObjects<BlockDecl *>()[i] =
1451         ReadDeclAs<BlockDecl>(Record, Idx);
1452
1453   E->SubExpr = Reader.ReadSubExpr();
1454 }
1455
1456 void
1457 ASTStmtReader::VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E){
1458   VisitExpr(E);
1459
1460   if (Record[Idx++]) // HasTemplateKWAndArgsInfo
1461     ReadTemplateKWAndArgsInfo(
1462         *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
1463         E->getTrailingObjects<TemplateArgumentLoc>(),
1464         /*NumTemplateArgs=*/Record[Idx++]);
1465
1466   E->Base = Reader.ReadSubExpr();
1467   E->BaseType = Reader.readType(F, Record, Idx);
1468   E->IsArrow = Record[Idx++];
1469   E->OperatorLoc = ReadSourceLocation(Record, Idx);
1470   E->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1471   E->FirstQualifierFoundInScope = ReadDeclAs<NamedDecl>(Record, Idx);
1472   ReadDeclarationNameInfo(E->MemberNameInfo, Record, Idx);
1473 }
1474
1475 void
1476 ASTStmtReader::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
1477   VisitExpr(E);
1478
1479   if (Record[Idx++]) // HasTemplateKWAndArgsInfo
1480     ReadTemplateKWAndArgsInfo(
1481         *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
1482         E->getTrailingObjects<TemplateArgumentLoc>(),
1483         /*NumTemplateArgs=*/Record[Idx++]);
1484
1485   E->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1486   ReadDeclarationNameInfo(E->NameInfo, Record, Idx);
1487 }
1488
1489 void
1490 ASTStmtReader::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) {
1491   VisitExpr(E);
1492   assert(Record[Idx] == E->arg_size() && "Read wrong record during creation ?");
1493   ++Idx; // NumArgs;
1494   for (unsigned I = 0, N = E->arg_size(); I != N; ++I)
1495     E->setArg(I, Reader.ReadSubExpr());
1496   E->Type = GetTypeSourceInfo(Record, Idx);
1497   E->setLParenLoc(ReadSourceLocation(Record, Idx));
1498   E->setRParenLoc(ReadSourceLocation(Record, Idx));
1499 }
1500
1501 void ASTStmtReader::VisitOverloadExpr(OverloadExpr *E) {
1502   VisitExpr(E);
1503
1504   if (Record[Idx++]) // HasTemplateKWAndArgsInfo
1505     ReadTemplateKWAndArgsInfo(*E->getTrailingASTTemplateKWAndArgsInfo(),
1506                               E->getTrailingTemplateArgumentLoc(),
1507                               /*NumTemplateArgs=*/Record[Idx++]);
1508
1509   unsigned NumDecls = Record[Idx++];
1510   UnresolvedSet<8> Decls;
1511   for (unsigned i = 0; i != NumDecls; ++i) {
1512     NamedDecl *D = ReadDeclAs<NamedDecl>(Record, Idx);
1513     AccessSpecifier AS = (AccessSpecifier)Record[Idx++];
1514     Decls.addDecl(D, AS);
1515   }
1516   E->initializeResults(Reader.getContext(), Decls.begin(), Decls.end());
1517
1518   ReadDeclarationNameInfo(E->NameInfo, Record, Idx);
1519   E->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1520 }
1521
1522 void ASTStmtReader::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) {
1523   VisitOverloadExpr(E);
1524   E->IsArrow = Record[Idx++];
1525   E->HasUnresolvedUsing = Record[Idx++];
1526   E->Base = Reader.ReadSubExpr();
1527   E->BaseType = Reader.readType(F, Record, Idx);
1528   E->OperatorLoc = ReadSourceLocation(Record, Idx);
1529 }
1530
1531 void ASTStmtReader::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
1532   VisitOverloadExpr(E);
1533   E->RequiresADL = Record[Idx++];
1534   E->Overloaded = Record[Idx++];
1535   E->NamingClass = ReadDeclAs<CXXRecordDecl>(Record, Idx);
1536 }
1537
1538 void ASTStmtReader::VisitTypeTraitExpr(TypeTraitExpr *E) {
1539   VisitExpr(E);
1540   E->TypeTraitExprBits.NumArgs = Record[Idx++];
1541   E->TypeTraitExprBits.Kind = Record[Idx++];
1542   E->TypeTraitExprBits.Value = Record[Idx++];
1543   SourceRange Range = ReadSourceRange(Record, Idx);
1544   E->Loc = Range.getBegin();
1545   E->RParenLoc = Range.getEnd();
1546
1547   TypeSourceInfo **Args = E->getTrailingObjects<TypeSourceInfo *>();
1548   for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
1549     Args[I] = GetTypeSourceInfo(Record, Idx);
1550 }
1551
1552 void ASTStmtReader::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
1553   VisitExpr(E);
1554   E->ATT = (ArrayTypeTrait)Record[Idx++];
1555   E->Value = (unsigned int)Record[Idx++];
1556   SourceRange Range = ReadSourceRange(Record, Idx);
1557   E->Loc = Range.getBegin();
1558   E->RParen = Range.getEnd();
1559   E->QueriedType = GetTypeSourceInfo(Record, Idx);
1560 }
1561
1562 void ASTStmtReader::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
1563   VisitExpr(E);
1564   E->ET = (ExpressionTrait)Record[Idx++];
1565   E->Value = (bool)Record[Idx++];
1566   SourceRange Range = ReadSourceRange(Record, Idx);
1567   E->QueriedExpression = Reader.ReadSubExpr();
1568   E->Loc = Range.getBegin();
1569   E->RParen = Range.getEnd();
1570 }
1571
1572 void ASTStmtReader::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
1573   VisitExpr(E);
1574   E->Value = (bool)Record[Idx++];
1575   E->Range = ReadSourceRange(Record, Idx);
1576   E->Operand = Reader.ReadSubExpr();
1577 }
1578
1579 void ASTStmtReader::VisitPackExpansionExpr(PackExpansionExpr *E) {
1580   VisitExpr(E);
1581   E->EllipsisLoc = ReadSourceLocation(Record, Idx);
1582   E->NumExpansions = Record[Idx++];
1583   E->Pattern = Reader.ReadSubExpr();
1584 }
1585
1586 void ASTStmtReader::VisitSizeOfPackExpr(SizeOfPackExpr *E) {
1587   VisitExpr(E);
1588   unsigned NumPartialArgs = Record[Idx++];
1589   E->OperatorLoc = ReadSourceLocation(Record, Idx);
1590   E->PackLoc = ReadSourceLocation(Record, Idx);
1591   E->RParenLoc = ReadSourceLocation(Record, Idx);
1592   E->Pack = Reader.ReadDeclAs<NamedDecl>(F, Record, Idx);
1593   if (E->isPartiallySubstituted()) {
1594     assert(E->Length == NumPartialArgs);
1595     for (auto *I = E->getTrailingObjects<TemplateArgument>(),
1596               *E = I + NumPartialArgs;
1597          I != E; ++I)
1598       new (I) TemplateArgument(Reader.ReadTemplateArgument(F, Record, Idx));
1599   } else if (!E->isValueDependent()) {
1600     E->Length = Record[Idx++];
1601   }
1602 }
1603
1604 void ASTStmtReader::VisitSubstNonTypeTemplateParmExpr(
1605                                               SubstNonTypeTemplateParmExpr *E) {
1606   VisitExpr(E);
1607   E->Param = ReadDeclAs<NonTypeTemplateParmDecl>(Record, Idx);
1608   E->NameLoc = ReadSourceLocation(Record, Idx);
1609   E->Replacement = Reader.ReadSubExpr();
1610 }
1611
1612 void ASTStmtReader::VisitSubstNonTypeTemplateParmPackExpr(
1613                                           SubstNonTypeTemplateParmPackExpr *E) {
1614   VisitExpr(E);
1615   E->Param = ReadDeclAs<NonTypeTemplateParmDecl>(Record, Idx);
1616   TemplateArgument ArgPack = Reader.ReadTemplateArgument(F, Record, Idx);
1617   if (ArgPack.getKind() != TemplateArgument::Pack)
1618     return;
1619
1620   E->Arguments = ArgPack.pack_begin();
1621   E->NumArguments = ArgPack.pack_size();
1622   E->NameLoc = ReadSourceLocation(Record, Idx);
1623 }
1624
1625 void ASTStmtReader::VisitFunctionParmPackExpr(FunctionParmPackExpr *E) {
1626   VisitExpr(E);
1627   E->NumParameters = Record[Idx++];
1628   E->ParamPack = ReadDeclAs<ParmVarDecl>(Record, Idx);
1629   E->NameLoc = ReadSourceLocation(Record, Idx);
1630   ParmVarDecl **Parms = E->getTrailingObjects<ParmVarDecl *>();
1631   for (unsigned i = 0, n = E->NumParameters; i != n; ++i)
1632     Parms[i] = ReadDeclAs<ParmVarDecl>(Record, Idx);
1633 }
1634
1635 void ASTStmtReader::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
1636   VisitExpr(E);
1637   E->State = Reader.ReadSubExpr();
1638   auto VD = ReadDeclAs<ValueDecl>(Record, Idx);
1639   unsigned ManglingNumber = Record[Idx++];
1640   E->setExtendingDecl(VD, ManglingNumber);
1641 }
1642
1643 void ASTStmtReader::VisitCXXFoldExpr(CXXFoldExpr *E) {
1644   VisitExpr(E);
1645   E->LParenLoc = ReadSourceLocation(Record, Idx);
1646   E->EllipsisLoc = ReadSourceLocation(Record, Idx);
1647   E->RParenLoc = ReadSourceLocation(Record, Idx);
1648   E->SubExprs[0] = Reader.ReadSubExpr();
1649   E->SubExprs[1] = Reader.ReadSubExpr();
1650   E->Opcode = (BinaryOperatorKind)Record[Idx++];
1651 }
1652
1653 void ASTStmtReader::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
1654   VisitExpr(E);
1655   E->SourceExpr = Reader.ReadSubExpr();
1656   E->Loc = ReadSourceLocation(Record, Idx);
1657 }
1658
1659 void ASTStmtReader::VisitTypoExpr(TypoExpr *E) {
1660   llvm_unreachable("Cannot read TypoExpr nodes");
1661 }
1662
1663 //===----------------------------------------------------------------------===//
1664 // Microsoft Expressions and Statements
1665 //===----------------------------------------------------------------------===//
1666 void ASTStmtReader::VisitMSPropertyRefExpr(MSPropertyRefExpr *E) {
1667   VisitExpr(E);
1668   E->IsArrow = (Record[Idx++] != 0);
1669   E->BaseExpr = Reader.ReadSubExpr();
1670   E->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1671   E->MemberLoc = ReadSourceLocation(Record, Idx);
1672   E->TheDecl = ReadDeclAs<MSPropertyDecl>(Record, Idx);
1673 }
1674
1675 void ASTStmtReader::VisitMSPropertySubscriptExpr(MSPropertySubscriptExpr *E) {
1676   VisitExpr(E);
1677   E->setBase(Reader.ReadSubExpr());
1678   E->setIdx(Reader.ReadSubExpr());
1679   E->setRBracketLoc(ReadSourceLocation(Record, Idx));
1680 }
1681
1682 void ASTStmtReader::VisitCXXUuidofExpr(CXXUuidofExpr *E) {
1683   VisitExpr(E);
1684   E->setSourceRange(ReadSourceRange(Record, Idx));
1685   if (E->isTypeOperand()) { // __uuidof(ComType)
1686     E->setTypeOperandSourceInfo(
1687         GetTypeSourceInfo(Record, Idx));
1688     return;
1689   }
1690
1691   // __uuidof(expr)
1692   E->setExprOperand(Reader.ReadSubExpr());
1693 }
1694
1695 void ASTStmtReader::VisitSEHLeaveStmt(SEHLeaveStmt *S) {
1696   VisitStmt(S);
1697   S->setLeaveLoc(ReadSourceLocation(Record, Idx));
1698 }
1699
1700 void ASTStmtReader::VisitSEHExceptStmt(SEHExceptStmt *S) {
1701   VisitStmt(S);
1702   S->Loc = ReadSourceLocation(Record, Idx);
1703   S->Children[SEHExceptStmt::FILTER_EXPR] = Reader.ReadSubStmt();
1704   S->Children[SEHExceptStmt::BLOCK] = Reader.ReadSubStmt();
1705 }
1706
1707 void ASTStmtReader::VisitSEHFinallyStmt(SEHFinallyStmt *S) {
1708   VisitStmt(S);
1709   S->Loc = ReadSourceLocation(Record, Idx);
1710   S->Block = Reader.ReadSubStmt();
1711 }
1712
1713 void ASTStmtReader::VisitSEHTryStmt(SEHTryStmt *S) {
1714   VisitStmt(S);
1715   S->IsCXXTry = Record[Idx++];
1716   S->TryLoc = ReadSourceLocation(Record, Idx);
1717   S->Children[SEHTryStmt::TRY] = Reader.ReadSubStmt();
1718   S->Children[SEHTryStmt::HANDLER] = Reader.ReadSubStmt();
1719 }
1720
1721 //===----------------------------------------------------------------------===//
1722 // CUDA Expressions and Statements
1723 //===----------------------------------------------------------------------===//
1724
1725 void ASTStmtReader::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *E) {
1726   VisitCallExpr(E);
1727   E->setConfig(cast<CallExpr>(Reader.ReadSubExpr()));
1728 }
1729
1730 //===----------------------------------------------------------------------===//
1731 // OpenCL Expressions and Statements.
1732 //===----------------------------------------------------------------------===//
1733 void ASTStmtReader::VisitAsTypeExpr(AsTypeExpr *E) {
1734   VisitExpr(E);
1735   E->BuiltinLoc = ReadSourceLocation(Record, Idx);
1736   E->RParenLoc = ReadSourceLocation(Record, Idx);
1737   E->SrcExpr = Reader.ReadSubExpr();
1738 }
1739
1740 //===----------------------------------------------------------------------===//
1741 // OpenMP Clauses.
1742 //===----------------------------------------------------------------------===//
1743
1744 namespace clang {
1745 class OMPClauseReader : public OMPClauseVisitor<OMPClauseReader> {
1746   ASTStmtReader *Reader;
1747   ASTContext &Context;
1748   const ASTReader::RecordData &Record;
1749   unsigned &Idx;
1750 public:
1751   OMPClauseReader(ASTStmtReader *R, ASTContext &C,
1752                   const ASTReader::RecordData &Record, unsigned &Idx)
1753     : Reader(R), Context(C), Record(Record), Idx(Idx) { }
1754 #define OPENMP_CLAUSE(Name, Class)    \
1755   void Visit##Class(Class *S);
1756 #include "clang/Basic/OpenMPKinds.def"
1757   OMPClause *readClause();
1758 };
1759 }
1760
1761 OMPClause *OMPClauseReader::readClause() {
1762   OMPClause *C;
1763   switch (Record[Idx++]) {
1764   case OMPC_if:
1765     C = new (Context) OMPIfClause();
1766     break;
1767   case OMPC_final:
1768     C = new (Context) OMPFinalClause();
1769     break;
1770   case OMPC_num_threads:
1771     C = new (Context) OMPNumThreadsClause();
1772     break;
1773   case OMPC_safelen:
1774     C = new (Context) OMPSafelenClause();
1775     break;
1776   case OMPC_simdlen:
1777     C = new (Context) OMPSimdlenClause();
1778     break;
1779   case OMPC_collapse:
1780     C = new (Context) OMPCollapseClause();
1781     break;
1782   case OMPC_default:
1783     C = new (Context) OMPDefaultClause();
1784     break;
1785   case OMPC_proc_bind:
1786     C = new (Context) OMPProcBindClause();
1787     break;
1788   case OMPC_schedule:
1789     C = new (Context) OMPScheduleClause();
1790     break;
1791   case OMPC_ordered:
1792     C = new (Context) OMPOrderedClause();
1793     break;
1794   case OMPC_nowait:
1795     C = new (Context) OMPNowaitClause();
1796     break;
1797   case OMPC_untied:
1798     C = new (Context) OMPUntiedClause();
1799     break;
1800   case OMPC_mergeable:
1801     C = new (Context) OMPMergeableClause();
1802     break;
1803   case OMPC_read:
1804     C = new (Context) OMPReadClause();
1805     break;
1806   case OMPC_write:
1807     C = new (Context) OMPWriteClause();
1808     break;
1809   case OMPC_update:
1810     C = new (Context) OMPUpdateClause();
1811     break;
1812   case OMPC_capture:
1813     C = new (Context) OMPCaptureClause();
1814     break;
1815   case OMPC_seq_cst:
1816     C = new (Context) OMPSeqCstClause();
1817     break;
1818   case OMPC_threads:
1819     C = new (Context) OMPThreadsClause();
1820     break;
1821   case OMPC_simd:
1822     C = new (Context) OMPSIMDClause();
1823     break;
1824   case OMPC_nogroup:
1825     C = new (Context) OMPNogroupClause();
1826     break;
1827   case OMPC_private:
1828     C = OMPPrivateClause::CreateEmpty(Context, Record[Idx++]);
1829     break;
1830   case OMPC_firstprivate:
1831     C = OMPFirstprivateClause::CreateEmpty(Context, Record[Idx++]);
1832     break;
1833   case OMPC_lastprivate:
1834     C = OMPLastprivateClause::CreateEmpty(Context, Record[Idx++]);
1835     break;
1836   case OMPC_shared:
1837     C = OMPSharedClause::CreateEmpty(Context, Record[Idx++]);
1838     break;
1839   case OMPC_reduction:
1840     C = OMPReductionClause::CreateEmpty(Context, Record[Idx++]);
1841     break;
1842   case OMPC_linear:
1843     C = OMPLinearClause::CreateEmpty(Context, Record[Idx++]);
1844     break;
1845   case OMPC_aligned:
1846     C = OMPAlignedClause::CreateEmpty(Context, Record[Idx++]);
1847     break;
1848   case OMPC_copyin:
1849     C = OMPCopyinClause::CreateEmpty(Context, Record[Idx++]);
1850     break;
1851   case OMPC_copyprivate:
1852     C = OMPCopyprivateClause::CreateEmpty(Context, Record[Idx++]);
1853     break;
1854   case OMPC_flush:
1855     C = OMPFlushClause::CreateEmpty(Context, Record[Idx++]);
1856     break;
1857   case OMPC_depend:
1858     C = OMPDependClause::CreateEmpty(Context, Record[Idx++]);
1859     break;
1860   case OMPC_device:
1861     C = new (Context) OMPDeviceClause();
1862     break;
1863   case OMPC_map:
1864     C = OMPMapClause::CreateEmpty(Context, Record[Idx++]);
1865     break;
1866   case OMPC_num_teams:
1867     C = new (Context) OMPNumTeamsClause();
1868     break;
1869   case OMPC_thread_limit:
1870     C = new (Context) OMPThreadLimitClause();
1871     break;
1872   case OMPC_priority:
1873     C = new (Context) OMPPriorityClause();
1874     break;
1875   case OMPC_grainsize:
1876     C = new (Context) OMPGrainsizeClause();
1877     break;
1878   case OMPC_num_tasks:
1879     C = new (Context) OMPNumTasksClause();
1880     break;
1881   case OMPC_hint:
1882     C = new (Context) OMPHintClause();
1883     break;
1884   }
1885   Visit(C);
1886   C->setLocStart(Reader->ReadSourceLocation(Record, Idx));
1887   C->setLocEnd(Reader->ReadSourceLocation(Record, Idx));
1888
1889   return C;
1890 }
1891
1892 void OMPClauseReader::VisitOMPIfClause(OMPIfClause *C) {
1893   C->setNameModifier(static_cast<OpenMPDirectiveKind>(Record[Idx++]));
1894   C->setNameModifierLoc(Reader->ReadSourceLocation(Record, Idx));
1895   C->setColonLoc(Reader->ReadSourceLocation(Record, Idx));
1896   C->setCondition(Reader->Reader.ReadSubExpr());
1897   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
1898 }
1899
1900 void OMPClauseReader::VisitOMPFinalClause(OMPFinalClause *C) {
1901   C->setCondition(Reader->Reader.ReadSubExpr());
1902   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
1903 }
1904
1905 void OMPClauseReader::VisitOMPNumThreadsClause(OMPNumThreadsClause *C) {
1906   C->setNumThreads(Reader->Reader.ReadSubExpr());
1907   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
1908 }
1909
1910 void OMPClauseReader::VisitOMPSafelenClause(OMPSafelenClause *C) {
1911   C->setSafelen(Reader->Reader.ReadSubExpr());
1912   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
1913 }
1914
1915 void OMPClauseReader::VisitOMPSimdlenClause(OMPSimdlenClause *C) {
1916   C->setSimdlen(Reader->Reader.ReadSubExpr());
1917   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
1918 }
1919
1920 void OMPClauseReader::VisitOMPCollapseClause(OMPCollapseClause *C) {
1921   C->setNumForLoops(Reader->Reader.ReadSubExpr());
1922   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
1923 }
1924
1925 void OMPClauseReader::VisitOMPDefaultClause(OMPDefaultClause *C) {
1926   C->setDefaultKind(
1927        static_cast<OpenMPDefaultClauseKind>(Record[Idx++]));
1928   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
1929   C->setDefaultKindKwLoc(Reader->ReadSourceLocation(Record, Idx));
1930 }
1931
1932 void OMPClauseReader::VisitOMPProcBindClause(OMPProcBindClause *C) {
1933   C->setProcBindKind(
1934        static_cast<OpenMPProcBindClauseKind>(Record[Idx++]));
1935   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
1936   C->setProcBindKindKwLoc(Reader->ReadSourceLocation(Record, Idx));
1937 }
1938
1939 void OMPClauseReader::VisitOMPScheduleClause(OMPScheduleClause *C) {
1940   C->setScheduleKind(
1941        static_cast<OpenMPScheduleClauseKind>(Record[Idx++]));
1942   C->setFirstScheduleModifier(
1943       static_cast<OpenMPScheduleClauseModifier>(Record[Idx++]));
1944   C->setSecondScheduleModifier(
1945       static_cast<OpenMPScheduleClauseModifier>(Record[Idx++]));
1946   C->setChunkSize(Reader->Reader.ReadSubExpr());
1947   C->setHelperChunkSize(Reader->Reader.ReadSubExpr());
1948   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
1949   C->setFirstScheduleModifierLoc(Reader->ReadSourceLocation(Record, Idx));
1950   C->setSecondScheduleModifierLoc(Reader->ReadSourceLocation(Record, Idx));
1951   C->setScheduleKindLoc(Reader->ReadSourceLocation(Record, Idx));
1952   C->setCommaLoc(Reader->ReadSourceLocation(Record, Idx));
1953 }
1954
1955 void OMPClauseReader::VisitOMPOrderedClause(OMPOrderedClause *C) {
1956   C->setNumForLoops(Reader->Reader.ReadSubExpr());
1957   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
1958 }
1959
1960 void OMPClauseReader::VisitOMPNowaitClause(OMPNowaitClause *) {}
1961
1962 void OMPClauseReader::VisitOMPUntiedClause(OMPUntiedClause *) {}
1963
1964 void OMPClauseReader::VisitOMPMergeableClause(OMPMergeableClause *) {}
1965
1966 void OMPClauseReader::VisitOMPReadClause(OMPReadClause *) {}
1967
1968 void OMPClauseReader::VisitOMPWriteClause(OMPWriteClause *) {}
1969
1970 void OMPClauseReader::VisitOMPUpdateClause(OMPUpdateClause *) {}
1971
1972 void OMPClauseReader::VisitOMPCaptureClause(OMPCaptureClause *) {}
1973
1974 void OMPClauseReader::VisitOMPSeqCstClause(OMPSeqCstClause *) {}
1975
1976 void OMPClauseReader::VisitOMPThreadsClause(OMPThreadsClause *) {}
1977
1978 void OMPClauseReader::VisitOMPSIMDClause(OMPSIMDClause *) {}
1979
1980 void OMPClauseReader::VisitOMPNogroupClause(OMPNogroupClause *) {}
1981
1982 void OMPClauseReader::VisitOMPPrivateClause(OMPPrivateClause *C) {
1983   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
1984   unsigned NumVars = C->varlist_size();
1985   SmallVector<Expr *, 16> Vars;
1986   Vars.reserve(NumVars);
1987   for (unsigned i = 0; i != NumVars; ++i)
1988     Vars.push_back(Reader->Reader.ReadSubExpr());
1989   C->setVarRefs(Vars);
1990   Vars.clear();
1991   for (unsigned i = 0; i != NumVars; ++i)
1992     Vars.push_back(Reader->Reader.ReadSubExpr());
1993   C->setPrivateCopies(Vars);
1994 }
1995
1996 void OMPClauseReader::VisitOMPFirstprivateClause(OMPFirstprivateClause *C) {
1997   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
1998   unsigned NumVars = C->varlist_size();
1999   SmallVector<Expr *, 16> Vars;
2000   Vars.reserve(NumVars);
2001   for (unsigned i = 0; i != NumVars; ++i)
2002     Vars.push_back(Reader->Reader.ReadSubExpr());
2003   C->setVarRefs(Vars);
2004   Vars.clear();
2005   for (unsigned i = 0; i != NumVars; ++i)
2006     Vars.push_back(Reader->Reader.ReadSubExpr());
2007   C->setPrivateCopies(Vars);
2008   Vars.clear();
2009   for (unsigned i = 0; i != NumVars; ++i)
2010     Vars.push_back(Reader->Reader.ReadSubExpr());
2011   C->setInits(Vars);
2012 }
2013
2014 void OMPClauseReader::VisitOMPLastprivateClause(OMPLastprivateClause *C) {
2015   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
2016   unsigned NumVars = C->varlist_size();
2017   SmallVector<Expr *, 16> Vars;
2018   Vars.reserve(NumVars);
2019   for (unsigned i = 0; i != NumVars; ++i)
2020     Vars.push_back(Reader->Reader.ReadSubExpr());
2021   C->setVarRefs(Vars);
2022   Vars.clear();
2023   for (unsigned i = 0; i != NumVars; ++i)
2024     Vars.push_back(Reader->Reader.ReadSubExpr());
2025   C->setPrivateCopies(Vars);
2026   Vars.clear();
2027   for (unsigned i = 0; i != NumVars; ++i)
2028     Vars.push_back(Reader->Reader.ReadSubExpr());
2029   C->setSourceExprs(Vars);
2030   Vars.clear();
2031   for (unsigned i = 0; i != NumVars; ++i)
2032     Vars.push_back(Reader->Reader.ReadSubExpr());
2033   C->setDestinationExprs(Vars);
2034   Vars.clear();
2035   for (unsigned i = 0; i != NumVars; ++i)
2036     Vars.push_back(Reader->Reader.ReadSubExpr());
2037   C->setAssignmentOps(Vars);
2038 }
2039
2040 void OMPClauseReader::VisitOMPSharedClause(OMPSharedClause *C) {
2041   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
2042   unsigned NumVars = C->varlist_size();
2043   SmallVector<Expr *, 16> Vars;
2044   Vars.reserve(NumVars);
2045   for (unsigned i = 0; i != NumVars; ++i)
2046     Vars.push_back(Reader->Reader.ReadSubExpr());
2047   C->setVarRefs(Vars);
2048 }
2049
2050 void OMPClauseReader::VisitOMPReductionClause(OMPReductionClause *C) {
2051   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
2052   C->setColonLoc(Reader->ReadSourceLocation(Record, Idx));
2053   NestedNameSpecifierLoc NNSL =
2054     Reader->Reader.ReadNestedNameSpecifierLoc(Reader->F, Record, Idx);
2055   DeclarationNameInfo DNI;
2056   Reader->ReadDeclarationNameInfo(DNI, Record, Idx);
2057   C->setQualifierLoc(NNSL);
2058   C->setNameInfo(DNI);
2059
2060   unsigned NumVars = C->varlist_size();
2061   SmallVector<Expr *, 16> Vars;
2062   Vars.reserve(NumVars);
2063   for (unsigned i = 0; i != NumVars; ++i)
2064     Vars.push_back(Reader->Reader.ReadSubExpr());
2065   C->setVarRefs(Vars);
2066   Vars.clear();
2067   for (unsigned i = 0; i != NumVars; ++i)
2068     Vars.push_back(Reader->Reader.ReadSubExpr());
2069   C->setPrivates(Vars);
2070   Vars.clear();
2071   for (unsigned i = 0; i != NumVars; ++i)
2072     Vars.push_back(Reader->Reader.ReadSubExpr());
2073   C->setLHSExprs(Vars);
2074   Vars.clear();
2075   for (unsigned i = 0; i != NumVars; ++i)
2076     Vars.push_back(Reader->Reader.ReadSubExpr());
2077   C->setRHSExprs(Vars);
2078   Vars.clear();
2079   for (unsigned i = 0; i != NumVars; ++i)
2080     Vars.push_back(Reader->Reader.ReadSubExpr());
2081   C->setReductionOps(Vars);
2082 }
2083
2084 void OMPClauseReader::VisitOMPLinearClause(OMPLinearClause *C) {
2085   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
2086   C->setColonLoc(Reader->ReadSourceLocation(Record, Idx));
2087   C->setModifier(static_cast<OpenMPLinearClauseKind>(Record[Idx++]));
2088   C->setModifierLoc(Reader->ReadSourceLocation(Record, Idx));
2089   unsigned NumVars = C->varlist_size();
2090   SmallVector<Expr *, 16> Vars;
2091   Vars.reserve(NumVars);
2092   for (unsigned i = 0; i != NumVars; ++i)
2093     Vars.push_back(Reader->Reader.ReadSubExpr());
2094   C->setVarRefs(Vars);
2095   Vars.clear();
2096   for (unsigned i = 0; i != NumVars; ++i)
2097     Vars.push_back(Reader->Reader.ReadSubExpr());
2098   C->setPrivates(Vars);
2099   Vars.clear();
2100   for (unsigned i = 0; i != NumVars; ++i)
2101     Vars.push_back(Reader->Reader.ReadSubExpr());
2102   C->setInits(Vars);
2103   Vars.clear();
2104   for (unsigned i = 0; i != NumVars; ++i)
2105     Vars.push_back(Reader->Reader.ReadSubExpr());
2106   C->setUpdates(Vars);
2107   Vars.clear();
2108   for (unsigned i = 0; i != NumVars; ++i)
2109     Vars.push_back(Reader->Reader.ReadSubExpr());
2110   C->setFinals(Vars);
2111   C->setStep(Reader->Reader.ReadSubExpr());
2112   C->setCalcStep(Reader->Reader.ReadSubExpr());
2113 }
2114
2115 void OMPClauseReader::VisitOMPAlignedClause(OMPAlignedClause *C) {
2116   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
2117   C->setColonLoc(Reader->ReadSourceLocation(Record, Idx));
2118   unsigned NumVars = C->varlist_size();
2119   SmallVector<Expr *, 16> Vars;
2120   Vars.reserve(NumVars);
2121   for (unsigned i = 0; i != NumVars; ++i)
2122     Vars.push_back(Reader->Reader.ReadSubExpr());
2123   C->setVarRefs(Vars);
2124   C->setAlignment(Reader->Reader.ReadSubExpr());
2125 }
2126
2127 void OMPClauseReader::VisitOMPCopyinClause(OMPCopyinClause *C) {
2128   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
2129   unsigned NumVars = C->varlist_size();
2130   SmallVector<Expr *, 16> Exprs;
2131   Exprs.reserve(NumVars);
2132   for (unsigned i = 0; i != NumVars; ++i)
2133     Exprs.push_back(Reader->Reader.ReadSubExpr());
2134   C->setVarRefs(Exprs);
2135   Exprs.clear();
2136   for (unsigned i = 0; i != NumVars; ++i)
2137     Exprs.push_back(Reader->Reader.ReadSubExpr());
2138   C->setSourceExprs(Exprs);
2139   Exprs.clear();
2140   for (unsigned i = 0; i != NumVars; ++i)
2141     Exprs.push_back(Reader->Reader.ReadSubExpr());
2142   C->setDestinationExprs(Exprs);
2143   Exprs.clear();
2144   for (unsigned i = 0; i != NumVars; ++i)
2145     Exprs.push_back(Reader->Reader.ReadSubExpr());
2146   C->setAssignmentOps(Exprs);
2147 }
2148
2149 void OMPClauseReader::VisitOMPCopyprivateClause(OMPCopyprivateClause *C) {
2150   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
2151   unsigned NumVars = C->varlist_size();
2152   SmallVector<Expr *, 16> Exprs;
2153   Exprs.reserve(NumVars);
2154   for (unsigned i = 0; i != NumVars; ++i)
2155     Exprs.push_back(Reader->Reader.ReadSubExpr());
2156   C->setVarRefs(Exprs);
2157   Exprs.clear();
2158   for (unsigned i = 0; i != NumVars; ++i)
2159     Exprs.push_back(Reader->Reader.ReadSubExpr());
2160   C->setSourceExprs(Exprs);
2161   Exprs.clear();
2162   for (unsigned i = 0; i != NumVars; ++i)
2163     Exprs.push_back(Reader->Reader.ReadSubExpr());
2164   C->setDestinationExprs(Exprs);
2165   Exprs.clear();
2166   for (unsigned i = 0; i != NumVars; ++i)
2167     Exprs.push_back(Reader->Reader.ReadSubExpr());
2168   C->setAssignmentOps(Exprs);
2169 }
2170
2171 void OMPClauseReader::VisitOMPFlushClause(OMPFlushClause *C) {
2172   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
2173   unsigned NumVars = C->varlist_size();
2174   SmallVector<Expr *, 16> Vars;
2175   Vars.reserve(NumVars);
2176   for (unsigned i = 0; i != NumVars; ++i)
2177     Vars.push_back(Reader->Reader.ReadSubExpr());
2178   C->setVarRefs(Vars);
2179 }
2180
2181 void OMPClauseReader::VisitOMPDependClause(OMPDependClause *C) {
2182   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
2183   C->setDependencyKind(static_cast<OpenMPDependClauseKind>(Record[Idx++]));
2184   C->setDependencyLoc(Reader->ReadSourceLocation(Record, Idx));
2185   C->setColonLoc(Reader->ReadSourceLocation(Record, Idx));
2186   unsigned NumVars = C->varlist_size();
2187   SmallVector<Expr *, 16> Vars;
2188   Vars.reserve(NumVars);
2189   for (unsigned i = 0; i != NumVars; ++i)
2190     Vars.push_back(Reader->Reader.ReadSubExpr());
2191   C->setVarRefs(Vars);
2192 }
2193
2194 void OMPClauseReader::VisitOMPDeviceClause(OMPDeviceClause *C) {
2195   C->setDevice(Reader->Reader.ReadSubExpr());
2196   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
2197 }
2198
2199 void OMPClauseReader::VisitOMPMapClause(OMPMapClause *C) {
2200   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
2201   C->setMapTypeModifier(
2202      static_cast<OpenMPMapClauseKind>(Record[Idx++]));
2203   C->setMapType(
2204      static_cast<OpenMPMapClauseKind>(Record[Idx++]));
2205   C->setMapLoc(Reader->ReadSourceLocation(Record, Idx));
2206   C->setColonLoc(Reader->ReadSourceLocation(Record, Idx));
2207   auto NumVars = C->varlist_size();
2208   SmallVector<Expr *, 16> Vars;
2209   Vars.reserve(NumVars);
2210   for (unsigned i = 0; i != NumVars; ++i) {
2211     Vars.push_back(Reader->Reader.ReadSubExpr());
2212   }
2213   C->setVarRefs(Vars);
2214 }
2215
2216 void OMPClauseReader::VisitOMPNumTeamsClause(OMPNumTeamsClause *C) {
2217   C->setNumTeams(Reader->Reader.ReadSubExpr());
2218   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
2219 }
2220
2221 void OMPClauseReader::VisitOMPThreadLimitClause(OMPThreadLimitClause *C) {
2222   C->setThreadLimit(Reader->Reader.ReadSubExpr());
2223   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
2224 }
2225
2226 void OMPClauseReader::VisitOMPPriorityClause(OMPPriorityClause *C) {
2227   C->setPriority(Reader->Reader.ReadSubExpr());
2228   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
2229 }
2230
2231 void OMPClauseReader::VisitOMPGrainsizeClause(OMPGrainsizeClause *C) {
2232   C->setGrainsize(Reader->Reader.ReadSubExpr());
2233   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
2234 }
2235
2236 void OMPClauseReader::VisitOMPNumTasksClause(OMPNumTasksClause *C) {
2237   C->setNumTasks(Reader->Reader.ReadSubExpr());
2238   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
2239 }
2240
2241 void OMPClauseReader::VisitOMPHintClause(OMPHintClause *C) {
2242   C->setHint(Reader->Reader.ReadSubExpr());
2243   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
2244 }
2245
2246 //===----------------------------------------------------------------------===//
2247 // OpenMP Directives.
2248 //===----------------------------------------------------------------------===//
2249 void ASTStmtReader::VisitOMPExecutableDirective(OMPExecutableDirective *E) {
2250   E->setLocStart(ReadSourceLocation(Record, Idx));
2251   E->setLocEnd(ReadSourceLocation(Record, Idx));
2252   OMPClauseReader ClauseReader(this, Reader.getContext(), Record, Idx);
2253   SmallVector<OMPClause *, 5> Clauses;
2254   for (unsigned i = 0; i < E->getNumClauses(); ++i)
2255     Clauses.push_back(ClauseReader.readClause());
2256   E->setClauses(Clauses);
2257   if (E->hasAssociatedStmt())
2258     E->setAssociatedStmt(Reader.ReadSubStmt());
2259 }
2260
2261 void ASTStmtReader::VisitOMPLoopDirective(OMPLoopDirective *D) {
2262   VisitStmt(D);
2263   // Two fields (NumClauses and CollapsedNum) were read in ReadStmtFromStream.
2264   Idx += 2;
2265   VisitOMPExecutableDirective(D);
2266   D->setIterationVariable(Reader.ReadSubExpr());
2267   D->setLastIteration(Reader.ReadSubExpr());
2268   D->setCalcLastIteration(Reader.ReadSubExpr());
2269   D->setPreCond(Reader.ReadSubExpr());
2270   D->setCond(Reader.ReadSubExpr());
2271   D->setInit(Reader.ReadSubExpr());
2272   D->setInc(Reader.ReadSubExpr());
2273   if (isOpenMPWorksharingDirective(D->getDirectiveKind())) {
2274     D->setIsLastIterVariable(Reader.ReadSubExpr());
2275     D->setLowerBoundVariable(Reader.ReadSubExpr());
2276     D->setUpperBoundVariable(Reader.ReadSubExpr());
2277     D->setStrideVariable(Reader.ReadSubExpr());
2278     D->setEnsureUpperBound(Reader.ReadSubExpr());
2279     D->setNextLowerBound(Reader.ReadSubExpr());
2280     D->setNextUpperBound(Reader.ReadSubExpr());
2281   }
2282   SmallVector<Expr *, 4> Sub;
2283   unsigned CollapsedNum = D->getCollapsedNumber();
2284   Sub.reserve(CollapsedNum);
2285   for (unsigned i = 0; i < CollapsedNum; ++i)
2286     Sub.push_back(Reader.ReadSubExpr());
2287   D->setCounters(Sub);
2288   Sub.clear();
2289   for (unsigned i = 0; i < CollapsedNum; ++i)
2290     Sub.push_back(Reader.ReadSubExpr());
2291   D->setPrivateCounters(Sub);
2292   Sub.clear();
2293   for (unsigned i = 0; i < CollapsedNum; ++i)
2294     Sub.push_back(Reader.ReadSubExpr());
2295   D->setInits(Sub);
2296   Sub.clear();
2297   for (unsigned i = 0; i < CollapsedNum; ++i)
2298     Sub.push_back(Reader.ReadSubExpr());
2299   D->setUpdates(Sub);
2300   Sub.clear();
2301   for (unsigned i = 0; i < CollapsedNum; ++i)
2302     Sub.push_back(Reader.ReadSubExpr());
2303   D->setFinals(Sub);
2304 }
2305
2306 void ASTStmtReader::VisitOMPParallelDirective(OMPParallelDirective *D) {
2307   VisitStmt(D);
2308   // The NumClauses field was read in ReadStmtFromStream.
2309   ++Idx;
2310   VisitOMPExecutableDirective(D);
2311   D->setHasCancel(Record[Idx++]);
2312 }
2313
2314 void ASTStmtReader::VisitOMPSimdDirective(OMPSimdDirective *D) {
2315   VisitOMPLoopDirective(D);
2316 }
2317
2318 void ASTStmtReader::VisitOMPForDirective(OMPForDirective *D) {
2319   VisitOMPLoopDirective(D);
2320   D->setHasCancel(Record[Idx++]);
2321 }
2322
2323 void ASTStmtReader::VisitOMPForSimdDirective(OMPForSimdDirective *D) {
2324   VisitOMPLoopDirective(D);
2325 }
2326
2327 void ASTStmtReader::VisitOMPSectionsDirective(OMPSectionsDirective *D) {
2328   VisitStmt(D);
2329   // The NumClauses field was read in ReadStmtFromStream.
2330   ++Idx;
2331   VisitOMPExecutableDirective(D);
2332   D->setHasCancel(Record[Idx++]);
2333 }
2334
2335 void ASTStmtReader::VisitOMPSectionDirective(OMPSectionDirective *D) {
2336   VisitStmt(D);
2337   VisitOMPExecutableDirective(D);
2338   D->setHasCancel(Record[Idx++]);
2339 }
2340
2341 void ASTStmtReader::VisitOMPSingleDirective(OMPSingleDirective *D) {
2342   VisitStmt(D);
2343   // The NumClauses field was read in ReadStmtFromStream.
2344   ++Idx;
2345   VisitOMPExecutableDirective(D);
2346 }
2347
2348 void ASTStmtReader::VisitOMPMasterDirective(OMPMasterDirective *D) {
2349   VisitStmt(D);
2350   VisitOMPExecutableDirective(D);
2351 }
2352
2353 void ASTStmtReader::VisitOMPCriticalDirective(OMPCriticalDirective *D) {
2354   VisitStmt(D);
2355   // The NumClauses field was read in ReadStmtFromStream.
2356   ++Idx;
2357   VisitOMPExecutableDirective(D);
2358   ReadDeclarationNameInfo(D->DirName, Record, Idx);
2359 }
2360
2361 void ASTStmtReader::VisitOMPParallelForDirective(OMPParallelForDirective *D) {
2362   VisitOMPLoopDirective(D);
2363   D->setHasCancel(Record[Idx++]);
2364 }
2365
2366 void ASTStmtReader::VisitOMPParallelForSimdDirective(
2367     OMPParallelForSimdDirective *D) {
2368   VisitOMPLoopDirective(D);
2369 }
2370
2371 void ASTStmtReader::VisitOMPParallelSectionsDirective(
2372     OMPParallelSectionsDirective *D) {
2373   VisitStmt(D);
2374   // The NumClauses field was read in ReadStmtFromStream.
2375   ++Idx;
2376   VisitOMPExecutableDirective(D);
2377   D->setHasCancel(Record[Idx++]);
2378 }
2379
2380 void ASTStmtReader::VisitOMPTaskDirective(OMPTaskDirective *D) {
2381   VisitStmt(D);
2382   // The NumClauses field was read in ReadStmtFromStream.
2383   ++Idx;
2384   VisitOMPExecutableDirective(D);
2385   D->setHasCancel(Record[Idx++]);
2386 }
2387
2388 void ASTStmtReader::VisitOMPTaskyieldDirective(OMPTaskyieldDirective *D) {
2389   VisitStmt(D);
2390   VisitOMPExecutableDirective(D);
2391 }
2392
2393 void ASTStmtReader::VisitOMPBarrierDirective(OMPBarrierDirective *D) {
2394   VisitStmt(D);
2395   VisitOMPExecutableDirective(D);
2396 }
2397
2398 void ASTStmtReader::VisitOMPTaskwaitDirective(OMPTaskwaitDirective *D) {
2399   VisitStmt(D);
2400   VisitOMPExecutableDirective(D);
2401 }
2402
2403 void ASTStmtReader::VisitOMPTaskgroupDirective(OMPTaskgroupDirective *D) {
2404   VisitStmt(D);
2405   VisitOMPExecutableDirective(D);
2406 }
2407
2408 void ASTStmtReader::VisitOMPFlushDirective(OMPFlushDirective *D) {
2409   VisitStmt(D);
2410   // The NumClauses field was read in ReadStmtFromStream.
2411   ++Idx;
2412   VisitOMPExecutableDirective(D);
2413 }
2414
2415 void ASTStmtReader::VisitOMPOrderedDirective(OMPOrderedDirective *D) {
2416   VisitStmt(D);
2417   // The NumClauses field was read in ReadStmtFromStream.
2418   ++Idx;
2419   VisitOMPExecutableDirective(D);
2420 }
2421
2422 void ASTStmtReader::VisitOMPAtomicDirective(OMPAtomicDirective *D) {
2423   VisitStmt(D);
2424   // The NumClauses field was read in ReadStmtFromStream.
2425   ++Idx;
2426   VisitOMPExecutableDirective(D);
2427   D->setX(Reader.ReadSubExpr());
2428   D->setV(Reader.ReadSubExpr());
2429   D->setExpr(Reader.ReadSubExpr());
2430   D->setUpdateExpr(Reader.ReadSubExpr());
2431   D->IsXLHSInRHSPart = Record[Idx++] != 0;
2432   D->IsPostfixUpdate = Record[Idx++] != 0;
2433 }
2434
2435 void ASTStmtReader::VisitOMPTargetDirective(OMPTargetDirective *D) {
2436   VisitStmt(D);
2437   // The NumClauses field was read in ReadStmtFromStream.
2438   ++Idx;
2439   VisitOMPExecutableDirective(D);
2440 }
2441
2442 void ASTStmtReader::VisitOMPTargetDataDirective(OMPTargetDataDirective *D) {
2443   VisitStmt(D);
2444   ++Idx;
2445   VisitOMPExecutableDirective(D);
2446 }
2447
2448 void ASTStmtReader::VisitOMPTeamsDirective(OMPTeamsDirective *D) {
2449   VisitStmt(D);
2450   // The NumClauses field was read in ReadStmtFromStream.
2451   ++Idx;
2452   VisitOMPExecutableDirective(D);
2453 }
2454
2455 void ASTStmtReader::VisitOMPCancellationPointDirective(
2456     OMPCancellationPointDirective *D) {
2457   VisitStmt(D);
2458   VisitOMPExecutableDirective(D);
2459   D->setCancelRegion(static_cast<OpenMPDirectiveKind>(Record[Idx++]));
2460 }
2461
2462 void ASTStmtReader::VisitOMPCancelDirective(OMPCancelDirective *D) {
2463   VisitStmt(D);
2464   // The NumClauses field was read in ReadStmtFromStream.
2465   ++Idx;
2466   VisitOMPExecutableDirective(D);
2467   D->setCancelRegion(static_cast<OpenMPDirectiveKind>(Record[Idx++]));
2468 }
2469
2470 void ASTStmtReader::VisitOMPTaskLoopDirective(OMPTaskLoopDirective *D) {
2471   VisitOMPLoopDirective(D);
2472 }
2473
2474 void ASTStmtReader::VisitOMPTaskLoopSimdDirective(OMPTaskLoopSimdDirective *D) {
2475   VisitOMPLoopDirective(D);
2476 }
2477
2478 void ASTStmtReader::VisitOMPDistributeDirective(OMPDistributeDirective *D) {
2479   VisitOMPLoopDirective(D);
2480 }
2481
2482 //===----------------------------------------------------------------------===//
2483 // ASTReader Implementation
2484 //===----------------------------------------------------------------------===//
2485
2486 Stmt *ASTReader::ReadStmt(ModuleFile &F) {
2487   switch (ReadingKind) {
2488   case Read_None:
2489     llvm_unreachable("should not call this when not reading anything");
2490   case Read_Decl:
2491   case Read_Type:
2492     return ReadStmtFromStream(F);
2493   case Read_Stmt:
2494     return ReadSubStmt();
2495   }
2496
2497   llvm_unreachable("ReadingKind not set ?");
2498 }
2499
2500 Expr *ASTReader::ReadExpr(ModuleFile &F) {
2501   return cast_or_null<Expr>(ReadStmt(F));
2502 }
2503
2504 Expr *ASTReader::ReadSubExpr() {
2505   return cast_or_null<Expr>(ReadSubStmt());
2506 }
2507
2508 // Within the bitstream, expressions are stored in Reverse Polish
2509 // Notation, with each of the subexpressions preceding the
2510 // expression they are stored in. Subexpressions are stored from last to first.
2511 // To evaluate expressions, we continue reading expressions and placing them on
2512 // the stack, with expressions having operands removing those operands from the
2513 // stack. Evaluation terminates when we see a STMT_STOP record, and
2514 // the single remaining expression on the stack is our result.
2515 Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) {
2516
2517   ReadingKindTracker ReadingKind(Read_Stmt, *this);
2518   llvm::BitstreamCursor &Cursor = F.DeclsCursor;
2519
2520   // Map of offset to previously deserialized stmt. The offset points
2521   /// just after the stmt record.
2522   llvm::DenseMap<uint64_t, Stmt *> StmtEntries;
2523
2524 #ifndef NDEBUG
2525   unsigned PrevNumStmts = StmtStack.size();
2526 #endif
2527
2528   RecordData Record;
2529   unsigned Idx;
2530   ASTStmtReader Reader(*this, F, Cursor, Record, Idx);
2531   Stmt::EmptyShell Empty;
2532
2533   while (true) {
2534     llvm::BitstreamEntry Entry = Cursor.advanceSkippingSubblocks();
2535
2536     switch (Entry.Kind) {
2537     case llvm::BitstreamEntry::SubBlock: // Handled for us already.
2538     case llvm::BitstreamEntry::Error:
2539       Error("malformed block record in AST file");
2540       return nullptr;
2541     case llvm::BitstreamEntry::EndBlock:
2542       goto Done;
2543     case llvm::BitstreamEntry::Record:
2544       // The interesting case.
2545       break;
2546     }
2547
2548     Stmt *S = nullptr;
2549     Idx = 0;
2550     Record.clear();
2551     bool Finished = false;
2552     bool IsStmtReference = false;
2553     switch ((StmtCode)Cursor.readRecord(Entry.ID, Record)) {
2554     case STMT_STOP:
2555       Finished = true;
2556       break;
2557
2558     case STMT_REF_PTR:
2559       IsStmtReference = true;
2560       assert(StmtEntries.find(Record[0]) != StmtEntries.end() &&
2561              "No stmt was recorded for this offset reference!");
2562       S = StmtEntries[Record[Idx++]];
2563       break;
2564
2565     case STMT_NULL_PTR:
2566       S = nullptr;
2567       break;
2568
2569     case STMT_NULL:
2570       S = new (Context) NullStmt(Empty);
2571       break;
2572
2573     case STMT_COMPOUND:
2574       S = new (Context) CompoundStmt(Empty);
2575       break;
2576
2577     case STMT_CASE:
2578       S = new (Context) CaseStmt(Empty);
2579       break;
2580
2581     case STMT_DEFAULT:
2582       S = new (Context) DefaultStmt(Empty);
2583       break;
2584
2585     case STMT_LABEL:
2586       S = new (Context) LabelStmt(Empty);
2587       break;
2588
2589     case STMT_ATTRIBUTED:
2590       S = AttributedStmt::CreateEmpty(
2591         Context,
2592         /*NumAttrs*/Record[ASTStmtReader::NumStmtFields]);
2593       break;
2594
2595     case STMT_IF:
2596       S = new (Context) IfStmt(Empty);
2597       break;
2598
2599     case STMT_SWITCH:
2600       S = new (Context) SwitchStmt(Empty);
2601       break;
2602
2603     case STMT_WHILE:
2604       S = new (Context) WhileStmt(Empty);
2605       break;
2606
2607     case STMT_DO:
2608       S = new (Context) DoStmt(Empty);
2609       break;
2610
2611     case STMT_FOR:
2612       S = new (Context) ForStmt(Empty);
2613       break;
2614
2615     case STMT_GOTO:
2616       S = new (Context) GotoStmt(Empty);
2617       break;
2618
2619     case STMT_INDIRECT_GOTO:
2620       S = new (Context) IndirectGotoStmt(Empty);
2621       break;
2622
2623     case STMT_CONTINUE:
2624       S = new (Context) ContinueStmt(Empty);
2625       break;
2626
2627     case STMT_BREAK:
2628       S = new (Context) BreakStmt(Empty);
2629       break;
2630
2631     case STMT_RETURN:
2632       S = new (Context) ReturnStmt(Empty);
2633       break;
2634
2635     case STMT_DECL:
2636       S = new (Context) DeclStmt(Empty);
2637       break;
2638
2639     case STMT_GCCASM:
2640       S = new (Context) GCCAsmStmt(Empty);
2641       break;
2642
2643     case STMT_MSASM:
2644       S = new (Context) MSAsmStmt(Empty);
2645       break;
2646
2647     case STMT_CAPTURED:
2648       S = CapturedStmt::CreateDeserialized(Context,
2649                                            Record[ASTStmtReader::NumStmtFields]);
2650       break;
2651
2652     case EXPR_PREDEFINED:
2653       S = new (Context) PredefinedExpr(Empty);
2654       break;
2655
2656     case EXPR_DECL_REF:
2657       S = DeclRefExpr::CreateEmpty(
2658         Context,
2659         /*HasQualifier=*/Record[ASTStmtReader::NumExprFields],
2660         /*HasFoundDecl=*/Record[ASTStmtReader::NumExprFields + 1],
2661         /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields + 2],
2662         /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields + 2] ?
2663           Record[ASTStmtReader::NumExprFields + 5] : 0);
2664       break;
2665
2666     case EXPR_INTEGER_LITERAL:
2667       S = IntegerLiteral::Create(Context, Empty);
2668       break;
2669
2670     case EXPR_FLOATING_LITERAL:
2671       S = FloatingLiteral::Create(Context, Empty);
2672       break;
2673
2674     case EXPR_IMAGINARY_LITERAL:
2675       S = new (Context) ImaginaryLiteral(Empty);
2676       break;
2677
2678     case EXPR_STRING_LITERAL:
2679       S = StringLiteral::CreateEmpty(Context,
2680                                      Record[ASTStmtReader::NumExprFields + 1]);
2681       break;
2682
2683     case EXPR_CHARACTER_LITERAL:
2684       S = new (Context) CharacterLiteral(Empty);
2685       break;
2686
2687     case EXPR_PAREN:
2688       S = new (Context) ParenExpr(Empty);
2689       break;
2690
2691     case EXPR_PAREN_LIST:
2692       S = new (Context) ParenListExpr(Empty);
2693       break;
2694
2695     case EXPR_UNARY_OPERATOR:
2696       S = new (Context) UnaryOperator(Empty);
2697       break;
2698
2699     case EXPR_OFFSETOF:
2700       S = OffsetOfExpr::CreateEmpty(Context,
2701                                     Record[ASTStmtReader::NumExprFields],
2702                                     Record[ASTStmtReader::NumExprFields + 1]);
2703       break;
2704
2705     case EXPR_SIZEOF_ALIGN_OF:
2706       S = new (Context) UnaryExprOrTypeTraitExpr(Empty);
2707       break;
2708
2709     case EXPR_ARRAY_SUBSCRIPT:
2710       S = new (Context) ArraySubscriptExpr(Empty);
2711       break;
2712
2713     case EXPR_OMP_ARRAY_SECTION:
2714       S = new (Context) OMPArraySectionExpr(Empty);
2715       break;
2716
2717     case EXPR_CALL:
2718       S = new (Context) CallExpr(Context, Stmt::CallExprClass, Empty);
2719       break;
2720
2721     case EXPR_MEMBER: {
2722       // We load everything here and fully initialize it at creation.
2723       // That way we can use MemberExpr::Create and don't have to duplicate its
2724       // logic with a MemberExpr::CreateEmpty.
2725
2726       assert(Idx == 0);
2727       NestedNameSpecifierLoc QualifierLoc;
2728       if (Record[Idx++]) { // HasQualifier.
2729         QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, Idx);
2730       }
2731
2732       SourceLocation TemplateKWLoc;
2733       TemplateArgumentListInfo ArgInfo;
2734       bool HasTemplateKWAndArgsInfo = Record[Idx++];
2735       if (HasTemplateKWAndArgsInfo) {
2736         TemplateKWLoc = ReadSourceLocation(F, Record, Idx);
2737         unsigned NumTemplateArgs = Record[Idx++];
2738         ArgInfo.setLAngleLoc(ReadSourceLocation(F, Record, Idx));
2739         ArgInfo.setRAngleLoc(ReadSourceLocation(F, Record, Idx));
2740         for (unsigned i = 0; i != NumTemplateArgs; ++i)
2741           ArgInfo.addArgument(ReadTemplateArgumentLoc(F, Record, Idx));
2742       }
2743
2744       bool HadMultipleCandidates = Record[Idx++];
2745
2746       NamedDecl *FoundD = ReadDeclAs<NamedDecl>(F, Record, Idx);
2747       AccessSpecifier AS = (AccessSpecifier)Record[Idx++];
2748       DeclAccessPair FoundDecl = DeclAccessPair::make(FoundD, AS);
2749
2750       QualType T = readType(F, Record, Idx);
2751       ExprValueKind VK = static_cast<ExprValueKind>(Record[Idx++]);
2752       ExprObjectKind OK = static_cast<ExprObjectKind>(Record[Idx++]);
2753       Expr *Base = ReadSubExpr();
2754       ValueDecl *MemberD = ReadDeclAs<ValueDecl>(F, Record, Idx);
2755       SourceLocation MemberLoc = ReadSourceLocation(F, Record, Idx);
2756       DeclarationNameInfo MemberNameInfo(MemberD->getDeclName(), MemberLoc);
2757       bool IsArrow = Record[Idx++];
2758       SourceLocation OperatorLoc = ReadSourceLocation(F, Record, Idx);
2759
2760       S = MemberExpr::Create(Context, Base, IsArrow, OperatorLoc, QualifierLoc,
2761                              TemplateKWLoc, MemberD, FoundDecl, MemberNameInfo,
2762                              HasTemplateKWAndArgsInfo ? &ArgInfo : nullptr, T,
2763                              VK, OK);
2764       ReadDeclarationNameLoc(F, cast<MemberExpr>(S)->MemberDNLoc,
2765                              MemberD->getDeclName(), Record, Idx);
2766       if (HadMultipleCandidates)
2767         cast<MemberExpr>(S)->setHadMultipleCandidates(true);
2768       break;
2769     }
2770
2771     case EXPR_BINARY_OPERATOR:
2772       S = new (Context) BinaryOperator(Empty);
2773       break;
2774
2775     case EXPR_COMPOUND_ASSIGN_OPERATOR:
2776       S = new (Context) CompoundAssignOperator(Empty);
2777       break;
2778
2779     case EXPR_CONDITIONAL_OPERATOR:
2780       S = new (Context) ConditionalOperator(Empty);
2781       break;
2782
2783     case EXPR_BINARY_CONDITIONAL_OPERATOR:
2784       S = new (Context) BinaryConditionalOperator(Empty);
2785       break;
2786
2787     case EXPR_IMPLICIT_CAST:
2788       S = ImplicitCastExpr::CreateEmpty(Context,
2789                        /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
2790       break;
2791
2792     case EXPR_CSTYLE_CAST:
2793       S = CStyleCastExpr::CreateEmpty(Context,
2794                        /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
2795       break;
2796
2797     case EXPR_COMPOUND_LITERAL:
2798       S = new (Context) CompoundLiteralExpr(Empty);
2799       break;
2800
2801     case EXPR_EXT_VECTOR_ELEMENT:
2802       S = new (Context) ExtVectorElementExpr(Empty);
2803       break;
2804
2805     case EXPR_INIT_LIST:
2806       S = new (Context) InitListExpr(Empty);
2807       break;
2808
2809     case EXPR_DESIGNATED_INIT:
2810       S = DesignatedInitExpr::CreateEmpty(Context,
2811                                      Record[ASTStmtReader::NumExprFields] - 1);
2812
2813       break;
2814
2815     case EXPR_DESIGNATED_INIT_UPDATE:
2816       S = new (Context) DesignatedInitUpdateExpr(Empty);
2817       break;
2818
2819     case EXPR_IMPLICIT_VALUE_INIT:
2820       S = new (Context) ImplicitValueInitExpr(Empty);
2821       break;
2822
2823     case EXPR_NO_INIT:
2824       S = new (Context) NoInitExpr(Empty);
2825       break;
2826
2827     case EXPR_VA_ARG:
2828       S = new (Context) VAArgExpr(Empty);
2829       break;
2830
2831     case EXPR_ADDR_LABEL:
2832       S = new (Context) AddrLabelExpr(Empty);
2833       break;
2834
2835     case EXPR_STMT:
2836       S = new (Context) StmtExpr(Empty);
2837       break;
2838
2839     case EXPR_CHOOSE:
2840       S = new (Context) ChooseExpr(Empty);
2841       break;
2842
2843     case EXPR_GNU_NULL:
2844       S = new (Context) GNUNullExpr(Empty);
2845       break;
2846
2847     case EXPR_SHUFFLE_VECTOR:
2848       S = new (Context) ShuffleVectorExpr(Empty);
2849       break;
2850
2851     case EXPR_CONVERT_VECTOR:
2852       S = new (Context) ConvertVectorExpr(Empty);
2853       break;
2854
2855     case EXPR_BLOCK:
2856       S = new (Context) BlockExpr(Empty);
2857       break;
2858
2859     case EXPR_GENERIC_SELECTION:
2860       S = new (Context) GenericSelectionExpr(Empty);
2861       break;
2862
2863     case EXPR_OBJC_STRING_LITERAL:
2864       S = new (Context) ObjCStringLiteral(Empty);
2865       break;
2866     case EXPR_OBJC_BOXED_EXPRESSION:
2867       S = new (Context) ObjCBoxedExpr(Empty);
2868       break;
2869     case EXPR_OBJC_ARRAY_LITERAL:
2870       S = ObjCArrayLiteral::CreateEmpty(Context,
2871                                         Record[ASTStmtReader::NumExprFields]);
2872       break;
2873     case EXPR_OBJC_DICTIONARY_LITERAL:
2874       S = ObjCDictionaryLiteral::CreateEmpty(Context,
2875             Record[ASTStmtReader::NumExprFields],
2876             Record[ASTStmtReader::NumExprFields + 1]);
2877       break;
2878     case EXPR_OBJC_ENCODE:
2879       S = new (Context) ObjCEncodeExpr(Empty);
2880       break;
2881     case EXPR_OBJC_SELECTOR_EXPR:
2882       S = new (Context) ObjCSelectorExpr(Empty);
2883       break;
2884     case EXPR_OBJC_PROTOCOL_EXPR:
2885       S = new (Context) ObjCProtocolExpr(Empty);
2886       break;
2887     case EXPR_OBJC_IVAR_REF_EXPR:
2888       S = new (Context) ObjCIvarRefExpr(Empty);
2889       break;
2890     case EXPR_OBJC_PROPERTY_REF_EXPR:
2891       S = new (Context) ObjCPropertyRefExpr(Empty);
2892       break;
2893     case EXPR_OBJC_SUBSCRIPT_REF_EXPR:
2894       S = new (Context) ObjCSubscriptRefExpr(Empty);
2895       break;
2896     case EXPR_OBJC_KVC_REF_EXPR:
2897       llvm_unreachable("mismatching AST file");
2898     case EXPR_OBJC_MESSAGE_EXPR:
2899       S = ObjCMessageExpr::CreateEmpty(Context,
2900                                      Record[ASTStmtReader::NumExprFields],
2901                                      Record[ASTStmtReader::NumExprFields + 1]);
2902       break;
2903     case EXPR_OBJC_ISA:
2904       S = new (Context) ObjCIsaExpr(Empty);
2905       break;
2906     case EXPR_OBJC_INDIRECT_COPY_RESTORE:
2907       S = new (Context) ObjCIndirectCopyRestoreExpr(Empty);
2908       break;
2909     case EXPR_OBJC_BRIDGED_CAST:
2910       S = new (Context) ObjCBridgedCastExpr(Empty);
2911       break;
2912     case STMT_OBJC_FOR_COLLECTION:
2913       S = new (Context) ObjCForCollectionStmt(Empty);
2914       break;
2915     case STMT_OBJC_CATCH:
2916       S = new (Context) ObjCAtCatchStmt(Empty);
2917       break;
2918     case STMT_OBJC_FINALLY:
2919       S = new (Context) ObjCAtFinallyStmt(Empty);
2920       break;
2921     case STMT_OBJC_AT_TRY:
2922       S = ObjCAtTryStmt::CreateEmpty(Context,
2923                                      Record[ASTStmtReader::NumStmtFields],
2924                                      Record[ASTStmtReader::NumStmtFields + 1]);
2925       break;
2926     case STMT_OBJC_AT_SYNCHRONIZED:
2927       S = new (Context) ObjCAtSynchronizedStmt(Empty);
2928       break;
2929     case STMT_OBJC_AT_THROW:
2930       S = new (Context) ObjCAtThrowStmt(Empty);
2931       break;
2932     case STMT_OBJC_AUTORELEASE_POOL:
2933       S = new (Context) ObjCAutoreleasePoolStmt(Empty);
2934       break;
2935     case EXPR_OBJC_BOOL_LITERAL:
2936       S = new (Context) ObjCBoolLiteralExpr(Empty);
2937       break;
2938     case STMT_SEH_LEAVE:
2939       S = new (Context) SEHLeaveStmt(Empty);
2940       break;
2941     case STMT_SEH_EXCEPT:
2942       S = new (Context) SEHExceptStmt(Empty);
2943       break;
2944     case STMT_SEH_FINALLY:
2945       S = new (Context) SEHFinallyStmt(Empty);
2946       break;
2947     case STMT_SEH_TRY:
2948       S = new (Context) SEHTryStmt(Empty);
2949       break;
2950     case STMT_CXX_CATCH:
2951       S = new (Context) CXXCatchStmt(Empty);
2952       break;
2953
2954     case STMT_CXX_TRY:
2955       S = CXXTryStmt::Create(Context, Empty,
2956              /*NumHandlers=*/Record[ASTStmtReader::NumStmtFields]);
2957       break;
2958
2959     case STMT_CXX_FOR_RANGE:
2960       S = new (Context) CXXForRangeStmt(Empty);
2961       break;
2962
2963     case STMT_MS_DEPENDENT_EXISTS:
2964       S = new (Context) MSDependentExistsStmt(SourceLocation(), true,
2965                                               NestedNameSpecifierLoc(),
2966                                               DeclarationNameInfo(),
2967                                               nullptr);
2968       break;
2969
2970     case STMT_OMP_PARALLEL_DIRECTIVE:
2971       S =
2972         OMPParallelDirective::CreateEmpty(Context,
2973                                           Record[ASTStmtReader::NumStmtFields],
2974                                           Empty);
2975       break;
2976
2977     case STMT_OMP_SIMD_DIRECTIVE: {
2978       unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
2979       unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
2980       S = OMPSimdDirective::CreateEmpty(Context, NumClauses,
2981                                         CollapsedNum, Empty);
2982       break;
2983     }
2984
2985     case STMT_OMP_FOR_DIRECTIVE: {
2986       unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
2987       unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
2988       S = OMPForDirective::CreateEmpty(Context, NumClauses, CollapsedNum,
2989                                        Empty);
2990       break;
2991     }
2992
2993     case STMT_OMP_FOR_SIMD_DIRECTIVE: {
2994       unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
2995       unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
2996       S = OMPForSimdDirective::CreateEmpty(Context, NumClauses, CollapsedNum,
2997                                            Empty);
2998       break;
2999     }
3000
3001     case STMT_OMP_SECTIONS_DIRECTIVE:
3002       S = OMPSectionsDirective::CreateEmpty(
3003           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3004       break;
3005
3006     case STMT_OMP_SECTION_DIRECTIVE:
3007       S = OMPSectionDirective::CreateEmpty(Context, Empty);
3008       break;
3009
3010     case STMT_OMP_SINGLE_DIRECTIVE:
3011       S = OMPSingleDirective::CreateEmpty(
3012           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3013       break;
3014
3015     case STMT_OMP_MASTER_DIRECTIVE:
3016       S = OMPMasterDirective::CreateEmpty(Context, Empty);
3017       break;
3018
3019     case STMT_OMP_CRITICAL_DIRECTIVE:
3020       S = OMPCriticalDirective::CreateEmpty(
3021           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3022       break;
3023
3024     case STMT_OMP_PARALLEL_FOR_DIRECTIVE: {
3025       unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3026       unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3027       S = OMPParallelForDirective::CreateEmpty(Context, NumClauses,
3028                                                CollapsedNum, Empty);
3029       break;
3030     }
3031
3032     case STMT_OMP_PARALLEL_FOR_SIMD_DIRECTIVE: {
3033       unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3034       unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3035       S = OMPParallelForSimdDirective::CreateEmpty(Context, NumClauses,
3036                                                    CollapsedNum, Empty);
3037       break;
3038     }
3039
3040     case STMT_OMP_PARALLEL_SECTIONS_DIRECTIVE:
3041       S = OMPParallelSectionsDirective::CreateEmpty(
3042           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3043       break;
3044
3045     case STMT_OMP_TASK_DIRECTIVE:
3046       S = OMPTaskDirective::CreateEmpty(
3047           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3048       break;
3049
3050     case STMT_OMP_TASKYIELD_DIRECTIVE:
3051       S = OMPTaskyieldDirective::CreateEmpty(Context, Empty);
3052       break;
3053
3054     case STMT_OMP_BARRIER_DIRECTIVE:
3055       S = OMPBarrierDirective::CreateEmpty(Context, Empty);
3056       break;
3057
3058     case STMT_OMP_TASKWAIT_DIRECTIVE:
3059       S = OMPTaskwaitDirective::CreateEmpty(Context, Empty);
3060       break;
3061
3062     case STMT_OMP_TASKGROUP_DIRECTIVE:
3063       S = OMPTaskgroupDirective::CreateEmpty(Context, Empty);
3064       break;
3065
3066     case STMT_OMP_FLUSH_DIRECTIVE:
3067       S = OMPFlushDirective::CreateEmpty(
3068           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3069       break;
3070
3071     case STMT_OMP_ORDERED_DIRECTIVE:
3072       S = OMPOrderedDirective::CreateEmpty(
3073           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3074       break;
3075
3076     case STMT_OMP_ATOMIC_DIRECTIVE:
3077       S = OMPAtomicDirective::CreateEmpty(
3078           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3079       break;
3080
3081     case STMT_OMP_TARGET_DIRECTIVE:
3082       S = OMPTargetDirective::CreateEmpty(
3083           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3084       break;
3085
3086     case STMT_OMP_TARGET_DATA_DIRECTIVE:
3087       S = OMPTargetDataDirective::CreateEmpty(
3088           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3089       break;
3090
3091     case STMT_OMP_TEAMS_DIRECTIVE:
3092       S = OMPTeamsDirective::CreateEmpty(
3093           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3094       break;
3095
3096     case STMT_OMP_CANCELLATION_POINT_DIRECTIVE:
3097       S = OMPCancellationPointDirective::CreateEmpty(Context, Empty);
3098       break;
3099
3100     case STMT_OMP_CANCEL_DIRECTIVE:
3101       S = OMPCancelDirective::CreateEmpty(
3102           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3103       break;
3104
3105     case STMT_OMP_TASKLOOP_DIRECTIVE: {
3106       unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3107       unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3108       S = OMPTaskLoopDirective::CreateEmpty(Context, NumClauses, CollapsedNum,
3109                                             Empty);
3110       break;
3111     }
3112
3113     case STMT_OMP_TASKLOOP_SIMD_DIRECTIVE: {
3114       unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3115       unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3116       S = OMPTaskLoopSimdDirective::CreateEmpty(Context, NumClauses,
3117                                                 CollapsedNum, Empty);
3118       break;
3119     }
3120
3121     case STMT_OMP_DISTRIBUTE_DIRECTIVE: {
3122       unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3123       unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3124       S = OMPDistributeDirective::CreateEmpty(Context, NumClauses, CollapsedNum,
3125                                               Empty);
3126       break;
3127     }
3128
3129     case EXPR_CXX_OPERATOR_CALL:
3130       S = new (Context) CXXOperatorCallExpr(Context, Empty);
3131       break;
3132
3133     case EXPR_CXX_MEMBER_CALL:
3134       S = new (Context) CXXMemberCallExpr(Context, Empty);
3135       break;
3136
3137     case EXPR_CXX_CONSTRUCT:
3138       S = new (Context) CXXConstructExpr(Empty);
3139       break;
3140
3141     case EXPR_CXX_TEMPORARY_OBJECT:
3142       S = new (Context) CXXTemporaryObjectExpr(Empty);
3143       break;
3144
3145     case EXPR_CXX_STATIC_CAST:
3146       S = CXXStaticCastExpr::CreateEmpty(Context,
3147                        /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
3148       break;
3149
3150     case EXPR_CXX_DYNAMIC_CAST:
3151       S = CXXDynamicCastExpr::CreateEmpty(Context,
3152                        /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
3153       break;
3154
3155     case EXPR_CXX_REINTERPRET_CAST:
3156       S = CXXReinterpretCastExpr::CreateEmpty(Context,
3157                        /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
3158       break;
3159
3160     case EXPR_CXX_CONST_CAST:
3161       S = CXXConstCastExpr::CreateEmpty(Context);
3162       break;
3163
3164     case EXPR_CXX_FUNCTIONAL_CAST:
3165       S = CXXFunctionalCastExpr::CreateEmpty(Context,
3166                        /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
3167       break;
3168
3169     case EXPR_USER_DEFINED_LITERAL:
3170       S = new (Context) UserDefinedLiteral(Context, Empty);
3171       break;
3172
3173     case EXPR_CXX_STD_INITIALIZER_LIST:
3174       S = new (Context) CXXStdInitializerListExpr(Empty);
3175       break;
3176
3177     case EXPR_CXX_BOOL_LITERAL:
3178       S = new (Context) CXXBoolLiteralExpr(Empty);
3179       break;
3180
3181     case EXPR_CXX_NULL_PTR_LITERAL:
3182       S = new (Context) CXXNullPtrLiteralExpr(Empty);
3183       break;
3184     case EXPR_CXX_TYPEID_EXPR:
3185       S = new (Context) CXXTypeidExpr(Empty, true);
3186       break;
3187     case EXPR_CXX_TYPEID_TYPE:
3188       S = new (Context) CXXTypeidExpr(Empty, false);
3189       break;
3190     case EXPR_CXX_UUIDOF_EXPR:
3191       S = new (Context) CXXUuidofExpr(Empty, true);
3192       break;
3193     case EXPR_CXX_PROPERTY_REF_EXPR:
3194       S = new (Context) MSPropertyRefExpr(Empty);
3195       break;
3196     case EXPR_CXX_PROPERTY_SUBSCRIPT_EXPR:
3197       S = new (Context) MSPropertySubscriptExpr(Empty);
3198       break;
3199     case EXPR_CXX_UUIDOF_TYPE:
3200       S = new (Context) CXXUuidofExpr(Empty, false);
3201       break;
3202     case EXPR_CXX_THIS:
3203       S = new (Context) CXXThisExpr(Empty);
3204       break;
3205     case EXPR_CXX_THROW:
3206       S = new (Context) CXXThrowExpr(Empty);
3207       break;
3208     case EXPR_CXX_DEFAULT_ARG: {
3209       bool HasOtherExprStored = Record[ASTStmtReader::NumExprFields];
3210       if (HasOtherExprStored) {
3211         Expr *SubExpr = ReadSubExpr();
3212         S = CXXDefaultArgExpr::Create(Context, SourceLocation(), nullptr,
3213                                       SubExpr);
3214       } else
3215         S = new (Context) CXXDefaultArgExpr(Empty);
3216       break;
3217     }
3218     case EXPR_CXX_DEFAULT_INIT:
3219       S = new (Context) CXXDefaultInitExpr(Empty);
3220       break;
3221     case EXPR_CXX_BIND_TEMPORARY:
3222       S = new (Context) CXXBindTemporaryExpr(Empty);
3223       break;
3224
3225     case EXPR_CXX_SCALAR_VALUE_INIT:
3226       S = new (Context) CXXScalarValueInitExpr(Empty);
3227       break;
3228     case EXPR_CXX_NEW:
3229       S = new (Context) CXXNewExpr(Empty);
3230       break;
3231     case EXPR_CXX_DELETE:
3232       S = new (Context) CXXDeleteExpr(Empty);
3233       break;
3234     case EXPR_CXX_PSEUDO_DESTRUCTOR:
3235       S = new (Context) CXXPseudoDestructorExpr(Empty);
3236       break;
3237
3238     case EXPR_EXPR_WITH_CLEANUPS:
3239       S = ExprWithCleanups::Create(Context, Empty,
3240                                    Record[ASTStmtReader::NumExprFields]);
3241       break;
3242
3243     case EXPR_CXX_DEPENDENT_SCOPE_MEMBER:
3244       S = CXXDependentScopeMemberExpr::CreateEmpty(Context,
3245          /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields],
3246                   /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]
3247                                    ? Record[ASTStmtReader::NumExprFields + 1]
3248                                    : 0);
3249       break;
3250
3251     case EXPR_CXX_DEPENDENT_SCOPE_DECL_REF:
3252       S = DependentScopeDeclRefExpr::CreateEmpty(Context,
3253          /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields],
3254                   /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]
3255                                    ? Record[ASTStmtReader::NumExprFields + 1]
3256                                    : 0);
3257       break;
3258
3259     case EXPR_CXX_UNRESOLVED_CONSTRUCT:
3260       S = CXXUnresolvedConstructExpr::CreateEmpty(Context,
3261                               /*NumArgs=*/Record[ASTStmtReader::NumExprFields]);
3262       break;
3263
3264     case EXPR_CXX_UNRESOLVED_MEMBER:
3265       S = UnresolvedMemberExpr::CreateEmpty(Context,
3266          /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields],
3267                   /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]
3268                                    ? Record[ASTStmtReader::NumExprFields + 1]
3269                                    : 0);
3270       break;
3271
3272     case EXPR_CXX_UNRESOLVED_LOOKUP:
3273       S = UnresolvedLookupExpr::CreateEmpty(Context,
3274          /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields],
3275                   /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]
3276                                    ? Record[ASTStmtReader::NumExprFields + 1]
3277                                    : 0);
3278       break;
3279
3280     case EXPR_TYPE_TRAIT:
3281       S = TypeTraitExpr::CreateDeserialized(Context,
3282             Record[ASTStmtReader::NumExprFields]);
3283       break;
3284
3285     case EXPR_ARRAY_TYPE_TRAIT:
3286       S = new (Context) ArrayTypeTraitExpr(Empty);
3287       break;
3288
3289     case EXPR_CXX_EXPRESSION_TRAIT:
3290       S = new (Context) ExpressionTraitExpr(Empty);
3291       break;
3292
3293     case EXPR_CXX_NOEXCEPT:
3294       S = new (Context) CXXNoexceptExpr(Empty);
3295       break;
3296
3297     case EXPR_PACK_EXPANSION:
3298       S = new (Context) PackExpansionExpr(Empty);
3299       break;
3300
3301     case EXPR_SIZEOF_PACK:
3302       S = SizeOfPackExpr::CreateDeserialized(
3303               Context,
3304               /*NumPartialArgs=*/Record[ASTStmtReader::NumExprFields]);
3305       break;
3306
3307     case EXPR_SUBST_NON_TYPE_TEMPLATE_PARM:
3308       S = new (Context) SubstNonTypeTemplateParmExpr(Empty);
3309       break;
3310
3311     case EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK:
3312       S = new (Context) SubstNonTypeTemplateParmPackExpr(Empty);
3313       break;
3314
3315     case EXPR_FUNCTION_PARM_PACK:
3316       S = FunctionParmPackExpr::CreateEmpty(Context,
3317                                           Record[ASTStmtReader::NumExprFields]);
3318       break;
3319
3320     case EXPR_MATERIALIZE_TEMPORARY:
3321       S = new (Context) MaterializeTemporaryExpr(Empty);
3322       break;
3323
3324     case EXPR_CXX_FOLD:
3325       S = new (Context) CXXFoldExpr(Empty);
3326       break;
3327
3328     case EXPR_OPAQUE_VALUE:
3329       S = new (Context) OpaqueValueExpr(Empty);
3330       break;
3331
3332     case EXPR_CUDA_KERNEL_CALL:
3333       S = new (Context) CUDAKernelCallExpr(Context, Empty);
3334       break;
3335
3336     case EXPR_ASTYPE:
3337       S = new (Context) AsTypeExpr(Empty);
3338       break;
3339
3340     case EXPR_PSEUDO_OBJECT: {
3341       unsigned numSemanticExprs = Record[ASTStmtReader::NumExprFields];
3342       S = PseudoObjectExpr::Create(Context, Empty, numSemanticExprs);
3343       break;
3344     }
3345
3346     case EXPR_ATOMIC:
3347       S = new (Context) AtomicExpr(Empty);
3348       break;
3349
3350     case EXPR_LAMBDA: {
3351       unsigned NumCaptures = Record[ASTStmtReader::NumExprFields];
3352       unsigned NumArrayIndexVars = Record[ASTStmtReader::NumExprFields + 1];
3353       S = LambdaExpr::CreateDeserialized(Context, NumCaptures,
3354                                          NumArrayIndexVars);
3355       break;
3356     }
3357     }
3358
3359     // We hit a STMT_STOP, so we're done with this expression.
3360     if (Finished)
3361       break;
3362
3363     ++NumStatementsRead;
3364
3365     if (S && !IsStmtReference) {
3366       Reader.Visit(S);
3367       StmtEntries[Cursor.GetCurrentBitNo()] = S;
3368     }
3369
3370
3371     assert(Idx == Record.size() && "Invalid deserialization of statement");
3372     StmtStack.push_back(S);
3373   }
3374 Done:
3375   assert(StmtStack.size() > PrevNumStmts && "Read too many sub-stmts!");
3376   assert(StmtStack.size() == PrevNumStmts + 1 && "Extra expressions on stack!");
3377   return StmtStack.pop_back_val();
3378 }