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