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