StmtProfile.cpp revision 276479
1//===---- StmtProfile.cpp - Profile implementation for Stmt ASTs ----------===// 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// This file implements the Stmt::Profile method, which builds a unique bit 11// representation that identifies a statement/expression. 12// 13//===----------------------------------------------------------------------===// 14#include "clang/AST/ASTContext.h" 15#include "clang/AST/DeclCXX.h" 16#include "clang/AST/DeclObjC.h" 17#include "clang/AST/DeclTemplate.h" 18#include "clang/AST/Expr.h" 19#include "clang/AST/ExprCXX.h" 20#include "clang/AST/ExprObjC.h" 21#include "clang/AST/StmtVisitor.h" 22#include "llvm/ADT/FoldingSet.h" 23using namespace clang; 24 25namespace { 26 class StmtProfiler : public ConstStmtVisitor<StmtProfiler> { 27 llvm::FoldingSetNodeID &ID; 28 const ASTContext &Context; 29 bool Canonical; 30 31 public: 32 StmtProfiler(llvm::FoldingSetNodeID &ID, const ASTContext &Context, 33 bool Canonical) 34 : ID(ID), Context(Context), Canonical(Canonical) { } 35 36 void VisitStmt(const Stmt *S); 37 38#define STMT(Node, Base) void Visit##Node(const Node *S); 39#include "clang/AST/StmtNodes.inc" 40 41 /// \brief Visit a declaration that is referenced within an expression 42 /// or statement. 43 void VisitDecl(const Decl *D); 44 45 /// \brief Visit a type that is referenced within an expression or 46 /// statement. 47 void VisitType(QualType T); 48 49 /// \brief Visit a name that occurs within an expression or statement. 50 void VisitName(DeclarationName Name); 51 52 /// \brief Visit a nested-name-specifier that occurs within an expression 53 /// or statement. 54 void VisitNestedNameSpecifier(NestedNameSpecifier *NNS); 55 56 /// \brief Visit a template name that occurs within an expression or 57 /// statement. 58 void VisitTemplateName(TemplateName Name); 59 60 /// \brief Visit template arguments that occur within an expression or 61 /// statement. 62 void VisitTemplateArguments(const TemplateArgumentLoc *Args, 63 unsigned NumArgs); 64 65 /// \brief Visit a single template argument. 66 void VisitTemplateArgument(const TemplateArgument &Arg); 67 }; 68} 69 70void StmtProfiler::VisitStmt(const Stmt *S) { 71 ID.AddInteger(S->getStmtClass()); 72 for (Stmt::const_child_range C = S->children(); C; ++C) { 73 if (*C) 74 Visit(*C); 75 else 76 ID.AddInteger(0); 77 } 78} 79 80void StmtProfiler::VisitDeclStmt(const DeclStmt *S) { 81 VisitStmt(S); 82 for (const auto *D : S->decls()) 83 VisitDecl(D); 84} 85 86void StmtProfiler::VisitNullStmt(const NullStmt *S) { 87 VisitStmt(S); 88} 89 90void StmtProfiler::VisitCompoundStmt(const CompoundStmt *S) { 91 VisitStmt(S); 92} 93 94void StmtProfiler::VisitSwitchCase(const SwitchCase *S) { 95 VisitStmt(S); 96} 97 98void StmtProfiler::VisitCaseStmt(const CaseStmt *S) { 99 VisitStmt(S); 100} 101 102void StmtProfiler::VisitDefaultStmt(const DefaultStmt *S) { 103 VisitStmt(S); 104} 105 106void StmtProfiler::VisitLabelStmt(const LabelStmt *S) { 107 VisitStmt(S); 108 VisitDecl(S->getDecl()); 109} 110 111void StmtProfiler::VisitAttributedStmt(const AttributedStmt *S) { 112 VisitStmt(S); 113 // TODO: maybe visit attributes? 114} 115 116void StmtProfiler::VisitIfStmt(const IfStmt *S) { 117 VisitStmt(S); 118 VisitDecl(S->getConditionVariable()); 119} 120 121void StmtProfiler::VisitSwitchStmt(const SwitchStmt *S) { 122 VisitStmt(S); 123 VisitDecl(S->getConditionVariable()); 124} 125 126void StmtProfiler::VisitWhileStmt(const WhileStmt *S) { 127 VisitStmt(S); 128 VisitDecl(S->getConditionVariable()); 129} 130 131void StmtProfiler::VisitDoStmt(const DoStmt *S) { 132 VisitStmt(S); 133} 134 135void StmtProfiler::VisitForStmt(const ForStmt *S) { 136 VisitStmt(S); 137} 138 139void StmtProfiler::VisitGotoStmt(const GotoStmt *S) { 140 VisitStmt(S); 141 VisitDecl(S->getLabel()); 142} 143 144void StmtProfiler::VisitIndirectGotoStmt(const IndirectGotoStmt *S) { 145 VisitStmt(S); 146} 147 148void StmtProfiler::VisitContinueStmt(const ContinueStmt *S) { 149 VisitStmt(S); 150} 151 152void StmtProfiler::VisitBreakStmt(const BreakStmt *S) { 153 VisitStmt(S); 154} 155 156void StmtProfiler::VisitReturnStmt(const ReturnStmt *S) { 157 VisitStmt(S); 158} 159 160void StmtProfiler::VisitGCCAsmStmt(const GCCAsmStmt *S) { 161 VisitStmt(S); 162 ID.AddBoolean(S->isVolatile()); 163 ID.AddBoolean(S->isSimple()); 164 VisitStringLiteral(S->getAsmString()); 165 ID.AddInteger(S->getNumOutputs()); 166 for (unsigned I = 0, N = S->getNumOutputs(); I != N; ++I) { 167 ID.AddString(S->getOutputName(I)); 168 VisitStringLiteral(S->getOutputConstraintLiteral(I)); 169 } 170 ID.AddInteger(S->getNumInputs()); 171 for (unsigned I = 0, N = S->getNumInputs(); I != N; ++I) { 172 ID.AddString(S->getInputName(I)); 173 VisitStringLiteral(S->getInputConstraintLiteral(I)); 174 } 175 ID.AddInteger(S->getNumClobbers()); 176 for (unsigned I = 0, N = S->getNumClobbers(); I != N; ++I) 177 VisitStringLiteral(S->getClobberStringLiteral(I)); 178} 179 180void StmtProfiler::VisitMSAsmStmt(const MSAsmStmt *S) { 181 // FIXME: Implement MS style inline asm statement profiler. 182 VisitStmt(S); 183} 184 185void StmtProfiler::VisitCXXCatchStmt(const CXXCatchStmt *S) { 186 VisitStmt(S); 187 VisitType(S->getCaughtType()); 188} 189 190void StmtProfiler::VisitCXXTryStmt(const CXXTryStmt *S) { 191 VisitStmt(S); 192} 193 194void StmtProfiler::VisitCXXForRangeStmt(const CXXForRangeStmt *S) { 195 VisitStmt(S); 196} 197 198void StmtProfiler::VisitMSDependentExistsStmt(const MSDependentExistsStmt *S) { 199 VisitStmt(S); 200 ID.AddBoolean(S->isIfExists()); 201 VisitNestedNameSpecifier(S->getQualifierLoc().getNestedNameSpecifier()); 202 VisitName(S->getNameInfo().getName()); 203} 204 205void StmtProfiler::VisitSEHTryStmt(const SEHTryStmt *S) { 206 VisitStmt(S); 207} 208 209void StmtProfiler::VisitSEHFinallyStmt(const SEHFinallyStmt *S) { 210 VisitStmt(S); 211} 212 213void StmtProfiler::VisitSEHExceptStmt(const SEHExceptStmt *S) { 214 VisitStmt(S); 215} 216 217void StmtProfiler::VisitSEHLeaveStmt(const SEHLeaveStmt *S) { 218 VisitStmt(S); 219} 220 221void StmtProfiler::VisitCapturedStmt(const CapturedStmt *S) { 222 VisitStmt(S); 223} 224 225void StmtProfiler::VisitObjCForCollectionStmt(const ObjCForCollectionStmt *S) { 226 VisitStmt(S); 227} 228 229void StmtProfiler::VisitObjCAtCatchStmt(const ObjCAtCatchStmt *S) { 230 VisitStmt(S); 231 ID.AddBoolean(S->hasEllipsis()); 232 if (S->getCatchParamDecl()) 233 VisitType(S->getCatchParamDecl()->getType()); 234} 235 236void StmtProfiler::VisitObjCAtFinallyStmt(const ObjCAtFinallyStmt *S) { 237 VisitStmt(S); 238} 239 240void StmtProfiler::VisitObjCAtTryStmt(const ObjCAtTryStmt *S) { 241 VisitStmt(S); 242} 243 244void 245StmtProfiler::VisitObjCAtSynchronizedStmt(const ObjCAtSynchronizedStmt *S) { 246 VisitStmt(S); 247} 248 249void StmtProfiler::VisitObjCAtThrowStmt(const ObjCAtThrowStmt *S) { 250 VisitStmt(S); 251} 252 253void 254StmtProfiler::VisitObjCAutoreleasePoolStmt(const ObjCAutoreleasePoolStmt *S) { 255 VisitStmt(S); 256} 257 258namespace { 259class OMPClauseProfiler : public ConstOMPClauseVisitor<OMPClauseProfiler> { 260 StmtProfiler *Profiler; 261 /// \brief Process clauses with list of variables. 262 template <typename T> 263 void VisitOMPClauseList(T *Node); 264public: 265 OMPClauseProfiler(StmtProfiler *P) : Profiler(P) { } 266#define OPENMP_CLAUSE(Name, Class) \ 267 void Visit##Class(const Class *C); 268#include "clang/Basic/OpenMPKinds.def" 269}; 270 271void OMPClauseProfiler::VisitOMPIfClause(const OMPIfClause *C) { 272 if (C->getCondition()) 273 Profiler->VisitStmt(C->getCondition()); 274} 275 276void OMPClauseProfiler::VisitOMPFinalClause(const OMPFinalClause *C) { 277 if (C->getCondition()) 278 Profiler->VisitStmt(C->getCondition()); 279} 280 281void OMPClauseProfiler::VisitOMPNumThreadsClause(const OMPNumThreadsClause *C) { 282 if (C->getNumThreads()) 283 Profiler->VisitStmt(C->getNumThreads()); 284} 285 286void OMPClauseProfiler::VisitOMPSafelenClause(const OMPSafelenClause *C) { 287 if (C->getSafelen()) 288 Profiler->VisitStmt(C->getSafelen()); 289} 290 291void OMPClauseProfiler::VisitOMPCollapseClause(const OMPCollapseClause *C) { 292 if (C->getNumForLoops()) 293 Profiler->VisitStmt(C->getNumForLoops()); 294} 295 296void OMPClauseProfiler::VisitOMPDefaultClause(const OMPDefaultClause *C) { } 297 298void OMPClauseProfiler::VisitOMPProcBindClause(const OMPProcBindClause *C) { } 299 300void OMPClauseProfiler::VisitOMPScheduleClause(const OMPScheduleClause *C) { 301 if (C->getChunkSize()) 302 Profiler->VisitStmt(C->getChunkSize()); 303} 304 305void OMPClauseProfiler::VisitOMPOrderedClause(const OMPOrderedClause *) {} 306 307void OMPClauseProfiler::VisitOMPNowaitClause(const OMPNowaitClause *) {} 308 309void OMPClauseProfiler::VisitOMPUntiedClause(const OMPUntiedClause *) {} 310 311void OMPClauseProfiler::VisitOMPMergeableClause(const OMPMergeableClause *) {} 312 313template<typename T> 314void OMPClauseProfiler::VisitOMPClauseList(T *Node) { 315 for (auto *I : Node->varlists()) 316 Profiler->VisitStmt(I); 317} 318 319void OMPClauseProfiler::VisitOMPPrivateClause(const OMPPrivateClause *C) { 320 VisitOMPClauseList(C); 321} 322void OMPClauseProfiler::VisitOMPFirstprivateClause( 323 const OMPFirstprivateClause *C) { 324 VisitOMPClauseList(C); 325} 326void 327OMPClauseProfiler::VisitOMPLastprivateClause(const OMPLastprivateClause *C) { 328 VisitOMPClauseList(C); 329} 330void OMPClauseProfiler::VisitOMPSharedClause(const OMPSharedClause *C) { 331 VisitOMPClauseList(C); 332} 333void OMPClauseProfiler::VisitOMPReductionClause( 334 const OMPReductionClause *C) { 335 Profiler->VisitNestedNameSpecifier( 336 C->getQualifierLoc().getNestedNameSpecifier()); 337 Profiler->VisitName(C->getNameInfo().getName()); 338 VisitOMPClauseList(C); 339} 340void OMPClauseProfiler::VisitOMPLinearClause(const OMPLinearClause *C) { 341 VisitOMPClauseList(C); 342 Profiler->VisitStmt(C->getStep()); 343} 344void OMPClauseProfiler::VisitOMPAlignedClause(const OMPAlignedClause *C) { 345 VisitOMPClauseList(C); 346 Profiler->VisitStmt(C->getAlignment()); 347} 348void OMPClauseProfiler::VisitOMPCopyinClause(const OMPCopyinClause *C) { 349 VisitOMPClauseList(C); 350} 351void 352OMPClauseProfiler::VisitOMPCopyprivateClause(const OMPCopyprivateClause *C) { 353 VisitOMPClauseList(C); 354} 355void OMPClauseProfiler::VisitOMPFlushClause(const OMPFlushClause *C) { 356 VisitOMPClauseList(C); 357} 358} 359 360void 361StmtProfiler::VisitOMPExecutableDirective(const OMPExecutableDirective *S) { 362 VisitStmt(S); 363 OMPClauseProfiler P(this); 364 ArrayRef<OMPClause *> Clauses = S->clauses(); 365 for (ArrayRef<OMPClause *>::iterator I = Clauses.begin(), E = Clauses.end(); 366 I != E; ++I) 367 if (*I) 368 P.Visit(*I); 369} 370 371void StmtProfiler::VisitOMPParallelDirective(const OMPParallelDirective *S) { 372 VisitOMPExecutableDirective(S); 373} 374 375void StmtProfiler::VisitOMPSimdDirective(const OMPSimdDirective *S) { 376 VisitOMPExecutableDirective(S); 377} 378 379void StmtProfiler::VisitOMPForDirective(const OMPForDirective *S) { 380 VisitOMPExecutableDirective(S); 381} 382 383void StmtProfiler::VisitOMPSectionsDirective(const OMPSectionsDirective *S) { 384 VisitOMPExecutableDirective(S); 385} 386 387void StmtProfiler::VisitOMPSectionDirective(const OMPSectionDirective *S) { 388 VisitOMPExecutableDirective(S); 389} 390 391void StmtProfiler::VisitOMPSingleDirective(const OMPSingleDirective *S) { 392 VisitOMPExecutableDirective(S); 393} 394 395void StmtProfiler::VisitOMPMasterDirective(const OMPMasterDirective *S) { 396 VisitOMPExecutableDirective(S); 397} 398 399void StmtProfiler::VisitOMPCriticalDirective(const OMPCriticalDirective *S) { 400 VisitOMPExecutableDirective(S); 401 VisitName(S->getDirectiveName().getName()); 402} 403 404void 405StmtProfiler::VisitOMPParallelForDirective(const OMPParallelForDirective *S) { 406 VisitOMPExecutableDirective(S); 407} 408 409void StmtProfiler::VisitOMPParallelSectionsDirective( 410 const OMPParallelSectionsDirective *S) { 411 VisitOMPExecutableDirective(S); 412} 413 414void StmtProfiler::VisitOMPTaskDirective(const OMPTaskDirective *S) { 415 VisitOMPExecutableDirective(S); 416} 417 418void StmtProfiler::VisitOMPTaskyieldDirective(const OMPTaskyieldDirective *S) { 419 VisitOMPExecutableDirective(S); 420} 421 422void StmtProfiler::VisitOMPBarrierDirective(const OMPBarrierDirective *S) { 423 VisitOMPExecutableDirective(S); 424} 425 426void StmtProfiler::VisitOMPTaskwaitDirective(const OMPTaskwaitDirective *S) { 427 VisitOMPExecutableDirective(S); 428} 429 430void StmtProfiler::VisitOMPFlushDirective(const OMPFlushDirective *S) { 431 VisitOMPExecutableDirective(S); 432} 433 434void StmtProfiler::VisitExpr(const Expr *S) { 435 VisitStmt(S); 436} 437 438void StmtProfiler::VisitDeclRefExpr(const DeclRefExpr *S) { 439 VisitExpr(S); 440 if (!Canonical) 441 VisitNestedNameSpecifier(S->getQualifier()); 442 VisitDecl(S->getDecl()); 443 if (!Canonical) 444 VisitTemplateArguments(S->getTemplateArgs(), S->getNumTemplateArgs()); 445} 446 447void StmtProfiler::VisitPredefinedExpr(const PredefinedExpr *S) { 448 VisitExpr(S); 449 ID.AddInteger(S->getIdentType()); 450} 451 452void StmtProfiler::VisitIntegerLiteral(const IntegerLiteral *S) { 453 VisitExpr(S); 454 S->getValue().Profile(ID); 455} 456 457void StmtProfiler::VisitCharacterLiteral(const CharacterLiteral *S) { 458 VisitExpr(S); 459 ID.AddInteger(S->getKind()); 460 ID.AddInteger(S->getValue()); 461} 462 463void StmtProfiler::VisitFloatingLiteral(const FloatingLiteral *S) { 464 VisitExpr(S); 465 S->getValue().Profile(ID); 466 ID.AddBoolean(S->isExact()); 467} 468 469void StmtProfiler::VisitImaginaryLiteral(const ImaginaryLiteral *S) { 470 VisitExpr(S); 471} 472 473void StmtProfiler::VisitStringLiteral(const StringLiteral *S) { 474 VisitExpr(S); 475 ID.AddString(S->getBytes()); 476 ID.AddInteger(S->getKind()); 477} 478 479void StmtProfiler::VisitParenExpr(const ParenExpr *S) { 480 VisitExpr(S); 481} 482 483void StmtProfiler::VisitParenListExpr(const ParenListExpr *S) { 484 VisitExpr(S); 485} 486 487void StmtProfiler::VisitUnaryOperator(const UnaryOperator *S) { 488 VisitExpr(S); 489 ID.AddInteger(S->getOpcode()); 490} 491 492void StmtProfiler::VisitOffsetOfExpr(const OffsetOfExpr *S) { 493 VisitType(S->getTypeSourceInfo()->getType()); 494 unsigned n = S->getNumComponents(); 495 for (unsigned i = 0; i < n; ++i) { 496 const OffsetOfExpr::OffsetOfNode& ON = S->getComponent(i); 497 ID.AddInteger(ON.getKind()); 498 switch (ON.getKind()) { 499 case OffsetOfExpr::OffsetOfNode::Array: 500 // Expressions handled below. 501 break; 502 503 case OffsetOfExpr::OffsetOfNode::Field: 504 VisitDecl(ON.getField()); 505 break; 506 507 case OffsetOfExpr::OffsetOfNode::Identifier: 508 ID.AddPointer(ON.getFieldName()); 509 break; 510 511 case OffsetOfExpr::OffsetOfNode::Base: 512 // These nodes are implicit, and therefore don't need profiling. 513 break; 514 } 515 } 516 517 VisitExpr(S); 518} 519 520void 521StmtProfiler::VisitUnaryExprOrTypeTraitExpr(const UnaryExprOrTypeTraitExpr *S) { 522 VisitExpr(S); 523 ID.AddInteger(S->getKind()); 524 if (S->isArgumentType()) 525 VisitType(S->getArgumentType()); 526} 527 528void StmtProfiler::VisitArraySubscriptExpr(const ArraySubscriptExpr *S) { 529 VisitExpr(S); 530} 531 532void StmtProfiler::VisitCallExpr(const CallExpr *S) { 533 VisitExpr(S); 534} 535 536void StmtProfiler::VisitMemberExpr(const MemberExpr *S) { 537 VisitExpr(S); 538 VisitDecl(S->getMemberDecl()); 539 if (!Canonical) 540 VisitNestedNameSpecifier(S->getQualifier()); 541 ID.AddBoolean(S->isArrow()); 542} 543 544void StmtProfiler::VisitCompoundLiteralExpr(const CompoundLiteralExpr *S) { 545 VisitExpr(S); 546 ID.AddBoolean(S->isFileScope()); 547} 548 549void StmtProfiler::VisitCastExpr(const CastExpr *S) { 550 VisitExpr(S); 551} 552 553void StmtProfiler::VisitImplicitCastExpr(const ImplicitCastExpr *S) { 554 VisitCastExpr(S); 555 ID.AddInteger(S->getValueKind()); 556} 557 558void StmtProfiler::VisitExplicitCastExpr(const ExplicitCastExpr *S) { 559 VisitCastExpr(S); 560 VisitType(S->getTypeAsWritten()); 561} 562 563void StmtProfiler::VisitCStyleCastExpr(const CStyleCastExpr *S) { 564 VisitExplicitCastExpr(S); 565} 566 567void StmtProfiler::VisitBinaryOperator(const BinaryOperator *S) { 568 VisitExpr(S); 569 ID.AddInteger(S->getOpcode()); 570} 571 572void 573StmtProfiler::VisitCompoundAssignOperator(const CompoundAssignOperator *S) { 574 VisitBinaryOperator(S); 575} 576 577void StmtProfiler::VisitConditionalOperator(const ConditionalOperator *S) { 578 VisitExpr(S); 579} 580 581void StmtProfiler::VisitBinaryConditionalOperator( 582 const BinaryConditionalOperator *S) { 583 VisitExpr(S); 584} 585 586void StmtProfiler::VisitAddrLabelExpr(const AddrLabelExpr *S) { 587 VisitExpr(S); 588 VisitDecl(S->getLabel()); 589} 590 591void StmtProfiler::VisitStmtExpr(const StmtExpr *S) { 592 VisitExpr(S); 593} 594 595void StmtProfiler::VisitShuffleVectorExpr(const ShuffleVectorExpr *S) { 596 VisitExpr(S); 597} 598 599void StmtProfiler::VisitConvertVectorExpr(const ConvertVectorExpr *S) { 600 VisitExpr(S); 601} 602 603void StmtProfiler::VisitChooseExpr(const ChooseExpr *S) { 604 VisitExpr(S); 605} 606 607void StmtProfiler::VisitGNUNullExpr(const GNUNullExpr *S) { 608 VisitExpr(S); 609} 610 611void StmtProfiler::VisitVAArgExpr(const VAArgExpr *S) { 612 VisitExpr(S); 613} 614 615void StmtProfiler::VisitInitListExpr(const InitListExpr *S) { 616 if (S->getSyntacticForm()) { 617 VisitInitListExpr(S->getSyntacticForm()); 618 return; 619 } 620 621 VisitExpr(S); 622} 623 624void StmtProfiler::VisitDesignatedInitExpr(const DesignatedInitExpr *S) { 625 VisitExpr(S); 626 ID.AddBoolean(S->usesGNUSyntax()); 627 for (DesignatedInitExpr::const_designators_iterator D = 628 S->designators_begin(), DEnd = S->designators_end(); 629 D != DEnd; ++D) { 630 if (D->isFieldDesignator()) { 631 ID.AddInteger(0); 632 VisitName(D->getFieldName()); 633 continue; 634 } 635 636 if (D->isArrayDesignator()) { 637 ID.AddInteger(1); 638 } else { 639 assert(D->isArrayRangeDesignator()); 640 ID.AddInteger(2); 641 } 642 ID.AddInteger(D->getFirstExprIndex()); 643 } 644} 645 646void StmtProfiler::VisitImplicitValueInitExpr(const ImplicitValueInitExpr *S) { 647 VisitExpr(S); 648} 649 650void StmtProfiler::VisitExtVectorElementExpr(const ExtVectorElementExpr *S) { 651 VisitExpr(S); 652 VisitName(&S->getAccessor()); 653} 654 655void StmtProfiler::VisitBlockExpr(const BlockExpr *S) { 656 VisitExpr(S); 657 VisitDecl(S->getBlockDecl()); 658} 659 660void StmtProfiler::VisitGenericSelectionExpr(const GenericSelectionExpr *S) { 661 VisitExpr(S); 662 for (unsigned i = 0; i != S->getNumAssocs(); ++i) { 663 QualType T = S->getAssocType(i); 664 if (T.isNull()) 665 ID.AddPointer(nullptr); 666 else 667 VisitType(T); 668 VisitExpr(S->getAssocExpr(i)); 669 } 670} 671 672void StmtProfiler::VisitPseudoObjectExpr(const PseudoObjectExpr *S) { 673 VisitExpr(S); 674 for (PseudoObjectExpr::const_semantics_iterator 675 i = S->semantics_begin(), e = S->semantics_end(); i != e; ++i) 676 // Normally, we would not profile the source expressions of OVEs. 677 if (const OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(*i)) 678 Visit(OVE->getSourceExpr()); 679} 680 681void StmtProfiler::VisitAtomicExpr(const AtomicExpr *S) { 682 VisitExpr(S); 683 ID.AddInteger(S->getOp()); 684} 685 686static Stmt::StmtClass DecodeOperatorCall(const CXXOperatorCallExpr *S, 687 UnaryOperatorKind &UnaryOp, 688 BinaryOperatorKind &BinaryOp) { 689 switch (S->getOperator()) { 690 case OO_None: 691 case OO_New: 692 case OO_Delete: 693 case OO_Array_New: 694 case OO_Array_Delete: 695 case OO_Arrow: 696 case OO_Call: 697 case OO_Conditional: 698 case NUM_OVERLOADED_OPERATORS: 699 llvm_unreachable("Invalid operator call kind"); 700 701 case OO_Plus: 702 if (S->getNumArgs() == 1) { 703 UnaryOp = UO_Plus; 704 return Stmt::UnaryOperatorClass; 705 } 706 707 BinaryOp = BO_Add; 708 return Stmt::BinaryOperatorClass; 709 710 case OO_Minus: 711 if (S->getNumArgs() == 1) { 712 UnaryOp = UO_Minus; 713 return Stmt::UnaryOperatorClass; 714 } 715 716 BinaryOp = BO_Sub; 717 return Stmt::BinaryOperatorClass; 718 719 case OO_Star: 720 if (S->getNumArgs() == 1) { 721 UnaryOp = UO_Deref; 722 return Stmt::UnaryOperatorClass; 723 } 724 725 BinaryOp = BO_Mul; 726 return Stmt::BinaryOperatorClass; 727 728 case OO_Slash: 729 BinaryOp = BO_Div; 730 return Stmt::BinaryOperatorClass; 731 732 case OO_Percent: 733 BinaryOp = BO_Rem; 734 return Stmt::BinaryOperatorClass; 735 736 case OO_Caret: 737 BinaryOp = BO_Xor; 738 return Stmt::BinaryOperatorClass; 739 740 case OO_Amp: 741 if (S->getNumArgs() == 1) { 742 UnaryOp = UO_AddrOf; 743 return Stmt::UnaryOperatorClass; 744 } 745 746 BinaryOp = BO_And; 747 return Stmt::BinaryOperatorClass; 748 749 case OO_Pipe: 750 BinaryOp = BO_Or; 751 return Stmt::BinaryOperatorClass; 752 753 case OO_Tilde: 754 UnaryOp = UO_Not; 755 return Stmt::UnaryOperatorClass; 756 757 case OO_Exclaim: 758 UnaryOp = UO_LNot; 759 return Stmt::UnaryOperatorClass; 760 761 case OO_Equal: 762 BinaryOp = BO_Assign; 763 return Stmt::BinaryOperatorClass; 764 765 case OO_Less: 766 BinaryOp = BO_LT; 767 return Stmt::BinaryOperatorClass; 768 769 case OO_Greater: 770 BinaryOp = BO_GT; 771 return Stmt::BinaryOperatorClass; 772 773 case OO_PlusEqual: 774 BinaryOp = BO_AddAssign; 775 return Stmt::CompoundAssignOperatorClass; 776 777 case OO_MinusEqual: 778 BinaryOp = BO_SubAssign; 779 return Stmt::CompoundAssignOperatorClass; 780 781 case OO_StarEqual: 782 BinaryOp = BO_MulAssign; 783 return Stmt::CompoundAssignOperatorClass; 784 785 case OO_SlashEqual: 786 BinaryOp = BO_DivAssign; 787 return Stmt::CompoundAssignOperatorClass; 788 789 case OO_PercentEqual: 790 BinaryOp = BO_RemAssign; 791 return Stmt::CompoundAssignOperatorClass; 792 793 case OO_CaretEqual: 794 BinaryOp = BO_XorAssign; 795 return Stmt::CompoundAssignOperatorClass; 796 797 case OO_AmpEqual: 798 BinaryOp = BO_AndAssign; 799 return Stmt::CompoundAssignOperatorClass; 800 801 case OO_PipeEqual: 802 BinaryOp = BO_OrAssign; 803 return Stmt::CompoundAssignOperatorClass; 804 805 case OO_LessLess: 806 BinaryOp = BO_Shl; 807 return Stmt::BinaryOperatorClass; 808 809 case OO_GreaterGreater: 810 BinaryOp = BO_Shr; 811 return Stmt::BinaryOperatorClass; 812 813 case OO_LessLessEqual: 814 BinaryOp = BO_ShlAssign; 815 return Stmt::CompoundAssignOperatorClass; 816 817 case OO_GreaterGreaterEqual: 818 BinaryOp = BO_ShrAssign; 819 return Stmt::CompoundAssignOperatorClass; 820 821 case OO_EqualEqual: 822 BinaryOp = BO_EQ; 823 return Stmt::BinaryOperatorClass; 824 825 case OO_ExclaimEqual: 826 BinaryOp = BO_NE; 827 return Stmt::BinaryOperatorClass; 828 829 case OO_LessEqual: 830 BinaryOp = BO_LE; 831 return Stmt::BinaryOperatorClass; 832 833 case OO_GreaterEqual: 834 BinaryOp = BO_GE; 835 return Stmt::BinaryOperatorClass; 836 837 case OO_AmpAmp: 838 BinaryOp = BO_LAnd; 839 return Stmt::BinaryOperatorClass; 840 841 case OO_PipePipe: 842 BinaryOp = BO_LOr; 843 return Stmt::BinaryOperatorClass; 844 845 case OO_PlusPlus: 846 UnaryOp = S->getNumArgs() == 1? UO_PreInc 847 : UO_PostInc; 848 return Stmt::UnaryOperatorClass; 849 850 case OO_MinusMinus: 851 UnaryOp = S->getNumArgs() == 1? UO_PreDec 852 : UO_PostDec; 853 return Stmt::UnaryOperatorClass; 854 855 case OO_Comma: 856 BinaryOp = BO_Comma; 857 return Stmt::BinaryOperatorClass; 858 859 860 case OO_ArrowStar: 861 BinaryOp = BO_PtrMemI; 862 return Stmt::BinaryOperatorClass; 863 864 case OO_Subscript: 865 return Stmt::ArraySubscriptExprClass; 866 } 867 868 llvm_unreachable("Invalid overloaded operator expression"); 869} 870 871 872void StmtProfiler::VisitCXXOperatorCallExpr(const CXXOperatorCallExpr *S) { 873 if (S->isTypeDependent()) { 874 // Type-dependent operator calls are profiled like their underlying 875 // syntactic operator. 876 UnaryOperatorKind UnaryOp = UO_Extension; 877 BinaryOperatorKind BinaryOp = BO_Comma; 878 Stmt::StmtClass SC = DecodeOperatorCall(S, UnaryOp, BinaryOp); 879 880 ID.AddInteger(SC); 881 for (unsigned I = 0, N = S->getNumArgs(); I != N; ++I) 882 Visit(S->getArg(I)); 883 if (SC == Stmt::UnaryOperatorClass) 884 ID.AddInteger(UnaryOp); 885 else if (SC == Stmt::BinaryOperatorClass || 886 SC == Stmt::CompoundAssignOperatorClass) 887 ID.AddInteger(BinaryOp); 888 else 889 assert(SC == Stmt::ArraySubscriptExprClass); 890 891 return; 892 } 893 894 VisitCallExpr(S); 895 ID.AddInteger(S->getOperator()); 896} 897 898void StmtProfiler::VisitCXXMemberCallExpr(const CXXMemberCallExpr *S) { 899 VisitCallExpr(S); 900} 901 902void StmtProfiler::VisitCUDAKernelCallExpr(const CUDAKernelCallExpr *S) { 903 VisitCallExpr(S); 904} 905 906void StmtProfiler::VisitAsTypeExpr(const AsTypeExpr *S) { 907 VisitExpr(S); 908} 909 910void StmtProfiler::VisitCXXNamedCastExpr(const CXXNamedCastExpr *S) { 911 VisitExplicitCastExpr(S); 912} 913 914void StmtProfiler::VisitCXXStaticCastExpr(const CXXStaticCastExpr *S) { 915 VisitCXXNamedCastExpr(S); 916} 917 918void StmtProfiler::VisitCXXDynamicCastExpr(const CXXDynamicCastExpr *S) { 919 VisitCXXNamedCastExpr(S); 920} 921 922void 923StmtProfiler::VisitCXXReinterpretCastExpr(const CXXReinterpretCastExpr *S) { 924 VisitCXXNamedCastExpr(S); 925} 926 927void StmtProfiler::VisitCXXConstCastExpr(const CXXConstCastExpr *S) { 928 VisitCXXNamedCastExpr(S); 929} 930 931void StmtProfiler::VisitUserDefinedLiteral(const UserDefinedLiteral *S) { 932 VisitCallExpr(S); 933} 934 935void StmtProfiler::VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *S) { 936 VisitExpr(S); 937 ID.AddBoolean(S->getValue()); 938} 939 940void StmtProfiler::VisitCXXNullPtrLiteralExpr(const CXXNullPtrLiteralExpr *S) { 941 VisitExpr(S); 942} 943 944void StmtProfiler::VisitCXXStdInitializerListExpr( 945 const CXXStdInitializerListExpr *S) { 946 VisitExpr(S); 947} 948 949void StmtProfiler::VisitCXXTypeidExpr(const CXXTypeidExpr *S) { 950 VisitExpr(S); 951 if (S->isTypeOperand()) 952 VisitType(S->getTypeOperandSourceInfo()->getType()); 953} 954 955void StmtProfiler::VisitCXXUuidofExpr(const CXXUuidofExpr *S) { 956 VisitExpr(S); 957 if (S->isTypeOperand()) 958 VisitType(S->getTypeOperandSourceInfo()->getType()); 959} 960 961void StmtProfiler::VisitMSPropertyRefExpr(const MSPropertyRefExpr *S) { 962 VisitExpr(S); 963 VisitDecl(S->getPropertyDecl()); 964} 965 966void StmtProfiler::VisitCXXThisExpr(const CXXThisExpr *S) { 967 VisitExpr(S); 968 ID.AddBoolean(S->isImplicit()); 969} 970 971void StmtProfiler::VisitCXXThrowExpr(const CXXThrowExpr *S) { 972 VisitExpr(S); 973} 974 975void StmtProfiler::VisitCXXDefaultArgExpr(const CXXDefaultArgExpr *S) { 976 VisitExpr(S); 977 VisitDecl(S->getParam()); 978} 979 980void StmtProfiler::VisitCXXDefaultInitExpr(const CXXDefaultInitExpr *S) { 981 VisitExpr(S); 982 VisitDecl(S->getField()); 983} 984 985void StmtProfiler::VisitCXXBindTemporaryExpr(const CXXBindTemporaryExpr *S) { 986 VisitExpr(S); 987 VisitDecl( 988 const_cast<CXXDestructorDecl *>(S->getTemporary()->getDestructor())); 989} 990 991void StmtProfiler::VisitCXXConstructExpr(const CXXConstructExpr *S) { 992 VisitExpr(S); 993 VisitDecl(S->getConstructor()); 994 ID.AddBoolean(S->isElidable()); 995} 996 997void StmtProfiler::VisitCXXFunctionalCastExpr(const CXXFunctionalCastExpr *S) { 998 VisitExplicitCastExpr(S); 999} 1000 1001void 1002StmtProfiler::VisitCXXTemporaryObjectExpr(const CXXTemporaryObjectExpr *S) { 1003 VisitCXXConstructExpr(S); 1004} 1005 1006void 1007StmtProfiler::VisitLambdaExpr(const LambdaExpr *S) { 1008 VisitExpr(S); 1009 for (LambdaExpr::capture_iterator C = S->explicit_capture_begin(), 1010 CEnd = S->explicit_capture_end(); 1011 C != CEnd; ++C) { 1012 ID.AddInteger(C->getCaptureKind()); 1013 switch (C->getCaptureKind()) { 1014 case LCK_This: 1015 break; 1016 case LCK_ByRef: 1017 case LCK_ByCopy: 1018 VisitDecl(C->getCapturedVar()); 1019 ID.AddBoolean(C->isPackExpansion()); 1020 break; 1021 } 1022 } 1023 // Note: If we actually needed to be able to match lambda 1024 // expressions, we would have to consider parameters and return type 1025 // here, among other things. 1026 VisitStmt(S->getBody()); 1027} 1028 1029void 1030StmtProfiler::VisitCXXScalarValueInitExpr(const CXXScalarValueInitExpr *S) { 1031 VisitExpr(S); 1032} 1033 1034void StmtProfiler::VisitCXXDeleteExpr(const CXXDeleteExpr *S) { 1035 VisitExpr(S); 1036 ID.AddBoolean(S->isGlobalDelete()); 1037 ID.AddBoolean(S->isArrayForm()); 1038 VisitDecl(S->getOperatorDelete()); 1039} 1040 1041 1042void StmtProfiler::VisitCXXNewExpr(const CXXNewExpr *S) { 1043 VisitExpr(S); 1044 VisitType(S->getAllocatedType()); 1045 VisitDecl(S->getOperatorNew()); 1046 VisitDecl(S->getOperatorDelete()); 1047 ID.AddBoolean(S->isArray()); 1048 ID.AddInteger(S->getNumPlacementArgs()); 1049 ID.AddBoolean(S->isGlobalNew()); 1050 ID.AddBoolean(S->isParenTypeId()); 1051 ID.AddInteger(S->getInitializationStyle()); 1052} 1053 1054void 1055StmtProfiler::VisitCXXPseudoDestructorExpr(const CXXPseudoDestructorExpr *S) { 1056 VisitExpr(S); 1057 ID.AddBoolean(S->isArrow()); 1058 VisitNestedNameSpecifier(S->getQualifier()); 1059 ID.AddBoolean(S->getScopeTypeInfo() != nullptr); 1060 if (S->getScopeTypeInfo()) 1061 VisitType(S->getScopeTypeInfo()->getType()); 1062 ID.AddBoolean(S->getDestroyedTypeInfo() != nullptr); 1063 if (S->getDestroyedTypeInfo()) 1064 VisitType(S->getDestroyedType()); 1065 else 1066 ID.AddPointer(S->getDestroyedTypeIdentifier()); 1067} 1068 1069void StmtProfiler::VisitOverloadExpr(const OverloadExpr *S) { 1070 VisitExpr(S); 1071 VisitNestedNameSpecifier(S->getQualifier()); 1072 VisitName(S->getName()); 1073 ID.AddBoolean(S->hasExplicitTemplateArgs()); 1074 if (S->hasExplicitTemplateArgs()) 1075 VisitTemplateArguments(S->getExplicitTemplateArgs().getTemplateArgs(), 1076 S->getExplicitTemplateArgs().NumTemplateArgs); 1077} 1078 1079void 1080StmtProfiler::VisitUnresolvedLookupExpr(const UnresolvedLookupExpr *S) { 1081 VisitOverloadExpr(S); 1082} 1083 1084void StmtProfiler::VisitTypeTraitExpr(const TypeTraitExpr *S) { 1085 VisitExpr(S); 1086 ID.AddInteger(S->getTrait()); 1087 ID.AddInteger(S->getNumArgs()); 1088 for (unsigned I = 0, N = S->getNumArgs(); I != N; ++I) 1089 VisitType(S->getArg(I)->getType()); 1090} 1091 1092void StmtProfiler::VisitArrayTypeTraitExpr(const ArrayTypeTraitExpr *S) { 1093 VisitExpr(S); 1094 ID.AddInteger(S->getTrait()); 1095 VisitType(S->getQueriedType()); 1096} 1097 1098void StmtProfiler::VisitExpressionTraitExpr(const ExpressionTraitExpr *S) { 1099 VisitExpr(S); 1100 ID.AddInteger(S->getTrait()); 1101 VisitExpr(S->getQueriedExpression()); 1102} 1103 1104void StmtProfiler::VisitDependentScopeDeclRefExpr( 1105 const DependentScopeDeclRefExpr *S) { 1106 VisitExpr(S); 1107 VisitName(S->getDeclName()); 1108 VisitNestedNameSpecifier(S->getQualifier()); 1109 ID.AddBoolean(S->hasExplicitTemplateArgs()); 1110 if (S->hasExplicitTemplateArgs()) 1111 VisitTemplateArguments(S->getTemplateArgs(), S->getNumTemplateArgs()); 1112} 1113 1114void StmtProfiler::VisitExprWithCleanups(const ExprWithCleanups *S) { 1115 VisitExpr(S); 1116} 1117 1118void StmtProfiler::VisitCXXUnresolvedConstructExpr( 1119 const CXXUnresolvedConstructExpr *S) { 1120 VisitExpr(S); 1121 VisitType(S->getTypeAsWritten()); 1122} 1123 1124void StmtProfiler::VisitCXXDependentScopeMemberExpr( 1125 const CXXDependentScopeMemberExpr *S) { 1126 ID.AddBoolean(S->isImplicitAccess()); 1127 if (!S->isImplicitAccess()) { 1128 VisitExpr(S); 1129 ID.AddBoolean(S->isArrow()); 1130 } 1131 VisitNestedNameSpecifier(S->getQualifier()); 1132 VisitName(S->getMember()); 1133 ID.AddBoolean(S->hasExplicitTemplateArgs()); 1134 if (S->hasExplicitTemplateArgs()) 1135 VisitTemplateArguments(S->getTemplateArgs(), S->getNumTemplateArgs()); 1136} 1137 1138void StmtProfiler::VisitUnresolvedMemberExpr(const UnresolvedMemberExpr *S) { 1139 ID.AddBoolean(S->isImplicitAccess()); 1140 if (!S->isImplicitAccess()) { 1141 VisitExpr(S); 1142 ID.AddBoolean(S->isArrow()); 1143 } 1144 VisitNestedNameSpecifier(S->getQualifier()); 1145 VisitName(S->getMemberName()); 1146 ID.AddBoolean(S->hasExplicitTemplateArgs()); 1147 if (S->hasExplicitTemplateArgs()) 1148 VisitTemplateArguments(S->getTemplateArgs(), S->getNumTemplateArgs()); 1149} 1150 1151void StmtProfiler::VisitCXXNoexceptExpr(const CXXNoexceptExpr *S) { 1152 VisitExpr(S); 1153} 1154 1155void StmtProfiler::VisitPackExpansionExpr(const PackExpansionExpr *S) { 1156 VisitExpr(S); 1157} 1158 1159void StmtProfiler::VisitSizeOfPackExpr(const SizeOfPackExpr *S) { 1160 VisitExpr(S); 1161 VisitDecl(S->getPack()); 1162} 1163 1164void StmtProfiler::VisitSubstNonTypeTemplateParmPackExpr( 1165 const SubstNonTypeTemplateParmPackExpr *S) { 1166 VisitExpr(S); 1167 VisitDecl(S->getParameterPack()); 1168 VisitTemplateArgument(S->getArgumentPack()); 1169} 1170 1171void StmtProfiler::VisitSubstNonTypeTemplateParmExpr( 1172 const SubstNonTypeTemplateParmExpr *E) { 1173 // Profile exactly as the replacement expression. 1174 Visit(E->getReplacement()); 1175} 1176 1177void StmtProfiler::VisitFunctionParmPackExpr(const FunctionParmPackExpr *S) { 1178 VisitExpr(S); 1179 VisitDecl(S->getParameterPack()); 1180 ID.AddInteger(S->getNumExpansions()); 1181 for (FunctionParmPackExpr::iterator I = S->begin(), E = S->end(); I != E; ++I) 1182 VisitDecl(*I); 1183} 1184 1185void StmtProfiler::VisitMaterializeTemporaryExpr( 1186 const MaterializeTemporaryExpr *S) { 1187 VisitExpr(S); 1188} 1189 1190void StmtProfiler::VisitOpaqueValueExpr(const OpaqueValueExpr *E) { 1191 VisitExpr(E); 1192} 1193 1194void StmtProfiler::VisitObjCStringLiteral(const ObjCStringLiteral *S) { 1195 VisitExpr(S); 1196} 1197 1198void StmtProfiler::VisitObjCBoxedExpr(const ObjCBoxedExpr *E) { 1199 VisitExpr(E); 1200} 1201 1202void StmtProfiler::VisitObjCArrayLiteral(const ObjCArrayLiteral *E) { 1203 VisitExpr(E); 1204} 1205 1206void StmtProfiler::VisitObjCDictionaryLiteral(const ObjCDictionaryLiteral *E) { 1207 VisitExpr(E); 1208} 1209 1210void StmtProfiler::VisitObjCEncodeExpr(const ObjCEncodeExpr *S) { 1211 VisitExpr(S); 1212 VisitType(S->getEncodedType()); 1213} 1214 1215void StmtProfiler::VisitObjCSelectorExpr(const ObjCSelectorExpr *S) { 1216 VisitExpr(S); 1217 VisitName(S->getSelector()); 1218} 1219 1220void StmtProfiler::VisitObjCProtocolExpr(const ObjCProtocolExpr *S) { 1221 VisitExpr(S); 1222 VisitDecl(S->getProtocol()); 1223} 1224 1225void StmtProfiler::VisitObjCIvarRefExpr(const ObjCIvarRefExpr *S) { 1226 VisitExpr(S); 1227 VisitDecl(S->getDecl()); 1228 ID.AddBoolean(S->isArrow()); 1229 ID.AddBoolean(S->isFreeIvar()); 1230} 1231 1232void StmtProfiler::VisitObjCPropertyRefExpr(const ObjCPropertyRefExpr *S) { 1233 VisitExpr(S); 1234 if (S->isImplicitProperty()) { 1235 VisitDecl(S->getImplicitPropertyGetter()); 1236 VisitDecl(S->getImplicitPropertySetter()); 1237 } else { 1238 VisitDecl(S->getExplicitProperty()); 1239 } 1240 if (S->isSuperReceiver()) { 1241 ID.AddBoolean(S->isSuperReceiver()); 1242 VisitType(S->getSuperReceiverType()); 1243 } 1244} 1245 1246void StmtProfiler::VisitObjCSubscriptRefExpr(const ObjCSubscriptRefExpr *S) { 1247 VisitExpr(S); 1248 VisitDecl(S->getAtIndexMethodDecl()); 1249 VisitDecl(S->setAtIndexMethodDecl()); 1250} 1251 1252void StmtProfiler::VisitObjCMessageExpr(const ObjCMessageExpr *S) { 1253 VisitExpr(S); 1254 VisitName(S->getSelector()); 1255 VisitDecl(S->getMethodDecl()); 1256} 1257 1258void StmtProfiler::VisitObjCIsaExpr(const ObjCIsaExpr *S) { 1259 VisitExpr(S); 1260 ID.AddBoolean(S->isArrow()); 1261} 1262 1263void StmtProfiler::VisitObjCBoolLiteralExpr(const ObjCBoolLiteralExpr *S) { 1264 VisitExpr(S); 1265 ID.AddBoolean(S->getValue()); 1266} 1267 1268void StmtProfiler::VisitObjCIndirectCopyRestoreExpr( 1269 const ObjCIndirectCopyRestoreExpr *S) { 1270 VisitExpr(S); 1271 ID.AddBoolean(S->shouldCopy()); 1272} 1273 1274void StmtProfiler::VisitObjCBridgedCastExpr(const ObjCBridgedCastExpr *S) { 1275 VisitExplicitCastExpr(S); 1276 ID.AddBoolean(S->getBridgeKind()); 1277} 1278 1279void StmtProfiler::VisitDecl(const Decl *D) { 1280 ID.AddInteger(D? D->getKind() : 0); 1281 1282 if (Canonical && D) { 1283 if (const NonTypeTemplateParmDecl *NTTP = 1284 dyn_cast<NonTypeTemplateParmDecl>(D)) { 1285 ID.AddInteger(NTTP->getDepth()); 1286 ID.AddInteger(NTTP->getIndex()); 1287 ID.AddBoolean(NTTP->isParameterPack()); 1288 VisitType(NTTP->getType()); 1289 return; 1290 } 1291 1292 if (const ParmVarDecl *Parm = dyn_cast<ParmVarDecl>(D)) { 1293 // The Itanium C++ ABI uses the type, scope depth, and scope 1294 // index of a parameter when mangling expressions that involve 1295 // function parameters, so we will use the parameter's type for 1296 // establishing function parameter identity. That way, our 1297 // definition of "equivalent" (per C++ [temp.over.link]) is at 1298 // least as strong as the definition of "equivalent" used for 1299 // name mangling. 1300 VisitType(Parm->getType()); 1301 ID.AddInteger(Parm->getFunctionScopeDepth()); 1302 ID.AddInteger(Parm->getFunctionScopeIndex()); 1303 return; 1304 } 1305 1306 if (const TemplateTypeParmDecl *TTP = 1307 dyn_cast<TemplateTypeParmDecl>(D)) { 1308 ID.AddInteger(TTP->getDepth()); 1309 ID.AddInteger(TTP->getIndex()); 1310 ID.AddBoolean(TTP->isParameterPack()); 1311 return; 1312 } 1313 1314 if (const TemplateTemplateParmDecl *TTP = 1315 dyn_cast<TemplateTemplateParmDecl>(D)) { 1316 ID.AddInteger(TTP->getDepth()); 1317 ID.AddInteger(TTP->getIndex()); 1318 ID.AddBoolean(TTP->isParameterPack()); 1319 return; 1320 } 1321 } 1322 1323 ID.AddPointer(D? D->getCanonicalDecl() : nullptr); 1324} 1325 1326void StmtProfiler::VisitType(QualType T) { 1327 if (Canonical) 1328 T = Context.getCanonicalType(T); 1329 1330 ID.AddPointer(T.getAsOpaquePtr()); 1331} 1332 1333void StmtProfiler::VisitName(DeclarationName Name) { 1334 ID.AddPointer(Name.getAsOpaquePtr()); 1335} 1336 1337void StmtProfiler::VisitNestedNameSpecifier(NestedNameSpecifier *NNS) { 1338 if (Canonical) 1339 NNS = Context.getCanonicalNestedNameSpecifier(NNS); 1340 ID.AddPointer(NNS); 1341} 1342 1343void StmtProfiler::VisitTemplateName(TemplateName Name) { 1344 if (Canonical) 1345 Name = Context.getCanonicalTemplateName(Name); 1346 1347 Name.Profile(ID); 1348} 1349 1350void StmtProfiler::VisitTemplateArguments(const TemplateArgumentLoc *Args, 1351 unsigned NumArgs) { 1352 ID.AddInteger(NumArgs); 1353 for (unsigned I = 0; I != NumArgs; ++I) 1354 VisitTemplateArgument(Args[I].getArgument()); 1355} 1356 1357void StmtProfiler::VisitTemplateArgument(const TemplateArgument &Arg) { 1358 // Mostly repetitive with TemplateArgument::Profile! 1359 ID.AddInteger(Arg.getKind()); 1360 switch (Arg.getKind()) { 1361 case TemplateArgument::Null: 1362 break; 1363 1364 case TemplateArgument::Type: 1365 VisitType(Arg.getAsType()); 1366 break; 1367 1368 case TemplateArgument::Template: 1369 case TemplateArgument::TemplateExpansion: 1370 VisitTemplateName(Arg.getAsTemplateOrTemplatePattern()); 1371 break; 1372 1373 case TemplateArgument::Declaration: 1374 VisitDecl(Arg.getAsDecl()); 1375 break; 1376 1377 case TemplateArgument::NullPtr: 1378 VisitType(Arg.getNullPtrType()); 1379 break; 1380 1381 case TemplateArgument::Integral: 1382 Arg.getAsIntegral().Profile(ID); 1383 VisitType(Arg.getIntegralType()); 1384 break; 1385 1386 case TemplateArgument::Expression: 1387 Visit(Arg.getAsExpr()); 1388 break; 1389 1390 case TemplateArgument::Pack: 1391 for (const auto &P : Arg.pack_elements()) 1392 VisitTemplateArgument(P); 1393 break; 1394 } 1395} 1396 1397void Stmt::Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context, 1398 bool Canonical) const { 1399 StmtProfiler Profiler(ID, Context, Canonical); 1400 Profiler.Visit(this); 1401} 1402