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