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