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->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 1172 void 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 1182 void 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 1190 void ASTStmtWriter::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) { 1191 VisitCallExpr(E); 1192 Code = serialization::EXPR_CXX_MEMBER_CALL; 1193 } 1194 1195 void 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 1212 void ASTStmtWriter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) { 1213 VisitCXXConstructExpr(E); 1214 Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record); 1215 Code = serialization::EXPR_CXX_TEMPORARY_OBJECT; 1216 } 1217 1218 void 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 1251 void ASTStmtWriter::VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) { 1252 VisitExpr(E); 1253 Writer.AddStmt(E->getSubExpr()); 1254 Code = serialization::EXPR_CXX_STD_INITIALIZER_LIST; 1255 } 1256 1257 void 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 1264 void ASTStmtWriter::VisitCXXStaticCastExpr(CXXStaticCastExpr *E) { 1265 VisitCXXNamedCastExpr(E); 1266 Code = serialization::EXPR_CXX_STATIC_CAST; 1267 } 1268 1269 void ASTStmtWriter::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E) { 1270 VisitCXXNamedCastExpr(E); 1271 Code = serialization::EXPR_CXX_DYNAMIC_CAST; 1272 } 1273 1274 void ASTStmtWriter::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E) { 1275 VisitCXXNamedCastExpr(E); 1276 Code = serialization::EXPR_CXX_REINTERPRET_CAST; 1277 } 1278 1279 void ASTStmtWriter::VisitCXXConstCastExpr(CXXConstCastExpr *E) { 1280 VisitCXXNamedCastExpr(E); 1281 Code = serialization::EXPR_CXX_CONST_CAST; 1282 } 1283 1284 void 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 1291 void ASTStmtWriter::VisitUserDefinedLiteral(UserDefinedLiteral *E) { 1292 VisitCallExpr(E); 1293 Writer.AddSourceLocation(E->UDSuffixLoc, Record); 1294 Code = serialization::EXPR_USER_DEFINED_LITERAL; 1295 } 1296 1297 void 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 1304 void ASTStmtWriter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) { 1305 VisitExpr(E); 1306 Writer.AddSourceLocation(E->getLocation(), Record); 1307 Code = serialization::EXPR_CXX_NULL_PTR_LITERAL; 1308 } 1309 1310 void 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 1322 void 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 1329 void 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 1337 void 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 1344 void 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 1351 void 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 1358 void 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 1365 void 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 1385 void 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 1398 void 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 1419 void 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 1429 void 1430 ASTStmtWriter::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 1458 void 1459 ASTStmtWriter::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 1479 void 1480 ASTStmtWriter::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 1492 void 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 1517 void 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 1527 void 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 1535 void 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 1546 void 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 1555 void 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 1564 void 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 1572 void 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 1580 void 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 1597 void 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 1606 void 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 1615 void 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 1626 void 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 1634 void 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 1645 void 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 1652 void ASTStmtWriter::VisitTypoExpr(TypoExpr *E) { 1653 VisitExpr(E); 1654 // TODO: Figure out sane writer behavior for a TypoExpr, if necessary 1655 llvm_unreachable("Cannot write TypoExpr nodes"); 1656 } 1657 1658 //===----------------------------------------------------------------------===// 1659 // CUDA Expressions and Statements. 1660 //===----------------------------------------------------------------------===// 1661 1662 void 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 //===----------------------------------------------------------------------===// 1671 void 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 //===----------------------------------------------------------------------===// 1682 void 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 1692 void 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 1700 void 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 1712 void 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 1720 void 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 1727 void 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 1736 void 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 1746 namespace clang { 1747 class OMPClauseWriter : public OMPClauseVisitor<OMPClauseWriter> { 1748 ASTStmtWriter *Writer; 1749 ASTWriter::RecordData &Record; 1750 public: 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 void VisitOMPClauseWithPreInit(OMPClauseWithPreInit *C); 1758 void VisitOMPClauseWithPostUpdate(OMPClauseWithPostUpdate *C); 1759 }; 1760 } 1761 1762 void OMPClauseWriter::writeClause(OMPClause *C) { 1763 Record.push_back(C->getClauseKind()); 1764 Visit(C); 1765 Writer->Writer.AddSourceLocation(C->getLocStart(), Record); 1766 Writer->Writer.AddSourceLocation(C->getLocEnd(), Record); 1767 } 1768 1769 void OMPClauseWriter::VisitOMPClauseWithPreInit(OMPClauseWithPreInit *C) { 1770 Writer->Writer.AddStmt(C->getPreInitStmt()); 1771 } 1772 1773 void OMPClauseWriter::VisitOMPClauseWithPostUpdate(OMPClauseWithPostUpdate *C) { 1774 VisitOMPClauseWithPreInit(C); 1775 Writer->Writer.AddStmt(C->getPostUpdateExpr()); 1776 } 1777 1778 void OMPClauseWriter::VisitOMPIfClause(OMPIfClause *C) { 1779 Record.push_back(C->getNameModifier()); 1780 Writer->Writer.AddSourceLocation(C->getNameModifierLoc(), Record); 1781 Writer->Writer.AddSourceLocation(C->getColonLoc(), Record); 1782 Writer->Writer.AddStmt(C->getCondition()); 1783 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 1784 } 1785 1786 void OMPClauseWriter::VisitOMPFinalClause(OMPFinalClause *C) { 1787 Writer->Writer.AddStmt(C->getCondition()); 1788 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 1789 } 1790 1791 void OMPClauseWriter::VisitOMPNumThreadsClause(OMPNumThreadsClause *C) { 1792 Writer->Writer.AddStmt(C->getNumThreads()); 1793 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 1794 } 1795 1796 void OMPClauseWriter::VisitOMPSafelenClause(OMPSafelenClause *C) { 1797 Writer->Writer.AddStmt(C->getSafelen()); 1798 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 1799 } 1800 1801 void OMPClauseWriter::VisitOMPSimdlenClause(OMPSimdlenClause *C) { 1802 Writer->Writer.AddStmt(C->getSimdlen()); 1803 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 1804 } 1805 1806 void OMPClauseWriter::VisitOMPCollapseClause(OMPCollapseClause *C) { 1807 Writer->Writer.AddStmt(C->getNumForLoops()); 1808 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 1809 } 1810 1811 void OMPClauseWriter::VisitOMPDefaultClause(OMPDefaultClause *C) { 1812 Record.push_back(C->getDefaultKind()); 1813 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 1814 Writer->Writer.AddSourceLocation(C->getDefaultKindKwLoc(), Record); 1815 } 1816 1817 void OMPClauseWriter::VisitOMPProcBindClause(OMPProcBindClause *C) { 1818 Record.push_back(C->getProcBindKind()); 1819 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 1820 Writer->Writer.AddSourceLocation(C->getProcBindKindKwLoc(), Record); 1821 } 1822 1823 void OMPClauseWriter::VisitOMPScheduleClause(OMPScheduleClause *C) { 1824 VisitOMPClauseWithPreInit(C); 1825 Record.push_back(C->getScheduleKind()); 1826 Record.push_back(C->getFirstScheduleModifier()); 1827 Record.push_back(C->getSecondScheduleModifier()); 1828 Writer->Writer.AddStmt(C->getChunkSize()); 1829 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 1830 Writer->Writer.AddSourceLocation(C->getFirstScheduleModifierLoc(), Record); 1831 Writer->Writer.AddSourceLocation(C->getSecondScheduleModifierLoc(), Record); 1832 Writer->Writer.AddSourceLocation(C->getScheduleKindLoc(), Record); 1833 Writer->Writer.AddSourceLocation(C->getCommaLoc(), Record); 1834 } 1835 1836 void OMPClauseWriter::VisitOMPOrderedClause(OMPOrderedClause *C) { 1837 Writer->Writer.AddStmt(C->getNumForLoops()); 1838 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 1839 } 1840 1841 void OMPClauseWriter::VisitOMPNowaitClause(OMPNowaitClause *) {} 1842 1843 void OMPClauseWriter::VisitOMPUntiedClause(OMPUntiedClause *) {} 1844 1845 void OMPClauseWriter::VisitOMPMergeableClause(OMPMergeableClause *) {} 1846 1847 void OMPClauseWriter::VisitOMPReadClause(OMPReadClause *) {} 1848 1849 void OMPClauseWriter::VisitOMPWriteClause(OMPWriteClause *) {} 1850 1851 void OMPClauseWriter::VisitOMPUpdateClause(OMPUpdateClause *) {} 1852 1853 void OMPClauseWriter::VisitOMPCaptureClause(OMPCaptureClause *) {} 1854 1855 void OMPClauseWriter::VisitOMPSeqCstClause(OMPSeqCstClause *) {} 1856 1857 void OMPClauseWriter::VisitOMPThreadsClause(OMPThreadsClause *) {} 1858 1859 void OMPClauseWriter::VisitOMPSIMDClause(OMPSIMDClause *) {} 1860 1861 void OMPClauseWriter::VisitOMPNogroupClause(OMPNogroupClause *) {} 1862 1863 void OMPClauseWriter::VisitOMPPrivateClause(OMPPrivateClause *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 } 1873 1874 void OMPClauseWriter::VisitOMPFirstprivateClause(OMPFirstprivateClause *C) { 1875 Record.push_back(C->varlist_size()); 1876 VisitOMPClauseWithPreInit(C); 1877 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 1878 for (auto *VE : C->varlists()) { 1879 Writer->Writer.AddStmt(VE); 1880 } 1881 for (auto *VE : C->private_copies()) { 1882 Writer->Writer.AddStmt(VE); 1883 } 1884 for (auto *VE : C->inits()) { 1885 Writer->Writer.AddStmt(VE); 1886 } 1887 } 1888 1889 void OMPClauseWriter::VisitOMPLastprivateClause(OMPLastprivateClause *C) { 1890 Record.push_back(C->varlist_size()); 1891 VisitOMPClauseWithPostUpdate(C); 1892 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 1893 for (auto *VE : C->varlists()) 1894 Writer->Writer.AddStmt(VE); 1895 for (auto *E : C->private_copies()) 1896 Writer->Writer.AddStmt(E); 1897 for (auto *E : C->source_exprs()) 1898 Writer->Writer.AddStmt(E); 1899 for (auto *E : C->destination_exprs()) 1900 Writer->Writer.AddStmt(E); 1901 for (auto *E : C->assignment_ops()) 1902 Writer->Writer.AddStmt(E); 1903 } 1904 1905 void OMPClauseWriter::VisitOMPSharedClause(OMPSharedClause *C) { 1906 Record.push_back(C->varlist_size()); 1907 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 1908 for (auto *VE : C->varlists()) 1909 Writer->Writer.AddStmt(VE); 1910 } 1911 1912 void OMPClauseWriter::VisitOMPReductionClause(OMPReductionClause *C) { 1913 Record.push_back(C->varlist_size()); 1914 VisitOMPClauseWithPostUpdate(C); 1915 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 1916 Writer->Writer.AddSourceLocation(C->getColonLoc(), Record); 1917 Writer->Writer.AddNestedNameSpecifierLoc(C->getQualifierLoc(), Record); 1918 Writer->Writer.AddDeclarationNameInfo(C->getNameInfo(), Record); 1919 for (auto *VE : C->varlists()) 1920 Writer->Writer.AddStmt(VE); 1921 for (auto *VE : C->privates()) 1922 Writer->Writer.AddStmt(VE); 1923 for (auto *E : C->lhs_exprs()) 1924 Writer->Writer.AddStmt(E); 1925 for (auto *E : C->rhs_exprs()) 1926 Writer->Writer.AddStmt(E); 1927 for (auto *E : C->reduction_ops()) 1928 Writer->Writer.AddStmt(E); 1929 } 1930 1931 void OMPClauseWriter::VisitOMPLinearClause(OMPLinearClause *C) { 1932 Record.push_back(C->varlist_size()); 1933 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 1934 Writer->Writer.AddSourceLocation(C->getColonLoc(), Record); 1935 Record.push_back(C->getModifier()); 1936 Writer->Writer.AddSourceLocation(C->getModifierLoc(), Record); 1937 for (auto *VE : C->varlists()) { 1938 Writer->Writer.AddStmt(VE); 1939 } 1940 for (auto *VE : C->privates()) { 1941 Writer->Writer.AddStmt(VE); 1942 } 1943 for (auto *VE : C->inits()) { 1944 Writer->Writer.AddStmt(VE); 1945 } 1946 for (auto *VE : C->updates()) { 1947 Writer->Writer.AddStmt(VE); 1948 } 1949 for (auto *VE : C->finals()) { 1950 Writer->Writer.AddStmt(VE); 1951 } 1952 Writer->Writer.AddStmt(C->getStep()); 1953 Writer->Writer.AddStmt(C->getCalcStep()); 1954 } 1955 1956 void OMPClauseWriter::VisitOMPAlignedClause(OMPAlignedClause *C) { 1957 Record.push_back(C->varlist_size()); 1958 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 1959 Writer->Writer.AddSourceLocation(C->getColonLoc(), Record); 1960 for (auto *VE : C->varlists()) 1961 Writer->Writer.AddStmt(VE); 1962 Writer->Writer.AddStmt(C->getAlignment()); 1963 } 1964 1965 void OMPClauseWriter::VisitOMPCopyinClause(OMPCopyinClause *C) { 1966 Record.push_back(C->varlist_size()); 1967 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 1968 for (auto *VE : C->varlists()) 1969 Writer->Writer.AddStmt(VE); 1970 for (auto *E : C->source_exprs()) 1971 Writer->Writer.AddStmt(E); 1972 for (auto *E : C->destination_exprs()) 1973 Writer->Writer.AddStmt(E); 1974 for (auto *E : C->assignment_ops()) 1975 Writer->Writer.AddStmt(E); 1976 } 1977 1978 void OMPClauseWriter::VisitOMPCopyprivateClause(OMPCopyprivateClause *C) { 1979 Record.push_back(C->varlist_size()); 1980 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 1981 for (auto *VE : C->varlists()) 1982 Writer->Writer.AddStmt(VE); 1983 for (auto *E : C->source_exprs()) 1984 Writer->Writer.AddStmt(E); 1985 for (auto *E : C->destination_exprs()) 1986 Writer->Writer.AddStmt(E); 1987 for (auto *E : C->assignment_ops()) 1988 Writer->Writer.AddStmt(E); 1989 } 1990 1991 void OMPClauseWriter::VisitOMPFlushClause(OMPFlushClause *C) { 1992 Record.push_back(C->varlist_size()); 1993 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 1994 for (auto *VE : C->varlists()) 1995 Writer->Writer.AddStmt(VE); 1996 } 1997 1998 void OMPClauseWriter::VisitOMPDependClause(OMPDependClause *C) { 1999 Record.push_back(C->varlist_size()); 2000 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 2001 Record.push_back(C->getDependencyKind()); 2002 Writer->Writer.AddSourceLocation(C->getDependencyLoc(), Record); 2003 Writer->Writer.AddSourceLocation(C->getColonLoc(), Record); 2004 for (auto *VE : C->varlists()) 2005 Writer->Writer.AddStmt(VE); 2006 } 2007 2008 void OMPClauseWriter::VisitOMPDeviceClause(OMPDeviceClause *C) { 2009 Writer->Writer.AddStmt(C->getDevice()); 2010 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 2011 } 2012 2013 void OMPClauseWriter::VisitOMPMapClause(OMPMapClause *C) { 2014 Record.push_back(C->varlist_size()); 2015 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 2016 Record.push_back(C->getMapTypeModifier()); 2017 Record.push_back(C->getMapType()); 2018 Writer->Writer.AddSourceLocation(C->getMapLoc(), Record); 2019 Writer->Writer.AddSourceLocation(C->getColonLoc(), Record); 2020 for (auto *VE : C->varlists()) 2021 Writer->Writer.AddStmt(VE); 2022 } 2023 2024 void OMPClauseWriter::VisitOMPNumTeamsClause(OMPNumTeamsClause *C) { 2025 Writer->Writer.AddStmt(C->getNumTeams()); 2026 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 2027 } 2028 2029 void OMPClauseWriter::VisitOMPThreadLimitClause(OMPThreadLimitClause *C) { 2030 Writer->Writer.AddStmt(C->getThreadLimit()); 2031 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 2032 } 2033 2034 void OMPClauseWriter::VisitOMPPriorityClause(OMPPriorityClause *C) { 2035 Writer->Writer.AddStmt(C->getPriority()); 2036 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 2037 } 2038 2039 void OMPClauseWriter::VisitOMPGrainsizeClause(OMPGrainsizeClause *C) { 2040 Writer->Writer.AddStmt(C->getGrainsize()); 2041 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 2042 } 2043 2044 void OMPClauseWriter::VisitOMPNumTasksClause(OMPNumTasksClause *C) { 2045 Writer->Writer.AddStmt(C->getNumTasks()); 2046 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 2047 } 2048 2049 void OMPClauseWriter::VisitOMPHintClause(OMPHintClause *C) { 2050 Writer->Writer.AddStmt(C->getHint()); 2051 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 2052 } 2053 2054 void OMPClauseWriter::VisitOMPDistScheduleClause(OMPDistScheduleClause *C) { 2055 VisitOMPClauseWithPreInit(C); 2056 Record.push_back(C->getDistScheduleKind()); 2057 Writer->Writer.AddStmt(C->getChunkSize()); 2058 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 2059 Writer->Writer.AddSourceLocation(C->getDistScheduleKindLoc(), Record); 2060 Writer->Writer.AddSourceLocation(C->getCommaLoc(), Record); 2061 } 2062 2063 void OMPClauseWriter::VisitOMPDefaultmapClause(OMPDefaultmapClause *C) { 2064 Record.push_back(C->getDefaultmapKind()); 2065 Record.push_back(C->getDefaultmapModifier()); 2066 Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record); 2067 Writer->Writer.AddSourceLocation(C->getDefaultmapModifierLoc(), Record); 2068 Writer->Writer.AddSourceLocation(C->getDefaultmapKindLoc(), Record); 2069 } 2070 2071 //===----------------------------------------------------------------------===// 2072 // OpenMP Directives. 2073 //===----------------------------------------------------------------------===// 2074 void ASTStmtWriter::VisitOMPExecutableDirective(OMPExecutableDirective *E) { 2075 Writer.AddSourceLocation(E->getLocStart(), Record); 2076 Writer.AddSourceLocation(E->getLocEnd(), Record); 2077 OMPClauseWriter ClauseWriter(this, Record); 2078 for (unsigned i = 0; i < E->getNumClauses(); ++i) { 2079 ClauseWriter.writeClause(E->getClause(i)); 2080 } 2081 if (E->hasAssociatedStmt()) 2082 Writer.AddStmt(E->getAssociatedStmt()); 2083 } 2084 2085 void ASTStmtWriter::VisitOMPLoopDirective(OMPLoopDirective *D) { 2086 VisitStmt(D); 2087 Record.push_back(D->getNumClauses()); 2088 Record.push_back(D->getCollapsedNumber()); 2089 VisitOMPExecutableDirective(D); 2090 Writer.AddStmt(D->getIterationVariable()); 2091 Writer.AddStmt(D->getLastIteration()); 2092 Writer.AddStmt(D->getCalcLastIteration()); 2093 Writer.AddStmt(D->getPreCond()); 2094 Writer.AddStmt(D->getCond()); 2095 Writer.AddStmt(D->getInit()); 2096 Writer.AddStmt(D->getInc()); 2097 if (isOpenMPWorksharingDirective(D->getDirectiveKind()) || 2098 isOpenMPTaskLoopDirective(D->getDirectiveKind()) || 2099 isOpenMPDistributeDirective(D->getDirectiveKind())) { 2100 Writer.AddStmt(D->getIsLastIterVariable()); 2101 Writer.AddStmt(D->getLowerBoundVariable()); 2102 Writer.AddStmt(D->getUpperBoundVariable()); 2103 Writer.AddStmt(D->getStrideVariable()); 2104 Writer.AddStmt(D->getEnsureUpperBound()); 2105 Writer.AddStmt(D->getNextLowerBound()); 2106 Writer.AddStmt(D->getNextUpperBound()); 2107 } 2108 for (auto I : D->counters()) { 2109 Writer.AddStmt(I); 2110 } 2111 for (auto I : D->private_counters()) { 2112 Writer.AddStmt(I); 2113 } 2114 for (auto I : D->inits()) { 2115 Writer.AddStmt(I); 2116 } 2117 for (auto I : D->updates()) { 2118 Writer.AddStmt(I); 2119 } 2120 for (auto I : D->finals()) { 2121 Writer.AddStmt(I); 2122 } 2123 } 2124 2125 void ASTStmtWriter::VisitOMPParallelDirective(OMPParallelDirective *D) { 2126 VisitStmt(D); 2127 Record.push_back(D->getNumClauses()); 2128 VisitOMPExecutableDirective(D); 2129 Record.push_back(D->hasCancel() ? 1 : 0); 2130 Code = serialization::STMT_OMP_PARALLEL_DIRECTIVE; 2131 } 2132 2133 void ASTStmtWriter::VisitOMPSimdDirective(OMPSimdDirective *D) { 2134 VisitOMPLoopDirective(D); 2135 Code = serialization::STMT_OMP_SIMD_DIRECTIVE; 2136 } 2137 2138 void ASTStmtWriter::VisitOMPForDirective(OMPForDirective *D) { 2139 VisitOMPLoopDirective(D); 2140 Record.push_back(D->hasCancel() ? 1 : 0); 2141 Code = serialization::STMT_OMP_FOR_DIRECTIVE; 2142 } 2143 2144 void ASTStmtWriter::VisitOMPForSimdDirective(OMPForSimdDirective *D) { 2145 VisitOMPLoopDirective(D); 2146 Code = serialization::STMT_OMP_FOR_SIMD_DIRECTIVE; 2147 } 2148 2149 void ASTStmtWriter::VisitOMPSectionsDirective(OMPSectionsDirective *D) { 2150 VisitStmt(D); 2151 Record.push_back(D->getNumClauses()); 2152 VisitOMPExecutableDirective(D); 2153 Record.push_back(D->hasCancel() ? 1 : 0); 2154 Code = serialization::STMT_OMP_SECTIONS_DIRECTIVE; 2155 } 2156 2157 void ASTStmtWriter::VisitOMPSectionDirective(OMPSectionDirective *D) { 2158 VisitStmt(D); 2159 VisitOMPExecutableDirective(D); 2160 Record.push_back(D->hasCancel() ? 1 : 0); 2161 Code = serialization::STMT_OMP_SECTION_DIRECTIVE; 2162 } 2163 2164 void ASTStmtWriter::VisitOMPSingleDirective(OMPSingleDirective *D) { 2165 VisitStmt(D); 2166 Record.push_back(D->getNumClauses()); 2167 VisitOMPExecutableDirective(D); 2168 Code = serialization::STMT_OMP_SINGLE_DIRECTIVE; 2169 } 2170 2171 void ASTStmtWriter::VisitOMPMasterDirective(OMPMasterDirective *D) { 2172 VisitStmt(D); 2173 VisitOMPExecutableDirective(D); 2174 Code = serialization::STMT_OMP_MASTER_DIRECTIVE; 2175 } 2176 2177 void ASTStmtWriter::VisitOMPCriticalDirective(OMPCriticalDirective *D) { 2178 VisitStmt(D); 2179 Record.push_back(D->getNumClauses()); 2180 VisitOMPExecutableDirective(D); 2181 Writer.AddDeclarationNameInfo(D->getDirectiveName(), Record); 2182 Code = serialization::STMT_OMP_CRITICAL_DIRECTIVE; 2183 } 2184 2185 void ASTStmtWriter::VisitOMPParallelForDirective(OMPParallelForDirective *D) { 2186 VisitOMPLoopDirective(D); 2187 Record.push_back(D->hasCancel() ? 1 : 0); 2188 Code = serialization::STMT_OMP_PARALLEL_FOR_DIRECTIVE; 2189 } 2190 2191 void ASTStmtWriter::VisitOMPParallelForSimdDirective( 2192 OMPParallelForSimdDirective *D) { 2193 VisitOMPLoopDirective(D); 2194 Code = serialization::STMT_OMP_PARALLEL_FOR_SIMD_DIRECTIVE; 2195 } 2196 2197 void ASTStmtWriter::VisitOMPParallelSectionsDirective( 2198 OMPParallelSectionsDirective *D) { 2199 VisitStmt(D); 2200 Record.push_back(D->getNumClauses()); 2201 VisitOMPExecutableDirective(D); 2202 Record.push_back(D->hasCancel() ? 1 : 0); 2203 Code = serialization::STMT_OMP_PARALLEL_SECTIONS_DIRECTIVE; 2204 } 2205 2206 void ASTStmtWriter::VisitOMPTaskDirective(OMPTaskDirective *D) { 2207 VisitStmt(D); 2208 Record.push_back(D->getNumClauses()); 2209 VisitOMPExecutableDirective(D); 2210 Record.push_back(D->hasCancel() ? 1 : 0); 2211 Code = serialization::STMT_OMP_TASK_DIRECTIVE; 2212 } 2213 2214 void ASTStmtWriter::VisitOMPAtomicDirective(OMPAtomicDirective *D) { 2215 VisitStmt(D); 2216 Record.push_back(D->getNumClauses()); 2217 VisitOMPExecutableDirective(D); 2218 Writer.AddStmt(D->getX()); 2219 Writer.AddStmt(D->getV()); 2220 Writer.AddStmt(D->getExpr()); 2221 Writer.AddStmt(D->getUpdateExpr()); 2222 Record.push_back(D->isXLHSInRHSPart() ? 1 : 0); 2223 Record.push_back(D->isPostfixUpdate() ? 1 : 0); 2224 Code = serialization::STMT_OMP_ATOMIC_DIRECTIVE; 2225 } 2226 2227 void ASTStmtWriter::VisitOMPTargetDirective(OMPTargetDirective *D) { 2228 VisitStmt(D); 2229 Record.push_back(D->getNumClauses()); 2230 VisitOMPExecutableDirective(D); 2231 Code = serialization::STMT_OMP_TARGET_DIRECTIVE; 2232 } 2233 2234 void ASTStmtWriter::VisitOMPTargetDataDirective(OMPTargetDataDirective *D) { 2235 VisitStmt(D); 2236 Record.push_back(D->getNumClauses()); 2237 VisitOMPExecutableDirective(D); 2238 Code = serialization::STMT_OMP_TARGET_DATA_DIRECTIVE; 2239 } 2240 2241 void ASTStmtWriter::VisitOMPTargetEnterDataDirective( 2242 OMPTargetEnterDataDirective *D) { 2243 VisitStmt(D); 2244 Record.push_back(D->getNumClauses()); 2245 VisitOMPExecutableDirective(D); 2246 Code = serialization::STMT_OMP_TARGET_ENTER_DATA_DIRECTIVE; 2247 } 2248 2249 void ASTStmtWriter::VisitOMPTargetExitDataDirective( 2250 OMPTargetExitDataDirective *D) { 2251 VisitStmt(D); 2252 Record.push_back(D->getNumClauses()); 2253 VisitOMPExecutableDirective(D); 2254 Code = serialization::STMT_OMP_TARGET_EXIT_DATA_DIRECTIVE; 2255 } 2256 2257 void ASTStmtWriter::VisitOMPTargetParallelDirective( 2258 OMPTargetParallelDirective *D) { 2259 VisitStmt(D); 2260 Record.push_back(D->getNumClauses()); 2261 VisitOMPExecutableDirective(D); 2262 Code = serialization::STMT_OMP_TARGET_PARALLEL_DIRECTIVE; 2263 } 2264 2265 void ASTStmtWriter::VisitOMPTargetParallelForDirective( 2266 OMPTargetParallelForDirective *D) { 2267 VisitOMPLoopDirective(D); 2268 Record.push_back(D->hasCancel() ? 1 : 0); 2269 Code = serialization::STMT_OMP_TARGET_PARALLEL_FOR_DIRECTIVE; 2270 } 2271 2272 void ASTStmtWriter::VisitOMPTaskyieldDirective(OMPTaskyieldDirective *D) { 2273 VisitStmt(D); 2274 VisitOMPExecutableDirective(D); 2275 Code = serialization::STMT_OMP_TASKYIELD_DIRECTIVE; 2276 } 2277 2278 void ASTStmtWriter::VisitOMPBarrierDirective(OMPBarrierDirective *D) { 2279 VisitStmt(D); 2280 VisitOMPExecutableDirective(D); 2281 Code = serialization::STMT_OMP_BARRIER_DIRECTIVE; 2282 } 2283 2284 void ASTStmtWriter::VisitOMPTaskwaitDirective(OMPTaskwaitDirective *D) { 2285 VisitStmt(D); 2286 VisitOMPExecutableDirective(D); 2287 Code = serialization::STMT_OMP_TASKWAIT_DIRECTIVE; 2288 } 2289 2290 void ASTStmtWriter::VisitOMPTaskgroupDirective(OMPTaskgroupDirective *D) { 2291 VisitStmt(D); 2292 VisitOMPExecutableDirective(D); 2293 Code = serialization::STMT_OMP_TASKGROUP_DIRECTIVE; 2294 } 2295 2296 void ASTStmtWriter::VisitOMPFlushDirective(OMPFlushDirective *D) { 2297 VisitStmt(D); 2298 Record.push_back(D->getNumClauses()); 2299 VisitOMPExecutableDirective(D); 2300 Code = serialization::STMT_OMP_FLUSH_DIRECTIVE; 2301 } 2302 2303 void ASTStmtWriter::VisitOMPOrderedDirective(OMPOrderedDirective *D) { 2304 VisitStmt(D); 2305 Record.push_back(D->getNumClauses()); 2306 VisitOMPExecutableDirective(D); 2307 Code = serialization::STMT_OMP_ORDERED_DIRECTIVE; 2308 } 2309 2310 void ASTStmtWriter::VisitOMPTeamsDirective(OMPTeamsDirective *D) { 2311 VisitStmt(D); 2312 Record.push_back(D->getNumClauses()); 2313 VisitOMPExecutableDirective(D); 2314 Code = serialization::STMT_OMP_TEAMS_DIRECTIVE; 2315 } 2316 2317 void ASTStmtWriter::VisitOMPCancellationPointDirective( 2318 OMPCancellationPointDirective *D) { 2319 VisitStmt(D); 2320 VisitOMPExecutableDirective(D); 2321 Record.push_back(D->getCancelRegion()); 2322 Code = serialization::STMT_OMP_CANCELLATION_POINT_DIRECTIVE; 2323 } 2324 2325 void ASTStmtWriter::VisitOMPCancelDirective(OMPCancelDirective *D) { 2326 VisitStmt(D); 2327 Record.push_back(D->getNumClauses()); 2328 VisitOMPExecutableDirective(D); 2329 Record.push_back(D->getCancelRegion()); 2330 Code = serialization::STMT_OMP_CANCEL_DIRECTIVE; 2331 } 2332 2333 void ASTStmtWriter::VisitOMPTaskLoopDirective(OMPTaskLoopDirective *D) { 2334 VisitOMPLoopDirective(D); 2335 Code = serialization::STMT_OMP_TASKLOOP_DIRECTIVE; 2336 } 2337 2338 void ASTStmtWriter::VisitOMPTaskLoopSimdDirective(OMPTaskLoopSimdDirective *D) { 2339 VisitOMPLoopDirective(D); 2340 Code = serialization::STMT_OMP_TASKLOOP_SIMD_DIRECTIVE; 2341 } 2342 2343 void ASTStmtWriter::VisitOMPDistributeDirective(OMPDistributeDirective *D) { 2344 VisitOMPLoopDirective(D); 2345 Code = serialization::STMT_OMP_DISTRIBUTE_DIRECTIVE; 2346 } 2347 2348 //===----------------------------------------------------------------------===// 2349 // ASTWriter Implementation 2350 //===----------------------------------------------------------------------===// 2351 2352 unsigned ASTWriter::RecordSwitchCaseID(SwitchCase *S) { 2353 assert(SwitchCaseIDs.find(S) == SwitchCaseIDs.end() && 2354 "SwitchCase recorded twice"); 2355 unsigned NextID = SwitchCaseIDs.size(); 2356 SwitchCaseIDs[S] = NextID; 2357 return NextID; 2358 } 2359 2360 unsigned ASTWriter::getSwitchCaseID(SwitchCase *S) { 2361 assert(SwitchCaseIDs.find(S) != SwitchCaseIDs.end() && 2362 "SwitchCase hasn't been seen yet"); 2363 return SwitchCaseIDs[S]; 2364 } 2365 2366 void ASTWriter::ClearSwitchCaseIDs() { 2367 SwitchCaseIDs.clear(); 2368 } 2369 2370 /// \brief Write the given substatement or subexpression to the 2371 /// bitstream. 2372 void ASTWriter::WriteSubStmt(Stmt *S, 2373 llvm::DenseMap<Stmt *, uint64_t> &SubStmtEntries, 2374 llvm::DenseSet<Stmt *> &ParentStmts) { 2375 RecordData Record; 2376 ASTStmtWriter Writer(*this, Record); 2377 ++NumStatements; 2378 2379 if (!S) { 2380 Stream.EmitRecord(serialization::STMT_NULL_PTR, Record); 2381 return; 2382 } 2383 2384 llvm::DenseMap<Stmt *, uint64_t>::iterator I = SubStmtEntries.find(S); 2385 if (I != SubStmtEntries.end()) { 2386 Record.push_back(I->second); 2387 Stream.EmitRecord(serialization::STMT_REF_PTR, Record); 2388 return; 2389 } 2390 2391 #ifndef NDEBUG 2392 assert(!ParentStmts.count(S) && "There is a Stmt cycle!"); 2393 2394 struct ParentStmtInserterRAII { 2395 Stmt *S; 2396 llvm::DenseSet<Stmt *> &ParentStmts; 2397 2398 ParentStmtInserterRAII(Stmt *S, llvm::DenseSet<Stmt *> &ParentStmts) 2399 : S(S), ParentStmts(ParentStmts) { 2400 ParentStmts.insert(S); 2401 } 2402 ~ParentStmtInserterRAII() { 2403 ParentStmts.erase(S); 2404 } 2405 }; 2406 2407 ParentStmtInserterRAII ParentStmtInserter(S, ParentStmts); 2408 #endif 2409 2410 // Redirect ASTWriter::AddStmt to collect sub-stmts. 2411 SmallVector<Stmt *, 16> SubStmts; 2412 CollectedStmts = &SubStmts; 2413 2414 Writer.Code = serialization::STMT_NULL_PTR; 2415 Writer.AbbrevToUse = 0; 2416 Writer.Visit(S); 2417 2418 #ifndef NDEBUG 2419 if (Writer.Code == serialization::STMT_NULL_PTR) { 2420 SourceManager &SrcMgr 2421 = DeclIDs.begin()->first->getASTContext().getSourceManager(); 2422 S->dump(SrcMgr); 2423 llvm_unreachable("Unhandled sub-statement writing AST file"); 2424 } 2425 #endif 2426 2427 // Revert ASTWriter::AddStmt. 2428 CollectedStmts = &StmtsToEmit; 2429 2430 // Write the sub-stmts in reverse order, last to first. When reading them back 2431 // we will read them in correct order by "pop"ing them from the Stmts stack. 2432 // This simplifies reading and allows to store a variable number of sub-stmts 2433 // without knowing it in advance. 2434 while (!SubStmts.empty()) 2435 WriteSubStmt(SubStmts.pop_back_val(), SubStmtEntries, ParentStmts); 2436 2437 Stream.EmitRecord(Writer.Code, Record, Writer.AbbrevToUse); 2438 2439 SubStmtEntries[S] = Stream.GetCurrentBitNo(); 2440 } 2441 2442 /// \brief Flush all of the statements that have been added to the 2443 /// queue via AddStmt(). 2444 void ASTWriter::FlushStmts() { 2445 RecordData Record; 2446 2447 // We expect to be the only consumer of the two temporary statement maps, 2448 // assert that they are empty. 2449 assert(SubStmtEntries.empty() && "unexpected entries in sub-stmt map"); 2450 assert(ParentStmts.empty() && "unexpected entries in parent stmt map"); 2451 2452 for (unsigned I = 0, N = StmtsToEmit.size(); I != N; ++I) { 2453 WriteSubStmt(StmtsToEmit[I], SubStmtEntries, ParentStmts); 2454 2455 assert(N == StmtsToEmit.size() && 2456 "Substatement written via AddStmt rather than WriteSubStmt!"); 2457 2458 // Note that we are at the end of a full expression. Any 2459 // expression records that follow this one are part of a different 2460 // expression. 2461 Stream.EmitRecord(serialization::STMT_STOP, Record); 2462 2463 SubStmtEntries.clear(); 2464 ParentStmts.clear(); 2465 } 2466 2467 StmtsToEmit.clear(); 2468 } 2469