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