1 //===- ASTReaderStmt.cpp - Stmt/Expr Deserialization ----------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // Statement/expression deserialization. This implements the 10 // ASTReader::ReadStmt method. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "clang/AST/ASTConcept.h" 15 #include "clang/AST/ASTContext.h" 16 #include "clang/AST/AttrIterator.h" 17 #include "clang/AST/Decl.h" 18 #include "clang/AST/DeclAccessPair.h" 19 #include "clang/AST/DeclCXX.h" 20 #include "clang/AST/DeclGroup.h" 21 #include "clang/AST/DeclObjC.h" 22 #include "clang/AST/DeclTemplate.h" 23 #include "clang/AST/DeclarationName.h" 24 #include "clang/AST/DependenceFlags.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/StmtSYCL.h" 37 #include "clang/AST/StmtVisitor.h" 38 #include "clang/AST/TemplateBase.h" 39 #include "clang/AST/Type.h" 40 #include "clang/AST/UnresolvedSet.h" 41 #include "clang/Basic/CapturedStmt.h" 42 #include "clang/Basic/ExpressionTraits.h" 43 #include "clang/Basic/LLVM.h" 44 #include "clang/Basic/LangOptions.h" 45 #include "clang/Basic/OpenMPKinds.h" 46 #include "clang/Basic/SourceLocation.h" 47 #include "clang/Basic/Specifiers.h" 48 #include "clang/Basic/TypeTraits.h" 49 #include "clang/Lex/Token.h" 50 #include "clang/Serialization/ASTBitCodes.h" 51 #include "clang/Serialization/ASTRecordReader.h" 52 #include "llvm/ADT/DenseMap.h" 53 #include "llvm/ADT/SmallVector.h" 54 #include "llvm/ADT/StringRef.h" 55 #include "llvm/Bitstream/BitstreamReader.h" 56 #include "llvm/Support/ErrorHandling.h" 57 #include <algorithm> 58 #include <cassert> 59 #include <cstdint> 60 #include <optional> 61 #include <string> 62 63 using namespace clang; 64 using namespace serialization; 65 66 namespace clang { 67 68 class ASTStmtReader : public StmtVisitor<ASTStmtReader> { 69 ASTRecordReader &Record; 70 llvm::BitstreamCursor &DeclsCursor; 71 72 std::optional<BitsUnpacker> CurrentUnpackingBits; 73 74 SourceLocation readSourceLocation() { 75 return Record.readSourceLocation(); 76 } 77 78 SourceRange readSourceRange() { 79 return Record.readSourceRange(); 80 } 81 82 std::string readString() { 83 return Record.readString(); 84 } 85 86 TypeSourceInfo *readTypeSourceInfo() { 87 return Record.readTypeSourceInfo(); 88 } 89 90 Decl *readDecl() { 91 return Record.readDecl(); 92 } 93 94 template<typename T> 95 T *readDeclAs() { 96 return Record.readDeclAs<T>(); 97 } 98 99 public: 100 ASTStmtReader(ASTRecordReader &Record, llvm::BitstreamCursor &Cursor) 101 : Record(Record), DeclsCursor(Cursor) {} 102 103 /// The number of record fields required for the Stmt class 104 /// itself. 105 static const unsigned NumStmtFields = 0; 106 107 /// The number of record fields required for the Expr class 108 /// itself. 109 static const unsigned NumExprFields = NumStmtFields + 2; 110 111 /// The number of bits required for the packing bits for the Expr class. 112 static const unsigned NumExprBits = 10; 113 114 /// Read and initialize a ExplicitTemplateArgumentList structure. 115 void ReadTemplateKWAndArgsInfo(ASTTemplateKWAndArgsInfo &Args, 116 TemplateArgumentLoc *ArgsLocArray, 117 unsigned NumTemplateArgs); 118 119 void VisitStmt(Stmt *S); 120 #define STMT(Type, Base) \ 121 void Visit##Type(Type *); 122 #include "clang/AST/StmtNodes.inc" 123 }; 124 125 } // namespace clang 126 127 void ASTStmtReader::ReadTemplateKWAndArgsInfo(ASTTemplateKWAndArgsInfo &Args, 128 TemplateArgumentLoc *ArgsLocArray, 129 unsigned NumTemplateArgs) { 130 SourceLocation TemplateKWLoc = readSourceLocation(); 131 TemplateArgumentListInfo ArgInfo; 132 ArgInfo.setLAngleLoc(readSourceLocation()); 133 ArgInfo.setRAngleLoc(readSourceLocation()); 134 for (unsigned i = 0; i != NumTemplateArgs; ++i) 135 ArgInfo.addArgument(Record.readTemplateArgumentLoc()); 136 Args.initializeFrom(TemplateKWLoc, ArgInfo, ArgsLocArray); 137 } 138 139 void ASTStmtReader::VisitStmt(Stmt *S) { 140 assert(Record.getIdx() == NumStmtFields && "Incorrect statement field count"); 141 } 142 143 void ASTStmtReader::VisitNullStmt(NullStmt *S) { 144 VisitStmt(S); 145 S->setSemiLoc(readSourceLocation()); 146 S->NullStmtBits.HasLeadingEmptyMacro = Record.readInt(); 147 } 148 149 void ASTStmtReader::VisitCompoundStmt(CompoundStmt *S) { 150 VisitStmt(S); 151 SmallVector<Stmt *, 16> Stmts; 152 unsigned NumStmts = Record.readInt(); 153 unsigned HasFPFeatures = Record.readInt(); 154 assert(S->hasStoredFPFeatures() == HasFPFeatures); 155 while (NumStmts--) 156 Stmts.push_back(Record.readSubStmt()); 157 S->setStmts(Stmts); 158 if (HasFPFeatures) 159 S->setStoredFPFeatures( 160 FPOptionsOverride::getFromOpaqueInt(Record.readInt())); 161 S->LBraceLoc = readSourceLocation(); 162 S->RBraceLoc = readSourceLocation(); 163 } 164 165 void ASTStmtReader::VisitSwitchCase(SwitchCase *S) { 166 VisitStmt(S); 167 Record.recordSwitchCaseID(S, Record.readInt()); 168 S->setKeywordLoc(readSourceLocation()); 169 S->setColonLoc(readSourceLocation()); 170 } 171 172 void ASTStmtReader::VisitCaseStmt(CaseStmt *S) { 173 VisitSwitchCase(S); 174 bool CaseStmtIsGNURange = Record.readInt(); 175 S->setLHS(Record.readSubExpr()); 176 S->setSubStmt(Record.readSubStmt()); 177 if (CaseStmtIsGNURange) { 178 S->setRHS(Record.readSubExpr()); 179 S->setEllipsisLoc(readSourceLocation()); 180 } 181 } 182 183 void ASTStmtReader::VisitDefaultStmt(DefaultStmt *S) { 184 VisitSwitchCase(S); 185 S->setSubStmt(Record.readSubStmt()); 186 } 187 188 void ASTStmtReader::VisitLabelStmt(LabelStmt *S) { 189 VisitStmt(S); 190 bool IsSideEntry = Record.readInt(); 191 auto *LD = readDeclAs<LabelDecl>(); 192 LD->setStmt(S); 193 S->setDecl(LD); 194 S->setSubStmt(Record.readSubStmt()); 195 S->setIdentLoc(readSourceLocation()); 196 S->setSideEntry(IsSideEntry); 197 } 198 199 void ASTStmtReader::VisitAttributedStmt(AttributedStmt *S) { 200 VisitStmt(S); 201 // NumAttrs in AttributedStmt is set when creating an empty 202 // AttributedStmt in AttributedStmt::CreateEmpty, since it is needed 203 // to allocate the right amount of space for the trailing Attr *. 204 uint64_t NumAttrs = Record.readInt(); 205 AttrVec Attrs; 206 Record.readAttributes(Attrs); 207 (void)NumAttrs; 208 assert(NumAttrs == S->AttributedStmtBits.NumAttrs); 209 assert(NumAttrs == Attrs.size()); 210 std::copy(Attrs.begin(), Attrs.end(), S->getAttrArrayPtr()); 211 S->SubStmt = Record.readSubStmt(); 212 S->AttributedStmtBits.AttrLoc = readSourceLocation(); 213 } 214 215 void ASTStmtReader::VisitIfStmt(IfStmt *S) { 216 VisitStmt(S); 217 218 CurrentUnpackingBits.emplace(Record.readInt()); 219 220 bool HasElse = CurrentUnpackingBits->getNextBit(); 221 bool HasVar = CurrentUnpackingBits->getNextBit(); 222 bool HasInit = CurrentUnpackingBits->getNextBit(); 223 224 S->setStatementKind(static_cast<IfStatementKind>(Record.readInt())); 225 S->setCond(Record.readSubExpr()); 226 S->setThen(Record.readSubStmt()); 227 if (HasElse) 228 S->setElse(Record.readSubStmt()); 229 if (HasVar) 230 S->setConditionVariableDeclStmt(cast<DeclStmt>(Record.readSubStmt())); 231 if (HasInit) 232 S->setInit(Record.readSubStmt()); 233 234 S->setIfLoc(readSourceLocation()); 235 S->setLParenLoc(readSourceLocation()); 236 S->setRParenLoc(readSourceLocation()); 237 if (HasElse) 238 S->setElseLoc(readSourceLocation()); 239 } 240 241 void ASTStmtReader::VisitSwitchStmt(SwitchStmt *S) { 242 VisitStmt(S); 243 244 bool HasInit = Record.readInt(); 245 bool HasVar = Record.readInt(); 246 bool AllEnumCasesCovered = Record.readInt(); 247 if (AllEnumCasesCovered) 248 S->setAllEnumCasesCovered(); 249 250 S->setCond(Record.readSubExpr()); 251 S->setBody(Record.readSubStmt()); 252 if (HasInit) 253 S->setInit(Record.readSubStmt()); 254 if (HasVar) 255 S->setConditionVariableDeclStmt(cast<DeclStmt>(Record.readSubStmt())); 256 257 S->setSwitchLoc(readSourceLocation()); 258 S->setLParenLoc(readSourceLocation()); 259 S->setRParenLoc(readSourceLocation()); 260 261 SwitchCase *PrevSC = nullptr; 262 for (auto E = Record.size(); Record.getIdx() != E; ) { 263 SwitchCase *SC = Record.getSwitchCaseWithID(Record.readInt()); 264 if (PrevSC) 265 PrevSC->setNextSwitchCase(SC); 266 else 267 S->setSwitchCaseList(SC); 268 269 PrevSC = SC; 270 } 271 } 272 273 void ASTStmtReader::VisitWhileStmt(WhileStmt *S) { 274 VisitStmt(S); 275 276 bool HasVar = Record.readInt(); 277 278 S->setCond(Record.readSubExpr()); 279 S->setBody(Record.readSubStmt()); 280 if (HasVar) 281 S->setConditionVariableDeclStmt(cast<DeclStmt>(Record.readSubStmt())); 282 283 S->setWhileLoc(readSourceLocation()); 284 S->setLParenLoc(readSourceLocation()); 285 S->setRParenLoc(readSourceLocation()); 286 } 287 288 void ASTStmtReader::VisitDoStmt(DoStmt *S) { 289 VisitStmt(S); 290 S->setCond(Record.readSubExpr()); 291 S->setBody(Record.readSubStmt()); 292 S->setDoLoc(readSourceLocation()); 293 S->setWhileLoc(readSourceLocation()); 294 S->setRParenLoc(readSourceLocation()); 295 } 296 297 void ASTStmtReader::VisitForStmt(ForStmt *S) { 298 VisitStmt(S); 299 S->setInit(Record.readSubStmt()); 300 S->setCond(Record.readSubExpr()); 301 S->setConditionVariableDeclStmt(cast_or_null<DeclStmt>(Record.readSubStmt())); 302 S->setInc(Record.readSubExpr()); 303 S->setBody(Record.readSubStmt()); 304 S->setForLoc(readSourceLocation()); 305 S->setLParenLoc(readSourceLocation()); 306 S->setRParenLoc(readSourceLocation()); 307 } 308 309 void ASTStmtReader::VisitGotoStmt(GotoStmt *S) { 310 VisitStmt(S); 311 S->setLabel(readDeclAs<LabelDecl>()); 312 S->setGotoLoc(readSourceLocation()); 313 S->setLabelLoc(readSourceLocation()); 314 } 315 316 void ASTStmtReader::VisitIndirectGotoStmt(IndirectGotoStmt *S) { 317 VisitStmt(S); 318 S->setGotoLoc(readSourceLocation()); 319 S->setStarLoc(readSourceLocation()); 320 S->setTarget(Record.readSubExpr()); 321 } 322 323 void ASTStmtReader::VisitContinueStmt(ContinueStmt *S) { 324 VisitStmt(S); 325 S->setContinueLoc(readSourceLocation()); 326 } 327 328 void ASTStmtReader::VisitBreakStmt(BreakStmt *S) { 329 VisitStmt(S); 330 S->setBreakLoc(readSourceLocation()); 331 } 332 333 void ASTStmtReader::VisitReturnStmt(ReturnStmt *S) { 334 VisitStmt(S); 335 336 bool HasNRVOCandidate = Record.readInt(); 337 338 S->setRetValue(Record.readSubExpr()); 339 if (HasNRVOCandidate) 340 S->setNRVOCandidate(readDeclAs<VarDecl>()); 341 342 S->setReturnLoc(readSourceLocation()); 343 } 344 345 void ASTStmtReader::VisitDeclStmt(DeclStmt *S) { 346 VisitStmt(S); 347 S->setStartLoc(readSourceLocation()); 348 S->setEndLoc(readSourceLocation()); 349 350 if (Record.size() - Record.getIdx() == 1) { 351 // Single declaration 352 S->setDeclGroup(DeclGroupRef(readDecl())); 353 } else { 354 SmallVector<Decl *, 16> Decls; 355 int N = Record.size() - Record.getIdx(); 356 Decls.reserve(N); 357 for (int I = 0; I < N; ++I) 358 Decls.push_back(readDecl()); 359 S->setDeclGroup(DeclGroupRef(DeclGroup::Create(Record.getContext(), 360 Decls.data(), 361 Decls.size()))); 362 } 363 } 364 365 void ASTStmtReader::VisitAsmStmt(AsmStmt *S) { 366 VisitStmt(S); 367 S->NumOutputs = Record.readInt(); 368 S->NumInputs = Record.readInt(); 369 S->NumClobbers = Record.readInt(); 370 S->setAsmLoc(readSourceLocation()); 371 S->setVolatile(Record.readInt()); 372 S->setSimple(Record.readInt()); 373 } 374 375 void ASTStmtReader::VisitGCCAsmStmt(GCCAsmStmt *S) { 376 VisitAsmStmt(S); 377 S->NumLabels = Record.readInt(); 378 S->setRParenLoc(readSourceLocation()); 379 S->setAsmStringExpr(cast_or_null<Expr>(Record.readSubStmt())); 380 381 unsigned NumOutputs = S->getNumOutputs(); 382 unsigned NumInputs = S->getNumInputs(); 383 unsigned NumClobbers = S->getNumClobbers(); 384 unsigned NumLabels = S->getNumLabels(); 385 386 // Outputs and inputs 387 SmallVector<IdentifierInfo *, 16> Names; 388 SmallVector<Expr *, 16> Constraints; 389 SmallVector<Stmt*, 16> Exprs; 390 for (unsigned I = 0, N = NumOutputs + NumInputs; I != N; ++I) { 391 Names.push_back(Record.readIdentifier()); 392 Constraints.push_back(cast_or_null<Expr>(Record.readSubStmt())); 393 Exprs.push_back(Record.readSubStmt()); 394 } 395 396 // Constraints 397 SmallVector<Expr *, 16> Clobbers; 398 for (unsigned I = 0; I != NumClobbers; ++I) 399 Clobbers.push_back(cast_or_null<Expr>(Record.readSubStmt())); 400 401 // Labels 402 for (unsigned I = 0, N = NumLabels; I != N; ++I) { 403 Names.push_back(Record.readIdentifier()); 404 Exprs.push_back(Record.readSubStmt()); 405 } 406 407 S->setOutputsAndInputsAndClobbers(Record.getContext(), 408 Names.data(), Constraints.data(), 409 Exprs.data(), NumOutputs, NumInputs, 410 NumLabels, 411 Clobbers.data(), NumClobbers); 412 } 413 414 void ASTStmtReader::VisitMSAsmStmt(MSAsmStmt *S) { 415 VisitAsmStmt(S); 416 S->LBraceLoc = readSourceLocation(); 417 S->EndLoc = readSourceLocation(); 418 S->NumAsmToks = Record.readInt(); 419 std::string AsmStr = readString(); 420 421 // Read the tokens. 422 SmallVector<Token, 16> AsmToks; 423 AsmToks.reserve(S->NumAsmToks); 424 for (unsigned i = 0, e = S->NumAsmToks; i != e; ++i) { 425 AsmToks.push_back(Record.readToken()); 426 } 427 428 // The calls to reserve() for the FooData vectors are mandatory to 429 // prevent dead StringRefs in the Foo vectors. 430 431 // Read the clobbers. 432 SmallVector<std::string, 16> ClobbersData; 433 SmallVector<StringRef, 16> Clobbers; 434 ClobbersData.reserve(S->NumClobbers); 435 Clobbers.reserve(S->NumClobbers); 436 for (unsigned i = 0, e = S->NumClobbers; i != e; ++i) { 437 ClobbersData.push_back(readString()); 438 Clobbers.push_back(ClobbersData.back()); 439 } 440 441 // Read the operands. 442 unsigned NumOperands = S->NumOutputs + S->NumInputs; 443 SmallVector<Expr*, 16> Exprs; 444 SmallVector<std::string, 16> ConstraintsData; 445 SmallVector<StringRef, 16> Constraints; 446 Exprs.reserve(NumOperands); 447 ConstraintsData.reserve(NumOperands); 448 Constraints.reserve(NumOperands); 449 for (unsigned i = 0; i != NumOperands; ++i) { 450 Exprs.push_back(cast<Expr>(Record.readSubStmt())); 451 ConstraintsData.push_back(readString()); 452 Constraints.push_back(ConstraintsData.back()); 453 } 454 455 S->initialize(Record.getContext(), AsmStr, AsmToks, 456 Constraints, Exprs, Clobbers); 457 } 458 459 void ASTStmtReader::VisitCoroutineBodyStmt(CoroutineBodyStmt *S) { 460 VisitStmt(S); 461 assert(Record.peekInt() == S->NumParams); 462 Record.skipInts(1); 463 auto *StoredStmts = S->getStoredStmts(); 464 for (unsigned i = 0; 465 i < CoroutineBodyStmt::SubStmt::FirstParamMove + S->NumParams; ++i) 466 StoredStmts[i] = Record.readSubStmt(); 467 } 468 469 void ASTStmtReader::VisitCoreturnStmt(CoreturnStmt *S) { 470 VisitStmt(S); 471 S->CoreturnLoc = Record.readSourceLocation(); 472 for (auto &SubStmt: S->SubStmts) 473 SubStmt = Record.readSubStmt(); 474 S->IsImplicit = Record.readInt() != 0; 475 } 476 477 void ASTStmtReader::VisitCoawaitExpr(CoawaitExpr *E) { 478 VisitExpr(E); 479 E->KeywordLoc = readSourceLocation(); 480 for (auto &SubExpr: E->SubExprs) 481 SubExpr = Record.readSubStmt(); 482 E->OpaqueValue = cast_or_null<OpaqueValueExpr>(Record.readSubStmt()); 483 E->setIsImplicit(Record.readInt() != 0); 484 } 485 486 void ASTStmtReader::VisitCoyieldExpr(CoyieldExpr *E) { 487 VisitExpr(E); 488 E->KeywordLoc = readSourceLocation(); 489 for (auto &SubExpr: E->SubExprs) 490 SubExpr = Record.readSubStmt(); 491 E->OpaqueValue = cast_or_null<OpaqueValueExpr>(Record.readSubStmt()); 492 } 493 494 void ASTStmtReader::VisitDependentCoawaitExpr(DependentCoawaitExpr *E) { 495 VisitExpr(E); 496 E->KeywordLoc = readSourceLocation(); 497 for (auto &SubExpr: E->SubExprs) 498 SubExpr = Record.readSubStmt(); 499 } 500 501 void ASTStmtReader::VisitCapturedStmt(CapturedStmt *S) { 502 VisitStmt(S); 503 Record.skipInts(1); 504 S->setCapturedDecl(readDeclAs<CapturedDecl>()); 505 S->setCapturedRegionKind(static_cast<CapturedRegionKind>(Record.readInt())); 506 S->setCapturedRecordDecl(readDeclAs<RecordDecl>()); 507 508 // Capture inits 509 for (CapturedStmt::capture_init_iterator I = S->capture_init_begin(), 510 E = S->capture_init_end(); 511 I != E; ++I) 512 *I = Record.readSubExpr(); 513 514 // Body 515 S->setCapturedStmt(Record.readSubStmt()); 516 S->getCapturedDecl()->setBody(S->getCapturedStmt()); 517 518 // Captures 519 for (auto &I : S->captures()) { 520 I.VarAndKind.setPointer(readDeclAs<VarDecl>()); 521 I.VarAndKind.setInt( 522 static_cast<CapturedStmt::VariableCaptureKind>(Record.readInt())); 523 I.Loc = readSourceLocation(); 524 } 525 } 526 527 void ASTStmtReader::VisitSYCLKernelCallStmt(SYCLKernelCallStmt *S) { 528 VisitStmt(S); 529 S->setOriginalStmt(cast<CompoundStmt>(Record.readSubStmt())); 530 S->setOutlinedFunctionDecl(readDeclAs<OutlinedFunctionDecl>()); 531 } 532 533 void ASTStmtReader::VisitExpr(Expr *E) { 534 VisitStmt(E); 535 CurrentUnpackingBits.emplace(Record.readInt()); 536 E->setDependence(static_cast<ExprDependence>( 537 CurrentUnpackingBits->getNextBits(/*Width=*/5))); 538 E->setValueKind(static_cast<ExprValueKind>( 539 CurrentUnpackingBits->getNextBits(/*Width=*/2))); 540 E->setObjectKind(static_cast<ExprObjectKind>( 541 CurrentUnpackingBits->getNextBits(/*Width=*/3))); 542 543 E->setType(Record.readType()); 544 assert(Record.getIdx() == NumExprFields && 545 "Incorrect expression field count"); 546 } 547 548 void ASTStmtReader::VisitConstantExpr(ConstantExpr *E) { 549 VisitExpr(E); 550 551 auto StorageKind = static_cast<ConstantResultStorageKind>(Record.readInt()); 552 assert(E->getResultStorageKind() == StorageKind && "Wrong ResultKind!"); 553 554 E->ConstantExprBits.APValueKind = Record.readInt(); 555 E->ConstantExprBits.IsUnsigned = Record.readInt(); 556 E->ConstantExprBits.BitWidth = Record.readInt(); 557 E->ConstantExprBits.HasCleanup = false; // Not serialized, see below. 558 E->ConstantExprBits.IsImmediateInvocation = Record.readInt(); 559 560 switch (StorageKind) { 561 case ConstantResultStorageKind::None: 562 break; 563 564 case ConstantResultStorageKind::Int64: 565 E->Int64Result() = Record.readInt(); 566 break; 567 568 case ConstantResultStorageKind::APValue: 569 E->APValueResult() = Record.readAPValue(); 570 if (E->APValueResult().needsCleanup()) { 571 E->ConstantExprBits.HasCleanup = true; 572 Record.getContext().addDestruction(&E->APValueResult()); 573 } 574 break; 575 } 576 577 E->setSubExpr(Record.readSubExpr()); 578 } 579 580 void ASTStmtReader::VisitOpenACCAsteriskSizeExpr(OpenACCAsteriskSizeExpr *E) { 581 VisitExpr(E); 582 E->setAsteriskLocation(readSourceLocation()); 583 } 584 585 void ASTStmtReader::VisitSYCLUniqueStableNameExpr(SYCLUniqueStableNameExpr *E) { 586 VisitExpr(E); 587 588 E->setLocation(readSourceLocation()); 589 E->setLParenLocation(readSourceLocation()); 590 E->setRParenLocation(readSourceLocation()); 591 592 E->setTypeSourceInfo(Record.readTypeSourceInfo()); 593 } 594 595 void ASTStmtReader::VisitPredefinedExpr(PredefinedExpr *E) { 596 VisitExpr(E); 597 bool HasFunctionName = Record.readInt(); 598 E->PredefinedExprBits.HasFunctionName = HasFunctionName; 599 E->PredefinedExprBits.Kind = Record.readInt(); 600 E->PredefinedExprBits.IsTransparent = Record.readInt(); 601 E->setLocation(readSourceLocation()); 602 if (HasFunctionName) 603 E->setFunctionName(cast<StringLiteral>(Record.readSubExpr())); 604 } 605 606 void ASTStmtReader::VisitDeclRefExpr(DeclRefExpr *E) { 607 VisitExpr(E); 608 609 CurrentUnpackingBits.emplace(Record.readInt()); 610 E->DeclRefExprBits.HadMultipleCandidates = CurrentUnpackingBits->getNextBit(); 611 E->DeclRefExprBits.RefersToEnclosingVariableOrCapture = 612 CurrentUnpackingBits->getNextBit(); 613 E->DeclRefExprBits.NonOdrUseReason = 614 CurrentUnpackingBits->getNextBits(/*Width=*/2); 615 E->DeclRefExprBits.IsImmediateEscalating = CurrentUnpackingBits->getNextBit(); 616 E->DeclRefExprBits.HasFoundDecl = CurrentUnpackingBits->getNextBit(); 617 E->DeclRefExprBits.HasQualifier = CurrentUnpackingBits->getNextBit(); 618 E->DeclRefExprBits.HasTemplateKWAndArgsInfo = 619 CurrentUnpackingBits->getNextBit(); 620 E->DeclRefExprBits.CapturedByCopyInLambdaWithExplicitObjectParameter = false; 621 unsigned NumTemplateArgs = 0; 622 if (E->hasTemplateKWAndArgsInfo()) 623 NumTemplateArgs = Record.readInt(); 624 625 if (E->hasQualifier()) 626 new (E->getTrailingObjects<NestedNameSpecifierLoc>()) 627 NestedNameSpecifierLoc(Record.readNestedNameSpecifierLoc()); 628 629 if (E->hasFoundDecl()) 630 *E->getTrailingObjects<NamedDecl *>() = readDeclAs<NamedDecl>(); 631 632 if (E->hasTemplateKWAndArgsInfo()) 633 ReadTemplateKWAndArgsInfo( 634 *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(), 635 E->getTrailingObjects<TemplateArgumentLoc>(), NumTemplateArgs); 636 637 E->D = readDeclAs<ValueDecl>(); 638 E->setLocation(readSourceLocation()); 639 E->DNLoc = Record.readDeclarationNameLoc(E->getDecl()->getDeclName()); 640 } 641 642 void ASTStmtReader::VisitIntegerLiteral(IntegerLiteral *E) { 643 VisitExpr(E); 644 E->setLocation(readSourceLocation()); 645 E->setValue(Record.getContext(), Record.readAPInt()); 646 } 647 648 void ASTStmtReader::VisitFixedPointLiteral(FixedPointLiteral *E) { 649 VisitExpr(E); 650 E->setLocation(readSourceLocation()); 651 E->setScale(Record.readInt()); 652 E->setValue(Record.getContext(), Record.readAPInt()); 653 } 654 655 void ASTStmtReader::VisitFloatingLiteral(FloatingLiteral *E) { 656 VisitExpr(E); 657 E->setRawSemantics( 658 static_cast<llvm::APFloatBase::Semantics>(Record.readInt())); 659 E->setExact(Record.readInt()); 660 E->setValue(Record.getContext(), Record.readAPFloat(E->getSemantics())); 661 E->setLocation(readSourceLocation()); 662 } 663 664 void ASTStmtReader::VisitImaginaryLiteral(ImaginaryLiteral *E) { 665 VisitExpr(E); 666 E->setSubExpr(Record.readSubExpr()); 667 } 668 669 void ASTStmtReader::VisitStringLiteral(StringLiteral *E) { 670 VisitExpr(E); 671 672 // NumConcatenated, Length and CharByteWidth are set by the empty 673 // ctor since they are needed to allocate storage for the trailing objects. 674 unsigned NumConcatenated = Record.readInt(); 675 unsigned Length = Record.readInt(); 676 unsigned CharByteWidth = Record.readInt(); 677 assert((NumConcatenated == E->getNumConcatenated()) && 678 "Wrong number of concatenated tokens!"); 679 assert((Length == E->getLength()) && "Wrong Length!"); 680 assert((CharByteWidth == E->getCharByteWidth()) && "Wrong character width!"); 681 E->StringLiteralBits.Kind = Record.readInt(); 682 E->StringLiteralBits.IsPascal = Record.readInt(); 683 684 // The character width is originally computed via mapCharByteWidth. 685 // Check that the deserialized character width is consistant with the result 686 // of calling mapCharByteWidth. 687 assert((CharByteWidth == 688 StringLiteral::mapCharByteWidth(Record.getContext().getTargetInfo(), 689 E->getKind())) && 690 "Wrong character width!"); 691 692 // Deserialize the trailing array of SourceLocation. 693 for (unsigned I = 0; I < NumConcatenated; ++I) 694 E->setStrTokenLoc(I, readSourceLocation()); 695 696 // Deserialize the trailing array of char holding the string data. 697 char *StrData = E->getStrDataAsChar(); 698 for (unsigned I = 0; I < Length * CharByteWidth; ++I) 699 StrData[I] = Record.readInt(); 700 } 701 702 void ASTStmtReader::VisitCharacterLiteral(CharacterLiteral *E) { 703 VisitExpr(E); 704 E->setValue(Record.readInt()); 705 E->setLocation(readSourceLocation()); 706 E->setKind(static_cast<CharacterLiteralKind>(Record.readInt())); 707 } 708 709 void ASTStmtReader::VisitParenExpr(ParenExpr *E) { 710 VisitExpr(E); 711 E->setIsProducedByFoldExpansion(Record.readInt()); 712 E->setLParen(readSourceLocation()); 713 E->setRParen(readSourceLocation()); 714 E->setSubExpr(Record.readSubExpr()); 715 } 716 717 void ASTStmtReader::VisitParenListExpr(ParenListExpr *E) { 718 VisitExpr(E); 719 unsigned NumExprs = Record.readInt(); 720 assert((NumExprs == E->getNumExprs()) && "Wrong NumExprs!"); 721 for (unsigned I = 0; I != NumExprs; ++I) 722 E->getTrailingObjects()[I] = Record.readSubStmt(); 723 E->LParenLoc = readSourceLocation(); 724 E->RParenLoc = readSourceLocation(); 725 } 726 727 void ASTStmtReader::VisitUnaryOperator(UnaryOperator *E) { 728 VisitExpr(E); 729 bool hasFP_Features = CurrentUnpackingBits->getNextBit(); 730 assert(hasFP_Features == E->hasStoredFPFeatures()); 731 E->setSubExpr(Record.readSubExpr()); 732 E->setOpcode( 733 (UnaryOperator::Opcode)CurrentUnpackingBits->getNextBits(/*Width=*/5)); 734 E->setOperatorLoc(readSourceLocation()); 735 E->setCanOverflow(CurrentUnpackingBits->getNextBit()); 736 if (hasFP_Features) 737 E->setStoredFPFeatures( 738 FPOptionsOverride::getFromOpaqueInt(Record.readInt())); 739 } 740 741 void ASTStmtReader::VisitOffsetOfExpr(OffsetOfExpr *E) { 742 VisitExpr(E); 743 assert(E->getNumComponents() == Record.peekInt()); 744 Record.skipInts(1); 745 assert(E->getNumExpressions() == Record.peekInt()); 746 Record.skipInts(1); 747 E->setOperatorLoc(readSourceLocation()); 748 E->setRParenLoc(readSourceLocation()); 749 E->setTypeSourceInfo(readTypeSourceInfo()); 750 for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) { 751 auto Kind = static_cast<OffsetOfNode::Kind>(Record.readInt()); 752 SourceLocation Start = readSourceLocation(); 753 SourceLocation End = readSourceLocation(); 754 switch (Kind) { 755 case OffsetOfNode::Array: 756 E->setComponent(I, OffsetOfNode(Start, Record.readInt(), End)); 757 break; 758 759 case OffsetOfNode::Field: 760 E->setComponent( 761 I, OffsetOfNode(Start, readDeclAs<FieldDecl>(), End)); 762 break; 763 764 case OffsetOfNode::Identifier: 765 E->setComponent( 766 I, 767 OffsetOfNode(Start, Record.readIdentifier(), End)); 768 break; 769 770 case OffsetOfNode::Base: { 771 auto *Base = new (Record.getContext()) CXXBaseSpecifier(); 772 *Base = Record.readCXXBaseSpecifier(); 773 E->setComponent(I, OffsetOfNode(Base)); 774 break; 775 } 776 } 777 } 778 779 for (unsigned I = 0, N = E->getNumExpressions(); I != N; ++I) 780 E->setIndexExpr(I, Record.readSubExpr()); 781 } 782 783 void ASTStmtReader::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) { 784 VisitExpr(E); 785 E->setKind(static_cast<UnaryExprOrTypeTrait>(Record.readInt())); 786 if (Record.peekInt() == 0) { 787 E->setArgument(Record.readSubExpr()); 788 Record.skipInts(1); 789 } else { 790 E->setArgument(readTypeSourceInfo()); 791 } 792 E->setOperatorLoc(readSourceLocation()); 793 E->setRParenLoc(readSourceLocation()); 794 } 795 796 static ConstraintSatisfaction 797 readConstraintSatisfaction(ASTRecordReader &Record) { 798 ConstraintSatisfaction Satisfaction; 799 Satisfaction.IsSatisfied = Record.readInt(); 800 Satisfaction.ContainsErrors = Record.readInt(); 801 const ASTContext &C = Record.getContext(); 802 if (!Satisfaction.IsSatisfied) { 803 unsigned NumDetailRecords = Record.readInt(); 804 for (unsigned i = 0; i != NumDetailRecords; ++i) { 805 if (/* IsDiagnostic */Record.readInt()) { 806 SourceLocation DiagLocation = Record.readSourceLocation(); 807 StringRef DiagMessage = C.backupStr(Record.readString()); 808 809 Satisfaction.Details.emplace_back( 810 new (C) ConstraintSatisfaction::SubstitutionDiagnostic( 811 DiagLocation, DiagMessage)); 812 } else 813 Satisfaction.Details.emplace_back(Record.readExpr()); 814 } 815 } 816 return Satisfaction; 817 } 818 819 void ASTStmtReader::VisitConceptSpecializationExpr( 820 ConceptSpecializationExpr *E) { 821 VisitExpr(E); 822 E->SpecDecl = Record.readDeclAs<ImplicitConceptSpecializationDecl>(); 823 if (Record.readBool()) 824 E->ConceptRef = Record.readConceptReference(); 825 E->Satisfaction = E->isValueDependent() ? nullptr : 826 ASTConstraintSatisfaction::Create(Record.getContext(), 827 readConstraintSatisfaction(Record)); 828 } 829 830 static concepts::Requirement::SubstitutionDiagnostic * 831 readSubstitutionDiagnostic(ASTRecordReader &Record) { 832 const ASTContext &C = Record.getContext(); 833 StringRef SubstitutedEntity = C.backupStr(Record.readString()); 834 SourceLocation DiagLoc = Record.readSourceLocation(); 835 StringRef DiagMessage = C.backupStr(Record.readString()); 836 837 return new (Record.getContext()) 838 concepts::Requirement::SubstitutionDiagnostic{SubstitutedEntity, DiagLoc, 839 DiagMessage}; 840 } 841 842 void ASTStmtReader::VisitRequiresExpr(RequiresExpr *E) { 843 VisitExpr(E); 844 unsigned NumLocalParameters = Record.readInt(); 845 unsigned NumRequirements = Record.readInt(); 846 E->RequiresExprBits.RequiresKWLoc = Record.readSourceLocation(); 847 E->RequiresExprBits.IsSatisfied = Record.readInt(); 848 E->Body = Record.readDeclAs<RequiresExprBodyDecl>(); 849 llvm::SmallVector<ParmVarDecl *, 4> LocalParameters; 850 for (unsigned i = 0; i < NumLocalParameters; ++i) 851 LocalParameters.push_back(cast<ParmVarDecl>(Record.readDecl())); 852 std::copy(LocalParameters.begin(), LocalParameters.end(), 853 E->getTrailingObjects<ParmVarDecl *>()); 854 llvm::SmallVector<concepts::Requirement *, 4> Requirements; 855 for (unsigned i = 0; i < NumRequirements; ++i) { 856 auto RK = 857 static_cast<concepts::Requirement::RequirementKind>(Record.readInt()); 858 concepts::Requirement *R = nullptr; 859 switch (RK) { 860 case concepts::Requirement::RK_Type: { 861 auto Status = 862 static_cast<concepts::TypeRequirement::SatisfactionStatus>( 863 Record.readInt()); 864 if (Status == concepts::TypeRequirement::SS_SubstitutionFailure) 865 R = new (Record.getContext()) 866 concepts::TypeRequirement(readSubstitutionDiagnostic(Record)); 867 else 868 R = new (Record.getContext()) 869 concepts::TypeRequirement(Record.readTypeSourceInfo()); 870 } break; 871 case concepts::Requirement::RK_Simple: 872 case concepts::Requirement::RK_Compound: { 873 auto Status = 874 static_cast<concepts::ExprRequirement::SatisfactionStatus>( 875 Record.readInt()); 876 llvm::PointerUnion<concepts::Requirement::SubstitutionDiagnostic *, 877 Expr *> E; 878 if (Status == concepts::ExprRequirement::SS_ExprSubstitutionFailure) { 879 E = readSubstitutionDiagnostic(Record); 880 } else 881 E = Record.readExpr(); 882 883 std::optional<concepts::ExprRequirement::ReturnTypeRequirement> Req; 884 ConceptSpecializationExpr *SubstitutedConstraintExpr = nullptr; 885 SourceLocation NoexceptLoc; 886 if (RK == concepts::Requirement::RK_Simple) { 887 Req.emplace(); 888 } else { 889 NoexceptLoc = Record.readSourceLocation(); 890 switch (/* returnTypeRequirementKind */Record.readInt()) { 891 case 0: 892 // No return type requirement. 893 Req.emplace(); 894 break; 895 case 1: { 896 // type-constraint 897 TemplateParameterList *TPL = Record.readTemplateParameterList(); 898 if (Status >= 899 concepts::ExprRequirement::SS_ConstraintsNotSatisfied) 900 SubstitutedConstraintExpr = 901 cast<ConceptSpecializationExpr>(Record.readExpr()); 902 Req.emplace(TPL); 903 } break; 904 case 2: 905 // Substitution failure 906 Req.emplace(readSubstitutionDiagnostic(Record)); 907 break; 908 } 909 } 910 if (Expr *Ex = E.dyn_cast<Expr *>()) 911 R = new (Record.getContext()) concepts::ExprRequirement( 912 Ex, RK == concepts::Requirement::RK_Simple, NoexceptLoc, 913 std::move(*Req), Status, SubstitutedConstraintExpr); 914 else 915 R = new (Record.getContext()) concepts::ExprRequirement( 916 cast<concepts::Requirement::SubstitutionDiagnostic *>(E), 917 RK == concepts::Requirement::RK_Simple, NoexceptLoc, 918 std::move(*Req)); 919 } break; 920 case concepts::Requirement::RK_Nested: { 921 ASTContext &C = Record.getContext(); 922 bool HasInvalidConstraint = Record.readInt(); 923 if (HasInvalidConstraint) { 924 StringRef InvalidConstraint = C.backupStr(Record.readString()); 925 R = new (C) concepts::NestedRequirement( 926 Record.getContext(), InvalidConstraint, 927 readConstraintSatisfaction(Record)); 928 break; 929 } 930 Expr *E = Record.readExpr(); 931 if (E->isInstantiationDependent()) 932 R = new (C) concepts::NestedRequirement(E); 933 else 934 R = new (C) concepts::NestedRequirement( 935 C, E, readConstraintSatisfaction(Record)); 936 } break; 937 } 938 if (!R) 939 continue; 940 Requirements.push_back(R); 941 } 942 std::copy(Requirements.begin(), Requirements.end(), 943 E->getTrailingObjects<concepts::Requirement *>()); 944 E->LParenLoc = Record.readSourceLocation(); 945 E->RParenLoc = Record.readSourceLocation(); 946 E->RBraceLoc = Record.readSourceLocation(); 947 } 948 949 void ASTStmtReader::VisitArraySubscriptExpr(ArraySubscriptExpr *E) { 950 VisitExpr(E); 951 E->setLHS(Record.readSubExpr()); 952 E->setRHS(Record.readSubExpr()); 953 E->setRBracketLoc(readSourceLocation()); 954 } 955 956 void ASTStmtReader::VisitMatrixSubscriptExpr(MatrixSubscriptExpr *E) { 957 VisitExpr(E); 958 E->setBase(Record.readSubExpr()); 959 E->setRowIdx(Record.readSubExpr()); 960 E->setColumnIdx(Record.readSubExpr()); 961 E->setRBracketLoc(readSourceLocation()); 962 } 963 964 void ASTStmtReader::VisitArraySectionExpr(ArraySectionExpr *E) { 965 VisitExpr(E); 966 E->ASType = Record.readEnum<ArraySectionExpr::ArraySectionType>(); 967 968 E->setBase(Record.readSubExpr()); 969 E->setLowerBound(Record.readSubExpr()); 970 E->setLength(Record.readSubExpr()); 971 972 if (E->isOMPArraySection()) 973 E->setStride(Record.readSubExpr()); 974 975 E->setColonLocFirst(readSourceLocation()); 976 977 if (E->isOMPArraySection()) 978 E->setColonLocSecond(readSourceLocation()); 979 980 E->setRBracketLoc(readSourceLocation()); 981 } 982 983 void ASTStmtReader::VisitOMPArrayShapingExpr(OMPArrayShapingExpr *E) { 984 VisitExpr(E); 985 unsigned NumDims = Record.readInt(); 986 E->setBase(Record.readSubExpr()); 987 SmallVector<Expr *, 4> Dims(NumDims); 988 for (unsigned I = 0; I < NumDims; ++I) 989 Dims[I] = Record.readSubExpr(); 990 E->setDimensions(Dims); 991 SmallVector<SourceRange, 4> SRs(NumDims); 992 for (unsigned I = 0; I < NumDims; ++I) 993 SRs[I] = readSourceRange(); 994 E->setBracketsRanges(SRs); 995 E->setLParenLoc(readSourceLocation()); 996 E->setRParenLoc(readSourceLocation()); 997 } 998 999 void ASTStmtReader::VisitOMPIteratorExpr(OMPIteratorExpr *E) { 1000 VisitExpr(E); 1001 unsigned NumIters = Record.readInt(); 1002 E->setIteratorKwLoc(readSourceLocation()); 1003 E->setLParenLoc(readSourceLocation()); 1004 E->setRParenLoc(readSourceLocation()); 1005 for (unsigned I = 0; I < NumIters; ++I) { 1006 E->setIteratorDeclaration(I, Record.readDeclRef()); 1007 E->setAssignmentLoc(I, readSourceLocation()); 1008 Expr *Begin = Record.readSubExpr(); 1009 Expr *End = Record.readSubExpr(); 1010 Expr *Step = Record.readSubExpr(); 1011 SourceLocation ColonLoc = readSourceLocation(); 1012 SourceLocation SecColonLoc; 1013 if (Step) 1014 SecColonLoc = readSourceLocation(); 1015 E->setIteratorRange(I, Begin, ColonLoc, End, SecColonLoc, Step); 1016 // Deserialize helpers 1017 OMPIteratorHelperData HD; 1018 HD.CounterVD = cast_or_null<VarDecl>(Record.readDeclRef()); 1019 HD.Upper = Record.readSubExpr(); 1020 HD.Update = Record.readSubExpr(); 1021 HD.CounterUpdate = Record.readSubExpr(); 1022 E->setHelper(I, HD); 1023 } 1024 } 1025 1026 void ASTStmtReader::VisitCallExpr(CallExpr *E) { 1027 VisitExpr(E); 1028 1029 unsigned NumArgs = Record.readInt(); 1030 CurrentUnpackingBits.emplace(Record.readInt()); 1031 E->setADLCallKind( 1032 static_cast<CallExpr::ADLCallKind>(CurrentUnpackingBits->getNextBit())); 1033 bool HasFPFeatures = CurrentUnpackingBits->getNextBit(); 1034 E->setCoroElideSafe(CurrentUnpackingBits->getNextBit()); 1035 E->setUsesMemberSyntax(CurrentUnpackingBits->getNextBit()); 1036 assert((NumArgs == E->getNumArgs()) && "Wrong NumArgs!"); 1037 E->setRParenLoc(readSourceLocation()); 1038 E->setCallee(Record.readSubExpr()); 1039 for (unsigned I = 0; I != NumArgs; ++I) 1040 E->setArg(I, Record.readSubExpr()); 1041 1042 if (HasFPFeatures) 1043 E->setStoredFPFeatures( 1044 FPOptionsOverride::getFromOpaqueInt(Record.readInt())); 1045 1046 if (E->getStmtClass() == Stmt::CallExprClass) 1047 E->updateTrailingSourceLoc(); 1048 } 1049 1050 void ASTStmtReader::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) { 1051 VisitCallExpr(E); 1052 } 1053 1054 void ASTStmtReader::VisitMemberExpr(MemberExpr *E) { 1055 VisitExpr(E); 1056 1057 CurrentUnpackingBits.emplace(Record.readInt()); 1058 bool HasQualifier = CurrentUnpackingBits->getNextBit(); 1059 bool HasFoundDecl = CurrentUnpackingBits->getNextBit(); 1060 bool HasTemplateInfo = CurrentUnpackingBits->getNextBit(); 1061 unsigned NumTemplateArgs = Record.readInt(); 1062 1063 E->Base = Record.readSubExpr(); 1064 E->MemberDecl = Record.readDeclAs<ValueDecl>(); 1065 E->MemberDNLoc = Record.readDeclarationNameLoc(E->MemberDecl->getDeclName()); 1066 E->MemberLoc = Record.readSourceLocation(); 1067 E->MemberExprBits.IsArrow = CurrentUnpackingBits->getNextBit(); 1068 E->MemberExprBits.HasQualifier = HasQualifier; 1069 E->MemberExprBits.HasFoundDecl = HasFoundDecl; 1070 E->MemberExprBits.HasTemplateKWAndArgsInfo = HasTemplateInfo; 1071 E->MemberExprBits.HadMultipleCandidates = CurrentUnpackingBits->getNextBit(); 1072 E->MemberExprBits.NonOdrUseReason = 1073 CurrentUnpackingBits->getNextBits(/*Width=*/2); 1074 E->MemberExprBits.OperatorLoc = Record.readSourceLocation(); 1075 1076 if (HasQualifier) 1077 new (E->getTrailingObjects<NestedNameSpecifierLoc>()) 1078 NestedNameSpecifierLoc(Record.readNestedNameSpecifierLoc()); 1079 1080 if (HasFoundDecl) { 1081 auto *FoundD = Record.readDeclAs<NamedDecl>(); 1082 auto AS = (AccessSpecifier)CurrentUnpackingBits->getNextBits(/*Width=*/2); 1083 *E->getTrailingObjects<DeclAccessPair>() = DeclAccessPair::make(FoundD, AS); 1084 } 1085 1086 if (HasTemplateInfo) 1087 ReadTemplateKWAndArgsInfo( 1088 *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(), 1089 E->getTrailingObjects<TemplateArgumentLoc>(), NumTemplateArgs); 1090 } 1091 1092 void ASTStmtReader::VisitObjCIsaExpr(ObjCIsaExpr *E) { 1093 VisitExpr(E); 1094 E->setBase(Record.readSubExpr()); 1095 E->setIsaMemberLoc(readSourceLocation()); 1096 E->setOpLoc(readSourceLocation()); 1097 E->setArrow(Record.readInt()); 1098 } 1099 1100 void ASTStmtReader:: 1101 VisitObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) { 1102 VisitExpr(E); 1103 E->Operand = Record.readSubExpr(); 1104 E->setShouldCopy(Record.readInt()); 1105 } 1106 1107 void ASTStmtReader::VisitObjCBridgedCastExpr(ObjCBridgedCastExpr *E) { 1108 VisitExplicitCastExpr(E); 1109 E->LParenLoc = readSourceLocation(); 1110 E->BridgeKeywordLoc = readSourceLocation(); 1111 E->Kind = Record.readInt(); 1112 } 1113 1114 void ASTStmtReader::VisitCastExpr(CastExpr *E) { 1115 VisitExpr(E); 1116 unsigned NumBaseSpecs = Record.readInt(); 1117 assert(NumBaseSpecs == E->path_size()); 1118 1119 CurrentUnpackingBits.emplace(Record.readInt()); 1120 E->setCastKind((CastKind)CurrentUnpackingBits->getNextBits(/*Width=*/7)); 1121 unsigned HasFPFeatures = CurrentUnpackingBits->getNextBit(); 1122 assert(E->hasStoredFPFeatures() == HasFPFeatures); 1123 1124 E->setSubExpr(Record.readSubExpr()); 1125 1126 CastExpr::path_iterator BaseI = E->path_begin(); 1127 while (NumBaseSpecs--) { 1128 auto *BaseSpec = new (Record.getContext()) CXXBaseSpecifier; 1129 *BaseSpec = Record.readCXXBaseSpecifier(); 1130 *BaseI++ = BaseSpec; 1131 } 1132 if (HasFPFeatures) 1133 *E->getTrailingFPFeatures() = 1134 FPOptionsOverride::getFromOpaqueInt(Record.readInt()); 1135 } 1136 1137 void ASTStmtReader::VisitBinaryOperator(BinaryOperator *E) { 1138 VisitExpr(E); 1139 CurrentUnpackingBits.emplace(Record.readInt()); 1140 E->setOpcode( 1141 (BinaryOperator::Opcode)CurrentUnpackingBits->getNextBits(/*Width=*/6)); 1142 bool hasFP_Features = CurrentUnpackingBits->getNextBit(); 1143 E->setHasStoredFPFeatures(hasFP_Features); 1144 E->setExcludedOverflowPattern(CurrentUnpackingBits->getNextBit()); 1145 E->setLHS(Record.readSubExpr()); 1146 E->setRHS(Record.readSubExpr()); 1147 E->setOperatorLoc(readSourceLocation()); 1148 if (hasFP_Features) 1149 E->setStoredFPFeatures( 1150 FPOptionsOverride::getFromOpaqueInt(Record.readInt())); 1151 } 1152 1153 void ASTStmtReader::VisitCompoundAssignOperator(CompoundAssignOperator *E) { 1154 VisitBinaryOperator(E); 1155 E->setComputationLHSType(Record.readType()); 1156 E->setComputationResultType(Record.readType()); 1157 } 1158 1159 void ASTStmtReader::VisitConditionalOperator(ConditionalOperator *E) { 1160 VisitExpr(E); 1161 E->SubExprs[ConditionalOperator::COND] = Record.readSubExpr(); 1162 E->SubExprs[ConditionalOperator::LHS] = Record.readSubExpr(); 1163 E->SubExprs[ConditionalOperator::RHS] = Record.readSubExpr(); 1164 E->QuestionLoc = readSourceLocation(); 1165 E->ColonLoc = readSourceLocation(); 1166 } 1167 1168 void 1169 ASTStmtReader::VisitBinaryConditionalOperator(BinaryConditionalOperator *E) { 1170 VisitExpr(E); 1171 E->OpaqueValue = cast<OpaqueValueExpr>(Record.readSubExpr()); 1172 E->SubExprs[BinaryConditionalOperator::COMMON] = Record.readSubExpr(); 1173 E->SubExprs[BinaryConditionalOperator::COND] = Record.readSubExpr(); 1174 E->SubExprs[BinaryConditionalOperator::LHS] = Record.readSubExpr(); 1175 E->SubExprs[BinaryConditionalOperator::RHS] = Record.readSubExpr(); 1176 E->QuestionLoc = readSourceLocation(); 1177 E->ColonLoc = readSourceLocation(); 1178 } 1179 1180 void ASTStmtReader::VisitImplicitCastExpr(ImplicitCastExpr *E) { 1181 VisitCastExpr(E); 1182 E->setIsPartOfExplicitCast(CurrentUnpackingBits->getNextBit()); 1183 } 1184 1185 void ASTStmtReader::VisitExplicitCastExpr(ExplicitCastExpr *E) { 1186 VisitCastExpr(E); 1187 E->setTypeInfoAsWritten(readTypeSourceInfo()); 1188 } 1189 1190 void ASTStmtReader::VisitCStyleCastExpr(CStyleCastExpr *E) { 1191 VisitExplicitCastExpr(E); 1192 E->setLParenLoc(readSourceLocation()); 1193 E->setRParenLoc(readSourceLocation()); 1194 } 1195 1196 void ASTStmtReader::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) { 1197 VisitExpr(E); 1198 E->setLParenLoc(readSourceLocation()); 1199 E->setTypeSourceInfo(readTypeSourceInfo()); 1200 E->setInitializer(Record.readSubExpr()); 1201 E->setFileScope(Record.readInt()); 1202 } 1203 1204 void ASTStmtReader::VisitExtVectorElementExpr(ExtVectorElementExpr *E) { 1205 VisitExpr(E); 1206 E->setBase(Record.readSubExpr()); 1207 E->setAccessor(Record.readIdentifier()); 1208 E->setAccessorLoc(readSourceLocation()); 1209 } 1210 1211 void ASTStmtReader::VisitInitListExpr(InitListExpr *E) { 1212 VisitExpr(E); 1213 if (auto *SyntForm = cast_or_null<InitListExpr>(Record.readSubStmt())) 1214 E->setSyntacticForm(SyntForm); 1215 E->setLBraceLoc(readSourceLocation()); 1216 E->setRBraceLoc(readSourceLocation()); 1217 bool isArrayFiller = Record.readInt(); 1218 Expr *filler = nullptr; 1219 if (isArrayFiller) { 1220 filler = Record.readSubExpr(); 1221 E->ArrayFillerOrUnionFieldInit = filler; 1222 } else 1223 E->ArrayFillerOrUnionFieldInit = readDeclAs<FieldDecl>(); 1224 E->sawArrayRangeDesignator(Record.readInt()); 1225 unsigned NumInits = Record.readInt(); 1226 E->reserveInits(Record.getContext(), NumInits); 1227 if (isArrayFiller) { 1228 for (unsigned I = 0; I != NumInits; ++I) { 1229 Expr *init = Record.readSubExpr(); 1230 E->updateInit(Record.getContext(), I, init ? init : filler); 1231 } 1232 } else { 1233 for (unsigned I = 0; I != NumInits; ++I) 1234 E->updateInit(Record.getContext(), I, Record.readSubExpr()); 1235 } 1236 } 1237 1238 void ASTStmtReader::VisitDesignatedInitExpr(DesignatedInitExpr *E) { 1239 using Designator = DesignatedInitExpr::Designator; 1240 1241 VisitExpr(E); 1242 unsigned NumSubExprs = Record.readInt(); 1243 assert(NumSubExprs == E->getNumSubExprs() && "Wrong number of subexprs"); 1244 for (unsigned I = 0; I != NumSubExprs; ++I) 1245 E->setSubExpr(I, Record.readSubExpr()); 1246 E->setEqualOrColonLoc(readSourceLocation()); 1247 E->setGNUSyntax(Record.readInt()); 1248 1249 SmallVector<Designator, 4> Designators; 1250 while (Record.getIdx() < Record.size()) { 1251 switch ((DesignatorTypes)Record.readInt()) { 1252 case DESIG_FIELD_DECL: { 1253 auto *Field = readDeclAs<FieldDecl>(); 1254 SourceLocation DotLoc = readSourceLocation(); 1255 SourceLocation FieldLoc = readSourceLocation(); 1256 Designators.push_back(Designator::CreateFieldDesignator( 1257 Field->getIdentifier(), DotLoc, FieldLoc)); 1258 Designators.back().setFieldDecl(Field); 1259 break; 1260 } 1261 1262 case DESIG_FIELD_NAME: { 1263 const IdentifierInfo *Name = Record.readIdentifier(); 1264 SourceLocation DotLoc = readSourceLocation(); 1265 SourceLocation FieldLoc = readSourceLocation(); 1266 Designators.push_back(Designator::CreateFieldDesignator(Name, DotLoc, 1267 FieldLoc)); 1268 break; 1269 } 1270 1271 case DESIG_ARRAY: { 1272 unsigned Index = Record.readInt(); 1273 SourceLocation LBracketLoc = readSourceLocation(); 1274 SourceLocation RBracketLoc = readSourceLocation(); 1275 Designators.push_back(Designator::CreateArrayDesignator(Index, 1276 LBracketLoc, 1277 RBracketLoc)); 1278 break; 1279 } 1280 1281 case DESIG_ARRAY_RANGE: { 1282 unsigned Index = Record.readInt(); 1283 SourceLocation LBracketLoc = readSourceLocation(); 1284 SourceLocation EllipsisLoc = readSourceLocation(); 1285 SourceLocation RBracketLoc = readSourceLocation(); 1286 Designators.push_back(Designator::CreateArrayRangeDesignator( 1287 Index, LBracketLoc, EllipsisLoc, RBracketLoc)); 1288 break; 1289 } 1290 } 1291 } 1292 E->setDesignators(Record.getContext(), 1293 Designators.data(), Designators.size()); 1294 } 1295 1296 void ASTStmtReader::VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E) { 1297 VisitExpr(E); 1298 E->setBase(Record.readSubExpr()); 1299 E->setUpdater(Record.readSubExpr()); 1300 } 1301 1302 void ASTStmtReader::VisitNoInitExpr(NoInitExpr *E) { 1303 VisitExpr(E); 1304 } 1305 1306 void ASTStmtReader::VisitArrayInitLoopExpr(ArrayInitLoopExpr *E) { 1307 VisitExpr(E); 1308 E->SubExprs[0] = Record.readSubExpr(); 1309 E->SubExprs[1] = Record.readSubExpr(); 1310 } 1311 1312 void ASTStmtReader::VisitArrayInitIndexExpr(ArrayInitIndexExpr *E) { 1313 VisitExpr(E); 1314 } 1315 1316 void ASTStmtReader::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) { 1317 VisitExpr(E); 1318 } 1319 1320 void ASTStmtReader::VisitVAArgExpr(VAArgExpr *E) { 1321 VisitExpr(E); 1322 E->setSubExpr(Record.readSubExpr()); 1323 E->setWrittenTypeInfo(readTypeSourceInfo()); 1324 E->setBuiltinLoc(readSourceLocation()); 1325 E->setRParenLoc(readSourceLocation()); 1326 E->setIsMicrosoftABI(Record.readInt()); 1327 } 1328 1329 void ASTStmtReader::VisitSourceLocExpr(SourceLocExpr *E) { 1330 VisitExpr(E); 1331 E->ParentContext = readDeclAs<DeclContext>(); 1332 E->BuiltinLoc = readSourceLocation(); 1333 E->RParenLoc = readSourceLocation(); 1334 E->SourceLocExprBits.Kind = Record.readInt(); 1335 } 1336 1337 void ASTStmtReader::VisitEmbedExpr(EmbedExpr *E) { 1338 VisitExpr(E); 1339 E->EmbedKeywordLoc = readSourceLocation(); 1340 EmbedDataStorage *Data = new (Record.getContext()) EmbedDataStorage; 1341 Data->BinaryData = cast<StringLiteral>(Record.readSubStmt()); 1342 E->Data = Data; 1343 E->Begin = Record.readInt(); 1344 E->NumOfElements = Record.readInt(); 1345 } 1346 1347 void ASTStmtReader::VisitAddrLabelExpr(AddrLabelExpr *E) { 1348 VisitExpr(E); 1349 E->setAmpAmpLoc(readSourceLocation()); 1350 E->setLabelLoc(readSourceLocation()); 1351 E->setLabel(readDeclAs<LabelDecl>()); 1352 } 1353 1354 void ASTStmtReader::VisitStmtExpr(StmtExpr *E) { 1355 VisitExpr(E); 1356 E->setLParenLoc(readSourceLocation()); 1357 E->setRParenLoc(readSourceLocation()); 1358 E->setSubStmt(cast_or_null<CompoundStmt>(Record.readSubStmt())); 1359 E->StmtExprBits.TemplateDepth = Record.readInt(); 1360 } 1361 1362 void ASTStmtReader::VisitChooseExpr(ChooseExpr *E) { 1363 VisitExpr(E); 1364 E->setCond(Record.readSubExpr()); 1365 E->setLHS(Record.readSubExpr()); 1366 E->setRHS(Record.readSubExpr()); 1367 E->setBuiltinLoc(readSourceLocation()); 1368 E->setRParenLoc(readSourceLocation()); 1369 E->setIsConditionTrue(Record.readInt()); 1370 } 1371 1372 void ASTStmtReader::VisitGNUNullExpr(GNUNullExpr *E) { 1373 VisitExpr(E); 1374 E->setTokenLocation(readSourceLocation()); 1375 } 1376 1377 void ASTStmtReader::VisitShuffleVectorExpr(ShuffleVectorExpr *E) { 1378 VisitExpr(E); 1379 SmallVector<Expr *, 16> Exprs; 1380 unsigned NumExprs = Record.readInt(); 1381 while (NumExprs--) 1382 Exprs.push_back(Record.readSubExpr()); 1383 E->setExprs(Record.getContext(), Exprs); 1384 E->setBuiltinLoc(readSourceLocation()); 1385 E->setRParenLoc(readSourceLocation()); 1386 } 1387 1388 void ASTStmtReader::VisitConvertVectorExpr(ConvertVectorExpr *E) { 1389 VisitExpr(E); 1390 bool HasFPFeatures = CurrentUnpackingBits->getNextBit(); 1391 assert(HasFPFeatures == E->hasStoredFPFeatures()); 1392 E->BuiltinLoc = readSourceLocation(); 1393 E->RParenLoc = readSourceLocation(); 1394 E->TInfo = readTypeSourceInfo(); 1395 E->SrcExpr = Record.readSubExpr(); 1396 if (HasFPFeatures) 1397 E->setStoredFPFeatures( 1398 FPOptionsOverride::getFromOpaqueInt(Record.readInt())); 1399 } 1400 1401 void ASTStmtReader::VisitBlockExpr(BlockExpr *E) { 1402 VisitExpr(E); 1403 E->setBlockDecl(readDeclAs<BlockDecl>()); 1404 } 1405 1406 void ASTStmtReader::VisitGenericSelectionExpr(GenericSelectionExpr *E) { 1407 VisitExpr(E); 1408 1409 unsigned NumAssocs = Record.readInt(); 1410 assert(NumAssocs == E->getNumAssocs() && "Wrong NumAssocs!"); 1411 E->IsExprPredicate = Record.readInt(); 1412 E->ResultIndex = Record.readInt(); 1413 E->GenericSelectionExprBits.GenericLoc = readSourceLocation(); 1414 E->DefaultLoc = readSourceLocation(); 1415 E->RParenLoc = readSourceLocation(); 1416 1417 Stmt **Stmts = E->getTrailingObjects<Stmt *>(); 1418 // Add 1 to account for the controlling expression which is the first 1419 // expression in the trailing array of Stmt *. This is not needed for 1420 // the trailing array of TypeSourceInfo *. 1421 for (unsigned I = 0, N = NumAssocs + 1; I < N; ++I) 1422 Stmts[I] = Record.readSubExpr(); 1423 1424 TypeSourceInfo **TSIs = E->getTrailingObjects<TypeSourceInfo *>(); 1425 for (unsigned I = 0, N = NumAssocs; I < N; ++I) 1426 TSIs[I] = readTypeSourceInfo(); 1427 } 1428 1429 void ASTStmtReader::VisitPseudoObjectExpr(PseudoObjectExpr *E) { 1430 VisitExpr(E); 1431 unsigned numSemanticExprs = Record.readInt(); 1432 assert(numSemanticExprs + 1 == E->PseudoObjectExprBits.NumSubExprs); 1433 E->PseudoObjectExprBits.ResultIndex = Record.readInt(); 1434 1435 // Read the syntactic expression. 1436 E->getTrailingObjects()[0] = Record.readSubExpr(); 1437 1438 // Read all the semantic expressions. 1439 for (unsigned i = 0; i != numSemanticExprs; ++i) { 1440 Expr *subExpr = Record.readSubExpr(); 1441 E->getTrailingObjects()[i + 1] = subExpr; 1442 } 1443 } 1444 1445 void ASTStmtReader::VisitAtomicExpr(AtomicExpr *E) { 1446 VisitExpr(E); 1447 E->Op = AtomicExpr::AtomicOp(Record.readInt()); 1448 E->NumSubExprs = AtomicExpr::getNumSubExprs(E->Op); 1449 for (unsigned I = 0; I != E->NumSubExprs; ++I) 1450 E->SubExprs[I] = Record.readSubExpr(); 1451 E->BuiltinLoc = readSourceLocation(); 1452 E->RParenLoc = readSourceLocation(); 1453 } 1454 1455 //===----------------------------------------------------------------------===// 1456 // Objective-C Expressions and Statements 1457 1458 void ASTStmtReader::VisitObjCStringLiteral(ObjCStringLiteral *E) { 1459 VisitExpr(E); 1460 E->setString(cast<StringLiteral>(Record.readSubStmt())); 1461 E->setAtLoc(readSourceLocation()); 1462 } 1463 1464 void ASTStmtReader::VisitObjCBoxedExpr(ObjCBoxedExpr *E) { 1465 VisitExpr(E); 1466 // could be one of several IntegerLiteral, FloatLiteral, etc. 1467 E->SubExpr = Record.readSubStmt(); 1468 E->BoxingMethod = readDeclAs<ObjCMethodDecl>(); 1469 E->Range = readSourceRange(); 1470 } 1471 1472 void ASTStmtReader::VisitObjCArrayLiteral(ObjCArrayLiteral *E) { 1473 VisitExpr(E); 1474 unsigned NumElements = Record.readInt(); 1475 assert(NumElements == E->getNumElements() && "Wrong number of elements"); 1476 Expr **Elements = E->getElements(); 1477 for (unsigned I = 0, N = NumElements; I != N; ++I) 1478 Elements[I] = Record.readSubExpr(); 1479 E->ArrayWithObjectsMethod = readDeclAs<ObjCMethodDecl>(); 1480 E->Range = readSourceRange(); 1481 } 1482 1483 void ASTStmtReader::VisitObjCDictionaryLiteral(ObjCDictionaryLiteral *E) { 1484 VisitExpr(E); 1485 unsigned NumElements = Record.readInt(); 1486 assert(NumElements == E->getNumElements() && "Wrong number of elements"); 1487 bool HasPackExpansions = Record.readInt(); 1488 assert(HasPackExpansions == E->HasPackExpansions &&"Pack expansion mismatch"); 1489 auto *KeyValues = 1490 E->getTrailingObjects<ObjCDictionaryLiteral::KeyValuePair>(); 1491 auto *Expansions = 1492 E->getTrailingObjects<ObjCDictionaryLiteral::ExpansionData>(); 1493 for (unsigned I = 0; I != NumElements; ++I) { 1494 KeyValues[I].Key = Record.readSubExpr(); 1495 KeyValues[I].Value = Record.readSubExpr(); 1496 if (HasPackExpansions) { 1497 Expansions[I].EllipsisLoc = readSourceLocation(); 1498 Expansions[I].NumExpansionsPlusOne = Record.readInt(); 1499 } 1500 } 1501 E->DictWithObjectsMethod = readDeclAs<ObjCMethodDecl>(); 1502 E->Range = readSourceRange(); 1503 } 1504 1505 void ASTStmtReader::VisitObjCEncodeExpr(ObjCEncodeExpr *E) { 1506 VisitExpr(E); 1507 E->setEncodedTypeSourceInfo(readTypeSourceInfo()); 1508 E->setAtLoc(readSourceLocation()); 1509 E->setRParenLoc(readSourceLocation()); 1510 } 1511 1512 void ASTStmtReader::VisitObjCSelectorExpr(ObjCSelectorExpr *E) { 1513 VisitExpr(E); 1514 E->setSelector(Record.readSelector()); 1515 E->setAtLoc(readSourceLocation()); 1516 E->setRParenLoc(readSourceLocation()); 1517 } 1518 1519 void ASTStmtReader::VisitObjCProtocolExpr(ObjCProtocolExpr *E) { 1520 VisitExpr(E); 1521 E->setProtocol(readDeclAs<ObjCProtocolDecl>()); 1522 E->setAtLoc(readSourceLocation()); 1523 E->ProtoLoc = readSourceLocation(); 1524 E->setRParenLoc(readSourceLocation()); 1525 } 1526 1527 void ASTStmtReader::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) { 1528 VisitExpr(E); 1529 E->setDecl(readDeclAs<ObjCIvarDecl>()); 1530 E->setLocation(readSourceLocation()); 1531 E->setOpLoc(readSourceLocation()); 1532 E->setBase(Record.readSubExpr()); 1533 E->setIsArrow(Record.readInt()); 1534 E->setIsFreeIvar(Record.readInt()); 1535 } 1536 1537 void ASTStmtReader::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) { 1538 VisitExpr(E); 1539 unsigned MethodRefFlags = Record.readInt(); 1540 bool Implicit = Record.readInt() != 0; 1541 if (Implicit) { 1542 auto *Getter = readDeclAs<ObjCMethodDecl>(); 1543 auto *Setter = readDeclAs<ObjCMethodDecl>(); 1544 E->setImplicitProperty(Getter, Setter, MethodRefFlags); 1545 } else { 1546 E->setExplicitProperty(readDeclAs<ObjCPropertyDecl>(), MethodRefFlags); 1547 } 1548 E->setLocation(readSourceLocation()); 1549 E->setReceiverLocation(readSourceLocation()); 1550 switch (Record.readInt()) { 1551 case 0: 1552 E->setBase(Record.readSubExpr()); 1553 break; 1554 case 1: 1555 E->setSuperReceiver(Record.readType()); 1556 break; 1557 case 2: 1558 E->setClassReceiver(readDeclAs<ObjCInterfaceDecl>()); 1559 break; 1560 } 1561 } 1562 1563 void ASTStmtReader::VisitObjCSubscriptRefExpr(ObjCSubscriptRefExpr *E) { 1564 VisitExpr(E); 1565 E->setRBracket(readSourceLocation()); 1566 E->setBaseExpr(Record.readSubExpr()); 1567 E->setKeyExpr(Record.readSubExpr()); 1568 E->GetAtIndexMethodDecl = readDeclAs<ObjCMethodDecl>(); 1569 E->SetAtIndexMethodDecl = readDeclAs<ObjCMethodDecl>(); 1570 } 1571 1572 void ASTStmtReader::VisitObjCMessageExpr(ObjCMessageExpr *E) { 1573 VisitExpr(E); 1574 assert(Record.peekInt() == E->getNumArgs()); 1575 Record.skipInts(1); 1576 unsigned NumStoredSelLocs = Record.readInt(); 1577 E->SelLocsKind = Record.readInt(); 1578 E->setDelegateInitCall(Record.readInt()); 1579 E->IsImplicit = Record.readInt(); 1580 auto Kind = static_cast<ObjCMessageExpr::ReceiverKind>(Record.readInt()); 1581 switch (Kind) { 1582 case ObjCMessageExpr::Instance: 1583 E->setInstanceReceiver(Record.readSubExpr()); 1584 break; 1585 1586 case ObjCMessageExpr::Class: 1587 E->setClassReceiver(readTypeSourceInfo()); 1588 break; 1589 1590 case ObjCMessageExpr::SuperClass: 1591 case ObjCMessageExpr::SuperInstance: { 1592 QualType T = Record.readType(); 1593 SourceLocation SuperLoc = readSourceLocation(); 1594 E->setSuper(SuperLoc, T, Kind == ObjCMessageExpr::SuperInstance); 1595 break; 1596 } 1597 } 1598 1599 assert(Kind == E->getReceiverKind()); 1600 1601 if (Record.readInt()) 1602 E->setMethodDecl(readDeclAs<ObjCMethodDecl>()); 1603 else 1604 E->setSelector(Record.readSelector()); 1605 1606 E->LBracLoc = readSourceLocation(); 1607 E->RBracLoc = readSourceLocation(); 1608 1609 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) 1610 E->setArg(I, Record.readSubExpr()); 1611 1612 SourceLocation *Locs = E->getStoredSelLocs(); 1613 for (unsigned I = 0; I != NumStoredSelLocs; ++I) 1614 Locs[I] = readSourceLocation(); 1615 } 1616 1617 void ASTStmtReader::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) { 1618 VisitStmt(S); 1619 S->setElement(Record.readSubStmt()); 1620 S->setCollection(Record.readSubExpr()); 1621 S->setBody(Record.readSubStmt()); 1622 S->setForLoc(readSourceLocation()); 1623 S->setRParenLoc(readSourceLocation()); 1624 } 1625 1626 void ASTStmtReader::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) { 1627 VisitStmt(S); 1628 S->setCatchBody(Record.readSubStmt()); 1629 S->setCatchParamDecl(readDeclAs<VarDecl>()); 1630 S->setAtCatchLoc(readSourceLocation()); 1631 S->setRParenLoc(readSourceLocation()); 1632 } 1633 1634 void ASTStmtReader::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) { 1635 VisitStmt(S); 1636 S->setFinallyBody(Record.readSubStmt()); 1637 S->setAtFinallyLoc(readSourceLocation()); 1638 } 1639 1640 void ASTStmtReader::VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S) { 1641 VisitStmt(S); // FIXME: no test coverage. 1642 S->setSubStmt(Record.readSubStmt()); 1643 S->setAtLoc(readSourceLocation()); 1644 } 1645 1646 void ASTStmtReader::VisitObjCAtTryStmt(ObjCAtTryStmt *S) { 1647 VisitStmt(S); 1648 assert(Record.peekInt() == S->getNumCatchStmts()); 1649 Record.skipInts(1); 1650 bool HasFinally = Record.readInt(); 1651 S->setTryBody(Record.readSubStmt()); 1652 for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I) 1653 S->setCatchStmt(I, cast_or_null<ObjCAtCatchStmt>(Record.readSubStmt())); 1654 1655 if (HasFinally) 1656 S->setFinallyStmt(Record.readSubStmt()); 1657 S->setAtTryLoc(readSourceLocation()); 1658 } 1659 1660 void ASTStmtReader::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) { 1661 VisitStmt(S); // FIXME: no test coverage. 1662 S->setSynchExpr(Record.readSubStmt()); 1663 S->setSynchBody(Record.readSubStmt()); 1664 S->setAtSynchronizedLoc(readSourceLocation()); 1665 } 1666 1667 void ASTStmtReader::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) { 1668 VisitStmt(S); // FIXME: no test coverage. 1669 S->setThrowExpr(Record.readSubStmt()); 1670 S->setThrowLoc(readSourceLocation()); 1671 } 1672 1673 void ASTStmtReader::VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) { 1674 VisitExpr(E); 1675 E->setValue(Record.readInt()); 1676 E->setLocation(readSourceLocation()); 1677 } 1678 1679 void ASTStmtReader::VisitObjCAvailabilityCheckExpr(ObjCAvailabilityCheckExpr *E) { 1680 VisitExpr(E); 1681 SourceRange R = Record.readSourceRange(); 1682 E->AtLoc = R.getBegin(); 1683 E->RParen = R.getEnd(); 1684 E->VersionToCheck = Record.readVersionTuple(); 1685 } 1686 1687 //===----------------------------------------------------------------------===// 1688 // C++ Expressions and Statements 1689 //===----------------------------------------------------------------------===// 1690 1691 void ASTStmtReader::VisitCXXCatchStmt(CXXCatchStmt *S) { 1692 VisitStmt(S); 1693 S->CatchLoc = readSourceLocation(); 1694 S->ExceptionDecl = readDeclAs<VarDecl>(); 1695 S->HandlerBlock = Record.readSubStmt(); 1696 } 1697 1698 void ASTStmtReader::VisitCXXTryStmt(CXXTryStmt *S) { 1699 VisitStmt(S); 1700 assert(Record.peekInt() == S->getNumHandlers() && "NumStmtFields is wrong ?"); 1701 Record.skipInts(1); 1702 S->TryLoc = readSourceLocation(); 1703 S->getStmts()[0] = Record.readSubStmt(); 1704 for (unsigned i = 0, e = S->getNumHandlers(); i != e; ++i) 1705 S->getStmts()[i + 1] = Record.readSubStmt(); 1706 } 1707 1708 void ASTStmtReader::VisitCXXForRangeStmt(CXXForRangeStmt *S) { 1709 VisitStmt(S); 1710 S->ForLoc = readSourceLocation(); 1711 S->CoawaitLoc = readSourceLocation(); 1712 S->ColonLoc = readSourceLocation(); 1713 S->RParenLoc = readSourceLocation(); 1714 S->setInit(Record.readSubStmt()); 1715 S->setRangeStmt(Record.readSubStmt()); 1716 S->setBeginStmt(Record.readSubStmt()); 1717 S->setEndStmt(Record.readSubStmt()); 1718 S->setCond(Record.readSubExpr()); 1719 S->setInc(Record.readSubExpr()); 1720 S->setLoopVarStmt(Record.readSubStmt()); 1721 S->setBody(Record.readSubStmt()); 1722 } 1723 1724 void ASTStmtReader::VisitMSDependentExistsStmt(MSDependentExistsStmt *S) { 1725 VisitStmt(S); 1726 S->KeywordLoc = readSourceLocation(); 1727 S->IsIfExists = Record.readInt(); 1728 S->QualifierLoc = Record.readNestedNameSpecifierLoc(); 1729 S->NameInfo = Record.readDeclarationNameInfo(); 1730 S->SubStmt = Record.readSubStmt(); 1731 } 1732 1733 void ASTStmtReader::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) { 1734 VisitCallExpr(E); 1735 E->CXXOperatorCallExprBits.OperatorKind = Record.readInt(); 1736 E->BeginLoc = Record.readSourceLocation(); 1737 } 1738 1739 void ASTStmtReader::VisitCXXRewrittenBinaryOperator( 1740 CXXRewrittenBinaryOperator *E) { 1741 VisitExpr(E); 1742 E->CXXRewrittenBinaryOperatorBits.IsReversed = Record.readInt(); 1743 E->SemanticForm = Record.readSubExpr(); 1744 } 1745 1746 void ASTStmtReader::VisitCXXConstructExpr(CXXConstructExpr *E) { 1747 VisitExpr(E); 1748 1749 unsigned NumArgs = Record.readInt(); 1750 assert((NumArgs == E->getNumArgs()) && "Wrong NumArgs!"); 1751 1752 E->CXXConstructExprBits.Elidable = Record.readInt(); 1753 E->CXXConstructExprBits.HadMultipleCandidates = Record.readInt(); 1754 E->CXXConstructExprBits.ListInitialization = Record.readInt(); 1755 E->CXXConstructExprBits.StdInitListInitialization = Record.readInt(); 1756 E->CXXConstructExprBits.ZeroInitialization = Record.readInt(); 1757 E->CXXConstructExprBits.ConstructionKind = Record.readInt(); 1758 E->CXXConstructExprBits.IsImmediateEscalating = Record.readInt(); 1759 E->CXXConstructExprBits.Loc = readSourceLocation(); 1760 E->Constructor = readDeclAs<CXXConstructorDecl>(); 1761 E->ParenOrBraceRange = readSourceRange(); 1762 1763 for (unsigned I = 0; I != NumArgs; ++I) 1764 E->setArg(I, Record.readSubExpr()); 1765 } 1766 1767 void ASTStmtReader::VisitCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr *E) { 1768 VisitExpr(E); 1769 E->Constructor = readDeclAs<CXXConstructorDecl>(); 1770 E->Loc = readSourceLocation(); 1771 E->ConstructsVirtualBase = Record.readInt(); 1772 E->InheritedFromVirtualBase = Record.readInt(); 1773 } 1774 1775 void ASTStmtReader::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) { 1776 VisitCXXConstructExpr(E); 1777 E->TSI = readTypeSourceInfo(); 1778 } 1779 1780 void ASTStmtReader::VisitLambdaExpr(LambdaExpr *E) { 1781 VisitExpr(E); 1782 unsigned NumCaptures = Record.readInt(); 1783 (void)NumCaptures; 1784 assert(NumCaptures == E->LambdaExprBits.NumCaptures); 1785 E->IntroducerRange = readSourceRange(); 1786 E->LambdaExprBits.CaptureDefault = Record.readInt(); 1787 E->CaptureDefaultLoc = readSourceLocation(); 1788 E->LambdaExprBits.ExplicitParams = Record.readInt(); 1789 E->LambdaExprBits.ExplicitResultType = Record.readInt(); 1790 E->ClosingBrace = readSourceLocation(); 1791 1792 // Read capture initializers. 1793 for (LambdaExpr::capture_init_iterator C = E->capture_init_begin(), 1794 CEnd = E->capture_init_end(); 1795 C != CEnd; ++C) 1796 *C = Record.readSubExpr(); 1797 1798 // The body will be lazily deserialized when needed from the call operator 1799 // declaration. 1800 } 1801 1802 void 1803 ASTStmtReader::VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) { 1804 VisitExpr(E); 1805 E->SubExpr = Record.readSubExpr(); 1806 } 1807 1808 void ASTStmtReader::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) { 1809 VisitExplicitCastExpr(E); 1810 SourceRange R = readSourceRange(); 1811 E->Loc = R.getBegin(); 1812 E->RParenLoc = R.getEnd(); 1813 if (CurrentUnpackingBits->getNextBit()) 1814 E->AngleBrackets = readSourceRange(); 1815 } 1816 1817 void ASTStmtReader::VisitCXXStaticCastExpr(CXXStaticCastExpr *E) { 1818 return VisitCXXNamedCastExpr(E); 1819 } 1820 1821 void ASTStmtReader::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E) { 1822 return VisitCXXNamedCastExpr(E); 1823 } 1824 1825 void ASTStmtReader::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E) { 1826 return VisitCXXNamedCastExpr(E); 1827 } 1828 1829 void ASTStmtReader::VisitCXXAddrspaceCastExpr(CXXAddrspaceCastExpr *E) { 1830 return VisitCXXNamedCastExpr(E); 1831 } 1832 1833 void ASTStmtReader::VisitCXXConstCastExpr(CXXConstCastExpr *E) { 1834 return VisitCXXNamedCastExpr(E); 1835 } 1836 1837 void ASTStmtReader::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) { 1838 VisitExplicitCastExpr(E); 1839 E->setLParenLoc(readSourceLocation()); 1840 E->setRParenLoc(readSourceLocation()); 1841 } 1842 1843 void ASTStmtReader::VisitBuiltinBitCastExpr(BuiltinBitCastExpr *E) { 1844 VisitExplicitCastExpr(E); 1845 E->KWLoc = readSourceLocation(); 1846 E->RParenLoc = readSourceLocation(); 1847 } 1848 1849 void ASTStmtReader::VisitUserDefinedLiteral(UserDefinedLiteral *E) { 1850 VisitCallExpr(E); 1851 E->UDSuffixLoc = readSourceLocation(); 1852 } 1853 1854 void ASTStmtReader::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) { 1855 VisitExpr(E); 1856 E->setValue(Record.readInt()); 1857 E->setLocation(readSourceLocation()); 1858 } 1859 1860 void ASTStmtReader::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) { 1861 VisitExpr(E); 1862 E->setLocation(readSourceLocation()); 1863 } 1864 1865 void ASTStmtReader::VisitCXXTypeidExpr(CXXTypeidExpr *E) { 1866 VisitExpr(E); 1867 E->setSourceRange(readSourceRange()); 1868 if (E->isTypeOperand()) 1869 E->Operand = readTypeSourceInfo(); 1870 else 1871 E->Operand = Record.readSubExpr(); 1872 } 1873 1874 void ASTStmtReader::VisitCXXThisExpr(CXXThisExpr *E) { 1875 VisitExpr(E); 1876 E->setLocation(readSourceLocation()); 1877 E->setImplicit(Record.readInt()); 1878 E->setCapturedByCopyInLambdaWithExplicitObjectParameter(Record.readInt()); 1879 } 1880 1881 void ASTStmtReader::VisitCXXThrowExpr(CXXThrowExpr *E) { 1882 VisitExpr(E); 1883 E->CXXThrowExprBits.ThrowLoc = readSourceLocation(); 1884 E->Operand = Record.readSubExpr(); 1885 E->CXXThrowExprBits.IsThrownVariableInScope = Record.readInt(); 1886 } 1887 1888 void ASTStmtReader::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) { 1889 VisitExpr(E); 1890 E->Param = readDeclAs<ParmVarDecl>(); 1891 E->UsedContext = readDeclAs<DeclContext>(); 1892 E->CXXDefaultArgExprBits.Loc = readSourceLocation(); 1893 E->CXXDefaultArgExprBits.HasRewrittenInit = Record.readInt(); 1894 if (E->CXXDefaultArgExprBits.HasRewrittenInit) 1895 *E->getTrailingObjects() = Record.readSubExpr(); 1896 } 1897 1898 void ASTStmtReader::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) { 1899 VisitExpr(E); 1900 E->CXXDefaultInitExprBits.HasRewrittenInit = Record.readInt(); 1901 E->Field = readDeclAs<FieldDecl>(); 1902 E->UsedContext = readDeclAs<DeclContext>(); 1903 E->CXXDefaultInitExprBits.Loc = readSourceLocation(); 1904 if (E->CXXDefaultInitExprBits.HasRewrittenInit) 1905 *E->getTrailingObjects() = Record.readSubExpr(); 1906 } 1907 1908 void ASTStmtReader::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) { 1909 VisitExpr(E); 1910 E->setTemporary(Record.readCXXTemporary()); 1911 E->setSubExpr(Record.readSubExpr()); 1912 } 1913 1914 void ASTStmtReader::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) { 1915 VisitExpr(E); 1916 E->TypeInfo = readTypeSourceInfo(); 1917 E->CXXScalarValueInitExprBits.RParenLoc = readSourceLocation(); 1918 } 1919 1920 void ASTStmtReader::VisitCXXNewExpr(CXXNewExpr *E) { 1921 VisitExpr(E); 1922 1923 bool IsArray = Record.readInt(); 1924 bool HasInit = Record.readInt(); 1925 unsigned NumPlacementArgs = Record.readInt(); 1926 bool IsParenTypeId = Record.readInt(); 1927 1928 E->CXXNewExprBits.IsGlobalNew = Record.readInt(); 1929 E->CXXNewExprBits.ShouldPassAlignment = Record.readInt(); 1930 E->CXXNewExprBits.ShouldPassTypeIdentity = Record.readInt(); 1931 E->CXXNewExprBits.UsualArrayDeleteWantsSize = Record.readInt(); 1932 E->CXXNewExprBits.HasInitializer = Record.readInt(); 1933 E->CXXNewExprBits.StoredInitializationStyle = Record.readInt(); 1934 1935 assert((IsArray == E->isArray()) && "Wrong IsArray!"); 1936 assert((HasInit == E->hasInitializer()) && "Wrong HasInit!"); 1937 assert((NumPlacementArgs == E->getNumPlacementArgs()) && 1938 "Wrong NumPlacementArgs!"); 1939 assert((IsParenTypeId == E->isParenTypeId()) && "Wrong IsParenTypeId!"); 1940 (void)IsArray; 1941 (void)HasInit; 1942 (void)NumPlacementArgs; 1943 1944 E->setOperatorNew(readDeclAs<FunctionDecl>()); 1945 E->setOperatorDelete(readDeclAs<FunctionDecl>()); 1946 E->AllocatedTypeInfo = readTypeSourceInfo(); 1947 if (IsParenTypeId) 1948 E->getTrailingObjects<SourceRange>()[0] = readSourceRange(); 1949 E->Range = readSourceRange(); 1950 E->DirectInitRange = readSourceRange(); 1951 1952 // Install all the subexpressions. 1953 for (CXXNewExpr::raw_arg_iterator I = E->raw_arg_begin(), 1954 N = E->raw_arg_end(); 1955 I != N; ++I) 1956 *I = Record.readSubStmt(); 1957 } 1958 1959 void ASTStmtReader::VisitCXXDeleteExpr(CXXDeleteExpr *E) { 1960 VisitExpr(E); 1961 E->CXXDeleteExprBits.GlobalDelete = Record.readInt(); 1962 E->CXXDeleteExprBits.ArrayForm = Record.readInt(); 1963 E->CXXDeleteExprBits.ArrayFormAsWritten = Record.readInt(); 1964 E->CXXDeleteExprBits.UsualArrayDeleteWantsSize = Record.readInt(); 1965 E->OperatorDelete = readDeclAs<FunctionDecl>(); 1966 E->Argument = Record.readSubExpr(); 1967 E->CXXDeleteExprBits.Loc = readSourceLocation(); 1968 } 1969 1970 void ASTStmtReader::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) { 1971 VisitExpr(E); 1972 1973 E->Base = Record.readSubExpr(); 1974 E->IsArrow = Record.readInt(); 1975 E->OperatorLoc = readSourceLocation(); 1976 E->QualifierLoc = Record.readNestedNameSpecifierLoc(); 1977 E->ScopeType = readTypeSourceInfo(); 1978 E->ColonColonLoc = readSourceLocation(); 1979 E->TildeLoc = readSourceLocation(); 1980 1981 IdentifierInfo *II = Record.readIdentifier(); 1982 if (II) 1983 E->setDestroyedType(II, readSourceLocation()); 1984 else 1985 E->setDestroyedType(readTypeSourceInfo()); 1986 } 1987 1988 void ASTStmtReader::VisitExprWithCleanups(ExprWithCleanups *E) { 1989 VisitExpr(E); 1990 1991 unsigned NumObjects = Record.readInt(); 1992 assert(NumObjects == E->getNumObjects()); 1993 for (unsigned i = 0; i != NumObjects; ++i) { 1994 unsigned CleanupKind = Record.readInt(); 1995 ExprWithCleanups::CleanupObject Obj; 1996 if (CleanupKind == COK_Block) 1997 Obj = readDeclAs<BlockDecl>(); 1998 else if (CleanupKind == COK_CompoundLiteral) 1999 Obj = cast<CompoundLiteralExpr>(Record.readSubExpr()); 2000 else 2001 llvm_unreachable("unexpected cleanup object type"); 2002 E->getTrailingObjects()[i] = Obj; 2003 } 2004 2005 E->ExprWithCleanupsBits.CleanupsHaveSideEffects = Record.readInt(); 2006 E->SubExpr = Record.readSubExpr(); 2007 } 2008 2009 void ASTStmtReader::VisitCXXDependentScopeMemberExpr( 2010 CXXDependentScopeMemberExpr *E) { 2011 VisitExpr(E); 2012 2013 unsigned NumTemplateArgs = Record.readInt(); 2014 CurrentUnpackingBits.emplace(Record.readInt()); 2015 bool HasTemplateKWAndArgsInfo = CurrentUnpackingBits->getNextBit(); 2016 bool HasFirstQualifierFoundInScope = CurrentUnpackingBits->getNextBit(); 2017 2018 assert((HasTemplateKWAndArgsInfo == E->hasTemplateKWAndArgsInfo()) && 2019 "Wrong HasTemplateKWAndArgsInfo!"); 2020 assert( 2021 (HasFirstQualifierFoundInScope == E->hasFirstQualifierFoundInScope()) && 2022 "Wrong HasFirstQualifierFoundInScope!"); 2023 2024 if (HasTemplateKWAndArgsInfo) 2025 ReadTemplateKWAndArgsInfo( 2026 *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(), 2027 E->getTrailingObjects<TemplateArgumentLoc>(), NumTemplateArgs); 2028 2029 assert((NumTemplateArgs == E->getNumTemplateArgs()) && 2030 "Wrong NumTemplateArgs!"); 2031 2032 E->CXXDependentScopeMemberExprBits.IsArrow = 2033 CurrentUnpackingBits->getNextBit(); 2034 2035 E->BaseType = Record.readType(); 2036 E->QualifierLoc = Record.readNestedNameSpecifierLoc(); 2037 // not ImplicitAccess 2038 if (CurrentUnpackingBits->getNextBit()) 2039 E->Base = Record.readSubExpr(); 2040 else 2041 E->Base = nullptr; 2042 2043 E->CXXDependentScopeMemberExprBits.OperatorLoc = readSourceLocation(); 2044 2045 if (HasFirstQualifierFoundInScope) 2046 *E->getTrailingObjects<NamedDecl *>() = readDeclAs<NamedDecl>(); 2047 2048 E->MemberNameInfo = Record.readDeclarationNameInfo(); 2049 } 2050 2051 void 2052 ASTStmtReader::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) { 2053 VisitExpr(E); 2054 2055 if (CurrentUnpackingBits->getNextBit()) // HasTemplateKWAndArgsInfo 2056 ReadTemplateKWAndArgsInfo( 2057 *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(), 2058 E->getTrailingObjects<TemplateArgumentLoc>(), 2059 /*NumTemplateArgs=*/CurrentUnpackingBits->getNextBits(/*Width=*/16)); 2060 2061 E->QualifierLoc = Record.readNestedNameSpecifierLoc(); 2062 E->NameInfo = Record.readDeclarationNameInfo(); 2063 } 2064 2065 void 2066 ASTStmtReader::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) { 2067 VisitExpr(E); 2068 assert(Record.peekInt() == E->getNumArgs() && 2069 "Read wrong record during creation ?"); 2070 Record.skipInts(1); 2071 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) 2072 E->setArg(I, Record.readSubExpr()); 2073 E->TypeAndInitForm.setPointer(readTypeSourceInfo()); 2074 E->setLParenLoc(readSourceLocation()); 2075 E->setRParenLoc(readSourceLocation()); 2076 E->TypeAndInitForm.setInt(Record.readInt()); 2077 } 2078 2079 void ASTStmtReader::VisitOverloadExpr(OverloadExpr *E) { 2080 VisitExpr(E); 2081 2082 unsigned NumResults = Record.readInt(); 2083 CurrentUnpackingBits.emplace(Record.readInt()); 2084 bool HasTemplateKWAndArgsInfo = CurrentUnpackingBits->getNextBit(); 2085 assert((E->getNumDecls() == NumResults) && "Wrong NumResults!"); 2086 assert((E->hasTemplateKWAndArgsInfo() == HasTemplateKWAndArgsInfo) && 2087 "Wrong HasTemplateKWAndArgsInfo!"); 2088 2089 if (HasTemplateKWAndArgsInfo) { 2090 unsigned NumTemplateArgs = Record.readInt(); 2091 ReadTemplateKWAndArgsInfo(*E->getTrailingASTTemplateKWAndArgsInfo(), 2092 E->getTrailingTemplateArgumentLoc(), 2093 NumTemplateArgs); 2094 assert((E->getNumTemplateArgs() == NumTemplateArgs) && 2095 "Wrong NumTemplateArgs!"); 2096 } 2097 2098 UnresolvedSet<8> Decls; 2099 for (unsigned I = 0; I != NumResults; ++I) { 2100 auto *D = readDeclAs<NamedDecl>(); 2101 auto AS = (AccessSpecifier)Record.readInt(); 2102 Decls.addDecl(D, AS); 2103 } 2104 2105 DeclAccessPair *Results = E->getTrailingResults(); 2106 UnresolvedSetIterator Iter = Decls.begin(); 2107 for (unsigned I = 0; I != NumResults; ++I) { 2108 Results[I] = (Iter + I).getPair(); 2109 } 2110 2111 E->NameInfo = Record.readDeclarationNameInfo(); 2112 E->QualifierLoc = Record.readNestedNameSpecifierLoc(); 2113 } 2114 2115 void ASTStmtReader::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) { 2116 VisitOverloadExpr(E); 2117 E->UnresolvedMemberExprBits.IsArrow = CurrentUnpackingBits->getNextBit(); 2118 E->UnresolvedMemberExprBits.HasUnresolvedUsing = 2119 CurrentUnpackingBits->getNextBit(); 2120 2121 if (/*!isImplicitAccess=*/CurrentUnpackingBits->getNextBit()) 2122 E->Base = Record.readSubExpr(); 2123 else 2124 E->Base = nullptr; 2125 2126 E->OperatorLoc = readSourceLocation(); 2127 2128 E->BaseType = Record.readType(); 2129 } 2130 2131 void ASTStmtReader::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) { 2132 VisitOverloadExpr(E); 2133 E->UnresolvedLookupExprBits.RequiresADL = CurrentUnpackingBits->getNextBit(); 2134 E->NamingClass = readDeclAs<CXXRecordDecl>(); 2135 } 2136 2137 void ASTStmtReader::VisitTypeTraitExpr(TypeTraitExpr *E) { 2138 VisitExpr(E); 2139 E->TypeTraitExprBits.IsBooleanTypeTrait = Record.readInt(); 2140 E->TypeTraitExprBits.NumArgs = Record.readInt(); 2141 E->TypeTraitExprBits.Kind = Record.readInt(); 2142 2143 if (E->TypeTraitExprBits.IsBooleanTypeTrait) 2144 E->TypeTraitExprBits.Value = Record.readInt(); 2145 else 2146 *E->getTrailingObjects<APValue>() = Record.readAPValue(); 2147 2148 SourceRange Range = readSourceRange(); 2149 E->Loc = Range.getBegin(); 2150 E->RParenLoc = Range.getEnd(); 2151 2152 auto **Args = E->getTrailingObjects<TypeSourceInfo *>(); 2153 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) 2154 Args[I] = readTypeSourceInfo(); 2155 } 2156 2157 void ASTStmtReader::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) { 2158 VisitExpr(E); 2159 E->ArrayTypeTraitExprBits.ATT = (ArrayTypeTrait)Record.readInt(); 2160 E->Value = (unsigned int)Record.readInt(); 2161 SourceRange Range = readSourceRange(); 2162 E->Loc = Range.getBegin(); 2163 E->RParen = Range.getEnd(); 2164 E->QueriedType = readTypeSourceInfo(); 2165 E->Dimension = Record.readSubExpr(); 2166 } 2167 2168 void ASTStmtReader::VisitExpressionTraitExpr(ExpressionTraitExpr *E) { 2169 VisitExpr(E); 2170 E->ExpressionTraitExprBits.ET = (ExpressionTrait)Record.readInt(); 2171 E->ExpressionTraitExprBits.Value = (bool)Record.readInt(); 2172 SourceRange Range = readSourceRange(); 2173 E->QueriedExpression = Record.readSubExpr(); 2174 E->Loc = Range.getBegin(); 2175 E->RParen = Range.getEnd(); 2176 } 2177 2178 void ASTStmtReader::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) { 2179 VisitExpr(E); 2180 E->CXXNoexceptExprBits.Value = Record.readInt(); 2181 E->Range = readSourceRange(); 2182 E->Operand = Record.readSubExpr(); 2183 } 2184 2185 void ASTStmtReader::VisitPackExpansionExpr(PackExpansionExpr *E) { 2186 VisitExpr(E); 2187 E->EllipsisLoc = readSourceLocation(); 2188 E->NumExpansions = Record.readInt(); 2189 E->Pattern = Record.readSubExpr(); 2190 } 2191 2192 void ASTStmtReader::VisitSizeOfPackExpr(SizeOfPackExpr *E) { 2193 VisitExpr(E); 2194 unsigned NumPartialArgs = Record.readInt(); 2195 E->OperatorLoc = readSourceLocation(); 2196 E->PackLoc = readSourceLocation(); 2197 E->RParenLoc = readSourceLocation(); 2198 E->Pack = Record.readDeclAs<NamedDecl>(); 2199 if (E->isPartiallySubstituted()) { 2200 assert(E->Length == NumPartialArgs); 2201 for (auto *I = E->getTrailingObjects(), *E = I + NumPartialArgs; I != E; 2202 ++I) 2203 new (I) TemplateArgument(Record.readTemplateArgument()); 2204 } else if (!E->isValueDependent()) { 2205 E->Length = Record.readInt(); 2206 } 2207 } 2208 2209 void ASTStmtReader::VisitPackIndexingExpr(PackIndexingExpr *E) { 2210 VisitExpr(E); 2211 E->PackIndexingExprBits.TransformedExpressions = Record.readInt(); 2212 E->PackIndexingExprBits.FullySubstituted = Record.readInt(); 2213 E->EllipsisLoc = readSourceLocation(); 2214 E->RSquareLoc = readSourceLocation(); 2215 E->SubExprs[0] = Record.readStmt(); 2216 E->SubExprs[1] = Record.readStmt(); 2217 auto **Exprs = E->getTrailingObjects(); 2218 for (unsigned I = 0; I < E->PackIndexingExprBits.TransformedExpressions; ++I) 2219 Exprs[I] = Record.readExpr(); 2220 } 2221 2222 void ASTStmtReader::VisitSubstNonTypeTemplateParmExpr( 2223 SubstNonTypeTemplateParmExpr *E) { 2224 VisitExpr(E); 2225 E->AssociatedDeclAndRef.setPointer(readDeclAs<Decl>()); 2226 E->AssociatedDeclAndRef.setInt(CurrentUnpackingBits->getNextBit()); 2227 E->Index = CurrentUnpackingBits->getNextBits(/*Width=*/12); 2228 E->PackIndex = Record.readUnsignedOrNone().toInternalRepresentation(); 2229 E->Final = CurrentUnpackingBits->getNextBit(); 2230 E->SubstNonTypeTemplateParmExprBits.NameLoc = readSourceLocation(); 2231 E->Replacement = Record.readSubExpr(); 2232 } 2233 2234 void ASTStmtReader::VisitSubstNonTypeTemplateParmPackExpr( 2235 SubstNonTypeTemplateParmPackExpr *E) { 2236 VisitExpr(E); 2237 E->AssociatedDecl = readDeclAs<Decl>(); 2238 E->Final = CurrentUnpackingBits->getNextBit(); 2239 E->Index = Record.readInt(); 2240 TemplateArgument ArgPack = Record.readTemplateArgument(); 2241 if (ArgPack.getKind() != TemplateArgument::Pack) 2242 return; 2243 2244 E->Arguments = ArgPack.pack_begin(); 2245 E->NumArguments = ArgPack.pack_size(); 2246 E->NameLoc = readSourceLocation(); 2247 } 2248 2249 void ASTStmtReader::VisitFunctionParmPackExpr(FunctionParmPackExpr *E) { 2250 VisitExpr(E); 2251 E->NumParameters = Record.readInt(); 2252 E->ParamPack = readDeclAs<ValueDecl>(); 2253 E->NameLoc = readSourceLocation(); 2254 auto **Parms = E->getTrailingObjects(); 2255 for (unsigned i = 0, n = E->NumParameters; i != n; ++i) 2256 Parms[i] = readDeclAs<ValueDecl>(); 2257 } 2258 2259 void ASTStmtReader::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) { 2260 VisitExpr(E); 2261 bool HasMaterialzedDecl = Record.readInt(); 2262 if (HasMaterialzedDecl) 2263 E->State = cast<LifetimeExtendedTemporaryDecl>(Record.readDecl()); 2264 else 2265 E->State = Record.readSubExpr(); 2266 } 2267 2268 void ASTStmtReader::VisitCXXFoldExpr(CXXFoldExpr *E) { 2269 VisitExpr(E); 2270 E->LParenLoc = readSourceLocation(); 2271 E->EllipsisLoc = readSourceLocation(); 2272 E->RParenLoc = readSourceLocation(); 2273 E->NumExpansions = Record.readUnsignedOrNone(); 2274 E->SubExprs[0] = Record.readSubExpr(); 2275 E->SubExprs[1] = Record.readSubExpr(); 2276 E->SubExprs[2] = Record.readSubExpr(); 2277 E->CXXFoldExprBits.Opcode = (BinaryOperatorKind)Record.readInt(); 2278 } 2279 2280 void ASTStmtReader::VisitCXXParenListInitExpr(CXXParenListInitExpr *E) { 2281 VisitExpr(E); 2282 unsigned ExpectedNumExprs = Record.readInt(); 2283 assert(E->NumExprs == ExpectedNumExprs && 2284 "expected number of expressions does not equal the actual number of " 2285 "serialized expressions."); 2286 E->NumUserSpecifiedExprs = Record.readInt(); 2287 E->InitLoc = readSourceLocation(); 2288 E->LParenLoc = readSourceLocation(); 2289 E->RParenLoc = readSourceLocation(); 2290 for (unsigned I = 0; I < ExpectedNumExprs; I++) 2291 E->getTrailingObjects()[I] = Record.readSubExpr(); 2292 2293 bool HasArrayFillerOrUnionDecl = Record.readBool(); 2294 if (HasArrayFillerOrUnionDecl) { 2295 bool HasArrayFiller = Record.readBool(); 2296 if (HasArrayFiller) { 2297 E->setArrayFiller(Record.readSubExpr()); 2298 } else { 2299 E->setInitializedFieldInUnion(readDeclAs<FieldDecl>()); 2300 } 2301 } 2302 E->updateDependence(); 2303 } 2304 2305 void ASTStmtReader::VisitOpaqueValueExpr(OpaqueValueExpr *E) { 2306 VisitExpr(E); 2307 E->SourceExpr = Record.readSubExpr(); 2308 E->OpaqueValueExprBits.Loc = readSourceLocation(); 2309 E->setIsUnique(Record.readInt()); 2310 } 2311 2312 void ASTStmtReader::VisitRecoveryExpr(RecoveryExpr *E) { 2313 VisitExpr(E); 2314 unsigned NumArgs = Record.readInt(); 2315 E->BeginLoc = readSourceLocation(); 2316 E->EndLoc = readSourceLocation(); 2317 assert((NumArgs + 0LL == 2318 std::distance(E->children().begin(), E->children().end())) && 2319 "Wrong NumArgs!"); 2320 (void)NumArgs; 2321 for (Stmt *&Child : E->children()) 2322 Child = Record.readSubStmt(); 2323 } 2324 2325 //===----------------------------------------------------------------------===// 2326 // Microsoft Expressions and Statements 2327 //===----------------------------------------------------------------------===// 2328 void ASTStmtReader::VisitMSPropertyRefExpr(MSPropertyRefExpr *E) { 2329 VisitExpr(E); 2330 E->IsArrow = (Record.readInt() != 0); 2331 E->BaseExpr = Record.readSubExpr(); 2332 E->QualifierLoc = Record.readNestedNameSpecifierLoc(); 2333 E->MemberLoc = readSourceLocation(); 2334 E->TheDecl = readDeclAs<MSPropertyDecl>(); 2335 } 2336 2337 void ASTStmtReader::VisitMSPropertySubscriptExpr(MSPropertySubscriptExpr *E) { 2338 VisitExpr(E); 2339 E->setBase(Record.readSubExpr()); 2340 E->setIdx(Record.readSubExpr()); 2341 E->setRBracketLoc(readSourceLocation()); 2342 } 2343 2344 void ASTStmtReader::VisitCXXUuidofExpr(CXXUuidofExpr *E) { 2345 VisitExpr(E); 2346 E->setSourceRange(readSourceRange()); 2347 E->Guid = readDeclAs<MSGuidDecl>(); 2348 if (E->isTypeOperand()) 2349 E->Operand = readTypeSourceInfo(); 2350 else 2351 E->Operand = Record.readSubExpr(); 2352 } 2353 2354 void ASTStmtReader::VisitSEHLeaveStmt(SEHLeaveStmt *S) { 2355 VisitStmt(S); 2356 S->setLeaveLoc(readSourceLocation()); 2357 } 2358 2359 void ASTStmtReader::VisitSEHExceptStmt(SEHExceptStmt *S) { 2360 VisitStmt(S); 2361 S->Loc = readSourceLocation(); 2362 S->Children[SEHExceptStmt::FILTER_EXPR] = Record.readSubStmt(); 2363 S->Children[SEHExceptStmt::BLOCK] = Record.readSubStmt(); 2364 } 2365 2366 void ASTStmtReader::VisitSEHFinallyStmt(SEHFinallyStmt *S) { 2367 VisitStmt(S); 2368 S->Loc = readSourceLocation(); 2369 S->Block = Record.readSubStmt(); 2370 } 2371 2372 void ASTStmtReader::VisitSEHTryStmt(SEHTryStmt *S) { 2373 VisitStmt(S); 2374 S->IsCXXTry = Record.readInt(); 2375 S->TryLoc = readSourceLocation(); 2376 S->Children[SEHTryStmt::TRY] = Record.readSubStmt(); 2377 S->Children[SEHTryStmt::HANDLER] = Record.readSubStmt(); 2378 } 2379 2380 //===----------------------------------------------------------------------===// 2381 // CUDA Expressions and Statements 2382 //===----------------------------------------------------------------------===// 2383 2384 void ASTStmtReader::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *E) { 2385 VisitCallExpr(E); 2386 E->setPreArg(CUDAKernelCallExpr::CONFIG, Record.readSubExpr()); 2387 } 2388 2389 //===----------------------------------------------------------------------===// 2390 // OpenCL Expressions and Statements. 2391 //===----------------------------------------------------------------------===// 2392 void ASTStmtReader::VisitAsTypeExpr(AsTypeExpr *E) { 2393 VisitExpr(E); 2394 E->BuiltinLoc = readSourceLocation(); 2395 E->RParenLoc = readSourceLocation(); 2396 E->SrcExpr = Record.readSubExpr(); 2397 } 2398 2399 //===----------------------------------------------------------------------===// 2400 // OpenMP Directives. 2401 //===----------------------------------------------------------------------===// 2402 2403 void ASTStmtReader::VisitOMPCanonicalLoop(OMPCanonicalLoop *S) { 2404 VisitStmt(S); 2405 for (Stmt *&SubStmt : S->SubStmts) 2406 SubStmt = Record.readSubStmt(); 2407 } 2408 2409 void ASTStmtReader::VisitOMPExecutableDirective(OMPExecutableDirective *E) { 2410 Record.readOMPChildren(E->Data); 2411 E->setLocStart(readSourceLocation()); 2412 E->setLocEnd(readSourceLocation()); 2413 } 2414 2415 void ASTStmtReader::VisitOMPLoopBasedDirective(OMPLoopBasedDirective *D) { 2416 VisitStmt(D); 2417 // Field CollapsedNum was read in ReadStmtFromStream. 2418 Record.skipInts(1); 2419 VisitOMPExecutableDirective(D); 2420 } 2421 2422 void ASTStmtReader::VisitOMPLoopDirective(OMPLoopDirective *D) { 2423 VisitOMPLoopBasedDirective(D); 2424 } 2425 2426 void ASTStmtReader::VisitOMPMetaDirective(OMPMetaDirective *D) { 2427 VisitStmt(D); 2428 // The NumClauses field was read in ReadStmtFromStream. 2429 Record.skipInts(1); 2430 VisitOMPExecutableDirective(D); 2431 } 2432 2433 void ASTStmtReader::VisitOMPParallelDirective(OMPParallelDirective *D) { 2434 VisitStmt(D); 2435 VisitOMPExecutableDirective(D); 2436 D->setHasCancel(Record.readBool()); 2437 } 2438 2439 void ASTStmtReader::VisitOMPSimdDirective(OMPSimdDirective *D) { 2440 VisitOMPLoopDirective(D); 2441 } 2442 2443 void ASTStmtReader::VisitOMPLoopTransformationDirective( 2444 OMPLoopTransformationDirective *D) { 2445 VisitOMPLoopBasedDirective(D); 2446 D->setNumGeneratedLoops(Record.readUInt32()); 2447 } 2448 2449 void ASTStmtReader::VisitOMPTileDirective(OMPTileDirective *D) { 2450 VisitOMPLoopTransformationDirective(D); 2451 } 2452 2453 void ASTStmtReader::VisitOMPStripeDirective(OMPStripeDirective *D) { 2454 VisitOMPLoopTransformationDirective(D); 2455 } 2456 2457 void ASTStmtReader::VisitOMPUnrollDirective(OMPUnrollDirective *D) { 2458 VisitOMPLoopTransformationDirective(D); 2459 } 2460 2461 void ASTStmtReader::VisitOMPReverseDirective(OMPReverseDirective *D) { 2462 VisitOMPLoopTransformationDirective(D); 2463 } 2464 2465 void ASTStmtReader::VisitOMPInterchangeDirective(OMPInterchangeDirective *D) { 2466 VisitOMPLoopTransformationDirective(D); 2467 } 2468 2469 void ASTStmtReader::VisitOMPForDirective(OMPForDirective *D) { 2470 VisitOMPLoopDirective(D); 2471 D->setHasCancel(Record.readBool()); 2472 } 2473 2474 void ASTStmtReader::VisitOMPForSimdDirective(OMPForSimdDirective *D) { 2475 VisitOMPLoopDirective(D); 2476 } 2477 2478 void ASTStmtReader::VisitOMPSectionsDirective(OMPSectionsDirective *D) { 2479 VisitStmt(D); 2480 VisitOMPExecutableDirective(D); 2481 D->setHasCancel(Record.readBool()); 2482 } 2483 2484 void ASTStmtReader::VisitOMPSectionDirective(OMPSectionDirective *D) { 2485 VisitStmt(D); 2486 VisitOMPExecutableDirective(D); 2487 D->setHasCancel(Record.readBool()); 2488 } 2489 2490 void ASTStmtReader::VisitOMPScopeDirective(OMPScopeDirective *D) { 2491 VisitStmt(D); 2492 VisitOMPExecutableDirective(D); 2493 } 2494 2495 void ASTStmtReader::VisitOMPSingleDirective(OMPSingleDirective *D) { 2496 VisitStmt(D); 2497 VisitOMPExecutableDirective(D); 2498 } 2499 2500 void ASTStmtReader::VisitOMPMasterDirective(OMPMasterDirective *D) { 2501 VisitStmt(D); 2502 VisitOMPExecutableDirective(D); 2503 } 2504 2505 void ASTStmtReader::VisitOMPCriticalDirective(OMPCriticalDirective *D) { 2506 VisitStmt(D); 2507 VisitOMPExecutableDirective(D); 2508 D->DirName = Record.readDeclarationNameInfo(); 2509 } 2510 2511 void ASTStmtReader::VisitOMPParallelForDirective(OMPParallelForDirective *D) { 2512 VisitOMPLoopDirective(D); 2513 D->setHasCancel(Record.readBool()); 2514 } 2515 2516 void ASTStmtReader::VisitOMPParallelForSimdDirective( 2517 OMPParallelForSimdDirective *D) { 2518 VisitOMPLoopDirective(D); 2519 } 2520 2521 void ASTStmtReader::VisitOMPParallelMasterDirective( 2522 OMPParallelMasterDirective *D) { 2523 VisitStmt(D); 2524 VisitOMPExecutableDirective(D); 2525 } 2526 2527 void ASTStmtReader::VisitOMPParallelMaskedDirective( 2528 OMPParallelMaskedDirective *D) { 2529 VisitStmt(D); 2530 VisitOMPExecutableDirective(D); 2531 } 2532 2533 void ASTStmtReader::VisitOMPParallelSectionsDirective( 2534 OMPParallelSectionsDirective *D) { 2535 VisitStmt(D); 2536 VisitOMPExecutableDirective(D); 2537 D->setHasCancel(Record.readBool()); 2538 } 2539 2540 void ASTStmtReader::VisitOMPTaskDirective(OMPTaskDirective *D) { 2541 VisitStmt(D); 2542 VisitOMPExecutableDirective(D); 2543 D->setHasCancel(Record.readBool()); 2544 } 2545 2546 void ASTStmtReader::VisitOMPTaskyieldDirective(OMPTaskyieldDirective *D) { 2547 VisitStmt(D); 2548 VisitOMPExecutableDirective(D); 2549 } 2550 2551 void ASTStmtReader::VisitOMPBarrierDirective(OMPBarrierDirective *D) { 2552 VisitStmt(D); 2553 VisitOMPExecutableDirective(D); 2554 } 2555 2556 void ASTStmtReader::VisitOMPTaskwaitDirective(OMPTaskwaitDirective *D) { 2557 VisitStmt(D); 2558 // The NumClauses field was read in ReadStmtFromStream. 2559 Record.skipInts(1); 2560 VisitOMPExecutableDirective(D); 2561 } 2562 2563 void ASTStmtReader::VisitOMPAssumeDirective(OMPAssumeDirective *D) { 2564 VisitStmt(D); 2565 VisitOMPExecutableDirective(D); 2566 } 2567 2568 void ASTStmtReader::VisitOMPErrorDirective(OMPErrorDirective *D) { 2569 VisitStmt(D); 2570 // The NumClauses field was read in ReadStmtFromStream. 2571 Record.skipInts(1); 2572 VisitOMPExecutableDirective(D); 2573 } 2574 2575 void ASTStmtReader::VisitOMPTaskgroupDirective(OMPTaskgroupDirective *D) { 2576 VisitStmt(D); 2577 VisitOMPExecutableDirective(D); 2578 } 2579 2580 void ASTStmtReader::VisitOMPFlushDirective(OMPFlushDirective *D) { 2581 VisitStmt(D); 2582 VisitOMPExecutableDirective(D); 2583 } 2584 2585 void ASTStmtReader::VisitOMPDepobjDirective(OMPDepobjDirective *D) { 2586 VisitStmt(D); 2587 VisitOMPExecutableDirective(D); 2588 } 2589 2590 void ASTStmtReader::VisitOMPScanDirective(OMPScanDirective *D) { 2591 VisitStmt(D); 2592 VisitOMPExecutableDirective(D); 2593 } 2594 2595 void ASTStmtReader::VisitOMPOrderedDirective(OMPOrderedDirective *D) { 2596 VisitStmt(D); 2597 VisitOMPExecutableDirective(D); 2598 } 2599 2600 void ASTStmtReader::VisitOMPAtomicDirective(OMPAtomicDirective *D) { 2601 VisitStmt(D); 2602 VisitOMPExecutableDirective(D); 2603 D->Flags.IsXLHSInRHSPart = Record.readBool() ? 1 : 0; 2604 D->Flags.IsPostfixUpdate = Record.readBool() ? 1 : 0; 2605 D->Flags.IsFailOnly = Record.readBool() ? 1 : 0; 2606 } 2607 2608 void ASTStmtReader::VisitOMPTargetDirective(OMPTargetDirective *D) { 2609 VisitStmt(D); 2610 VisitOMPExecutableDirective(D); 2611 } 2612 2613 void ASTStmtReader::VisitOMPTargetDataDirective(OMPTargetDataDirective *D) { 2614 VisitStmt(D); 2615 VisitOMPExecutableDirective(D); 2616 } 2617 2618 void ASTStmtReader::VisitOMPTargetEnterDataDirective( 2619 OMPTargetEnterDataDirective *D) { 2620 VisitStmt(D); 2621 VisitOMPExecutableDirective(D); 2622 } 2623 2624 void ASTStmtReader::VisitOMPTargetExitDataDirective( 2625 OMPTargetExitDataDirective *D) { 2626 VisitStmt(D); 2627 VisitOMPExecutableDirective(D); 2628 } 2629 2630 void ASTStmtReader::VisitOMPTargetParallelDirective( 2631 OMPTargetParallelDirective *D) { 2632 VisitStmt(D); 2633 VisitOMPExecutableDirective(D); 2634 D->setHasCancel(Record.readBool()); 2635 } 2636 2637 void ASTStmtReader::VisitOMPTargetParallelForDirective( 2638 OMPTargetParallelForDirective *D) { 2639 VisitOMPLoopDirective(D); 2640 D->setHasCancel(Record.readBool()); 2641 } 2642 2643 void ASTStmtReader::VisitOMPTeamsDirective(OMPTeamsDirective *D) { 2644 VisitStmt(D); 2645 VisitOMPExecutableDirective(D); 2646 } 2647 2648 void ASTStmtReader::VisitOMPCancellationPointDirective( 2649 OMPCancellationPointDirective *D) { 2650 VisitStmt(D); 2651 VisitOMPExecutableDirective(D); 2652 D->setCancelRegion(Record.readEnum<OpenMPDirectiveKind>()); 2653 } 2654 2655 void ASTStmtReader::VisitOMPCancelDirective(OMPCancelDirective *D) { 2656 VisitStmt(D); 2657 VisitOMPExecutableDirective(D); 2658 D->setCancelRegion(Record.readEnum<OpenMPDirectiveKind>()); 2659 } 2660 2661 void ASTStmtReader::VisitOMPTaskLoopDirective(OMPTaskLoopDirective *D) { 2662 VisitOMPLoopDirective(D); 2663 D->setHasCancel(Record.readBool()); 2664 } 2665 2666 void ASTStmtReader::VisitOMPTaskLoopSimdDirective(OMPTaskLoopSimdDirective *D) { 2667 VisitOMPLoopDirective(D); 2668 } 2669 2670 void ASTStmtReader::VisitOMPMasterTaskLoopDirective( 2671 OMPMasterTaskLoopDirective *D) { 2672 VisitOMPLoopDirective(D); 2673 D->setHasCancel(Record.readBool()); 2674 } 2675 2676 void ASTStmtReader::VisitOMPMaskedTaskLoopDirective( 2677 OMPMaskedTaskLoopDirective *D) { 2678 VisitOMPLoopDirective(D); 2679 D->setHasCancel(Record.readBool()); 2680 } 2681 2682 void ASTStmtReader::VisitOMPMasterTaskLoopSimdDirective( 2683 OMPMasterTaskLoopSimdDirective *D) { 2684 VisitOMPLoopDirective(D); 2685 } 2686 2687 void ASTStmtReader::VisitOMPMaskedTaskLoopSimdDirective( 2688 OMPMaskedTaskLoopSimdDirective *D) { 2689 VisitOMPLoopDirective(D); 2690 } 2691 2692 void ASTStmtReader::VisitOMPParallelMasterTaskLoopDirective( 2693 OMPParallelMasterTaskLoopDirective *D) { 2694 VisitOMPLoopDirective(D); 2695 D->setHasCancel(Record.readBool()); 2696 } 2697 2698 void ASTStmtReader::VisitOMPParallelMaskedTaskLoopDirective( 2699 OMPParallelMaskedTaskLoopDirective *D) { 2700 VisitOMPLoopDirective(D); 2701 D->setHasCancel(Record.readBool()); 2702 } 2703 2704 void ASTStmtReader::VisitOMPParallelMasterTaskLoopSimdDirective( 2705 OMPParallelMasterTaskLoopSimdDirective *D) { 2706 VisitOMPLoopDirective(D); 2707 } 2708 2709 void ASTStmtReader::VisitOMPParallelMaskedTaskLoopSimdDirective( 2710 OMPParallelMaskedTaskLoopSimdDirective *D) { 2711 VisitOMPLoopDirective(D); 2712 } 2713 2714 void ASTStmtReader::VisitOMPDistributeDirective(OMPDistributeDirective *D) { 2715 VisitOMPLoopDirective(D); 2716 } 2717 2718 void ASTStmtReader::VisitOMPTargetUpdateDirective(OMPTargetUpdateDirective *D) { 2719 VisitStmt(D); 2720 VisitOMPExecutableDirective(D); 2721 } 2722 2723 void ASTStmtReader::VisitOMPDistributeParallelForDirective( 2724 OMPDistributeParallelForDirective *D) { 2725 VisitOMPLoopDirective(D); 2726 D->setHasCancel(Record.readBool()); 2727 } 2728 2729 void ASTStmtReader::VisitOMPDistributeParallelForSimdDirective( 2730 OMPDistributeParallelForSimdDirective *D) { 2731 VisitOMPLoopDirective(D); 2732 } 2733 2734 void ASTStmtReader::VisitOMPDistributeSimdDirective( 2735 OMPDistributeSimdDirective *D) { 2736 VisitOMPLoopDirective(D); 2737 } 2738 2739 void ASTStmtReader::VisitOMPTargetParallelForSimdDirective( 2740 OMPTargetParallelForSimdDirective *D) { 2741 VisitOMPLoopDirective(D); 2742 } 2743 2744 void ASTStmtReader::VisitOMPTargetSimdDirective(OMPTargetSimdDirective *D) { 2745 VisitOMPLoopDirective(D); 2746 } 2747 2748 void ASTStmtReader::VisitOMPTeamsDistributeDirective( 2749 OMPTeamsDistributeDirective *D) { 2750 VisitOMPLoopDirective(D); 2751 } 2752 2753 void ASTStmtReader::VisitOMPTeamsDistributeSimdDirective( 2754 OMPTeamsDistributeSimdDirective *D) { 2755 VisitOMPLoopDirective(D); 2756 } 2757 2758 void ASTStmtReader::VisitOMPTeamsDistributeParallelForSimdDirective( 2759 OMPTeamsDistributeParallelForSimdDirective *D) { 2760 VisitOMPLoopDirective(D); 2761 } 2762 2763 void ASTStmtReader::VisitOMPTeamsDistributeParallelForDirective( 2764 OMPTeamsDistributeParallelForDirective *D) { 2765 VisitOMPLoopDirective(D); 2766 D->setHasCancel(Record.readBool()); 2767 } 2768 2769 void ASTStmtReader::VisitOMPTargetTeamsDirective(OMPTargetTeamsDirective *D) { 2770 VisitStmt(D); 2771 VisitOMPExecutableDirective(D); 2772 } 2773 2774 void ASTStmtReader::VisitOMPTargetTeamsDistributeDirective( 2775 OMPTargetTeamsDistributeDirective *D) { 2776 VisitOMPLoopDirective(D); 2777 } 2778 2779 void ASTStmtReader::VisitOMPTargetTeamsDistributeParallelForDirective( 2780 OMPTargetTeamsDistributeParallelForDirective *D) { 2781 VisitOMPLoopDirective(D); 2782 D->setHasCancel(Record.readBool()); 2783 } 2784 2785 void ASTStmtReader::VisitOMPTargetTeamsDistributeParallelForSimdDirective( 2786 OMPTargetTeamsDistributeParallelForSimdDirective *D) { 2787 VisitOMPLoopDirective(D); 2788 } 2789 2790 void ASTStmtReader::VisitOMPTargetTeamsDistributeSimdDirective( 2791 OMPTargetTeamsDistributeSimdDirective *D) { 2792 VisitOMPLoopDirective(D); 2793 } 2794 2795 void ASTStmtReader::VisitOMPInteropDirective(OMPInteropDirective *D) { 2796 VisitStmt(D); 2797 VisitOMPExecutableDirective(D); 2798 } 2799 2800 void ASTStmtReader::VisitOMPDispatchDirective(OMPDispatchDirective *D) { 2801 VisitStmt(D); 2802 VisitOMPExecutableDirective(D); 2803 D->setTargetCallLoc(Record.readSourceLocation()); 2804 } 2805 2806 void ASTStmtReader::VisitOMPMaskedDirective(OMPMaskedDirective *D) { 2807 VisitStmt(D); 2808 VisitOMPExecutableDirective(D); 2809 } 2810 2811 void ASTStmtReader::VisitOMPGenericLoopDirective(OMPGenericLoopDirective *D) { 2812 VisitOMPLoopDirective(D); 2813 } 2814 2815 void ASTStmtReader::VisitOMPTeamsGenericLoopDirective( 2816 OMPTeamsGenericLoopDirective *D) { 2817 VisitOMPLoopDirective(D); 2818 } 2819 2820 void ASTStmtReader::VisitOMPTargetTeamsGenericLoopDirective( 2821 OMPTargetTeamsGenericLoopDirective *D) { 2822 VisitOMPLoopDirective(D); 2823 D->setCanBeParallelFor(Record.readBool()); 2824 } 2825 2826 void ASTStmtReader::VisitOMPParallelGenericLoopDirective( 2827 OMPParallelGenericLoopDirective *D) { 2828 VisitOMPLoopDirective(D); 2829 } 2830 2831 void ASTStmtReader::VisitOMPTargetParallelGenericLoopDirective( 2832 OMPTargetParallelGenericLoopDirective *D) { 2833 VisitOMPLoopDirective(D); 2834 } 2835 2836 //===----------------------------------------------------------------------===// 2837 // OpenACC Constructs/Directives. 2838 //===----------------------------------------------------------------------===// 2839 void ASTStmtReader::VisitOpenACCConstructStmt(OpenACCConstructStmt *S) { 2840 (void)Record.readInt(); 2841 S->Kind = Record.readEnum<OpenACCDirectiveKind>(); 2842 S->Range = Record.readSourceRange(); 2843 S->DirectiveLoc = Record.readSourceLocation(); 2844 Record.readOpenACCClauseList(S->Clauses); 2845 } 2846 2847 void ASTStmtReader::VisitOpenACCAssociatedStmtConstruct( 2848 OpenACCAssociatedStmtConstruct *S) { 2849 VisitOpenACCConstructStmt(S); 2850 S->setAssociatedStmt(Record.readSubStmt()); 2851 } 2852 2853 void ASTStmtReader::VisitOpenACCComputeConstruct(OpenACCComputeConstruct *S) { 2854 VisitStmt(S); 2855 VisitOpenACCAssociatedStmtConstruct(S); 2856 } 2857 2858 void ASTStmtReader::VisitOpenACCLoopConstruct(OpenACCLoopConstruct *S) { 2859 VisitStmt(S); 2860 VisitOpenACCAssociatedStmtConstruct(S); 2861 S->ParentComputeConstructKind = Record.readEnum<OpenACCDirectiveKind>(); 2862 } 2863 2864 void ASTStmtReader::VisitOpenACCCombinedConstruct(OpenACCCombinedConstruct *S) { 2865 VisitStmt(S); 2866 VisitOpenACCAssociatedStmtConstruct(S); 2867 } 2868 2869 void ASTStmtReader::VisitOpenACCDataConstruct(OpenACCDataConstruct *S) { 2870 VisitStmt(S); 2871 VisitOpenACCAssociatedStmtConstruct(S); 2872 } 2873 2874 void ASTStmtReader::VisitOpenACCEnterDataConstruct( 2875 OpenACCEnterDataConstruct *S) { 2876 VisitStmt(S); 2877 VisitOpenACCConstructStmt(S); 2878 } 2879 2880 void ASTStmtReader::VisitOpenACCExitDataConstruct(OpenACCExitDataConstruct *S) { 2881 VisitStmt(S); 2882 VisitOpenACCConstructStmt(S); 2883 } 2884 2885 void ASTStmtReader::VisitOpenACCInitConstruct(OpenACCInitConstruct *S) { 2886 VisitStmt(S); 2887 VisitOpenACCConstructStmt(S); 2888 } 2889 2890 void ASTStmtReader::VisitOpenACCShutdownConstruct(OpenACCShutdownConstruct *S) { 2891 VisitStmt(S); 2892 VisitOpenACCConstructStmt(S); 2893 } 2894 2895 void ASTStmtReader::VisitOpenACCSetConstruct(OpenACCSetConstruct *S) { 2896 VisitStmt(S); 2897 VisitOpenACCConstructStmt(S); 2898 } 2899 2900 void ASTStmtReader::VisitOpenACCUpdateConstruct(OpenACCUpdateConstruct *S) { 2901 VisitStmt(S); 2902 VisitOpenACCConstructStmt(S); 2903 } 2904 2905 void ASTStmtReader::VisitOpenACCHostDataConstruct(OpenACCHostDataConstruct *S) { 2906 VisitStmt(S); 2907 VisitOpenACCAssociatedStmtConstruct(S); 2908 } 2909 2910 void ASTStmtReader::VisitOpenACCWaitConstruct(OpenACCWaitConstruct *S) { 2911 VisitStmt(S); 2912 // Consume the count of Expressions. 2913 (void)Record.readInt(); 2914 VisitOpenACCConstructStmt(S); 2915 S->LParenLoc = Record.readSourceLocation(); 2916 S->RParenLoc = Record.readSourceLocation(); 2917 S->QueuesLoc = Record.readSourceLocation(); 2918 2919 for (unsigned I = 0; I < S->NumExprs; ++I) { 2920 S->getExprPtr()[I] = cast_if_present<Expr>(Record.readSubStmt()); 2921 assert((I == 0 || S->getExprPtr()[I] != nullptr) && 2922 "Only first expression should be null"); 2923 } 2924 } 2925 2926 void ASTStmtReader::VisitOpenACCCacheConstruct(OpenACCCacheConstruct *S) { 2927 VisitStmt(S); 2928 (void)Record.readInt(); 2929 VisitOpenACCConstructStmt(S); 2930 S->ParensLoc = Record.readSourceRange(); 2931 S->ReadOnlyLoc = Record.readSourceLocation(); 2932 for (unsigned I = 0; I < S->NumVars; ++I) 2933 S->getVarList()[I] = cast<Expr>(Record.readSubStmt()); 2934 } 2935 2936 void ASTStmtReader::VisitOpenACCAtomicConstruct(OpenACCAtomicConstruct *S) { 2937 VisitStmt(S); 2938 VisitOpenACCConstructStmt(S); 2939 S->AtomicKind = Record.readEnum<OpenACCAtomicKind>(); 2940 S->setAssociatedStmt(Record.readSubStmt()); 2941 } 2942 2943 //===----------------------------------------------------------------------===// 2944 // HLSL Constructs/Directives. 2945 //===----------------------------------------------------------------------===// 2946 2947 void ASTStmtReader::VisitHLSLOutArgExpr(HLSLOutArgExpr *S) { 2948 VisitExpr(S); 2949 S->SubExprs[HLSLOutArgExpr::BaseLValue] = Record.readSubExpr(); 2950 S->SubExprs[HLSLOutArgExpr::CastedTemporary] = Record.readSubExpr(); 2951 S->SubExprs[HLSLOutArgExpr::WritebackCast] = Record.readSubExpr(); 2952 S->IsInOut = Record.readBool(); 2953 } 2954 2955 //===----------------------------------------------------------------------===// 2956 // ASTReader Implementation 2957 //===----------------------------------------------------------------------===// 2958 2959 Stmt *ASTReader::ReadStmt(ModuleFile &F) { 2960 switch (ReadingKind) { 2961 case Read_None: 2962 llvm_unreachable("should not call this when not reading anything"); 2963 case Read_Decl: 2964 case Read_Type: 2965 return ReadStmtFromStream(F); 2966 case Read_Stmt: 2967 return ReadSubStmt(); 2968 } 2969 2970 llvm_unreachable("ReadingKind not set ?"); 2971 } 2972 2973 Expr *ASTReader::ReadExpr(ModuleFile &F) { 2974 return cast_or_null<Expr>(ReadStmt(F)); 2975 } 2976 2977 Expr *ASTReader::ReadSubExpr() { 2978 return cast_or_null<Expr>(ReadSubStmt()); 2979 } 2980 2981 // Within the bitstream, expressions are stored in Reverse Polish 2982 // Notation, with each of the subexpressions preceding the 2983 // expression they are stored in. Subexpressions are stored from last to first. 2984 // To evaluate expressions, we continue reading expressions and placing them on 2985 // the stack, with expressions having operands removing those operands from the 2986 // stack. Evaluation terminates when we see a STMT_STOP record, and 2987 // the single remaining expression on the stack is our result. 2988 Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) { 2989 ReadingKindTracker ReadingKind(Read_Stmt, *this); 2990 llvm::BitstreamCursor &Cursor = F.DeclsCursor; 2991 2992 // Map of offset to previously deserialized stmt. The offset points 2993 // just after the stmt record. 2994 llvm::DenseMap<uint64_t, Stmt *> StmtEntries; 2995 2996 #ifndef NDEBUG 2997 unsigned PrevNumStmts = StmtStack.size(); 2998 #endif 2999 3000 ASTRecordReader Record(*this, F); 3001 ASTStmtReader Reader(Record, Cursor); 3002 Stmt::EmptyShell Empty; 3003 3004 while (true) { 3005 llvm::Expected<llvm::BitstreamEntry> MaybeEntry = 3006 Cursor.advanceSkippingSubblocks(); 3007 if (!MaybeEntry) { 3008 Error(toString(MaybeEntry.takeError())); 3009 return nullptr; 3010 } 3011 llvm::BitstreamEntry Entry = MaybeEntry.get(); 3012 3013 switch (Entry.Kind) { 3014 case llvm::BitstreamEntry::SubBlock: // Handled for us already. 3015 case llvm::BitstreamEntry::Error: 3016 Error("malformed block record in AST file"); 3017 return nullptr; 3018 case llvm::BitstreamEntry::EndBlock: 3019 goto Done; 3020 case llvm::BitstreamEntry::Record: 3021 // The interesting case. 3022 break; 3023 } 3024 3025 ASTContext &Context = getContext(); 3026 Stmt *S = nullptr; 3027 bool Finished = false; 3028 bool IsStmtReference = false; 3029 Expected<unsigned> MaybeStmtCode = Record.readRecord(Cursor, Entry.ID); 3030 if (!MaybeStmtCode) { 3031 Error(toString(MaybeStmtCode.takeError())); 3032 return nullptr; 3033 } 3034 switch ((StmtCode)MaybeStmtCode.get()) { 3035 case STMT_STOP: 3036 Finished = true; 3037 break; 3038 3039 case STMT_REF_PTR: 3040 IsStmtReference = true; 3041 assert(StmtEntries.contains(Record[0]) && 3042 "No stmt was recorded for this offset reference!"); 3043 S = StmtEntries[Record.readInt()]; 3044 break; 3045 3046 case STMT_NULL_PTR: 3047 S = nullptr; 3048 break; 3049 3050 case STMT_NULL: 3051 S = new (Context) NullStmt(Empty); 3052 break; 3053 3054 case STMT_COMPOUND: { 3055 unsigned NumStmts = Record[ASTStmtReader::NumStmtFields]; 3056 bool HasFPFeatures = Record[ASTStmtReader::NumStmtFields + 1]; 3057 S = CompoundStmt::CreateEmpty(Context, NumStmts, HasFPFeatures); 3058 break; 3059 } 3060 3061 case STMT_CASE: 3062 S = CaseStmt::CreateEmpty( 3063 Context, 3064 /*CaseStmtIsGNURange*/ Record[ASTStmtReader::NumStmtFields + 3]); 3065 break; 3066 3067 case STMT_DEFAULT: 3068 S = new (Context) DefaultStmt(Empty); 3069 break; 3070 3071 case STMT_LABEL: 3072 S = new (Context) LabelStmt(Empty); 3073 break; 3074 3075 case STMT_ATTRIBUTED: 3076 S = AttributedStmt::CreateEmpty( 3077 Context, 3078 /*NumAttrs*/Record[ASTStmtReader::NumStmtFields]); 3079 break; 3080 3081 case STMT_IF: { 3082 BitsUnpacker IfStmtBits(Record[ASTStmtReader::NumStmtFields]); 3083 bool HasElse = IfStmtBits.getNextBit(); 3084 bool HasVar = IfStmtBits.getNextBit(); 3085 bool HasInit = IfStmtBits.getNextBit(); 3086 S = IfStmt::CreateEmpty(Context, HasElse, HasVar, HasInit); 3087 break; 3088 } 3089 3090 case STMT_SWITCH: 3091 S = SwitchStmt::CreateEmpty( 3092 Context, 3093 /* HasInit=*/Record[ASTStmtReader::NumStmtFields], 3094 /* HasVar=*/Record[ASTStmtReader::NumStmtFields + 1]); 3095 break; 3096 3097 case STMT_WHILE: 3098 S = WhileStmt::CreateEmpty( 3099 Context, 3100 /* HasVar=*/Record[ASTStmtReader::NumStmtFields]); 3101 break; 3102 3103 case STMT_DO: 3104 S = new (Context) DoStmt(Empty); 3105 break; 3106 3107 case STMT_FOR: 3108 S = new (Context) ForStmt(Empty); 3109 break; 3110 3111 case STMT_GOTO: 3112 S = new (Context) GotoStmt(Empty); 3113 break; 3114 3115 case STMT_INDIRECT_GOTO: 3116 S = new (Context) IndirectGotoStmt(Empty); 3117 break; 3118 3119 case STMT_CONTINUE: 3120 S = new (Context) ContinueStmt(Empty); 3121 break; 3122 3123 case STMT_BREAK: 3124 S = new (Context) BreakStmt(Empty); 3125 break; 3126 3127 case STMT_RETURN: 3128 S = ReturnStmt::CreateEmpty( 3129 Context, /* HasNRVOCandidate=*/Record[ASTStmtReader::NumStmtFields]); 3130 break; 3131 3132 case STMT_DECL: 3133 S = new (Context) DeclStmt(Empty); 3134 break; 3135 3136 case STMT_GCCASM: 3137 S = new (Context) GCCAsmStmt(Empty); 3138 break; 3139 3140 case STMT_MSASM: 3141 S = new (Context) MSAsmStmt(Empty); 3142 break; 3143 3144 case STMT_CAPTURED: 3145 S = CapturedStmt::CreateDeserialized( 3146 Context, Record[ASTStmtReader::NumStmtFields]); 3147 break; 3148 3149 case STMT_SYCLKERNELCALL: 3150 S = new (Context) SYCLKernelCallStmt(Empty); 3151 break; 3152 3153 case EXPR_CONSTANT: 3154 S = ConstantExpr::CreateEmpty( 3155 Context, static_cast<ConstantResultStorageKind>( 3156 /*StorageKind=*/Record[ASTStmtReader::NumExprFields])); 3157 break; 3158 3159 case EXPR_SYCL_UNIQUE_STABLE_NAME: 3160 S = SYCLUniqueStableNameExpr::CreateEmpty(Context); 3161 break; 3162 3163 case EXPR_OPENACC_ASTERISK_SIZE: 3164 S = OpenACCAsteriskSizeExpr::CreateEmpty(Context); 3165 break; 3166 3167 case EXPR_PREDEFINED: 3168 S = PredefinedExpr::CreateEmpty( 3169 Context, 3170 /*HasFunctionName*/ Record[ASTStmtReader::NumExprFields]); 3171 break; 3172 3173 case EXPR_DECL_REF: { 3174 BitsUnpacker DeclRefExprBits(Record[ASTStmtReader::NumExprFields]); 3175 DeclRefExprBits.advance(5); 3176 bool HasFoundDecl = DeclRefExprBits.getNextBit(); 3177 bool HasQualifier = DeclRefExprBits.getNextBit(); 3178 bool HasTemplateKWAndArgsInfo = DeclRefExprBits.getNextBit(); 3179 unsigned NumTemplateArgs = HasTemplateKWAndArgsInfo 3180 ? Record[ASTStmtReader::NumExprFields + 1] 3181 : 0; 3182 S = DeclRefExpr::CreateEmpty(Context, HasQualifier, HasFoundDecl, 3183 HasTemplateKWAndArgsInfo, NumTemplateArgs); 3184 break; 3185 } 3186 3187 case EXPR_INTEGER_LITERAL: 3188 S = IntegerLiteral::Create(Context, Empty); 3189 break; 3190 3191 case EXPR_FIXEDPOINT_LITERAL: 3192 S = FixedPointLiteral::Create(Context, Empty); 3193 break; 3194 3195 case EXPR_FLOATING_LITERAL: 3196 S = FloatingLiteral::Create(Context, Empty); 3197 break; 3198 3199 case EXPR_IMAGINARY_LITERAL: 3200 S = new (Context) ImaginaryLiteral(Empty); 3201 break; 3202 3203 case EXPR_STRING_LITERAL: 3204 S = StringLiteral::CreateEmpty( 3205 Context, 3206 /* NumConcatenated=*/Record[ASTStmtReader::NumExprFields], 3207 /* Length=*/Record[ASTStmtReader::NumExprFields + 1], 3208 /* CharByteWidth=*/Record[ASTStmtReader::NumExprFields + 2]); 3209 break; 3210 3211 case EXPR_CHARACTER_LITERAL: 3212 S = new (Context) CharacterLiteral(Empty); 3213 break; 3214 3215 case EXPR_PAREN: 3216 S = new (Context) ParenExpr(Empty); 3217 break; 3218 3219 case EXPR_PAREN_LIST: 3220 S = ParenListExpr::CreateEmpty( 3221 Context, 3222 /* NumExprs=*/Record[ASTStmtReader::NumExprFields]); 3223 break; 3224 3225 case EXPR_UNARY_OPERATOR: { 3226 BitsUnpacker UnaryOperatorBits(Record[ASTStmtReader::NumStmtFields]); 3227 UnaryOperatorBits.advance(ASTStmtReader::NumExprBits); 3228 bool HasFPFeatures = UnaryOperatorBits.getNextBit(); 3229 S = UnaryOperator::CreateEmpty(Context, HasFPFeatures); 3230 break; 3231 } 3232 3233 case EXPR_OFFSETOF: 3234 S = OffsetOfExpr::CreateEmpty(Context, 3235 Record[ASTStmtReader::NumExprFields], 3236 Record[ASTStmtReader::NumExprFields + 1]); 3237 break; 3238 3239 case EXPR_SIZEOF_ALIGN_OF: 3240 S = new (Context) UnaryExprOrTypeTraitExpr(Empty); 3241 break; 3242 3243 case EXPR_ARRAY_SUBSCRIPT: 3244 S = new (Context) ArraySubscriptExpr(Empty); 3245 break; 3246 3247 case EXPR_MATRIX_SUBSCRIPT: 3248 S = new (Context) MatrixSubscriptExpr(Empty); 3249 break; 3250 3251 case EXPR_ARRAY_SECTION: 3252 S = new (Context) ArraySectionExpr(Empty); 3253 break; 3254 3255 case EXPR_OMP_ARRAY_SHAPING: 3256 S = OMPArrayShapingExpr::CreateEmpty( 3257 Context, Record[ASTStmtReader::NumExprFields]); 3258 break; 3259 3260 case EXPR_OMP_ITERATOR: 3261 S = OMPIteratorExpr::CreateEmpty(Context, 3262 Record[ASTStmtReader::NumExprFields]); 3263 break; 3264 3265 case EXPR_CALL: { 3266 auto NumArgs = Record[ASTStmtReader::NumExprFields]; 3267 BitsUnpacker CallExprBits(Record[ASTStmtReader::NumExprFields + 1]); 3268 CallExprBits.advance(1); 3269 auto HasFPFeatures = CallExprBits.getNextBit(); 3270 S = CallExpr::CreateEmpty(Context, NumArgs, HasFPFeatures, Empty); 3271 break; 3272 } 3273 3274 case EXPR_RECOVERY: 3275 S = RecoveryExpr::CreateEmpty( 3276 Context, /*NumArgs=*/Record[ASTStmtReader::NumExprFields]); 3277 break; 3278 3279 case EXPR_MEMBER: { 3280 BitsUnpacker ExprMemberBits(Record[ASTStmtReader::NumExprFields]); 3281 bool HasQualifier = ExprMemberBits.getNextBit(); 3282 bool HasFoundDecl = ExprMemberBits.getNextBit(); 3283 bool HasTemplateInfo = ExprMemberBits.getNextBit(); 3284 unsigned NumTemplateArgs = Record[ASTStmtReader::NumExprFields + 1]; 3285 S = MemberExpr::CreateEmpty(Context, HasQualifier, HasFoundDecl, 3286 HasTemplateInfo, NumTemplateArgs); 3287 break; 3288 } 3289 3290 case EXPR_BINARY_OPERATOR: { 3291 BitsUnpacker BinaryOperatorBits(Record[ASTStmtReader::NumExprFields]); 3292 BinaryOperatorBits.advance(/*Size of opcode*/ 6); 3293 bool HasFPFeatures = BinaryOperatorBits.getNextBit(); 3294 S = BinaryOperator::CreateEmpty(Context, HasFPFeatures); 3295 break; 3296 } 3297 3298 case EXPR_COMPOUND_ASSIGN_OPERATOR: { 3299 BitsUnpacker BinaryOperatorBits(Record[ASTStmtReader::NumExprFields]); 3300 BinaryOperatorBits.advance(/*Size of opcode*/ 6); 3301 bool HasFPFeatures = BinaryOperatorBits.getNextBit(); 3302 S = CompoundAssignOperator::CreateEmpty(Context, HasFPFeatures); 3303 break; 3304 } 3305 3306 case EXPR_CONDITIONAL_OPERATOR: 3307 S = new (Context) ConditionalOperator(Empty); 3308 break; 3309 3310 case EXPR_BINARY_CONDITIONAL_OPERATOR: 3311 S = new (Context) BinaryConditionalOperator(Empty); 3312 break; 3313 3314 case EXPR_IMPLICIT_CAST: { 3315 unsigned PathSize = Record[ASTStmtReader::NumExprFields]; 3316 BitsUnpacker CastExprBits(Record[ASTStmtReader::NumExprFields + 1]); 3317 CastExprBits.advance(7); 3318 bool HasFPFeatures = CastExprBits.getNextBit(); 3319 S = ImplicitCastExpr::CreateEmpty(Context, PathSize, HasFPFeatures); 3320 break; 3321 } 3322 3323 case EXPR_CSTYLE_CAST: { 3324 unsigned PathSize = Record[ASTStmtReader::NumExprFields]; 3325 BitsUnpacker CastExprBits(Record[ASTStmtReader::NumExprFields + 1]); 3326 CastExprBits.advance(7); 3327 bool HasFPFeatures = CastExprBits.getNextBit(); 3328 S = CStyleCastExpr::CreateEmpty(Context, PathSize, HasFPFeatures); 3329 break; 3330 } 3331 3332 case EXPR_COMPOUND_LITERAL: 3333 S = new (Context) CompoundLiteralExpr(Empty); 3334 break; 3335 3336 case EXPR_EXT_VECTOR_ELEMENT: 3337 S = new (Context) ExtVectorElementExpr(Empty); 3338 break; 3339 3340 case EXPR_INIT_LIST: 3341 S = new (Context) InitListExpr(Empty); 3342 break; 3343 3344 case EXPR_DESIGNATED_INIT: 3345 S = DesignatedInitExpr::CreateEmpty(Context, 3346 Record[ASTStmtReader::NumExprFields] - 1); 3347 3348 break; 3349 3350 case EXPR_DESIGNATED_INIT_UPDATE: 3351 S = new (Context) DesignatedInitUpdateExpr(Empty); 3352 break; 3353 3354 case EXPR_IMPLICIT_VALUE_INIT: 3355 S = new (Context) ImplicitValueInitExpr(Empty); 3356 break; 3357 3358 case EXPR_NO_INIT: 3359 S = new (Context) NoInitExpr(Empty); 3360 break; 3361 3362 case EXPR_ARRAY_INIT_LOOP: 3363 S = new (Context) ArrayInitLoopExpr(Empty); 3364 break; 3365 3366 case EXPR_ARRAY_INIT_INDEX: 3367 S = new (Context) ArrayInitIndexExpr(Empty); 3368 break; 3369 3370 case EXPR_VA_ARG: 3371 S = new (Context) VAArgExpr(Empty); 3372 break; 3373 3374 case EXPR_SOURCE_LOC: 3375 S = new (Context) SourceLocExpr(Empty); 3376 break; 3377 3378 case EXPR_BUILTIN_PP_EMBED: 3379 S = new (Context) EmbedExpr(Empty); 3380 break; 3381 3382 case EXPR_ADDR_LABEL: 3383 S = new (Context) AddrLabelExpr(Empty); 3384 break; 3385 3386 case EXPR_STMT: 3387 S = new (Context) StmtExpr(Empty); 3388 break; 3389 3390 case EXPR_CHOOSE: 3391 S = new (Context) ChooseExpr(Empty); 3392 break; 3393 3394 case EXPR_GNU_NULL: 3395 S = new (Context) GNUNullExpr(Empty); 3396 break; 3397 3398 case EXPR_SHUFFLE_VECTOR: 3399 S = new (Context) ShuffleVectorExpr(Empty); 3400 break; 3401 3402 case EXPR_CONVERT_VECTOR: { 3403 BitsUnpacker ConvertVectorExprBits(Record[ASTStmtReader::NumStmtFields]); 3404 ConvertVectorExprBits.advance(ASTStmtReader::NumExprBits); 3405 bool HasFPFeatures = ConvertVectorExprBits.getNextBit(); 3406 S = ConvertVectorExpr::CreateEmpty(Context, HasFPFeatures); 3407 break; 3408 } 3409 3410 case EXPR_BLOCK: 3411 S = new (Context) BlockExpr(Empty); 3412 break; 3413 3414 case EXPR_GENERIC_SELECTION: 3415 S = GenericSelectionExpr::CreateEmpty( 3416 Context, 3417 /*NumAssocs=*/Record[ASTStmtReader::NumExprFields]); 3418 break; 3419 3420 case EXPR_OBJC_STRING_LITERAL: 3421 S = new (Context) ObjCStringLiteral(Empty); 3422 break; 3423 3424 case EXPR_OBJC_BOXED_EXPRESSION: 3425 S = new (Context) ObjCBoxedExpr(Empty); 3426 break; 3427 3428 case EXPR_OBJC_ARRAY_LITERAL: 3429 S = ObjCArrayLiteral::CreateEmpty(Context, 3430 Record[ASTStmtReader::NumExprFields]); 3431 break; 3432 3433 case EXPR_OBJC_DICTIONARY_LITERAL: 3434 S = ObjCDictionaryLiteral::CreateEmpty(Context, 3435 Record[ASTStmtReader::NumExprFields], 3436 Record[ASTStmtReader::NumExprFields + 1]); 3437 break; 3438 3439 case EXPR_OBJC_ENCODE: 3440 S = new (Context) ObjCEncodeExpr(Empty); 3441 break; 3442 3443 case EXPR_OBJC_SELECTOR_EXPR: 3444 S = new (Context) ObjCSelectorExpr(Empty); 3445 break; 3446 3447 case EXPR_OBJC_PROTOCOL_EXPR: 3448 S = new (Context) ObjCProtocolExpr(Empty); 3449 break; 3450 3451 case EXPR_OBJC_IVAR_REF_EXPR: 3452 S = new (Context) ObjCIvarRefExpr(Empty); 3453 break; 3454 3455 case EXPR_OBJC_PROPERTY_REF_EXPR: 3456 S = new (Context) ObjCPropertyRefExpr(Empty); 3457 break; 3458 3459 case EXPR_OBJC_SUBSCRIPT_REF_EXPR: 3460 S = new (Context) ObjCSubscriptRefExpr(Empty); 3461 break; 3462 3463 case EXPR_OBJC_KVC_REF_EXPR: 3464 llvm_unreachable("mismatching AST file"); 3465 3466 case EXPR_OBJC_MESSAGE_EXPR: 3467 S = ObjCMessageExpr::CreateEmpty(Context, 3468 Record[ASTStmtReader::NumExprFields], 3469 Record[ASTStmtReader::NumExprFields + 1]); 3470 break; 3471 3472 case EXPR_OBJC_ISA: 3473 S = new (Context) ObjCIsaExpr(Empty); 3474 break; 3475 3476 case EXPR_OBJC_INDIRECT_COPY_RESTORE: 3477 S = new (Context) ObjCIndirectCopyRestoreExpr(Empty); 3478 break; 3479 3480 case EXPR_OBJC_BRIDGED_CAST: 3481 S = new (Context) ObjCBridgedCastExpr(Empty); 3482 break; 3483 3484 case STMT_OBJC_FOR_COLLECTION: 3485 S = new (Context) ObjCForCollectionStmt(Empty); 3486 break; 3487 3488 case STMT_OBJC_CATCH: 3489 S = new (Context) ObjCAtCatchStmt(Empty); 3490 break; 3491 3492 case STMT_OBJC_FINALLY: 3493 S = new (Context) ObjCAtFinallyStmt(Empty); 3494 break; 3495 3496 case STMT_OBJC_AT_TRY: 3497 S = ObjCAtTryStmt::CreateEmpty(Context, 3498 Record[ASTStmtReader::NumStmtFields], 3499 Record[ASTStmtReader::NumStmtFields + 1]); 3500 break; 3501 3502 case STMT_OBJC_AT_SYNCHRONIZED: 3503 S = new (Context) ObjCAtSynchronizedStmt(Empty); 3504 break; 3505 3506 case STMT_OBJC_AT_THROW: 3507 S = new (Context) ObjCAtThrowStmt(Empty); 3508 break; 3509 3510 case STMT_OBJC_AUTORELEASE_POOL: 3511 S = new (Context) ObjCAutoreleasePoolStmt(Empty); 3512 break; 3513 3514 case EXPR_OBJC_BOOL_LITERAL: 3515 S = new (Context) ObjCBoolLiteralExpr(Empty); 3516 break; 3517 3518 case EXPR_OBJC_AVAILABILITY_CHECK: 3519 S = new (Context) ObjCAvailabilityCheckExpr(Empty); 3520 break; 3521 3522 case STMT_SEH_LEAVE: 3523 S = new (Context) SEHLeaveStmt(Empty); 3524 break; 3525 3526 case STMT_SEH_EXCEPT: 3527 S = new (Context) SEHExceptStmt(Empty); 3528 break; 3529 3530 case STMT_SEH_FINALLY: 3531 S = new (Context) SEHFinallyStmt(Empty); 3532 break; 3533 3534 case STMT_SEH_TRY: 3535 S = new (Context) SEHTryStmt(Empty); 3536 break; 3537 3538 case STMT_CXX_CATCH: 3539 S = new (Context) CXXCatchStmt(Empty); 3540 break; 3541 3542 case STMT_CXX_TRY: 3543 S = CXXTryStmt::Create(Context, Empty, 3544 /*numHandlers=*/Record[ASTStmtReader::NumStmtFields]); 3545 break; 3546 3547 case STMT_CXX_FOR_RANGE: 3548 S = new (Context) CXXForRangeStmt(Empty); 3549 break; 3550 3551 case STMT_MS_DEPENDENT_EXISTS: 3552 S = new (Context) MSDependentExistsStmt(SourceLocation(), true, 3553 NestedNameSpecifierLoc(), 3554 DeclarationNameInfo(), 3555 nullptr); 3556 break; 3557 3558 case STMT_OMP_CANONICAL_LOOP: 3559 S = OMPCanonicalLoop::createEmpty(Context); 3560 break; 3561 3562 case STMT_OMP_META_DIRECTIVE: 3563 S = OMPMetaDirective::CreateEmpty( 3564 Context, Record[ASTStmtReader::NumStmtFields], Empty); 3565 break; 3566 3567 case STMT_OMP_PARALLEL_DIRECTIVE: 3568 S = 3569 OMPParallelDirective::CreateEmpty(Context, 3570 Record[ASTStmtReader::NumStmtFields], 3571 Empty); 3572 break; 3573 3574 case STMT_OMP_SIMD_DIRECTIVE: { 3575 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; 3576 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; 3577 S = OMPSimdDirective::CreateEmpty(Context, NumClauses, 3578 CollapsedNum, Empty); 3579 break; 3580 } 3581 3582 case STMT_OMP_TILE_DIRECTIVE: { 3583 unsigned NumLoops = Record[ASTStmtReader::NumStmtFields]; 3584 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; 3585 S = OMPTileDirective::CreateEmpty(Context, NumClauses, NumLoops); 3586 break; 3587 } 3588 3589 case STMP_OMP_STRIPE_DIRECTIVE: { 3590 unsigned NumLoops = Record[ASTStmtReader::NumStmtFields]; 3591 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; 3592 S = OMPStripeDirective::CreateEmpty(Context, NumClauses, NumLoops); 3593 break; 3594 } 3595 3596 case STMT_OMP_UNROLL_DIRECTIVE: { 3597 assert(Record[ASTStmtReader::NumStmtFields] == 1 && "Unroll directive accepts only a single loop"); 3598 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; 3599 S = OMPUnrollDirective::CreateEmpty(Context, NumClauses); 3600 break; 3601 } 3602 3603 case STMT_OMP_REVERSE_DIRECTIVE: { 3604 unsigned NumLoops = Record[ASTStmtReader::NumStmtFields]; 3605 assert(Record[ASTStmtReader::NumStmtFields + 1] == 0 && 3606 "Reverse directive has no clauses"); 3607 S = OMPReverseDirective::CreateEmpty(Context, NumLoops); 3608 break; 3609 } 3610 3611 case STMT_OMP_INTERCHANGE_DIRECTIVE: { 3612 unsigned NumLoops = Record[ASTStmtReader::NumStmtFields]; 3613 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; 3614 S = OMPInterchangeDirective::CreateEmpty(Context, NumClauses, NumLoops); 3615 break; 3616 } 3617 3618 case STMT_OMP_FOR_DIRECTIVE: { 3619 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; 3620 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; 3621 S = OMPForDirective::CreateEmpty(Context, NumClauses, CollapsedNum, 3622 Empty); 3623 break; 3624 } 3625 3626 case STMT_OMP_FOR_SIMD_DIRECTIVE: { 3627 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; 3628 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; 3629 S = OMPForSimdDirective::CreateEmpty(Context, NumClauses, CollapsedNum, 3630 Empty); 3631 break; 3632 } 3633 3634 case STMT_OMP_SECTIONS_DIRECTIVE: 3635 S = OMPSectionsDirective::CreateEmpty( 3636 Context, Record[ASTStmtReader::NumStmtFields], Empty); 3637 break; 3638 3639 case STMT_OMP_SECTION_DIRECTIVE: 3640 S = OMPSectionDirective::CreateEmpty(Context, Empty); 3641 break; 3642 3643 case STMT_OMP_SCOPE_DIRECTIVE: 3644 S = OMPScopeDirective::CreateEmpty( 3645 Context, Record[ASTStmtReader::NumStmtFields], Empty); 3646 break; 3647 3648 case STMT_OMP_SINGLE_DIRECTIVE: 3649 S = OMPSingleDirective::CreateEmpty( 3650 Context, Record[ASTStmtReader::NumStmtFields], Empty); 3651 break; 3652 3653 case STMT_OMP_MASTER_DIRECTIVE: 3654 S = OMPMasterDirective::CreateEmpty(Context, Empty); 3655 break; 3656 3657 case STMT_OMP_CRITICAL_DIRECTIVE: 3658 S = OMPCriticalDirective::CreateEmpty( 3659 Context, Record[ASTStmtReader::NumStmtFields], Empty); 3660 break; 3661 3662 case STMT_OMP_PARALLEL_FOR_DIRECTIVE: { 3663 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; 3664 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; 3665 S = OMPParallelForDirective::CreateEmpty(Context, NumClauses, 3666 CollapsedNum, Empty); 3667 break; 3668 } 3669 3670 case STMT_OMP_PARALLEL_FOR_SIMD_DIRECTIVE: { 3671 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; 3672 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; 3673 S = OMPParallelForSimdDirective::CreateEmpty(Context, NumClauses, 3674 CollapsedNum, Empty); 3675 break; 3676 } 3677 3678 case STMT_OMP_PARALLEL_MASTER_DIRECTIVE: 3679 S = OMPParallelMasterDirective::CreateEmpty( 3680 Context, Record[ASTStmtReader::NumStmtFields], Empty); 3681 break; 3682 3683 case STMT_OMP_PARALLEL_MASKED_DIRECTIVE: 3684 S = OMPParallelMaskedDirective::CreateEmpty( 3685 Context, Record[ASTStmtReader::NumStmtFields], Empty); 3686 break; 3687 3688 case STMT_OMP_PARALLEL_SECTIONS_DIRECTIVE: 3689 S = OMPParallelSectionsDirective::CreateEmpty( 3690 Context, Record[ASTStmtReader::NumStmtFields], Empty); 3691 break; 3692 3693 case STMT_OMP_TASK_DIRECTIVE: 3694 S = OMPTaskDirective::CreateEmpty( 3695 Context, Record[ASTStmtReader::NumStmtFields], Empty); 3696 break; 3697 3698 case STMT_OMP_TASKYIELD_DIRECTIVE: 3699 S = OMPTaskyieldDirective::CreateEmpty(Context, Empty); 3700 break; 3701 3702 case STMT_OMP_BARRIER_DIRECTIVE: 3703 S = OMPBarrierDirective::CreateEmpty(Context, Empty); 3704 break; 3705 3706 case STMT_OMP_TASKWAIT_DIRECTIVE: 3707 S = OMPTaskwaitDirective::CreateEmpty( 3708 Context, Record[ASTStmtReader::NumStmtFields], Empty); 3709 break; 3710 3711 case STMT_OMP_ERROR_DIRECTIVE: 3712 S = OMPErrorDirective::CreateEmpty( 3713 Context, Record[ASTStmtReader::NumStmtFields], Empty); 3714 break; 3715 3716 case STMT_OMP_TASKGROUP_DIRECTIVE: 3717 S = OMPTaskgroupDirective::CreateEmpty( 3718 Context, Record[ASTStmtReader::NumStmtFields], Empty); 3719 break; 3720 3721 case STMT_OMP_FLUSH_DIRECTIVE: 3722 S = OMPFlushDirective::CreateEmpty( 3723 Context, Record[ASTStmtReader::NumStmtFields], Empty); 3724 break; 3725 3726 case STMT_OMP_DEPOBJ_DIRECTIVE: 3727 S = OMPDepobjDirective::CreateEmpty( 3728 Context, Record[ASTStmtReader::NumStmtFields], Empty); 3729 break; 3730 3731 case STMT_OMP_SCAN_DIRECTIVE: 3732 S = OMPScanDirective::CreateEmpty( 3733 Context, Record[ASTStmtReader::NumStmtFields], Empty); 3734 break; 3735 3736 case STMT_OMP_ORDERED_DIRECTIVE: { 3737 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields]; 3738 bool HasAssociatedStmt = Record[ASTStmtReader::NumStmtFields + 2]; 3739 S = OMPOrderedDirective::CreateEmpty(Context, NumClauses, 3740 !HasAssociatedStmt, Empty); 3741 break; 3742 } 3743 3744 case STMT_OMP_ATOMIC_DIRECTIVE: 3745 S = OMPAtomicDirective::CreateEmpty( 3746 Context, Record[ASTStmtReader::NumStmtFields], Empty); 3747 break; 3748 3749 case STMT_OMP_TARGET_DIRECTIVE: 3750 S = OMPTargetDirective::CreateEmpty( 3751 Context, Record[ASTStmtReader::NumStmtFields], Empty); 3752 break; 3753 3754 case STMT_OMP_TARGET_DATA_DIRECTIVE: 3755 S = OMPTargetDataDirective::CreateEmpty( 3756 Context, Record[ASTStmtReader::NumStmtFields], Empty); 3757 break; 3758 3759 case STMT_OMP_TARGET_ENTER_DATA_DIRECTIVE: 3760 S = OMPTargetEnterDataDirective::CreateEmpty( 3761 Context, Record[ASTStmtReader::NumStmtFields], Empty); 3762 break; 3763 3764 case STMT_OMP_TARGET_EXIT_DATA_DIRECTIVE: 3765 S = OMPTargetExitDataDirective::CreateEmpty( 3766 Context, Record[ASTStmtReader::NumStmtFields], Empty); 3767 break; 3768 3769 case STMT_OMP_TARGET_PARALLEL_DIRECTIVE: 3770 S = OMPTargetParallelDirective::CreateEmpty( 3771 Context, Record[ASTStmtReader::NumStmtFields], Empty); 3772 break; 3773 3774 case STMT_OMP_TARGET_PARALLEL_FOR_DIRECTIVE: { 3775 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; 3776 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; 3777 S = OMPTargetParallelForDirective::CreateEmpty(Context, NumClauses, 3778 CollapsedNum, Empty); 3779 break; 3780 } 3781 3782 case STMT_OMP_TARGET_UPDATE_DIRECTIVE: 3783 S = OMPTargetUpdateDirective::CreateEmpty( 3784 Context, Record[ASTStmtReader::NumStmtFields], Empty); 3785 break; 3786 3787 case STMT_OMP_TEAMS_DIRECTIVE: 3788 S = OMPTeamsDirective::CreateEmpty( 3789 Context, Record[ASTStmtReader::NumStmtFields], Empty); 3790 break; 3791 3792 case STMT_OMP_CANCELLATION_POINT_DIRECTIVE: 3793 S = OMPCancellationPointDirective::CreateEmpty(Context, Empty); 3794 break; 3795 3796 case STMT_OMP_CANCEL_DIRECTIVE: 3797 S = OMPCancelDirective::CreateEmpty( 3798 Context, Record[ASTStmtReader::NumStmtFields], Empty); 3799 break; 3800 3801 case STMT_OMP_TASKLOOP_DIRECTIVE: { 3802 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; 3803 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; 3804 S = OMPTaskLoopDirective::CreateEmpty(Context, NumClauses, CollapsedNum, 3805 Empty); 3806 break; 3807 } 3808 3809 case STMT_OMP_TASKLOOP_SIMD_DIRECTIVE: { 3810 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; 3811 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; 3812 S = OMPTaskLoopSimdDirective::CreateEmpty(Context, NumClauses, 3813 CollapsedNum, Empty); 3814 break; 3815 } 3816 3817 case STMT_OMP_MASTER_TASKLOOP_DIRECTIVE: { 3818 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; 3819 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; 3820 S = OMPMasterTaskLoopDirective::CreateEmpty(Context, NumClauses, 3821 CollapsedNum, Empty); 3822 break; 3823 } 3824 3825 case STMT_OMP_MASKED_TASKLOOP_DIRECTIVE: { 3826 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; 3827 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; 3828 S = OMPMaskedTaskLoopDirective::CreateEmpty(Context, NumClauses, 3829 CollapsedNum, Empty); 3830 break; 3831 } 3832 3833 case STMT_OMP_MASTER_TASKLOOP_SIMD_DIRECTIVE: { 3834 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; 3835 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; 3836 S = OMPMasterTaskLoopSimdDirective::CreateEmpty(Context, NumClauses, 3837 CollapsedNum, Empty); 3838 break; 3839 } 3840 3841 case STMT_OMP_MASKED_TASKLOOP_SIMD_DIRECTIVE: { 3842 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; 3843 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; 3844 S = OMPMaskedTaskLoopSimdDirective::CreateEmpty(Context, NumClauses, 3845 CollapsedNum, Empty); 3846 break; 3847 } 3848 3849 case STMT_OMP_PARALLEL_MASTER_TASKLOOP_DIRECTIVE: { 3850 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; 3851 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; 3852 S = OMPParallelMasterTaskLoopDirective::CreateEmpty(Context, NumClauses, 3853 CollapsedNum, Empty); 3854 break; 3855 } 3856 3857 case STMT_OMP_PARALLEL_MASKED_TASKLOOP_DIRECTIVE: { 3858 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; 3859 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; 3860 S = OMPParallelMaskedTaskLoopDirective::CreateEmpty(Context, NumClauses, 3861 CollapsedNum, Empty); 3862 break; 3863 } 3864 3865 case STMT_OMP_PARALLEL_MASTER_TASKLOOP_SIMD_DIRECTIVE: { 3866 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; 3867 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; 3868 S = OMPParallelMasterTaskLoopSimdDirective::CreateEmpty( 3869 Context, NumClauses, CollapsedNum, Empty); 3870 break; 3871 } 3872 3873 case STMT_OMP_PARALLEL_MASKED_TASKLOOP_SIMD_DIRECTIVE: { 3874 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; 3875 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; 3876 S = OMPParallelMaskedTaskLoopSimdDirective::CreateEmpty( 3877 Context, NumClauses, CollapsedNum, Empty); 3878 break; 3879 } 3880 3881 case STMT_OMP_DISTRIBUTE_DIRECTIVE: { 3882 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; 3883 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; 3884 S = OMPDistributeDirective::CreateEmpty(Context, NumClauses, CollapsedNum, 3885 Empty); 3886 break; 3887 } 3888 3889 case STMT_OMP_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE: { 3890 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; 3891 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; 3892 S = OMPDistributeParallelForDirective::CreateEmpty(Context, NumClauses, 3893 CollapsedNum, Empty); 3894 break; 3895 } 3896 3897 case STMT_OMP_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE: { 3898 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; 3899 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; 3900 S = OMPDistributeParallelForSimdDirective::CreateEmpty(Context, NumClauses, 3901 CollapsedNum, 3902 Empty); 3903 break; 3904 } 3905 3906 case STMT_OMP_DISTRIBUTE_SIMD_DIRECTIVE: { 3907 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; 3908 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; 3909 S = OMPDistributeSimdDirective::CreateEmpty(Context, NumClauses, 3910 CollapsedNum, Empty); 3911 break; 3912 } 3913 3914 case STMT_OMP_TARGET_PARALLEL_FOR_SIMD_DIRECTIVE: { 3915 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; 3916 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; 3917 S = OMPTargetParallelForSimdDirective::CreateEmpty(Context, NumClauses, 3918 CollapsedNum, Empty); 3919 break; 3920 } 3921 3922 case STMT_OMP_TARGET_SIMD_DIRECTIVE: { 3923 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; 3924 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; 3925 S = OMPTargetSimdDirective::CreateEmpty(Context, NumClauses, CollapsedNum, 3926 Empty); 3927 break; 3928 } 3929 3930 case STMT_OMP_TEAMS_DISTRIBUTE_DIRECTIVE: { 3931 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; 3932 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; 3933 S = OMPTeamsDistributeDirective::CreateEmpty(Context, NumClauses, 3934 CollapsedNum, Empty); 3935 break; 3936 } 3937 3938 case STMT_OMP_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE: { 3939 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; 3940 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; 3941 S = OMPTeamsDistributeSimdDirective::CreateEmpty(Context, NumClauses, 3942 CollapsedNum, Empty); 3943 break; 3944 } 3945 3946 case STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE: { 3947 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; 3948 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; 3949 S = OMPTeamsDistributeParallelForSimdDirective::CreateEmpty( 3950 Context, NumClauses, CollapsedNum, Empty); 3951 break; 3952 } 3953 3954 case STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE: { 3955 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; 3956 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; 3957 S = OMPTeamsDistributeParallelForDirective::CreateEmpty( 3958 Context, NumClauses, CollapsedNum, Empty); 3959 break; 3960 } 3961 3962 case STMT_OMP_TARGET_TEAMS_DIRECTIVE: 3963 S = OMPTargetTeamsDirective::CreateEmpty( 3964 Context, Record[ASTStmtReader::NumStmtFields], Empty); 3965 break; 3966 3967 case STMT_OMP_TARGET_TEAMS_DISTRIBUTE_DIRECTIVE: { 3968 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; 3969 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; 3970 S = OMPTargetTeamsDistributeDirective::CreateEmpty(Context, NumClauses, 3971 CollapsedNum, Empty); 3972 break; 3973 } 3974 3975 case STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE: { 3976 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; 3977 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; 3978 S = OMPTargetTeamsDistributeParallelForDirective::CreateEmpty( 3979 Context, NumClauses, CollapsedNum, Empty); 3980 break; 3981 } 3982 3983 case STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE: { 3984 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; 3985 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; 3986 S = OMPTargetTeamsDistributeParallelForSimdDirective::CreateEmpty( 3987 Context, NumClauses, CollapsedNum, Empty); 3988 break; 3989 } 3990 3991 case STMT_OMP_TARGET_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE: { 3992 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; 3993 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; 3994 S = OMPTargetTeamsDistributeSimdDirective::CreateEmpty( 3995 Context, NumClauses, CollapsedNum, Empty); 3996 break; 3997 } 3998 3999 case STMT_OMP_INTEROP_DIRECTIVE: 4000 S = OMPInteropDirective::CreateEmpty( 4001 Context, Record[ASTStmtReader::NumStmtFields], Empty); 4002 break; 4003 4004 case STMT_OMP_DISPATCH_DIRECTIVE: 4005 S = OMPDispatchDirective::CreateEmpty( 4006 Context, Record[ASTStmtReader::NumStmtFields], Empty); 4007 break; 4008 4009 case STMT_OMP_MASKED_DIRECTIVE: 4010 S = OMPMaskedDirective::CreateEmpty( 4011 Context, Record[ASTStmtReader::NumStmtFields], Empty); 4012 break; 4013 4014 case STMT_OMP_GENERIC_LOOP_DIRECTIVE: { 4015 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; 4016 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; 4017 S = OMPGenericLoopDirective::CreateEmpty(Context, NumClauses, 4018 CollapsedNum, Empty); 4019 break; 4020 } 4021 4022 case STMT_OMP_TEAMS_GENERIC_LOOP_DIRECTIVE: { 4023 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; 4024 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; 4025 S = OMPTeamsGenericLoopDirective::CreateEmpty(Context, NumClauses, 4026 CollapsedNum, Empty); 4027 break; 4028 } 4029 4030 case STMT_OMP_TARGET_TEAMS_GENERIC_LOOP_DIRECTIVE: { 4031 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; 4032 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; 4033 S = OMPTargetTeamsGenericLoopDirective::CreateEmpty(Context, NumClauses, 4034 CollapsedNum, Empty); 4035 break; 4036 } 4037 4038 case STMT_OMP_PARALLEL_GENERIC_LOOP_DIRECTIVE: { 4039 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; 4040 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; 4041 S = OMPParallelGenericLoopDirective::CreateEmpty(Context, NumClauses, 4042 CollapsedNum, Empty); 4043 break; 4044 } 4045 4046 case STMT_OMP_TARGET_PARALLEL_GENERIC_LOOP_DIRECTIVE: { 4047 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; 4048 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; 4049 S = OMPTargetParallelGenericLoopDirective::CreateEmpty( 4050 Context, NumClauses, CollapsedNum, Empty); 4051 break; 4052 } 4053 4054 case STMT_OMP_ASSUME_DIRECTIVE: { 4055 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields]; 4056 S = OMPAssumeDirective::CreateEmpty(Context, NumClauses, Empty); 4057 break; 4058 } 4059 4060 case EXPR_CXX_OPERATOR_CALL: { 4061 auto NumArgs = Record[ASTStmtReader::NumExprFields]; 4062 BitsUnpacker CallExprBits(Record[ASTStmtReader::NumExprFields + 1]); 4063 CallExprBits.advance(1); 4064 auto HasFPFeatures = CallExprBits.getNextBit(); 4065 S = CXXOperatorCallExpr::CreateEmpty(Context, NumArgs, HasFPFeatures, 4066 Empty); 4067 break; 4068 } 4069 4070 case EXPR_CXX_MEMBER_CALL: { 4071 auto NumArgs = Record[ASTStmtReader::NumExprFields]; 4072 BitsUnpacker CallExprBits(Record[ASTStmtReader::NumExprFields + 1]); 4073 CallExprBits.advance(1); 4074 auto HasFPFeatures = CallExprBits.getNextBit(); 4075 S = CXXMemberCallExpr::CreateEmpty(Context, NumArgs, HasFPFeatures, 4076 Empty); 4077 break; 4078 } 4079 4080 case EXPR_CXX_REWRITTEN_BINARY_OPERATOR: 4081 S = new (Context) CXXRewrittenBinaryOperator(Empty); 4082 break; 4083 4084 case EXPR_CXX_CONSTRUCT: 4085 S = CXXConstructExpr::CreateEmpty( 4086 Context, 4087 /* NumArgs=*/Record[ASTStmtReader::NumExprFields]); 4088 break; 4089 4090 case EXPR_CXX_INHERITED_CTOR_INIT: 4091 S = new (Context) CXXInheritedCtorInitExpr(Empty); 4092 break; 4093 4094 case EXPR_CXX_TEMPORARY_OBJECT: 4095 S = CXXTemporaryObjectExpr::CreateEmpty( 4096 Context, 4097 /* NumArgs=*/Record[ASTStmtReader::NumExprFields]); 4098 break; 4099 4100 case EXPR_CXX_STATIC_CAST: { 4101 unsigned PathSize = Record[ASTStmtReader::NumExprFields]; 4102 BitsUnpacker CastExprBits(Record[ASTStmtReader::NumExprFields + 1]); 4103 CastExprBits.advance(7); 4104 bool HasFPFeatures = CastExprBits.getNextBit(); 4105 S = CXXStaticCastExpr::CreateEmpty(Context, PathSize, HasFPFeatures); 4106 break; 4107 } 4108 4109 case EXPR_CXX_DYNAMIC_CAST: { 4110 unsigned PathSize = Record[ASTStmtReader::NumExprFields]; 4111 S = CXXDynamicCastExpr::CreateEmpty(Context, PathSize); 4112 break; 4113 } 4114 4115 case EXPR_CXX_REINTERPRET_CAST: { 4116 unsigned PathSize = Record[ASTStmtReader::NumExprFields]; 4117 S = CXXReinterpretCastExpr::CreateEmpty(Context, PathSize); 4118 break; 4119 } 4120 4121 case EXPR_CXX_CONST_CAST: 4122 S = CXXConstCastExpr::CreateEmpty(Context); 4123 break; 4124 4125 case EXPR_CXX_ADDRSPACE_CAST: 4126 S = CXXAddrspaceCastExpr::CreateEmpty(Context); 4127 break; 4128 4129 case EXPR_CXX_FUNCTIONAL_CAST: { 4130 unsigned PathSize = Record[ASTStmtReader::NumExprFields]; 4131 BitsUnpacker CastExprBits(Record[ASTStmtReader::NumExprFields + 1]); 4132 CastExprBits.advance(7); 4133 bool HasFPFeatures = CastExprBits.getNextBit(); 4134 S = CXXFunctionalCastExpr::CreateEmpty(Context, PathSize, HasFPFeatures); 4135 break; 4136 } 4137 4138 case EXPR_BUILTIN_BIT_CAST: { 4139 #ifndef NDEBUG 4140 unsigned PathSize = Record[ASTStmtReader::NumExprFields]; 4141 assert(PathSize == 0 && "Wrong PathSize!"); 4142 #endif 4143 S = new (Context) BuiltinBitCastExpr(Empty); 4144 break; 4145 } 4146 4147 case EXPR_USER_DEFINED_LITERAL: { 4148 auto NumArgs = Record[ASTStmtReader::NumExprFields]; 4149 BitsUnpacker CallExprBits(Record[ASTStmtReader::NumExprFields + 1]); 4150 CallExprBits.advance(1); 4151 auto HasFPFeatures = CallExprBits.getNextBit(); 4152 S = UserDefinedLiteral::CreateEmpty(Context, NumArgs, HasFPFeatures, 4153 Empty); 4154 break; 4155 } 4156 4157 case EXPR_CXX_STD_INITIALIZER_LIST: 4158 S = new (Context) CXXStdInitializerListExpr(Empty); 4159 break; 4160 4161 case EXPR_CXX_BOOL_LITERAL: 4162 S = new (Context) CXXBoolLiteralExpr(Empty); 4163 break; 4164 4165 case EXPR_CXX_NULL_PTR_LITERAL: 4166 S = new (Context) CXXNullPtrLiteralExpr(Empty); 4167 break; 4168 4169 case EXPR_CXX_TYPEID_EXPR: 4170 S = new (Context) CXXTypeidExpr(Empty, true); 4171 break; 4172 4173 case EXPR_CXX_TYPEID_TYPE: 4174 S = new (Context) CXXTypeidExpr(Empty, false); 4175 break; 4176 4177 case EXPR_CXX_UUIDOF_EXPR: 4178 S = new (Context) CXXUuidofExpr(Empty, true); 4179 break; 4180 4181 case EXPR_CXX_PROPERTY_REF_EXPR: 4182 S = new (Context) MSPropertyRefExpr(Empty); 4183 break; 4184 4185 case EXPR_CXX_PROPERTY_SUBSCRIPT_EXPR: 4186 S = new (Context) MSPropertySubscriptExpr(Empty); 4187 break; 4188 4189 case EXPR_CXX_UUIDOF_TYPE: 4190 S = new (Context) CXXUuidofExpr(Empty, false); 4191 break; 4192 4193 case EXPR_CXX_THIS: 4194 S = CXXThisExpr::CreateEmpty(Context); 4195 break; 4196 4197 case EXPR_CXX_THROW: 4198 S = new (Context) CXXThrowExpr(Empty); 4199 break; 4200 4201 case EXPR_CXX_DEFAULT_ARG: 4202 S = CXXDefaultArgExpr::CreateEmpty( 4203 Context, /*HasRewrittenInit=*/Record[ASTStmtReader::NumExprFields]); 4204 break; 4205 4206 case EXPR_CXX_DEFAULT_INIT: 4207 S = CXXDefaultInitExpr::CreateEmpty( 4208 Context, /*HasRewrittenInit=*/Record[ASTStmtReader::NumExprFields]); 4209 break; 4210 4211 case EXPR_CXX_BIND_TEMPORARY: 4212 S = new (Context) CXXBindTemporaryExpr(Empty); 4213 break; 4214 4215 case EXPR_CXX_SCALAR_VALUE_INIT: 4216 S = new (Context) CXXScalarValueInitExpr(Empty); 4217 break; 4218 4219 case EXPR_CXX_NEW: 4220 S = CXXNewExpr::CreateEmpty( 4221 Context, 4222 /*IsArray=*/Record[ASTStmtReader::NumExprFields], 4223 /*HasInit=*/Record[ASTStmtReader::NumExprFields + 1], 4224 /*NumPlacementArgs=*/Record[ASTStmtReader::NumExprFields + 2], 4225 /*IsParenTypeId=*/Record[ASTStmtReader::NumExprFields + 3]); 4226 break; 4227 4228 case EXPR_CXX_DELETE: 4229 S = new (Context) CXXDeleteExpr(Empty); 4230 break; 4231 4232 case EXPR_CXX_PSEUDO_DESTRUCTOR: 4233 S = new (Context) CXXPseudoDestructorExpr(Empty); 4234 break; 4235 4236 case EXPR_EXPR_WITH_CLEANUPS: 4237 S = ExprWithCleanups::Create(Context, Empty, 4238 Record[ASTStmtReader::NumExprFields]); 4239 break; 4240 4241 case EXPR_CXX_DEPENDENT_SCOPE_MEMBER: { 4242 unsigned NumTemplateArgs = Record[ASTStmtReader::NumExprFields]; 4243 BitsUnpacker DependentScopeMemberBits( 4244 Record[ASTStmtReader::NumExprFields + 1]); 4245 bool HasTemplateKWAndArgsInfo = DependentScopeMemberBits.getNextBit(); 4246 4247 bool HasFirstQualifierFoundInScope = 4248 DependentScopeMemberBits.getNextBit(); 4249 S = CXXDependentScopeMemberExpr::CreateEmpty( 4250 Context, HasTemplateKWAndArgsInfo, NumTemplateArgs, 4251 HasFirstQualifierFoundInScope); 4252 break; 4253 } 4254 4255 case EXPR_CXX_DEPENDENT_SCOPE_DECL_REF: { 4256 BitsUnpacker DependentScopeDeclRefBits( 4257 Record[ASTStmtReader::NumStmtFields]); 4258 DependentScopeDeclRefBits.advance(ASTStmtReader::NumExprBits); 4259 bool HasTemplateKWAndArgsInfo = DependentScopeDeclRefBits.getNextBit(); 4260 unsigned NumTemplateArgs = 4261 HasTemplateKWAndArgsInfo 4262 ? DependentScopeDeclRefBits.getNextBits(/*Width=*/16) 4263 : 0; 4264 S = DependentScopeDeclRefExpr::CreateEmpty( 4265 Context, HasTemplateKWAndArgsInfo, NumTemplateArgs); 4266 break; 4267 } 4268 4269 case EXPR_CXX_UNRESOLVED_CONSTRUCT: 4270 S = CXXUnresolvedConstructExpr::CreateEmpty(Context, 4271 /*NumArgs=*/Record[ASTStmtReader::NumExprFields]); 4272 break; 4273 4274 case EXPR_CXX_UNRESOLVED_MEMBER: { 4275 auto NumResults = Record[ASTStmtReader::NumExprFields]; 4276 BitsUnpacker OverloadExprBits(Record[ASTStmtReader::NumExprFields + 1]); 4277 auto HasTemplateKWAndArgsInfo = OverloadExprBits.getNextBit(); 4278 auto NumTemplateArgs = HasTemplateKWAndArgsInfo 4279 ? Record[ASTStmtReader::NumExprFields + 2] 4280 : 0; 4281 S = UnresolvedMemberExpr::CreateEmpty( 4282 Context, NumResults, HasTemplateKWAndArgsInfo, NumTemplateArgs); 4283 break; 4284 } 4285 4286 case EXPR_CXX_UNRESOLVED_LOOKUP: { 4287 auto NumResults = Record[ASTStmtReader::NumExprFields]; 4288 BitsUnpacker OverloadExprBits(Record[ASTStmtReader::NumExprFields + 1]); 4289 auto HasTemplateKWAndArgsInfo = OverloadExprBits.getNextBit(); 4290 auto NumTemplateArgs = HasTemplateKWAndArgsInfo 4291 ? Record[ASTStmtReader::NumExprFields + 2] 4292 : 0; 4293 S = UnresolvedLookupExpr::CreateEmpty( 4294 Context, NumResults, HasTemplateKWAndArgsInfo, NumTemplateArgs); 4295 break; 4296 } 4297 4298 case EXPR_TYPE_TRAIT: 4299 S = TypeTraitExpr::CreateDeserialized( 4300 Context, Record[ASTStmtReader::NumExprFields], 4301 Record[ASTStmtReader::NumExprFields + 1]); 4302 break; 4303 4304 case EXPR_ARRAY_TYPE_TRAIT: 4305 S = new (Context) ArrayTypeTraitExpr(Empty); 4306 break; 4307 4308 case EXPR_CXX_EXPRESSION_TRAIT: 4309 S = new (Context) ExpressionTraitExpr(Empty); 4310 break; 4311 4312 case EXPR_CXX_NOEXCEPT: 4313 S = new (Context) CXXNoexceptExpr(Empty); 4314 break; 4315 4316 case EXPR_PACK_EXPANSION: 4317 S = new (Context) PackExpansionExpr(Empty); 4318 break; 4319 4320 case EXPR_SIZEOF_PACK: 4321 S = SizeOfPackExpr::CreateDeserialized( 4322 Context, 4323 /*NumPartialArgs=*/Record[ASTStmtReader::NumExprFields]); 4324 break; 4325 4326 case EXPR_PACK_INDEXING: 4327 S = PackIndexingExpr::CreateDeserialized( 4328 Context, 4329 /*TransformedExprs=*/Record[ASTStmtReader::NumExprFields]); 4330 break; 4331 4332 case EXPR_SUBST_NON_TYPE_TEMPLATE_PARM: 4333 S = new (Context) SubstNonTypeTemplateParmExpr(Empty); 4334 break; 4335 4336 case EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK: 4337 S = new (Context) SubstNonTypeTemplateParmPackExpr(Empty); 4338 break; 4339 4340 case EXPR_FUNCTION_PARM_PACK: 4341 S = FunctionParmPackExpr::CreateEmpty(Context, 4342 Record[ASTStmtReader::NumExprFields]); 4343 break; 4344 4345 case EXPR_MATERIALIZE_TEMPORARY: 4346 S = new (Context) MaterializeTemporaryExpr(Empty); 4347 break; 4348 4349 case EXPR_CXX_FOLD: 4350 S = new (Context) CXXFoldExpr(Empty); 4351 break; 4352 4353 case EXPR_CXX_PAREN_LIST_INIT: 4354 S = CXXParenListInitExpr::CreateEmpty( 4355 Context, /*numExprs=*/Record[ASTStmtReader::NumExprFields], Empty); 4356 break; 4357 4358 case EXPR_OPAQUE_VALUE: 4359 S = new (Context) OpaqueValueExpr(Empty); 4360 break; 4361 4362 case EXPR_CUDA_KERNEL_CALL: { 4363 auto NumArgs = Record[ASTStmtReader::NumExprFields]; 4364 BitsUnpacker CallExprBits(Record[ASTStmtReader::NumExprFields + 1]); 4365 CallExprBits.advance(1); 4366 auto HasFPFeatures = CallExprBits.getNextBit(); 4367 S = CUDAKernelCallExpr::CreateEmpty(Context, NumArgs, HasFPFeatures, 4368 Empty); 4369 break; 4370 } 4371 4372 case EXPR_ASTYPE: 4373 S = new (Context) AsTypeExpr(Empty); 4374 break; 4375 4376 case EXPR_PSEUDO_OBJECT: { 4377 unsigned numSemanticExprs = Record[ASTStmtReader::NumExprFields]; 4378 S = PseudoObjectExpr::Create(Context, Empty, numSemanticExprs); 4379 break; 4380 } 4381 4382 case EXPR_ATOMIC: 4383 S = new (Context) AtomicExpr(Empty); 4384 break; 4385 4386 case EXPR_LAMBDA: { 4387 unsigned NumCaptures = Record[ASTStmtReader::NumExprFields]; 4388 S = LambdaExpr::CreateDeserialized(Context, NumCaptures); 4389 break; 4390 } 4391 4392 case STMT_COROUTINE_BODY: { 4393 unsigned NumParams = Record[ASTStmtReader::NumStmtFields]; 4394 S = CoroutineBodyStmt::Create(Context, Empty, NumParams); 4395 break; 4396 } 4397 4398 case STMT_CORETURN: 4399 S = new (Context) CoreturnStmt(Empty); 4400 break; 4401 4402 case EXPR_COAWAIT: 4403 S = new (Context) CoawaitExpr(Empty); 4404 break; 4405 4406 case EXPR_COYIELD: 4407 S = new (Context) CoyieldExpr(Empty); 4408 break; 4409 4410 case EXPR_DEPENDENT_COAWAIT: 4411 S = new (Context) DependentCoawaitExpr(Empty); 4412 break; 4413 4414 case EXPR_CONCEPT_SPECIALIZATION: { 4415 S = new (Context) ConceptSpecializationExpr(Empty); 4416 break; 4417 } 4418 case STMT_OPENACC_COMPUTE_CONSTRUCT: { 4419 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields]; 4420 S = OpenACCComputeConstruct::CreateEmpty(Context, NumClauses); 4421 break; 4422 } 4423 case STMT_OPENACC_LOOP_CONSTRUCT: { 4424 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields]; 4425 S = OpenACCLoopConstruct::CreateEmpty(Context, NumClauses); 4426 break; 4427 } 4428 case STMT_OPENACC_COMBINED_CONSTRUCT: { 4429 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields]; 4430 S = OpenACCCombinedConstruct::CreateEmpty(Context, NumClauses); 4431 break; 4432 } 4433 case STMT_OPENACC_DATA_CONSTRUCT: { 4434 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields]; 4435 S = OpenACCDataConstruct::CreateEmpty(Context, NumClauses); 4436 break; 4437 } 4438 case STMT_OPENACC_ENTER_DATA_CONSTRUCT: { 4439 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields]; 4440 S = OpenACCEnterDataConstruct::CreateEmpty(Context, NumClauses); 4441 break; 4442 } 4443 case STMT_OPENACC_EXIT_DATA_CONSTRUCT: { 4444 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields]; 4445 S = OpenACCExitDataConstruct::CreateEmpty(Context, NumClauses); 4446 break; 4447 } 4448 case STMT_OPENACC_HOST_DATA_CONSTRUCT: { 4449 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields]; 4450 S = OpenACCHostDataConstruct::CreateEmpty(Context, NumClauses); 4451 break; 4452 } 4453 case STMT_OPENACC_WAIT_CONSTRUCT: { 4454 unsigned NumExprs = Record[ASTStmtReader::NumStmtFields]; 4455 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; 4456 S = OpenACCWaitConstruct::CreateEmpty(Context, NumExprs, NumClauses); 4457 break; 4458 } 4459 case STMT_OPENACC_CACHE_CONSTRUCT: { 4460 unsigned NumVars = Record[ASTStmtReader::NumStmtFields]; 4461 S = OpenACCCacheConstruct::CreateEmpty(Context, NumVars); 4462 break; 4463 } 4464 case STMT_OPENACC_INIT_CONSTRUCT: { 4465 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields]; 4466 S = OpenACCInitConstruct::CreateEmpty(Context, NumClauses); 4467 break; 4468 } 4469 case STMT_OPENACC_SHUTDOWN_CONSTRUCT: { 4470 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields]; 4471 S = OpenACCShutdownConstruct::CreateEmpty(Context, NumClauses); 4472 break; 4473 } 4474 case STMT_OPENACC_SET_CONSTRUCT: { 4475 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields]; 4476 S = OpenACCSetConstruct::CreateEmpty(Context, NumClauses); 4477 break; 4478 } 4479 case STMT_OPENACC_UPDATE_CONSTRUCT: { 4480 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields]; 4481 S = OpenACCUpdateConstruct::CreateEmpty(Context, NumClauses); 4482 break; 4483 } 4484 case STMT_OPENACC_ATOMIC_CONSTRUCT: { 4485 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields]; 4486 S = OpenACCAtomicConstruct::CreateEmpty(Context, NumClauses); 4487 break; 4488 } 4489 case EXPR_REQUIRES: { 4490 unsigned numLocalParameters = Record[ASTStmtReader::NumExprFields]; 4491 unsigned numRequirement = Record[ASTStmtReader::NumExprFields + 1]; 4492 S = RequiresExpr::Create(Context, Empty, numLocalParameters, 4493 numRequirement); 4494 break; 4495 } 4496 case EXPR_HLSL_OUT_ARG: 4497 S = HLSLOutArgExpr::CreateEmpty(Context); 4498 break; 4499 } 4500 4501 // We hit a STMT_STOP, so we're done with this expression. 4502 if (Finished) 4503 break; 4504 4505 ++NumStatementsRead; 4506 4507 if (S && !IsStmtReference) { 4508 Reader.Visit(S); 4509 StmtEntries[Cursor.GetCurrentBitNo()] = S; 4510 } 4511 4512 assert(Record.getIdx() == Record.size() && 4513 "Invalid deserialization of statement"); 4514 StmtStack.push_back(S); 4515 } 4516 Done: 4517 assert(StmtStack.size() > PrevNumStmts && "Read too many sub-stmts!"); 4518 assert(StmtStack.size() == PrevNumStmts + 1 && "Extra expressions on stack!"); 4519 return StmtStack.pop_back_val(); 4520 } 4521