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 = E->getKeyValues();
 991   ObjCDictionaryLiteral::ExpansionData *Expansions = E->getExpansionData();
 992   for (unsigned I = 0; I != NumElements; ++I) {
 993     KeyValues[I].Key = Reader.ReadSubExpr();
 994     KeyValues[I].Value = Reader.ReadSubExpr();
 995     if (HasPackExpansions) {
 996       Expansions[I].EllipsisLoc = ReadSourceLocation(Record, Idx);
 997       Expansions[I].NumExpansionsPlusOne = Record[Idx++];
 998     }
 999   }
1000   E->DictWithObjectsMethod = ReadDeclAs<ObjCMethodDecl>(Record, Idx);
1001   E->Range = ReadSourceRange(Record, Idx);
1002 }
1003
1004 void ASTStmtReader::VisitObjCEncodeExpr(ObjCEncodeExpr *E) {
1005   VisitExpr(E);
1006   E->setEncodedTypeSourceInfo(GetTypeSourceInfo(Record, Idx));
1007   E->setAtLoc(ReadSourceLocation(Record, Idx));
1008   E->setRParenLoc(ReadSourceLocation(Record, Idx));
1009 }
1010
1011 void ASTStmtReader::VisitObjCSelectorExpr(ObjCSelectorExpr *E) {
1012   VisitExpr(E);
1013   E->setSelector(Reader.ReadSelector(F, Record, Idx));
1014   E->setAtLoc(ReadSourceLocation(Record, Idx));
1015   E->setRParenLoc(ReadSourceLocation(Record, Idx));
1016 }
1017
1018 void ASTStmtReader::VisitObjCProtocolExpr(ObjCProtocolExpr *E) {
1019   VisitExpr(E);
1020   E->setProtocol(ReadDeclAs<ObjCProtocolDecl>(Record, Idx));
1021   E->setAtLoc(ReadSourceLocation(Record, Idx));
1022   E->ProtoLoc = ReadSourceLocation(Record, Idx);
1023   E->setRParenLoc(ReadSourceLocation(Record, Idx));
1024 }
1025
1026 void ASTStmtReader::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
1027   VisitExpr(E);
1028   E->setDecl(ReadDeclAs<ObjCIvarDecl>(Record, Idx));
1029   E->setLocation(ReadSourceLocation(Record, Idx));
1030   E->setOpLoc(ReadSourceLocation(Record, Idx));
1031   E->setBase(Reader.ReadSubExpr());
1032   E->setIsArrow(Record[Idx++]);
1033   E->setIsFreeIvar(Record[Idx++]);
1034 }
1035
1036 void ASTStmtReader::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
1037   VisitExpr(E);
1038   unsigned MethodRefFlags = Record[Idx++];
1039   bool Implicit = Record[Idx++] != 0;
1040   if (Implicit) {
1041     ObjCMethodDecl *Getter = ReadDeclAs<ObjCMethodDecl>(Record, Idx);
1042     ObjCMethodDecl *Setter = ReadDeclAs<ObjCMethodDecl>(Record, Idx);
1043     E->setImplicitProperty(Getter, Setter, MethodRefFlags);
1044   } else {
1045     E->setExplicitProperty(ReadDeclAs<ObjCPropertyDecl>(Record, Idx),
1046                            MethodRefFlags);
1047   }
1048   E->setLocation(ReadSourceLocation(Record, Idx));
1049   E->setReceiverLocation(ReadSourceLocation(Record, Idx));
1050   switch (Record[Idx++]) {
1051   case 0:
1052     E->setBase(Reader.ReadSubExpr());
1053     break;
1054   case 1:
1055     E->setSuperReceiver(Reader.readType(F, Record, Idx));
1056     break;
1057   case 2:
1058     E->setClassReceiver(ReadDeclAs<ObjCInterfaceDecl>(Record, Idx));
1059     break;
1060   }
1061 }
1062
1063 void ASTStmtReader::VisitObjCSubscriptRefExpr(ObjCSubscriptRefExpr *E) {
1064   VisitExpr(E);
1065   E->setRBracket(ReadSourceLocation(Record, Idx));
1066   E->setBaseExpr(Reader.ReadSubExpr());
1067   E->setKeyExpr(Reader.ReadSubExpr());
1068   E->GetAtIndexMethodDecl = ReadDeclAs<ObjCMethodDecl>(Record, Idx);
1069   E->SetAtIndexMethodDecl = ReadDeclAs<ObjCMethodDecl>(Record, Idx);
1070 }
1071
1072 void ASTStmtReader::VisitObjCMessageExpr(ObjCMessageExpr *E) {
1073   VisitExpr(E);
1074   assert(Record[Idx] == E->getNumArgs());
1075   ++Idx;
1076   unsigned NumStoredSelLocs = Record[Idx++];
1077   E->SelLocsKind = Record[Idx++];
1078   E->setDelegateInitCall(Record[Idx++]);
1079   E->IsImplicit = Record[Idx++];
1080   ObjCMessageExpr::ReceiverKind Kind
1081     = static_cast<ObjCMessageExpr::ReceiverKind>(Record[Idx++]);
1082   switch (Kind) {
1083   case ObjCMessageExpr::Instance:
1084     E->setInstanceReceiver(Reader.ReadSubExpr());
1085     break;
1086
1087   case ObjCMessageExpr::Class:
1088     E->setClassReceiver(GetTypeSourceInfo(Record, Idx));
1089     break;
1090
1091   case ObjCMessageExpr::SuperClass:
1092   case ObjCMessageExpr::SuperInstance: {
1093     QualType T = Reader.readType(F, Record, Idx);
1094     SourceLocation SuperLoc = ReadSourceLocation(Record, Idx);
1095     E->setSuper(SuperLoc, T, Kind == ObjCMessageExpr::SuperInstance);
1096     break;
1097   }
1098   }
1099
1100   assert(Kind == E->getReceiverKind());
1101
1102   if (Record[Idx++])
1103     E->setMethodDecl(ReadDeclAs<ObjCMethodDecl>(Record, Idx));
1104   else
1105     E->setSelector(Reader.ReadSelector(F, Record, Idx));
1106
1107   E->LBracLoc = ReadSourceLocation(Record, Idx);
1108   E->RBracLoc = ReadSourceLocation(Record, Idx);
1109
1110   for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
1111     E->setArg(I, Reader.ReadSubExpr());
1112
1113   SourceLocation *Locs = E->getStoredSelLocs();
1114   for (unsigned I = 0; I != NumStoredSelLocs; ++I)
1115     Locs[I] = ReadSourceLocation(Record, Idx);
1116 }
1117
1118 void ASTStmtReader::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
1119   VisitStmt(S);
1120   S->setElement(Reader.ReadSubStmt());
1121   S->setCollection(Reader.ReadSubExpr());
1122   S->setBody(Reader.ReadSubStmt());
1123   S->setForLoc(ReadSourceLocation(Record, Idx));
1124   S->setRParenLoc(ReadSourceLocation(Record, Idx));
1125 }
1126
1127 void ASTStmtReader::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {
1128   VisitStmt(S);
1129   S->setCatchBody(Reader.ReadSubStmt());
1130   S->setCatchParamDecl(ReadDeclAs<VarDecl>(Record, Idx));
1131   S->setAtCatchLoc(ReadSourceLocation(Record, Idx));
1132   S->setRParenLoc(ReadSourceLocation(Record, Idx));
1133 }
1134
1135 void ASTStmtReader::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
1136   VisitStmt(S);
1137   S->setFinallyBody(Reader.ReadSubStmt());
1138   S->setAtFinallyLoc(ReadSourceLocation(Record, Idx));
1139 }
1140
1141 void ASTStmtReader::VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S) {
1142   VisitStmt(S);
1143   S->setSubStmt(Reader.ReadSubStmt());
1144   S->setAtLoc(ReadSourceLocation(Record, Idx));
1145 }
1146
1147 void ASTStmtReader::VisitObjCAtTryStmt(ObjCAtTryStmt *S) {
1148   VisitStmt(S);
1149   assert(Record[Idx] == S->getNumCatchStmts());
1150   ++Idx;
1151   bool HasFinally = Record[Idx++];
1152   S->setTryBody(Reader.ReadSubStmt());
1153   for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I)
1154     S->setCatchStmt(I, cast_or_null<ObjCAtCatchStmt>(Reader.ReadSubStmt()));
1155
1156   if (HasFinally)
1157     S->setFinallyStmt(Reader.ReadSubStmt());
1158   S->setAtTryLoc(ReadSourceLocation(Record, Idx));
1159 }
1160
1161 void ASTStmtReader::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) {
1162   VisitStmt(S);
1163   S->setSynchExpr(Reader.ReadSubStmt());
1164   S->setSynchBody(Reader.ReadSubStmt());
1165   S->setAtSynchronizedLoc(ReadSourceLocation(Record, Idx));
1166 }
1167
1168 void ASTStmtReader::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {
1169   VisitStmt(S);
1170   S->setThrowExpr(Reader.ReadSubStmt());
1171   S->setThrowLoc(ReadSourceLocation(Record, Idx));
1172 }
1173
1174 void ASTStmtReader::VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) {
1175   VisitExpr(E);
1176   E->setValue(Record[Idx++]);
1177   E->setLocation(ReadSourceLocation(Record, Idx));
1178 }
1179
1180 //===----------------------------------------------------------------------===//
1181 // C++ Expressions and Statements
1182 //===----------------------------------------------------------------------===//
1183
1184 void ASTStmtReader::VisitCXXCatchStmt(CXXCatchStmt *S) {
1185   VisitStmt(S);
1186   S->CatchLoc = ReadSourceLocation(Record, Idx);
1187   S->ExceptionDecl = ReadDeclAs<VarDecl>(Record, Idx);
1188   S->HandlerBlock = Reader.ReadSubStmt();
1189 }
1190
1191 void ASTStmtReader::VisitCXXTryStmt(CXXTryStmt *S) {
1192   VisitStmt(S);
1193   assert(Record[Idx] == S->getNumHandlers() && "NumStmtFields is wrong ?");
1194   ++Idx;
1195   S->TryLoc = ReadSourceLocation(Record, Idx);
1196   S->getStmts()[0] = Reader.ReadSubStmt();
1197   for (unsigned i = 0, e = S->getNumHandlers(); i != e; ++i)
1198     S->getStmts()[i + 1] = Reader.ReadSubStmt();
1199 }
1200
1201 void ASTStmtReader::VisitCXXForRangeStmt(CXXForRangeStmt *S) {
1202   VisitStmt(S);
1203   S->ForLoc = ReadSourceLocation(Record, Idx);
1204   S->CoawaitLoc = ReadSourceLocation(Record, Idx);
1205   S->ColonLoc = ReadSourceLocation(Record, Idx);
1206   S->RParenLoc = ReadSourceLocation(Record, Idx);
1207   S->setRangeStmt(Reader.ReadSubStmt());
1208   S->setBeginEndStmt(Reader.ReadSubStmt());
1209   S->setCond(Reader.ReadSubExpr());
1210   S->setInc(Reader.ReadSubExpr());
1211   S->setLoopVarStmt(Reader.ReadSubStmt());
1212   S->setBody(Reader.ReadSubStmt());
1213 }
1214
1215 void ASTStmtReader::VisitMSDependentExistsStmt(MSDependentExistsStmt *S) {
1216   VisitStmt(S);
1217   S->KeywordLoc = ReadSourceLocation(Record, Idx);
1218   S->IsIfExists = Record[Idx++];
1219   S->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1220   ReadDeclarationNameInfo(S->NameInfo, Record, Idx);
1221   S->SubStmt = Reader.ReadSubStmt();
1222 }
1223
1224 void ASTStmtReader::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
1225   VisitCallExpr(E);
1226   E->Operator = (OverloadedOperatorKind)Record[Idx++];
1227   E->Range = Reader.ReadSourceRange(F, Record, Idx);
1228   E->setFPContractable((bool)Record[Idx++]);
1229 }
1230
1231 void ASTStmtReader::VisitCXXConstructExpr(CXXConstructExpr *E) {
1232   VisitExpr(E);
1233   E->NumArgs = Record[Idx++];
1234   if (E->NumArgs)
1235     E->Args = new (Reader.getContext()) Stmt*[E->NumArgs];
1236   for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
1237     E->setArg(I, Reader.ReadSubExpr());
1238   E->setConstructor(ReadDeclAs<CXXConstructorDecl>(Record, Idx));
1239   E->setLocation(ReadSourceLocation(Record, Idx));
1240   E->setElidable(Record[Idx++]);
1241   E->setHadMultipleCandidates(Record[Idx++]);
1242   E->setListInitialization(Record[Idx++]);
1243   E->setStdInitListInitialization(Record[Idx++]);
1244   E->setRequiresZeroInitialization(Record[Idx++]);
1245   E->setConstructionKind((CXXConstructExpr::ConstructionKind)Record[Idx++]);
1246   E->ParenOrBraceRange = ReadSourceRange(Record, Idx);
1247 }
1248
1249 void ASTStmtReader::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) {
1250   VisitCXXConstructExpr(E);
1251   E->Type = GetTypeSourceInfo(Record, Idx);
1252 }
1253
1254 void ASTStmtReader::VisitLambdaExpr(LambdaExpr *E) {
1255   VisitExpr(E);
1256   unsigned NumCaptures = Record[Idx++];
1257   assert(NumCaptures == E->NumCaptures);(void)NumCaptures;
1258   unsigned NumArrayIndexVars = Record[Idx++];
1259   E->IntroducerRange = ReadSourceRange(Record, Idx);
1260   E->CaptureDefault = static_cast<LambdaCaptureDefault>(Record[Idx++]);
1261   E->CaptureDefaultLoc = ReadSourceLocation(Record, Idx);
1262   E->ExplicitParams = Record[Idx++];
1263   E->ExplicitResultType = Record[Idx++];
1264   E->ClosingBrace = ReadSourceLocation(Record, Idx);
1265
1266   // Read capture initializers.
1267   for (LambdaExpr::capture_init_iterator C = E->capture_init_begin(),
1268                                       CEnd = E->capture_init_end();
1269        C != CEnd; ++C)
1270     *C = Reader.ReadSubExpr();
1271
1272   // Read array capture index variables.
1273   if (NumArrayIndexVars > 0) {
1274     unsigned *ArrayIndexStarts = E->getArrayIndexStarts();
1275     for (unsigned I = 0; I != NumCaptures + 1; ++I)
1276       ArrayIndexStarts[I] = Record[Idx++];
1277
1278     VarDecl **ArrayIndexVars = E->getArrayIndexVars();
1279     for (unsigned I = 0; I != NumArrayIndexVars; ++I)
1280       ArrayIndexVars[I] = ReadDeclAs<VarDecl>(Record, Idx);
1281   }
1282 }
1283
1284 void
1285 ASTStmtReader::VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) {
1286   VisitExpr(E);
1287   E->SubExpr = Reader.ReadSubExpr();
1288 }
1289
1290 void ASTStmtReader::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
1291   VisitExplicitCastExpr(E);
1292   SourceRange R = ReadSourceRange(Record, Idx);
1293   E->Loc = R.getBegin();
1294   E->RParenLoc = R.getEnd();
1295   R = ReadSourceRange(Record, Idx);
1296   E->AngleBrackets = R;
1297 }
1298
1299 void ASTStmtReader::VisitCXXStaticCastExpr(CXXStaticCastExpr *E) {
1300   return VisitCXXNamedCastExpr(E);
1301 }
1302
1303 void ASTStmtReader::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E) {
1304   return VisitCXXNamedCastExpr(E);
1305 }
1306
1307 void ASTStmtReader::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E) {
1308   return VisitCXXNamedCastExpr(E);
1309 }
1310
1311 void ASTStmtReader::VisitCXXConstCastExpr(CXXConstCastExpr *E) {
1312   return VisitCXXNamedCastExpr(E);
1313 }
1314
1315 void ASTStmtReader::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) {
1316   VisitExplicitCastExpr(E);
1317   E->setLParenLoc(ReadSourceLocation(Record, Idx));
1318   E->setRParenLoc(ReadSourceLocation(Record, Idx));
1319 }
1320
1321 void ASTStmtReader::VisitUserDefinedLiteral(UserDefinedLiteral *E) {
1322   VisitCallExpr(E);
1323   E->UDSuffixLoc = ReadSourceLocation(Record, Idx);
1324 }
1325
1326 void ASTStmtReader::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
1327   VisitExpr(E);
1328   E->setValue(Record[Idx++]);
1329   E->setLocation(ReadSourceLocation(Record, Idx));
1330 }
1331
1332 void ASTStmtReader::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {
1333   VisitExpr(E);
1334   E->setLocation(ReadSourceLocation(Record, Idx));
1335 }
1336
1337 void ASTStmtReader::VisitCXXTypeidExpr(CXXTypeidExpr *E) {
1338   VisitExpr(E);
1339   E->setSourceRange(ReadSourceRange(Record, Idx));
1340   if (E->isTypeOperand()) { // typeid(int)
1341     E->setTypeOperandSourceInfo(
1342         GetTypeSourceInfo(Record, Idx));
1343     return;
1344   }
1345
1346   // typeid(42+2)
1347   E->setExprOperand(Reader.ReadSubExpr());
1348 }
1349
1350 void ASTStmtReader::VisitCXXThisExpr(CXXThisExpr *E) {
1351   VisitExpr(E);
1352   E->setLocation(ReadSourceLocation(Record, Idx));
1353   E->setImplicit(Record[Idx++]);
1354 }
1355
1356 void ASTStmtReader::VisitCXXThrowExpr(CXXThrowExpr *E) {
1357   VisitExpr(E);
1358   E->ThrowLoc = ReadSourceLocation(Record, Idx);
1359   E->Op = Reader.ReadSubExpr();
1360   E->IsThrownVariableInScope = Record[Idx++];
1361 }
1362
1363 void ASTStmtReader::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
1364   VisitExpr(E);
1365
1366   assert((bool)Record[Idx] == E->Param.getInt() && "We messed up at creation ?");
1367   ++Idx; // HasOtherExprStored and SubExpr was handled during creation.
1368   E->Param.setPointer(ReadDeclAs<ParmVarDecl>(Record, Idx));
1369   E->Loc = ReadSourceLocation(Record, Idx);
1370 }
1371
1372 void ASTStmtReader::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
1373   VisitExpr(E);
1374   E->Field = ReadDeclAs<FieldDecl>(Record, Idx);
1375   E->Loc = ReadSourceLocation(Record, Idx);
1376 }
1377
1378 void ASTStmtReader::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
1379   VisitExpr(E);
1380   E->setTemporary(Reader.ReadCXXTemporary(F, Record, Idx));
1381   E->setSubExpr(Reader.ReadSubExpr());
1382 }
1383
1384 void ASTStmtReader::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
1385   VisitExpr(E);
1386   E->TypeInfo = GetTypeSourceInfo(Record, Idx);
1387   E->RParenLoc = ReadSourceLocation(Record, Idx);
1388 }
1389
1390 void ASTStmtReader::VisitCXXNewExpr(CXXNewExpr *E) {
1391   VisitExpr(E);
1392   E->GlobalNew = Record[Idx++];
1393   bool isArray = Record[Idx++];
1394   E->UsualArrayDeleteWantsSize = Record[Idx++];
1395   unsigned NumPlacementArgs = Record[Idx++];
1396   E->StoredInitializationStyle = Record[Idx++];
1397   E->setOperatorNew(ReadDeclAs<FunctionDecl>(Record, Idx));
1398   E->setOperatorDelete(ReadDeclAs<FunctionDecl>(Record, Idx));
1399   E->AllocatedTypeInfo = GetTypeSourceInfo(Record, Idx);
1400   E->TypeIdParens = ReadSourceRange(Record, Idx);
1401   E->Range = ReadSourceRange(Record, Idx);
1402   E->DirectInitRange = ReadSourceRange(Record, Idx);
1403
1404   E->AllocateArgsArray(Reader.getContext(), isArray, NumPlacementArgs,
1405                        E->StoredInitializationStyle != 0);
1406
1407   // Install all the subexpressions.
1408   for (CXXNewExpr::raw_arg_iterator I = E->raw_arg_begin(),e = E->raw_arg_end();
1409        I != e; ++I)
1410     *I = Reader.ReadSubStmt();
1411 }
1412
1413 void ASTStmtReader::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
1414   VisitExpr(E);
1415   E->GlobalDelete = Record[Idx++];
1416   E->ArrayForm = Record[Idx++];
1417   E->ArrayFormAsWritten = Record[Idx++];
1418   E->UsualArrayDeleteWantsSize = Record[Idx++];
1419   E->OperatorDelete = ReadDeclAs<FunctionDecl>(Record, Idx);
1420   E->Argument = Reader.ReadSubExpr();
1421   E->Loc = ReadSourceLocation(Record, Idx);
1422 }
1423
1424 void ASTStmtReader::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) {
1425   VisitExpr(E);
1426
1427   E->Base = Reader.ReadSubExpr();
1428   E->IsArrow = Record[Idx++];
1429   E->OperatorLoc = ReadSourceLocation(Record, Idx);
1430   E->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1431   E->ScopeType = GetTypeSourceInfo(Record, Idx);
1432   E->ColonColonLoc = ReadSourceLocation(Record, Idx);
1433   E->TildeLoc = ReadSourceLocation(Record, Idx);
1434
1435   IdentifierInfo *II = Reader.GetIdentifierInfo(F, Record, Idx);
1436   if (II)
1437     E->setDestroyedType(II, ReadSourceLocation(Record, Idx));
1438   else
1439     E->setDestroyedType(GetTypeSourceInfo(Record, Idx));
1440 }
1441
1442 void ASTStmtReader::VisitExprWithCleanups(ExprWithCleanups *E) {
1443   VisitExpr(E);
1444
1445   unsigned NumObjects = Record[Idx++];
1446   assert(NumObjects == E->getNumObjects());
1447   for (unsigned i = 0; i != NumObjects; ++i)
1448     E->getObjectsBuffer()[i] = ReadDeclAs<BlockDecl>(Record, Idx);
1449
1450   E->SubExpr = Reader.ReadSubExpr();
1451 }
1452
1453 void
1454 ASTStmtReader::VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E){
1455   VisitExpr(E);
1456
1457   if (Record[Idx++]) // HasTemplateKWAndArgsInfo
1458     ReadTemplateKWAndArgsInfo(
1459         *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
1460         E->getTrailingObjects<TemplateArgumentLoc>(),
1461         /*NumTemplateArgs=*/Record[Idx++]);
1462
1463   E->Base = Reader.ReadSubExpr();
1464   E->BaseType = Reader.readType(F, Record, Idx);
1465   E->IsArrow = Record[Idx++];
1466   E->OperatorLoc = ReadSourceLocation(Record, Idx);
1467   E->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1468   E->FirstQualifierFoundInScope = ReadDeclAs<NamedDecl>(Record, Idx);
1469   ReadDeclarationNameInfo(E->MemberNameInfo, Record, Idx);
1470 }
1471
1472 void
1473 ASTStmtReader::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
1474   VisitExpr(E);
1475
1476   if (Record[Idx++]) // HasTemplateKWAndArgsInfo
1477     ReadTemplateKWAndArgsInfo(
1478         *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
1479         E->getTrailingObjects<TemplateArgumentLoc>(),
1480         /*NumTemplateArgs=*/Record[Idx++]);
1481
1482   E->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1483   ReadDeclarationNameInfo(E->NameInfo, Record, Idx);
1484 }
1485
1486 void
1487 ASTStmtReader::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) {
1488   VisitExpr(E);
1489   assert(Record[Idx] == E->arg_size() && "Read wrong record during creation ?");
1490   ++Idx; // NumArgs;
1491   for (unsigned I = 0, N = E->arg_size(); I != N; ++I)
1492     E->setArg(I, Reader.ReadSubExpr());
1493   E->Type = GetTypeSourceInfo(Record, Idx);
1494   E->setLParenLoc(ReadSourceLocation(Record, Idx));
1495   E->setRParenLoc(ReadSourceLocation(Record, Idx));
1496 }
1497
1498 void ASTStmtReader::VisitOverloadExpr(OverloadExpr *E) {
1499   VisitExpr(E);
1500
1501   if (Record[Idx++]) // HasTemplateKWAndArgsInfo
1502     ReadTemplateKWAndArgsInfo(*E->getTrailingASTTemplateKWAndArgsInfo(),
1503                               E->getTrailingTemplateArgumentLoc(),
1504                               /*NumTemplateArgs=*/Record[Idx++]);
1505
1506   unsigned NumDecls = Record[Idx++];
1507   UnresolvedSet<8> Decls;
1508   for (unsigned i = 0; i != NumDecls; ++i) {
1509     NamedDecl *D = ReadDeclAs<NamedDecl>(Record, Idx);
1510     AccessSpecifier AS = (AccessSpecifier)Record[Idx++];
1511     Decls.addDecl(D, AS);
1512   }
1513   E->initializeResults(Reader.getContext(), Decls.begin(), Decls.end());
1514
1515   ReadDeclarationNameInfo(E->NameInfo, Record, Idx);
1516   E->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1517 }
1518
1519 void ASTStmtReader::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) {
1520   VisitOverloadExpr(E);
1521   E->IsArrow = Record[Idx++];
1522   E->HasUnresolvedUsing = Record[Idx++];
1523   E->Base = Reader.ReadSubExpr();
1524   E->BaseType = Reader.readType(F, Record, Idx);
1525   E->OperatorLoc = ReadSourceLocation(Record, Idx);
1526 }
1527
1528 void ASTStmtReader::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
1529   VisitOverloadExpr(E);
1530   E->RequiresADL = Record[Idx++];
1531   E->Overloaded = Record[Idx++];
1532   E->NamingClass = ReadDeclAs<CXXRecordDecl>(Record, Idx);
1533 }
1534
1535 void ASTStmtReader::VisitTypeTraitExpr(TypeTraitExpr *E) {
1536   VisitExpr(E);
1537   E->TypeTraitExprBits.NumArgs = Record[Idx++];
1538   E->TypeTraitExprBits.Kind = Record[Idx++];
1539   E->TypeTraitExprBits.Value = Record[Idx++];
1540   SourceRange Range = ReadSourceRange(Record, Idx);
1541   E->Loc = Range.getBegin();
1542   E->RParenLoc = Range.getEnd();
1543
1544   TypeSourceInfo **Args = E->getTypeSourceInfos();
1545   for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
1546     Args[I] = GetTypeSourceInfo(Record, Idx);
1547 }
1548
1549 void ASTStmtReader::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
1550   VisitExpr(E);
1551   E->ATT = (ArrayTypeTrait)Record[Idx++];
1552   E->Value = (unsigned int)Record[Idx++];
1553   SourceRange Range = ReadSourceRange(Record, Idx);
1554   E->Loc = Range.getBegin();
1555   E->RParen = Range.getEnd();
1556   E->QueriedType = GetTypeSourceInfo(Record, Idx);
1557 }
1558
1559 void ASTStmtReader::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
1560   VisitExpr(E);
1561   E->ET = (ExpressionTrait)Record[Idx++];
1562   E->Value = (bool)Record[Idx++];
1563   SourceRange Range = ReadSourceRange(Record, Idx);
1564   E->QueriedExpression = Reader.ReadSubExpr();
1565   E->Loc = Range.getBegin();
1566   E->RParen = Range.getEnd();
1567 }
1568
1569 void ASTStmtReader::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
1570   VisitExpr(E);
1571   E->Value = (bool)Record[Idx++];
1572   E->Range = ReadSourceRange(Record, Idx);
1573   E->Operand = Reader.ReadSubExpr();
1574 }
1575
1576 void ASTStmtReader::VisitPackExpansionExpr(PackExpansionExpr *E) {
1577   VisitExpr(E);
1578   E->EllipsisLoc = ReadSourceLocation(Record, Idx);
1579   E->NumExpansions = Record[Idx++];
1580   E->Pattern = Reader.ReadSubExpr();
1581 }
1582
1583 void ASTStmtReader::VisitSizeOfPackExpr(SizeOfPackExpr *E) {
1584   VisitExpr(E);
1585   unsigned NumPartialArgs = Record[Idx++];
1586   E->OperatorLoc = ReadSourceLocation(Record, Idx);
1587   E->PackLoc = ReadSourceLocation(Record, Idx);
1588   E->RParenLoc = ReadSourceLocation(Record, Idx);
1589   E->Pack = Reader.ReadDeclAs<NamedDecl>(F, Record, Idx);
1590   if (E->isPartiallySubstituted()) {
1591     assert(E->Length == NumPartialArgs);
1592     for (auto *I = reinterpret_cast<TemplateArgument *>(E + 1),
1593               *E = I + NumPartialArgs;
1594          I != E; ++I)
1595       new (I) TemplateArgument(Reader.ReadTemplateArgument(F, Record, Idx));
1596   } else if (!E->isValueDependent()) {
1597     E->Length = Record[Idx++];
1598   }
1599 }
1600
1601 void ASTStmtReader::VisitSubstNonTypeTemplateParmExpr(
1602                                               SubstNonTypeTemplateParmExpr *E) {
1603   VisitExpr(E);
1604   E->Param = ReadDeclAs<NonTypeTemplateParmDecl>(Record, Idx);
1605   E->NameLoc = ReadSourceLocation(Record, Idx);
1606   E->Replacement = Reader.ReadSubExpr();
1607 }
1608
1609 void ASTStmtReader::VisitSubstNonTypeTemplateParmPackExpr(
1610                                           SubstNonTypeTemplateParmPackExpr *E) {
1611   VisitExpr(E);
1612   E->Param = ReadDeclAs<NonTypeTemplateParmDecl>(Record, Idx);
1613   TemplateArgument ArgPack = Reader.ReadTemplateArgument(F, Record, Idx);
1614   if (ArgPack.getKind() != TemplateArgument::Pack)
1615     return;
1616
1617   E->Arguments = ArgPack.pack_begin();
1618   E->NumArguments = ArgPack.pack_size();
1619   E->NameLoc = ReadSourceLocation(Record, Idx);
1620 }
1621
1622 void ASTStmtReader::VisitFunctionParmPackExpr(FunctionParmPackExpr *E) {
1623   VisitExpr(E);
1624   E->NumParameters = Record[Idx++];
1625   E->ParamPack = ReadDeclAs<ParmVarDecl>(Record, Idx);
1626   E->NameLoc = ReadSourceLocation(Record, Idx);
1627   ParmVarDecl **Parms = reinterpret_cast<ParmVarDecl**>(E+1);
1628   for (unsigned i = 0, n = E->NumParameters; i != n; ++i)
1629     Parms[i] = ReadDeclAs<ParmVarDecl>(Record, Idx);
1630 }
1631
1632 void ASTStmtReader::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
1633   VisitExpr(E);
1634   E->State = Reader.ReadSubExpr();
1635   auto VD = ReadDeclAs<ValueDecl>(Record, Idx);
1636   unsigned ManglingNumber = Record[Idx++];
1637   E->setExtendingDecl(VD, ManglingNumber);
1638 }
1639
1640 void ASTStmtReader::VisitCXXFoldExpr(CXXFoldExpr *E) {
1641   VisitExpr(E);
1642   E->LParenLoc = ReadSourceLocation(Record, Idx);
1643   E->EllipsisLoc = ReadSourceLocation(Record, Idx);
1644   E->RParenLoc = ReadSourceLocation(Record, Idx);
1645   E->SubExprs[0] = Reader.ReadSubExpr();
1646   E->SubExprs[1] = Reader.ReadSubExpr();
1647   E->Opcode = (BinaryOperatorKind)Record[Idx++];
1648 }
1649
1650 void ASTStmtReader::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
1651   VisitExpr(E);
1652   E->SourceExpr = Reader.ReadSubExpr();
1653   E->Loc = ReadSourceLocation(Record, Idx);
1654 }
1655
1656 void ASTStmtReader::VisitTypoExpr(TypoExpr *E) {
1657   llvm_unreachable("Cannot read TypoExpr nodes");
1658 }
1659
1660 //===----------------------------------------------------------------------===//
1661 // Microsoft Expressions and Statements
1662 //===----------------------------------------------------------------------===//
1663 void ASTStmtReader::VisitMSPropertyRefExpr(MSPropertyRefExpr *E) {
1664   VisitExpr(E);
1665   E->IsArrow = (Record[Idx++] != 0);
1666   E->BaseExpr = Reader.ReadSubExpr();
1667   E->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1668   E->MemberLoc = ReadSourceLocation(Record, Idx);
1669   E->TheDecl = ReadDeclAs<MSPropertyDecl>(Record, Idx);
1670 }
1671
1672 void ASTStmtReader::VisitMSPropertySubscriptExpr(MSPropertySubscriptExpr *E) {
1673   VisitExpr(E);
1674   E->setBase(Reader.ReadSubExpr());
1675   E->setIdx(Reader.ReadSubExpr());
1676   E->setRBracketLoc(ReadSourceLocation(Record, Idx));
1677 }
1678
1679 void ASTStmtReader::VisitCXXUuidofExpr(CXXUuidofExpr *E) {
1680   VisitExpr(E);
1681   E->setSourceRange(ReadSourceRange(Record, Idx));
1682   if (E->isTypeOperand()) { // __uuidof(ComType)
1683     E->setTypeOperandSourceInfo(
1684         GetTypeSourceInfo(Record, Idx));
1685     return;
1686   }
1687
1688   // __uuidof(expr)
1689   E->setExprOperand(Reader.ReadSubExpr());
1690 }
1691
1692 void ASTStmtReader::VisitSEHLeaveStmt(SEHLeaveStmt *S) {
1693   VisitStmt(S);
1694   S->setLeaveLoc(ReadSourceLocation(Record, Idx));
1695 }
1696
1697 void ASTStmtReader::VisitSEHExceptStmt(SEHExceptStmt *S) {
1698   VisitStmt(S);
1699   S->Loc = ReadSourceLocation(Record, Idx);
1700   S->Children[SEHExceptStmt::FILTER_EXPR] = Reader.ReadSubStmt();
1701   S->Children[SEHExceptStmt::BLOCK] = Reader.ReadSubStmt();
1702 }
1703
1704 void ASTStmtReader::VisitSEHFinallyStmt(SEHFinallyStmt *S) {
1705   VisitStmt(S);
1706   S->Loc = ReadSourceLocation(Record, Idx);
1707   S->Block = Reader.ReadSubStmt();
1708 }
1709
1710 void ASTStmtReader::VisitSEHTryStmt(SEHTryStmt *S) {
1711   VisitStmt(S);
1712   S->IsCXXTry = Record[Idx++];
1713   S->TryLoc = ReadSourceLocation(Record, Idx);
1714   S->Children[SEHTryStmt::TRY] = Reader.ReadSubStmt();
1715   S->Children[SEHTryStmt::HANDLER] = Reader.ReadSubStmt();
1716 }
1717
1718 //===----------------------------------------------------------------------===//
1719 // CUDA Expressions and Statements
1720 //===----------------------------------------------------------------------===//
1721
1722 void ASTStmtReader::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *E) {
1723   VisitCallExpr(E);
1724   E->setConfig(cast<CallExpr>(Reader.ReadSubExpr()));
1725 }
1726
1727 //===----------------------------------------------------------------------===//
1728 // OpenCL Expressions and Statements.
1729 //===----------------------------------------------------------------------===//
1730 void ASTStmtReader::VisitAsTypeExpr(AsTypeExpr *E) {
1731   VisitExpr(E);
1732   E->BuiltinLoc = ReadSourceLocation(Record, Idx);
1733   E->RParenLoc = ReadSourceLocation(Record, Idx);
1734   E->SrcExpr = Reader.ReadSubExpr();
1735 }
1736
1737 //===----------------------------------------------------------------------===//
1738 // OpenMP Clauses.
1739 //===----------------------------------------------------------------------===//
1740
1741 namespace clang {
1742 class OMPClauseReader : public OMPClauseVisitor<OMPClauseReader> {
1743   ASTStmtReader *Reader;
1744   ASTContext &Context;
1745   const ASTReader::RecordData &Record;
1746   unsigned &Idx;
1747 public:
1748   OMPClauseReader(ASTStmtReader *R, ASTContext &C,
1749                   const ASTReader::RecordData &Record, unsigned &Idx)
1750     : Reader(R), Context(C), Record(Record), Idx(Idx) { }
1751 #define OPENMP_CLAUSE(Name, Class)    \
1752   void Visit##Class(Class *S);
1753 #include "clang/Basic/OpenMPKinds.def"
1754   OMPClause *readClause();
1755 };
1756 }
1757
1758 OMPClause *OMPClauseReader::readClause() {
1759   OMPClause *C;
1760   switch (Record[Idx++]) {
1761   case OMPC_if:
1762     C = new (Context) OMPIfClause();
1763     break;
1764   case OMPC_final:
1765     C = new (Context) OMPFinalClause();
1766     break;
1767   case OMPC_num_threads:
1768     C = new (Context) OMPNumThreadsClause();
1769     break;
1770   case OMPC_safelen:
1771     C = new (Context) OMPSafelenClause();
1772     break;
1773   case OMPC_simdlen:
1774     C = new (Context) OMPSimdlenClause();
1775     break;
1776   case OMPC_collapse:
1777     C = new (Context) OMPCollapseClause();
1778     break;
1779   case OMPC_default:
1780     C = new (Context) OMPDefaultClause();
1781     break;
1782   case OMPC_proc_bind:
1783     C = new (Context) OMPProcBindClause();
1784     break;
1785   case OMPC_schedule:
1786     C = new (Context) OMPScheduleClause();
1787     break;
1788   case OMPC_ordered:
1789     C = new (Context) OMPOrderedClause();
1790     break;
1791   case OMPC_nowait:
1792     C = new (Context) OMPNowaitClause();
1793     break;
1794   case OMPC_untied:
1795     C = new (Context) OMPUntiedClause();
1796     break;
1797   case OMPC_mergeable:
1798     C = new (Context) OMPMergeableClause();
1799     break;
1800   case OMPC_read:
1801     C = new (Context) OMPReadClause();
1802     break;
1803   case OMPC_write:
1804     C = new (Context) OMPWriteClause();
1805     break;
1806   case OMPC_update:
1807     C = new (Context) OMPUpdateClause();
1808     break;
1809   case OMPC_capture:
1810     C = new (Context) OMPCaptureClause();
1811     break;
1812   case OMPC_seq_cst:
1813     C = new (Context) OMPSeqCstClause();
1814     break;
1815   case OMPC_threads:
1816     C = new (Context) OMPThreadsClause();
1817     break;
1818   case OMPC_simd:
1819     C = new (Context) OMPSIMDClause();
1820     break;
1821   case OMPC_nogroup:
1822     C = new (Context) OMPNogroupClause();
1823     break;
1824   case OMPC_private:
1825     C = OMPPrivateClause::CreateEmpty(Context, Record[Idx++]);
1826     break;
1827   case OMPC_firstprivate:
1828     C = OMPFirstprivateClause::CreateEmpty(Context, Record[Idx++]);
1829     break;
1830   case OMPC_lastprivate:
1831     C = OMPLastprivateClause::CreateEmpty(Context, Record[Idx++]);
1832     break;
1833   case OMPC_shared:
1834     C = OMPSharedClause::CreateEmpty(Context, Record[Idx++]);
1835     break;
1836   case OMPC_reduction:
1837     C = OMPReductionClause::CreateEmpty(Context, Record[Idx++]);
1838     break;
1839   case OMPC_linear:
1840     C = OMPLinearClause::CreateEmpty(Context, Record[Idx++]);
1841     break;
1842   case OMPC_aligned:
1843     C = OMPAlignedClause::CreateEmpty(Context, Record[Idx++]);
1844     break;
1845   case OMPC_copyin:
1846     C = OMPCopyinClause::CreateEmpty(Context, Record[Idx++]);
1847     break;
1848   case OMPC_copyprivate:
1849     C = OMPCopyprivateClause::CreateEmpty(Context, Record[Idx++]);
1850     break;
1851   case OMPC_flush:
1852     C = OMPFlushClause::CreateEmpty(Context, Record[Idx++]);
1853     break;
1854   case OMPC_depend:
1855     C = OMPDependClause::CreateEmpty(Context, Record[Idx++]);
1856     break;
1857   case OMPC_device:
1858     C = new (Context) OMPDeviceClause();
1859     break;
1860   case OMPC_map:
1861     C = OMPMapClause::CreateEmpty(Context, Record[Idx++]);
1862     break;
1863   case OMPC_num_teams:
1864     C = new (Context) OMPNumTeamsClause();
1865     break;
1866   case OMPC_thread_limit:
1867     C = new (Context) OMPThreadLimitClause();
1868     break;
1869   case OMPC_priority:
1870     C = new (Context) OMPPriorityClause();
1871     break;
1872   case OMPC_grainsize:
1873     C = new (Context) OMPGrainsizeClause();
1874     break;
1875   case OMPC_num_tasks:
1876     C = new (Context) OMPNumTasksClause();
1877     break;
1878   case OMPC_hint:
1879     C = new (Context) OMPHintClause();
1880     break;
1881   }
1882   Visit(C);
1883   C->setLocStart(Reader->ReadSourceLocation(Record, Idx));
1884   C->setLocEnd(Reader->ReadSourceLocation(Record, Idx));
1885
1886   return C;
1887 }
1888
1889 void OMPClauseReader::VisitOMPIfClause(OMPIfClause *C) {
1890   C->setNameModifier(static_cast<OpenMPDirectiveKind>(Record[Idx++]));
1891   C->setNameModifierLoc(Reader->ReadSourceLocation(Record, Idx));
1892   C->setColonLoc(Reader->ReadSourceLocation(Record, Idx));
1893   C->setCondition(Reader->Reader.ReadSubExpr());
1894   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
1895 }
1896
1897 void OMPClauseReader::VisitOMPFinalClause(OMPFinalClause *C) {
1898   C->setCondition(Reader->Reader.ReadSubExpr());
1899   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
1900 }
1901
1902 void OMPClauseReader::VisitOMPNumThreadsClause(OMPNumThreadsClause *C) {
1903   C->setNumThreads(Reader->Reader.ReadSubExpr());
1904   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
1905 }
1906
1907 void OMPClauseReader::VisitOMPSafelenClause(OMPSafelenClause *C) {
1908   C->setSafelen(Reader->Reader.ReadSubExpr());
1909   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
1910 }
1911
1912 void OMPClauseReader::VisitOMPSimdlenClause(OMPSimdlenClause *C) {
1913   C->setSimdlen(Reader->Reader.ReadSubExpr());
1914   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
1915 }
1916
1917 void OMPClauseReader::VisitOMPCollapseClause(OMPCollapseClause *C) {
1918   C->setNumForLoops(Reader->Reader.ReadSubExpr());
1919   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
1920 }
1921
1922 void OMPClauseReader::VisitOMPDefaultClause(OMPDefaultClause *C) {
1923   C->setDefaultKind(
1924        static_cast<OpenMPDefaultClauseKind>(Record[Idx++]));
1925   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
1926   C->setDefaultKindKwLoc(Reader->ReadSourceLocation(Record, Idx));
1927 }
1928
1929 void OMPClauseReader::VisitOMPProcBindClause(OMPProcBindClause *C) {
1930   C->setProcBindKind(
1931        static_cast<OpenMPProcBindClauseKind>(Record[Idx++]));
1932   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
1933   C->setProcBindKindKwLoc(Reader->ReadSourceLocation(Record, Idx));
1934 }
1935
1936 void OMPClauseReader::VisitOMPScheduleClause(OMPScheduleClause *C) {
1937   C->setScheduleKind(
1938        static_cast<OpenMPScheduleClauseKind>(Record[Idx++]));
1939   C->setFirstScheduleModifier(
1940       static_cast<OpenMPScheduleClauseModifier>(Record[Idx++]));
1941   C->setSecondScheduleModifier(
1942       static_cast<OpenMPScheduleClauseModifier>(Record[Idx++]));
1943   C->setChunkSize(Reader->Reader.ReadSubExpr());
1944   C->setHelperChunkSize(Reader->Reader.ReadSubExpr());
1945   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
1946   C->setFirstScheduleModifierLoc(Reader->ReadSourceLocation(Record, Idx));
1947   C->setSecondScheduleModifierLoc(Reader->ReadSourceLocation(Record, Idx));
1948   C->setScheduleKindLoc(Reader->ReadSourceLocation(Record, Idx));
1949   C->setCommaLoc(Reader->ReadSourceLocation(Record, Idx));
1950 }
1951
1952 void OMPClauseReader::VisitOMPOrderedClause(OMPOrderedClause *C) {
1953   C->setNumForLoops(Reader->Reader.ReadSubExpr());
1954   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
1955 }
1956
1957 void OMPClauseReader::VisitOMPNowaitClause(OMPNowaitClause *) {}
1958
1959 void OMPClauseReader::VisitOMPUntiedClause(OMPUntiedClause *) {}
1960
1961 void OMPClauseReader::VisitOMPMergeableClause(OMPMergeableClause *) {}
1962
1963 void OMPClauseReader::VisitOMPReadClause(OMPReadClause *) {}
1964
1965 void OMPClauseReader::VisitOMPWriteClause(OMPWriteClause *) {}
1966
1967 void OMPClauseReader::VisitOMPUpdateClause(OMPUpdateClause *) {}
1968
1969 void OMPClauseReader::VisitOMPCaptureClause(OMPCaptureClause *) {}
1970
1971 void OMPClauseReader::VisitOMPSeqCstClause(OMPSeqCstClause *) {}
1972
1973 void OMPClauseReader::VisitOMPThreadsClause(OMPThreadsClause *) {}
1974
1975 void OMPClauseReader::VisitOMPSIMDClause(OMPSIMDClause *) {}
1976
1977 void OMPClauseReader::VisitOMPNogroupClause(OMPNogroupClause *) {}
1978
1979 void OMPClauseReader::VisitOMPPrivateClause(OMPPrivateClause *C) {
1980   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
1981   unsigned NumVars = C->varlist_size();
1982   SmallVector<Expr *, 16> Vars;
1983   Vars.reserve(NumVars);
1984   for (unsigned i = 0; i != NumVars; ++i)
1985     Vars.push_back(Reader->Reader.ReadSubExpr());
1986   C->setVarRefs(Vars);
1987   Vars.clear();
1988   for (unsigned i = 0; i != NumVars; ++i)
1989     Vars.push_back(Reader->Reader.ReadSubExpr());
1990   C->setPrivateCopies(Vars);
1991 }
1992
1993 void OMPClauseReader::VisitOMPFirstprivateClause(OMPFirstprivateClause *C) {
1994   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
1995   unsigned NumVars = C->varlist_size();
1996   SmallVector<Expr *, 16> Vars;
1997   Vars.reserve(NumVars);
1998   for (unsigned i = 0; i != NumVars; ++i)
1999     Vars.push_back(Reader->Reader.ReadSubExpr());
2000   C->setVarRefs(Vars);
2001   Vars.clear();
2002   for (unsigned i = 0; i != NumVars; ++i)
2003     Vars.push_back(Reader->Reader.ReadSubExpr());
2004   C->setPrivateCopies(Vars);
2005   Vars.clear();
2006   for (unsigned i = 0; i != NumVars; ++i)
2007     Vars.push_back(Reader->Reader.ReadSubExpr());
2008   C->setInits(Vars);
2009 }
2010
2011 void OMPClauseReader::VisitOMPLastprivateClause(OMPLastprivateClause *C) {
2012   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
2013   unsigned NumVars = C->varlist_size();
2014   SmallVector<Expr *, 16> Vars;
2015   Vars.reserve(NumVars);
2016   for (unsigned i = 0; i != NumVars; ++i)
2017     Vars.push_back(Reader->Reader.ReadSubExpr());
2018   C->setVarRefs(Vars);
2019   Vars.clear();
2020   for (unsigned i = 0; i != NumVars; ++i)
2021     Vars.push_back(Reader->Reader.ReadSubExpr());
2022   C->setPrivateCopies(Vars);
2023   Vars.clear();
2024   for (unsigned i = 0; i != NumVars; ++i)
2025     Vars.push_back(Reader->Reader.ReadSubExpr());
2026   C->setSourceExprs(Vars);
2027   Vars.clear();
2028   for (unsigned i = 0; i != NumVars; ++i)
2029     Vars.push_back(Reader->Reader.ReadSubExpr());
2030   C->setDestinationExprs(Vars);
2031   Vars.clear();
2032   for (unsigned i = 0; i != NumVars; ++i)
2033     Vars.push_back(Reader->Reader.ReadSubExpr());
2034   C->setAssignmentOps(Vars);
2035 }
2036
2037 void OMPClauseReader::VisitOMPSharedClause(OMPSharedClause *C) {
2038   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
2039   unsigned NumVars = C->varlist_size();
2040   SmallVector<Expr *, 16> Vars;
2041   Vars.reserve(NumVars);
2042   for (unsigned i = 0; i != NumVars; ++i)
2043     Vars.push_back(Reader->Reader.ReadSubExpr());
2044   C->setVarRefs(Vars);
2045 }
2046
2047 void OMPClauseReader::VisitOMPReductionClause(OMPReductionClause *C) {
2048   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
2049   C->setColonLoc(Reader->ReadSourceLocation(Record, Idx));
2050   NestedNameSpecifierLoc NNSL =
2051     Reader->Reader.ReadNestedNameSpecifierLoc(Reader->F, Record, Idx);
2052   DeclarationNameInfo DNI;
2053   Reader->ReadDeclarationNameInfo(DNI, Record, Idx);
2054   C->setQualifierLoc(NNSL);
2055   C->setNameInfo(DNI);
2056
2057   unsigned NumVars = C->varlist_size();
2058   SmallVector<Expr *, 16> Vars;
2059   Vars.reserve(NumVars);
2060   for (unsigned i = 0; i != NumVars; ++i)
2061     Vars.push_back(Reader->Reader.ReadSubExpr());
2062   C->setVarRefs(Vars);
2063   Vars.clear();
2064   for (unsigned i = 0; i != NumVars; ++i)
2065     Vars.push_back(Reader->Reader.ReadSubExpr());
2066   C->setPrivates(Vars);
2067   Vars.clear();
2068   for (unsigned i = 0; i != NumVars; ++i)
2069     Vars.push_back(Reader->Reader.ReadSubExpr());
2070   C->setLHSExprs(Vars);
2071   Vars.clear();
2072   for (unsigned i = 0; i != NumVars; ++i)
2073     Vars.push_back(Reader->Reader.ReadSubExpr());
2074   C->setRHSExprs(Vars);
2075   Vars.clear();
2076   for (unsigned i = 0; i != NumVars; ++i)
2077     Vars.push_back(Reader->Reader.ReadSubExpr());
2078   C->setReductionOps(Vars);
2079 }
2080
2081 void OMPClauseReader::VisitOMPLinearClause(OMPLinearClause *C) {
2082   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
2083   C->setColonLoc(Reader->ReadSourceLocation(Record, Idx));
2084   C->setModifier(static_cast<OpenMPLinearClauseKind>(Record[Idx++]));
2085   C->setModifierLoc(Reader->ReadSourceLocation(Record, Idx));
2086   unsigned NumVars = C->varlist_size();
2087   SmallVector<Expr *, 16> Vars;
2088   Vars.reserve(NumVars);
2089   for (unsigned i = 0; i != NumVars; ++i)
2090     Vars.push_back(Reader->Reader.ReadSubExpr());
2091   C->setVarRefs(Vars);
2092   Vars.clear();
2093   for (unsigned i = 0; i != NumVars; ++i)
2094     Vars.push_back(Reader->Reader.ReadSubExpr());
2095   C->setPrivates(Vars);
2096   Vars.clear();
2097   for (unsigned i = 0; i != NumVars; ++i)
2098     Vars.push_back(Reader->Reader.ReadSubExpr());
2099   C->setInits(Vars);
2100   Vars.clear();
2101   for (unsigned i = 0; i != NumVars; ++i)
2102     Vars.push_back(Reader->Reader.ReadSubExpr());
2103   C->setUpdates(Vars);
2104   Vars.clear();
2105   for (unsigned i = 0; i != NumVars; ++i)
2106     Vars.push_back(Reader->Reader.ReadSubExpr());
2107   C->setFinals(Vars);
2108   C->setStep(Reader->Reader.ReadSubExpr());
2109   C->setCalcStep(Reader->Reader.ReadSubExpr());
2110 }
2111
2112 void OMPClauseReader::VisitOMPAlignedClause(OMPAlignedClause *C) {
2113   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
2114   C->setColonLoc(Reader->ReadSourceLocation(Record, Idx));
2115   unsigned NumVars = C->varlist_size();
2116   SmallVector<Expr *, 16> Vars;
2117   Vars.reserve(NumVars);
2118   for (unsigned i = 0; i != NumVars; ++i)
2119     Vars.push_back(Reader->Reader.ReadSubExpr());
2120   C->setVarRefs(Vars);
2121   C->setAlignment(Reader->Reader.ReadSubExpr());
2122 }
2123
2124 void OMPClauseReader::VisitOMPCopyinClause(OMPCopyinClause *C) {
2125   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
2126   unsigned NumVars = C->varlist_size();
2127   SmallVector<Expr *, 16> Exprs;
2128   Exprs.reserve(NumVars);
2129   for (unsigned i = 0; i != NumVars; ++i)
2130     Exprs.push_back(Reader->Reader.ReadSubExpr());
2131   C->setVarRefs(Exprs);
2132   Exprs.clear();
2133   for (unsigned i = 0; i != NumVars; ++i)
2134     Exprs.push_back(Reader->Reader.ReadSubExpr());
2135   C->setSourceExprs(Exprs);
2136   Exprs.clear();
2137   for (unsigned i = 0; i != NumVars; ++i)
2138     Exprs.push_back(Reader->Reader.ReadSubExpr());
2139   C->setDestinationExprs(Exprs);
2140   Exprs.clear();
2141   for (unsigned i = 0; i != NumVars; ++i)
2142     Exprs.push_back(Reader->Reader.ReadSubExpr());
2143   C->setAssignmentOps(Exprs);
2144 }
2145
2146 void OMPClauseReader::VisitOMPCopyprivateClause(OMPCopyprivateClause *C) {
2147   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
2148   unsigned NumVars = C->varlist_size();
2149   SmallVector<Expr *, 16> Exprs;
2150   Exprs.reserve(NumVars);
2151   for (unsigned i = 0; i != NumVars; ++i)
2152     Exprs.push_back(Reader->Reader.ReadSubExpr());
2153   C->setVarRefs(Exprs);
2154   Exprs.clear();
2155   for (unsigned i = 0; i != NumVars; ++i)
2156     Exprs.push_back(Reader->Reader.ReadSubExpr());
2157   C->setSourceExprs(Exprs);
2158   Exprs.clear();
2159   for (unsigned i = 0; i != NumVars; ++i)
2160     Exprs.push_back(Reader->Reader.ReadSubExpr());
2161   C->setDestinationExprs(Exprs);
2162   Exprs.clear();
2163   for (unsigned i = 0; i != NumVars; ++i)
2164     Exprs.push_back(Reader->Reader.ReadSubExpr());
2165   C->setAssignmentOps(Exprs);
2166 }
2167
2168 void OMPClauseReader::VisitOMPFlushClause(OMPFlushClause *C) {
2169   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
2170   unsigned NumVars = C->varlist_size();
2171   SmallVector<Expr *, 16> Vars;
2172   Vars.reserve(NumVars);
2173   for (unsigned i = 0; i != NumVars; ++i)
2174     Vars.push_back(Reader->Reader.ReadSubExpr());
2175   C->setVarRefs(Vars);
2176 }
2177
2178 void OMPClauseReader::VisitOMPDependClause(OMPDependClause *C) {
2179   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
2180   C->setDependencyKind(static_cast<OpenMPDependClauseKind>(Record[Idx++]));
2181   C->setDependencyLoc(Reader->ReadSourceLocation(Record, Idx));
2182   C->setColonLoc(Reader->ReadSourceLocation(Record, Idx));
2183   unsigned NumVars = C->varlist_size();
2184   SmallVector<Expr *, 16> Vars;
2185   Vars.reserve(NumVars);
2186   for (unsigned i = 0; i != NumVars; ++i)
2187     Vars.push_back(Reader->Reader.ReadSubExpr());
2188   C->setVarRefs(Vars);
2189 }
2190
2191 void OMPClauseReader::VisitOMPDeviceClause(OMPDeviceClause *C) {
2192   C->setDevice(Reader->Reader.ReadSubExpr());
2193   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
2194 }
2195
2196 void OMPClauseReader::VisitOMPMapClause(OMPMapClause *C) {
2197   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
2198   C->setMapTypeModifier(
2199      static_cast<OpenMPMapClauseKind>(Record[Idx++]));
2200   C->setMapType(
2201      static_cast<OpenMPMapClauseKind>(Record[Idx++]));
2202   C->setMapLoc(Reader->ReadSourceLocation(Record, Idx));
2203   C->setColonLoc(Reader->ReadSourceLocation(Record, Idx));
2204   auto NumVars = C->varlist_size();
2205   SmallVector<Expr *, 16> Vars;
2206   Vars.reserve(NumVars);
2207   for (unsigned i = 0; i != NumVars; ++i) {
2208     Vars.push_back(Reader->Reader.ReadSubExpr());
2209   }
2210   C->setVarRefs(Vars);
2211 }
2212
2213 void OMPClauseReader::VisitOMPNumTeamsClause(OMPNumTeamsClause *C) {
2214   C->setNumTeams(Reader->Reader.ReadSubExpr());
2215   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
2216 }
2217
2218 void OMPClauseReader::VisitOMPThreadLimitClause(OMPThreadLimitClause *C) {
2219   C->setThreadLimit(Reader->Reader.ReadSubExpr());
2220   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
2221 }
2222
2223 void OMPClauseReader::VisitOMPPriorityClause(OMPPriorityClause *C) {
2224   C->setPriority(Reader->Reader.ReadSubExpr());
2225   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
2226 }
2227
2228 void OMPClauseReader::VisitOMPGrainsizeClause(OMPGrainsizeClause *C) {
2229   C->setGrainsize(Reader->Reader.ReadSubExpr());
2230   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
2231 }
2232
2233 void OMPClauseReader::VisitOMPNumTasksClause(OMPNumTasksClause *C) {
2234   C->setNumTasks(Reader->Reader.ReadSubExpr());
2235   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
2236 }
2237
2238 void OMPClauseReader::VisitOMPHintClause(OMPHintClause *C) {
2239   C->setHint(Reader->Reader.ReadSubExpr());
2240   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
2241 }
2242
2243 //===----------------------------------------------------------------------===//
2244 // OpenMP Directives.
2245 //===----------------------------------------------------------------------===//
2246 void ASTStmtReader::VisitOMPExecutableDirective(OMPExecutableDirective *E) {
2247   E->setLocStart(ReadSourceLocation(Record, Idx));
2248   E->setLocEnd(ReadSourceLocation(Record, Idx));
2249   OMPClauseReader ClauseReader(this, Reader.getContext(), Record, Idx);
2250   SmallVector<OMPClause *, 5> Clauses;
2251   for (unsigned i = 0; i < E->getNumClauses(); ++i)
2252     Clauses.push_back(ClauseReader.readClause());
2253   E->setClauses(Clauses);
2254   if (E->hasAssociatedStmt())
2255     E->setAssociatedStmt(Reader.ReadSubStmt());
2256 }
2257
2258 void ASTStmtReader::VisitOMPLoopDirective(OMPLoopDirective *D) {
2259   VisitStmt(D);
2260   // Two fields (NumClauses and CollapsedNum) were read in ReadStmtFromStream.
2261   Idx += 2;
2262   VisitOMPExecutableDirective(D);
2263   D->setIterationVariable(Reader.ReadSubExpr());
2264   D->setLastIteration(Reader.ReadSubExpr());
2265   D->setCalcLastIteration(Reader.ReadSubExpr());
2266   D->setPreCond(Reader.ReadSubExpr());
2267   D->setCond(Reader.ReadSubExpr());
2268   D->setInit(Reader.ReadSubExpr());
2269   D->setInc(Reader.ReadSubExpr());
2270   if (isOpenMPWorksharingDirective(D->getDirectiveKind())) {
2271     D->setIsLastIterVariable(Reader.ReadSubExpr());
2272     D->setLowerBoundVariable(Reader.ReadSubExpr());
2273     D->setUpperBoundVariable(Reader.ReadSubExpr());
2274     D->setStrideVariable(Reader.ReadSubExpr());
2275     D->setEnsureUpperBound(Reader.ReadSubExpr());
2276     D->setNextLowerBound(Reader.ReadSubExpr());
2277     D->setNextUpperBound(Reader.ReadSubExpr());
2278   }
2279   SmallVector<Expr *, 4> Sub;
2280   unsigned CollapsedNum = D->getCollapsedNumber();
2281   Sub.reserve(CollapsedNum);
2282   for (unsigned i = 0; i < CollapsedNum; ++i)
2283     Sub.push_back(Reader.ReadSubExpr());
2284   D->setCounters(Sub);
2285   Sub.clear();
2286   for (unsigned i = 0; i < CollapsedNum; ++i)
2287     Sub.push_back(Reader.ReadSubExpr());
2288   D->setPrivateCounters(Sub);
2289   Sub.clear();
2290   for (unsigned i = 0; i < CollapsedNum; ++i)
2291     Sub.push_back(Reader.ReadSubExpr());
2292   D->setInits(Sub);
2293   Sub.clear();
2294   for (unsigned i = 0; i < CollapsedNum; ++i)
2295     Sub.push_back(Reader.ReadSubExpr());
2296   D->setUpdates(Sub);
2297   Sub.clear();
2298   for (unsigned i = 0; i < CollapsedNum; ++i)
2299     Sub.push_back(Reader.ReadSubExpr());
2300   D->setFinals(Sub);
2301 }
2302
2303 void ASTStmtReader::VisitOMPParallelDirective(OMPParallelDirective *D) {
2304   VisitStmt(D);
2305   // The NumClauses field was read in ReadStmtFromStream.
2306   ++Idx;
2307   VisitOMPExecutableDirective(D);
2308   D->setHasCancel(Record[Idx++]);
2309 }
2310
2311 void ASTStmtReader::VisitOMPSimdDirective(OMPSimdDirective *D) {
2312   VisitOMPLoopDirective(D);
2313 }
2314
2315 void ASTStmtReader::VisitOMPForDirective(OMPForDirective *D) {
2316   VisitOMPLoopDirective(D);
2317   D->setHasCancel(Record[Idx++]);
2318 }
2319
2320 void ASTStmtReader::VisitOMPForSimdDirective(OMPForSimdDirective *D) {
2321   VisitOMPLoopDirective(D);
2322 }
2323
2324 void ASTStmtReader::VisitOMPSectionsDirective(OMPSectionsDirective *D) {
2325   VisitStmt(D);
2326   // The NumClauses field was read in ReadStmtFromStream.
2327   ++Idx;
2328   VisitOMPExecutableDirective(D);
2329   D->setHasCancel(Record[Idx++]);
2330 }
2331
2332 void ASTStmtReader::VisitOMPSectionDirective(OMPSectionDirective *D) {
2333   VisitStmt(D);
2334   VisitOMPExecutableDirective(D);
2335   D->setHasCancel(Record[Idx++]);
2336 }
2337
2338 void ASTStmtReader::VisitOMPSingleDirective(OMPSingleDirective *D) {
2339   VisitStmt(D);
2340   // The NumClauses field was read in ReadStmtFromStream.
2341   ++Idx;
2342   VisitOMPExecutableDirective(D);
2343 }
2344
2345 void ASTStmtReader::VisitOMPMasterDirective(OMPMasterDirective *D) {
2346   VisitStmt(D);
2347   VisitOMPExecutableDirective(D);
2348 }
2349
2350 void ASTStmtReader::VisitOMPCriticalDirective(OMPCriticalDirective *D) {
2351   VisitStmt(D);
2352   // The NumClauses field was read in ReadStmtFromStream.
2353   ++Idx;
2354   VisitOMPExecutableDirective(D);
2355   ReadDeclarationNameInfo(D->DirName, Record, Idx);
2356 }
2357
2358 void ASTStmtReader::VisitOMPParallelForDirective(OMPParallelForDirective *D) {
2359   VisitOMPLoopDirective(D);
2360   D->setHasCancel(Record[Idx++]);
2361 }
2362
2363 void ASTStmtReader::VisitOMPParallelForSimdDirective(
2364     OMPParallelForSimdDirective *D) {
2365   VisitOMPLoopDirective(D);
2366 }
2367
2368 void ASTStmtReader::VisitOMPParallelSectionsDirective(
2369     OMPParallelSectionsDirective *D) {
2370   VisitStmt(D);
2371   // The NumClauses field was read in ReadStmtFromStream.
2372   ++Idx;
2373   VisitOMPExecutableDirective(D);
2374   D->setHasCancel(Record[Idx++]);
2375 }
2376
2377 void ASTStmtReader::VisitOMPTaskDirective(OMPTaskDirective *D) {
2378   VisitStmt(D);
2379   // The NumClauses field was read in ReadStmtFromStream.
2380   ++Idx;
2381   VisitOMPExecutableDirective(D);
2382   D->setHasCancel(Record[Idx++]);
2383 }
2384
2385 void ASTStmtReader::VisitOMPTaskyieldDirective(OMPTaskyieldDirective *D) {
2386   VisitStmt(D);
2387   VisitOMPExecutableDirective(D);
2388 }
2389
2390 void ASTStmtReader::VisitOMPBarrierDirective(OMPBarrierDirective *D) {
2391   VisitStmt(D);
2392   VisitOMPExecutableDirective(D);
2393 }
2394
2395 void ASTStmtReader::VisitOMPTaskwaitDirective(OMPTaskwaitDirective *D) {
2396   VisitStmt(D);
2397   VisitOMPExecutableDirective(D);
2398 }
2399
2400 void ASTStmtReader::VisitOMPTaskgroupDirective(OMPTaskgroupDirective *D) {
2401   VisitStmt(D);
2402   VisitOMPExecutableDirective(D);
2403 }
2404
2405 void ASTStmtReader::VisitOMPFlushDirective(OMPFlushDirective *D) {
2406   VisitStmt(D);
2407   // The NumClauses field was read in ReadStmtFromStream.
2408   ++Idx;
2409   VisitOMPExecutableDirective(D);
2410 }
2411
2412 void ASTStmtReader::VisitOMPOrderedDirective(OMPOrderedDirective *D) {
2413   VisitStmt(D);
2414   // The NumClauses field was read in ReadStmtFromStream.
2415   ++Idx;
2416   VisitOMPExecutableDirective(D);
2417 }
2418
2419 void ASTStmtReader::VisitOMPAtomicDirective(OMPAtomicDirective *D) {
2420   VisitStmt(D);
2421   // The NumClauses field was read in ReadStmtFromStream.
2422   ++Idx;
2423   VisitOMPExecutableDirective(D);
2424   D->setX(Reader.ReadSubExpr());
2425   D->setV(Reader.ReadSubExpr());
2426   D->setExpr(Reader.ReadSubExpr());
2427   D->setUpdateExpr(Reader.ReadSubExpr());
2428   D->IsXLHSInRHSPart = Record[Idx++] != 0;
2429   D->IsPostfixUpdate = Record[Idx++] != 0;
2430 }
2431
2432 void ASTStmtReader::VisitOMPTargetDirective(OMPTargetDirective *D) {
2433   VisitStmt(D);
2434   // The NumClauses field was read in ReadStmtFromStream.
2435   ++Idx;
2436   VisitOMPExecutableDirective(D);
2437 }
2438
2439 void ASTStmtReader::VisitOMPTargetDataDirective(OMPTargetDataDirective *D) {
2440   VisitStmt(D);
2441   ++Idx;
2442   VisitOMPExecutableDirective(D);
2443 }
2444
2445 void ASTStmtReader::VisitOMPTeamsDirective(OMPTeamsDirective *D) {
2446   VisitStmt(D);
2447   // The NumClauses field was read in ReadStmtFromStream.
2448   ++Idx;
2449   VisitOMPExecutableDirective(D);
2450 }
2451
2452 void ASTStmtReader::VisitOMPCancellationPointDirective(
2453     OMPCancellationPointDirective *D) {
2454   VisitStmt(D);
2455   VisitOMPExecutableDirective(D);
2456   D->setCancelRegion(static_cast<OpenMPDirectiveKind>(Record[Idx++]));
2457 }
2458
2459 void ASTStmtReader::VisitOMPCancelDirective(OMPCancelDirective *D) {
2460   VisitStmt(D);
2461   // The NumClauses field was read in ReadStmtFromStream.
2462   ++Idx;
2463   VisitOMPExecutableDirective(D);
2464   D->setCancelRegion(static_cast<OpenMPDirectiveKind>(Record[Idx++]));
2465 }
2466
2467 void ASTStmtReader::VisitOMPTaskLoopDirective(OMPTaskLoopDirective *D) {
2468   VisitOMPLoopDirective(D);
2469 }
2470
2471 void ASTStmtReader::VisitOMPTaskLoopSimdDirective(OMPTaskLoopSimdDirective *D) {
2472   VisitOMPLoopDirective(D);
2473 }
2474
2475 void ASTStmtReader::VisitOMPDistributeDirective(OMPDistributeDirective *D) {
2476   VisitOMPLoopDirective(D);
2477 }
2478
2479 //===----------------------------------------------------------------------===//
2480 // ASTReader Implementation
2481 //===----------------------------------------------------------------------===//
2482
2483 Stmt *ASTReader::ReadStmt(ModuleFile &F) {
2484   switch (ReadingKind) {
2485   case Read_None:
2486     llvm_unreachable("should not call this when not reading anything");
2487   case Read_Decl:
2488   case Read_Type:
2489     return ReadStmtFromStream(F);
2490   case Read_Stmt:
2491     return ReadSubStmt();
2492   }
2493
2494   llvm_unreachable("ReadingKind not set ?");
2495 }
2496
2497 Expr *ASTReader::ReadExpr(ModuleFile &F) {
2498   return cast_or_null<Expr>(ReadStmt(F));
2499 }
2500
2501 Expr *ASTReader::ReadSubExpr() {
2502   return cast_or_null<Expr>(ReadSubStmt());
2503 }
2504
2505 // Within the bitstream, expressions are stored in Reverse Polish
2506 // Notation, with each of the subexpressions preceding the
2507 // expression they are stored in. Subexpressions are stored from last to first.
2508 // To evaluate expressions, we continue reading expressions and placing them on
2509 // the stack, with expressions having operands removing those operands from the
2510 // stack. Evaluation terminates when we see a STMT_STOP record, and
2511 // the single remaining expression on the stack is our result.
2512 Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) {
2513
2514   ReadingKindTracker ReadingKind(Read_Stmt, *this);
2515   llvm::BitstreamCursor &Cursor = F.DeclsCursor;
2516
2517   // Map of offset to previously deserialized stmt. The offset points
2518   /// just after the stmt record.
2519   llvm::DenseMap<uint64_t, Stmt *> StmtEntries;
2520
2521 #ifndef NDEBUG
2522   unsigned PrevNumStmts = StmtStack.size();
2523 #endif
2524
2525   RecordData Record;
2526   unsigned Idx;
2527   ASTStmtReader Reader(*this, F, Cursor, Record, Idx);
2528   Stmt::EmptyShell Empty;
2529
2530   while (true) {
2531     llvm::BitstreamEntry Entry = Cursor.advanceSkippingSubblocks();
2532
2533     switch (Entry.Kind) {
2534     case llvm::BitstreamEntry::SubBlock: // Handled for us already.
2535     case llvm::BitstreamEntry::Error:
2536       Error("malformed block record in AST file");
2537       return nullptr;
2538     case llvm::BitstreamEntry::EndBlock:
2539       goto Done;
2540     case llvm::BitstreamEntry::Record:
2541       // The interesting case.
2542       break;
2543     }
2544
2545     Stmt *S = nullptr;
2546     Idx = 0;
2547     Record.clear();
2548     bool Finished = false;
2549     bool IsStmtReference = false;
2550     switch ((StmtCode)Cursor.readRecord(Entry.ID, Record)) {
2551     case STMT_STOP:
2552       Finished = true;
2553       break;
2554
2555     case STMT_REF_PTR:
2556       IsStmtReference = true;
2557       assert(StmtEntries.find(Record[0]) != StmtEntries.end() &&
2558              "No stmt was recorded for this offset reference!");
2559       S = StmtEntries[Record[Idx++]];
2560       break;
2561
2562     case STMT_NULL_PTR:
2563       S = nullptr;
2564       break;
2565
2566     case STMT_NULL:
2567       S = new (Context) NullStmt(Empty);
2568       break;
2569
2570     case STMT_COMPOUND:
2571       S = new (Context) CompoundStmt(Empty);
2572       break;
2573
2574     case STMT_CASE:
2575       S = new (Context) CaseStmt(Empty);
2576       break;
2577
2578     case STMT_DEFAULT:
2579       S = new (Context) DefaultStmt(Empty);
2580       break;
2581
2582     case STMT_LABEL:
2583       S = new (Context) LabelStmt(Empty);
2584       break;
2585
2586     case STMT_ATTRIBUTED:
2587       S = AttributedStmt::CreateEmpty(
2588         Context,
2589         /*NumAttrs*/Record[ASTStmtReader::NumStmtFields]);
2590       break;
2591
2592     case STMT_IF:
2593       S = new (Context) IfStmt(Empty);
2594       break;
2595
2596     case STMT_SWITCH:
2597       S = new (Context) SwitchStmt(Empty);
2598       break;
2599
2600     case STMT_WHILE:
2601       S = new (Context) WhileStmt(Empty);
2602       break;
2603
2604     case STMT_DO:
2605       S = new (Context) DoStmt(Empty);
2606       break;
2607
2608     case STMT_FOR:
2609       S = new (Context) ForStmt(Empty);
2610       break;
2611
2612     case STMT_GOTO:
2613       S = new (Context) GotoStmt(Empty);
2614       break;
2615
2616     case STMT_INDIRECT_GOTO:
2617       S = new (Context) IndirectGotoStmt(Empty);
2618       break;
2619
2620     case STMT_CONTINUE:
2621       S = new (Context) ContinueStmt(Empty);
2622       break;
2623
2624     case STMT_BREAK:
2625       S = new (Context) BreakStmt(Empty);
2626       break;
2627
2628     case STMT_RETURN:
2629       S = new (Context) ReturnStmt(Empty);
2630       break;
2631
2632     case STMT_DECL:
2633       S = new (Context) DeclStmt(Empty);
2634       break;
2635
2636     case STMT_GCCASM:
2637       S = new (Context) GCCAsmStmt(Empty);
2638       break;
2639
2640     case STMT_MSASM:
2641       S = new (Context) MSAsmStmt(Empty);
2642       break;
2643
2644     case STMT_CAPTURED:
2645       S = CapturedStmt::CreateDeserialized(Context,
2646                                            Record[ASTStmtReader::NumStmtFields]);
2647       break;
2648
2649     case EXPR_PREDEFINED:
2650       S = new (Context) PredefinedExpr(Empty);
2651       break;
2652
2653     case EXPR_DECL_REF:
2654       S = DeclRefExpr::CreateEmpty(
2655         Context,
2656         /*HasQualifier=*/Record[ASTStmtReader::NumExprFields],
2657         /*HasFoundDecl=*/Record[ASTStmtReader::NumExprFields + 1],
2658         /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields + 2],
2659         /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields + 2] ?
2660           Record[ASTStmtReader::NumExprFields + 5] : 0);
2661       break;
2662
2663     case EXPR_INTEGER_LITERAL:
2664       S = IntegerLiteral::Create(Context, Empty);
2665       break;
2666
2667     case EXPR_FLOATING_LITERAL:
2668       S = FloatingLiteral::Create(Context, Empty);
2669       break;
2670
2671     case EXPR_IMAGINARY_LITERAL:
2672       S = new (Context) ImaginaryLiteral(Empty);
2673       break;
2674
2675     case EXPR_STRING_LITERAL:
2676       S = StringLiteral::CreateEmpty(Context,
2677                                      Record[ASTStmtReader::NumExprFields + 1]);
2678       break;
2679
2680     case EXPR_CHARACTER_LITERAL:
2681       S = new (Context) CharacterLiteral(Empty);
2682       break;
2683
2684     case EXPR_PAREN:
2685       S = new (Context) ParenExpr(Empty);
2686       break;
2687
2688     case EXPR_PAREN_LIST:
2689       S = new (Context) ParenListExpr(Empty);
2690       break;
2691
2692     case EXPR_UNARY_OPERATOR:
2693       S = new (Context) UnaryOperator(Empty);
2694       break;
2695
2696     case EXPR_OFFSETOF:
2697       S = OffsetOfExpr::CreateEmpty(Context,
2698                                     Record[ASTStmtReader::NumExprFields],
2699                                     Record[ASTStmtReader::NumExprFields + 1]);
2700       break;
2701
2702     case EXPR_SIZEOF_ALIGN_OF:
2703       S = new (Context) UnaryExprOrTypeTraitExpr(Empty);
2704       break;
2705
2706     case EXPR_ARRAY_SUBSCRIPT:
2707       S = new (Context) ArraySubscriptExpr(Empty);
2708       break;
2709
2710     case EXPR_OMP_ARRAY_SECTION:
2711       S = new (Context) OMPArraySectionExpr(Empty);
2712       break;
2713
2714     case EXPR_CALL:
2715       S = new (Context) CallExpr(Context, Stmt::CallExprClass, Empty);
2716       break;
2717
2718     case EXPR_MEMBER: {
2719       // We load everything here and fully initialize it at creation.
2720       // That way we can use MemberExpr::Create and don't have to duplicate its
2721       // logic with a MemberExpr::CreateEmpty.
2722
2723       assert(Idx == 0);
2724       NestedNameSpecifierLoc QualifierLoc;
2725       if (Record[Idx++]) { // HasQualifier.
2726         QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, Idx);
2727       }
2728
2729       SourceLocation TemplateKWLoc;
2730       TemplateArgumentListInfo ArgInfo;
2731       bool HasTemplateKWAndArgsInfo = Record[Idx++];
2732       if (HasTemplateKWAndArgsInfo) {
2733         TemplateKWLoc = ReadSourceLocation(F, Record, Idx);
2734         unsigned NumTemplateArgs = Record[Idx++];
2735         ArgInfo.setLAngleLoc(ReadSourceLocation(F, Record, Idx));
2736         ArgInfo.setRAngleLoc(ReadSourceLocation(F, Record, Idx));
2737         for (unsigned i = 0; i != NumTemplateArgs; ++i)
2738           ArgInfo.addArgument(ReadTemplateArgumentLoc(F, Record, Idx));
2739       }
2740
2741       bool HadMultipleCandidates = Record[Idx++];
2742
2743       NamedDecl *FoundD = ReadDeclAs<NamedDecl>(F, Record, Idx);
2744       AccessSpecifier AS = (AccessSpecifier)Record[Idx++];
2745       DeclAccessPair FoundDecl = DeclAccessPair::make(FoundD, AS);
2746
2747       QualType T = readType(F, Record, Idx);
2748       ExprValueKind VK = static_cast<ExprValueKind>(Record[Idx++]);
2749       ExprObjectKind OK = static_cast<ExprObjectKind>(Record[Idx++]);
2750       Expr *Base = ReadSubExpr();
2751       ValueDecl *MemberD = ReadDeclAs<ValueDecl>(F, Record, Idx);
2752       SourceLocation MemberLoc = ReadSourceLocation(F, Record, Idx);
2753       DeclarationNameInfo MemberNameInfo(MemberD->getDeclName(), MemberLoc);
2754       bool IsArrow = Record[Idx++];
2755       SourceLocation OperatorLoc = ReadSourceLocation(F, Record, Idx);
2756
2757       S = MemberExpr::Create(Context, Base, IsArrow, OperatorLoc, QualifierLoc,
2758                              TemplateKWLoc, MemberD, FoundDecl, MemberNameInfo,
2759                              HasTemplateKWAndArgsInfo ? &ArgInfo : nullptr, T,
2760                              VK, OK);
2761       ReadDeclarationNameLoc(F, cast<MemberExpr>(S)->MemberDNLoc,
2762                              MemberD->getDeclName(), Record, Idx);
2763       if (HadMultipleCandidates)
2764         cast<MemberExpr>(S)->setHadMultipleCandidates(true);
2765       break;
2766     }
2767
2768     case EXPR_BINARY_OPERATOR:
2769       S = new (Context) BinaryOperator(Empty);
2770       break;
2771
2772     case EXPR_COMPOUND_ASSIGN_OPERATOR:
2773       S = new (Context) CompoundAssignOperator(Empty);
2774       break;
2775
2776     case EXPR_CONDITIONAL_OPERATOR:
2777       S = new (Context) ConditionalOperator(Empty);
2778       break;
2779
2780     case EXPR_BINARY_CONDITIONAL_OPERATOR:
2781       S = new (Context) BinaryConditionalOperator(Empty);
2782       break;
2783
2784     case EXPR_IMPLICIT_CAST:
2785       S = ImplicitCastExpr::CreateEmpty(Context,
2786                        /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
2787       break;
2788
2789     case EXPR_CSTYLE_CAST:
2790       S = CStyleCastExpr::CreateEmpty(Context,
2791                        /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
2792       break;
2793
2794     case EXPR_COMPOUND_LITERAL:
2795       S = new (Context) CompoundLiteralExpr(Empty);
2796       break;
2797
2798     case EXPR_EXT_VECTOR_ELEMENT:
2799       S = new (Context) ExtVectorElementExpr(Empty);
2800       break;
2801
2802     case EXPR_INIT_LIST:
2803       S = new (Context) InitListExpr(Empty);
2804       break;
2805
2806     case EXPR_DESIGNATED_INIT:
2807       S = DesignatedInitExpr::CreateEmpty(Context,
2808                                      Record[ASTStmtReader::NumExprFields] - 1);
2809
2810       break;
2811
2812     case EXPR_DESIGNATED_INIT_UPDATE:
2813       S = new (Context) DesignatedInitUpdateExpr(Empty);
2814       break;
2815
2816     case EXPR_IMPLICIT_VALUE_INIT:
2817       S = new (Context) ImplicitValueInitExpr(Empty);
2818       break;
2819
2820     case EXPR_NO_INIT:
2821       S = new (Context) NoInitExpr(Empty);
2822       break;
2823
2824     case EXPR_VA_ARG:
2825       S = new (Context) VAArgExpr(Empty);
2826       break;
2827
2828     case EXPR_ADDR_LABEL:
2829       S = new (Context) AddrLabelExpr(Empty);
2830       break;
2831
2832     case EXPR_STMT:
2833       S = new (Context) StmtExpr(Empty);
2834       break;
2835
2836     case EXPR_CHOOSE:
2837       S = new (Context) ChooseExpr(Empty);
2838       break;
2839
2840     case EXPR_GNU_NULL:
2841       S = new (Context) GNUNullExpr(Empty);
2842       break;
2843
2844     case EXPR_SHUFFLE_VECTOR:
2845       S = new (Context) ShuffleVectorExpr(Empty);
2846       break;
2847
2848     case EXPR_CONVERT_VECTOR:
2849       S = new (Context) ConvertVectorExpr(Empty);
2850       break;
2851
2852     case EXPR_BLOCK:
2853       S = new (Context) BlockExpr(Empty);
2854       break;
2855
2856     case EXPR_GENERIC_SELECTION:
2857       S = new (Context) GenericSelectionExpr(Empty);
2858       break;
2859
2860     case EXPR_OBJC_STRING_LITERAL:
2861       S = new (Context) ObjCStringLiteral(Empty);
2862       break;
2863     case EXPR_OBJC_BOXED_EXPRESSION:
2864       S = new (Context) ObjCBoxedExpr(Empty);
2865       break;
2866     case EXPR_OBJC_ARRAY_LITERAL:
2867       S = ObjCArrayLiteral::CreateEmpty(Context,
2868                                         Record[ASTStmtReader::NumExprFields]);
2869       break;
2870     case EXPR_OBJC_DICTIONARY_LITERAL:
2871       S = ObjCDictionaryLiteral::CreateEmpty(Context,
2872             Record[ASTStmtReader::NumExprFields],
2873             Record[ASTStmtReader::NumExprFields + 1]);
2874       break;
2875     case EXPR_OBJC_ENCODE:
2876       S = new (Context) ObjCEncodeExpr(Empty);
2877       break;
2878     case EXPR_OBJC_SELECTOR_EXPR:
2879       S = new (Context) ObjCSelectorExpr(Empty);
2880       break;
2881     case EXPR_OBJC_PROTOCOL_EXPR:
2882       S = new (Context) ObjCProtocolExpr(Empty);
2883       break;
2884     case EXPR_OBJC_IVAR_REF_EXPR:
2885       S = new (Context) ObjCIvarRefExpr(Empty);
2886       break;
2887     case EXPR_OBJC_PROPERTY_REF_EXPR:
2888       S = new (Context) ObjCPropertyRefExpr(Empty);
2889       break;
2890     case EXPR_OBJC_SUBSCRIPT_REF_EXPR:
2891       S = new (Context) ObjCSubscriptRefExpr(Empty);
2892       break;
2893     case EXPR_OBJC_KVC_REF_EXPR:
2894       llvm_unreachable("mismatching AST file");
2895     case EXPR_OBJC_MESSAGE_EXPR:
2896       S = ObjCMessageExpr::CreateEmpty(Context,
2897                                      Record[ASTStmtReader::NumExprFields],
2898                                      Record[ASTStmtReader::NumExprFields + 1]);
2899       break;
2900     case EXPR_OBJC_ISA:
2901       S = new (Context) ObjCIsaExpr(Empty);
2902       break;
2903     case EXPR_OBJC_INDIRECT_COPY_RESTORE:
2904       S = new (Context) ObjCIndirectCopyRestoreExpr(Empty);
2905       break;
2906     case EXPR_OBJC_BRIDGED_CAST:
2907       S = new (Context) ObjCBridgedCastExpr(Empty);
2908       break;
2909     case STMT_OBJC_FOR_COLLECTION:
2910       S = new (Context) ObjCForCollectionStmt(Empty);
2911       break;
2912     case STMT_OBJC_CATCH:
2913       S = new (Context) ObjCAtCatchStmt(Empty);
2914       break;
2915     case STMT_OBJC_FINALLY:
2916       S = new (Context) ObjCAtFinallyStmt(Empty);
2917       break;
2918     case STMT_OBJC_AT_TRY:
2919       S = ObjCAtTryStmt::CreateEmpty(Context,
2920                                      Record[ASTStmtReader::NumStmtFields],
2921                                      Record[ASTStmtReader::NumStmtFields + 1]);
2922       break;
2923     case STMT_OBJC_AT_SYNCHRONIZED:
2924       S = new (Context) ObjCAtSynchronizedStmt(Empty);
2925       break;
2926     case STMT_OBJC_AT_THROW:
2927       S = new (Context) ObjCAtThrowStmt(Empty);
2928       break;
2929     case STMT_OBJC_AUTORELEASE_POOL:
2930       S = new (Context) ObjCAutoreleasePoolStmt(Empty);
2931       break;
2932     case EXPR_OBJC_BOOL_LITERAL:
2933       S = new (Context) ObjCBoolLiteralExpr(Empty);
2934       break;
2935     case STMT_SEH_LEAVE:
2936       S = new (Context) SEHLeaveStmt(Empty);
2937       break;
2938     case STMT_SEH_EXCEPT:
2939       S = new (Context) SEHExceptStmt(Empty);
2940       break;
2941     case STMT_SEH_FINALLY:
2942       S = new (Context) SEHFinallyStmt(Empty);
2943       break;
2944     case STMT_SEH_TRY:
2945       S = new (Context) SEHTryStmt(Empty);
2946       break;
2947     case STMT_CXX_CATCH:
2948       S = new (Context) CXXCatchStmt(Empty);
2949       break;
2950
2951     case STMT_CXX_TRY:
2952       S = CXXTryStmt::Create(Context, Empty,
2953              /*NumHandlers=*/Record[ASTStmtReader::NumStmtFields]);
2954       break;
2955
2956     case STMT_CXX_FOR_RANGE:
2957       S = new (Context) CXXForRangeStmt(Empty);
2958       break;
2959
2960     case STMT_MS_DEPENDENT_EXISTS:
2961       S = new (Context) MSDependentExistsStmt(SourceLocation(), true,
2962                                               NestedNameSpecifierLoc(),
2963                                               DeclarationNameInfo(),
2964                                               nullptr);
2965       break;
2966
2967     case STMT_OMP_PARALLEL_DIRECTIVE:
2968       S =
2969         OMPParallelDirective::CreateEmpty(Context,
2970                                           Record[ASTStmtReader::NumStmtFields],
2971                                           Empty);
2972       break;
2973
2974     case STMT_OMP_SIMD_DIRECTIVE: {
2975       unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
2976       unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
2977       S = OMPSimdDirective::CreateEmpty(Context, NumClauses,
2978                                         CollapsedNum, Empty);
2979       break;
2980     }
2981
2982     case STMT_OMP_FOR_DIRECTIVE: {
2983       unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
2984       unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
2985       S = OMPForDirective::CreateEmpty(Context, NumClauses, CollapsedNum,
2986                                        Empty);
2987       break;
2988     }
2989
2990     case STMT_OMP_FOR_SIMD_DIRECTIVE: {
2991       unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
2992       unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
2993       S = OMPForSimdDirective::CreateEmpty(Context, NumClauses, CollapsedNum,
2994                                            Empty);
2995       break;
2996     }
2997
2998     case STMT_OMP_SECTIONS_DIRECTIVE:
2999       S = OMPSectionsDirective::CreateEmpty(
3000           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3001       break;
3002
3003     case STMT_OMP_SECTION_DIRECTIVE:
3004       S = OMPSectionDirective::CreateEmpty(Context, Empty);
3005       break;
3006
3007     case STMT_OMP_SINGLE_DIRECTIVE:
3008       S = OMPSingleDirective::CreateEmpty(
3009           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3010       break;
3011
3012     case STMT_OMP_MASTER_DIRECTIVE:
3013       S = OMPMasterDirective::CreateEmpty(Context, Empty);
3014       break;
3015
3016     case STMT_OMP_CRITICAL_DIRECTIVE:
3017       S = OMPCriticalDirective::CreateEmpty(
3018           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3019       break;
3020
3021     case STMT_OMP_PARALLEL_FOR_DIRECTIVE: {
3022       unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3023       unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3024       S = OMPParallelForDirective::CreateEmpty(Context, NumClauses,
3025                                                CollapsedNum, Empty);
3026       break;
3027     }
3028
3029     case STMT_OMP_PARALLEL_FOR_SIMD_DIRECTIVE: {
3030       unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3031       unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3032       S = OMPParallelForSimdDirective::CreateEmpty(Context, NumClauses,
3033                                                    CollapsedNum, Empty);
3034       break;
3035     }
3036
3037     case STMT_OMP_PARALLEL_SECTIONS_DIRECTIVE:
3038       S = OMPParallelSectionsDirective::CreateEmpty(
3039           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3040       break;
3041
3042     case STMT_OMP_TASK_DIRECTIVE:
3043       S = OMPTaskDirective::CreateEmpty(
3044           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3045       break;
3046
3047     case STMT_OMP_TASKYIELD_DIRECTIVE:
3048       S = OMPTaskyieldDirective::CreateEmpty(Context, Empty);
3049       break;
3050
3051     case STMT_OMP_BARRIER_DIRECTIVE:
3052       S = OMPBarrierDirective::CreateEmpty(Context, Empty);
3053       break;
3054
3055     case STMT_OMP_TASKWAIT_DIRECTIVE:
3056       S = OMPTaskwaitDirective::CreateEmpty(Context, Empty);
3057       break;
3058
3059     case STMT_OMP_TASKGROUP_DIRECTIVE:
3060       S = OMPTaskgroupDirective::CreateEmpty(Context, Empty);
3061       break;
3062
3063     case STMT_OMP_FLUSH_DIRECTIVE:
3064       S = OMPFlushDirective::CreateEmpty(
3065           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3066       break;
3067
3068     case STMT_OMP_ORDERED_DIRECTIVE:
3069       S = OMPOrderedDirective::CreateEmpty(
3070           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3071       break;
3072
3073     case STMT_OMP_ATOMIC_DIRECTIVE:
3074       S = OMPAtomicDirective::CreateEmpty(
3075           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3076       break;
3077
3078     case STMT_OMP_TARGET_DIRECTIVE:
3079       S = OMPTargetDirective::CreateEmpty(
3080           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3081       break;
3082
3083     case STMT_OMP_TARGET_DATA_DIRECTIVE:
3084       S = OMPTargetDataDirective::CreateEmpty(
3085           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3086       break;
3087
3088     case STMT_OMP_TEAMS_DIRECTIVE:
3089       S = OMPTeamsDirective::CreateEmpty(
3090           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3091       break;
3092
3093     case STMT_OMP_CANCELLATION_POINT_DIRECTIVE:
3094       S = OMPCancellationPointDirective::CreateEmpty(Context, Empty);
3095       break;
3096
3097     case STMT_OMP_CANCEL_DIRECTIVE:
3098       S = OMPCancelDirective::CreateEmpty(
3099           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3100       break;
3101
3102     case STMT_OMP_TASKLOOP_DIRECTIVE: {
3103       unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3104       unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3105       S = OMPTaskLoopDirective::CreateEmpty(Context, NumClauses, CollapsedNum,
3106                                             Empty);
3107       break;
3108     }
3109
3110     case STMT_OMP_TASKLOOP_SIMD_DIRECTIVE: {
3111       unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3112       unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3113       S = OMPTaskLoopSimdDirective::CreateEmpty(Context, NumClauses,
3114                                                 CollapsedNum, Empty);
3115       break;
3116     }
3117
3118     case STMT_OMP_DISTRIBUTE_DIRECTIVE: {
3119       unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3120       unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3121       S = OMPDistributeDirective::CreateEmpty(Context, NumClauses, CollapsedNum,
3122                                               Empty);
3123       break;
3124     }
3125
3126     case EXPR_CXX_OPERATOR_CALL:
3127       S = new (Context) CXXOperatorCallExpr(Context, Empty);
3128       break;
3129
3130     case EXPR_CXX_MEMBER_CALL:
3131       S = new (Context) CXXMemberCallExpr(Context, Empty);
3132       break;
3133
3134     case EXPR_CXX_CONSTRUCT:
3135       S = new (Context) CXXConstructExpr(Empty);
3136       break;
3137
3138     case EXPR_CXX_TEMPORARY_OBJECT:
3139       S = new (Context) CXXTemporaryObjectExpr(Empty);
3140       break;
3141
3142     case EXPR_CXX_STATIC_CAST:
3143       S = CXXStaticCastExpr::CreateEmpty(Context,
3144                        /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
3145       break;
3146
3147     case EXPR_CXX_DYNAMIC_CAST:
3148       S = CXXDynamicCastExpr::CreateEmpty(Context,
3149                        /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
3150       break;
3151
3152     case EXPR_CXX_REINTERPRET_CAST:
3153       S = CXXReinterpretCastExpr::CreateEmpty(Context,
3154                        /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
3155       break;
3156
3157     case EXPR_CXX_CONST_CAST:
3158       S = CXXConstCastExpr::CreateEmpty(Context);
3159       break;
3160
3161     case EXPR_CXX_FUNCTIONAL_CAST:
3162       S = CXXFunctionalCastExpr::CreateEmpty(Context,
3163                        /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
3164       break;
3165
3166     case EXPR_USER_DEFINED_LITERAL:
3167       S = new (Context) UserDefinedLiteral(Context, Empty);
3168       break;
3169
3170     case EXPR_CXX_STD_INITIALIZER_LIST:
3171       S = new (Context) CXXStdInitializerListExpr(Empty);
3172       break;
3173
3174     case EXPR_CXX_BOOL_LITERAL:
3175       S = new (Context) CXXBoolLiteralExpr(Empty);
3176       break;
3177
3178     case EXPR_CXX_NULL_PTR_LITERAL:
3179       S = new (Context) CXXNullPtrLiteralExpr(Empty);
3180       break;
3181     case EXPR_CXX_TYPEID_EXPR:
3182       S = new (Context) CXXTypeidExpr(Empty, true);
3183       break;
3184     case EXPR_CXX_TYPEID_TYPE:
3185       S = new (Context) CXXTypeidExpr(Empty, false);
3186       break;
3187     case EXPR_CXX_UUIDOF_EXPR:
3188       S = new (Context) CXXUuidofExpr(Empty, true);
3189       break;
3190     case EXPR_CXX_PROPERTY_REF_EXPR:
3191       S = new (Context) MSPropertyRefExpr(Empty);
3192       break;
3193     case EXPR_CXX_PROPERTY_SUBSCRIPT_EXPR:
3194       S = new (Context) MSPropertySubscriptExpr(Empty);
3195       break;
3196     case EXPR_CXX_UUIDOF_TYPE:
3197       S = new (Context) CXXUuidofExpr(Empty, false);
3198       break;
3199     case EXPR_CXX_THIS:
3200       S = new (Context) CXXThisExpr(Empty);
3201       break;
3202     case EXPR_CXX_THROW:
3203       S = new (Context) CXXThrowExpr(Empty);
3204       break;
3205     case EXPR_CXX_DEFAULT_ARG: {
3206       bool HasOtherExprStored = Record[ASTStmtReader::NumExprFields];
3207       if (HasOtherExprStored) {
3208         Expr *SubExpr = ReadSubExpr();
3209         S = CXXDefaultArgExpr::Create(Context, SourceLocation(), nullptr,
3210                                       SubExpr);
3211       } else
3212         S = new (Context) CXXDefaultArgExpr(Empty);
3213       break;
3214     }
3215     case EXPR_CXX_DEFAULT_INIT:
3216       S = new (Context) CXXDefaultInitExpr(Empty);
3217       break;
3218     case EXPR_CXX_BIND_TEMPORARY:
3219       S = new (Context) CXXBindTemporaryExpr(Empty);
3220       break;
3221
3222     case EXPR_CXX_SCALAR_VALUE_INIT:
3223       S = new (Context) CXXScalarValueInitExpr(Empty);
3224       break;
3225     case EXPR_CXX_NEW:
3226       S = new (Context) CXXNewExpr(Empty);
3227       break;
3228     case EXPR_CXX_DELETE:
3229       S = new (Context) CXXDeleteExpr(Empty);
3230       break;
3231     case EXPR_CXX_PSEUDO_DESTRUCTOR:
3232       S = new (Context) CXXPseudoDestructorExpr(Empty);
3233       break;
3234
3235     case EXPR_EXPR_WITH_CLEANUPS:
3236       S = ExprWithCleanups::Create(Context, Empty,
3237                                    Record[ASTStmtReader::NumExprFields]);
3238       break;
3239
3240     case EXPR_CXX_DEPENDENT_SCOPE_MEMBER:
3241       S = CXXDependentScopeMemberExpr::CreateEmpty(Context,
3242          /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields],
3243                   /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]
3244                                    ? Record[ASTStmtReader::NumExprFields + 1]
3245                                    : 0);
3246       break;
3247
3248     case EXPR_CXX_DEPENDENT_SCOPE_DECL_REF:
3249       S = DependentScopeDeclRefExpr::CreateEmpty(Context,
3250          /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields],
3251                   /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]
3252                                    ? Record[ASTStmtReader::NumExprFields + 1]
3253                                    : 0);
3254       break;
3255
3256     case EXPR_CXX_UNRESOLVED_CONSTRUCT:
3257       S = CXXUnresolvedConstructExpr::CreateEmpty(Context,
3258                               /*NumArgs=*/Record[ASTStmtReader::NumExprFields]);
3259       break;
3260
3261     case EXPR_CXX_UNRESOLVED_MEMBER:
3262       S = UnresolvedMemberExpr::CreateEmpty(Context,
3263          /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields],
3264                   /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]
3265                                    ? Record[ASTStmtReader::NumExprFields + 1]
3266                                    : 0);
3267       break;
3268
3269     case EXPR_CXX_UNRESOLVED_LOOKUP:
3270       S = UnresolvedLookupExpr::CreateEmpty(Context,
3271          /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields],
3272                   /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]
3273                                    ? Record[ASTStmtReader::NumExprFields + 1]
3274                                    : 0);
3275       break;
3276
3277     case EXPR_TYPE_TRAIT:
3278       S = TypeTraitExpr::CreateDeserialized(Context,
3279             Record[ASTStmtReader::NumExprFields]);
3280       break;
3281
3282     case EXPR_ARRAY_TYPE_TRAIT:
3283       S = new (Context) ArrayTypeTraitExpr(Empty);
3284       break;
3285
3286     case EXPR_CXX_EXPRESSION_TRAIT:
3287       S = new (Context) ExpressionTraitExpr(Empty);
3288       break;
3289
3290     case EXPR_CXX_NOEXCEPT:
3291       S = new (Context) CXXNoexceptExpr(Empty);
3292       break;
3293
3294     case EXPR_PACK_EXPANSION:
3295       S = new (Context) PackExpansionExpr(Empty);
3296       break;
3297
3298     case EXPR_SIZEOF_PACK:
3299       S = SizeOfPackExpr::CreateDeserialized(
3300               Context,
3301               /*NumPartialArgs=*/Record[ASTStmtReader::NumExprFields]);
3302       break;
3303
3304     case EXPR_SUBST_NON_TYPE_TEMPLATE_PARM:
3305       S = new (Context) SubstNonTypeTemplateParmExpr(Empty);
3306       break;
3307
3308     case EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK:
3309       S = new (Context) SubstNonTypeTemplateParmPackExpr(Empty);
3310       break;
3311
3312     case EXPR_FUNCTION_PARM_PACK:
3313       S = FunctionParmPackExpr::CreateEmpty(Context,
3314                                           Record[ASTStmtReader::NumExprFields]);
3315       break;
3316
3317     case EXPR_MATERIALIZE_TEMPORARY:
3318       S = new (Context) MaterializeTemporaryExpr(Empty);
3319       break;
3320
3321     case EXPR_CXX_FOLD:
3322       S = new (Context) CXXFoldExpr(Empty);
3323       break;
3324
3325     case EXPR_OPAQUE_VALUE:
3326       S = new (Context) OpaqueValueExpr(Empty);
3327       break;
3328
3329     case EXPR_CUDA_KERNEL_CALL:
3330       S = new (Context) CUDAKernelCallExpr(Context, Empty);
3331       break;
3332
3333     case EXPR_ASTYPE:
3334       S = new (Context) AsTypeExpr(Empty);
3335       break;
3336
3337     case EXPR_PSEUDO_OBJECT: {
3338       unsigned numSemanticExprs = Record[ASTStmtReader::NumExprFields];
3339       S = PseudoObjectExpr::Create(Context, Empty, numSemanticExprs);
3340       break;
3341     }
3342
3343     case EXPR_ATOMIC:
3344       S = new (Context) AtomicExpr(Empty);
3345       break;
3346
3347     case EXPR_LAMBDA: {
3348       unsigned NumCaptures = Record[ASTStmtReader::NumExprFields];
3349       unsigned NumArrayIndexVars = Record[ASTStmtReader::NumExprFields + 1];
3350       S = LambdaExpr::CreateDeserialized(Context, NumCaptures,
3351                                          NumArrayIndexVars);
3352       break;
3353     }
3354     }
3355
3356     // We hit a STMT_STOP, so we're done with this expression.
3357     if (Finished)
3358       break;
3359
3360     ++NumStatementsRead;
3361
3362     if (S && !IsStmtReference) {
3363       Reader.Visit(S);
3364       StmtEntries[Cursor.GetCurrentBitNo()] = S;
3365     }
3366
3367
3368     assert(Idx == Record.size() && "Invalid deserialization of statement");
3369     StmtStack.push_back(S);
3370   }
3371 Done:
3372   assert(StmtStack.size() > PrevNumStmts && "Read too many sub-stmts!");
3373   assert(StmtStack.size() == PrevNumStmts + 1 && "Extra expressions on stack!");
3374   return StmtStack.pop_back_val();
3375 }