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 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 53 void 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 62 void ASTStmtWriter::VisitStmt(Stmt *S) { 63 } 64 65 void 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 72 void 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 82 void 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 89 void 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 98 void ASTStmtWriter::VisitDefaultStmt(DefaultStmt *S) { 99 VisitSwitchCase(S); 100 Writer.AddStmt(S->getSubStmt()); 101 Code = serialization::STMT_DEFAULT; 102 } 103 104 void 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 112 void 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 121 void 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 132 void 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 145 void 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 154 void 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 164 void 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 177 void 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 185 void 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 193 void ASTStmtWriter::VisitContinueStmt(ContinueStmt *S) { 194 VisitStmt(S); 195 Writer.AddSourceLocation(S->getContinueLoc(), Record); 196 Code = serialization::STMT_CONTINUE; 197 } 198 199 void ASTStmtWriter::VisitBreakStmt(BreakStmt *S) { 200 VisitStmt(S); 201 Writer.AddSourceLocation(S->getBreakLoc(), Record); 202 Code = serialization::STMT_BREAK; 203 } 204 205 void 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 213 void 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 223 void 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 233 void 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 259 void 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 291 void ASTStmtWriter::VisitCoroutineBodyStmt(CoroutineBodyStmt *S) { 292 // FIXME: Implement coroutine serialization. 293 llvm_unreachable("unimplemented"); 294 } 295 296 void ASTStmtWriter::VisitCoreturnStmt(CoreturnStmt *S) { 297 // FIXME: Implement coroutine serialization. 298 llvm_unreachable("unimplemented"); 299 } 300 301 void ASTStmtWriter::VisitCoawaitExpr(CoawaitExpr *S) { 302 // FIXME: Implement coroutine serialization. 303 llvm_unreachable("unimplemented"); 304 } 305 306 void ASTStmtWriter::VisitCoyieldExpr(CoyieldExpr *S) { 307 // FIXME: Implement coroutine serialization. 308 llvm_unreachable("unimplemented"); 309 } 310 311 void 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 342 void 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 353 void 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 361 void 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 399 void 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 411 void 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 420 void ASTStmtWriter::VisitImaginaryLiteral(ImaginaryLiteral *E) { 421 VisitExpr(E); 422 Writer.AddStmt(E->getSubExpr()); 423 Code = serialization::EXPR_IMAGINARY_LITERAL; 424 } 425 426 void 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 442 void 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 453 void 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 461 void 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 471 void 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 479 void 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 514 void 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 528 void 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 536 void 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 546 void 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 557 void 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 594 void 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 603 void ASTStmtWriter:: 604 VisitObjCIndirectCopyRestoreExpr(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 611 void 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 619 void 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 630 void 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 640 void 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 647 void 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 657 void 658 ASTStmtWriter::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 670 void 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 679 void ASTStmtWriter::VisitExplicitCastExpr(ExplicitCastExpr *E) { 680 VisitCastExpr(E); 681 Writer.AddTypeSourceInfo(E->getTypeInfoAsWritten(), Record); 682 } 683 684 void 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 691 void 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 700 void 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 708 void 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 736 void 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 773 void 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 780 void ASTStmtWriter::VisitNoInitExpr(NoInitExpr *E) { 781 VisitExpr(E); 782 Code = serialization::EXPR_NO_INIT; 783 } 784 785 void ASTStmtWriter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) { 786 VisitExpr(E); 787 Code = serialization::EXPR_IMPLICIT_VALUE_INIT; 788 } 789 790 void 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 800 void 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 808 void 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 816 void 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 827 void ASTStmtWriter::VisitGNUNullExpr(GNUNullExpr *E) { 828 VisitExpr(E); 829 Writer.AddSourceLocation(E->getTokenLocation(), Record); 830 Code = serialization::EXPR_GNU_NULL; 831 } 832 833 void 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 843 void 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 852 void ASTStmtWriter::VisitBlockExpr(BlockExpr *E) { 853 VisitExpr(E); 854 Writer.AddDeclRef(E->getBlockDecl(), Record); 855 Code = serialization::EXPR_BLOCK; 856 } 857 858 void 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 875 void 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 893 void 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 907 void 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 914 void 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 922 void 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 932 void 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 954 void 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 962 void 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 970 void 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 979 void 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 990 void 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 1016 void 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 1027 void 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 1073 void 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 1083 void 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 1091 void ASTStmtWriter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) { 1092 Writer.AddStmt(S->getFinallyBody()); 1093 Writer.AddSourceLocation(S->getAtFinallyLoc(), Record); 1094 Code = serialization::STMT_OBJC_FINALLY; 1095 } 1096 1097 void ASTStmtWriter::VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S) { 1098 Writer.AddStmt(S->getSubStmt()); 1099 Writer.AddSourceLocation(S->getAtLoc(), Record); 1100 Code = serialization::STMT_OBJC_AUTORELEASE_POOL; 1101 } 1102 1103 void 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 1115 void 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 1122 void ASTStmtWriter::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) { 1123 Writer.AddStmt(S->getThrowExpr()); 1124 Writer.AddSourceLocation(S->getThrowLoc(), Record); 1125 Code = serialization::STMT_OBJC_AT_THROW; 1126 } 1127 1128 void 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 1139 void 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 1147 void 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 1157 void 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->getBeginStmt()); 1165 Writer.AddStmt(S->getEndStmt()); 1166 Writer.AddStmt(S->getCond()); 1167 Writer.AddStmt(S->getInc()); 1168 Writer.AddStmt(S->getLoopVarStmt()); 1169 Writer.AddStmt(S->getBody()); 1170 Code = serialization::STMT_CXX_FOR_RANGE; 1171 } 1172 1173 void ASTStmtWriter::VisitMSDependentExistsStmt(MSDependentExistsStmt *S) { 1174 VisitStmt(S); 1175 Writer.AddSourceLocation(S->getKeywordLoc(), Record); 1176 Record.push_back(S->isIfExists()); 1177 Writer.AddNestedNameSpecifierLoc(S->getQualifierLoc(), Record); 1178 Writer.AddDeclarationNameInfo(S->getNameInfo(), Record); 1179 Writer.AddStmt(S->getSubStmt()); 1180 Code = serialization::STMT_MS_DEPENDENT_EXISTS; 1181 } 1182 1183 void ASTStmtWriter::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) { 1184 VisitCallExpr(E); 1185 Record.push_back(E->getOperator()); 1186 Writer.AddSourceRange(E->Range, Record); 1187 Record.push_back(E->isFPContractable()); 1188 Code = serialization::EXPR_CXX_OPERATOR_CALL; 1189 } 1190 1191 void ASTStmtWriter::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) { 1192 VisitCallExpr(E); 1193 Code = serialization::EXPR_CXX_MEMBER_CALL; 1194 } 1195 1196 void ASTStmtWriter::VisitCXXConstructExpr(CXXConstructExpr *E) { 1197 VisitExpr(E); 1198 Record.push_back(E->getNumArgs()); 1199 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) 1200 Writer.AddStmt(E->getArg(I)); 1201 Writer.AddDeclRef(E->getConstructor(), Record); 1202 Writer.AddSourceLocation(E->getLocation(), Record); 1203 Record.push_back(E->isElidable()); 1204 Record.push_back(E->hadMultipleCandidates()); 1205 Record.push_back(E->isListInitialization()); 1206 Record.push_back(E->isStdInitListInitialization()); 1207 Record.push_back(E->requiresZeroInitialization()); 1208 Record.push_back(E->getConstructionKind()); // FIXME: stable encoding 1209 Writer.AddSourceRange(E->getParenOrBraceRange(), Record); 1210 Code = serialization::EXPR_CXX_CONSTRUCT; 1211 } 1212 1213 void ASTStmtWriter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) { 1214 VisitCXXConstructExpr(E); 1215 Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record); 1216 Code = serialization::EXPR_CXX_TEMPORARY_OBJECT; 1217 } 1218 1219 void ASTStmtWriter::VisitLambdaExpr(LambdaExpr *E) { 1220 VisitExpr(E); 1221 Record.push_back(E->NumCaptures); 1222 unsigned NumArrayIndexVars = 0; 1223 if (E->HasArrayIndexVars) 1224 NumArrayIndexVars = E->getArrayIndexStarts()[E->NumCaptures]; 1225 Record.push_back(NumArrayIndexVars); 1226 Writer.AddSourceRange(E->IntroducerRange, Record); 1227 Record.push_back(E->CaptureDefault); // FIXME: stable encoding 1228 Writer.AddSourceLocation(E->CaptureDefaultLoc, Record); 1229 Record.push_back(E->ExplicitParams); 1230 Record.push_back(E->ExplicitResultType); 1231 Writer.AddSourceLocation(E->ClosingBrace, Record); 1232 1233 // Add capture initializers. 1234 for (LambdaExpr::capture_init_iterator C = E->capture_init_begin(), 1235 CEnd = E->capture_init_end(); 1236 C != CEnd; ++C) { 1237 Writer.AddStmt(*C); 1238 } 1239 1240 // Add array index variables, if any. 1241 if (NumArrayIndexVars) { 1242 Record.append(E->getArrayIndexStarts(), 1243 E->getArrayIndexStarts() + E->NumCaptures + 1); 1244 VarDecl **ArrayIndexVars = E->getArrayIndexVars(); 1245 for (unsigned I = 0; I != NumArrayIndexVars; ++I) 1246 Writer.AddDeclRef(ArrayIndexVars[I], Record); 1247 } 1248 1249 Code = serialization::EXPR_LAMBDA; 1250 } 1251 1252 void ASTStmtWriter::VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) { 1253 VisitExpr(E); 1254 Writer.AddStmt(E->getSubExpr()); 1255 Code = serialization::EXPR_CXX_STD_INITIALIZER_LIST; 1256 } 1257 1258 void ASTStmtWriter::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) { 1259 VisitExplicitCastExpr(E); 1260 Writer.AddSourceRange(SourceRange(E->getOperatorLoc(), E->getRParenLoc()), 1261 Record); 1262 Writer.AddSourceRange(E->getAngleBrackets(), Record); 1263 } 1264 1265 void ASTStmtWriter::VisitCXXStaticCastExpr(CXXStaticCastExpr *E) { 1266 VisitCXXNamedCastExpr(E); 1267 Code = serialization::EXPR_CXX_STATIC_CAST; 1268 } 1269 1270 void ASTStmtWriter::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E) { 1271 VisitCXXNamedCastExpr(E); 1272 Code = serialization::EXPR_CXX_DYNAMIC_CAST; 1273 } 1274 1275 void ASTStmtWriter::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E) { 1276 VisitCXXNamedCastExpr(E); 1277 Code = serialization::EXPR_CXX_REINTERPRET_CAST; 1278 } 1279 1280 void ASTStmtWriter::VisitCXXConstCastExpr(CXXConstCastExpr *E) { 1281 VisitCXXNamedCastExpr(E); 1282 Code = serialization::EXPR_CXX_CONST_CAST; 1283 } 1284 1285 void ASTStmtWriter::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) { 1286 VisitExplicitCastExpr(E); 1287 Writer.AddSourceLocation(E->getLParenLoc(), Record); 1288 Writer.AddSourceLocation(E->getRParenLoc(), Record); 1289 Code = serialization::EXPR_CXX_FUNCTIONAL_CAST; 1290 } 1291 1292 void ASTStmtWriter::VisitUserDefinedLiteral(UserDefinedLiteral *E) { 1293 VisitCallExpr(E); 1294 Writer.AddSourceLocation(E->UDSuffixLoc, Record); 1295 Code = serialization::EXPR_USER_DEFINED_LITERAL; 1296 } 1297 1298 void ASTStmtWriter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) { 1299 VisitExpr(E); 1300 Record.push_back(E->getValue()); 1301 Writer.AddSourceLocation(E->getLocation(), Record); 1302 Code = serialization::EXPR_CXX_BOOL_LITERAL; 1303 } 1304 1305 void ASTStmtWriter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) { 1306 VisitExpr(E); 1307 Writer.AddSourceLocation(E->getLocation(), Record); 1308 Code = serialization::EXPR_CXX_NULL_PTR_LITERAL; 1309 } 1310 1311 void ASTStmtWriter::VisitCXXTypeidExpr(CXXTypeidExpr *E) { 1312 VisitExpr(E); 1313 Writer.AddSourceRange(E->getSourceRange(), Record); 1314 if (E->isTypeOperand()) { 1315 Writer.AddTypeSourceInfo(E->getTypeOperandSourceInfo(), Record); 1316 Code = serialization::EXPR_CXX_TYPEID_TYPE; 1317 } else { 1318 Writer.AddStmt(E->getExprOperand()); 1319 Code = serialization::EXPR_CXX_TYPEID_EXPR; 1320 } 1321 } 1322 1323 void ASTStmtWriter::VisitCXXThisExpr(CXXThisExpr *E) { 1324 VisitExpr(E); 1325 Writer.AddSourceLocation(E->getLocation(), Record); 1326 Record.push_back(E->isImplicit()); 1327 Code = serialization::EXPR_CXX_THIS; 1328 } 1329 1330 void ASTStmtWriter::VisitCXXThrowExpr(CXXThrowExpr *E) { 1331 VisitExpr(E); 1332 Writer.AddSourceLocation(E->getThrowLoc(), Record); 1333 Writer.AddStmt(E->getSubExpr()); 1334 Record.push_back(E->isThrownVariableInScope()); 1335 Code = serialization::EXPR_CXX_THROW; 1336 } 1337 1338 void ASTStmtWriter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) { 1339 VisitExpr(E); 1340 Writer.AddDeclRef(E->getParam(), Record); 1341 Writer.AddSourceLocation(E->getUsedLocation(), Record); 1342 Code = serialization::EXPR_CXX_DEFAULT_ARG; 1343 } 1344 1345 void ASTStmtWriter::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) { 1346 VisitExpr(E); 1347 Writer.AddDeclRef(E->getField(), Record); 1348 Writer.AddSourceLocation(E->getExprLoc(), Record); 1349 Code = serialization::EXPR_CXX_DEFAULT_INIT; 1350 } 1351 1352 void ASTStmtWriter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) { 1353 VisitExpr(E); 1354 Writer.AddCXXTemporary(E->getTemporary(), Record); 1355 Writer.AddStmt(E->getSubExpr()); 1356 Code = serialization::EXPR_CXX_BIND_TEMPORARY; 1357 } 1358 1359 void ASTStmtWriter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) { 1360 VisitExpr(E); 1361 Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record); 1362 Writer.AddSourceLocation(E->getRParenLoc(), Record); 1363 Code = serialization::EXPR_CXX_SCALAR_VALUE_INIT; 1364 } 1365 1366 void ASTStmtWriter::VisitCXXNewExpr(CXXNewExpr *E) { 1367 VisitExpr(E); 1368 Record.push_back(E->isGlobalNew()); 1369 Record.push_back(E->isArray()); 1370 Record.push_back(E->doesUsualArrayDeleteWantSize()); 1371 Record.push_back(E->getNumPlacementArgs()); 1372 Record.push_back(E->StoredInitializationStyle); 1373 Writer.AddDeclRef(E->getOperatorNew(), Record); 1374 Writer.AddDeclRef(E->getOperatorDelete(), Record); 1375 Writer.AddTypeSourceInfo(E->getAllocatedTypeSourceInfo(), Record); 1376 Writer.AddSourceRange(E->getTypeIdParens(), Record); 1377 Writer.AddSourceRange(E->getSourceRange(), Record); 1378 Writer.AddSourceRange(E->getDirectInitRange(), Record); 1379 for (CXXNewExpr::arg_iterator I = E->raw_arg_begin(), e = E->raw_arg_end(); 1380 I != e; ++I) 1381 Writer.AddStmt(*I); 1382 1383 Code = serialization::EXPR_CXX_NEW; 1384 } 1385 1386 void ASTStmtWriter::VisitCXXDeleteExpr(CXXDeleteExpr *E) { 1387 VisitExpr(E); 1388 Record.push_back(E->isGlobalDelete()); 1389 Record.push_back(E->isArrayForm()); 1390 Record.push_back(E->isArrayFormAsWritten()); 1391 Record.push_back(E->doesUsualArrayDeleteWantSize()); 1392 Writer.AddDeclRef(E->getOperatorDelete(), Record); 1393 Writer.AddStmt(E->getArgument()); 1394 Writer.AddSourceLocation(E->getSourceRange().getBegin(), Record); 1395 1396 Code = serialization::EXPR_CXX_DELETE; 1397 } 1398 1399 void ASTStmtWriter::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) { 1400 VisitExpr(E); 1401 1402 Writer.AddStmt(E->getBase()); 1403 Record.push_back(E->isArrow()); 1404 Writer.AddSourceLocation(E->getOperatorLoc(), Record); 1405 Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record); 1406 Writer.AddTypeSourceInfo(E->getScopeTypeInfo(), Record); 1407 Writer.AddSourceLocation(E->getColonColonLoc(), Record); 1408 Writer.AddSourceLocation(E->getTildeLoc(), Record); 1409 1410 // PseudoDestructorTypeStorage. 1411 Writer.AddIdentifierRef(E->getDestroyedTypeIdentifier(), Record); 1412 if (E->getDestroyedTypeIdentifier()) 1413 Writer.AddSourceLocation(E->getDestroyedTypeLoc(), Record); 1414 else 1415 Writer.AddTypeSourceInfo(E->getDestroyedTypeInfo(), Record); 1416 1417 Code = serialization::EXPR_CXX_PSEUDO_DESTRUCTOR; 1418 } 1419 1420 void ASTStmtWriter::VisitExprWithCleanups(ExprWithCleanups *E) { 1421 VisitExpr(E); 1422 Record.push_back(E->getNumObjects()); 1423 for (unsigned i = 0, e = E->getNumObjects(); i != e; ++i) 1424 Writer.AddDeclRef(E->getObject(i), Record); 1425 1426 Writer.AddStmt(E->getSubExpr()); 1427 Code = serialization::EXPR_EXPR_WITH_CLEANUPS; 1428 } 1429 1430 void 1431 ASTStmtWriter::VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E){ 1432 VisitExpr(E); 1433 1434 // Don't emit anything here, HasTemplateKWAndArgsInfo must be 1435 // emitted first. 1436 1437 Record.push_back(E->HasTemplateKWAndArgsInfo); 1438 if (E->HasTemplateKWAndArgsInfo) { 1439 const ASTTemplateKWAndArgsInfo &ArgInfo = 1440 *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(); 1441 Record.push_back(ArgInfo.NumTemplateArgs); 1442 AddTemplateKWAndArgsInfo(ArgInfo, 1443 E->getTrailingObjects<TemplateArgumentLoc>()); 1444 } 1445 1446 if (!E->isImplicitAccess()) 1447 Writer.AddStmt(E->getBase()); 1448 else 1449 Writer.AddStmt(nullptr); 1450 Writer.AddTypeRef(E->getBaseType(), Record); 1451 Record.push_back(E->isArrow()); 1452 Writer.AddSourceLocation(E->getOperatorLoc(), Record); 1453 Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record); 1454 Writer.AddDeclRef(E->getFirstQualifierFoundInScope(), Record); 1455 Writer.AddDeclarationNameInfo(E->MemberNameInfo, Record); 1456 Code = serialization::EXPR_CXX_DEPENDENT_SCOPE_MEMBER; 1457 } 1458 1459 void 1460 ASTStmtWriter::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) { 1461 VisitExpr(E); 1462 1463 // Don't emit anything here, HasTemplateKWAndArgsInfo must be 1464 // emitted first. 1465 1466 Record.push_back(E->HasTemplateKWAndArgsInfo); 1467 if (E->HasTemplateKWAndArgsInfo) { 1468 const ASTTemplateKWAndArgsInfo &ArgInfo = 1469 *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(); 1470 Record.push_back(ArgInfo.NumTemplateArgs); 1471 AddTemplateKWAndArgsInfo(ArgInfo, 1472 E->getTrailingObjects<TemplateArgumentLoc>()); 1473 } 1474 1475 Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record); 1476 Writer.AddDeclarationNameInfo(E->NameInfo, Record); 1477 Code = serialization::EXPR_CXX_DEPENDENT_SCOPE_DECL_REF; 1478 } 1479 1480 void 1481 ASTStmtWriter::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) { 1482 VisitExpr(E); 1483 Record.push_back(E->arg_size()); 1484 for (CXXUnresolvedConstructExpr::arg_iterator 1485 ArgI = E->arg_begin(), ArgE = E->arg_end(); ArgI != ArgE; ++ArgI) 1486 Writer.AddStmt(*ArgI); 1487 Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record); 1488 Writer.AddSourceLocation(E->getLParenLoc(), Record); 1489 Writer.AddSourceLocation(E->getRParenLoc(), Record); 1490 Code = serialization::EXPR_CXX_UNRESOLVED_CONSTRUCT; 1491 } 1492 1493 void ASTStmtWriter::VisitOverloadExpr(OverloadExpr *E) { 1494 VisitExpr(E); 1495 1496 // Don't emit anything here, HasTemplateKWAndArgsInfo must be 1497 // emitted first. 1498 1499 Record.push_back(E->HasTemplateKWAndArgsInfo); 1500 if (E->HasTemplateKWAndArgsInfo) { 1501 const ASTTemplateKWAndArgsInfo &ArgInfo = 1502 *E->getTrailingASTTemplateKWAndArgsInfo(); 1503 Record.push_back(ArgInfo.NumTemplateArgs); 1504 AddTemplateKWAndArgsInfo(ArgInfo, E->getTrailingTemplateArgumentLoc()); 1505 } 1506 1507 Record.push_back(E->getNumDecls()); 1508 for (OverloadExpr::decls_iterator 1509 OvI = E->decls_begin(), OvE = E->decls_end(); OvI != OvE; ++OvI) { 1510 Writer.AddDeclRef(OvI.getDecl(), Record); 1511 Record.push_back(OvI.getAccess()); 1512 } 1513 1514 Writer.AddDeclarationNameInfo(E->NameInfo, Record); 1515 Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record); 1516 } 1517 1518 void ASTStmtWriter::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) { 1519 VisitOverloadExpr(E); 1520 Record.push_back(E->isArrow()); 1521 Record.push_back(E->hasUnresolvedUsing()); 1522 Writer.AddStmt(!E->isImplicitAccess() ? E->getBase() : nullptr); 1523 Writer.AddTypeRef(E->getBaseType(), Record); 1524 Writer.AddSourceLocation(E->getOperatorLoc(), Record); 1525 Code = serialization::EXPR_CXX_UNRESOLVED_MEMBER; 1526 } 1527 1528 void ASTStmtWriter::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) { 1529 VisitOverloadExpr(E); 1530 Record.push_back(E->requiresADL()); 1531 Record.push_back(E->isOverloaded()); 1532 Writer.AddDeclRef(E->getNamingClass(), Record); 1533 Code = serialization::EXPR_CXX_UNRESOLVED_LOOKUP; 1534 } 1535 1536 void ASTStmtWriter::VisitTypeTraitExpr(TypeTraitExpr *E) { 1537 VisitExpr(E); 1538 Record.push_back(E->TypeTraitExprBits.NumArgs); 1539 Record.push_back(E->TypeTraitExprBits.Kind); // FIXME: Stable encoding 1540 Record.push_back(E->TypeTraitExprBits.Value); 1541 Writer.AddSourceRange(E->getSourceRange(), Record); 1542 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) 1543 Writer.AddTypeSourceInfo(E->getArg(I), Record); 1544 Code = serialization::EXPR_TYPE_TRAIT; 1545 } 1546 1547 void ASTStmtWriter::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) { 1548 VisitExpr(E); 1549 Record.push_back(E->getTrait()); 1550 Record.push_back(E->getValue()); 1551 Writer.AddSourceRange(E->getSourceRange(), Record); 1552 Writer.AddTypeSourceInfo(E->getQueriedTypeSourceInfo(), Record); 1553 Code = serialization::EXPR_ARRAY_TYPE_TRAIT; 1554 } 1555 1556 void ASTStmtWriter::VisitExpressionTraitExpr(ExpressionTraitExpr *E) { 1557 VisitExpr(E); 1558 Record.push_back(E->getTrait()); 1559 Record.push_back(E->getValue()); 1560 Writer.AddSourceRange(E->getSourceRange(), Record); 1561 Writer.AddStmt(E->getQueriedExpression()); 1562 Code = serialization::EXPR_CXX_EXPRESSION_TRAIT; 1563 } 1564 1565 void ASTStmtWriter::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) { 1566 VisitExpr(E); 1567 Record.push_back(E->getValue()); 1568 Writer.AddSourceRange(E->getSourceRange(), Record); 1569 Writer.AddStmt(E->getOperand()); 1570 Code = serialization::EXPR_CXX_NOEXCEPT; 1571 } 1572 1573 void ASTStmtWriter::VisitPackExpansionExpr(PackExpansionExpr *E) { 1574 VisitExpr(E); 1575 Writer.AddSourceLocation(E->getEllipsisLoc(), Record); 1576 Record.push_back(E->NumExpansions); 1577 Writer.AddStmt(E->getPattern()); 1578 Code = serialization::EXPR_PACK_EXPANSION; 1579 } 1580 1581 void ASTStmtWriter::VisitSizeOfPackExpr(SizeOfPackExpr *E) { 1582 VisitExpr(E); 1583 Record.push_back(E->isPartiallySubstituted() ? E->getPartialArguments().size() 1584 : 0); 1585 Writer.AddSourceLocation(E->OperatorLoc, Record); 1586 Writer.AddSourceLocation(E->PackLoc, Record); 1587 Writer.AddSourceLocation(E->RParenLoc, Record); 1588 Writer.AddDeclRef(E->Pack, Record); 1589 if (E->isPartiallySubstituted()) { 1590 for (const auto &TA : E->getPartialArguments()) 1591 Writer.AddTemplateArgument(TA, Record); 1592 } else if (!E->isValueDependent()) { 1593 Record.push_back(E->getPackLength()); 1594 } 1595 Code = serialization::EXPR_SIZEOF_PACK; 1596 } 1597 1598 void ASTStmtWriter::VisitSubstNonTypeTemplateParmExpr( 1599 SubstNonTypeTemplateParmExpr *E) { 1600 VisitExpr(E); 1601 Writer.AddDeclRef(E->getParameter(), Record); 1602 Writer.AddSourceLocation(E->getNameLoc(), Record); 1603 Writer.AddStmt(E->getReplacement()); 1604 Code = serialization::EXPR_SUBST_NON_TYPE_TEMPLATE_PARM; 1605 } 1606 1607 void ASTStmtWriter::VisitSubstNonTypeTemplateParmPackExpr( 1608 SubstNonTypeTemplateParmPackExpr *E) { 1609 VisitExpr(E); 1610 Writer.AddDeclRef(E->getParameterPack(), Record); 1611 Writer.AddTemplateArgument(E->getArgumentPack(), Record); 1612 Writer.AddSourceLocation(E->getParameterPackLocation(), Record); 1613 Code = serialization::EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK; 1614 } 1615 1616 void ASTStmtWriter::VisitFunctionParmPackExpr(FunctionParmPackExpr *E) { 1617 VisitExpr(E); 1618 Record.push_back(E->getNumExpansions()); 1619 Writer.AddDeclRef(E->getParameterPack(), Record); 1620 Writer.AddSourceLocation(E->getParameterPackLocation(), Record); 1621 for (FunctionParmPackExpr::iterator I = E->begin(), End = E->end(); 1622 I != End; ++I) 1623 Writer.AddDeclRef(*I, Record); 1624 Code = serialization::EXPR_FUNCTION_PARM_PACK; 1625 } 1626 1627 void ASTStmtWriter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) { 1628 VisitExpr(E); 1629 Writer.AddStmt(E->getTemporary()); 1630 Writer.AddDeclRef(E->getExtendingDecl(), Record); 1631 Record.push_back(E->getManglingNumber()); 1632 Code = serialization::EXPR_MATERIALIZE_TEMPORARY; 1633 } 1634 1635 void ASTStmtWriter::VisitCXXFoldExpr(CXXFoldExpr *E) { 1636 VisitExpr(E); 1637 Writer.AddSourceLocation(E->LParenLoc, Record); 1638 Writer.AddSourceLocation(E->EllipsisLoc, Record); 1639 Writer.AddSourceLocation(E->RParenLoc, Record); 1640 Writer.AddStmt(E->SubExprs[0]); 1641 Writer.AddStmt(E->SubExprs[1]); 1642 Record.push_back(E->Opcode); 1643 Code = serialization::EXPR_CXX_FOLD; 1644 } 1645 1646 void ASTStmtWriter::VisitOpaqueValueExpr(OpaqueValueExpr *E) { 1647 VisitExpr(E); 1648 Writer.AddStmt(E->getSourceExpr()); 1649 Writer.AddSourceLocation(E->getLocation(), Record); 1650 Code = serialization::EXPR_OPAQUE_VALUE; 1651 } 1652 1653 void ASTStmtWriter::VisitTypoExpr(TypoExpr *E) { 1654 VisitExpr(E); 1655 // TODO: Figure out sane writer behavior for a TypoExpr, if necessary 1656 llvm_unreachable("Cannot write TypoExpr nodes"); 1657 } 1658 1659 //===----------------------------------------------------------------------===// 1660 // CUDA Expressions and Statements. 1661 //===----------------------------------------------------------------------===// 1662 1663 void ASTStmtWriter::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *E) { 1664 VisitCallExpr(E); 1665 Writer.AddStmt(E->getConfig()); 1666 Code = serialization::EXPR_CUDA_KERNEL_CALL; 1667 } 1668 1669 //===----------------------------------------------------------------------===// 1670 // OpenCL Expressions and Statements. 1671 //===----------------------------------------------------------------------===// 1672 void ASTStmtWriter::VisitAsTypeExpr(AsTypeExpr *E) { 1673 VisitExpr(E); 1674 Writer.AddSourceLocation(E->getBuiltinLoc(), Record); 1675 Writer.AddSourceLocation(E->getRParenLoc(), Record); 1676 Writer.AddStmt(E->getSrcExpr()); 1677 Code = serialization::EXPR_ASTYPE; 1678 } 1679 1680 //===----------------------------------------------------------------------===// 1681 // Microsoft Expressions and Statements. 1682 //===----------------------------------------------------------------------===// 1683 void ASTStmtWriter::VisitMSPropertyRefExpr(MSPropertyRefExpr *E) { 1684 VisitExpr(E); 1685 Record.push_back(E->isArrow()); 1686 Writer.AddStmt(E->getBaseExpr()); 1687 Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record); 1688 Writer.AddSourceLocation(E->getMemberLoc(), Record); 1689 Writer.AddDeclRef(E->getPropertyDecl(), Record); 1690 Code = serialization::EXPR_CXX_PROPERTY_REF_EXPR; 1691 } 1692 1693 void ASTStmtWriter::VisitMSPropertySubscriptExpr(MSPropertySubscriptExpr *E) { 1694 VisitExpr(E); 1695 Writer.AddStmt(E->getBase()); 1696 Writer.AddStmt(E->getIdx()); 1697 Writer.AddSourceLocation(E->getRBracketLoc(), Record); 1698 Code = serialization::EXPR_CXX_PROPERTY_SUBSCRIPT_EXPR; 1699 } 1700 1701 void ASTStmtWriter::VisitCXXUuidofExpr(CXXUuidofExpr *E) { 1702 VisitExpr(E); 1703 Writer.AddSourceRange(E->getSourceRange(), Record); 1704 Writer.AddString(E->getUuidStr(), Record); 1705 if (E->isTypeOperand()) { 1706 Writer.AddTypeSourceInfo(E->getTypeOperandSourceInfo(), Record); 1707 Code = serialization::EXPR_CXX_UUIDOF_TYPE; 1708 } else { 1709 Writer.AddStmt(E->getExprOperand()); 1710 Code = serialization::EXPR_CXX_UUIDOF_EXPR; 1711 } 1712 } 1713 1714 void ASTStmtWriter::VisitSEHExceptStmt(SEHExceptStmt *S) { 1715 VisitStmt(S); 1716 Writer.AddSourceLocation(S->getExceptLoc(), Record); 1717 Writer.AddStmt(S->getFilterExpr()); 1718 Writer.AddStmt(S->getBlock()); 1719 Code = serialization::STMT_SEH_EXCEPT; 1720 } 1721 1722 void ASTStmtWriter::VisitSEHFinallyStmt(SEHFinallyStmt *S) { 1723 VisitStmt(S); 1724 Writer.AddSourceLocation(S->getFinallyLoc(), Record); 1725 Writer.AddStmt(S->getBlock()); 1726 Code = serialization::STMT_SEH_FINALLY; 1727 } 1728 1729 void ASTStmtWriter::VisitSEHTryStmt(SEHTryStmt *S) { 1730 VisitStmt(S); 1731 Record.push_back(S->getIsCXXTry()); 1732 Writer.AddSourceLocation(S->getTryLoc(), Record); 1733 Writer.AddStmt(S->getTryBlock()); 1734 Writer.AddStmt(S->getHandler()); 1735 Code = serialization::STMT_SEH_TRY; 1736 } 1737 1738 void ASTStmtWriter::VisitSEHLeaveStmt(SEHLeaveStmt *S) { 1739 VisitStmt(S); 1740 Writer.AddSourceLocation(S->getLeaveLoc(), Record); 1741 Code = serialization::STMT_SEH_LEAVE; 1742 } 1743 1744 //===----------------------------------------------------------------------===// 1745 // OpenMP Clauses. 1746 //===----------------------------------------------------------------------===// 1747 1748 namespace clang { 1749 class OMPClauseWriter : public OMPClauseVisitor<OMPClauseWriter> { 1750 ASTStmtWriter *Writer; 1751 ASTWriter::RecordData &Record; 1752 public: 1753 OMPClauseWriter(ASTStmtWriter *W, ASTWriter::RecordData &Record) 1754 : Writer(W), Record(Record) { } 1755 #define OPENMP_CLAUSE(Name, Class) \ 1756 void Visit##Class(Class *S); 1757 #include "clang/Basic/OpenMPKinds.def" 1758 void writeClause(OMPClause *C); 1759 void VisitOMPClauseWithPreInit(OMPClauseWithPreInit *C); 1760 void VisitOMPClauseWithPostUpdate(OMPClauseWithPostUpdate *C); 1761 }; 1762 } 1763 1764 void OMPClauseWriter::writeClause(OMPClause *C) { 1765 Record.push_back(C->getClauseKind()); 1766 Visit(C); 1767 Writer->Writer.AddSourceLocation(C->getLocStart(), Record); 1768 Writer->Writer.AddSourceLocation(C->getLocEnd(), Record); 1769 } 1770 1771 void OMPClauseWriter::VisitOMPClauseWithPreInit(OMPClauseWithPreInit *C) { 1772 Writer->Writer.AddStmt(C->getPreInitStmt()); 1773 } 1774 1775 void OMPClauseWriter::VisitOMPClauseWithPostUpdate(OMPClauseWithPostUpdate *C) { 1776 VisitOMPClauseWithPreInit(C); 1777 Writer->Writer.AddStmt(C->getPostUpdateExpr()); 1778 } 1779 1780 void OMPClauseWriter::VisitOMPIfClause(OMPIfClause *C) { 1781 Record.push_back(C->getNameModifier()); 1782 Writer->Writer.AddSourceLocation(C->getNameModifierLoc(), Record); 1783 Writer->Writer.AddSourceLocation(C->getColonLoc(), Record); 1784 Writer->Writer.AddStmt(C->getCondition()); 1785 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 1786 } 1787 1788 void OMPClauseWriter::VisitOMPFinalClause(OMPFinalClause *C) { 1789 Writer->Writer.AddStmt(C->getCondition()); 1790 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 1791 } 1792 1793 void OMPClauseWriter::VisitOMPNumThreadsClause(OMPNumThreadsClause *C) { 1794 Writer->Writer.AddStmt(C->getNumThreads()); 1795 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 1796 } 1797 1798 void OMPClauseWriter::VisitOMPSafelenClause(OMPSafelenClause *C) { 1799 Writer->Writer.AddStmt(C->getSafelen()); 1800 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 1801 } 1802 1803 void OMPClauseWriter::VisitOMPSimdlenClause(OMPSimdlenClause *C) { 1804 Writer->Writer.AddStmt(C->getSimdlen()); 1805 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 1806 } 1807 1808 void OMPClauseWriter::VisitOMPCollapseClause(OMPCollapseClause *C) { 1809 Writer->Writer.AddStmt(C->getNumForLoops()); 1810 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 1811 } 1812 1813 void OMPClauseWriter::VisitOMPDefaultClause(OMPDefaultClause *C) { 1814 Record.push_back(C->getDefaultKind()); 1815 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 1816 Writer->Writer.AddSourceLocation(C->getDefaultKindKwLoc(), Record); 1817 } 1818 1819 void OMPClauseWriter::VisitOMPProcBindClause(OMPProcBindClause *C) { 1820 Record.push_back(C->getProcBindKind()); 1821 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 1822 Writer->Writer.AddSourceLocation(C->getProcBindKindKwLoc(), Record); 1823 } 1824 1825 void OMPClauseWriter::VisitOMPScheduleClause(OMPScheduleClause *C) { 1826 VisitOMPClauseWithPreInit(C); 1827 Record.push_back(C->getScheduleKind()); 1828 Record.push_back(C->getFirstScheduleModifier()); 1829 Record.push_back(C->getSecondScheduleModifier()); 1830 Writer->Writer.AddStmt(C->getChunkSize()); 1831 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 1832 Writer->Writer.AddSourceLocation(C->getFirstScheduleModifierLoc(), Record); 1833 Writer->Writer.AddSourceLocation(C->getSecondScheduleModifierLoc(), Record); 1834 Writer->Writer.AddSourceLocation(C->getScheduleKindLoc(), Record); 1835 Writer->Writer.AddSourceLocation(C->getCommaLoc(), Record); 1836 } 1837 1838 void OMPClauseWriter::VisitOMPOrderedClause(OMPOrderedClause *C) { 1839 Writer->Writer.AddStmt(C->getNumForLoops()); 1840 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 1841 } 1842 1843 void OMPClauseWriter::VisitOMPNowaitClause(OMPNowaitClause *) {} 1844 1845 void OMPClauseWriter::VisitOMPUntiedClause(OMPUntiedClause *) {} 1846 1847 void OMPClauseWriter::VisitOMPMergeableClause(OMPMergeableClause *) {} 1848 1849 void OMPClauseWriter::VisitOMPReadClause(OMPReadClause *) {} 1850 1851 void OMPClauseWriter::VisitOMPWriteClause(OMPWriteClause *) {} 1852 1853 void OMPClauseWriter::VisitOMPUpdateClause(OMPUpdateClause *) {} 1854 1855 void OMPClauseWriter::VisitOMPCaptureClause(OMPCaptureClause *) {} 1856 1857 void OMPClauseWriter::VisitOMPSeqCstClause(OMPSeqCstClause *) {} 1858 1859 void OMPClauseWriter::VisitOMPThreadsClause(OMPThreadsClause *) {} 1860 1861 void OMPClauseWriter::VisitOMPSIMDClause(OMPSIMDClause *) {} 1862 1863 void OMPClauseWriter::VisitOMPNogroupClause(OMPNogroupClause *) {} 1864 1865 void OMPClauseWriter::VisitOMPPrivateClause(OMPPrivateClause *C) { 1866 Record.push_back(C->varlist_size()); 1867 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 1868 for (auto *VE : C->varlists()) { 1869 Writer->Writer.AddStmt(VE); 1870 } 1871 for (auto *VE : C->private_copies()) { 1872 Writer->Writer.AddStmt(VE); 1873 } 1874 } 1875 1876 void OMPClauseWriter::VisitOMPFirstprivateClause(OMPFirstprivateClause *C) { 1877 Record.push_back(C->varlist_size()); 1878 VisitOMPClauseWithPreInit(C); 1879 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 1880 for (auto *VE : C->varlists()) { 1881 Writer->Writer.AddStmt(VE); 1882 } 1883 for (auto *VE : C->private_copies()) { 1884 Writer->Writer.AddStmt(VE); 1885 } 1886 for (auto *VE : C->inits()) { 1887 Writer->Writer.AddStmt(VE); 1888 } 1889 } 1890 1891 void OMPClauseWriter::VisitOMPLastprivateClause(OMPLastprivateClause *C) { 1892 Record.push_back(C->varlist_size()); 1893 VisitOMPClauseWithPostUpdate(C); 1894 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 1895 for (auto *VE : C->varlists()) 1896 Writer->Writer.AddStmt(VE); 1897 for (auto *E : C->private_copies()) 1898 Writer->Writer.AddStmt(E); 1899 for (auto *E : C->source_exprs()) 1900 Writer->Writer.AddStmt(E); 1901 for (auto *E : C->destination_exprs()) 1902 Writer->Writer.AddStmt(E); 1903 for (auto *E : C->assignment_ops()) 1904 Writer->Writer.AddStmt(E); 1905 } 1906 1907 void OMPClauseWriter::VisitOMPSharedClause(OMPSharedClause *C) { 1908 Record.push_back(C->varlist_size()); 1909 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 1910 for (auto *VE : C->varlists()) 1911 Writer->Writer.AddStmt(VE); 1912 } 1913 1914 void OMPClauseWriter::VisitOMPReductionClause(OMPReductionClause *C) { 1915 Record.push_back(C->varlist_size()); 1916 VisitOMPClauseWithPostUpdate(C); 1917 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 1918 Writer->Writer.AddSourceLocation(C->getColonLoc(), Record); 1919 Writer->Writer.AddNestedNameSpecifierLoc(C->getQualifierLoc(), Record); 1920 Writer->Writer.AddDeclarationNameInfo(C->getNameInfo(), Record); 1921 for (auto *VE : C->varlists()) 1922 Writer->Writer.AddStmt(VE); 1923 for (auto *VE : C->privates()) 1924 Writer->Writer.AddStmt(VE); 1925 for (auto *E : C->lhs_exprs()) 1926 Writer->Writer.AddStmt(E); 1927 for (auto *E : C->rhs_exprs()) 1928 Writer->Writer.AddStmt(E); 1929 for (auto *E : C->reduction_ops()) 1930 Writer->Writer.AddStmt(E); 1931 } 1932 1933 void OMPClauseWriter::VisitOMPLinearClause(OMPLinearClause *C) { 1934 Record.push_back(C->varlist_size()); 1935 VisitOMPClauseWithPostUpdate(C); 1936 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 1937 Writer->Writer.AddSourceLocation(C->getColonLoc(), Record); 1938 Record.push_back(C->getModifier()); 1939 Writer->Writer.AddSourceLocation(C->getModifierLoc(), Record); 1940 for (auto *VE : C->varlists()) { 1941 Writer->Writer.AddStmt(VE); 1942 } 1943 for (auto *VE : C->privates()) { 1944 Writer->Writer.AddStmt(VE); 1945 } 1946 for (auto *VE : C->inits()) { 1947 Writer->Writer.AddStmt(VE); 1948 } 1949 for (auto *VE : C->updates()) { 1950 Writer->Writer.AddStmt(VE); 1951 } 1952 for (auto *VE : C->finals()) { 1953 Writer->Writer.AddStmt(VE); 1954 } 1955 Writer->Writer.AddStmt(C->getStep()); 1956 Writer->Writer.AddStmt(C->getCalcStep()); 1957 } 1958 1959 void OMPClauseWriter::VisitOMPAlignedClause(OMPAlignedClause *C) { 1960 Record.push_back(C->varlist_size()); 1961 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 1962 Writer->Writer.AddSourceLocation(C->getColonLoc(), Record); 1963 for (auto *VE : C->varlists()) 1964 Writer->Writer.AddStmt(VE); 1965 Writer->Writer.AddStmt(C->getAlignment()); 1966 } 1967 1968 void OMPClauseWriter::VisitOMPCopyinClause(OMPCopyinClause *C) { 1969 Record.push_back(C->varlist_size()); 1970 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 1971 for (auto *VE : C->varlists()) 1972 Writer->Writer.AddStmt(VE); 1973 for (auto *E : C->source_exprs()) 1974 Writer->Writer.AddStmt(E); 1975 for (auto *E : C->destination_exprs()) 1976 Writer->Writer.AddStmt(E); 1977 for (auto *E : C->assignment_ops()) 1978 Writer->Writer.AddStmt(E); 1979 } 1980 1981 void OMPClauseWriter::VisitOMPCopyprivateClause(OMPCopyprivateClause *C) { 1982 Record.push_back(C->varlist_size()); 1983 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 1984 for (auto *VE : C->varlists()) 1985 Writer->Writer.AddStmt(VE); 1986 for (auto *E : C->source_exprs()) 1987 Writer->Writer.AddStmt(E); 1988 for (auto *E : C->destination_exprs()) 1989 Writer->Writer.AddStmt(E); 1990 for (auto *E : C->assignment_ops()) 1991 Writer->Writer.AddStmt(E); 1992 } 1993 1994 void OMPClauseWriter::VisitOMPFlushClause(OMPFlushClause *C) { 1995 Record.push_back(C->varlist_size()); 1996 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 1997 for (auto *VE : C->varlists()) 1998 Writer->Writer.AddStmt(VE); 1999 } 2000 2001 void OMPClauseWriter::VisitOMPDependClause(OMPDependClause *C) { 2002 Record.push_back(C->varlist_size()); 2003 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 2004 Record.push_back(C->getDependencyKind()); 2005 Writer->Writer.AddSourceLocation(C->getDependencyLoc(), Record); 2006 Writer->Writer.AddSourceLocation(C->getColonLoc(), Record); 2007 for (auto *VE : C->varlists()) 2008 Writer->Writer.AddStmt(VE); 2009 } 2010 2011 void OMPClauseWriter::VisitOMPDeviceClause(OMPDeviceClause *C) { 2012 Writer->Writer.AddStmt(C->getDevice()); 2013 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 2014 } 2015 2016 void OMPClauseWriter::VisitOMPMapClause(OMPMapClause *C) { 2017 Record.push_back(C->varlist_size()); 2018 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 2019 Record.push_back(C->getMapTypeModifier()); 2020 Record.push_back(C->getMapType()); 2021 Writer->Writer.AddSourceLocation(C->getMapLoc(), Record); 2022 Writer->Writer.AddSourceLocation(C->getColonLoc(), Record); 2023 for (auto *VE : C->varlists()) 2024 Writer->Writer.AddStmt(VE); 2025 } 2026 2027 void OMPClauseWriter::VisitOMPNumTeamsClause(OMPNumTeamsClause *C) { 2028 Writer->Writer.AddStmt(C->getNumTeams()); 2029 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 2030 } 2031 2032 void OMPClauseWriter::VisitOMPThreadLimitClause(OMPThreadLimitClause *C) { 2033 Writer->Writer.AddStmt(C->getThreadLimit()); 2034 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 2035 } 2036 2037 void OMPClauseWriter::VisitOMPPriorityClause(OMPPriorityClause *C) { 2038 Writer->Writer.AddStmt(C->getPriority()); 2039 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 2040 } 2041 2042 void OMPClauseWriter::VisitOMPGrainsizeClause(OMPGrainsizeClause *C) { 2043 Writer->Writer.AddStmt(C->getGrainsize()); 2044 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 2045 } 2046 2047 void OMPClauseWriter::VisitOMPNumTasksClause(OMPNumTasksClause *C) { 2048 Writer->Writer.AddStmt(C->getNumTasks()); 2049 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 2050 } 2051 2052 void OMPClauseWriter::VisitOMPHintClause(OMPHintClause *C) { 2053 Writer->Writer.AddStmt(C->getHint()); 2054 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 2055 } 2056 2057 void OMPClauseWriter::VisitOMPDistScheduleClause(OMPDistScheduleClause *C) { 2058 VisitOMPClauseWithPreInit(C); 2059 Record.push_back(C->getDistScheduleKind()); 2060 Writer->Writer.AddStmt(C->getChunkSize()); 2061 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 2062 Writer->Writer.AddSourceLocation(C->getDistScheduleKindLoc(), Record); 2063 Writer->Writer.AddSourceLocation(C->getCommaLoc(), Record); 2064 } 2065 2066 void OMPClauseWriter::VisitOMPDefaultmapClause(OMPDefaultmapClause *C) { 2067 Record.push_back(C->getDefaultmapKind()); 2068 Record.push_back(C->getDefaultmapModifier()); 2069 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 2070 Writer->Writer.AddSourceLocation(C->getDefaultmapModifierLoc(), Record); 2071 Writer->Writer.AddSourceLocation(C->getDefaultmapKindLoc(), Record); 2072 } 2073 2074 //===----------------------------------------------------------------------===// 2075 // OpenMP Directives. 2076 //===----------------------------------------------------------------------===// 2077 void ASTStmtWriter::VisitOMPExecutableDirective(OMPExecutableDirective *E) { 2078 Writer.AddSourceLocation(E->getLocStart(), Record); 2079 Writer.AddSourceLocation(E->getLocEnd(), Record); 2080 OMPClauseWriter ClauseWriter(this, Record); 2081 for (unsigned i = 0; i < E->getNumClauses(); ++i) { 2082 ClauseWriter.writeClause(E->getClause(i)); 2083 } 2084 if (E->hasAssociatedStmt()) 2085 Writer.AddStmt(E->getAssociatedStmt()); 2086 } 2087 2088 void ASTStmtWriter::VisitOMPLoopDirective(OMPLoopDirective *D) { 2089 VisitStmt(D); 2090 Record.push_back(D->getNumClauses()); 2091 Record.push_back(D->getCollapsedNumber()); 2092 VisitOMPExecutableDirective(D); 2093 Writer.AddStmt(D->getIterationVariable()); 2094 Writer.AddStmt(D->getLastIteration()); 2095 Writer.AddStmt(D->getCalcLastIteration()); 2096 Writer.AddStmt(D->getPreCond()); 2097 Writer.AddStmt(D->getCond()); 2098 Writer.AddStmt(D->getInit()); 2099 Writer.AddStmt(D->getInc()); 2100 if (isOpenMPWorksharingDirective(D->getDirectiveKind()) || 2101 isOpenMPTaskLoopDirective(D->getDirectiveKind()) || 2102 isOpenMPDistributeDirective(D->getDirectiveKind())) { 2103 Writer.AddStmt(D->getIsLastIterVariable()); 2104 Writer.AddStmt(D->getLowerBoundVariable()); 2105 Writer.AddStmt(D->getUpperBoundVariable()); 2106 Writer.AddStmt(D->getStrideVariable()); 2107 Writer.AddStmt(D->getEnsureUpperBound()); 2108 Writer.AddStmt(D->getNextLowerBound()); 2109 Writer.AddStmt(D->getNextUpperBound()); 2110 } 2111 for (auto I : D->counters()) { 2112 Writer.AddStmt(I); 2113 } 2114 for (auto I : D->private_counters()) { 2115 Writer.AddStmt(I); 2116 } 2117 for (auto I : D->inits()) { 2118 Writer.AddStmt(I); 2119 } 2120 for (auto I : D->updates()) { 2121 Writer.AddStmt(I); 2122 } 2123 for (auto I : D->finals()) { 2124 Writer.AddStmt(I); 2125 } 2126 } 2127 2128 void ASTStmtWriter::VisitOMPParallelDirective(OMPParallelDirective *D) { 2129 VisitStmt(D); 2130 Record.push_back(D->getNumClauses()); 2131 VisitOMPExecutableDirective(D); 2132 Record.push_back(D->hasCancel() ? 1 : 0); 2133 Code = serialization::STMT_OMP_PARALLEL_DIRECTIVE; 2134 } 2135 2136 void ASTStmtWriter::VisitOMPSimdDirective(OMPSimdDirective *D) { 2137 VisitOMPLoopDirective(D); 2138 Code = serialization::STMT_OMP_SIMD_DIRECTIVE; 2139 } 2140 2141 void ASTStmtWriter::VisitOMPForDirective(OMPForDirective *D) { 2142 VisitOMPLoopDirective(D); 2143 Record.push_back(D->hasCancel() ? 1 : 0); 2144 Code = serialization::STMT_OMP_FOR_DIRECTIVE; 2145 } 2146 2147 void ASTStmtWriter::VisitOMPForSimdDirective(OMPForSimdDirective *D) { 2148 VisitOMPLoopDirective(D); 2149 Code = serialization::STMT_OMP_FOR_SIMD_DIRECTIVE; 2150 } 2151 2152 void ASTStmtWriter::VisitOMPSectionsDirective(OMPSectionsDirective *D) { 2153 VisitStmt(D); 2154 Record.push_back(D->getNumClauses()); 2155 VisitOMPExecutableDirective(D); 2156 Record.push_back(D->hasCancel() ? 1 : 0); 2157 Code = serialization::STMT_OMP_SECTIONS_DIRECTIVE; 2158 } 2159 2160 void ASTStmtWriter::VisitOMPSectionDirective(OMPSectionDirective *D) { 2161 VisitStmt(D); 2162 VisitOMPExecutableDirective(D); 2163 Record.push_back(D->hasCancel() ? 1 : 0); 2164 Code = serialization::STMT_OMP_SECTION_DIRECTIVE; 2165 } 2166 2167 void ASTStmtWriter::VisitOMPSingleDirective(OMPSingleDirective *D) { 2168 VisitStmt(D); 2169 Record.push_back(D->getNumClauses()); 2170 VisitOMPExecutableDirective(D); 2171 Code = serialization::STMT_OMP_SINGLE_DIRECTIVE; 2172 } 2173 2174 void ASTStmtWriter::VisitOMPMasterDirective(OMPMasterDirective *D) { 2175 VisitStmt(D); 2176 VisitOMPExecutableDirective(D); 2177 Code = serialization::STMT_OMP_MASTER_DIRECTIVE; 2178 } 2179 2180 void ASTStmtWriter::VisitOMPCriticalDirective(OMPCriticalDirective *D) { 2181 VisitStmt(D); 2182 Record.push_back(D->getNumClauses()); 2183 VisitOMPExecutableDirective(D); 2184 Writer.AddDeclarationNameInfo(D->getDirectiveName(), Record); 2185 Code = serialization::STMT_OMP_CRITICAL_DIRECTIVE; 2186 } 2187 2188 void ASTStmtWriter::VisitOMPParallelForDirective(OMPParallelForDirective *D) { 2189 VisitOMPLoopDirective(D); 2190 Record.push_back(D->hasCancel() ? 1 : 0); 2191 Code = serialization::STMT_OMP_PARALLEL_FOR_DIRECTIVE; 2192 } 2193 2194 void ASTStmtWriter::VisitOMPParallelForSimdDirective( 2195 OMPParallelForSimdDirective *D) { 2196 VisitOMPLoopDirective(D); 2197 Code = serialization::STMT_OMP_PARALLEL_FOR_SIMD_DIRECTIVE; 2198 } 2199 2200 void ASTStmtWriter::VisitOMPParallelSectionsDirective( 2201 OMPParallelSectionsDirective *D) { 2202 VisitStmt(D); 2203 Record.push_back(D->getNumClauses()); 2204 VisitOMPExecutableDirective(D); 2205 Record.push_back(D->hasCancel() ? 1 : 0); 2206 Code = serialization::STMT_OMP_PARALLEL_SECTIONS_DIRECTIVE; 2207 } 2208 2209 void ASTStmtWriter::VisitOMPTaskDirective(OMPTaskDirective *D) { 2210 VisitStmt(D); 2211 Record.push_back(D->getNumClauses()); 2212 VisitOMPExecutableDirective(D); 2213 Record.push_back(D->hasCancel() ? 1 : 0); 2214 Code = serialization::STMT_OMP_TASK_DIRECTIVE; 2215 } 2216 2217 void ASTStmtWriter::VisitOMPAtomicDirective(OMPAtomicDirective *D) { 2218 VisitStmt(D); 2219 Record.push_back(D->getNumClauses()); 2220 VisitOMPExecutableDirective(D); 2221 Writer.AddStmt(D->getX()); 2222 Writer.AddStmt(D->getV()); 2223 Writer.AddStmt(D->getExpr()); 2224 Writer.AddStmt(D->getUpdateExpr()); 2225 Record.push_back(D->isXLHSInRHSPart() ? 1 : 0); 2226 Record.push_back(D->isPostfixUpdate() ? 1 : 0); 2227 Code = serialization::STMT_OMP_ATOMIC_DIRECTIVE; 2228 } 2229 2230 void ASTStmtWriter::VisitOMPTargetDirective(OMPTargetDirective *D) { 2231 VisitStmt(D); 2232 Record.push_back(D->getNumClauses()); 2233 VisitOMPExecutableDirective(D); 2234 Code = serialization::STMT_OMP_TARGET_DIRECTIVE; 2235 } 2236 2237 void ASTStmtWriter::VisitOMPTargetDataDirective(OMPTargetDataDirective *D) { 2238 VisitStmt(D); 2239 Record.push_back(D->getNumClauses()); 2240 VisitOMPExecutableDirective(D); 2241 Code = serialization::STMT_OMP_TARGET_DATA_DIRECTIVE; 2242 } 2243 2244 void ASTStmtWriter::VisitOMPTargetEnterDataDirective( 2245 OMPTargetEnterDataDirective *D) { 2246 VisitStmt(D); 2247 Record.push_back(D->getNumClauses()); 2248 VisitOMPExecutableDirective(D); 2249 Code = serialization::STMT_OMP_TARGET_ENTER_DATA_DIRECTIVE; 2250 } 2251 2252 void ASTStmtWriter::VisitOMPTargetExitDataDirective( 2253 OMPTargetExitDataDirective *D) { 2254 VisitStmt(D); 2255 Record.push_back(D->getNumClauses()); 2256 VisitOMPExecutableDirective(D); 2257 Code = serialization::STMT_OMP_TARGET_EXIT_DATA_DIRECTIVE; 2258 } 2259 2260 void ASTStmtWriter::VisitOMPTargetParallelDirective( 2261 OMPTargetParallelDirective *D) { 2262 VisitStmt(D); 2263 Record.push_back(D->getNumClauses()); 2264 VisitOMPExecutableDirective(D); 2265 Code = serialization::STMT_OMP_TARGET_PARALLEL_DIRECTIVE; 2266 } 2267 2268 void ASTStmtWriter::VisitOMPTargetParallelForDirective( 2269 OMPTargetParallelForDirective *D) { 2270 VisitOMPLoopDirective(D); 2271 Record.push_back(D->hasCancel() ? 1 : 0); 2272 Code = serialization::STMT_OMP_TARGET_PARALLEL_FOR_DIRECTIVE; 2273 } 2274 2275 void ASTStmtWriter::VisitOMPTaskyieldDirective(OMPTaskyieldDirective *D) { 2276 VisitStmt(D); 2277 VisitOMPExecutableDirective(D); 2278 Code = serialization::STMT_OMP_TASKYIELD_DIRECTIVE; 2279 } 2280 2281 void ASTStmtWriter::VisitOMPBarrierDirective(OMPBarrierDirective *D) { 2282 VisitStmt(D); 2283 VisitOMPExecutableDirective(D); 2284 Code = serialization::STMT_OMP_BARRIER_DIRECTIVE; 2285 } 2286 2287 void ASTStmtWriter::VisitOMPTaskwaitDirective(OMPTaskwaitDirective *D) { 2288 VisitStmt(D); 2289 VisitOMPExecutableDirective(D); 2290 Code = serialization::STMT_OMP_TASKWAIT_DIRECTIVE; 2291 } 2292 2293 void ASTStmtWriter::VisitOMPTaskgroupDirective(OMPTaskgroupDirective *D) { 2294 VisitStmt(D); 2295 VisitOMPExecutableDirective(D); 2296 Code = serialization::STMT_OMP_TASKGROUP_DIRECTIVE; 2297 } 2298 2299 void ASTStmtWriter::VisitOMPFlushDirective(OMPFlushDirective *D) { 2300 VisitStmt(D); 2301 Record.push_back(D->getNumClauses()); 2302 VisitOMPExecutableDirective(D); 2303 Code = serialization::STMT_OMP_FLUSH_DIRECTIVE; 2304 } 2305 2306 void ASTStmtWriter::VisitOMPOrderedDirective(OMPOrderedDirective *D) { 2307 VisitStmt(D); 2308 Record.push_back(D->getNumClauses()); 2309 VisitOMPExecutableDirective(D); 2310 Code = serialization::STMT_OMP_ORDERED_DIRECTIVE; 2311 } 2312 2313 void ASTStmtWriter::VisitOMPTeamsDirective(OMPTeamsDirective *D) { 2314 VisitStmt(D); 2315 Record.push_back(D->getNumClauses()); 2316 VisitOMPExecutableDirective(D); 2317 Code = serialization::STMT_OMP_TEAMS_DIRECTIVE; 2318 } 2319 2320 void ASTStmtWriter::VisitOMPCancellationPointDirective( 2321 OMPCancellationPointDirective *D) { 2322 VisitStmt(D); 2323 VisitOMPExecutableDirective(D); 2324 Record.push_back(D->getCancelRegion()); 2325 Code = serialization::STMT_OMP_CANCELLATION_POINT_DIRECTIVE; 2326 } 2327 2328 void ASTStmtWriter::VisitOMPCancelDirective(OMPCancelDirective *D) { 2329 VisitStmt(D); 2330 Record.push_back(D->getNumClauses()); 2331 VisitOMPExecutableDirective(D); 2332 Record.push_back(D->getCancelRegion()); 2333 Code = serialization::STMT_OMP_CANCEL_DIRECTIVE; 2334 } 2335 2336 void ASTStmtWriter::VisitOMPTaskLoopDirective(OMPTaskLoopDirective *D) { 2337 VisitOMPLoopDirective(D); 2338 Code = serialization::STMT_OMP_TASKLOOP_DIRECTIVE; 2339 } 2340 2341 void ASTStmtWriter::VisitOMPTaskLoopSimdDirective(OMPTaskLoopSimdDirective *D) { 2342 VisitOMPLoopDirective(D); 2343 Code = serialization::STMT_OMP_TASKLOOP_SIMD_DIRECTIVE; 2344 } 2345 2346 void ASTStmtWriter::VisitOMPDistributeDirective(OMPDistributeDirective *D) { 2347 VisitOMPLoopDirective(D); 2348 Code = serialization::STMT_OMP_DISTRIBUTE_DIRECTIVE; 2349 } 2350 2351 //===----------------------------------------------------------------------===// 2352 // ASTWriter Implementation 2353 //===----------------------------------------------------------------------===// 2354 2355 unsigned ASTWriter::RecordSwitchCaseID(SwitchCase *S) { 2356 assert(SwitchCaseIDs.find(S) == SwitchCaseIDs.end() && 2357 "SwitchCase recorded twice"); 2358 unsigned NextID = SwitchCaseIDs.size(); 2359 SwitchCaseIDs[S] = NextID; 2360 return NextID; 2361 } 2362 2363 unsigned ASTWriter::getSwitchCaseID(SwitchCase *S) { 2364 assert(SwitchCaseIDs.find(S) != SwitchCaseIDs.end() && 2365 "SwitchCase hasn't been seen yet"); 2366 return SwitchCaseIDs[S]; 2367 } 2368 2369 void ASTWriter::ClearSwitchCaseIDs() { 2370 SwitchCaseIDs.clear(); 2371 } 2372 2373 /// \brief Write the given substatement or subexpression to the 2374 /// bitstream. 2375 void ASTWriter::WriteSubStmt(Stmt *S, 2376 llvm::DenseMap<Stmt *, uint64_t> &SubStmtEntries, 2377 llvm::DenseSet<Stmt *> &ParentStmts) { 2378 RecordData Record; 2379 ASTStmtWriter Writer(*this, Record); 2380 ++NumStatements; 2381 2382 if (!S) { 2383 Stream.EmitRecord(serialization::STMT_NULL_PTR, Record); 2384 return; 2385 } 2386 2387 llvm::DenseMap<Stmt *, uint64_t>::iterator I = SubStmtEntries.find(S); 2388 if (I != SubStmtEntries.end()) { 2389 Record.push_back(I->second); 2390 Stream.EmitRecord(serialization::STMT_REF_PTR, Record); 2391 return; 2392 } 2393 2394 #ifndef NDEBUG 2395 assert(!ParentStmts.count(S) && "There is a Stmt cycle!"); 2396 2397 struct ParentStmtInserterRAII { 2398 Stmt *S; 2399 llvm::DenseSet<Stmt *> &ParentStmts; 2400 2401 ParentStmtInserterRAII(Stmt *S, llvm::DenseSet<Stmt *> &ParentStmts) 2402 : S(S), ParentStmts(ParentStmts) { 2403 ParentStmts.insert(S); 2404 } 2405 ~ParentStmtInserterRAII() { 2406 ParentStmts.erase(S); 2407 } 2408 }; 2409 2410 ParentStmtInserterRAII ParentStmtInserter(S, ParentStmts); 2411 #endif 2412 2413 // Redirect ASTWriter::AddStmt to collect sub-stmts. 2414 SmallVector<Stmt *, 16> SubStmts; 2415 CollectedStmts = &SubStmts; 2416 2417 Writer.Code = serialization::STMT_NULL_PTR; 2418 Writer.AbbrevToUse = 0; 2419 Writer.Visit(S); 2420 2421 #ifndef NDEBUG 2422 if (Writer.Code == serialization::STMT_NULL_PTR) { 2423 SourceManager &SrcMgr 2424 = DeclIDs.begin()->first->getASTContext().getSourceManager(); 2425 S->dump(SrcMgr); 2426 llvm_unreachable("Unhandled sub-statement writing AST file"); 2427 } 2428 #endif 2429 2430 // Revert ASTWriter::AddStmt. 2431 CollectedStmts = &StmtsToEmit; 2432 2433 // Write the sub-stmts in reverse order, last to first. When reading them back 2434 // we will read them in correct order by "pop"ing them from the Stmts stack. 2435 // This simplifies reading and allows to store a variable number of sub-stmts 2436 // without knowing it in advance. 2437 while (!SubStmts.empty()) 2438 WriteSubStmt(SubStmts.pop_back_val(), SubStmtEntries, ParentStmts); 2439 2440 Stream.EmitRecord(Writer.Code, Record, Writer.AbbrevToUse); 2441 2442 SubStmtEntries[S] = Stream.GetCurrentBitNo(); 2443 } 2444 2445 /// \brief Flush all of the statements that have been added to the 2446 /// queue via AddStmt(). 2447 void ASTWriter::FlushStmts() { 2448 RecordData Record; 2449 2450 // We expect to be the only consumer of the two temporary statement maps, 2451 // assert that they are empty. 2452 assert(SubStmtEntries.empty() && "unexpected entries in sub-stmt map"); 2453 assert(ParentStmts.empty() && "unexpected entries in parent stmt map"); 2454 2455 for (unsigned I = 0, N = StmtsToEmit.size(); I != N; ++I) { 2456 WriteSubStmt(StmtsToEmit[I], SubStmtEntries, ParentStmts); 2457 2458 assert(N == StmtsToEmit.size() && 2459 "Substatement written via AddStmt rather than WriteSubStmt!"); 2460 2461 // Note that we are at the end of a full expression. Any 2462 // expression records that follow this one are part of a different 2463 // expression. 2464 Stream.EmitRecord(serialization::STMT_STOP, Record); 2465 2466 SubStmtEntries.clear(); 2467 ParentStmts.clear(); 2468 } 2469 2470 StmtsToEmit.clear(); 2471 } 2472