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::VisitArraySubscriptExpr(ArraySubscriptExpr *E) { 738 VisitExpr(E); 739 E->setLHS(Record.readSubExpr()); 740 E->setRHS(Record.readSubExpr()); 741 E->setRBracketLoc(ReadSourceLocation()); 742 } 743 744 void ASTStmtReader::VisitOMPArraySectionExpr(OMPArraySectionExpr *E) { 745 VisitExpr(E); 746 E->setBase(Record.readSubExpr()); 747 E->setLowerBound(Record.readSubExpr()); 748 E->setLength(Record.readSubExpr()); 749 E->setColonLoc(ReadSourceLocation()); 750 E->setRBracketLoc(ReadSourceLocation()); 751 } 752 753 void ASTStmtReader::VisitCallExpr(CallExpr *E) { 754 VisitExpr(E); 755 unsigned NumArgs = Record.readInt(); 756 assert((NumArgs == E->getNumArgs()) && "Wrong NumArgs!"); 757 E->setRParenLoc(ReadSourceLocation()); 758 E->setCallee(Record.readSubExpr()); 759 for (unsigned I = 0; I != NumArgs; ++I) 760 E->setArg(I, Record.readSubExpr()); 761 E->setADLCallKind(static_cast<CallExpr::ADLCallKind>(Record.readInt())); 762 } 763 764 void ASTStmtReader::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) { 765 VisitCallExpr(E); 766 } 767 768 void ASTStmtReader::VisitMemberExpr(MemberExpr *E) { 769 VisitExpr(E); 770 771 bool HasQualifier = Record.readInt(); 772 bool HasFoundDecl = Record.readInt(); 773 bool HasTemplateInfo = Record.readInt(); 774 unsigned NumTemplateArgs = Record.readInt(); 775 776 E->Base = Record.readSubExpr(); 777 E->MemberDecl = Record.readDeclAs<ValueDecl>(); 778 Record.readDeclarationNameLoc(E->MemberDNLoc, E->MemberDecl->getDeclName()); 779 E->MemberLoc = Record.readSourceLocation(); 780 E->MemberExprBits.IsArrow = Record.readInt(); 781 E->MemberExprBits.HasQualifierOrFoundDecl = HasQualifier || HasFoundDecl; 782 E->MemberExprBits.HasTemplateKWAndArgsInfo = HasTemplateInfo; 783 E->MemberExprBits.HadMultipleCandidates = Record.readInt(); 784 E->MemberExprBits.NonOdrUseReason = Record.readInt(); 785 E->MemberExprBits.OperatorLoc = Record.readSourceLocation(); 786 787 if (HasQualifier || HasFoundDecl) { 788 DeclAccessPair FoundDecl; 789 if (HasFoundDecl) { 790 auto *FoundD = Record.readDeclAs<NamedDecl>(); 791 auto AS = (AccessSpecifier)Record.readInt(); 792 FoundDecl = DeclAccessPair::make(FoundD, AS); 793 } else { 794 FoundDecl = DeclAccessPair::make(E->MemberDecl, 795 E->MemberDecl->getAccess()); 796 } 797 E->getTrailingObjects<MemberExprNameQualifier>()->FoundDecl = FoundDecl; 798 799 NestedNameSpecifierLoc QualifierLoc; 800 if (HasQualifier) 801 QualifierLoc = Record.readNestedNameSpecifierLoc(); 802 E->getTrailingObjects<MemberExprNameQualifier>()->QualifierLoc = 803 QualifierLoc; 804 } 805 806 if (HasTemplateInfo) 807 ReadTemplateKWAndArgsInfo( 808 *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(), 809 E->getTrailingObjects<TemplateArgumentLoc>(), NumTemplateArgs); 810 } 811 812 void ASTStmtReader::VisitObjCIsaExpr(ObjCIsaExpr *E) { 813 VisitExpr(E); 814 E->setBase(Record.readSubExpr()); 815 E->setIsaMemberLoc(ReadSourceLocation()); 816 E->setOpLoc(ReadSourceLocation()); 817 E->setArrow(Record.readInt()); 818 } 819 820 void ASTStmtReader:: 821 VisitObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) { 822 VisitExpr(E); 823 E->Operand = Record.readSubExpr(); 824 E->setShouldCopy(Record.readInt()); 825 } 826 827 void ASTStmtReader::VisitObjCBridgedCastExpr(ObjCBridgedCastExpr *E) { 828 VisitExplicitCastExpr(E); 829 E->LParenLoc = ReadSourceLocation(); 830 E->BridgeKeywordLoc = ReadSourceLocation(); 831 E->Kind = Record.readInt(); 832 } 833 834 void ASTStmtReader::VisitCastExpr(CastExpr *E) { 835 VisitExpr(E); 836 unsigned NumBaseSpecs = Record.readInt(); 837 assert(NumBaseSpecs == E->path_size()); 838 E->setSubExpr(Record.readSubExpr()); 839 E->setCastKind((CastKind)Record.readInt()); 840 CastExpr::path_iterator BaseI = E->path_begin(); 841 while (NumBaseSpecs--) { 842 auto *BaseSpec = new (Record.getContext()) CXXBaseSpecifier; 843 *BaseSpec = Record.readCXXBaseSpecifier(); 844 *BaseI++ = BaseSpec; 845 } 846 } 847 848 void ASTStmtReader::VisitBinaryOperator(BinaryOperator *E) { 849 VisitExpr(E); 850 E->setLHS(Record.readSubExpr()); 851 E->setRHS(Record.readSubExpr()); 852 E->setOpcode((BinaryOperator::Opcode)Record.readInt()); 853 E->setOperatorLoc(ReadSourceLocation()); 854 E->setFPFeatures(FPOptions(Record.readInt())); 855 } 856 857 void ASTStmtReader::VisitCompoundAssignOperator(CompoundAssignOperator *E) { 858 VisitBinaryOperator(E); 859 E->setComputationLHSType(Record.readType()); 860 E->setComputationResultType(Record.readType()); 861 } 862 863 void ASTStmtReader::VisitConditionalOperator(ConditionalOperator *E) { 864 VisitExpr(E); 865 E->SubExprs[ConditionalOperator::COND] = Record.readSubExpr(); 866 E->SubExprs[ConditionalOperator::LHS] = Record.readSubExpr(); 867 E->SubExprs[ConditionalOperator::RHS] = Record.readSubExpr(); 868 E->QuestionLoc = ReadSourceLocation(); 869 E->ColonLoc = ReadSourceLocation(); 870 } 871 872 void 873 ASTStmtReader::VisitBinaryConditionalOperator(BinaryConditionalOperator *E) { 874 VisitExpr(E); 875 E->OpaqueValue = cast<OpaqueValueExpr>(Record.readSubExpr()); 876 E->SubExprs[BinaryConditionalOperator::COMMON] = Record.readSubExpr(); 877 E->SubExprs[BinaryConditionalOperator::COND] = Record.readSubExpr(); 878 E->SubExprs[BinaryConditionalOperator::LHS] = Record.readSubExpr(); 879 E->SubExprs[BinaryConditionalOperator::RHS] = Record.readSubExpr(); 880 E->QuestionLoc = ReadSourceLocation(); 881 E->ColonLoc = ReadSourceLocation(); 882 } 883 884 void ASTStmtReader::VisitImplicitCastExpr(ImplicitCastExpr *E) { 885 VisitCastExpr(E); 886 E->setIsPartOfExplicitCast(Record.readInt()); 887 } 888 889 void ASTStmtReader::VisitExplicitCastExpr(ExplicitCastExpr *E) { 890 VisitCastExpr(E); 891 E->setTypeInfoAsWritten(GetTypeSourceInfo()); 892 } 893 894 void ASTStmtReader::VisitCStyleCastExpr(CStyleCastExpr *E) { 895 VisitExplicitCastExpr(E); 896 E->setLParenLoc(ReadSourceLocation()); 897 E->setRParenLoc(ReadSourceLocation()); 898 } 899 900 void ASTStmtReader::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) { 901 VisitExpr(E); 902 E->setLParenLoc(ReadSourceLocation()); 903 E->setTypeSourceInfo(GetTypeSourceInfo()); 904 E->setInitializer(Record.readSubExpr()); 905 E->setFileScope(Record.readInt()); 906 } 907 908 void ASTStmtReader::VisitExtVectorElementExpr(ExtVectorElementExpr *E) { 909 VisitExpr(E); 910 E->setBase(Record.readSubExpr()); 911 E->setAccessor(Record.getIdentifierInfo()); 912 E->setAccessorLoc(ReadSourceLocation()); 913 } 914 915 void ASTStmtReader::VisitInitListExpr(InitListExpr *E) { 916 VisitExpr(E); 917 if (auto *SyntForm = cast_or_null<InitListExpr>(Record.readSubStmt())) 918 E->setSyntacticForm(SyntForm); 919 E->setLBraceLoc(ReadSourceLocation()); 920 E->setRBraceLoc(ReadSourceLocation()); 921 bool isArrayFiller = Record.readInt(); 922 Expr *filler = nullptr; 923 if (isArrayFiller) { 924 filler = Record.readSubExpr(); 925 E->ArrayFillerOrUnionFieldInit = filler; 926 } else 927 E->ArrayFillerOrUnionFieldInit = ReadDeclAs<FieldDecl>(); 928 E->sawArrayRangeDesignator(Record.readInt()); 929 unsigned NumInits = Record.readInt(); 930 E->reserveInits(Record.getContext(), NumInits); 931 if (isArrayFiller) { 932 for (unsigned I = 0; I != NumInits; ++I) { 933 Expr *init = Record.readSubExpr(); 934 E->updateInit(Record.getContext(), I, init ? init : filler); 935 } 936 } else { 937 for (unsigned I = 0; I != NumInits; ++I) 938 E->updateInit(Record.getContext(), I, Record.readSubExpr()); 939 } 940 } 941 942 void ASTStmtReader::VisitDesignatedInitExpr(DesignatedInitExpr *E) { 943 using Designator = DesignatedInitExpr::Designator; 944 945 VisitExpr(E); 946 unsigned NumSubExprs = Record.readInt(); 947 assert(NumSubExprs == E->getNumSubExprs() && "Wrong number of subexprs"); 948 for (unsigned I = 0; I != NumSubExprs; ++I) 949 E->setSubExpr(I, Record.readSubExpr()); 950 E->setEqualOrColonLoc(ReadSourceLocation()); 951 E->setGNUSyntax(Record.readInt()); 952 953 SmallVector<Designator, 4> Designators; 954 while (Record.getIdx() < Record.size()) { 955 switch ((DesignatorTypes)Record.readInt()) { 956 case DESIG_FIELD_DECL: { 957 auto *Field = ReadDeclAs<FieldDecl>(); 958 SourceLocation DotLoc = ReadSourceLocation(); 959 SourceLocation FieldLoc = ReadSourceLocation(); 960 Designators.push_back(Designator(Field->getIdentifier(), DotLoc, 961 FieldLoc)); 962 Designators.back().setField(Field); 963 break; 964 } 965 966 case DESIG_FIELD_NAME: { 967 const IdentifierInfo *Name = Record.getIdentifierInfo(); 968 SourceLocation DotLoc = ReadSourceLocation(); 969 SourceLocation FieldLoc = ReadSourceLocation(); 970 Designators.push_back(Designator(Name, DotLoc, FieldLoc)); 971 break; 972 } 973 974 case DESIG_ARRAY: { 975 unsigned Index = Record.readInt(); 976 SourceLocation LBracketLoc = ReadSourceLocation(); 977 SourceLocation RBracketLoc = ReadSourceLocation(); 978 Designators.push_back(Designator(Index, LBracketLoc, RBracketLoc)); 979 break; 980 } 981 982 case DESIG_ARRAY_RANGE: { 983 unsigned Index = Record.readInt(); 984 SourceLocation LBracketLoc = ReadSourceLocation(); 985 SourceLocation EllipsisLoc = ReadSourceLocation(); 986 SourceLocation RBracketLoc = ReadSourceLocation(); 987 Designators.push_back(Designator(Index, LBracketLoc, EllipsisLoc, 988 RBracketLoc)); 989 break; 990 } 991 } 992 } 993 E->setDesignators(Record.getContext(), 994 Designators.data(), Designators.size()); 995 } 996 997 void ASTStmtReader::VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E) { 998 VisitExpr(E); 999 E->setBase(Record.readSubExpr()); 1000 E->setUpdater(Record.readSubExpr()); 1001 } 1002 1003 void ASTStmtReader::VisitNoInitExpr(NoInitExpr *E) { 1004 VisitExpr(E); 1005 } 1006 1007 void ASTStmtReader::VisitArrayInitLoopExpr(ArrayInitLoopExpr *E) { 1008 VisitExpr(E); 1009 E->SubExprs[0] = Record.readSubExpr(); 1010 E->SubExprs[1] = Record.readSubExpr(); 1011 } 1012 1013 void ASTStmtReader::VisitArrayInitIndexExpr(ArrayInitIndexExpr *E) { 1014 VisitExpr(E); 1015 } 1016 1017 void ASTStmtReader::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) { 1018 VisitExpr(E); 1019 } 1020 1021 void ASTStmtReader::VisitVAArgExpr(VAArgExpr *E) { 1022 VisitExpr(E); 1023 E->setSubExpr(Record.readSubExpr()); 1024 E->setWrittenTypeInfo(GetTypeSourceInfo()); 1025 E->setBuiltinLoc(ReadSourceLocation()); 1026 E->setRParenLoc(ReadSourceLocation()); 1027 E->setIsMicrosoftABI(Record.readInt()); 1028 } 1029 1030 void ASTStmtReader::VisitSourceLocExpr(SourceLocExpr *E) { 1031 VisitExpr(E); 1032 E->ParentContext = ReadDeclAs<DeclContext>(); 1033 E->BuiltinLoc = ReadSourceLocation(); 1034 E->RParenLoc = ReadSourceLocation(); 1035 E->SourceLocExprBits.Kind = 1036 static_cast<SourceLocExpr::IdentKind>(Record.readInt()); 1037 } 1038 1039 void ASTStmtReader::VisitAddrLabelExpr(AddrLabelExpr *E) { 1040 VisitExpr(E); 1041 E->setAmpAmpLoc(ReadSourceLocation()); 1042 E->setLabelLoc(ReadSourceLocation()); 1043 E->setLabel(ReadDeclAs<LabelDecl>()); 1044 } 1045 1046 void ASTStmtReader::VisitStmtExpr(StmtExpr *E) { 1047 VisitExpr(E); 1048 E->setLParenLoc(ReadSourceLocation()); 1049 E->setRParenLoc(ReadSourceLocation()); 1050 E->setSubStmt(cast_or_null<CompoundStmt>(Record.readSubStmt())); 1051 } 1052 1053 void ASTStmtReader::VisitChooseExpr(ChooseExpr *E) { 1054 VisitExpr(E); 1055 E->setCond(Record.readSubExpr()); 1056 E->setLHS(Record.readSubExpr()); 1057 E->setRHS(Record.readSubExpr()); 1058 E->setBuiltinLoc(ReadSourceLocation()); 1059 E->setRParenLoc(ReadSourceLocation()); 1060 E->setIsConditionTrue(Record.readInt()); 1061 } 1062 1063 void ASTStmtReader::VisitGNUNullExpr(GNUNullExpr *E) { 1064 VisitExpr(E); 1065 E->setTokenLocation(ReadSourceLocation()); 1066 } 1067 1068 void ASTStmtReader::VisitShuffleVectorExpr(ShuffleVectorExpr *E) { 1069 VisitExpr(E); 1070 SmallVector<Expr *, 16> Exprs; 1071 unsigned NumExprs = Record.readInt(); 1072 while (NumExprs--) 1073 Exprs.push_back(Record.readSubExpr()); 1074 E->setExprs(Record.getContext(), Exprs); 1075 E->setBuiltinLoc(ReadSourceLocation()); 1076 E->setRParenLoc(ReadSourceLocation()); 1077 } 1078 1079 void ASTStmtReader::VisitConvertVectorExpr(ConvertVectorExpr *E) { 1080 VisitExpr(E); 1081 E->BuiltinLoc = ReadSourceLocation(); 1082 E->RParenLoc = ReadSourceLocation(); 1083 E->TInfo = GetTypeSourceInfo(); 1084 E->SrcExpr = Record.readSubExpr(); 1085 } 1086 1087 void ASTStmtReader::VisitBlockExpr(BlockExpr *E) { 1088 VisitExpr(E); 1089 E->setBlockDecl(ReadDeclAs<BlockDecl>()); 1090 } 1091 1092 void ASTStmtReader::VisitGenericSelectionExpr(GenericSelectionExpr *E) { 1093 VisitExpr(E); 1094 1095 unsigned NumAssocs = Record.readInt(); 1096 assert(NumAssocs == E->getNumAssocs() && "Wrong NumAssocs!"); 1097 E->ResultIndex = Record.readInt(); 1098 E->GenericSelectionExprBits.GenericLoc = ReadSourceLocation(); 1099 E->DefaultLoc = ReadSourceLocation(); 1100 E->RParenLoc = ReadSourceLocation(); 1101 1102 Stmt **Stmts = E->getTrailingObjects<Stmt *>(); 1103 // Add 1 to account for the controlling expression which is the first 1104 // expression in the trailing array of Stmt *. This is not needed for 1105 // the trailing array of TypeSourceInfo *. 1106 for (unsigned I = 0, N = NumAssocs + 1; I < N; ++I) 1107 Stmts[I] = Record.readSubExpr(); 1108 1109 TypeSourceInfo **TSIs = E->getTrailingObjects<TypeSourceInfo *>(); 1110 for (unsigned I = 0, N = NumAssocs; I < N; ++I) 1111 TSIs[I] = GetTypeSourceInfo(); 1112 } 1113 1114 void ASTStmtReader::VisitPseudoObjectExpr(PseudoObjectExpr *E) { 1115 VisitExpr(E); 1116 unsigned numSemanticExprs = Record.readInt(); 1117 assert(numSemanticExprs + 1 == E->PseudoObjectExprBits.NumSubExprs); 1118 E->PseudoObjectExprBits.ResultIndex = Record.readInt(); 1119 1120 // Read the syntactic expression. 1121 E->getSubExprsBuffer()[0] = Record.readSubExpr(); 1122 1123 // Read all the semantic expressions. 1124 for (unsigned i = 0; i != numSemanticExprs; ++i) { 1125 Expr *subExpr = Record.readSubExpr(); 1126 E->getSubExprsBuffer()[i+1] = subExpr; 1127 } 1128 } 1129 1130 void ASTStmtReader::VisitAtomicExpr(AtomicExpr *E) { 1131 VisitExpr(E); 1132 E->Op = AtomicExpr::AtomicOp(Record.readInt()); 1133 E->NumSubExprs = AtomicExpr::getNumSubExprs(E->Op); 1134 for (unsigned I = 0; I != E->NumSubExprs; ++I) 1135 E->SubExprs[I] = Record.readSubExpr(); 1136 E->BuiltinLoc = ReadSourceLocation(); 1137 E->RParenLoc = ReadSourceLocation(); 1138 } 1139 1140 //===----------------------------------------------------------------------===// 1141 // Objective-C Expressions and Statements 1142 1143 void ASTStmtReader::VisitObjCStringLiteral(ObjCStringLiteral *E) { 1144 VisitExpr(E); 1145 E->setString(cast<StringLiteral>(Record.readSubStmt())); 1146 E->setAtLoc(ReadSourceLocation()); 1147 } 1148 1149 void ASTStmtReader::VisitObjCBoxedExpr(ObjCBoxedExpr *E) { 1150 VisitExpr(E); 1151 // could be one of several IntegerLiteral, FloatLiteral, etc. 1152 E->SubExpr = Record.readSubStmt(); 1153 E->BoxingMethod = ReadDeclAs<ObjCMethodDecl>(); 1154 E->Range = ReadSourceRange(); 1155 } 1156 1157 void ASTStmtReader::VisitObjCArrayLiteral(ObjCArrayLiteral *E) { 1158 VisitExpr(E); 1159 unsigned NumElements = Record.readInt(); 1160 assert(NumElements == E->getNumElements() && "Wrong number of elements"); 1161 Expr **Elements = E->getElements(); 1162 for (unsigned I = 0, N = NumElements; I != N; ++I) 1163 Elements[I] = Record.readSubExpr(); 1164 E->ArrayWithObjectsMethod = ReadDeclAs<ObjCMethodDecl>(); 1165 E->Range = ReadSourceRange(); 1166 } 1167 1168 void ASTStmtReader::VisitObjCDictionaryLiteral(ObjCDictionaryLiteral *E) { 1169 VisitExpr(E); 1170 unsigned NumElements = Record.readInt(); 1171 assert(NumElements == E->getNumElements() && "Wrong number of elements"); 1172 bool HasPackExpansions = Record.readInt(); 1173 assert(HasPackExpansions == E->HasPackExpansions &&"Pack expansion mismatch"); 1174 auto *KeyValues = 1175 E->getTrailingObjects<ObjCDictionaryLiteral::KeyValuePair>(); 1176 auto *Expansions = 1177 E->getTrailingObjects<ObjCDictionaryLiteral::ExpansionData>(); 1178 for (unsigned I = 0; I != NumElements; ++I) { 1179 KeyValues[I].Key = Record.readSubExpr(); 1180 KeyValues[I].Value = Record.readSubExpr(); 1181 if (HasPackExpansions) { 1182 Expansions[I].EllipsisLoc = ReadSourceLocation(); 1183 Expansions[I].NumExpansionsPlusOne = Record.readInt(); 1184 } 1185 } 1186 E->DictWithObjectsMethod = ReadDeclAs<ObjCMethodDecl>(); 1187 E->Range = ReadSourceRange(); 1188 } 1189 1190 void ASTStmtReader::VisitObjCEncodeExpr(ObjCEncodeExpr *E) { 1191 VisitExpr(E); 1192 E->setEncodedTypeSourceInfo(GetTypeSourceInfo()); 1193 E->setAtLoc(ReadSourceLocation()); 1194 E->setRParenLoc(ReadSourceLocation()); 1195 } 1196 1197 void ASTStmtReader::VisitObjCSelectorExpr(ObjCSelectorExpr *E) { 1198 VisitExpr(E); 1199 E->setSelector(Record.readSelector()); 1200 E->setAtLoc(ReadSourceLocation()); 1201 E->setRParenLoc(ReadSourceLocation()); 1202 } 1203 1204 void ASTStmtReader::VisitObjCProtocolExpr(ObjCProtocolExpr *E) { 1205 VisitExpr(E); 1206 E->setProtocol(ReadDeclAs<ObjCProtocolDecl>()); 1207 E->setAtLoc(ReadSourceLocation()); 1208 E->ProtoLoc = ReadSourceLocation(); 1209 E->setRParenLoc(ReadSourceLocation()); 1210 } 1211 1212 void ASTStmtReader::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) { 1213 VisitExpr(E); 1214 E->setDecl(ReadDeclAs<ObjCIvarDecl>()); 1215 E->setLocation(ReadSourceLocation()); 1216 E->setOpLoc(ReadSourceLocation()); 1217 E->setBase(Record.readSubExpr()); 1218 E->setIsArrow(Record.readInt()); 1219 E->setIsFreeIvar(Record.readInt()); 1220 } 1221 1222 void ASTStmtReader::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) { 1223 VisitExpr(E); 1224 unsigned MethodRefFlags = Record.readInt(); 1225 bool Implicit = Record.readInt() != 0; 1226 if (Implicit) { 1227 auto *Getter = ReadDeclAs<ObjCMethodDecl>(); 1228 auto *Setter = ReadDeclAs<ObjCMethodDecl>(); 1229 E->setImplicitProperty(Getter, Setter, MethodRefFlags); 1230 } else { 1231 E->setExplicitProperty(ReadDeclAs<ObjCPropertyDecl>(), MethodRefFlags); 1232 } 1233 E->setLocation(ReadSourceLocation()); 1234 E->setReceiverLocation(ReadSourceLocation()); 1235 switch (Record.readInt()) { 1236 case 0: 1237 E->setBase(Record.readSubExpr()); 1238 break; 1239 case 1: 1240 E->setSuperReceiver(Record.readType()); 1241 break; 1242 case 2: 1243 E->setClassReceiver(ReadDeclAs<ObjCInterfaceDecl>()); 1244 break; 1245 } 1246 } 1247 1248 void ASTStmtReader::VisitObjCSubscriptRefExpr(ObjCSubscriptRefExpr *E) { 1249 VisitExpr(E); 1250 E->setRBracket(ReadSourceLocation()); 1251 E->setBaseExpr(Record.readSubExpr()); 1252 E->setKeyExpr(Record.readSubExpr()); 1253 E->GetAtIndexMethodDecl = ReadDeclAs<ObjCMethodDecl>(); 1254 E->SetAtIndexMethodDecl = ReadDeclAs<ObjCMethodDecl>(); 1255 } 1256 1257 void ASTStmtReader::VisitObjCMessageExpr(ObjCMessageExpr *E) { 1258 VisitExpr(E); 1259 assert(Record.peekInt() == E->getNumArgs()); 1260 Record.skipInts(1); 1261 unsigned NumStoredSelLocs = Record.readInt(); 1262 E->SelLocsKind = Record.readInt(); 1263 E->setDelegateInitCall(Record.readInt()); 1264 E->IsImplicit = Record.readInt(); 1265 auto Kind = static_cast<ObjCMessageExpr::ReceiverKind>(Record.readInt()); 1266 switch (Kind) { 1267 case ObjCMessageExpr::Instance: 1268 E->setInstanceReceiver(Record.readSubExpr()); 1269 break; 1270 1271 case ObjCMessageExpr::Class: 1272 E->setClassReceiver(GetTypeSourceInfo()); 1273 break; 1274 1275 case ObjCMessageExpr::SuperClass: 1276 case ObjCMessageExpr::SuperInstance: { 1277 QualType T = Record.readType(); 1278 SourceLocation SuperLoc = ReadSourceLocation(); 1279 E->setSuper(SuperLoc, T, Kind == ObjCMessageExpr::SuperInstance); 1280 break; 1281 } 1282 } 1283 1284 assert(Kind == E->getReceiverKind()); 1285 1286 if (Record.readInt()) 1287 E->setMethodDecl(ReadDeclAs<ObjCMethodDecl>()); 1288 else 1289 E->setSelector(Record.readSelector()); 1290 1291 E->LBracLoc = ReadSourceLocation(); 1292 E->RBracLoc = ReadSourceLocation(); 1293 1294 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) 1295 E->setArg(I, Record.readSubExpr()); 1296 1297 SourceLocation *Locs = E->getStoredSelLocs(); 1298 for (unsigned I = 0; I != NumStoredSelLocs; ++I) 1299 Locs[I] = ReadSourceLocation(); 1300 } 1301 1302 void ASTStmtReader::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) { 1303 VisitStmt(S); 1304 S->setElement(Record.readSubStmt()); 1305 S->setCollection(Record.readSubExpr()); 1306 S->setBody(Record.readSubStmt()); 1307 S->setForLoc(ReadSourceLocation()); 1308 S->setRParenLoc(ReadSourceLocation()); 1309 } 1310 1311 void ASTStmtReader::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) { 1312 VisitStmt(S); 1313 S->setCatchBody(Record.readSubStmt()); 1314 S->setCatchParamDecl(ReadDeclAs<VarDecl>()); 1315 S->setAtCatchLoc(ReadSourceLocation()); 1316 S->setRParenLoc(ReadSourceLocation()); 1317 } 1318 1319 void ASTStmtReader::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) { 1320 VisitStmt(S); 1321 S->setFinallyBody(Record.readSubStmt()); 1322 S->setAtFinallyLoc(ReadSourceLocation()); 1323 } 1324 1325 void ASTStmtReader::VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S) { 1326 VisitStmt(S); // FIXME: no test coverage. 1327 S->setSubStmt(Record.readSubStmt()); 1328 S->setAtLoc(ReadSourceLocation()); 1329 } 1330 1331 void ASTStmtReader::VisitObjCAtTryStmt(ObjCAtTryStmt *S) { 1332 VisitStmt(S); 1333 assert(Record.peekInt() == S->getNumCatchStmts()); 1334 Record.skipInts(1); 1335 bool HasFinally = Record.readInt(); 1336 S->setTryBody(Record.readSubStmt()); 1337 for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I) 1338 S->setCatchStmt(I, cast_or_null<ObjCAtCatchStmt>(Record.readSubStmt())); 1339 1340 if (HasFinally) 1341 S->setFinallyStmt(Record.readSubStmt()); 1342 S->setAtTryLoc(ReadSourceLocation()); 1343 } 1344 1345 void ASTStmtReader::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) { 1346 VisitStmt(S); // FIXME: no test coverage. 1347 S->setSynchExpr(Record.readSubStmt()); 1348 S->setSynchBody(Record.readSubStmt()); 1349 S->setAtSynchronizedLoc(ReadSourceLocation()); 1350 } 1351 1352 void ASTStmtReader::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) { 1353 VisitStmt(S); // FIXME: no test coverage. 1354 S->setThrowExpr(Record.readSubStmt()); 1355 S->setThrowLoc(ReadSourceLocation()); 1356 } 1357 1358 void ASTStmtReader::VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) { 1359 VisitExpr(E); 1360 E->setValue(Record.readInt()); 1361 E->setLocation(ReadSourceLocation()); 1362 } 1363 1364 void ASTStmtReader::VisitObjCAvailabilityCheckExpr(ObjCAvailabilityCheckExpr *E) { 1365 VisitExpr(E); 1366 SourceRange R = Record.readSourceRange(); 1367 E->AtLoc = R.getBegin(); 1368 E->RParen = R.getEnd(); 1369 E->VersionToCheck = Record.readVersionTuple(); 1370 } 1371 1372 //===----------------------------------------------------------------------===// 1373 // C++ Expressions and Statements 1374 //===----------------------------------------------------------------------===// 1375 1376 void ASTStmtReader::VisitCXXCatchStmt(CXXCatchStmt *S) { 1377 VisitStmt(S); 1378 S->CatchLoc = ReadSourceLocation(); 1379 S->ExceptionDecl = ReadDeclAs<VarDecl>(); 1380 S->HandlerBlock = Record.readSubStmt(); 1381 } 1382 1383 void ASTStmtReader::VisitCXXTryStmt(CXXTryStmt *S) { 1384 VisitStmt(S); 1385 assert(Record.peekInt() == S->getNumHandlers() && "NumStmtFields is wrong ?"); 1386 Record.skipInts(1); 1387 S->TryLoc = ReadSourceLocation(); 1388 S->getStmts()[0] = Record.readSubStmt(); 1389 for (unsigned i = 0, e = S->getNumHandlers(); i != e; ++i) 1390 S->getStmts()[i + 1] = Record.readSubStmt(); 1391 } 1392 1393 void ASTStmtReader::VisitCXXForRangeStmt(CXXForRangeStmt *S) { 1394 VisitStmt(S); 1395 S->ForLoc = ReadSourceLocation(); 1396 S->CoawaitLoc = ReadSourceLocation(); 1397 S->ColonLoc = ReadSourceLocation(); 1398 S->RParenLoc = ReadSourceLocation(); 1399 S->setInit(Record.readSubStmt()); 1400 S->setRangeStmt(Record.readSubStmt()); 1401 S->setBeginStmt(Record.readSubStmt()); 1402 S->setEndStmt(Record.readSubStmt()); 1403 S->setCond(Record.readSubExpr()); 1404 S->setInc(Record.readSubExpr()); 1405 S->setLoopVarStmt(Record.readSubStmt()); 1406 S->setBody(Record.readSubStmt()); 1407 } 1408 1409 void ASTStmtReader::VisitMSDependentExistsStmt(MSDependentExistsStmt *S) { 1410 VisitStmt(S); 1411 S->KeywordLoc = ReadSourceLocation(); 1412 S->IsIfExists = Record.readInt(); 1413 S->QualifierLoc = Record.readNestedNameSpecifierLoc(); 1414 ReadDeclarationNameInfo(S->NameInfo); 1415 S->SubStmt = Record.readSubStmt(); 1416 } 1417 1418 void ASTStmtReader::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) { 1419 VisitCallExpr(E); 1420 E->CXXOperatorCallExprBits.OperatorKind = Record.readInt(); 1421 E->CXXOperatorCallExprBits.FPFeatures = Record.readInt(); 1422 E->Range = Record.readSourceRange(); 1423 } 1424 1425 void ASTStmtReader::VisitCXXConstructExpr(CXXConstructExpr *E) { 1426 VisitExpr(E); 1427 1428 unsigned NumArgs = Record.readInt(); 1429 assert((NumArgs == E->getNumArgs()) && "Wrong NumArgs!"); 1430 1431 E->CXXConstructExprBits.Elidable = Record.readInt(); 1432 E->CXXConstructExprBits.HadMultipleCandidates = Record.readInt(); 1433 E->CXXConstructExprBits.ListInitialization = Record.readInt(); 1434 E->CXXConstructExprBits.StdInitListInitialization = Record.readInt(); 1435 E->CXXConstructExprBits.ZeroInitialization = Record.readInt(); 1436 E->CXXConstructExprBits.ConstructionKind = Record.readInt(); 1437 E->CXXConstructExprBits.Loc = ReadSourceLocation(); 1438 E->Constructor = ReadDeclAs<CXXConstructorDecl>(); 1439 E->ParenOrBraceRange = ReadSourceRange(); 1440 1441 for (unsigned I = 0; I != NumArgs; ++I) 1442 E->setArg(I, Record.readSubExpr()); 1443 } 1444 1445 void ASTStmtReader::VisitCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr *E) { 1446 VisitExpr(E); 1447 E->Constructor = ReadDeclAs<CXXConstructorDecl>(); 1448 E->Loc = ReadSourceLocation(); 1449 E->ConstructsVirtualBase = Record.readInt(); 1450 E->InheritedFromVirtualBase = Record.readInt(); 1451 } 1452 1453 void ASTStmtReader::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) { 1454 VisitCXXConstructExpr(E); 1455 E->TSI = GetTypeSourceInfo(); 1456 } 1457 1458 void ASTStmtReader::VisitLambdaExpr(LambdaExpr *E) { 1459 VisitExpr(E); 1460 unsigned NumCaptures = Record.readInt(); 1461 assert(NumCaptures == E->NumCaptures);(void)NumCaptures; 1462 E->IntroducerRange = ReadSourceRange(); 1463 E->CaptureDefault = static_cast<LambdaCaptureDefault>(Record.readInt()); 1464 E->CaptureDefaultLoc = ReadSourceLocation(); 1465 E->ExplicitParams = Record.readInt(); 1466 E->ExplicitResultType = Record.readInt(); 1467 E->ClosingBrace = ReadSourceLocation(); 1468 1469 // Read capture initializers. 1470 for (LambdaExpr::capture_init_iterator C = E->capture_init_begin(), 1471 CEnd = E->capture_init_end(); 1472 C != CEnd; ++C) 1473 *C = Record.readSubExpr(); 1474 } 1475 1476 void 1477 ASTStmtReader::VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) { 1478 VisitExpr(E); 1479 E->SubExpr = Record.readSubExpr(); 1480 } 1481 1482 void ASTStmtReader::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) { 1483 VisitExplicitCastExpr(E); 1484 SourceRange R = ReadSourceRange(); 1485 E->Loc = R.getBegin(); 1486 E->RParenLoc = R.getEnd(); 1487 R = ReadSourceRange(); 1488 E->AngleBrackets = R; 1489 } 1490 1491 void ASTStmtReader::VisitCXXStaticCastExpr(CXXStaticCastExpr *E) { 1492 return VisitCXXNamedCastExpr(E); 1493 } 1494 1495 void ASTStmtReader::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E) { 1496 return VisitCXXNamedCastExpr(E); 1497 } 1498 1499 void ASTStmtReader::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E) { 1500 return VisitCXXNamedCastExpr(E); 1501 } 1502 1503 void ASTStmtReader::VisitCXXConstCastExpr(CXXConstCastExpr *E) { 1504 return VisitCXXNamedCastExpr(E); 1505 } 1506 1507 void ASTStmtReader::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) { 1508 VisitExplicitCastExpr(E); 1509 E->setLParenLoc(ReadSourceLocation()); 1510 E->setRParenLoc(ReadSourceLocation()); 1511 } 1512 1513 void ASTStmtReader::VisitBuiltinBitCastExpr(BuiltinBitCastExpr *E) { 1514 VisitExplicitCastExpr(E); 1515 E->KWLoc = ReadSourceLocation(); 1516 E->RParenLoc = ReadSourceLocation(); 1517 } 1518 1519 void ASTStmtReader::VisitUserDefinedLiteral(UserDefinedLiteral *E) { 1520 VisitCallExpr(E); 1521 E->UDSuffixLoc = ReadSourceLocation(); 1522 } 1523 1524 void ASTStmtReader::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) { 1525 VisitExpr(E); 1526 E->setValue(Record.readInt()); 1527 E->setLocation(ReadSourceLocation()); 1528 } 1529 1530 void ASTStmtReader::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) { 1531 VisitExpr(E); 1532 E->setLocation(ReadSourceLocation()); 1533 } 1534 1535 void ASTStmtReader::VisitCXXTypeidExpr(CXXTypeidExpr *E) { 1536 VisitExpr(E); 1537 E->setSourceRange(ReadSourceRange()); 1538 if (E->isTypeOperand()) { // typeid(int) 1539 E->setTypeOperandSourceInfo( 1540 GetTypeSourceInfo()); 1541 return; 1542 } 1543 1544 // typeid(42+2) 1545 E->setExprOperand(Record.readSubExpr()); 1546 } 1547 1548 void ASTStmtReader::VisitCXXThisExpr(CXXThisExpr *E) { 1549 VisitExpr(E); 1550 E->setLocation(ReadSourceLocation()); 1551 E->setImplicit(Record.readInt()); 1552 } 1553 1554 void ASTStmtReader::VisitCXXThrowExpr(CXXThrowExpr *E) { 1555 VisitExpr(E); 1556 E->CXXThrowExprBits.ThrowLoc = ReadSourceLocation(); 1557 E->Operand = Record.readSubExpr(); 1558 E->CXXThrowExprBits.IsThrownVariableInScope = Record.readInt(); 1559 } 1560 1561 void ASTStmtReader::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) { 1562 VisitExpr(E); 1563 E->Param = ReadDeclAs<ParmVarDecl>(); 1564 E->UsedContext = ReadDeclAs<DeclContext>(); 1565 E->CXXDefaultArgExprBits.Loc = ReadSourceLocation(); 1566 } 1567 1568 void ASTStmtReader::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) { 1569 VisitExpr(E); 1570 E->Field = ReadDeclAs<FieldDecl>(); 1571 E->UsedContext = ReadDeclAs<DeclContext>(); 1572 E->CXXDefaultInitExprBits.Loc = ReadSourceLocation(); 1573 } 1574 1575 void ASTStmtReader::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) { 1576 VisitExpr(E); 1577 E->setTemporary(Record.readCXXTemporary()); 1578 E->setSubExpr(Record.readSubExpr()); 1579 } 1580 1581 void ASTStmtReader::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) { 1582 VisitExpr(E); 1583 E->TypeInfo = GetTypeSourceInfo(); 1584 E->CXXScalarValueInitExprBits.RParenLoc = ReadSourceLocation(); 1585 } 1586 1587 void ASTStmtReader::VisitCXXNewExpr(CXXNewExpr *E) { 1588 VisitExpr(E); 1589 1590 bool IsArray = Record.readInt(); 1591 bool HasInit = Record.readInt(); 1592 unsigned NumPlacementArgs = Record.readInt(); 1593 bool IsParenTypeId = Record.readInt(); 1594 1595 E->CXXNewExprBits.IsGlobalNew = Record.readInt(); 1596 E->CXXNewExprBits.ShouldPassAlignment = Record.readInt(); 1597 E->CXXNewExprBits.UsualArrayDeleteWantsSize = Record.readInt(); 1598 E->CXXNewExprBits.StoredInitializationStyle = Record.readInt(); 1599 1600 assert((IsArray == E->isArray()) && "Wrong IsArray!"); 1601 assert((HasInit == E->hasInitializer()) && "Wrong HasInit!"); 1602 assert((NumPlacementArgs == E->getNumPlacementArgs()) && 1603 "Wrong NumPlacementArgs!"); 1604 assert((IsParenTypeId == E->isParenTypeId()) && "Wrong IsParenTypeId!"); 1605 (void)IsArray; 1606 (void)HasInit; 1607 (void)NumPlacementArgs; 1608 1609 E->setOperatorNew(ReadDeclAs<FunctionDecl>()); 1610 E->setOperatorDelete(ReadDeclAs<FunctionDecl>()); 1611 E->AllocatedTypeInfo = GetTypeSourceInfo(); 1612 if (IsParenTypeId) 1613 E->getTrailingObjects<SourceRange>()[0] = ReadSourceRange(); 1614 E->Range = ReadSourceRange(); 1615 E->DirectInitRange = ReadSourceRange(); 1616 1617 // Install all the subexpressions. 1618 for (CXXNewExpr::raw_arg_iterator I = E->raw_arg_begin(), 1619 N = E->raw_arg_end(); 1620 I != N; ++I) 1621 *I = Record.readSubStmt(); 1622 } 1623 1624 void ASTStmtReader::VisitCXXDeleteExpr(CXXDeleteExpr *E) { 1625 VisitExpr(E); 1626 E->CXXDeleteExprBits.GlobalDelete = Record.readInt(); 1627 E->CXXDeleteExprBits.ArrayForm = Record.readInt(); 1628 E->CXXDeleteExprBits.ArrayFormAsWritten = Record.readInt(); 1629 E->CXXDeleteExprBits.UsualArrayDeleteWantsSize = Record.readInt(); 1630 E->OperatorDelete = ReadDeclAs<FunctionDecl>(); 1631 E->Argument = Record.readSubExpr(); 1632 E->CXXDeleteExprBits.Loc = ReadSourceLocation(); 1633 } 1634 1635 void ASTStmtReader::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) { 1636 VisitExpr(E); 1637 1638 E->Base = Record.readSubExpr(); 1639 E->IsArrow = Record.readInt(); 1640 E->OperatorLoc = ReadSourceLocation(); 1641 E->QualifierLoc = Record.readNestedNameSpecifierLoc(); 1642 E->ScopeType = GetTypeSourceInfo(); 1643 E->ColonColonLoc = ReadSourceLocation(); 1644 E->TildeLoc = ReadSourceLocation(); 1645 1646 IdentifierInfo *II = Record.getIdentifierInfo(); 1647 if (II) 1648 E->setDestroyedType(II, ReadSourceLocation()); 1649 else 1650 E->setDestroyedType(GetTypeSourceInfo()); 1651 } 1652 1653 void ASTStmtReader::VisitExprWithCleanups(ExprWithCleanups *E) { 1654 VisitExpr(E); 1655 1656 unsigned NumObjects = Record.readInt(); 1657 assert(NumObjects == E->getNumObjects()); 1658 for (unsigned i = 0; i != NumObjects; ++i) 1659 E->getTrailingObjects<BlockDecl *>()[i] = 1660 ReadDeclAs<BlockDecl>(); 1661 1662 E->ExprWithCleanupsBits.CleanupsHaveSideEffects = Record.readInt(); 1663 E->SubExpr = Record.readSubExpr(); 1664 } 1665 1666 void ASTStmtReader::VisitCXXDependentScopeMemberExpr( 1667 CXXDependentScopeMemberExpr *E) { 1668 VisitExpr(E); 1669 1670 bool HasTemplateKWAndArgsInfo = Record.readInt(); 1671 unsigned NumTemplateArgs = Record.readInt(); 1672 bool HasFirstQualifierFoundInScope = Record.readInt(); 1673 1674 assert((HasTemplateKWAndArgsInfo == E->hasTemplateKWAndArgsInfo()) && 1675 "Wrong HasTemplateKWAndArgsInfo!"); 1676 assert( 1677 (HasFirstQualifierFoundInScope == E->hasFirstQualifierFoundInScope()) && 1678 "Wrong HasFirstQualifierFoundInScope!"); 1679 1680 if (HasTemplateKWAndArgsInfo) 1681 ReadTemplateKWAndArgsInfo( 1682 *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(), 1683 E->getTrailingObjects<TemplateArgumentLoc>(), NumTemplateArgs); 1684 1685 assert((NumTemplateArgs == E->getNumTemplateArgs()) && 1686 "Wrong NumTemplateArgs!"); 1687 1688 E->CXXDependentScopeMemberExprBits.IsArrow = Record.readInt(); 1689 E->CXXDependentScopeMemberExprBits.OperatorLoc = ReadSourceLocation(); 1690 E->BaseType = Record.readType(); 1691 E->QualifierLoc = Record.readNestedNameSpecifierLoc(); 1692 E->Base = Record.readSubExpr(); 1693 1694 if (HasFirstQualifierFoundInScope) 1695 *E->getTrailingObjects<NamedDecl *>() = ReadDeclAs<NamedDecl>(); 1696 1697 ReadDeclarationNameInfo(E->MemberNameInfo); 1698 } 1699 1700 void 1701 ASTStmtReader::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) { 1702 VisitExpr(E); 1703 1704 if (Record.readInt()) // HasTemplateKWAndArgsInfo 1705 ReadTemplateKWAndArgsInfo( 1706 *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(), 1707 E->getTrailingObjects<TemplateArgumentLoc>(), 1708 /*NumTemplateArgs=*/Record.readInt()); 1709 1710 E->QualifierLoc = Record.readNestedNameSpecifierLoc(); 1711 ReadDeclarationNameInfo(E->NameInfo); 1712 } 1713 1714 void 1715 ASTStmtReader::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) { 1716 VisitExpr(E); 1717 assert(Record.peekInt() == E->arg_size() && 1718 "Read wrong record during creation ?"); 1719 Record.skipInts(1); 1720 for (unsigned I = 0, N = E->arg_size(); I != N; ++I) 1721 E->setArg(I, Record.readSubExpr()); 1722 E->TSI = GetTypeSourceInfo(); 1723 E->setLParenLoc(ReadSourceLocation()); 1724 E->setRParenLoc(ReadSourceLocation()); 1725 } 1726 1727 void ASTStmtReader::VisitOverloadExpr(OverloadExpr *E) { 1728 VisitExpr(E); 1729 1730 unsigned NumResults = Record.readInt(); 1731 bool HasTemplateKWAndArgsInfo = Record.readInt(); 1732 assert((E->getNumDecls() == NumResults) && "Wrong NumResults!"); 1733 assert((E->hasTemplateKWAndArgsInfo() == HasTemplateKWAndArgsInfo) && 1734 "Wrong HasTemplateKWAndArgsInfo!"); 1735 1736 if (HasTemplateKWAndArgsInfo) { 1737 unsigned NumTemplateArgs = Record.readInt(); 1738 ReadTemplateKWAndArgsInfo(*E->getTrailingASTTemplateKWAndArgsInfo(), 1739 E->getTrailingTemplateArgumentLoc(), 1740 NumTemplateArgs); 1741 assert((E->getNumTemplateArgs() == NumTemplateArgs) && 1742 "Wrong NumTemplateArgs!"); 1743 } 1744 1745 UnresolvedSet<8> Decls; 1746 for (unsigned I = 0; I != NumResults; ++I) { 1747 auto *D = ReadDeclAs<NamedDecl>(); 1748 auto AS = (AccessSpecifier)Record.readInt(); 1749 Decls.addDecl(D, AS); 1750 } 1751 1752 DeclAccessPair *Results = E->getTrailingResults(); 1753 UnresolvedSetIterator Iter = Decls.begin(); 1754 for (unsigned I = 0; I != NumResults; ++I) { 1755 Results[I] = (Iter + I).getPair(); 1756 } 1757 1758 ReadDeclarationNameInfo(E->NameInfo); 1759 E->QualifierLoc = Record.readNestedNameSpecifierLoc(); 1760 } 1761 1762 void ASTStmtReader::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) { 1763 VisitOverloadExpr(E); 1764 E->UnresolvedMemberExprBits.IsArrow = Record.readInt(); 1765 E->UnresolvedMemberExprBits.HasUnresolvedUsing = Record.readInt(); 1766 E->Base = Record.readSubExpr(); 1767 E->BaseType = Record.readType(); 1768 E->OperatorLoc = ReadSourceLocation(); 1769 } 1770 1771 void ASTStmtReader::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) { 1772 VisitOverloadExpr(E); 1773 E->UnresolvedLookupExprBits.RequiresADL = Record.readInt(); 1774 E->UnresolvedLookupExprBits.Overloaded = Record.readInt(); 1775 E->NamingClass = ReadDeclAs<CXXRecordDecl>(); 1776 } 1777 1778 void ASTStmtReader::VisitTypeTraitExpr(TypeTraitExpr *E) { 1779 VisitExpr(E); 1780 E->TypeTraitExprBits.NumArgs = Record.readInt(); 1781 E->TypeTraitExprBits.Kind = Record.readInt(); 1782 E->TypeTraitExprBits.Value = Record.readInt(); 1783 SourceRange Range = ReadSourceRange(); 1784 E->Loc = Range.getBegin(); 1785 E->RParenLoc = Range.getEnd(); 1786 1787 auto **Args = E->getTrailingObjects<TypeSourceInfo *>(); 1788 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) 1789 Args[I] = GetTypeSourceInfo(); 1790 } 1791 1792 void ASTStmtReader::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) { 1793 VisitExpr(E); 1794 E->ATT = (ArrayTypeTrait)Record.readInt(); 1795 E->Value = (unsigned int)Record.readInt(); 1796 SourceRange Range = ReadSourceRange(); 1797 E->Loc = Range.getBegin(); 1798 E->RParen = Range.getEnd(); 1799 E->QueriedType = GetTypeSourceInfo(); 1800 E->Dimension = Record.readSubExpr(); 1801 } 1802 1803 void ASTStmtReader::VisitExpressionTraitExpr(ExpressionTraitExpr *E) { 1804 VisitExpr(E); 1805 E->ET = (ExpressionTrait)Record.readInt(); 1806 E->Value = (bool)Record.readInt(); 1807 SourceRange Range = ReadSourceRange(); 1808 E->QueriedExpression = Record.readSubExpr(); 1809 E->Loc = Range.getBegin(); 1810 E->RParen = Range.getEnd(); 1811 } 1812 1813 void ASTStmtReader::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) { 1814 VisitExpr(E); 1815 E->CXXNoexceptExprBits.Value = Record.readInt(); 1816 E->Range = ReadSourceRange(); 1817 E->Operand = Record.readSubExpr(); 1818 } 1819 1820 void ASTStmtReader::VisitPackExpansionExpr(PackExpansionExpr *E) { 1821 VisitExpr(E); 1822 E->EllipsisLoc = ReadSourceLocation(); 1823 E->NumExpansions = Record.readInt(); 1824 E->Pattern = Record.readSubExpr(); 1825 } 1826 1827 void ASTStmtReader::VisitSizeOfPackExpr(SizeOfPackExpr *E) { 1828 VisitExpr(E); 1829 unsigned NumPartialArgs = Record.readInt(); 1830 E->OperatorLoc = ReadSourceLocation(); 1831 E->PackLoc = ReadSourceLocation(); 1832 E->RParenLoc = ReadSourceLocation(); 1833 E->Pack = Record.readDeclAs<NamedDecl>(); 1834 if (E->isPartiallySubstituted()) { 1835 assert(E->Length == NumPartialArgs); 1836 for (auto *I = E->getTrailingObjects<TemplateArgument>(), 1837 *E = I + NumPartialArgs; 1838 I != E; ++I) 1839 new (I) TemplateArgument(Record.readTemplateArgument()); 1840 } else if (!E->isValueDependent()) { 1841 E->Length = Record.readInt(); 1842 } 1843 } 1844 1845 void ASTStmtReader::VisitSubstNonTypeTemplateParmExpr( 1846 SubstNonTypeTemplateParmExpr *E) { 1847 VisitExpr(E); 1848 E->Param = ReadDeclAs<NonTypeTemplateParmDecl>(); 1849 E->SubstNonTypeTemplateParmExprBits.NameLoc = ReadSourceLocation(); 1850 E->Replacement = Record.readSubExpr(); 1851 } 1852 1853 void ASTStmtReader::VisitSubstNonTypeTemplateParmPackExpr( 1854 SubstNonTypeTemplateParmPackExpr *E) { 1855 VisitExpr(E); 1856 E->Param = ReadDeclAs<NonTypeTemplateParmDecl>(); 1857 TemplateArgument ArgPack = Record.readTemplateArgument(); 1858 if (ArgPack.getKind() != TemplateArgument::Pack) 1859 return; 1860 1861 E->Arguments = ArgPack.pack_begin(); 1862 E->NumArguments = ArgPack.pack_size(); 1863 E->NameLoc = ReadSourceLocation(); 1864 } 1865 1866 void ASTStmtReader::VisitFunctionParmPackExpr(FunctionParmPackExpr *E) { 1867 VisitExpr(E); 1868 E->NumParameters = Record.readInt(); 1869 E->ParamPack = ReadDeclAs<ParmVarDecl>(); 1870 E->NameLoc = ReadSourceLocation(); 1871 auto **Parms = E->getTrailingObjects<VarDecl *>(); 1872 for (unsigned i = 0, n = E->NumParameters; i != n; ++i) 1873 Parms[i] = ReadDeclAs<VarDecl>(); 1874 } 1875 1876 void ASTStmtReader::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) { 1877 VisitExpr(E); 1878 E->State = Record.readSubExpr(); 1879 auto *VD = ReadDeclAs<ValueDecl>(); 1880 unsigned ManglingNumber = Record.readInt(); 1881 E->setExtendingDecl(VD, ManglingNumber); 1882 } 1883 1884 void ASTStmtReader::VisitCXXFoldExpr(CXXFoldExpr *E) { 1885 VisitExpr(E); 1886 E->LParenLoc = ReadSourceLocation(); 1887 E->EllipsisLoc = ReadSourceLocation(); 1888 E->RParenLoc = ReadSourceLocation(); 1889 E->NumExpansions = Record.readInt(); 1890 E->SubExprs[0] = Record.readSubExpr(); 1891 E->SubExprs[1] = Record.readSubExpr(); 1892 E->Opcode = (BinaryOperatorKind)Record.readInt(); 1893 } 1894 1895 void ASTStmtReader::VisitOpaqueValueExpr(OpaqueValueExpr *E) { 1896 VisitExpr(E); 1897 E->SourceExpr = Record.readSubExpr(); 1898 E->OpaqueValueExprBits.Loc = ReadSourceLocation(); 1899 E->setIsUnique(Record.readInt()); 1900 } 1901 1902 void ASTStmtReader::VisitTypoExpr(TypoExpr *E) { 1903 llvm_unreachable("Cannot read TypoExpr nodes"); 1904 } 1905 1906 //===----------------------------------------------------------------------===// 1907 // Microsoft Expressions and Statements 1908 //===----------------------------------------------------------------------===// 1909 void ASTStmtReader::VisitMSPropertyRefExpr(MSPropertyRefExpr *E) { 1910 VisitExpr(E); 1911 E->IsArrow = (Record.readInt() != 0); 1912 E->BaseExpr = Record.readSubExpr(); 1913 E->QualifierLoc = Record.readNestedNameSpecifierLoc(); 1914 E->MemberLoc = ReadSourceLocation(); 1915 E->TheDecl = ReadDeclAs<MSPropertyDecl>(); 1916 } 1917 1918 void ASTStmtReader::VisitMSPropertySubscriptExpr(MSPropertySubscriptExpr *E) { 1919 VisitExpr(E); 1920 E->setBase(Record.readSubExpr()); 1921 E->setIdx(Record.readSubExpr()); 1922 E->setRBracketLoc(ReadSourceLocation()); 1923 } 1924 1925 void ASTStmtReader::VisitCXXUuidofExpr(CXXUuidofExpr *E) { 1926 VisitExpr(E); 1927 E->setSourceRange(ReadSourceRange()); 1928 std::string UuidStr = ReadString(); 1929 E->setUuidStr(StringRef(UuidStr).copy(Record.getContext())); 1930 if (E->isTypeOperand()) { // __uuidof(ComType) 1931 E->setTypeOperandSourceInfo( 1932 GetTypeSourceInfo()); 1933 return; 1934 } 1935 1936 // __uuidof(expr) 1937 E->setExprOperand(Record.readSubExpr()); 1938 } 1939 1940 void ASTStmtReader::VisitSEHLeaveStmt(SEHLeaveStmt *S) { 1941 VisitStmt(S); 1942 S->setLeaveLoc(ReadSourceLocation()); 1943 } 1944 1945 void ASTStmtReader::VisitSEHExceptStmt(SEHExceptStmt *S) { 1946 VisitStmt(S); 1947 S->Loc = ReadSourceLocation(); 1948 S->Children[SEHExceptStmt::FILTER_EXPR] = Record.readSubStmt(); 1949 S->Children[SEHExceptStmt::BLOCK] = Record.readSubStmt(); 1950 } 1951 1952 void ASTStmtReader::VisitSEHFinallyStmt(SEHFinallyStmt *S) { 1953 VisitStmt(S); 1954 S->Loc = ReadSourceLocation(); 1955 S->Block = Record.readSubStmt(); 1956 } 1957 1958 void ASTStmtReader::VisitSEHTryStmt(SEHTryStmt *S) { 1959 VisitStmt(S); 1960 S->IsCXXTry = Record.readInt(); 1961 S->TryLoc = ReadSourceLocation(); 1962 S->Children[SEHTryStmt::TRY] = Record.readSubStmt(); 1963 S->Children[SEHTryStmt::HANDLER] = Record.readSubStmt(); 1964 } 1965 1966 //===----------------------------------------------------------------------===// 1967 // CUDA Expressions and Statements 1968 //===----------------------------------------------------------------------===// 1969 1970 void ASTStmtReader::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *E) { 1971 VisitCallExpr(E); 1972 E->setPreArg(CUDAKernelCallExpr::CONFIG, Record.readSubExpr()); 1973 } 1974 1975 //===----------------------------------------------------------------------===// 1976 // OpenCL Expressions and Statements. 1977 //===----------------------------------------------------------------------===// 1978 void ASTStmtReader::VisitAsTypeExpr(AsTypeExpr *E) { 1979 VisitExpr(E); 1980 E->BuiltinLoc = ReadSourceLocation(); 1981 E->RParenLoc = ReadSourceLocation(); 1982 E->SrcExpr = Record.readSubExpr(); 1983 } 1984 1985 //===----------------------------------------------------------------------===// 1986 // OpenMP Directives. 1987 //===----------------------------------------------------------------------===// 1988 1989 void ASTStmtReader::VisitOMPExecutableDirective(OMPExecutableDirective *E) { 1990 E->setLocStart(ReadSourceLocation()); 1991 E->setLocEnd(ReadSourceLocation()); 1992 OMPClauseReader ClauseReader(Record); 1993 SmallVector<OMPClause *, 5> Clauses; 1994 for (unsigned i = 0; i < E->getNumClauses(); ++i) 1995 Clauses.push_back(ClauseReader.readClause()); 1996 E->setClauses(Clauses); 1997 if (E->hasAssociatedStmt()) 1998 E->setAssociatedStmt(Record.readSubStmt()); 1999 } 2000 2001 void ASTStmtReader::VisitOMPLoopDirective(OMPLoopDirective *D) { 2002 VisitStmt(D); 2003 // Two fields (NumClauses and CollapsedNum) were read in ReadStmtFromStream. 2004 Record.skipInts(2); 2005 VisitOMPExecutableDirective(D); 2006 D->setIterationVariable(Record.readSubExpr()); 2007 D->setLastIteration(Record.readSubExpr()); 2008 D->setCalcLastIteration(Record.readSubExpr()); 2009 D->setPreCond(Record.readSubExpr()); 2010 D->setCond(Record.readSubExpr()); 2011 D->setInit(Record.readSubExpr()); 2012 D->setInc(Record.readSubExpr()); 2013 D->setPreInits(Record.readSubStmt()); 2014 if (isOpenMPWorksharingDirective(D->getDirectiveKind()) || 2015 isOpenMPTaskLoopDirective(D->getDirectiveKind()) || 2016 isOpenMPDistributeDirective(D->getDirectiveKind())) { 2017 D->setIsLastIterVariable(Record.readSubExpr()); 2018 D->setLowerBoundVariable(Record.readSubExpr()); 2019 D->setUpperBoundVariable(Record.readSubExpr()); 2020 D->setStrideVariable(Record.readSubExpr()); 2021 D->setEnsureUpperBound(Record.readSubExpr()); 2022 D->setNextLowerBound(Record.readSubExpr()); 2023 D->setNextUpperBound(Record.readSubExpr()); 2024 D->setNumIterations(Record.readSubExpr()); 2025 } 2026 if (isOpenMPLoopBoundSharingDirective(D->getDirectiveKind())) { 2027 D->setPrevLowerBoundVariable(Record.readSubExpr()); 2028 D->setPrevUpperBoundVariable(Record.readSubExpr()); 2029 D->setDistInc(Record.readSubExpr()); 2030 D->setPrevEnsureUpperBound(Record.readSubExpr()); 2031 D->setCombinedLowerBoundVariable(Record.readSubExpr()); 2032 D->setCombinedUpperBoundVariable(Record.readSubExpr()); 2033 D->setCombinedEnsureUpperBound(Record.readSubExpr()); 2034 D->setCombinedInit(Record.readSubExpr()); 2035 D->setCombinedCond(Record.readSubExpr()); 2036 D->setCombinedNextLowerBound(Record.readSubExpr()); 2037 D->setCombinedNextUpperBound(Record.readSubExpr()); 2038 D->setCombinedDistCond(Record.readSubExpr()); 2039 D->setCombinedParForInDistCond(Record.readSubExpr()); 2040 } 2041 SmallVector<Expr *, 4> Sub; 2042 unsigned CollapsedNum = D->getCollapsedNumber(); 2043 Sub.reserve(CollapsedNum); 2044 for (unsigned i = 0; i < CollapsedNum; ++i) 2045 Sub.push_back(Record.readSubExpr()); 2046 D->setCounters(Sub); 2047 Sub.clear(); 2048 for (unsigned i = 0; i < CollapsedNum; ++i) 2049 Sub.push_back(Record.readSubExpr()); 2050 D->setPrivateCounters(Sub); 2051 Sub.clear(); 2052 for (unsigned i = 0; i < CollapsedNum; ++i) 2053 Sub.push_back(Record.readSubExpr()); 2054 D->setInits(Sub); 2055 Sub.clear(); 2056 for (unsigned i = 0; i < CollapsedNum; ++i) 2057 Sub.push_back(Record.readSubExpr()); 2058 D->setUpdates(Sub); 2059 Sub.clear(); 2060 for (unsigned i = 0; i < CollapsedNum; ++i) 2061 Sub.push_back(Record.readSubExpr()); 2062 D->setFinals(Sub); 2063 } 2064 2065 void ASTStmtReader::VisitOMPParallelDirective(OMPParallelDirective *D) { 2066 VisitStmt(D); 2067 // The NumClauses field was read in ReadStmtFromStream. 2068 Record.skipInts(1); 2069 VisitOMPExecutableDirective(D); 2070 D->setHasCancel(Record.readInt()); 2071 } 2072 2073 void ASTStmtReader::VisitOMPSimdDirective(OMPSimdDirective *D) { 2074 VisitOMPLoopDirective(D); 2075 } 2076 2077 void ASTStmtReader::VisitOMPForDirective(OMPForDirective *D) { 2078 VisitOMPLoopDirective(D); 2079 D->setHasCancel(Record.readInt()); 2080 } 2081 2082 void ASTStmtReader::VisitOMPForSimdDirective(OMPForSimdDirective *D) { 2083 VisitOMPLoopDirective(D); 2084 } 2085 2086 void ASTStmtReader::VisitOMPSectionsDirective(OMPSectionsDirective *D) { 2087 VisitStmt(D); 2088 // The NumClauses field was read in ReadStmtFromStream. 2089 Record.skipInts(1); 2090 VisitOMPExecutableDirective(D); 2091 D->setHasCancel(Record.readInt()); 2092 } 2093 2094 void ASTStmtReader::VisitOMPSectionDirective(OMPSectionDirective *D) { 2095 VisitStmt(D); 2096 VisitOMPExecutableDirective(D); 2097 D->setHasCancel(Record.readInt()); 2098 } 2099 2100 void ASTStmtReader::VisitOMPSingleDirective(OMPSingleDirective *D) { 2101 VisitStmt(D); 2102 // The NumClauses field was read in ReadStmtFromStream. 2103 Record.skipInts(1); 2104 VisitOMPExecutableDirective(D); 2105 } 2106 2107 void ASTStmtReader::VisitOMPMasterDirective(OMPMasterDirective *D) { 2108 VisitStmt(D); 2109 VisitOMPExecutableDirective(D); 2110 } 2111 2112 void ASTStmtReader::VisitOMPCriticalDirective(OMPCriticalDirective *D) { 2113 VisitStmt(D); 2114 // The NumClauses field was read in ReadStmtFromStream. 2115 Record.skipInts(1); 2116 VisitOMPExecutableDirective(D); 2117 ReadDeclarationNameInfo(D->DirName); 2118 } 2119 2120 void ASTStmtReader::VisitOMPParallelForDirective(OMPParallelForDirective *D) { 2121 VisitOMPLoopDirective(D); 2122 D->setHasCancel(Record.readInt()); 2123 } 2124 2125 void ASTStmtReader::VisitOMPParallelForSimdDirective( 2126 OMPParallelForSimdDirective *D) { 2127 VisitOMPLoopDirective(D); 2128 } 2129 2130 void ASTStmtReader::VisitOMPParallelSectionsDirective( 2131 OMPParallelSectionsDirective *D) { 2132 VisitStmt(D); 2133 // The NumClauses field was read in ReadStmtFromStream. 2134 Record.skipInts(1); 2135 VisitOMPExecutableDirective(D); 2136 D->setHasCancel(Record.readInt()); 2137 } 2138 2139 void ASTStmtReader::VisitOMPTaskDirective(OMPTaskDirective *D) { 2140 VisitStmt(D); 2141 // The NumClauses field was read in ReadStmtFromStream. 2142 Record.skipInts(1); 2143 VisitOMPExecutableDirective(D); 2144 D->setHasCancel(Record.readInt()); 2145 } 2146 2147 void ASTStmtReader::VisitOMPTaskyieldDirective(OMPTaskyieldDirective *D) { 2148 VisitStmt(D); 2149 VisitOMPExecutableDirective(D); 2150 } 2151 2152 void ASTStmtReader::VisitOMPBarrierDirective(OMPBarrierDirective *D) { 2153 VisitStmt(D); 2154 VisitOMPExecutableDirective(D); 2155 } 2156 2157 void ASTStmtReader::VisitOMPTaskwaitDirective(OMPTaskwaitDirective *D) { 2158 VisitStmt(D); 2159 VisitOMPExecutableDirective(D); 2160 } 2161 2162 void ASTStmtReader::VisitOMPTaskgroupDirective(OMPTaskgroupDirective *D) { 2163 VisitStmt(D); 2164 // The NumClauses field was read in ReadStmtFromStream. 2165 Record.skipInts(1); 2166 VisitOMPExecutableDirective(D); 2167 D->setReductionRef(Record.readSubExpr()); 2168 } 2169 2170 void ASTStmtReader::VisitOMPFlushDirective(OMPFlushDirective *D) { 2171 VisitStmt(D); 2172 // The NumClauses field was read in ReadStmtFromStream. 2173 Record.skipInts(1); 2174 VisitOMPExecutableDirective(D); 2175 } 2176 2177 void ASTStmtReader::VisitOMPOrderedDirective(OMPOrderedDirective *D) { 2178 VisitStmt(D); 2179 // The NumClauses field was read in ReadStmtFromStream. 2180 Record.skipInts(1); 2181 VisitOMPExecutableDirective(D); 2182 } 2183 2184 void ASTStmtReader::VisitOMPAtomicDirective(OMPAtomicDirective *D) { 2185 VisitStmt(D); 2186 // The NumClauses field was read in ReadStmtFromStream. 2187 Record.skipInts(1); 2188 VisitOMPExecutableDirective(D); 2189 D->setX(Record.readSubExpr()); 2190 D->setV(Record.readSubExpr()); 2191 D->setExpr(Record.readSubExpr()); 2192 D->setUpdateExpr(Record.readSubExpr()); 2193 D->IsXLHSInRHSPart = Record.readInt() != 0; 2194 D->IsPostfixUpdate = Record.readInt() != 0; 2195 } 2196 2197 void ASTStmtReader::VisitOMPTargetDirective(OMPTargetDirective *D) { 2198 VisitStmt(D); 2199 // The NumClauses field was read in ReadStmtFromStream. 2200 Record.skipInts(1); 2201 VisitOMPExecutableDirective(D); 2202 } 2203 2204 void ASTStmtReader::VisitOMPTargetDataDirective(OMPTargetDataDirective *D) { 2205 VisitStmt(D); 2206 Record.skipInts(1); 2207 VisitOMPExecutableDirective(D); 2208 } 2209 2210 void ASTStmtReader::VisitOMPTargetEnterDataDirective( 2211 OMPTargetEnterDataDirective *D) { 2212 VisitStmt(D); 2213 Record.skipInts(1); 2214 VisitOMPExecutableDirective(D); 2215 } 2216 2217 void ASTStmtReader::VisitOMPTargetExitDataDirective( 2218 OMPTargetExitDataDirective *D) { 2219 VisitStmt(D); 2220 Record.skipInts(1); 2221 VisitOMPExecutableDirective(D); 2222 } 2223 2224 void ASTStmtReader::VisitOMPTargetParallelDirective( 2225 OMPTargetParallelDirective *D) { 2226 VisitStmt(D); 2227 Record.skipInts(1); 2228 VisitOMPExecutableDirective(D); 2229 } 2230 2231 void ASTStmtReader::VisitOMPTargetParallelForDirective( 2232 OMPTargetParallelForDirective *D) { 2233 VisitOMPLoopDirective(D); 2234 D->setHasCancel(Record.readInt()); 2235 } 2236 2237 void ASTStmtReader::VisitOMPTeamsDirective(OMPTeamsDirective *D) { 2238 VisitStmt(D); 2239 // The NumClauses field was read in ReadStmtFromStream. 2240 Record.skipInts(1); 2241 VisitOMPExecutableDirective(D); 2242 } 2243 2244 void ASTStmtReader::VisitOMPCancellationPointDirective( 2245 OMPCancellationPointDirective *D) { 2246 VisitStmt(D); 2247 VisitOMPExecutableDirective(D); 2248 D->setCancelRegion(static_cast<OpenMPDirectiveKind>(Record.readInt())); 2249 } 2250 2251 void ASTStmtReader::VisitOMPCancelDirective(OMPCancelDirective *D) { 2252 VisitStmt(D); 2253 // The NumClauses field was read in ReadStmtFromStream. 2254 Record.skipInts(1); 2255 VisitOMPExecutableDirective(D); 2256 D->setCancelRegion(static_cast<OpenMPDirectiveKind>(Record.readInt())); 2257 } 2258 2259 void ASTStmtReader::VisitOMPTaskLoopDirective(OMPTaskLoopDirective *D) { 2260 VisitOMPLoopDirective(D); 2261 } 2262 2263 void ASTStmtReader::VisitOMPTaskLoopSimdDirective(OMPTaskLoopSimdDirective *D) { 2264 VisitOMPLoopDirective(D); 2265 } 2266 2267 void ASTStmtReader::VisitOMPDistributeDirective(OMPDistributeDirective *D) { 2268 VisitOMPLoopDirective(D); 2269 } 2270 2271 void ASTStmtReader::VisitOMPTargetUpdateDirective(OMPTargetUpdateDirective *D) { 2272 VisitStmt(D); 2273 Record.skipInts(1); 2274 VisitOMPExecutableDirective(D); 2275 } 2276 2277 void ASTStmtReader::VisitOMPDistributeParallelForDirective( 2278 OMPDistributeParallelForDirective *D) { 2279 VisitOMPLoopDirective(D); 2280 D->setHasCancel(Record.readInt()); 2281 } 2282 2283 void ASTStmtReader::VisitOMPDistributeParallelForSimdDirective( 2284 OMPDistributeParallelForSimdDirective *D) { 2285 VisitOMPLoopDirective(D); 2286 } 2287 2288 void ASTStmtReader::VisitOMPDistributeSimdDirective( 2289 OMPDistributeSimdDirective *D) { 2290 VisitOMPLoopDirective(D); 2291 } 2292 2293 void ASTStmtReader::VisitOMPTargetParallelForSimdDirective( 2294 OMPTargetParallelForSimdDirective *D) { 2295 VisitOMPLoopDirective(D); 2296 } 2297 2298 void ASTStmtReader::VisitOMPTargetSimdDirective(OMPTargetSimdDirective *D) { 2299 VisitOMPLoopDirective(D); 2300 } 2301 2302 void ASTStmtReader::VisitOMPTeamsDistributeDirective( 2303 OMPTeamsDistributeDirective *D) { 2304 VisitOMPLoopDirective(D); 2305 } 2306 2307 void ASTStmtReader::VisitOMPTeamsDistributeSimdDirective( 2308 OMPTeamsDistributeSimdDirective *D) { 2309 VisitOMPLoopDirective(D); 2310 } 2311 2312 void ASTStmtReader::VisitOMPTeamsDistributeParallelForSimdDirective( 2313 OMPTeamsDistributeParallelForSimdDirective *D) { 2314 VisitOMPLoopDirective(D); 2315 } 2316 2317 void ASTStmtReader::VisitOMPTeamsDistributeParallelForDirective( 2318 OMPTeamsDistributeParallelForDirective *D) { 2319 VisitOMPLoopDirective(D); 2320 D->setHasCancel(Record.readInt()); 2321 } 2322 2323 void ASTStmtReader::VisitOMPTargetTeamsDirective(OMPTargetTeamsDirective *D) { 2324 VisitStmt(D); 2325 // The NumClauses field was read in ReadStmtFromStream. 2326 Record.skipInts(1); 2327 VisitOMPExecutableDirective(D); 2328 } 2329 2330 void ASTStmtReader::VisitOMPTargetTeamsDistributeDirective( 2331 OMPTargetTeamsDistributeDirective *D) { 2332 VisitOMPLoopDirective(D); 2333 } 2334 2335 void ASTStmtReader::VisitOMPTargetTeamsDistributeParallelForDirective( 2336 OMPTargetTeamsDistributeParallelForDirective *D) { 2337 VisitOMPLoopDirective(D); 2338 D->setHasCancel(Record.readInt()); 2339 } 2340 2341 void ASTStmtReader::VisitOMPTargetTeamsDistributeParallelForSimdDirective( 2342 OMPTargetTeamsDistributeParallelForSimdDirective *D) { 2343 VisitOMPLoopDirective(D); 2344 } 2345 2346 void ASTStmtReader::VisitOMPTargetTeamsDistributeSimdDirective( 2347 OMPTargetTeamsDistributeSimdDirective *D) { 2348 VisitOMPLoopDirective(D); 2349 } 2350 2351 //===----------------------------------------------------------------------===// 2352 // ASTReader Implementation 2353 //===----------------------------------------------------------------------===// 2354 2355 Stmt *ASTReader::ReadStmt(ModuleFile &F) { 2356 switch (ReadingKind) { 2357 case Read_None: 2358 llvm_unreachable("should not call this when not reading anything"); 2359 case Read_Decl: 2360 case Read_Type: 2361 return ReadStmtFromStream(F); 2362 case Read_Stmt: 2363 return ReadSubStmt(); 2364 } 2365 2366 llvm_unreachable("ReadingKind not set ?"); 2367 } 2368 2369 Expr *ASTReader::ReadExpr(ModuleFile &F) { 2370 return cast_or_null<Expr>(ReadStmt(F)); 2371 } 2372 2373 Expr *ASTReader::ReadSubExpr() { 2374 return cast_or_null<Expr>(ReadSubStmt()); 2375 } 2376 2377 // Within the bitstream, expressions are stored in Reverse Polish 2378 // Notation, with each of the subexpressions preceding the 2379 // expression they are stored in. Subexpressions are stored from last to first. 2380 // To evaluate expressions, we continue reading expressions and placing them on 2381 // the stack, with expressions having operands removing those operands from the 2382 // stack. Evaluation terminates when we see a STMT_STOP record, and 2383 // the single remaining expression on the stack is our result. 2384 Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) { 2385 ReadingKindTracker ReadingKind(Read_Stmt, *this); 2386 llvm::BitstreamCursor &Cursor = F.DeclsCursor; 2387 2388 // Map of offset to previously deserialized stmt. The offset points 2389 // just after the stmt record. 2390 llvm::DenseMap<uint64_t, Stmt *> StmtEntries; 2391 2392 #ifndef NDEBUG 2393 unsigned PrevNumStmts = StmtStack.size(); 2394 #endif 2395 2396 ASTRecordReader Record(*this, F); 2397 ASTStmtReader Reader(Record, Cursor); 2398 Stmt::EmptyShell Empty; 2399 2400 while (true) { 2401 llvm::Expected<llvm::BitstreamEntry> MaybeEntry = 2402 Cursor.advanceSkippingSubblocks(); 2403 if (!MaybeEntry) { 2404 Error(toString(MaybeEntry.takeError())); 2405 return nullptr; 2406 } 2407 llvm::BitstreamEntry Entry = MaybeEntry.get(); 2408 2409 switch (Entry.Kind) { 2410 case llvm::BitstreamEntry::SubBlock: // Handled for us already. 2411 case llvm::BitstreamEntry::Error: 2412 Error("malformed block record in AST file"); 2413 return nullptr; 2414 case llvm::BitstreamEntry::EndBlock: 2415 goto Done; 2416 case llvm::BitstreamEntry::Record: 2417 // The interesting case. 2418 break; 2419 } 2420 2421 ASTContext &Context = getContext(); 2422 Stmt *S = nullptr; 2423 bool Finished = false; 2424 bool IsStmtReference = false; 2425 Expected<unsigned> MaybeStmtCode = Record.readRecord(Cursor, Entry.ID); 2426 if (!MaybeStmtCode) { 2427 Error(toString(MaybeStmtCode.takeError())); 2428 return nullptr; 2429 } 2430 switch ((StmtCode)MaybeStmtCode.get()) { 2431 case STMT_STOP: 2432 Finished = true; 2433 break; 2434 2435 case STMT_REF_PTR: 2436 IsStmtReference = true; 2437 assert(StmtEntries.find(Record[0]) != StmtEntries.end() && 2438 "No stmt was recorded for this offset reference!"); 2439 S = StmtEntries[Record.readInt()]; 2440 break; 2441 2442 case STMT_NULL_PTR: 2443 S = nullptr; 2444 break; 2445 2446 case STMT_NULL: 2447 S = new (Context) NullStmt(Empty); 2448 break; 2449 2450 case STMT_COMPOUND: 2451 S = CompoundStmt::CreateEmpty( 2452 Context, /*NumStmts=*/Record[ASTStmtReader::NumStmtFields]); 2453 break; 2454 2455 case STMT_CASE: 2456 S = CaseStmt::CreateEmpty( 2457 Context, 2458 /*CaseStmtIsGNURange*/ Record[ASTStmtReader::NumStmtFields + 3]); 2459 break; 2460 2461 case STMT_DEFAULT: 2462 S = new (Context) DefaultStmt(Empty); 2463 break; 2464 2465 case STMT_LABEL: 2466 S = new (Context) LabelStmt(Empty); 2467 break; 2468 2469 case STMT_ATTRIBUTED: 2470 S = AttributedStmt::CreateEmpty( 2471 Context, 2472 /*NumAttrs*/Record[ASTStmtReader::NumStmtFields]); 2473 break; 2474 2475 case STMT_IF: 2476 S = IfStmt::CreateEmpty( 2477 Context, 2478 /* HasElse=*/Record[ASTStmtReader::NumStmtFields + 1], 2479 /* HasVar=*/Record[ASTStmtReader::NumStmtFields + 2], 2480 /* HasInit=*/Record[ASTStmtReader::NumStmtFields + 3]); 2481 break; 2482 2483 case STMT_SWITCH: 2484 S = SwitchStmt::CreateEmpty( 2485 Context, 2486 /* HasInit=*/Record[ASTStmtReader::NumStmtFields], 2487 /* HasVar=*/Record[ASTStmtReader::NumStmtFields + 1]); 2488 break; 2489 2490 case STMT_WHILE: 2491 S = WhileStmt::CreateEmpty( 2492 Context, 2493 /* HasVar=*/Record[ASTStmtReader::NumStmtFields]); 2494 break; 2495 2496 case STMT_DO: 2497 S = new (Context) DoStmt(Empty); 2498 break; 2499 2500 case STMT_FOR: 2501 S = new (Context) ForStmt(Empty); 2502 break; 2503 2504 case STMT_GOTO: 2505 S = new (Context) GotoStmt(Empty); 2506 break; 2507 2508 case STMT_INDIRECT_GOTO: 2509 S = new (Context) IndirectGotoStmt(Empty); 2510 break; 2511 2512 case STMT_CONTINUE: 2513 S = new (Context) ContinueStmt(Empty); 2514 break; 2515 2516 case STMT_BREAK: 2517 S = new (Context) BreakStmt(Empty); 2518 break; 2519 2520 case STMT_RETURN: 2521 S = ReturnStmt::CreateEmpty( 2522 Context, /* HasNRVOCandidate=*/Record[ASTStmtReader::NumStmtFields]); 2523 break; 2524 2525 case STMT_DECL: 2526 S = new (Context) DeclStmt(Empty); 2527 break; 2528 2529 case STMT_GCCASM: 2530 S = new (Context) GCCAsmStmt(Empty); 2531 break; 2532 2533 case STMT_MSASM: 2534 S = new (Context) MSAsmStmt(Empty); 2535 break; 2536 2537 case STMT_CAPTURED: 2538 S = CapturedStmt::CreateDeserialized( 2539 Context, Record[ASTStmtReader::NumStmtFields]); 2540 break; 2541 2542 case EXPR_CONSTANT: 2543 S = ConstantExpr::CreateEmpty( 2544 Context, 2545 static_cast<ConstantExpr::ResultStorageKind>( 2546 Record[ASTStmtReader::NumExprFields]), 2547 Empty); 2548 break; 2549 2550 case EXPR_PREDEFINED: 2551 S = PredefinedExpr::CreateEmpty( 2552 Context, 2553 /*HasFunctionName*/ Record[ASTStmtReader::NumExprFields]); 2554 break; 2555 2556 case EXPR_DECL_REF: 2557 S = DeclRefExpr::CreateEmpty( 2558 Context, 2559 /*HasQualifier=*/Record[ASTStmtReader::NumExprFields], 2560 /*HasFoundDecl=*/Record[ASTStmtReader::NumExprFields + 1], 2561 /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields + 2], 2562 /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields + 2] ? 2563 Record[ASTStmtReader::NumExprFields + 6] : 0); 2564 break; 2565 2566 case EXPR_INTEGER_LITERAL: 2567 S = IntegerLiteral::Create(Context, Empty); 2568 break; 2569 2570 case EXPR_FLOATING_LITERAL: 2571 S = FloatingLiteral::Create(Context, Empty); 2572 break; 2573 2574 case EXPR_IMAGINARY_LITERAL: 2575 S = new (Context) ImaginaryLiteral(Empty); 2576 break; 2577 2578 case EXPR_STRING_LITERAL: 2579 S = StringLiteral::CreateEmpty( 2580 Context, 2581 /* NumConcatenated=*/Record[ASTStmtReader::NumExprFields], 2582 /* Length=*/Record[ASTStmtReader::NumExprFields + 1], 2583 /* CharByteWidth=*/Record[ASTStmtReader::NumExprFields + 2]); 2584 break; 2585 2586 case EXPR_CHARACTER_LITERAL: 2587 S = new (Context) CharacterLiteral(Empty); 2588 break; 2589 2590 case EXPR_PAREN: 2591 S = new (Context) ParenExpr(Empty); 2592 break; 2593 2594 case EXPR_PAREN_LIST: 2595 S = ParenListExpr::CreateEmpty( 2596 Context, 2597 /* NumExprs=*/Record[ASTStmtReader::NumExprFields]); 2598 break; 2599 2600 case EXPR_UNARY_OPERATOR: 2601 S = new (Context) UnaryOperator(Empty); 2602 break; 2603 2604 case EXPR_OFFSETOF: 2605 S = OffsetOfExpr::CreateEmpty(Context, 2606 Record[ASTStmtReader::NumExprFields], 2607 Record[ASTStmtReader::NumExprFields + 1]); 2608 break; 2609 2610 case EXPR_SIZEOF_ALIGN_OF: 2611 S = new (Context) UnaryExprOrTypeTraitExpr(Empty); 2612 break; 2613 2614 case EXPR_ARRAY_SUBSCRIPT: 2615 S = new (Context) ArraySubscriptExpr(Empty); 2616 break; 2617 2618 case EXPR_OMP_ARRAY_SECTION: 2619 S = new (Context) OMPArraySectionExpr(Empty); 2620 break; 2621 2622 case EXPR_CALL: 2623 S = CallExpr::CreateEmpty( 2624 Context, /*NumArgs=*/Record[ASTStmtReader::NumExprFields], Empty); 2625 break; 2626 2627 case EXPR_MEMBER: 2628 S = MemberExpr::CreateEmpty(Context, Record[ASTStmtReader::NumExprFields], 2629 Record[ASTStmtReader::NumExprFields + 1], 2630 Record[ASTStmtReader::NumExprFields + 2], 2631 Record[ASTStmtReader::NumExprFields + 3]); 2632 break; 2633 2634 case EXPR_BINARY_OPERATOR: 2635 S = new (Context) BinaryOperator(Empty); 2636 break; 2637 2638 case EXPR_COMPOUND_ASSIGN_OPERATOR: 2639 S = new (Context) CompoundAssignOperator(Empty); 2640 break; 2641 2642 case EXPR_CONDITIONAL_OPERATOR: 2643 S = new (Context) ConditionalOperator(Empty); 2644 break; 2645 2646 case EXPR_BINARY_CONDITIONAL_OPERATOR: 2647 S = new (Context) BinaryConditionalOperator(Empty); 2648 break; 2649 2650 case EXPR_IMPLICIT_CAST: 2651 S = ImplicitCastExpr::CreateEmpty(Context, 2652 /*PathSize*/ Record[ASTStmtReader::NumExprFields]); 2653 break; 2654 2655 case EXPR_CSTYLE_CAST: 2656 S = CStyleCastExpr::CreateEmpty(Context, 2657 /*PathSize*/ Record[ASTStmtReader::NumExprFields]); 2658 break; 2659 2660 case EXPR_COMPOUND_LITERAL: 2661 S = new (Context) CompoundLiteralExpr(Empty); 2662 break; 2663 2664 case EXPR_EXT_VECTOR_ELEMENT: 2665 S = new (Context) ExtVectorElementExpr(Empty); 2666 break; 2667 2668 case EXPR_INIT_LIST: 2669 S = new (Context) InitListExpr(Empty); 2670 break; 2671 2672 case EXPR_DESIGNATED_INIT: 2673 S = DesignatedInitExpr::CreateEmpty(Context, 2674 Record[ASTStmtReader::NumExprFields] - 1); 2675 2676 break; 2677 2678 case EXPR_DESIGNATED_INIT_UPDATE: 2679 S = new (Context) DesignatedInitUpdateExpr(Empty); 2680 break; 2681 2682 case EXPR_IMPLICIT_VALUE_INIT: 2683 S = new (Context) ImplicitValueInitExpr(Empty); 2684 break; 2685 2686 case EXPR_NO_INIT: 2687 S = new (Context) NoInitExpr(Empty); 2688 break; 2689 2690 case EXPR_ARRAY_INIT_LOOP: 2691 S = new (Context) ArrayInitLoopExpr(Empty); 2692 break; 2693 2694 case EXPR_ARRAY_INIT_INDEX: 2695 S = new (Context) ArrayInitIndexExpr(Empty); 2696 break; 2697 2698 case EXPR_VA_ARG: 2699 S = new (Context) VAArgExpr(Empty); 2700 break; 2701 2702 case EXPR_SOURCE_LOC: 2703 S = new (Context) SourceLocExpr(Empty); 2704 break; 2705 2706 case EXPR_ADDR_LABEL: 2707 S = new (Context) AddrLabelExpr(Empty); 2708 break; 2709 2710 case EXPR_STMT: 2711 S = new (Context) StmtExpr(Empty); 2712 break; 2713 2714 case EXPR_CHOOSE: 2715 S = new (Context) ChooseExpr(Empty); 2716 break; 2717 2718 case EXPR_GNU_NULL: 2719 S = new (Context) GNUNullExpr(Empty); 2720 break; 2721 2722 case EXPR_SHUFFLE_VECTOR: 2723 S = new (Context) ShuffleVectorExpr(Empty); 2724 break; 2725 2726 case EXPR_CONVERT_VECTOR: 2727 S = new (Context) ConvertVectorExpr(Empty); 2728 break; 2729 2730 case EXPR_BLOCK: 2731 S = new (Context) BlockExpr(Empty); 2732 break; 2733 2734 case EXPR_GENERIC_SELECTION: 2735 S = GenericSelectionExpr::CreateEmpty( 2736 Context, 2737 /*NumAssocs=*/Record[ASTStmtReader::NumExprFields]); 2738 break; 2739 2740 case EXPR_OBJC_STRING_LITERAL: 2741 S = new (Context) ObjCStringLiteral(Empty); 2742 break; 2743 2744 case EXPR_OBJC_BOXED_EXPRESSION: 2745 S = new (Context) ObjCBoxedExpr(Empty); 2746 break; 2747 2748 case EXPR_OBJC_ARRAY_LITERAL: 2749 S = ObjCArrayLiteral::CreateEmpty(Context, 2750 Record[ASTStmtReader::NumExprFields]); 2751 break; 2752 2753 case EXPR_OBJC_DICTIONARY_LITERAL: 2754 S = ObjCDictionaryLiteral::CreateEmpty(Context, 2755 Record[ASTStmtReader::NumExprFields], 2756 Record[ASTStmtReader::NumExprFields + 1]); 2757 break; 2758 2759 case EXPR_OBJC_ENCODE: 2760 S = new (Context) ObjCEncodeExpr(Empty); 2761 break; 2762 2763 case EXPR_OBJC_SELECTOR_EXPR: 2764 S = new (Context) ObjCSelectorExpr(Empty); 2765 break; 2766 2767 case EXPR_OBJC_PROTOCOL_EXPR: 2768 S = new (Context) ObjCProtocolExpr(Empty); 2769 break; 2770 2771 case EXPR_OBJC_IVAR_REF_EXPR: 2772 S = new (Context) ObjCIvarRefExpr(Empty); 2773 break; 2774 2775 case EXPR_OBJC_PROPERTY_REF_EXPR: 2776 S = new (Context) ObjCPropertyRefExpr(Empty); 2777 break; 2778 2779 case EXPR_OBJC_SUBSCRIPT_REF_EXPR: 2780 S = new (Context) ObjCSubscriptRefExpr(Empty); 2781 break; 2782 2783 case EXPR_OBJC_KVC_REF_EXPR: 2784 llvm_unreachable("mismatching AST file"); 2785 2786 case EXPR_OBJC_MESSAGE_EXPR: 2787 S = ObjCMessageExpr::CreateEmpty(Context, 2788 Record[ASTStmtReader::NumExprFields], 2789 Record[ASTStmtReader::NumExprFields + 1]); 2790 break; 2791 2792 case EXPR_OBJC_ISA: 2793 S = new (Context) ObjCIsaExpr(Empty); 2794 break; 2795 2796 case EXPR_OBJC_INDIRECT_COPY_RESTORE: 2797 S = new (Context) ObjCIndirectCopyRestoreExpr(Empty); 2798 break; 2799 2800 case EXPR_OBJC_BRIDGED_CAST: 2801 S = new (Context) ObjCBridgedCastExpr(Empty); 2802 break; 2803 2804 case STMT_OBJC_FOR_COLLECTION: 2805 S = new (Context) ObjCForCollectionStmt(Empty); 2806 break; 2807 2808 case STMT_OBJC_CATCH: 2809 S = new (Context) ObjCAtCatchStmt(Empty); 2810 break; 2811 2812 case STMT_OBJC_FINALLY: 2813 S = new (Context) ObjCAtFinallyStmt(Empty); 2814 break; 2815 2816 case STMT_OBJC_AT_TRY: 2817 S = ObjCAtTryStmt::CreateEmpty(Context, 2818 Record[ASTStmtReader::NumStmtFields], 2819 Record[ASTStmtReader::NumStmtFields + 1]); 2820 break; 2821 2822 case STMT_OBJC_AT_SYNCHRONIZED: 2823 S = new (Context) ObjCAtSynchronizedStmt(Empty); 2824 break; 2825 2826 case STMT_OBJC_AT_THROW: 2827 S = new (Context) ObjCAtThrowStmt(Empty); 2828 break; 2829 2830 case STMT_OBJC_AUTORELEASE_POOL: 2831 S = new (Context) ObjCAutoreleasePoolStmt(Empty); 2832 break; 2833 2834 case EXPR_OBJC_BOOL_LITERAL: 2835 S = new (Context) ObjCBoolLiteralExpr(Empty); 2836 break; 2837 2838 case EXPR_OBJC_AVAILABILITY_CHECK: 2839 S = new (Context) ObjCAvailabilityCheckExpr(Empty); 2840 break; 2841 2842 case STMT_SEH_LEAVE: 2843 S = new (Context) SEHLeaveStmt(Empty); 2844 break; 2845 2846 case STMT_SEH_EXCEPT: 2847 S = new (Context) SEHExceptStmt(Empty); 2848 break; 2849 2850 case STMT_SEH_FINALLY: 2851 S = new (Context) SEHFinallyStmt(Empty); 2852 break; 2853 2854 case STMT_SEH_TRY: 2855 S = new (Context) SEHTryStmt(Empty); 2856 break; 2857 2858 case STMT_CXX_CATCH: 2859 S = new (Context) CXXCatchStmt(Empty); 2860 break; 2861 2862 case STMT_CXX_TRY: 2863 S = CXXTryStmt::Create(Context, Empty, 2864 /*numHandlers=*/Record[ASTStmtReader::NumStmtFields]); 2865 break; 2866 2867 case STMT_CXX_FOR_RANGE: 2868 S = new (Context) CXXForRangeStmt(Empty); 2869 break; 2870 2871 case STMT_MS_DEPENDENT_EXISTS: 2872 S = new (Context) MSDependentExistsStmt(SourceLocation(), true, 2873 NestedNameSpecifierLoc(), 2874 DeclarationNameInfo(), 2875 nullptr); 2876 break; 2877 2878 case STMT_OMP_PARALLEL_DIRECTIVE: 2879 S = 2880 OMPParallelDirective::CreateEmpty(Context, 2881 Record[ASTStmtReader::NumStmtFields], 2882 Empty); 2883 break; 2884 2885 case STMT_OMP_SIMD_DIRECTIVE: { 2886 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields]; 2887 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1]; 2888 S = OMPSimdDirective::CreateEmpty(Context, NumClauses, 2889 CollapsedNum, Empty); 2890 break; 2891 } 2892 2893 case STMT_OMP_FOR_DIRECTIVE: { 2894 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields]; 2895 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1]; 2896 S = OMPForDirective::CreateEmpty(Context, NumClauses, CollapsedNum, 2897 Empty); 2898 break; 2899 } 2900 2901 case STMT_OMP_FOR_SIMD_DIRECTIVE: { 2902 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields]; 2903 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1]; 2904 S = OMPForSimdDirective::CreateEmpty(Context, NumClauses, CollapsedNum, 2905 Empty); 2906 break; 2907 } 2908 2909 case STMT_OMP_SECTIONS_DIRECTIVE: 2910 S = OMPSectionsDirective::CreateEmpty( 2911 Context, Record[ASTStmtReader::NumStmtFields], Empty); 2912 break; 2913 2914 case STMT_OMP_SECTION_DIRECTIVE: 2915 S = OMPSectionDirective::CreateEmpty(Context, Empty); 2916 break; 2917 2918 case STMT_OMP_SINGLE_DIRECTIVE: 2919 S = OMPSingleDirective::CreateEmpty( 2920 Context, Record[ASTStmtReader::NumStmtFields], Empty); 2921 break; 2922 2923 case STMT_OMP_MASTER_DIRECTIVE: 2924 S = OMPMasterDirective::CreateEmpty(Context, Empty); 2925 break; 2926 2927 case STMT_OMP_CRITICAL_DIRECTIVE: 2928 S = OMPCriticalDirective::CreateEmpty( 2929 Context, Record[ASTStmtReader::NumStmtFields], Empty); 2930 break; 2931 2932 case STMT_OMP_PARALLEL_FOR_DIRECTIVE: { 2933 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields]; 2934 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1]; 2935 S = OMPParallelForDirective::CreateEmpty(Context, NumClauses, 2936 CollapsedNum, Empty); 2937 break; 2938 } 2939 2940 case STMT_OMP_PARALLEL_FOR_SIMD_DIRECTIVE: { 2941 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields]; 2942 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1]; 2943 S = OMPParallelForSimdDirective::CreateEmpty(Context, NumClauses, 2944 CollapsedNum, Empty); 2945 break; 2946 } 2947 2948 case STMT_OMP_PARALLEL_SECTIONS_DIRECTIVE: 2949 S = OMPParallelSectionsDirective::CreateEmpty( 2950 Context, Record[ASTStmtReader::NumStmtFields], Empty); 2951 break; 2952 2953 case STMT_OMP_TASK_DIRECTIVE: 2954 S = OMPTaskDirective::CreateEmpty( 2955 Context, Record[ASTStmtReader::NumStmtFields], Empty); 2956 break; 2957 2958 case STMT_OMP_TASKYIELD_DIRECTIVE: 2959 S = OMPTaskyieldDirective::CreateEmpty(Context, Empty); 2960 break; 2961 2962 case STMT_OMP_BARRIER_DIRECTIVE: 2963 S = OMPBarrierDirective::CreateEmpty(Context, Empty); 2964 break; 2965 2966 case STMT_OMP_TASKWAIT_DIRECTIVE: 2967 S = OMPTaskwaitDirective::CreateEmpty(Context, Empty); 2968 break; 2969 2970 case STMT_OMP_TASKGROUP_DIRECTIVE: 2971 S = OMPTaskgroupDirective::CreateEmpty( 2972 Context, Record[ASTStmtReader::NumStmtFields], Empty); 2973 break; 2974 2975 case STMT_OMP_FLUSH_DIRECTIVE: 2976 S = OMPFlushDirective::CreateEmpty( 2977 Context, Record[ASTStmtReader::NumStmtFields], Empty); 2978 break; 2979 2980 case STMT_OMP_ORDERED_DIRECTIVE: 2981 S = OMPOrderedDirective::CreateEmpty( 2982 Context, Record[ASTStmtReader::NumStmtFields], Empty); 2983 break; 2984 2985 case STMT_OMP_ATOMIC_DIRECTIVE: 2986 S = OMPAtomicDirective::CreateEmpty( 2987 Context, Record[ASTStmtReader::NumStmtFields], Empty); 2988 break; 2989 2990 case STMT_OMP_TARGET_DIRECTIVE: 2991 S = OMPTargetDirective::CreateEmpty( 2992 Context, Record[ASTStmtReader::NumStmtFields], Empty); 2993 break; 2994 2995 case STMT_OMP_TARGET_DATA_DIRECTIVE: 2996 S = OMPTargetDataDirective::CreateEmpty( 2997 Context, Record[ASTStmtReader::NumStmtFields], Empty); 2998 break; 2999 3000 case STMT_OMP_TARGET_ENTER_DATA_DIRECTIVE: 3001 S = OMPTargetEnterDataDirective::CreateEmpty( 3002 Context, Record[ASTStmtReader::NumStmtFields], Empty); 3003 break; 3004 3005 case STMT_OMP_TARGET_EXIT_DATA_DIRECTIVE: 3006 S = OMPTargetExitDataDirective::CreateEmpty( 3007 Context, Record[ASTStmtReader::NumStmtFields], Empty); 3008 break; 3009 3010 case STMT_OMP_TARGET_PARALLEL_DIRECTIVE: 3011 S = OMPTargetParallelDirective::CreateEmpty( 3012 Context, Record[ASTStmtReader::NumStmtFields], Empty); 3013 break; 3014 3015 case STMT_OMP_TARGET_PARALLEL_FOR_DIRECTIVE: { 3016 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields]; 3017 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1]; 3018 S = OMPTargetParallelForDirective::CreateEmpty(Context, NumClauses, 3019 CollapsedNum, Empty); 3020 break; 3021 } 3022 3023 case STMT_OMP_TARGET_UPDATE_DIRECTIVE: 3024 S = OMPTargetUpdateDirective::CreateEmpty( 3025 Context, Record[ASTStmtReader::NumStmtFields], Empty); 3026 break; 3027 3028 case STMT_OMP_TEAMS_DIRECTIVE: 3029 S = OMPTeamsDirective::CreateEmpty( 3030 Context, Record[ASTStmtReader::NumStmtFields], Empty); 3031 break; 3032 3033 case STMT_OMP_CANCELLATION_POINT_DIRECTIVE: 3034 S = OMPCancellationPointDirective::CreateEmpty(Context, Empty); 3035 break; 3036 3037 case STMT_OMP_CANCEL_DIRECTIVE: 3038 S = OMPCancelDirective::CreateEmpty( 3039 Context, Record[ASTStmtReader::NumStmtFields], Empty); 3040 break; 3041 3042 case STMT_OMP_TASKLOOP_DIRECTIVE: { 3043 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields]; 3044 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1]; 3045 S = OMPTaskLoopDirective::CreateEmpty(Context, NumClauses, CollapsedNum, 3046 Empty); 3047 break; 3048 } 3049 3050 case STMT_OMP_TASKLOOP_SIMD_DIRECTIVE: { 3051 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields]; 3052 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1]; 3053 S = OMPTaskLoopSimdDirective::CreateEmpty(Context, NumClauses, 3054 CollapsedNum, Empty); 3055 break; 3056 } 3057 3058 case STMT_OMP_DISTRIBUTE_DIRECTIVE: { 3059 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields]; 3060 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1]; 3061 S = OMPDistributeDirective::CreateEmpty(Context, NumClauses, CollapsedNum, 3062 Empty); 3063 break; 3064 } 3065 3066 case STMT_OMP_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE: { 3067 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields]; 3068 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1]; 3069 S = OMPDistributeParallelForDirective::CreateEmpty(Context, NumClauses, 3070 CollapsedNum, Empty); 3071 break; 3072 } 3073 3074 case STMT_OMP_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE: { 3075 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields]; 3076 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1]; 3077 S = OMPDistributeParallelForSimdDirective::CreateEmpty(Context, NumClauses, 3078 CollapsedNum, 3079 Empty); 3080 break; 3081 } 3082 3083 case STMT_OMP_DISTRIBUTE_SIMD_DIRECTIVE: { 3084 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields]; 3085 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1]; 3086 S = OMPDistributeSimdDirective::CreateEmpty(Context, NumClauses, 3087 CollapsedNum, Empty); 3088 break; 3089 } 3090 3091 case STMT_OMP_TARGET_PARALLEL_FOR_SIMD_DIRECTIVE: { 3092 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields]; 3093 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1]; 3094 S = OMPTargetParallelForSimdDirective::CreateEmpty(Context, NumClauses, 3095 CollapsedNum, Empty); 3096 break; 3097 } 3098 3099 case STMT_OMP_TARGET_SIMD_DIRECTIVE: { 3100 auto NumClauses = Record[ASTStmtReader::NumStmtFields]; 3101 auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1]; 3102 S = OMPTargetSimdDirective::CreateEmpty(Context, NumClauses, CollapsedNum, 3103 Empty); 3104 break; 3105 } 3106 3107 case STMT_OMP_TEAMS_DISTRIBUTE_DIRECTIVE: { 3108 auto NumClauses = Record[ASTStmtReader::NumStmtFields]; 3109 auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1]; 3110 S = OMPTeamsDistributeDirective::CreateEmpty(Context, NumClauses, 3111 CollapsedNum, Empty); 3112 break; 3113 } 3114 3115 case STMT_OMP_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE: { 3116 unsigned NumClauses = Record[ASTStmtReader::NumStmtFields]; 3117 unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1]; 3118 S = OMPTeamsDistributeSimdDirective::CreateEmpty(Context, NumClauses, 3119 CollapsedNum, Empty); 3120 break; 3121 } 3122 3123 case STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE: { 3124 auto NumClauses = Record[ASTStmtReader::NumStmtFields]; 3125 auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1]; 3126 S = OMPTeamsDistributeParallelForSimdDirective::CreateEmpty( 3127 Context, NumClauses, CollapsedNum, Empty); 3128 break; 3129 } 3130 3131 case STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE: { 3132 auto NumClauses = Record[ASTStmtReader::NumStmtFields]; 3133 auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1]; 3134 S = OMPTeamsDistributeParallelForDirective::CreateEmpty( 3135 Context, NumClauses, CollapsedNum, Empty); 3136 break; 3137 } 3138 3139 case STMT_OMP_TARGET_TEAMS_DIRECTIVE: 3140 S = OMPTargetTeamsDirective::CreateEmpty( 3141 Context, Record[ASTStmtReader::NumStmtFields], Empty); 3142 break; 3143 3144 case STMT_OMP_TARGET_TEAMS_DISTRIBUTE_DIRECTIVE: { 3145 auto NumClauses = Record[ASTStmtReader::NumStmtFields]; 3146 auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1]; 3147 S = OMPTargetTeamsDistributeDirective::CreateEmpty(Context, NumClauses, 3148 CollapsedNum, Empty); 3149 break; 3150 } 3151 3152 case STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE: { 3153 auto NumClauses = Record[ASTStmtReader::NumStmtFields]; 3154 auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1]; 3155 S = OMPTargetTeamsDistributeParallelForDirective::CreateEmpty( 3156 Context, NumClauses, CollapsedNum, Empty); 3157 break; 3158 } 3159 3160 case STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE: { 3161 auto NumClauses = Record[ASTStmtReader::NumStmtFields]; 3162 auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1]; 3163 S = OMPTargetTeamsDistributeParallelForSimdDirective::CreateEmpty( 3164 Context, NumClauses, CollapsedNum, Empty); 3165 break; 3166 } 3167 3168 case STMT_OMP_TARGET_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE: { 3169 auto NumClauses = Record[ASTStmtReader::NumStmtFields]; 3170 auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1]; 3171 S = OMPTargetTeamsDistributeSimdDirective::CreateEmpty( 3172 Context, NumClauses, CollapsedNum, Empty); 3173 break; 3174 } 3175 3176 case EXPR_CXX_OPERATOR_CALL: 3177 S = CXXOperatorCallExpr::CreateEmpty( 3178 Context, /*NumArgs=*/Record[ASTStmtReader::NumExprFields], Empty); 3179 break; 3180 3181 case EXPR_CXX_MEMBER_CALL: 3182 S = CXXMemberCallExpr::CreateEmpty( 3183 Context, /*NumArgs=*/Record[ASTStmtReader::NumExprFields], Empty); 3184 break; 3185 3186 case EXPR_CXX_CONSTRUCT: 3187 S = CXXConstructExpr::CreateEmpty( 3188 Context, 3189 /* NumArgs=*/Record[ASTStmtReader::NumExprFields]); 3190 break; 3191 3192 case EXPR_CXX_INHERITED_CTOR_INIT: 3193 S = new (Context) CXXInheritedCtorInitExpr(Empty); 3194 break; 3195 3196 case EXPR_CXX_TEMPORARY_OBJECT: 3197 S = CXXTemporaryObjectExpr::CreateEmpty( 3198 Context, 3199 /* NumArgs=*/Record[ASTStmtReader::NumExprFields]); 3200 break; 3201 3202 case EXPR_CXX_STATIC_CAST: 3203 S = CXXStaticCastExpr::CreateEmpty(Context, 3204 /*PathSize*/ Record[ASTStmtReader::NumExprFields]); 3205 break; 3206 3207 case EXPR_CXX_DYNAMIC_CAST: 3208 S = CXXDynamicCastExpr::CreateEmpty(Context, 3209 /*PathSize*/ Record[ASTStmtReader::NumExprFields]); 3210 break; 3211 3212 case EXPR_CXX_REINTERPRET_CAST: 3213 S = CXXReinterpretCastExpr::CreateEmpty(Context, 3214 /*PathSize*/ Record[ASTStmtReader::NumExprFields]); 3215 break; 3216 3217 case EXPR_CXX_CONST_CAST: 3218 S = CXXConstCastExpr::CreateEmpty(Context); 3219 break; 3220 3221 case EXPR_CXX_FUNCTIONAL_CAST: 3222 S = CXXFunctionalCastExpr::CreateEmpty(Context, 3223 /*PathSize*/ Record[ASTStmtReader::NumExprFields]); 3224 break; 3225 3226 case EXPR_USER_DEFINED_LITERAL: 3227 S = UserDefinedLiteral::CreateEmpty( 3228 Context, /*NumArgs=*/Record[ASTStmtReader::NumExprFields], Empty); 3229 break; 3230 3231 case EXPR_CXX_STD_INITIALIZER_LIST: 3232 S = new (Context) CXXStdInitializerListExpr(Empty); 3233 break; 3234 3235 case EXPR_CXX_BOOL_LITERAL: 3236 S = new (Context) CXXBoolLiteralExpr(Empty); 3237 break; 3238 3239 case EXPR_CXX_NULL_PTR_LITERAL: 3240 S = new (Context) CXXNullPtrLiteralExpr(Empty); 3241 break; 3242 3243 case EXPR_CXX_TYPEID_EXPR: 3244 S = new (Context) CXXTypeidExpr(Empty, true); 3245 break; 3246 3247 case EXPR_CXX_TYPEID_TYPE: 3248 S = new (Context) CXXTypeidExpr(Empty, false); 3249 break; 3250 3251 case EXPR_CXX_UUIDOF_EXPR: 3252 S = new (Context) CXXUuidofExpr(Empty, true); 3253 break; 3254 3255 case EXPR_CXX_PROPERTY_REF_EXPR: 3256 S = new (Context) MSPropertyRefExpr(Empty); 3257 break; 3258 3259 case EXPR_CXX_PROPERTY_SUBSCRIPT_EXPR: 3260 S = new (Context) MSPropertySubscriptExpr(Empty); 3261 break; 3262 3263 case EXPR_CXX_UUIDOF_TYPE: 3264 S = new (Context) CXXUuidofExpr(Empty, false); 3265 break; 3266 3267 case EXPR_CXX_THIS: 3268 S = new (Context) CXXThisExpr(Empty); 3269 break; 3270 3271 case EXPR_CXX_THROW: 3272 S = new (Context) CXXThrowExpr(Empty); 3273 break; 3274 3275 case EXPR_CXX_DEFAULT_ARG: 3276 S = new (Context) CXXDefaultArgExpr(Empty); 3277 break; 3278 3279 case EXPR_CXX_DEFAULT_INIT: 3280 S = new (Context) CXXDefaultInitExpr(Empty); 3281 break; 3282 3283 case EXPR_CXX_BIND_TEMPORARY: 3284 S = new (Context) CXXBindTemporaryExpr(Empty); 3285 break; 3286 3287 case EXPR_CXX_SCALAR_VALUE_INIT: 3288 S = new (Context) CXXScalarValueInitExpr(Empty); 3289 break; 3290 3291 case EXPR_CXX_NEW: 3292 S = CXXNewExpr::CreateEmpty( 3293 Context, 3294 /*IsArray=*/Record[ASTStmtReader::NumExprFields], 3295 /*HasInit=*/Record[ASTStmtReader::NumExprFields + 1], 3296 /*NumPlacementArgs=*/Record[ASTStmtReader::NumExprFields + 2], 3297 /*IsParenTypeId=*/Record[ASTStmtReader::NumExprFields + 3]); 3298 break; 3299 3300 case EXPR_CXX_DELETE: 3301 S = new (Context) CXXDeleteExpr(Empty); 3302 break; 3303 3304 case EXPR_CXX_PSEUDO_DESTRUCTOR: 3305 S = new (Context) CXXPseudoDestructorExpr(Empty); 3306 break; 3307 3308 case EXPR_EXPR_WITH_CLEANUPS: 3309 S = ExprWithCleanups::Create(Context, Empty, 3310 Record[ASTStmtReader::NumExprFields]); 3311 break; 3312 3313 case EXPR_CXX_DEPENDENT_SCOPE_MEMBER: 3314 S = CXXDependentScopeMemberExpr::CreateEmpty( 3315 Context, 3316 /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields], 3317 /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields + 1], 3318 /*HasFirstQualifierFoundInScope=*/ 3319 Record[ASTStmtReader::NumExprFields + 2]); 3320 break; 3321 3322 case EXPR_CXX_DEPENDENT_SCOPE_DECL_REF: 3323 S = DependentScopeDeclRefExpr::CreateEmpty(Context, 3324 /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields], 3325 /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields] 3326 ? Record[ASTStmtReader::NumExprFields + 1] 3327 : 0); 3328 break; 3329 3330 case EXPR_CXX_UNRESOLVED_CONSTRUCT: 3331 S = CXXUnresolvedConstructExpr::CreateEmpty(Context, 3332 /*NumArgs=*/Record[ASTStmtReader::NumExprFields]); 3333 break; 3334 3335 case EXPR_CXX_UNRESOLVED_MEMBER: 3336 S = UnresolvedMemberExpr::CreateEmpty( 3337 Context, 3338 /*NumResults=*/Record[ASTStmtReader::NumExprFields], 3339 /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields + 1], 3340 /*NumTemplateArgs=*/ 3341 Record[ASTStmtReader::NumExprFields + 1] 3342 ? Record[ASTStmtReader::NumExprFields + 2] 3343 : 0); 3344 break; 3345 3346 case EXPR_CXX_UNRESOLVED_LOOKUP: 3347 S = UnresolvedLookupExpr::CreateEmpty( 3348 Context, 3349 /*NumResults=*/Record[ASTStmtReader::NumExprFields], 3350 /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields + 1], 3351 /*NumTemplateArgs=*/ 3352 Record[ASTStmtReader::NumExprFields + 1] 3353 ? Record[ASTStmtReader::NumExprFields + 2] 3354 : 0); 3355 break; 3356 3357 case EXPR_TYPE_TRAIT: 3358 S = TypeTraitExpr::CreateDeserialized(Context, 3359 Record[ASTStmtReader::NumExprFields]); 3360 break; 3361 3362 case EXPR_ARRAY_TYPE_TRAIT: 3363 S = new (Context) ArrayTypeTraitExpr(Empty); 3364 break; 3365 3366 case EXPR_CXX_EXPRESSION_TRAIT: 3367 S = new (Context) ExpressionTraitExpr(Empty); 3368 break; 3369 3370 case EXPR_CXX_NOEXCEPT: 3371 S = new (Context) CXXNoexceptExpr(Empty); 3372 break; 3373 3374 case EXPR_PACK_EXPANSION: 3375 S = new (Context) PackExpansionExpr(Empty); 3376 break; 3377 3378 case EXPR_SIZEOF_PACK: 3379 S = SizeOfPackExpr::CreateDeserialized( 3380 Context, 3381 /*NumPartialArgs=*/Record[ASTStmtReader::NumExprFields]); 3382 break; 3383 3384 case EXPR_SUBST_NON_TYPE_TEMPLATE_PARM: 3385 S = new (Context) SubstNonTypeTemplateParmExpr(Empty); 3386 break; 3387 3388 case EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK: 3389 S = new (Context) SubstNonTypeTemplateParmPackExpr(Empty); 3390 break; 3391 3392 case EXPR_FUNCTION_PARM_PACK: 3393 S = FunctionParmPackExpr::CreateEmpty(Context, 3394 Record[ASTStmtReader::NumExprFields]); 3395 break; 3396 3397 case EXPR_MATERIALIZE_TEMPORARY: 3398 S = new (Context) MaterializeTemporaryExpr(Empty); 3399 break; 3400 3401 case EXPR_CXX_FOLD: 3402 S = new (Context) CXXFoldExpr(Empty); 3403 break; 3404 3405 case EXPR_OPAQUE_VALUE: 3406 S = new (Context) OpaqueValueExpr(Empty); 3407 break; 3408 3409 case EXPR_CUDA_KERNEL_CALL: 3410 S = CUDAKernelCallExpr::CreateEmpty( 3411 Context, /*NumArgs=*/Record[ASTStmtReader::NumExprFields], Empty); 3412 break; 3413 3414 case EXPR_ASTYPE: 3415 S = new (Context) AsTypeExpr(Empty); 3416 break; 3417 3418 case EXPR_PSEUDO_OBJECT: { 3419 unsigned numSemanticExprs = Record[ASTStmtReader::NumExprFields]; 3420 S = PseudoObjectExpr::Create(Context, Empty, numSemanticExprs); 3421 break; 3422 } 3423 3424 case EXPR_ATOMIC: 3425 S = new (Context) AtomicExpr(Empty); 3426 break; 3427 3428 case EXPR_LAMBDA: { 3429 unsigned NumCaptures = Record[ASTStmtReader::NumExprFields]; 3430 S = LambdaExpr::CreateDeserialized(Context, NumCaptures); 3431 break; 3432 } 3433 3434 case STMT_COROUTINE_BODY: { 3435 unsigned NumParams = Record[ASTStmtReader::NumStmtFields]; 3436 S = CoroutineBodyStmt::Create(Context, Empty, NumParams); 3437 break; 3438 } 3439 3440 case STMT_CORETURN: 3441 S = new (Context) CoreturnStmt(Empty); 3442 break; 3443 3444 case EXPR_COAWAIT: 3445 S = new (Context) CoawaitExpr(Empty); 3446 break; 3447 3448 case EXPR_COYIELD: 3449 S = new (Context) CoyieldExpr(Empty); 3450 break; 3451 3452 case EXPR_DEPENDENT_COAWAIT: 3453 S = new (Context) DependentCoawaitExpr(Empty); 3454 break; 3455 } 3456 3457 // We hit a STMT_STOP, so we're done with this expression. 3458 if (Finished) 3459 break; 3460 3461 ++NumStatementsRead; 3462 3463 if (S && !IsStmtReference) { 3464 Reader.Visit(S); 3465 StmtEntries[Cursor.GetCurrentBitNo()] = S; 3466 } 3467 3468 assert(Record.getIdx() == Record.size() && 3469 "Invalid deserialization of statement"); 3470 StmtStack.push_back(S); 3471 } 3472 Done: 3473 assert(StmtStack.size() > PrevNumStmts && "Read too many sub-stmts!"); 3474 assert(StmtStack.size() == PrevNumStmts + 1 && "Extra expressions on stack!"); 3475 return StmtStack.pop_back_val(); 3476 } 3477