1 //===--- ASTWriterStmt.cpp - Statement and Expression Serialization -------===// 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 /// \file 10 /// Implements serialization for Statements and Expressions. 11 /// 12 //===----------------------------------------------------------------------===// 13 14 #include "clang/Serialization/ASTWriter.h" 15 #include "clang/AST/ASTContext.h" 16 #include "clang/AST/DeclCXX.h" 17 #include "clang/AST/DeclObjC.h" 18 #include "clang/AST/DeclTemplate.h" 19 #include "clang/AST/StmtVisitor.h" 20 #include "clang/Lex/Token.h" 21 #include "llvm/Bitstream/BitstreamWriter.h" 22 using namespace clang; 23 24 //===----------------------------------------------------------------------===// 25 // Statement/expression serialization 26 //===----------------------------------------------------------------------===// 27 28 namespace clang { 29 30 class ASTStmtWriter : public StmtVisitor<ASTStmtWriter, void> { 31 ASTWriter &Writer; 32 ASTRecordWriter Record; 33 34 serialization::StmtCode Code; 35 unsigned AbbrevToUse; 36 37 public: 38 ASTStmtWriter(ASTWriter &Writer, ASTWriter::RecordData &Record) 39 : Writer(Writer), Record(Writer, Record), 40 Code(serialization::STMT_NULL_PTR), AbbrevToUse(0) {} 41 42 ASTStmtWriter(const ASTStmtWriter&) = delete; 43 44 uint64_t Emit() { 45 assert(Code != serialization::STMT_NULL_PTR && 46 "unhandled sub-statement writing AST file"); 47 return Record.EmitStmt(Code, AbbrevToUse); 48 } 49 50 void AddTemplateKWAndArgsInfo(const ASTTemplateKWAndArgsInfo &ArgInfo, 51 const TemplateArgumentLoc *Args); 52 53 void VisitStmt(Stmt *S); 54 #define STMT(Type, Base) \ 55 void Visit##Type(Type *); 56 #include "clang/AST/StmtNodes.inc" 57 }; 58 } 59 60 void ASTStmtWriter::AddTemplateKWAndArgsInfo( 61 const ASTTemplateKWAndArgsInfo &ArgInfo, const TemplateArgumentLoc *Args) { 62 Record.AddSourceLocation(ArgInfo.TemplateKWLoc); 63 Record.AddSourceLocation(ArgInfo.LAngleLoc); 64 Record.AddSourceLocation(ArgInfo.RAngleLoc); 65 for (unsigned i = 0; i != ArgInfo.NumTemplateArgs; ++i) 66 Record.AddTemplateArgumentLoc(Args[i]); 67 } 68 69 void ASTStmtWriter::VisitStmt(Stmt *S) { 70 Record.push_back(S->StmtBits.IsOMPStructuredBlock); 71 } 72 73 void ASTStmtWriter::VisitNullStmt(NullStmt *S) { 74 VisitStmt(S); 75 Record.AddSourceLocation(S->getSemiLoc()); 76 Record.push_back(S->NullStmtBits.HasLeadingEmptyMacro); 77 Code = serialization::STMT_NULL; 78 } 79 80 void ASTStmtWriter::VisitCompoundStmt(CompoundStmt *S) { 81 VisitStmt(S); 82 Record.push_back(S->size()); 83 for (auto *CS : S->body()) 84 Record.AddStmt(CS); 85 Record.AddSourceLocation(S->getLBracLoc()); 86 Record.AddSourceLocation(S->getRBracLoc()); 87 Code = serialization::STMT_COMPOUND; 88 } 89 90 void ASTStmtWriter::VisitSwitchCase(SwitchCase *S) { 91 VisitStmt(S); 92 Record.push_back(Writer.getSwitchCaseID(S)); 93 Record.AddSourceLocation(S->getKeywordLoc()); 94 Record.AddSourceLocation(S->getColonLoc()); 95 } 96 97 void ASTStmtWriter::VisitCaseStmt(CaseStmt *S) { 98 VisitSwitchCase(S); 99 Record.push_back(S->caseStmtIsGNURange()); 100 Record.AddStmt(S->getLHS()); 101 Record.AddStmt(S->getSubStmt()); 102 if (S->caseStmtIsGNURange()) { 103 Record.AddStmt(S->getRHS()); 104 Record.AddSourceLocation(S->getEllipsisLoc()); 105 } 106 Code = serialization::STMT_CASE; 107 } 108 109 void ASTStmtWriter::VisitDefaultStmt(DefaultStmt *S) { 110 VisitSwitchCase(S); 111 Record.AddStmt(S->getSubStmt()); 112 Code = serialization::STMT_DEFAULT; 113 } 114 115 void ASTStmtWriter::VisitLabelStmt(LabelStmt *S) { 116 VisitStmt(S); 117 Record.AddDeclRef(S->getDecl()); 118 Record.AddStmt(S->getSubStmt()); 119 Record.AddSourceLocation(S->getIdentLoc()); 120 Code = serialization::STMT_LABEL; 121 } 122 123 void ASTStmtWriter::VisitAttributedStmt(AttributedStmt *S) { 124 VisitStmt(S); 125 Record.push_back(S->getAttrs().size()); 126 Record.AddAttributes(S->getAttrs()); 127 Record.AddStmt(S->getSubStmt()); 128 Record.AddSourceLocation(S->getAttrLoc()); 129 Code = serialization::STMT_ATTRIBUTED; 130 } 131 132 void ASTStmtWriter::VisitIfStmt(IfStmt *S) { 133 VisitStmt(S); 134 135 bool HasElse = S->getElse() != nullptr; 136 bool HasVar = S->getConditionVariableDeclStmt() != nullptr; 137 bool HasInit = S->getInit() != nullptr; 138 139 Record.push_back(S->isConstexpr()); 140 Record.push_back(HasElse); 141 Record.push_back(HasVar); 142 Record.push_back(HasInit); 143 144 Record.AddStmt(S->getCond()); 145 Record.AddStmt(S->getThen()); 146 if (HasElse) 147 Record.AddStmt(S->getElse()); 148 if (HasVar) 149 Record.AddDeclRef(S->getConditionVariable()); 150 if (HasInit) 151 Record.AddStmt(S->getInit()); 152 153 Record.AddSourceLocation(S->getIfLoc()); 154 if (HasElse) 155 Record.AddSourceLocation(S->getElseLoc()); 156 157 Code = serialization::STMT_IF; 158 } 159 160 void ASTStmtWriter::VisitSwitchStmt(SwitchStmt *S) { 161 VisitStmt(S); 162 163 bool HasInit = S->getInit() != nullptr; 164 bool HasVar = S->getConditionVariableDeclStmt() != nullptr; 165 Record.push_back(HasInit); 166 Record.push_back(HasVar); 167 Record.push_back(S->isAllEnumCasesCovered()); 168 169 Record.AddStmt(S->getCond()); 170 Record.AddStmt(S->getBody()); 171 if (HasInit) 172 Record.AddStmt(S->getInit()); 173 if (HasVar) 174 Record.AddDeclRef(S->getConditionVariable()); 175 176 Record.AddSourceLocation(S->getSwitchLoc()); 177 178 for (SwitchCase *SC = S->getSwitchCaseList(); SC; 179 SC = SC->getNextSwitchCase()) 180 Record.push_back(Writer.RecordSwitchCaseID(SC)); 181 Code = serialization::STMT_SWITCH; 182 } 183 184 void ASTStmtWriter::VisitWhileStmt(WhileStmt *S) { 185 VisitStmt(S); 186 187 bool HasVar = S->getConditionVariableDeclStmt() != nullptr; 188 Record.push_back(HasVar); 189 190 Record.AddStmt(S->getCond()); 191 Record.AddStmt(S->getBody()); 192 if (HasVar) 193 Record.AddDeclRef(S->getConditionVariable()); 194 195 Record.AddSourceLocation(S->getWhileLoc()); 196 Code = serialization::STMT_WHILE; 197 } 198 199 void ASTStmtWriter::VisitDoStmt(DoStmt *S) { 200 VisitStmt(S); 201 Record.AddStmt(S->getCond()); 202 Record.AddStmt(S->getBody()); 203 Record.AddSourceLocation(S->getDoLoc()); 204 Record.AddSourceLocation(S->getWhileLoc()); 205 Record.AddSourceLocation(S->getRParenLoc()); 206 Code = serialization::STMT_DO; 207 } 208 209 void ASTStmtWriter::VisitForStmt(ForStmt *S) { 210 VisitStmt(S); 211 Record.AddStmt(S->getInit()); 212 Record.AddStmt(S->getCond()); 213 Record.AddDeclRef(S->getConditionVariable()); 214 Record.AddStmt(S->getInc()); 215 Record.AddStmt(S->getBody()); 216 Record.AddSourceLocation(S->getForLoc()); 217 Record.AddSourceLocation(S->getLParenLoc()); 218 Record.AddSourceLocation(S->getRParenLoc()); 219 Code = serialization::STMT_FOR; 220 } 221 222 void ASTStmtWriter::VisitGotoStmt(GotoStmt *S) { 223 VisitStmt(S); 224 Record.AddDeclRef(S->getLabel()); 225 Record.AddSourceLocation(S->getGotoLoc()); 226 Record.AddSourceLocation(S->getLabelLoc()); 227 Code = serialization::STMT_GOTO; 228 } 229 230 void ASTStmtWriter::VisitIndirectGotoStmt(IndirectGotoStmt *S) { 231 VisitStmt(S); 232 Record.AddSourceLocation(S->getGotoLoc()); 233 Record.AddSourceLocation(S->getStarLoc()); 234 Record.AddStmt(S->getTarget()); 235 Code = serialization::STMT_INDIRECT_GOTO; 236 } 237 238 void ASTStmtWriter::VisitContinueStmt(ContinueStmt *S) { 239 VisitStmt(S); 240 Record.AddSourceLocation(S->getContinueLoc()); 241 Code = serialization::STMT_CONTINUE; 242 } 243 244 void ASTStmtWriter::VisitBreakStmt(BreakStmt *S) { 245 VisitStmt(S); 246 Record.AddSourceLocation(S->getBreakLoc()); 247 Code = serialization::STMT_BREAK; 248 } 249 250 void ASTStmtWriter::VisitReturnStmt(ReturnStmt *S) { 251 VisitStmt(S); 252 253 bool HasNRVOCandidate = S->getNRVOCandidate() != nullptr; 254 Record.push_back(HasNRVOCandidate); 255 256 Record.AddStmt(S->getRetValue()); 257 if (HasNRVOCandidate) 258 Record.AddDeclRef(S->getNRVOCandidate()); 259 260 Record.AddSourceLocation(S->getReturnLoc()); 261 Code = serialization::STMT_RETURN; 262 } 263 264 void ASTStmtWriter::VisitDeclStmt(DeclStmt *S) { 265 VisitStmt(S); 266 Record.AddSourceLocation(S->getBeginLoc()); 267 Record.AddSourceLocation(S->getEndLoc()); 268 DeclGroupRef DG = S->getDeclGroup(); 269 for (DeclGroupRef::iterator D = DG.begin(), DEnd = DG.end(); D != DEnd; ++D) 270 Record.AddDeclRef(*D); 271 Code = serialization::STMT_DECL; 272 } 273 274 void ASTStmtWriter::VisitAsmStmt(AsmStmt *S) { 275 VisitStmt(S); 276 Record.push_back(S->getNumOutputs()); 277 Record.push_back(S->getNumInputs()); 278 Record.push_back(S->getNumClobbers()); 279 Record.AddSourceLocation(S->getAsmLoc()); 280 Record.push_back(S->isVolatile()); 281 Record.push_back(S->isSimple()); 282 } 283 284 void ASTStmtWriter::VisitGCCAsmStmt(GCCAsmStmt *S) { 285 VisitAsmStmt(S); 286 Record.push_back(S->getNumLabels()); 287 Record.AddSourceLocation(S->getRParenLoc()); 288 Record.AddStmt(S->getAsmString()); 289 290 // Outputs 291 for (unsigned I = 0, N = S->getNumOutputs(); I != N; ++I) { 292 Record.AddIdentifierRef(S->getOutputIdentifier(I)); 293 Record.AddStmt(S->getOutputConstraintLiteral(I)); 294 Record.AddStmt(S->getOutputExpr(I)); 295 } 296 297 // Inputs 298 for (unsigned I = 0, N = S->getNumInputs(); I != N; ++I) { 299 Record.AddIdentifierRef(S->getInputIdentifier(I)); 300 Record.AddStmt(S->getInputConstraintLiteral(I)); 301 Record.AddStmt(S->getInputExpr(I)); 302 } 303 304 // Clobbers 305 for (unsigned I = 0, N = S->getNumClobbers(); I != N; ++I) 306 Record.AddStmt(S->getClobberStringLiteral(I)); 307 308 // Labels 309 for (auto *E : S->labels()) Record.AddStmt(E); 310 311 Code = serialization::STMT_GCCASM; 312 } 313 314 void ASTStmtWriter::VisitMSAsmStmt(MSAsmStmt *S) { 315 VisitAsmStmt(S); 316 Record.AddSourceLocation(S->getLBraceLoc()); 317 Record.AddSourceLocation(S->getEndLoc()); 318 Record.push_back(S->getNumAsmToks()); 319 Record.AddString(S->getAsmString()); 320 321 // Tokens 322 for (unsigned I = 0, N = S->getNumAsmToks(); I != N; ++I) { 323 // FIXME: Move this to ASTRecordWriter? 324 Writer.AddToken(S->getAsmToks()[I], Record.getRecordData()); 325 } 326 327 // Clobbers 328 for (unsigned I = 0, N = S->getNumClobbers(); I != N; ++I) { 329 Record.AddString(S->getClobber(I)); 330 } 331 332 // Outputs 333 for (unsigned I = 0, N = S->getNumOutputs(); I != N; ++I) { 334 Record.AddStmt(S->getOutputExpr(I)); 335 Record.AddString(S->getOutputConstraint(I)); 336 } 337 338 // Inputs 339 for (unsigned I = 0, N = S->getNumInputs(); I != N; ++I) { 340 Record.AddStmt(S->getInputExpr(I)); 341 Record.AddString(S->getInputConstraint(I)); 342 } 343 344 Code = serialization::STMT_MSASM; 345 } 346 347 void ASTStmtWriter::VisitCoroutineBodyStmt(CoroutineBodyStmt *CoroStmt) { 348 VisitStmt(CoroStmt); 349 Record.push_back(CoroStmt->getParamMoves().size()); 350 for (Stmt *S : CoroStmt->children()) 351 Record.AddStmt(S); 352 Code = serialization::STMT_COROUTINE_BODY; 353 } 354 355 void ASTStmtWriter::VisitCoreturnStmt(CoreturnStmt *S) { 356 VisitStmt(S); 357 Record.AddSourceLocation(S->getKeywordLoc()); 358 Record.AddStmt(S->getOperand()); 359 Record.AddStmt(S->getPromiseCall()); 360 Record.push_back(S->isImplicit()); 361 Code = serialization::STMT_CORETURN; 362 } 363 364 void ASTStmtWriter::VisitCoroutineSuspendExpr(CoroutineSuspendExpr *E) { 365 VisitExpr(E); 366 Record.AddSourceLocation(E->getKeywordLoc()); 367 for (Stmt *S : E->children()) 368 Record.AddStmt(S); 369 Record.AddStmt(E->getOpaqueValue()); 370 } 371 372 void ASTStmtWriter::VisitCoawaitExpr(CoawaitExpr *E) { 373 VisitCoroutineSuspendExpr(E); 374 Record.push_back(E->isImplicit()); 375 Code = serialization::EXPR_COAWAIT; 376 } 377 378 void ASTStmtWriter::VisitCoyieldExpr(CoyieldExpr *E) { 379 VisitCoroutineSuspendExpr(E); 380 Code = serialization::EXPR_COYIELD; 381 } 382 383 void ASTStmtWriter::VisitDependentCoawaitExpr(DependentCoawaitExpr *E) { 384 VisitExpr(E); 385 Record.AddSourceLocation(E->getKeywordLoc()); 386 for (Stmt *S : E->children()) 387 Record.AddStmt(S); 388 Code = serialization::EXPR_DEPENDENT_COAWAIT; 389 } 390 391 void ASTStmtWriter::VisitConceptSpecializationExpr( 392 ConceptSpecializationExpr *E) { 393 VisitExpr(E); 394 ArrayRef<TemplateArgument> TemplateArgs = E->getTemplateArguments(); 395 Record.push_back(TemplateArgs.size()); 396 Record.AddNestedNameSpecifierLoc(E->getNestedNameSpecifierLoc()); 397 Record.AddSourceLocation(E->getTemplateKWLoc()); 398 Record.AddSourceLocation(E->getConceptNameLoc()); 399 Record.AddDeclRef(E->getFoundDecl()); 400 Record.AddDeclRef(E->getNamedConcept()); 401 Record.AddASTTemplateArgumentListInfo(E->getTemplateArgsAsWritten()); 402 for (const TemplateArgument &Arg : TemplateArgs) 403 Record.AddTemplateArgument(Arg); 404 const ASTConstraintSatisfaction &Satisfaction = E->getSatisfaction(); 405 Record.push_back(Satisfaction.IsSatisfied); 406 if (!Satisfaction.IsSatisfied) { 407 Record.push_back(Satisfaction.NumRecords); 408 for (const auto &DetailRecord : Satisfaction) { 409 Record.AddStmt(const_cast<Expr *>(DetailRecord.first)); 410 auto *E = DetailRecord.second.dyn_cast<Expr *>(); 411 Record.push_back(E == nullptr); 412 if (E) 413 Record.AddStmt(E); 414 else { 415 auto *Diag = DetailRecord.second.get<std::pair<SourceLocation, 416 StringRef> *>(); 417 Record.AddSourceLocation(Diag->first); 418 Record.AddString(Diag->second); 419 } 420 } 421 } 422 423 Code = serialization::EXPR_CONCEPT_SPECIALIZATION; 424 } 425 426 427 void ASTStmtWriter::VisitCapturedStmt(CapturedStmt *S) { 428 VisitStmt(S); 429 // NumCaptures 430 Record.push_back(std::distance(S->capture_begin(), S->capture_end())); 431 432 // CapturedDecl and captured region kind 433 Record.AddDeclRef(S->getCapturedDecl()); 434 Record.push_back(S->getCapturedRegionKind()); 435 436 Record.AddDeclRef(S->getCapturedRecordDecl()); 437 438 // Capture inits 439 for (auto *I : S->capture_inits()) 440 Record.AddStmt(I); 441 442 // Body 443 Record.AddStmt(S->getCapturedStmt()); 444 445 // Captures 446 for (const auto &I : S->captures()) { 447 if (I.capturesThis() || I.capturesVariableArrayType()) 448 Record.AddDeclRef(nullptr); 449 else 450 Record.AddDeclRef(I.getCapturedVar()); 451 Record.push_back(I.getCaptureKind()); 452 Record.AddSourceLocation(I.getLocation()); 453 } 454 455 Code = serialization::STMT_CAPTURED; 456 } 457 458 void ASTStmtWriter::VisitExpr(Expr *E) { 459 VisitStmt(E); 460 Record.AddTypeRef(E->getType()); 461 Record.push_back(E->isTypeDependent()); 462 Record.push_back(E->isValueDependent()); 463 Record.push_back(E->isInstantiationDependent()); 464 Record.push_back(E->containsUnexpandedParameterPack()); 465 Record.push_back(E->getValueKind()); 466 Record.push_back(E->getObjectKind()); 467 } 468 469 void ASTStmtWriter::VisitConstantExpr(ConstantExpr *E) { 470 VisitExpr(E); 471 Record.push_back(static_cast<uint64_t>(E->ConstantExprBits.ResultKind)); 472 switch (E->ConstantExprBits.ResultKind) { 473 case ConstantExpr::RSK_Int64: 474 Record.push_back(E->Int64Result()); 475 Record.push_back(E->ConstantExprBits.IsUnsigned | 476 E->ConstantExprBits.BitWidth << 1); 477 break; 478 case ConstantExpr::RSK_APValue: 479 Record.AddAPValue(E->APValueResult()); 480 } 481 Record.AddStmt(E->getSubExpr()); 482 Code = serialization::EXPR_CONSTANT; 483 } 484 485 void ASTStmtWriter::VisitPredefinedExpr(PredefinedExpr *E) { 486 VisitExpr(E); 487 488 bool HasFunctionName = E->getFunctionName() != nullptr; 489 Record.push_back(HasFunctionName); 490 Record.push_back(E->getIdentKind()); // FIXME: stable encoding 491 Record.AddSourceLocation(E->getLocation()); 492 if (HasFunctionName) 493 Record.AddStmt(E->getFunctionName()); 494 Code = serialization::EXPR_PREDEFINED; 495 } 496 497 void ASTStmtWriter::VisitDeclRefExpr(DeclRefExpr *E) { 498 VisitExpr(E); 499 500 Record.push_back(E->hasQualifier()); 501 Record.push_back(E->getDecl() != E->getFoundDecl()); 502 Record.push_back(E->hasTemplateKWAndArgsInfo()); 503 Record.push_back(E->hadMultipleCandidates()); 504 Record.push_back(E->refersToEnclosingVariableOrCapture()); 505 Record.push_back(E->isNonOdrUse()); 506 507 if (E->hasTemplateKWAndArgsInfo()) { 508 unsigned NumTemplateArgs = E->getNumTemplateArgs(); 509 Record.push_back(NumTemplateArgs); 510 } 511 512 DeclarationName::NameKind nk = (E->getDecl()->getDeclName().getNameKind()); 513 514 if ((!E->hasTemplateKWAndArgsInfo()) && (!E->hasQualifier()) && 515 (E->getDecl() == E->getFoundDecl()) && 516 nk == DeclarationName::Identifier && 517 !E->refersToEnclosingVariableOrCapture() && !E->isNonOdrUse()) { 518 AbbrevToUse = Writer.getDeclRefExprAbbrev(); 519 } 520 521 if (E->hasQualifier()) 522 Record.AddNestedNameSpecifierLoc(E->getQualifierLoc()); 523 524 if (E->getDecl() != E->getFoundDecl()) 525 Record.AddDeclRef(E->getFoundDecl()); 526 527 if (E->hasTemplateKWAndArgsInfo()) 528 AddTemplateKWAndArgsInfo(*E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(), 529 E->getTrailingObjects<TemplateArgumentLoc>()); 530 531 Record.AddDeclRef(E->getDecl()); 532 Record.AddSourceLocation(E->getLocation()); 533 Record.AddDeclarationNameLoc(E->DNLoc, E->getDecl()->getDeclName()); 534 Code = serialization::EXPR_DECL_REF; 535 } 536 537 void ASTStmtWriter::VisitIntegerLiteral(IntegerLiteral *E) { 538 VisitExpr(E); 539 Record.AddSourceLocation(E->getLocation()); 540 Record.AddAPInt(E->getValue()); 541 542 if (E->getValue().getBitWidth() == 32) { 543 AbbrevToUse = Writer.getIntegerLiteralAbbrev(); 544 } 545 546 Code = serialization::EXPR_INTEGER_LITERAL; 547 } 548 549 void ASTStmtWriter::VisitFixedPointLiteral(FixedPointLiteral *E) { 550 VisitExpr(E); 551 Record.AddSourceLocation(E->getLocation()); 552 Record.AddAPInt(E->getValue()); 553 Code = serialization::EXPR_INTEGER_LITERAL; 554 } 555 556 void ASTStmtWriter::VisitFloatingLiteral(FloatingLiteral *E) { 557 VisitExpr(E); 558 Record.push_back(E->getRawSemantics()); 559 Record.push_back(E->isExact()); 560 Record.AddAPFloat(E->getValue()); 561 Record.AddSourceLocation(E->getLocation()); 562 Code = serialization::EXPR_FLOATING_LITERAL; 563 } 564 565 void ASTStmtWriter::VisitImaginaryLiteral(ImaginaryLiteral *E) { 566 VisitExpr(E); 567 Record.AddStmt(E->getSubExpr()); 568 Code = serialization::EXPR_IMAGINARY_LITERAL; 569 } 570 571 void ASTStmtWriter::VisitStringLiteral(StringLiteral *E) { 572 VisitExpr(E); 573 574 // Store the various bits of data of StringLiteral. 575 Record.push_back(E->getNumConcatenated()); 576 Record.push_back(E->getLength()); 577 Record.push_back(E->getCharByteWidth()); 578 Record.push_back(E->getKind()); 579 Record.push_back(E->isPascal()); 580 581 // Store the trailing array of SourceLocation. 582 for (unsigned I = 0, N = E->getNumConcatenated(); I != N; ++I) 583 Record.AddSourceLocation(E->getStrTokenLoc(I)); 584 585 // Store the trailing array of char holding the string data. 586 StringRef StrData = E->getBytes(); 587 for (unsigned I = 0, N = E->getByteLength(); I != N; ++I) 588 Record.push_back(StrData[I]); 589 590 Code = serialization::EXPR_STRING_LITERAL; 591 } 592 593 void ASTStmtWriter::VisitCharacterLiteral(CharacterLiteral *E) { 594 VisitExpr(E); 595 Record.push_back(E->getValue()); 596 Record.AddSourceLocation(E->getLocation()); 597 Record.push_back(E->getKind()); 598 599 AbbrevToUse = Writer.getCharacterLiteralAbbrev(); 600 601 Code = serialization::EXPR_CHARACTER_LITERAL; 602 } 603 604 void ASTStmtWriter::VisitParenExpr(ParenExpr *E) { 605 VisitExpr(E); 606 Record.AddSourceLocation(E->getLParen()); 607 Record.AddSourceLocation(E->getRParen()); 608 Record.AddStmt(E->getSubExpr()); 609 Code = serialization::EXPR_PAREN; 610 } 611 612 void ASTStmtWriter::VisitParenListExpr(ParenListExpr *E) { 613 VisitExpr(E); 614 Record.push_back(E->getNumExprs()); 615 for (auto *SubStmt : E->exprs()) 616 Record.AddStmt(SubStmt); 617 Record.AddSourceLocation(E->getLParenLoc()); 618 Record.AddSourceLocation(E->getRParenLoc()); 619 Code = serialization::EXPR_PAREN_LIST; 620 } 621 622 void ASTStmtWriter::VisitUnaryOperator(UnaryOperator *E) { 623 VisitExpr(E); 624 Record.AddStmt(E->getSubExpr()); 625 Record.push_back(E->getOpcode()); // FIXME: stable encoding 626 Record.AddSourceLocation(E->getOperatorLoc()); 627 Record.push_back(E->canOverflow()); 628 Code = serialization::EXPR_UNARY_OPERATOR; 629 } 630 631 void ASTStmtWriter::VisitOffsetOfExpr(OffsetOfExpr *E) { 632 VisitExpr(E); 633 Record.push_back(E->getNumComponents()); 634 Record.push_back(E->getNumExpressions()); 635 Record.AddSourceLocation(E->getOperatorLoc()); 636 Record.AddSourceLocation(E->getRParenLoc()); 637 Record.AddTypeSourceInfo(E->getTypeSourceInfo()); 638 for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) { 639 const OffsetOfNode &ON = E->getComponent(I); 640 Record.push_back(ON.getKind()); // FIXME: Stable encoding 641 Record.AddSourceLocation(ON.getSourceRange().getBegin()); 642 Record.AddSourceLocation(ON.getSourceRange().getEnd()); 643 switch (ON.getKind()) { 644 case OffsetOfNode::Array: 645 Record.push_back(ON.getArrayExprIndex()); 646 break; 647 648 case OffsetOfNode::Field: 649 Record.AddDeclRef(ON.getField()); 650 break; 651 652 case OffsetOfNode::Identifier: 653 Record.AddIdentifierRef(ON.getFieldName()); 654 break; 655 656 case OffsetOfNode::Base: 657 Record.AddCXXBaseSpecifier(*ON.getBase()); 658 break; 659 } 660 } 661 for (unsigned I = 0, N = E->getNumExpressions(); I != N; ++I) 662 Record.AddStmt(E->getIndexExpr(I)); 663 Code = serialization::EXPR_OFFSETOF; 664 } 665 666 void ASTStmtWriter::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) { 667 VisitExpr(E); 668 Record.push_back(E->getKind()); 669 if (E->isArgumentType()) 670 Record.AddTypeSourceInfo(E->getArgumentTypeInfo()); 671 else { 672 Record.push_back(0); 673 Record.AddStmt(E->getArgumentExpr()); 674 } 675 Record.AddSourceLocation(E->getOperatorLoc()); 676 Record.AddSourceLocation(E->getRParenLoc()); 677 Code = serialization::EXPR_SIZEOF_ALIGN_OF; 678 } 679 680 void ASTStmtWriter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) { 681 VisitExpr(E); 682 Record.AddStmt(E->getLHS()); 683 Record.AddStmt(E->getRHS()); 684 Record.AddSourceLocation(E->getRBracketLoc()); 685 Code = serialization::EXPR_ARRAY_SUBSCRIPT; 686 } 687 688 void ASTStmtWriter::VisitOMPArraySectionExpr(OMPArraySectionExpr *E) { 689 VisitExpr(E); 690 Record.AddStmt(E->getBase()); 691 Record.AddStmt(E->getLowerBound()); 692 Record.AddStmt(E->getLength()); 693 Record.AddSourceLocation(E->getColonLoc()); 694 Record.AddSourceLocation(E->getRBracketLoc()); 695 Code = serialization::EXPR_OMP_ARRAY_SECTION; 696 } 697 698 void ASTStmtWriter::VisitCallExpr(CallExpr *E) { 699 VisitExpr(E); 700 Record.push_back(E->getNumArgs()); 701 Record.AddSourceLocation(E->getRParenLoc()); 702 Record.AddStmt(E->getCallee()); 703 for (CallExpr::arg_iterator Arg = E->arg_begin(), ArgEnd = E->arg_end(); 704 Arg != ArgEnd; ++Arg) 705 Record.AddStmt(*Arg); 706 Record.push_back(static_cast<unsigned>(E->getADLCallKind())); 707 Code = serialization::EXPR_CALL; 708 } 709 710 void ASTStmtWriter::VisitMemberExpr(MemberExpr *E) { 711 VisitExpr(E); 712 713 bool HasQualifier = E->hasQualifier(); 714 bool HasFoundDecl = 715 E->hasQualifierOrFoundDecl() && 716 (E->getFoundDecl().getDecl() != E->getMemberDecl() || 717 E->getFoundDecl().getAccess() != E->getMemberDecl()->getAccess()); 718 bool HasTemplateInfo = E->hasTemplateKWAndArgsInfo(); 719 unsigned NumTemplateArgs = E->getNumTemplateArgs(); 720 721 // Write these first for easy access when deserializing, as they affect the 722 // size of the MemberExpr. 723 Record.push_back(HasQualifier); 724 Record.push_back(HasFoundDecl); 725 Record.push_back(HasTemplateInfo); 726 Record.push_back(NumTemplateArgs); 727 728 Record.AddStmt(E->getBase()); 729 Record.AddDeclRef(E->getMemberDecl()); 730 Record.AddDeclarationNameLoc(E->MemberDNLoc, 731 E->getMemberDecl()->getDeclName()); 732 Record.AddSourceLocation(E->getMemberLoc()); 733 Record.push_back(E->isArrow()); 734 Record.push_back(E->hadMultipleCandidates()); 735 Record.push_back(E->isNonOdrUse()); 736 Record.AddSourceLocation(E->getOperatorLoc()); 737 738 if (HasFoundDecl) { 739 DeclAccessPair FoundDecl = E->getFoundDecl(); 740 Record.AddDeclRef(FoundDecl.getDecl()); 741 Record.push_back(FoundDecl.getAccess()); 742 } 743 744 if (HasQualifier) 745 Record.AddNestedNameSpecifierLoc(E->getQualifierLoc()); 746 747 if (HasTemplateInfo) 748 AddTemplateKWAndArgsInfo(*E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(), 749 E->getTrailingObjects<TemplateArgumentLoc>()); 750 751 Code = serialization::EXPR_MEMBER; 752 } 753 754 void ASTStmtWriter::VisitObjCIsaExpr(ObjCIsaExpr *E) { 755 VisitExpr(E); 756 Record.AddStmt(E->getBase()); 757 Record.AddSourceLocation(E->getIsaMemberLoc()); 758 Record.AddSourceLocation(E->getOpLoc()); 759 Record.push_back(E->isArrow()); 760 Code = serialization::EXPR_OBJC_ISA; 761 } 762 763 void ASTStmtWriter:: 764 VisitObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) { 765 VisitExpr(E); 766 Record.AddStmt(E->getSubExpr()); 767 Record.push_back(E->shouldCopy()); 768 Code = serialization::EXPR_OBJC_INDIRECT_COPY_RESTORE; 769 } 770 771 void ASTStmtWriter::VisitObjCBridgedCastExpr(ObjCBridgedCastExpr *E) { 772 VisitExplicitCastExpr(E); 773 Record.AddSourceLocation(E->getLParenLoc()); 774 Record.AddSourceLocation(E->getBridgeKeywordLoc()); 775 Record.push_back(E->getBridgeKind()); // FIXME: Stable encoding 776 Code = serialization::EXPR_OBJC_BRIDGED_CAST; 777 } 778 779 void ASTStmtWriter::VisitCastExpr(CastExpr *E) { 780 VisitExpr(E); 781 Record.push_back(E->path_size()); 782 Record.AddStmt(E->getSubExpr()); 783 Record.push_back(E->getCastKind()); // FIXME: stable encoding 784 785 for (CastExpr::path_iterator 786 PI = E->path_begin(), PE = E->path_end(); PI != PE; ++PI) 787 Record.AddCXXBaseSpecifier(**PI); 788 } 789 790 void ASTStmtWriter::VisitBinaryOperator(BinaryOperator *E) { 791 VisitExpr(E); 792 Record.AddStmt(E->getLHS()); 793 Record.AddStmt(E->getRHS()); 794 Record.push_back(E->getOpcode()); // FIXME: stable encoding 795 Record.AddSourceLocation(E->getOperatorLoc()); 796 Record.push_back(E->getFPFeatures().getInt()); 797 Code = serialization::EXPR_BINARY_OPERATOR; 798 } 799 800 void ASTStmtWriter::VisitCompoundAssignOperator(CompoundAssignOperator *E) { 801 VisitBinaryOperator(E); 802 Record.AddTypeRef(E->getComputationLHSType()); 803 Record.AddTypeRef(E->getComputationResultType()); 804 Code = serialization::EXPR_COMPOUND_ASSIGN_OPERATOR; 805 } 806 807 void ASTStmtWriter::VisitConditionalOperator(ConditionalOperator *E) { 808 VisitExpr(E); 809 Record.AddStmt(E->getCond()); 810 Record.AddStmt(E->getLHS()); 811 Record.AddStmt(E->getRHS()); 812 Record.AddSourceLocation(E->getQuestionLoc()); 813 Record.AddSourceLocation(E->getColonLoc()); 814 Code = serialization::EXPR_CONDITIONAL_OPERATOR; 815 } 816 817 void 818 ASTStmtWriter::VisitBinaryConditionalOperator(BinaryConditionalOperator *E) { 819 VisitExpr(E); 820 Record.AddStmt(E->getOpaqueValue()); 821 Record.AddStmt(E->getCommon()); 822 Record.AddStmt(E->getCond()); 823 Record.AddStmt(E->getTrueExpr()); 824 Record.AddStmt(E->getFalseExpr()); 825 Record.AddSourceLocation(E->getQuestionLoc()); 826 Record.AddSourceLocation(E->getColonLoc()); 827 Code = serialization::EXPR_BINARY_CONDITIONAL_OPERATOR; 828 } 829 830 void ASTStmtWriter::VisitImplicitCastExpr(ImplicitCastExpr *E) { 831 VisitCastExpr(E); 832 Record.push_back(E->isPartOfExplicitCast()); 833 834 if (E->path_size() == 0) 835 AbbrevToUse = Writer.getExprImplicitCastAbbrev(); 836 837 Code = serialization::EXPR_IMPLICIT_CAST; 838 } 839 840 void ASTStmtWriter::VisitExplicitCastExpr(ExplicitCastExpr *E) { 841 VisitCastExpr(E); 842 Record.AddTypeSourceInfo(E->getTypeInfoAsWritten()); 843 } 844 845 void ASTStmtWriter::VisitCStyleCastExpr(CStyleCastExpr *E) { 846 VisitExplicitCastExpr(E); 847 Record.AddSourceLocation(E->getLParenLoc()); 848 Record.AddSourceLocation(E->getRParenLoc()); 849 Code = serialization::EXPR_CSTYLE_CAST; 850 } 851 852 void ASTStmtWriter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) { 853 VisitExpr(E); 854 Record.AddSourceLocation(E->getLParenLoc()); 855 Record.AddTypeSourceInfo(E->getTypeSourceInfo()); 856 Record.AddStmt(E->getInitializer()); 857 Record.push_back(E->isFileScope()); 858 Code = serialization::EXPR_COMPOUND_LITERAL; 859 } 860 861 void ASTStmtWriter::VisitExtVectorElementExpr(ExtVectorElementExpr *E) { 862 VisitExpr(E); 863 Record.AddStmt(E->getBase()); 864 Record.AddIdentifierRef(&E->getAccessor()); 865 Record.AddSourceLocation(E->getAccessorLoc()); 866 Code = serialization::EXPR_EXT_VECTOR_ELEMENT; 867 } 868 869 void ASTStmtWriter::VisitInitListExpr(InitListExpr *E) { 870 VisitExpr(E); 871 // NOTE: only add the (possibly null) syntactic form. 872 // No need to serialize the isSemanticForm flag and the semantic form. 873 Record.AddStmt(E->getSyntacticForm()); 874 Record.AddSourceLocation(E->getLBraceLoc()); 875 Record.AddSourceLocation(E->getRBraceLoc()); 876 bool isArrayFiller = E->ArrayFillerOrUnionFieldInit.is<Expr*>(); 877 Record.push_back(isArrayFiller); 878 if (isArrayFiller) 879 Record.AddStmt(E->getArrayFiller()); 880 else 881 Record.AddDeclRef(E->getInitializedFieldInUnion()); 882 Record.push_back(E->hadArrayRangeDesignator()); 883 Record.push_back(E->getNumInits()); 884 if (isArrayFiller) { 885 // ArrayFiller may have filled "holes" due to designated initializer. 886 // Replace them by 0 to indicate that the filler goes in that place. 887 Expr *filler = E->getArrayFiller(); 888 for (unsigned I = 0, N = E->getNumInits(); I != N; ++I) 889 Record.AddStmt(E->getInit(I) != filler ? E->getInit(I) : nullptr); 890 } else { 891 for (unsigned I = 0, N = E->getNumInits(); I != N; ++I) 892 Record.AddStmt(E->getInit(I)); 893 } 894 Code = serialization::EXPR_INIT_LIST; 895 } 896 897 void ASTStmtWriter::VisitDesignatedInitExpr(DesignatedInitExpr *E) { 898 VisitExpr(E); 899 Record.push_back(E->getNumSubExprs()); 900 for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I) 901 Record.AddStmt(E->getSubExpr(I)); 902 Record.AddSourceLocation(E->getEqualOrColonLoc()); 903 Record.push_back(E->usesGNUSyntax()); 904 for (const DesignatedInitExpr::Designator &D : E->designators()) { 905 if (D.isFieldDesignator()) { 906 if (FieldDecl *Field = D.getField()) { 907 Record.push_back(serialization::DESIG_FIELD_DECL); 908 Record.AddDeclRef(Field); 909 } else { 910 Record.push_back(serialization::DESIG_FIELD_NAME); 911 Record.AddIdentifierRef(D.getFieldName()); 912 } 913 Record.AddSourceLocation(D.getDotLoc()); 914 Record.AddSourceLocation(D.getFieldLoc()); 915 } else if (D.isArrayDesignator()) { 916 Record.push_back(serialization::DESIG_ARRAY); 917 Record.push_back(D.getFirstExprIndex()); 918 Record.AddSourceLocation(D.getLBracketLoc()); 919 Record.AddSourceLocation(D.getRBracketLoc()); 920 } else { 921 assert(D.isArrayRangeDesignator() && "Unknown designator"); 922 Record.push_back(serialization::DESIG_ARRAY_RANGE); 923 Record.push_back(D.getFirstExprIndex()); 924 Record.AddSourceLocation(D.getLBracketLoc()); 925 Record.AddSourceLocation(D.getEllipsisLoc()); 926 Record.AddSourceLocation(D.getRBracketLoc()); 927 } 928 } 929 Code = serialization::EXPR_DESIGNATED_INIT; 930 } 931 932 void ASTStmtWriter::VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E) { 933 VisitExpr(E); 934 Record.AddStmt(E->getBase()); 935 Record.AddStmt(E->getUpdater()); 936 Code = serialization::EXPR_DESIGNATED_INIT_UPDATE; 937 } 938 939 void ASTStmtWriter::VisitNoInitExpr(NoInitExpr *E) { 940 VisitExpr(E); 941 Code = serialization::EXPR_NO_INIT; 942 } 943 944 void ASTStmtWriter::VisitArrayInitLoopExpr(ArrayInitLoopExpr *E) { 945 VisitExpr(E); 946 Record.AddStmt(E->SubExprs[0]); 947 Record.AddStmt(E->SubExprs[1]); 948 Code = serialization::EXPR_ARRAY_INIT_LOOP; 949 } 950 951 void ASTStmtWriter::VisitArrayInitIndexExpr(ArrayInitIndexExpr *E) { 952 VisitExpr(E); 953 Code = serialization::EXPR_ARRAY_INIT_INDEX; 954 } 955 956 void ASTStmtWriter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) { 957 VisitExpr(E); 958 Code = serialization::EXPR_IMPLICIT_VALUE_INIT; 959 } 960 961 void ASTStmtWriter::VisitVAArgExpr(VAArgExpr *E) { 962 VisitExpr(E); 963 Record.AddStmt(E->getSubExpr()); 964 Record.AddTypeSourceInfo(E->getWrittenTypeInfo()); 965 Record.AddSourceLocation(E->getBuiltinLoc()); 966 Record.AddSourceLocation(E->getRParenLoc()); 967 Record.push_back(E->isMicrosoftABI()); 968 Code = serialization::EXPR_VA_ARG; 969 } 970 971 void ASTStmtWriter::VisitSourceLocExpr(SourceLocExpr *E) { 972 VisitExpr(E); 973 Record.AddDeclRef(cast_or_null<Decl>(E->getParentContext())); 974 Record.AddSourceLocation(E->getBeginLoc()); 975 Record.AddSourceLocation(E->getEndLoc()); 976 Record.push_back(E->getIdentKind()); 977 Code = serialization::EXPR_SOURCE_LOC; 978 } 979 980 void ASTStmtWriter::VisitAddrLabelExpr(AddrLabelExpr *E) { 981 VisitExpr(E); 982 Record.AddSourceLocation(E->getAmpAmpLoc()); 983 Record.AddSourceLocation(E->getLabelLoc()); 984 Record.AddDeclRef(E->getLabel()); 985 Code = serialization::EXPR_ADDR_LABEL; 986 } 987 988 void ASTStmtWriter::VisitStmtExpr(StmtExpr *E) { 989 VisitExpr(E); 990 Record.AddStmt(E->getSubStmt()); 991 Record.AddSourceLocation(E->getLParenLoc()); 992 Record.AddSourceLocation(E->getRParenLoc()); 993 Code = serialization::EXPR_STMT; 994 } 995 996 void ASTStmtWriter::VisitChooseExpr(ChooseExpr *E) { 997 VisitExpr(E); 998 Record.AddStmt(E->getCond()); 999 Record.AddStmt(E->getLHS()); 1000 Record.AddStmt(E->getRHS()); 1001 Record.AddSourceLocation(E->getBuiltinLoc()); 1002 Record.AddSourceLocation(E->getRParenLoc()); 1003 Record.push_back(E->isConditionDependent() ? false : E->isConditionTrue()); 1004 Code = serialization::EXPR_CHOOSE; 1005 } 1006 1007 void ASTStmtWriter::VisitGNUNullExpr(GNUNullExpr *E) { 1008 VisitExpr(E); 1009 Record.AddSourceLocation(E->getTokenLocation()); 1010 Code = serialization::EXPR_GNU_NULL; 1011 } 1012 1013 void ASTStmtWriter::VisitShuffleVectorExpr(ShuffleVectorExpr *E) { 1014 VisitExpr(E); 1015 Record.push_back(E->getNumSubExprs()); 1016 for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I) 1017 Record.AddStmt(E->getExpr(I)); 1018 Record.AddSourceLocation(E->getBuiltinLoc()); 1019 Record.AddSourceLocation(E->getRParenLoc()); 1020 Code = serialization::EXPR_SHUFFLE_VECTOR; 1021 } 1022 1023 void ASTStmtWriter::VisitConvertVectorExpr(ConvertVectorExpr *E) { 1024 VisitExpr(E); 1025 Record.AddSourceLocation(E->getBuiltinLoc()); 1026 Record.AddSourceLocation(E->getRParenLoc()); 1027 Record.AddTypeSourceInfo(E->getTypeSourceInfo()); 1028 Record.AddStmt(E->getSrcExpr()); 1029 Code = serialization::EXPR_CONVERT_VECTOR; 1030 } 1031 1032 void ASTStmtWriter::VisitBlockExpr(BlockExpr *E) { 1033 VisitExpr(E); 1034 Record.AddDeclRef(E->getBlockDecl()); 1035 Code = serialization::EXPR_BLOCK; 1036 } 1037 1038 void ASTStmtWriter::VisitGenericSelectionExpr(GenericSelectionExpr *E) { 1039 VisitExpr(E); 1040 1041 Record.push_back(E->getNumAssocs()); 1042 Record.push_back(E->ResultIndex); 1043 Record.AddSourceLocation(E->getGenericLoc()); 1044 Record.AddSourceLocation(E->getDefaultLoc()); 1045 Record.AddSourceLocation(E->getRParenLoc()); 1046 1047 Stmt **Stmts = E->getTrailingObjects<Stmt *>(); 1048 // Add 1 to account for the controlling expression which is the first 1049 // expression in the trailing array of Stmt *. This is not needed for 1050 // the trailing array of TypeSourceInfo *. 1051 for (unsigned I = 0, N = E->getNumAssocs() + 1; I < N; ++I) 1052 Record.AddStmt(Stmts[I]); 1053 1054 TypeSourceInfo **TSIs = E->getTrailingObjects<TypeSourceInfo *>(); 1055 for (unsigned I = 0, N = E->getNumAssocs(); I < N; ++I) 1056 Record.AddTypeSourceInfo(TSIs[I]); 1057 1058 Code = serialization::EXPR_GENERIC_SELECTION; 1059 } 1060 1061 void ASTStmtWriter::VisitPseudoObjectExpr(PseudoObjectExpr *E) { 1062 VisitExpr(E); 1063 Record.push_back(E->getNumSemanticExprs()); 1064 1065 // Push the result index. Currently, this needs to exactly match 1066 // the encoding used internally for ResultIndex. 1067 unsigned result = E->getResultExprIndex(); 1068 result = (result == PseudoObjectExpr::NoResult ? 0 : result + 1); 1069 Record.push_back(result); 1070 1071 Record.AddStmt(E->getSyntacticForm()); 1072 for (PseudoObjectExpr::semantics_iterator 1073 i = E->semantics_begin(), e = E->semantics_end(); i != e; ++i) { 1074 Record.AddStmt(*i); 1075 } 1076 Code = serialization::EXPR_PSEUDO_OBJECT; 1077 } 1078 1079 void ASTStmtWriter::VisitAtomicExpr(AtomicExpr *E) { 1080 VisitExpr(E); 1081 Record.push_back(E->getOp()); 1082 for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I) 1083 Record.AddStmt(E->getSubExprs()[I]); 1084 Record.AddSourceLocation(E->getBuiltinLoc()); 1085 Record.AddSourceLocation(E->getRParenLoc()); 1086 Code = serialization::EXPR_ATOMIC; 1087 } 1088 1089 //===----------------------------------------------------------------------===// 1090 // Objective-C Expressions and Statements. 1091 //===----------------------------------------------------------------------===// 1092 1093 void ASTStmtWriter::VisitObjCStringLiteral(ObjCStringLiteral *E) { 1094 VisitExpr(E); 1095 Record.AddStmt(E->getString()); 1096 Record.AddSourceLocation(E->getAtLoc()); 1097 Code = serialization::EXPR_OBJC_STRING_LITERAL; 1098 } 1099 1100 void ASTStmtWriter::VisitObjCBoxedExpr(ObjCBoxedExpr *E) { 1101 VisitExpr(E); 1102 Record.AddStmt(E->getSubExpr()); 1103 Record.AddDeclRef(E->getBoxingMethod()); 1104 Record.AddSourceRange(E->getSourceRange()); 1105 Code = serialization::EXPR_OBJC_BOXED_EXPRESSION; 1106 } 1107 1108 void ASTStmtWriter::VisitObjCArrayLiteral(ObjCArrayLiteral *E) { 1109 VisitExpr(E); 1110 Record.push_back(E->getNumElements()); 1111 for (unsigned i = 0; i < E->getNumElements(); i++) 1112 Record.AddStmt(E->getElement(i)); 1113 Record.AddDeclRef(E->getArrayWithObjectsMethod()); 1114 Record.AddSourceRange(E->getSourceRange()); 1115 Code = serialization::EXPR_OBJC_ARRAY_LITERAL; 1116 } 1117 1118 void ASTStmtWriter::VisitObjCDictionaryLiteral(ObjCDictionaryLiteral *E) { 1119 VisitExpr(E); 1120 Record.push_back(E->getNumElements()); 1121 Record.push_back(E->HasPackExpansions); 1122 for (unsigned i = 0; i < E->getNumElements(); i++) { 1123 ObjCDictionaryElement Element = E->getKeyValueElement(i); 1124 Record.AddStmt(Element.Key); 1125 Record.AddStmt(Element.Value); 1126 if (E->HasPackExpansions) { 1127 Record.AddSourceLocation(Element.EllipsisLoc); 1128 unsigned NumExpansions = 0; 1129 if (Element.NumExpansions) 1130 NumExpansions = *Element.NumExpansions + 1; 1131 Record.push_back(NumExpansions); 1132 } 1133 } 1134 1135 Record.AddDeclRef(E->getDictWithObjectsMethod()); 1136 Record.AddSourceRange(E->getSourceRange()); 1137 Code = serialization::EXPR_OBJC_DICTIONARY_LITERAL; 1138 } 1139 1140 void ASTStmtWriter::VisitObjCEncodeExpr(ObjCEncodeExpr *E) { 1141 VisitExpr(E); 1142 Record.AddTypeSourceInfo(E->getEncodedTypeSourceInfo()); 1143 Record.AddSourceLocation(E->getAtLoc()); 1144 Record.AddSourceLocation(E->getRParenLoc()); 1145 Code = serialization::EXPR_OBJC_ENCODE; 1146 } 1147 1148 void ASTStmtWriter::VisitObjCSelectorExpr(ObjCSelectorExpr *E) { 1149 VisitExpr(E); 1150 Record.AddSelectorRef(E->getSelector()); 1151 Record.AddSourceLocation(E->getAtLoc()); 1152 Record.AddSourceLocation(E->getRParenLoc()); 1153 Code = serialization::EXPR_OBJC_SELECTOR_EXPR; 1154 } 1155 1156 void ASTStmtWriter::VisitObjCProtocolExpr(ObjCProtocolExpr *E) { 1157 VisitExpr(E); 1158 Record.AddDeclRef(E->getProtocol()); 1159 Record.AddSourceLocation(E->getAtLoc()); 1160 Record.AddSourceLocation(E->ProtoLoc); 1161 Record.AddSourceLocation(E->getRParenLoc()); 1162 Code = serialization::EXPR_OBJC_PROTOCOL_EXPR; 1163 } 1164 1165 void ASTStmtWriter::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) { 1166 VisitExpr(E); 1167 Record.AddDeclRef(E->getDecl()); 1168 Record.AddSourceLocation(E->getLocation()); 1169 Record.AddSourceLocation(E->getOpLoc()); 1170 Record.AddStmt(E->getBase()); 1171 Record.push_back(E->isArrow()); 1172 Record.push_back(E->isFreeIvar()); 1173 Code = serialization::EXPR_OBJC_IVAR_REF_EXPR; 1174 } 1175 1176 void ASTStmtWriter::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) { 1177 VisitExpr(E); 1178 Record.push_back(E->SetterAndMethodRefFlags.getInt()); 1179 Record.push_back(E->isImplicitProperty()); 1180 if (E->isImplicitProperty()) { 1181 Record.AddDeclRef(E->getImplicitPropertyGetter()); 1182 Record.AddDeclRef(E->getImplicitPropertySetter()); 1183 } else { 1184 Record.AddDeclRef(E->getExplicitProperty()); 1185 } 1186 Record.AddSourceLocation(E->getLocation()); 1187 Record.AddSourceLocation(E->getReceiverLocation()); 1188 if (E->isObjectReceiver()) { 1189 Record.push_back(0); 1190 Record.AddStmt(E->getBase()); 1191 } else if (E->isSuperReceiver()) { 1192 Record.push_back(1); 1193 Record.AddTypeRef(E->getSuperReceiverType()); 1194 } else { 1195 Record.push_back(2); 1196 Record.AddDeclRef(E->getClassReceiver()); 1197 } 1198 1199 Code = serialization::EXPR_OBJC_PROPERTY_REF_EXPR; 1200 } 1201 1202 void ASTStmtWriter::VisitObjCSubscriptRefExpr(ObjCSubscriptRefExpr *E) { 1203 VisitExpr(E); 1204 Record.AddSourceLocation(E->getRBracket()); 1205 Record.AddStmt(E->getBaseExpr()); 1206 Record.AddStmt(E->getKeyExpr()); 1207 Record.AddDeclRef(E->getAtIndexMethodDecl()); 1208 Record.AddDeclRef(E->setAtIndexMethodDecl()); 1209 1210 Code = serialization::EXPR_OBJC_SUBSCRIPT_REF_EXPR; 1211 } 1212 1213 void ASTStmtWriter::VisitObjCMessageExpr(ObjCMessageExpr *E) { 1214 VisitExpr(E); 1215 Record.push_back(E->getNumArgs()); 1216 Record.push_back(E->getNumStoredSelLocs()); 1217 Record.push_back(E->SelLocsKind); 1218 Record.push_back(E->isDelegateInitCall()); 1219 Record.push_back(E->IsImplicit); 1220 Record.push_back((unsigned)E->getReceiverKind()); // FIXME: stable encoding 1221 switch (E->getReceiverKind()) { 1222 case ObjCMessageExpr::Instance: 1223 Record.AddStmt(E->getInstanceReceiver()); 1224 break; 1225 1226 case ObjCMessageExpr::Class: 1227 Record.AddTypeSourceInfo(E->getClassReceiverTypeInfo()); 1228 break; 1229 1230 case ObjCMessageExpr::SuperClass: 1231 case ObjCMessageExpr::SuperInstance: 1232 Record.AddTypeRef(E->getSuperType()); 1233 Record.AddSourceLocation(E->getSuperLoc()); 1234 break; 1235 } 1236 1237 if (E->getMethodDecl()) { 1238 Record.push_back(1); 1239 Record.AddDeclRef(E->getMethodDecl()); 1240 } else { 1241 Record.push_back(0); 1242 Record.AddSelectorRef(E->getSelector()); 1243 } 1244 1245 Record.AddSourceLocation(E->getLeftLoc()); 1246 Record.AddSourceLocation(E->getRightLoc()); 1247 1248 for (CallExpr::arg_iterator Arg = E->arg_begin(), ArgEnd = E->arg_end(); 1249 Arg != ArgEnd; ++Arg) 1250 Record.AddStmt(*Arg); 1251 1252 SourceLocation *Locs = E->getStoredSelLocs(); 1253 for (unsigned i = 0, e = E->getNumStoredSelLocs(); i != e; ++i) 1254 Record.AddSourceLocation(Locs[i]); 1255 1256 Code = serialization::EXPR_OBJC_MESSAGE_EXPR; 1257 } 1258 1259 void ASTStmtWriter::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) { 1260 VisitStmt(S); 1261 Record.AddStmt(S->getElement()); 1262 Record.AddStmt(S->getCollection()); 1263 Record.AddStmt(S->getBody()); 1264 Record.AddSourceLocation(S->getForLoc()); 1265 Record.AddSourceLocation(S->getRParenLoc()); 1266 Code = serialization::STMT_OBJC_FOR_COLLECTION; 1267 } 1268 1269 void ASTStmtWriter::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) { 1270 VisitStmt(S); 1271 Record.AddStmt(S->getCatchBody()); 1272 Record.AddDeclRef(S->getCatchParamDecl()); 1273 Record.AddSourceLocation(S->getAtCatchLoc()); 1274 Record.AddSourceLocation(S->getRParenLoc()); 1275 Code = serialization::STMT_OBJC_CATCH; 1276 } 1277 1278 void ASTStmtWriter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) { 1279 VisitStmt(S); 1280 Record.AddStmt(S->getFinallyBody()); 1281 Record.AddSourceLocation(S->getAtFinallyLoc()); 1282 Code = serialization::STMT_OBJC_FINALLY; 1283 } 1284 1285 void ASTStmtWriter::VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S) { 1286 VisitStmt(S); // FIXME: no test coverage. 1287 Record.AddStmt(S->getSubStmt()); 1288 Record.AddSourceLocation(S->getAtLoc()); 1289 Code = serialization::STMT_OBJC_AUTORELEASE_POOL; 1290 } 1291 1292 void ASTStmtWriter::VisitObjCAtTryStmt(ObjCAtTryStmt *S) { 1293 VisitStmt(S); 1294 Record.push_back(S->getNumCatchStmts()); 1295 Record.push_back(S->getFinallyStmt() != nullptr); 1296 Record.AddStmt(S->getTryBody()); 1297 for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I) 1298 Record.AddStmt(S->getCatchStmt(I)); 1299 if (S->getFinallyStmt()) 1300 Record.AddStmt(S->getFinallyStmt()); 1301 Record.AddSourceLocation(S->getAtTryLoc()); 1302 Code = serialization::STMT_OBJC_AT_TRY; 1303 } 1304 1305 void ASTStmtWriter::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) { 1306 VisitStmt(S); // FIXME: no test coverage. 1307 Record.AddStmt(S->getSynchExpr()); 1308 Record.AddStmt(S->getSynchBody()); 1309 Record.AddSourceLocation(S->getAtSynchronizedLoc()); 1310 Code = serialization::STMT_OBJC_AT_SYNCHRONIZED; 1311 } 1312 1313 void ASTStmtWriter::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) { 1314 VisitStmt(S); // FIXME: no test coverage. 1315 Record.AddStmt(S->getThrowExpr()); 1316 Record.AddSourceLocation(S->getThrowLoc()); 1317 Code = serialization::STMT_OBJC_AT_THROW; 1318 } 1319 1320 void ASTStmtWriter::VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) { 1321 VisitExpr(E); 1322 Record.push_back(E->getValue()); 1323 Record.AddSourceLocation(E->getLocation()); 1324 Code = serialization::EXPR_OBJC_BOOL_LITERAL; 1325 } 1326 1327 void ASTStmtWriter::VisitObjCAvailabilityCheckExpr(ObjCAvailabilityCheckExpr *E) { 1328 VisitExpr(E); 1329 Record.AddSourceRange(E->getSourceRange()); 1330 Record.AddVersionTuple(E->getVersion()); 1331 Code = serialization::EXPR_OBJC_AVAILABILITY_CHECK; 1332 } 1333 1334 //===----------------------------------------------------------------------===// 1335 // C++ Expressions and Statements. 1336 //===----------------------------------------------------------------------===// 1337 1338 void ASTStmtWriter::VisitCXXCatchStmt(CXXCatchStmt *S) { 1339 VisitStmt(S); 1340 Record.AddSourceLocation(S->getCatchLoc()); 1341 Record.AddDeclRef(S->getExceptionDecl()); 1342 Record.AddStmt(S->getHandlerBlock()); 1343 Code = serialization::STMT_CXX_CATCH; 1344 } 1345 1346 void ASTStmtWriter::VisitCXXTryStmt(CXXTryStmt *S) { 1347 VisitStmt(S); 1348 Record.push_back(S->getNumHandlers()); 1349 Record.AddSourceLocation(S->getTryLoc()); 1350 Record.AddStmt(S->getTryBlock()); 1351 for (unsigned i = 0, e = S->getNumHandlers(); i != e; ++i) 1352 Record.AddStmt(S->getHandler(i)); 1353 Code = serialization::STMT_CXX_TRY; 1354 } 1355 1356 void ASTStmtWriter::VisitCXXForRangeStmt(CXXForRangeStmt *S) { 1357 VisitStmt(S); 1358 Record.AddSourceLocation(S->getForLoc()); 1359 Record.AddSourceLocation(S->getCoawaitLoc()); 1360 Record.AddSourceLocation(S->getColonLoc()); 1361 Record.AddSourceLocation(S->getRParenLoc()); 1362 Record.AddStmt(S->getInit()); 1363 Record.AddStmt(S->getRangeStmt()); 1364 Record.AddStmt(S->getBeginStmt()); 1365 Record.AddStmt(S->getEndStmt()); 1366 Record.AddStmt(S->getCond()); 1367 Record.AddStmt(S->getInc()); 1368 Record.AddStmt(S->getLoopVarStmt()); 1369 Record.AddStmt(S->getBody()); 1370 Code = serialization::STMT_CXX_FOR_RANGE; 1371 } 1372 1373 void ASTStmtWriter::VisitMSDependentExistsStmt(MSDependentExistsStmt *S) { 1374 VisitStmt(S); 1375 Record.AddSourceLocation(S->getKeywordLoc()); 1376 Record.push_back(S->isIfExists()); 1377 Record.AddNestedNameSpecifierLoc(S->getQualifierLoc()); 1378 Record.AddDeclarationNameInfo(S->getNameInfo()); 1379 Record.AddStmt(S->getSubStmt()); 1380 Code = serialization::STMT_MS_DEPENDENT_EXISTS; 1381 } 1382 1383 void ASTStmtWriter::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) { 1384 VisitCallExpr(E); 1385 Record.push_back(E->getOperator()); 1386 Record.push_back(E->getFPFeatures().getInt()); 1387 Record.AddSourceRange(E->Range); 1388 Code = serialization::EXPR_CXX_OPERATOR_CALL; 1389 } 1390 1391 void ASTStmtWriter::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) { 1392 VisitCallExpr(E); 1393 Code = serialization::EXPR_CXX_MEMBER_CALL; 1394 } 1395 1396 void ASTStmtWriter::VisitCXXRewrittenBinaryOperator( 1397 CXXRewrittenBinaryOperator *E) { 1398 VisitExpr(E); 1399 Record.push_back(E->isReversed()); 1400 Record.AddStmt(E->getSemanticForm()); 1401 Code = serialization::EXPR_CXX_REWRITTEN_BINARY_OPERATOR; 1402 } 1403 1404 void ASTStmtWriter::VisitCXXConstructExpr(CXXConstructExpr *E) { 1405 VisitExpr(E); 1406 1407 Record.push_back(E->getNumArgs()); 1408 Record.push_back(E->isElidable()); 1409 Record.push_back(E->hadMultipleCandidates()); 1410 Record.push_back(E->isListInitialization()); 1411 Record.push_back(E->isStdInitListInitialization()); 1412 Record.push_back(E->requiresZeroInitialization()); 1413 Record.push_back(E->getConstructionKind()); // FIXME: stable encoding 1414 Record.AddSourceLocation(E->getLocation()); 1415 Record.AddDeclRef(E->getConstructor()); 1416 Record.AddSourceRange(E->getParenOrBraceRange()); 1417 1418 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) 1419 Record.AddStmt(E->getArg(I)); 1420 1421 Code = serialization::EXPR_CXX_CONSTRUCT; 1422 } 1423 1424 void ASTStmtWriter::VisitCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr *E) { 1425 VisitExpr(E); 1426 Record.AddDeclRef(E->getConstructor()); 1427 Record.AddSourceLocation(E->getLocation()); 1428 Record.push_back(E->constructsVBase()); 1429 Record.push_back(E->inheritedFromVBase()); 1430 Code = serialization::EXPR_CXX_INHERITED_CTOR_INIT; 1431 } 1432 1433 void ASTStmtWriter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) { 1434 VisitCXXConstructExpr(E); 1435 Record.AddTypeSourceInfo(E->getTypeSourceInfo()); 1436 Code = serialization::EXPR_CXX_TEMPORARY_OBJECT; 1437 } 1438 1439 void ASTStmtWriter::VisitLambdaExpr(LambdaExpr *E) { 1440 VisitExpr(E); 1441 Record.push_back(E->NumCaptures); 1442 Record.AddSourceRange(E->IntroducerRange); 1443 Record.push_back(E->CaptureDefault); // FIXME: stable encoding 1444 Record.AddSourceLocation(E->CaptureDefaultLoc); 1445 Record.push_back(E->ExplicitParams); 1446 Record.push_back(E->ExplicitResultType); 1447 Record.AddSourceLocation(E->ClosingBrace); 1448 1449 // Add capture initializers. 1450 for (LambdaExpr::capture_init_iterator C = E->capture_init_begin(), 1451 CEnd = E->capture_init_end(); 1452 C != CEnd; ++C) { 1453 Record.AddStmt(*C); 1454 } 1455 1456 Code = serialization::EXPR_LAMBDA; 1457 } 1458 1459 void ASTStmtWriter::VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) { 1460 VisitExpr(E); 1461 Record.AddStmt(E->getSubExpr()); 1462 Code = serialization::EXPR_CXX_STD_INITIALIZER_LIST; 1463 } 1464 1465 void ASTStmtWriter::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) { 1466 VisitExplicitCastExpr(E); 1467 Record.AddSourceRange(SourceRange(E->getOperatorLoc(), E->getRParenLoc())); 1468 Record.AddSourceRange(E->getAngleBrackets()); 1469 } 1470 1471 void ASTStmtWriter::VisitCXXStaticCastExpr(CXXStaticCastExpr *E) { 1472 VisitCXXNamedCastExpr(E); 1473 Code = serialization::EXPR_CXX_STATIC_CAST; 1474 } 1475 1476 void ASTStmtWriter::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E) { 1477 VisitCXXNamedCastExpr(E); 1478 Code = serialization::EXPR_CXX_DYNAMIC_CAST; 1479 } 1480 1481 void ASTStmtWriter::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E) { 1482 VisitCXXNamedCastExpr(E); 1483 Code = serialization::EXPR_CXX_REINTERPRET_CAST; 1484 } 1485 1486 void ASTStmtWriter::VisitCXXConstCastExpr(CXXConstCastExpr *E) { 1487 VisitCXXNamedCastExpr(E); 1488 Code = serialization::EXPR_CXX_CONST_CAST; 1489 } 1490 1491 void ASTStmtWriter::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) { 1492 VisitExplicitCastExpr(E); 1493 Record.AddSourceLocation(E->getLParenLoc()); 1494 Record.AddSourceLocation(E->getRParenLoc()); 1495 Code = serialization::EXPR_CXX_FUNCTIONAL_CAST; 1496 } 1497 1498 void ASTStmtWriter::VisitBuiltinBitCastExpr(BuiltinBitCastExpr *E) { 1499 VisitExplicitCastExpr(E); 1500 Record.AddSourceLocation(E->getBeginLoc()); 1501 Record.AddSourceLocation(E->getEndLoc()); 1502 } 1503 1504 void ASTStmtWriter::VisitUserDefinedLiteral(UserDefinedLiteral *E) { 1505 VisitCallExpr(E); 1506 Record.AddSourceLocation(E->UDSuffixLoc); 1507 Code = serialization::EXPR_USER_DEFINED_LITERAL; 1508 } 1509 1510 void ASTStmtWriter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) { 1511 VisitExpr(E); 1512 Record.push_back(E->getValue()); 1513 Record.AddSourceLocation(E->getLocation()); 1514 Code = serialization::EXPR_CXX_BOOL_LITERAL; 1515 } 1516 1517 void ASTStmtWriter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) { 1518 VisitExpr(E); 1519 Record.AddSourceLocation(E->getLocation()); 1520 Code = serialization::EXPR_CXX_NULL_PTR_LITERAL; 1521 } 1522 1523 void ASTStmtWriter::VisitCXXTypeidExpr(CXXTypeidExpr *E) { 1524 VisitExpr(E); 1525 Record.AddSourceRange(E->getSourceRange()); 1526 if (E->isTypeOperand()) { 1527 Record.AddTypeSourceInfo(E->getTypeOperandSourceInfo()); 1528 Code = serialization::EXPR_CXX_TYPEID_TYPE; 1529 } else { 1530 Record.AddStmt(E->getExprOperand()); 1531 Code = serialization::EXPR_CXX_TYPEID_EXPR; 1532 } 1533 } 1534 1535 void ASTStmtWriter::VisitCXXThisExpr(CXXThisExpr *E) { 1536 VisitExpr(E); 1537 Record.AddSourceLocation(E->getLocation()); 1538 Record.push_back(E->isImplicit()); 1539 Code = serialization::EXPR_CXX_THIS; 1540 } 1541 1542 void ASTStmtWriter::VisitCXXThrowExpr(CXXThrowExpr *E) { 1543 VisitExpr(E); 1544 Record.AddSourceLocation(E->getThrowLoc()); 1545 Record.AddStmt(E->getSubExpr()); 1546 Record.push_back(E->isThrownVariableInScope()); 1547 Code = serialization::EXPR_CXX_THROW; 1548 } 1549 1550 void ASTStmtWriter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) { 1551 VisitExpr(E); 1552 Record.AddDeclRef(E->getParam()); 1553 Record.AddDeclRef(cast_or_null<Decl>(E->getUsedContext())); 1554 Record.AddSourceLocation(E->getUsedLocation()); 1555 Code = serialization::EXPR_CXX_DEFAULT_ARG; 1556 } 1557 1558 void ASTStmtWriter::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) { 1559 VisitExpr(E); 1560 Record.AddDeclRef(E->getField()); 1561 Record.AddDeclRef(cast_or_null<Decl>(E->getUsedContext())); 1562 Record.AddSourceLocation(E->getExprLoc()); 1563 Code = serialization::EXPR_CXX_DEFAULT_INIT; 1564 } 1565 1566 void ASTStmtWriter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) { 1567 VisitExpr(E); 1568 Record.AddCXXTemporary(E->getTemporary()); 1569 Record.AddStmt(E->getSubExpr()); 1570 Code = serialization::EXPR_CXX_BIND_TEMPORARY; 1571 } 1572 1573 void ASTStmtWriter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) { 1574 VisitExpr(E); 1575 Record.AddTypeSourceInfo(E->getTypeSourceInfo()); 1576 Record.AddSourceLocation(E->getRParenLoc()); 1577 Code = serialization::EXPR_CXX_SCALAR_VALUE_INIT; 1578 } 1579 1580 void ASTStmtWriter::VisitCXXNewExpr(CXXNewExpr *E) { 1581 VisitExpr(E); 1582 1583 Record.push_back(E->isArray()); 1584 Record.push_back(E->hasInitializer()); 1585 Record.push_back(E->getNumPlacementArgs()); 1586 Record.push_back(E->isParenTypeId()); 1587 1588 Record.push_back(E->isGlobalNew()); 1589 Record.push_back(E->passAlignment()); 1590 Record.push_back(E->doesUsualArrayDeleteWantSize()); 1591 Record.push_back(E->CXXNewExprBits.StoredInitializationStyle); 1592 1593 Record.AddDeclRef(E->getOperatorNew()); 1594 Record.AddDeclRef(E->getOperatorDelete()); 1595 Record.AddTypeSourceInfo(E->getAllocatedTypeSourceInfo()); 1596 if (E->isParenTypeId()) 1597 Record.AddSourceRange(E->getTypeIdParens()); 1598 Record.AddSourceRange(E->getSourceRange()); 1599 Record.AddSourceRange(E->getDirectInitRange()); 1600 1601 for (CXXNewExpr::arg_iterator I = E->raw_arg_begin(), N = E->raw_arg_end(); 1602 I != N; ++I) 1603 Record.AddStmt(*I); 1604 1605 Code = serialization::EXPR_CXX_NEW; 1606 } 1607 1608 void ASTStmtWriter::VisitCXXDeleteExpr(CXXDeleteExpr *E) { 1609 VisitExpr(E); 1610 Record.push_back(E->isGlobalDelete()); 1611 Record.push_back(E->isArrayForm()); 1612 Record.push_back(E->isArrayFormAsWritten()); 1613 Record.push_back(E->doesUsualArrayDeleteWantSize()); 1614 Record.AddDeclRef(E->getOperatorDelete()); 1615 Record.AddStmt(E->getArgument()); 1616 Record.AddSourceLocation(E->getBeginLoc()); 1617 1618 Code = serialization::EXPR_CXX_DELETE; 1619 } 1620 1621 void ASTStmtWriter::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) { 1622 VisitExpr(E); 1623 1624 Record.AddStmt(E->getBase()); 1625 Record.push_back(E->isArrow()); 1626 Record.AddSourceLocation(E->getOperatorLoc()); 1627 Record.AddNestedNameSpecifierLoc(E->getQualifierLoc()); 1628 Record.AddTypeSourceInfo(E->getScopeTypeInfo()); 1629 Record.AddSourceLocation(E->getColonColonLoc()); 1630 Record.AddSourceLocation(E->getTildeLoc()); 1631 1632 // PseudoDestructorTypeStorage. 1633 Record.AddIdentifierRef(E->getDestroyedTypeIdentifier()); 1634 if (E->getDestroyedTypeIdentifier()) 1635 Record.AddSourceLocation(E->getDestroyedTypeLoc()); 1636 else 1637 Record.AddTypeSourceInfo(E->getDestroyedTypeInfo()); 1638 1639 Code = serialization::EXPR_CXX_PSEUDO_DESTRUCTOR; 1640 } 1641 1642 void ASTStmtWriter::VisitExprWithCleanups(ExprWithCleanups *E) { 1643 VisitExpr(E); 1644 Record.push_back(E->getNumObjects()); 1645 for (unsigned i = 0, e = E->getNumObjects(); i != e; ++i) 1646 Record.AddDeclRef(E->getObject(i)); 1647 1648 Record.push_back(E->cleanupsHaveSideEffects()); 1649 Record.AddStmt(E->getSubExpr()); 1650 Code = serialization::EXPR_EXPR_WITH_CLEANUPS; 1651 } 1652 1653 void ASTStmtWriter::VisitCXXDependentScopeMemberExpr( 1654 CXXDependentScopeMemberExpr *E) { 1655 VisitExpr(E); 1656 1657 // Don't emit anything here (or if you do you will have to update 1658 // the corresponding deserialization function). 1659 1660 Record.push_back(E->hasTemplateKWAndArgsInfo()); 1661 Record.push_back(E->getNumTemplateArgs()); 1662 Record.push_back(E->hasFirstQualifierFoundInScope()); 1663 1664 if (E->hasTemplateKWAndArgsInfo()) { 1665 const ASTTemplateKWAndArgsInfo &ArgInfo = 1666 *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(); 1667 AddTemplateKWAndArgsInfo(ArgInfo, 1668 E->getTrailingObjects<TemplateArgumentLoc>()); 1669 } 1670 1671 Record.push_back(E->isArrow()); 1672 Record.AddSourceLocation(E->getOperatorLoc()); 1673 Record.AddTypeRef(E->getBaseType()); 1674 Record.AddNestedNameSpecifierLoc(E->getQualifierLoc()); 1675 if (!E->isImplicitAccess()) 1676 Record.AddStmt(E->getBase()); 1677 else 1678 Record.AddStmt(nullptr); 1679 1680 if (E->hasFirstQualifierFoundInScope()) 1681 Record.AddDeclRef(E->getFirstQualifierFoundInScope()); 1682 1683 Record.AddDeclarationNameInfo(E->MemberNameInfo); 1684 Code = serialization::EXPR_CXX_DEPENDENT_SCOPE_MEMBER; 1685 } 1686 1687 void 1688 ASTStmtWriter::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) { 1689 VisitExpr(E); 1690 1691 // Don't emit anything here, HasTemplateKWAndArgsInfo must be 1692 // emitted first. 1693 1694 Record.push_back(E->DependentScopeDeclRefExprBits.HasTemplateKWAndArgsInfo); 1695 if (E->DependentScopeDeclRefExprBits.HasTemplateKWAndArgsInfo) { 1696 const ASTTemplateKWAndArgsInfo &ArgInfo = 1697 *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(); 1698 Record.push_back(ArgInfo.NumTemplateArgs); 1699 AddTemplateKWAndArgsInfo(ArgInfo, 1700 E->getTrailingObjects<TemplateArgumentLoc>()); 1701 } 1702 1703 Record.AddNestedNameSpecifierLoc(E->getQualifierLoc()); 1704 Record.AddDeclarationNameInfo(E->NameInfo); 1705 Code = serialization::EXPR_CXX_DEPENDENT_SCOPE_DECL_REF; 1706 } 1707 1708 void 1709 ASTStmtWriter::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) { 1710 VisitExpr(E); 1711 Record.push_back(E->arg_size()); 1712 for (CXXUnresolvedConstructExpr::arg_iterator 1713 ArgI = E->arg_begin(), ArgE = E->arg_end(); ArgI != ArgE; ++ArgI) 1714 Record.AddStmt(*ArgI); 1715 Record.AddTypeSourceInfo(E->getTypeSourceInfo()); 1716 Record.AddSourceLocation(E->getLParenLoc()); 1717 Record.AddSourceLocation(E->getRParenLoc()); 1718 Code = serialization::EXPR_CXX_UNRESOLVED_CONSTRUCT; 1719 } 1720 1721 void ASTStmtWriter::VisitOverloadExpr(OverloadExpr *E) { 1722 VisitExpr(E); 1723 1724 Record.push_back(E->getNumDecls()); 1725 Record.push_back(E->hasTemplateKWAndArgsInfo()); 1726 if (E->hasTemplateKWAndArgsInfo()) { 1727 const ASTTemplateKWAndArgsInfo &ArgInfo = 1728 *E->getTrailingASTTemplateKWAndArgsInfo(); 1729 Record.push_back(ArgInfo.NumTemplateArgs); 1730 AddTemplateKWAndArgsInfo(ArgInfo, E->getTrailingTemplateArgumentLoc()); 1731 } 1732 1733 for (OverloadExpr::decls_iterator OvI = E->decls_begin(), 1734 OvE = E->decls_end(); 1735 OvI != OvE; ++OvI) { 1736 Record.AddDeclRef(OvI.getDecl()); 1737 Record.push_back(OvI.getAccess()); 1738 } 1739 1740 Record.AddDeclarationNameInfo(E->getNameInfo()); 1741 Record.AddNestedNameSpecifierLoc(E->getQualifierLoc()); 1742 } 1743 1744 void ASTStmtWriter::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) { 1745 VisitOverloadExpr(E); 1746 Record.push_back(E->isArrow()); 1747 Record.push_back(E->hasUnresolvedUsing()); 1748 Record.AddStmt(!E->isImplicitAccess() ? E->getBase() : nullptr); 1749 Record.AddTypeRef(E->getBaseType()); 1750 Record.AddSourceLocation(E->getOperatorLoc()); 1751 Code = serialization::EXPR_CXX_UNRESOLVED_MEMBER; 1752 } 1753 1754 void ASTStmtWriter::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) { 1755 VisitOverloadExpr(E); 1756 Record.push_back(E->requiresADL()); 1757 Record.push_back(E->isOverloaded()); 1758 Record.AddDeclRef(E->getNamingClass()); 1759 Code = serialization::EXPR_CXX_UNRESOLVED_LOOKUP; 1760 } 1761 1762 void ASTStmtWriter::VisitTypeTraitExpr(TypeTraitExpr *E) { 1763 VisitExpr(E); 1764 Record.push_back(E->TypeTraitExprBits.NumArgs); 1765 Record.push_back(E->TypeTraitExprBits.Kind); // FIXME: Stable encoding 1766 Record.push_back(E->TypeTraitExprBits.Value); 1767 Record.AddSourceRange(E->getSourceRange()); 1768 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) 1769 Record.AddTypeSourceInfo(E->getArg(I)); 1770 Code = serialization::EXPR_TYPE_TRAIT; 1771 } 1772 1773 void ASTStmtWriter::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) { 1774 VisitExpr(E); 1775 Record.push_back(E->getTrait()); 1776 Record.push_back(E->getValue()); 1777 Record.AddSourceRange(E->getSourceRange()); 1778 Record.AddTypeSourceInfo(E->getQueriedTypeSourceInfo()); 1779 Record.AddStmt(E->getDimensionExpression()); 1780 Code = serialization::EXPR_ARRAY_TYPE_TRAIT; 1781 } 1782 1783 void ASTStmtWriter::VisitExpressionTraitExpr(ExpressionTraitExpr *E) { 1784 VisitExpr(E); 1785 Record.push_back(E->getTrait()); 1786 Record.push_back(E->getValue()); 1787 Record.AddSourceRange(E->getSourceRange()); 1788 Record.AddStmt(E->getQueriedExpression()); 1789 Code = serialization::EXPR_CXX_EXPRESSION_TRAIT; 1790 } 1791 1792 void ASTStmtWriter::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) { 1793 VisitExpr(E); 1794 Record.push_back(E->getValue()); 1795 Record.AddSourceRange(E->getSourceRange()); 1796 Record.AddStmt(E->getOperand()); 1797 Code = serialization::EXPR_CXX_NOEXCEPT; 1798 } 1799 1800 void ASTStmtWriter::VisitPackExpansionExpr(PackExpansionExpr *E) { 1801 VisitExpr(E); 1802 Record.AddSourceLocation(E->getEllipsisLoc()); 1803 Record.push_back(E->NumExpansions); 1804 Record.AddStmt(E->getPattern()); 1805 Code = serialization::EXPR_PACK_EXPANSION; 1806 } 1807 1808 void ASTStmtWriter::VisitSizeOfPackExpr(SizeOfPackExpr *E) { 1809 VisitExpr(E); 1810 Record.push_back(E->isPartiallySubstituted() ? E->getPartialArguments().size() 1811 : 0); 1812 Record.AddSourceLocation(E->OperatorLoc); 1813 Record.AddSourceLocation(E->PackLoc); 1814 Record.AddSourceLocation(E->RParenLoc); 1815 Record.AddDeclRef(E->Pack); 1816 if (E->isPartiallySubstituted()) { 1817 for (const auto &TA : E->getPartialArguments()) 1818 Record.AddTemplateArgument(TA); 1819 } else if (!E->isValueDependent()) { 1820 Record.push_back(E->getPackLength()); 1821 } 1822 Code = serialization::EXPR_SIZEOF_PACK; 1823 } 1824 1825 void ASTStmtWriter::VisitSubstNonTypeTemplateParmExpr( 1826 SubstNonTypeTemplateParmExpr *E) { 1827 VisitExpr(E); 1828 Record.AddDeclRef(E->getParameter()); 1829 Record.AddSourceLocation(E->getNameLoc()); 1830 Record.AddStmt(E->getReplacement()); 1831 Code = serialization::EXPR_SUBST_NON_TYPE_TEMPLATE_PARM; 1832 } 1833 1834 void ASTStmtWriter::VisitSubstNonTypeTemplateParmPackExpr( 1835 SubstNonTypeTemplateParmPackExpr *E) { 1836 VisitExpr(E); 1837 Record.AddDeclRef(E->getParameterPack()); 1838 Record.AddTemplateArgument(E->getArgumentPack()); 1839 Record.AddSourceLocation(E->getParameterPackLocation()); 1840 Code = serialization::EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK; 1841 } 1842 1843 void ASTStmtWriter::VisitFunctionParmPackExpr(FunctionParmPackExpr *E) { 1844 VisitExpr(E); 1845 Record.push_back(E->getNumExpansions()); 1846 Record.AddDeclRef(E->getParameterPack()); 1847 Record.AddSourceLocation(E->getParameterPackLocation()); 1848 for (FunctionParmPackExpr::iterator I = E->begin(), End = E->end(); 1849 I != End; ++I) 1850 Record.AddDeclRef(*I); 1851 Code = serialization::EXPR_FUNCTION_PARM_PACK; 1852 } 1853 1854 void ASTStmtWriter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) { 1855 VisitExpr(E); 1856 Record.push_back(static_cast<bool>(E->getLifetimeExtendedTemporaryDecl())); 1857 if (E->getLifetimeExtendedTemporaryDecl()) 1858 Record.AddDeclRef(E->getLifetimeExtendedTemporaryDecl()); 1859 else 1860 Record.AddStmt(E->getSubExpr()); 1861 Code = serialization::EXPR_MATERIALIZE_TEMPORARY; 1862 } 1863 1864 void ASTStmtWriter::VisitCXXFoldExpr(CXXFoldExpr *E) { 1865 VisitExpr(E); 1866 Record.AddSourceLocation(E->LParenLoc); 1867 Record.AddSourceLocation(E->EllipsisLoc); 1868 Record.AddSourceLocation(E->RParenLoc); 1869 Record.push_back(E->NumExpansions); 1870 Record.AddStmt(E->SubExprs[0]); 1871 Record.AddStmt(E->SubExprs[1]); 1872 Record.push_back(E->Opcode); 1873 Code = serialization::EXPR_CXX_FOLD; 1874 } 1875 1876 void ASTStmtWriter::VisitOpaqueValueExpr(OpaqueValueExpr *E) { 1877 VisitExpr(E); 1878 Record.AddStmt(E->getSourceExpr()); 1879 Record.AddSourceLocation(E->getLocation()); 1880 Record.push_back(E->isUnique()); 1881 Code = serialization::EXPR_OPAQUE_VALUE; 1882 } 1883 1884 void ASTStmtWriter::VisitTypoExpr(TypoExpr *E) { 1885 VisitExpr(E); 1886 // TODO: Figure out sane writer behavior for a TypoExpr, if necessary 1887 llvm_unreachable("Cannot write TypoExpr nodes"); 1888 } 1889 1890 //===----------------------------------------------------------------------===// 1891 // CUDA Expressions and Statements. 1892 //===----------------------------------------------------------------------===// 1893 1894 void ASTStmtWriter::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *E) { 1895 VisitCallExpr(E); 1896 Record.AddStmt(E->getConfig()); 1897 Code = serialization::EXPR_CUDA_KERNEL_CALL; 1898 } 1899 1900 //===----------------------------------------------------------------------===// 1901 // OpenCL Expressions and Statements. 1902 //===----------------------------------------------------------------------===// 1903 void ASTStmtWriter::VisitAsTypeExpr(AsTypeExpr *E) { 1904 VisitExpr(E); 1905 Record.AddSourceLocation(E->getBuiltinLoc()); 1906 Record.AddSourceLocation(E->getRParenLoc()); 1907 Record.AddStmt(E->getSrcExpr()); 1908 Code = serialization::EXPR_ASTYPE; 1909 } 1910 1911 //===----------------------------------------------------------------------===// 1912 // Microsoft Expressions and Statements. 1913 //===----------------------------------------------------------------------===// 1914 void ASTStmtWriter::VisitMSPropertyRefExpr(MSPropertyRefExpr *E) { 1915 VisitExpr(E); 1916 Record.push_back(E->isArrow()); 1917 Record.AddStmt(E->getBaseExpr()); 1918 Record.AddNestedNameSpecifierLoc(E->getQualifierLoc()); 1919 Record.AddSourceLocation(E->getMemberLoc()); 1920 Record.AddDeclRef(E->getPropertyDecl()); 1921 Code = serialization::EXPR_CXX_PROPERTY_REF_EXPR; 1922 } 1923 1924 void ASTStmtWriter::VisitMSPropertySubscriptExpr(MSPropertySubscriptExpr *E) { 1925 VisitExpr(E); 1926 Record.AddStmt(E->getBase()); 1927 Record.AddStmt(E->getIdx()); 1928 Record.AddSourceLocation(E->getRBracketLoc()); 1929 Code = serialization::EXPR_CXX_PROPERTY_SUBSCRIPT_EXPR; 1930 } 1931 1932 void ASTStmtWriter::VisitCXXUuidofExpr(CXXUuidofExpr *E) { 1933 VisitExpr(E); 1934 Record.AddSourceRange(E->getSourceRange()); 1935 Record.AddString(E->getUuidStr()); 1936 if (E->isTypeOperand()) { 1937 Record.AddTypeSourceInfo(E->getTypeOperandSourceInfo()); 1938 Code = serialization::EXPR_CXX_UUIDOF_TYPE; 1939 } else { 1940 Record.AddStmt(E->getExprOperand()); 1941 Code = serialization::EXPR_CXX_UUIDOF_EXPR; 1942 } 1943 } 1944 1945 void ASTStmtWriter::VisitSEHExceptStmt(SEHExceptStmt *S) { 1946 VisitStmt(S); 1947 Record.AddSourceLocation(S->getExceptLoc()); 1948 Record.AddStmt(S->getFilterExpr()); 1949 Record.AddStmt(S->getBlock()); 1950 Code = serialization::STMT_SEH_EXCEPT; 1951 } 1952 1953 void ASTStmtWriter::VisitSEHFinallyStmt(SEHFinallyStmt *S) { 1954 VisitStmt(S); 1955 Record.AddSourceLocation(S->getFinallyLoc()); 1956 Record.AddStmt(S->getBlock()); 1957 Code = serialization::STMT_SEH_FINALLY; 1958 } 1959 1960 void ASTStmtWriter::VisitSEHTryStmt(SEHTryStmt *S) { 1961 VisitStmt(S); 1962 Record.push_back(S->getIsCXXTry()); 1963 Record.AddSourceLocation(S->getTryLoc()); 1964 Record.AddStmt(S->getTryBlock()); 1965 Record.AddStmt(S->getHandler()); 1966 Code = serialization::STMT_SEH_TRY; 1967 } 1968 1969 void ASTStmtWriter::VisitSEHLeaveStmt(SEHLeaveStmt *S) { 1970 VisitStmt(S); 1971 Record.AddSourceLocation(S->getLeaveLoc()); 1972 Code = serialization::STMT_SEH_LEAVE; 1973 } 1974 1975 //===----------------------------------------------------------------------===// 1976 // OpenMP Directives. 1977 //===----------------------------------------------------------------------===// 1978 void ASTStmtWriter::VisitOMPExecutableDirective(OMPExecutableDirective *E) { 1979 Record.AddSourceLocation(E->getBeginLoc()); 1980 Record.AddSourceLocation(E->getEndLoc()); 1981 OMPClauseWriter ClauseWriter(Record); 1982 for (unsigned i = 0; i < E->getNumClauses(); ++i) { 1983 ClauseWriter.writeClause(E->getClause(i)); 1984 } 1985 if (E->hasAssociatedStmt()) 1986 Record.AddStmt(E->getAssociatedStmt()); 1987 } 1988 1989 void ASTStmtWriter::VisitOMPLoopDirective(OMPLoopDirective *D) { 1990 VisitStmt(D); 1991 Record.push_back(D->getNumClauses()); 1992 Record.push_back(D->getCollapsedNumber()); 1993 VisitOMPExecutableDirective(D); 1994 Record.AddStmt(D->getIterationVariable()); 1995 Record.AddStmt(D->getLastIteration()); 1996 Record.AddStmt(D->getCalcLastIteration()); 1997 Record.AddStmt(D->getPreCond()); 1998 Record.AddStmt(D->getCond()); 1999 Record.AddStmt(D->getInit()); 2000 Record.AddStmt(D->getInc()); 2001 Record.AddStmt(D->getPreInits()); 2002 if (isOpenMPWorksharingDirective(D->getDirectiveKind()) || 2003 isOpenMPTaskLoopDirective(D->getDirectiveKind()) || 2004 isOpenMPDistributeDirective(D->getDirectiveKind())) { 2005 Record.AddStmt(D->getIsLastIterVariable()); 2006 Record.AddStmt(D->getLowerBoundVariable()); 2007 Record.AddStmt(D->getUpperBoundVariable()); 2008 Record.AddStmt(D->getStrideVariable()); 2009 Record.AddStmt(D->getEnsureUpperBound()); 2010 Record.AddStmt(D->getNextLowerBound()); 2011 Record.AddStmt(D->getNextUpperBound()); 2012 Record.AddStmt(D->getNumIterations()); 2013 } 2014 if (isOpenMPLoopBoundSharingDirective(D->getDirectiveKind())) { 2015 Record.AddStmt(D->getPrevLowerBoundVariable()); 2016 Record.AddStmt(D->getPrevUpperBoundVariable()); 2017 Record.AddStmt(D->getDistInc()); 2018 Record.AddStmt(D->getPrevEnsureUpperBound()); 2019 Record.AddStmt(D->getCombinedLowerBoundVariable()); 2020 Record.AddStmt(D->getCombinedUpperBoundVariable()); 2021 Record.AddStmt(D->getCombinedEnsureUpperBound()); 2022 Record.AddStmt(D->getCombinedInit()); 2023 Record.AddStmt(D->getCombinedCond()); 2024 Record.AddStmt(D->getCombinedNextLowerBound()); 2025 Record.AddStmt(D->getCombinedNextUpperBound()); 2026 Record.AddStmt(D->getCombinedDistCond()); 2027 Record.AddStmt(D->getCombinedParForInDistCond()); 2028 } 2029 for (auto I : D->counters()) { 2030 Record.AddStmt(I); 2031 } 2032 for (auto I : D->private_counters()) { 2033 Record.AddStmt(I); 2034 } 2035 for (auto I : D->inits()) { 2036 Record.AddStmt(I); 2037 } 2038 for (auto I : D->updates()) { 2039 Record.AddStmt(I); 2040 } 2041 for (auto I : D->finals()) { 2042 Record.AddStmt(I); 2043 } 2044 for (Stmt *S : D->dependent_counters()) 2045 Record.AddStmt(S); 2046 for (Stmt *S : D->dependent_inits()) 2047 Record.AddStmt(S); 2048 for (Stmt *S : D->finals_conditions()) 2049 Record.AddStmt(S); 2050 } 2051 2052 void ASTStmtWriter::VisitOMPParallelDirective(OMPParallelDirective *D) { 2053 VisitStmt(D); 2054 Record.push_back(D->getNumClauses()); 2055 VisitOMPExecutableDirective(D); 2056 Record.push_back(D->hasCancel() ? 1 : 0); 2057 Code = serialization::STMT_OMP_PARALLEL_DIRECTIVE; 2058 } 2059 2060 void ASTStmtWriter::VisitOMPSimdDirective(OMPSimdDirective *D) { 2061 VisitOMPLoopDirective(D); 2062 Code = serialization::STMT_OMP_SIMD_DIRECTIVE; 2063 } 2064 2065 void ASTStmtWriter::VisitOMPForDirective(OMPForDirective *D) { 2066 VisitOMPLoopDirective(D); 2067 Record.push_back(D->hasCancel() ? 1 : 0); 2068 Code = serialization::STMT_OMP_FOR_DIRECTIVE; 2069 } 2070 2071 void ASTStmtWriter::VisitOMPForSimdDirective(OMPForSimdDirective *D) { 2072 VisitOMPLoopDirective(D); 2073 Code = serialization::STMT_OMP_FOR_SIMD_DIRECTIVE; 2074 } 2075 2076 void ASTStmtWriter::VisitOMPSectionsDirective(OMPSectionsDirective *D) { 2077 VisitStmt(D); 2078 Record.push_back(D->getNumClauses()); 2079 VisitOMPExecutableDirective(D); 2080 Record.push_back(D->hasCancel() ? 1 : 0); 2081 Code = serialization::STMT_OMP_SECTIONS_DIRECTIVE; 2082 } 2083 2084 void ASTStmtWriter::VisitOMPSectionDirective(OMPSectionDirective *D) { 2085 VisitStmt(D); 2086 VisitOMPExecutableDirective(D); 2087 Record.push_back(D->hasCancel() ? 1 : 0); 2088 Code = serialization::STMT_OMP_SECTION_DIRECTIVE; 2089 } 2090 2091 void ASTStmtWriter::VisitOMPSingleDirective(OMPSingleDirective *D) { 2092 VisitStmt(D); 2093 Record.push_back(D->getNumClauses()); 2094 VisitOMPExecutableDirective(D); 2095 Code = serialization::STMT_OMP_SINGLE_DIRECTIVE; 2096 } 2097 2098 void ASTStmtWriter::VisitOMPMasterDirective(OMPMasterDirective *D) { 2099 VisitStmt(D); 2100 VisitOMPExecutableDirective(D); 2101 Code = serialization::STMT_OMP_MASTER_DIRECTIVE; 2102 } 2103 2104 void ASTStmtWriter::VisitOMPCriticalDirective(OMPCriticalDirective *D) { 2105 VisitStmt(D); 2106 Record.push_back(D->getNumClauses()); 2107 VisitOMPExecutableDirective(D); 2108 Record.AddDeclarationNameInfo(D->getDirectiveName()); 2109 Code = serialization::STMT_OMP_CRITICAL_DIRECTIVE; 2110 } 2111 2112 void ASTStmtWriter::VisitOMPParallelForDirective(OMPParallelForDirective *D) { 2113 VisitOMPLoopDirective(D); 2114 Record.push_back(D->hasCancel() ? 1 : 0); 2115 Code = serialization::STMT_OMP_PARALLEL_FOR_DIRECTIVE; 2116 } 2117 2118 void ASTStmtWriter::VisitOMPParallelForSimdDirective( 2119 OMPParallelForSimdDirective *D) { 2120 VisitOMPLoopDirective(D); 2121 Code = serialization::STMT_OMP_PARALLEL_FOR_SIMD_DIRECTIVE; 2122 } 2123 2124 void ASTStmtWriter::VisitOMPParallelMasterDirective( 2125 OMPParallelMasterDirective *D) { 2126 VisitStmt(D); 2127 Record.push_back(D->getNumClauses()); 2128 VisitOMPExecutableDirective(D); 2129 Code = serialization::STMT_OMP_PARALLEL_MASTER_DIRECTIVE; 2130 } 2131 2132 void ASTStmtWriter::VisitOMPParallelSectionsDirective( 2133 OMPParallelSectionsDirective *D) { 2134 VisitStmt(D); 2135 Record.push_back(D->getNumClauses()); 2136 VisitOMPExecutableDirective(D); 2137 Record.push_back(D->hasCancel() ? 1 : 0); 2138 Code = serialization::STMT_OMP_PARALLEL_SECTIONS_DIRECTIVE; 2139 } 2140 2141 void ASTStmtWriter::VisitOMPTaskDirective(OMPTaskDirective *D) { 2142 VisitStmt(D); 2143 Record.push_back(D->getNumClauses()); 2144 VisitOMPExecutableDirective(D); 2145 Record.push_back(D->hasCancel() ? 1 : 0); 2146 Code = serialization::STMT_OMP_TASK_DIRECTIVE; 2147 } 2148 2149 void ASTStmtWriter::VisitOMPAtomicDirective(OMPAtomicDirective *D) { 2150 VisitStmt(D); 2151 Record.push_back(D->getNumClauses()); 2152 VisitOMPExecutableDirective(D); 2153 Record.AddStmt(D->getX()); 2154 Record.AddStmt(D->getV()); 2155 Record.AddStmt(D->getExpr()); 2156 Record.AddStmt(D->getUpdateExpr()); 2157 Record.push_back(D->isXLHSInRHSPart() ? 1 : 0); 2158 Record.push_back(D->isPostfixUpdate() ? 1 : 0); 2159 Code = serialization::STMT_OMP_ATOMIC_DIRECTIVE; 2160 } 2161 2162 void ASTStmtWriter::VisitOMPTargetDirective(OMPTargetDirective *D) { 2163 VisitStmt(D); 2164 Record.push_back(D->getNumClauses()); 2165 VisitOMPExecutableDirective(D); 2166 Code = serialization::STMT_OMP_TARGET_DIRECTIVE; 2167 } 2168 2169 void ASTStmtWriter::VisitOMPTargetDataDirective(OMPTargetDataDirective *D) { 2170 VisitStmt(D); 2171 Record.push_back(D->getNumClauses()); 2172 VisitOMPExecutableDirective(D); 2173 Code = serialization::STMT_OMP_TARGET_DATA_DIRECTIVE; 2174 } 2175 2176 void ASTStmtWriter::VisitOMPTargetEnterDataDirective( 2177 OMPTargetEnterDataDirective *D) { 2178 VisitStmt(D); 2179 Record.push_back(D->getNumClauses()); 2180 VisitOMPExecutableDirective(D); 2181 Code = serialization::STMT_OMP_TARGET_ENTER_DATA_DIRECTIVE; 2182 } 2183 2184 void ASTStmtWriter::VisitOMPTargetExitDataDirective( 2185 OMPTargetExitDataDirective *D) { 2186 VisitStmt(D); 2187 Record.push_back(D->getNumClauses()); 2188 VisitOMPExecutableDirective(D); 2189 Code = serialization::STMT_OMP_TARGET_EXIT_DATA_DIRECTIVE; 2190 } 2191 2192 void ASTStmtWriter::VisitOMPTargetParallelDirective( 2193 OMPTargetParallelDirective *D) { 2194 VisitStmt(D); 2195 Record.push_back(D->getNumClauses()); 2196 VisitOMPExecutableDirective(D); 2197 Code = serialization::STMT_OMP_TARGET_PARALLEL_DIRECTIVE; 2198 } 2199 2200 void ASTStmtWriter::VisitOMPTargetParallelForDirective( 2201 OMPTargetParallelForDirective *D) { 2202 VisitOMPLoopDirective(D); 2203 Record.push_back(D->hasCancel() ? 1 : 0); 2204 Code = serialization::STMT_OMP_TARGET_PARALLEL_FOR_DIRECTIVE; 2205 } 2206 2207 void ASTStmtWriter::VisitOMPTaskyieldDirective(OMPTaskyieldDirective *D) { 2208 VisitStmt(D); 2209 VisitOMPExecutableDirective(D); 2210 Code = serialization::STMT_OMP_TASKYIELD_DIRECTIVE; 2211 } 2212 2213 void ASTStmtWriter::VisitOMPBarrierDirective(OMPBarrierDirective *D) { 2214 VisitStmt(D); 2215 VisitOMPExecutableDirective(D); 2216 Code = serialization::STMT_OMP_BARRIER_DIRECTIVE; 2217 } 2218 2219 void ASTStmtWriter::VisitOMPTaskwaitDirective(OMPTaskwaitDirective *D) { 2220 VisitStmt(D); 2221 VisitOMPExecutableDirective(D); 2222 Code = serialization::STMT_OMP_TASKWAIT_DIRECTIVE; 2223 } 2224 2225 void ASTStmtWriter::VisitOMPTaskgroupDirective(OMPTaskgroupDirective *D) { 2226 VisitStmt(D); 2227 Record.push_back(D->getNumClauses()); 2228 VisitOMPExecutableDirective(D); 2229 Record.AddStmt(D->getReductionRef()); 2230 Code = serialization::STMT_OMP_TASKGROUP_DIRECTIVE; 2231 } 2232 2233 void ASTStmtWriter::VisitOMPFlushDirective(OMPFlushDirective *D) { 2234 VisitStmt(D); 2235 Record.push_back(D->getNumClauses()); 2236 VisitOMPExecutableDirective(D); 2237 Code = serialization::STMT_OMP_FLUSH_DIRECTIVE; 2238 } 2239 2240 void ASTStmtWriter::VisitOMPOrderedDirective(OMPOrderedDirective *D) { 2241 VisitStmt(D); 2242 Record.push_back(D->getNumClauses()); 2243 VisitOMPExecutableDirective(D); 2244 Code = serialization::STMT_OMP_ORDERED_DIRECTIVE; 2245 } 2246 2247 void ASTStmtWriter::VisitOMPTeamsDirective(OMPTeamsDirective *D) { 2248 VisitStmt(D); 2249 Record.push_back(D->getNumClauses()); 2250 VisitOMPExecutableDirective(D); 2251 Code = serialization::STMT_OMP_TEAMS_DIRECTIVE; 2252 } 2253 2254 void ASTStmtWriter::VisitOMPCancellationPointDirective( 2255 OMPCancellationPointDirective *D) { 2256 VisitStmt(D); 2257 VisitOMPExecutableDirective(D); 2258 Record.push_back(D->getCancelRegion()); 2259 Code = serialization::STMT_OMP_CANCELLATION_POINT_DIRECTIVE; 2260 } 2261 2262 void ASTStmtWriter::VisitOMPCancelDirective(OMPCancelDirective *D) { 2263 VisitStmt(D); 2264 Record.push_back(D->getNumClauses()); 2265 VisitOMPExecutableDirective(D); 2266 Record.push_back(D->getCancelRegion()); 2267 Code = serialization::STMT_OMP_CANCEL_DIRECTIVE; 2268 } 2269 2270 void ASTStmtWriter::VisitOMPTaskLoopDirective(OMPTaskLoopDirective *D) { 2271 VisitOMPLoopDirective(D); 2272 Code = serialization::STMT_OMP_TASKLOOP_DIRECTIVE; 2273 } 2274 2275 void ASTStmtWriter::VisitOMPTaskLoopSimdDirective(OMPTaskLoopSimdDirective *D) { 2276 VisitOMPLoopDirective(D); 2277 Code = serialization::STMT_OMP_TASKLOOP_SIMD_DIRECTIVE; 2278 } 2279 2280 void ASTStmtWriter::VisitOMPMasterTaskLoopDirective( 2281 OMPMasterTaskLoopDirective *D) { 2282 VisitOMPLoopDirective(D); 2283 Code = serialization::STMT_OMP_MASTER_TASKLOOP_DIRECTIVE; 2284 } 2285 2286 void ASTStmtWriter::VisitOMPMasterTaskLoopSimdDirective( 2287 OMPMasterTaskLoopSimdDirective *D) { 2288 VisitOMPLoopDirective(D); 2289 Code = serialization::STMT_OMP_MASTER_TASKLOOP_SIMD_DIRECTIVE; 2290 } 2291 2292 void ASTStmtWriter::VisitOMPParallelMasterTaskLoopDirective( 2293 OMPParallelMasterTaskLoopDirective *D) { 2294 VisitOMPLoopDirective(D); 2295 Code = serialization::STMT_OMP_PARALLEL_MASTER_TASKLOOP_DIRECTIVE; 2296 } 2297 2298 void ASTStmtWriter::VisitOMPParallelMasterTaskLoopSimdDirective( 2299 OMPParallelMasterTaskLoopSimdDirective *D) { 2300 VisitOMPLoopDirective(D); 2301 Code = serialization::STMT_OMP_PARALLEL_MASTER_TASKLOOP_SIMD_DIRECTIVE; 2302 } 2303 2304 void ASTStmtWriter::VisitOMPDistributeDirective(OMPDistributeDirective *D) { 2305 VisitOMPLoopDirective(D); 2306 Code = serialization::STMT_OMP_DISTRIBUTE_DIRECTIVE; 2307 } 2308 2309 void ASTStmtWriter::VisitOMPTargetUpdateDirective(OMPTargetUpdateDirective *D) { 2310 VisitStmt(D); 2311 Record.push_back(D->getNumClauses()); 2312 VisitOMPExecutableDirective(D); 2313 Code = serialization::STMT_OMP_TARGET_UPDATE_DIRECTIVE; 2314 } 2315 2316 void ASTStmtWriter::VisitOMPDistributeParallelForDirective( 2317 OMPDistributeParallelForDirective *D) { 2318 VisitOMPLoopDirective(D); 2319 Record.push_back(D->hasCancel() ? 1 : 0); 2320 Code = serialization::STMT_OMP_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE; 2321 } 2322 2323 void ASTStmtWriter::VisitOMPDistributeParallelForSimdDirective( 2324 OMPDistributeParallelForSimdDirective *D) { 2325 VisitOMPLoopDirective(D); 2326 Code = serialization::STMT_OMP_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE; 2327 } 2328 2329 void ASTStmtWriter::VisitOMPDistributeSimdDirective( 2330 OMPDistributeSimdDirective *D) { 2331 VisitOMPLoopDirective(D); 2332 Code = serialization::STMT_OMP_DISTRIBUTE_SIMD_DIRECTIVE; 2333 } 2334 2335 void ASTStmtWriter::VisitOMPTargetParallelForSimdDirective( 2336 OMPTargetParallelForSimdDirective *D) { 2337 VisitOMPLoopDirective(D); 2338 Code = serialization::STMT_OMP_TARGET_PARALLEL_FOR_SIMD_DIRECTIVE; 2339 } 2340 2341 void ASTStmtWriter::VisitOMPTargetSimdDirective(OMPTargetSimdDirective *D) { 2342 VisitOMPLoopDirective(D); 2343 Code = serialization::STMT_OMP_TARGET_SIMD_DIRECTIVE; 2344 } 2345 2346 void ASTStmtWriter::VisitOMPTeamsDistributeDirective( 2347 OMPTeamsDistributeDirective *D) { 2348 VisitOMPLoopDirective(D); 2349 Code = serialization::STMT_OMP_TEAMS_DISTRIBUTE_DIRECTIVE; 2350 } 2351 2352 void ASTStmtWriter::VisitOMPTeamsDistributeSimdDirective( 2353 OMPTeamsDistributeSimdDirective *D) { 2354 VisitOMPLoopDirective(D); 2355 Code = serialization::STMT_OMP_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE; 2356 } 2357 2358 void ASTStmtWriter::VisitOMPTeamsDistributeParallelForSimdDirective( 2359 OMPTeamsDistributeParallelForSimdDirective *D) { 2360 VisitOMPLoopDirective(D); 2361 Code = serialization::STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE; 2362 } 2363 2364 void ASTStmtWriter::VisitOMPTeamsDistributeParallelForDirective( 2365 OMPTeamsDistributeParallelForDirective *D) { 2366 VisitOMPLoopDirective(D); 2367 Record.push_back(D->hasCancel() ? 1 : 0); 2368 Code = serialization::STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE; 2369 } 2370 2371 void ASTStmtWriter::VisitOMPTargetTeamsDirective(OMPTargetTeamsDirective *D) { 2372 VisitStmt(D); 2373 Record.push_back(D->getNumClauses()); 2374 VisitOMPExecutableDirective(D); 2375 Code = serialization::STMT_OMP_TARGET_TEAMS_DIRECTIVE; 2376 } 2377 2378 void ASTStmtWriter::VisitOMPTargetTeamsDistributeDirective( 2379 OMPTargetTeamsDistributeDirective *D) { 2380 VisitOMPLoopDirective(D); 2381 Code = serialization::STMT_OMP_TARGET_TEAMS_DISTRIBUTE_DIRECTIVE; 2382 } 2383 2384 void ASTStmtWriter::VisitOMPTargetTeamsDistributeParallelForDirective( 2385 OMPTargetTeamsDistributeParallelForDirective *D) { 2386 VisitOMPLoopDirective(D); 2387 Record.push_back(D->hasCancel() ? 1 : 0); 2388 Code = serialization::STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE; 2389 } 2390 2391 void ASTStmtWriter::VisitOMPTargetTeamsDistributeParallelForSimdDirective( 2392 OMPTargetTeamsDistributeParallelForSimdDirective *D) { 2393 VisitOMPLoopDirective(D); 2394 Code = serialization:: 2395 STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE; 2396 } 2397 2398 void ASTStmtWriter::VisitOMPTargetTeamsDistributeSimdDirective( 2399 OMPTargetTeamsDistributeSimdDirective *D) { 2400 VisitOMPLoopDirective(D); 2401 Code = serialization::STMT_OMP_TARGET_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE; 2402 } 2403 2404 //===----------------------------------------------------------------------===// 2405 // ASTWriter Implementation 2406 //===----------------------------------------------------------------------===// 2407 2408 unsigned ASTWriter::RecordSwitchCaseID(SwitchCase *S) { 2409 assert(SwitchCaseIDs.find(S) == SwitchCaseIDs.end() && 2410 "SwitchCase recorded twice"); 2411 unsigned NextID = SwitchCaseIDs.size(); 2412 SwitchCaseIDs[S] = NextID; 2413 return NextID; 2414 } 2415 2416 unsigned ASTWriter::getSwitchCaseID(SwitchCase *S) { 2417 assert(SwitchCaseIDs.find(S) != SwitchCaseIDs.end() && 2418 "SwitchCase hasn't been seen yet"); 2419 return SwitchCaseIDs[S]; 2420 } 2421 2422 void ASTWriter::ClearSwitchCaseIDs() { 2423 SwitchCaseIDs.clear(); 2424 } 2425 2426 /// Write the given substatement or subexpression to the 2427 /// bitstream. 2428 void ASTWriter::WriteSubStmt(Stmt *S) { 2429 RecordData Record; 2430 ASTStmtWriter Writer(*this, Record); 2431 ++NumStatements; 2432 2433 if (!S) { 2434 Stream.EmitRecord(serialization::STMT_NULL_PTR, Record); 2435 return; 2436 } 2437 2438 llvm::DenseMap<Stmt *, uint64_t>::iterator I = SubStmtEntries.find(S); 2439 if (I != SubStmtEntries.end()) { 2440 Record.push_back(I->second); 2441 Stream.EmitRecord(serialization::STMT_REF_PTR, Record); 2442 return; 2443 } 2444 2445 #ifndef NDEBUG 2446 assert(!ParentStmts.count(S) && "There is a Stmt cycle!"); 2447 2448 struct ParentStmtInserterRAII { 2449 Stmt *S; 2450 llvm::DenseSet<Stmt *> &ParentStmts; 2451 2452 ParentStmtInserterRAII(Stmt *S, llvm::DenseSet<Stmt *> &ParentStmts) 2453 : S(S), ParentStmts(ParentStmts) { 2454 ParentStmts.insert(S); 2455 } 2456 ~ParentStmtInserterRAII() { 2457 ParentStmts.erase(S); 2458 } 2459 }; 2460 2461 ParentStmtInserterRAII ParentStmtInserter(S, ParentStmts); 2462 #endif 2463 2464 Writer.Visit(S); 2465 2466 uint64_t Offset = Writer.Emit(); 2467 SubStmtEntries[S] = Offset; 2468 } 2469 2470 /// Flush all of the statements that have been added to the 2471 /// queue via AddStmt(). 2472 void ASTRecordWriter::FlushStmts() { 2473 // We expect to be the only consumer of the two temporary statement maps, 2474 // assert that they are empty. 2475 assert(Writer->SubStmtEntries.empty() && "unexpected entries in sub-stmt map"); 2476 assert(Writer->ParentStmts.empty() && "unexpected entries in parent stmt map"); 2477 2478 for (unsigned I = 0, N = StmtsToEmit.size(); I != N; ++I) { 2479 Writer->WriteSubStmt(StmtsToEmit[I]); 2480 2481 assert(N == StmtsToEmit.size() && "record modified while being written!"); 2482 2483 // Note that we are at the end of a full expression. Any 2484 // expression records that follow this one are part of a different 2485 // expression. 2486 Writer->Stream.EmitRecord(serialization::STMT_STOP, ArrayRef<uint32_t>()); 2487 2488 Writer->SubStmtEntries.clear(); 2489 Writer->ParentStmts.clear(); 2490 } 2491 2492 StmtsToEmit.clear(); 2493 } 2494 2495 void ASTRecordWriter::FlushSubStmts() { 2496 // For a nested statement, write out the substatements in reverse order (so 2497 // that a simple stack machine can be used when loading), and don't emit a 2498 // STMT_STOP after each one. 2499 for (unsigned I = 0, N = StmtsToEmit.size(); I != N; ++I) { 2500 Writer->WriteSubStmt(StmtsToEmit[N - I - 1]); 2501 assert(N == StmtsToEmit.size() && "record modified while being written!"); 2502 } 2503 2504 StmtsToEmit.clear(); 2505 } 2506