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