1 //===---- StmtProfile.cpp - Profile implementation for Stmt ASTs ----------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This file implements the Stmt::Profile method, which builds a unique bit 10 // representation that identifies a statement/expression. 11 // 12 //===----------------------------------------------------------------------===// 13 #include "clang/AST/ASTContext.h" 14 #include "clang/AST/DeclCXX.h" 15 #include "clang/AST/DeclObjC.h" 16 #include "clang/AST/DeclTemplate.h" 17 #include "clang/AST/Expr.h" 18 #include "clang/AST/ExprCXX.h" 19 #include "clang/AST/ExprObjC.h" 20 #include "clang/AST/ExprOpenMP.h" 21 #include "clang/AST/ODRHash.h" 22 #include "clang/AST/StmtVisitor.h" 23 #include "llvm/ADT/FoldingSet.h" 24 using namespace clang; 25 26 namespace { 27 class StmtProfiler : public ConstStmtVisitor<StmtProfiler> { 28 protected: 29 llvm::FoldingSetNodeID &ID; 30 bool Canonical; 31 32 public: 33 StmtProfiler(llvm::FoldingSetNodeID &ID, bool Canonical) 34 : ID(ID), Canonical(Canonical) {} 35 36 virtual ~StmtProfiler() {} 37 38 void VisitStmt(const Stmt *S); 39 40 virtual void HandleStmtClass(Stmt::StmtClass SC) = 0; 41 42 #define STMT(Node, Base) void Visit##Node(const Node *S); 43 #include "clang/AST/StmtNodes.inc" 44 45 /// Visit a declaration that is referenced within an expression 46 /// or statement. 47 virtual void VisitDecl(const Decl *D) = 0; 48 49 /// Visit a type that is referenced within an expression or 50 /// statement. 51 virtual void VisitType(QualType T) = 0; 52 53 /// Visit a name that occurs within an expression or statement. 54 virtual void VisitName(DeclarationName Name, bool TreatAsDecl = false) = 0; 55 56 /// Visit identifiers that are not in Decl's or Type's. 57 virtual void VisitIdentifierInfo(IdentifierInfo *II) = 0; 58 59 /// Visit a nested-name-specifier that occurs within an expression 60 /// or statement. 61 virtual void VisitNestedNameSpecifier(NestedNameSpecifier *NNS) = 0; 62 63 /// Visit a template name that occurs within an expression or 64 /// statement. 65 virtual void VisitTemplateName(TemplateName Name) = 0; 66 67 /// Visit template arguments that occur within an expression or 68 /// statement. 69 void VisitTemplateArguments(const TemplateArgumentLoc *Args, 70 unsigned NumArgs); 71 72 /// Visit a single template argument. 73 void VisitTemplateArgument(const TemplateArgument &Arg); 74 }; 75 76 class StmtProfilerWithPointers : public StmtProfiler { 77 const ASTContext &Context; 78 79 public: 80 StmtProfilerWithPointers(llvm::FoldingSetNodeID &ID, 81 const ASTContext &Context, bool Canonical) 82 : StmtProfiler(ID, Canonical), Context(Context) {} 83 private: 84 void HandleStmtClass(Stmt::StmtClass SC) override { 85 ID.AddInteger(SC); 86 } 87 88 void VisitDecl(const Decl *D) override { 89 ID.AddInteger(D ? D->getKind() : 0); 90 91 if (Canonical && D) { 92 if (const NonTypeTemplateParmDecl *NTTP = 93 dyn_cast<NonTypeTemplateParmDecl>(D)) { 94 ID.AddInteger(NTTP->getDepth()); 95 ID.AddInteger(NTTP->getIndex()); 96 ID.AddBoolean(NTTP->isParameterPack()); 97 VisitType(NTTP->getType()); 98 return; 99 } 100 101 if (const ParmVarDecl *Parm = dyn_cast<ParmVarDecl>(D)) { 102 // The Itanium C++ ABI uses the type, scope depth, and scope 103 // index of a parameter when mangling expressions that involve 104 // function parameters, so we will use the parameter's type for 105 // establishing function parameter identity. That way, our 106 // definition of "equivalent" (per C++ [temp.over.link]) is at 107 // least as strong as the definition of "equivalent" used for 108 // name mangling. 109 VisitType(Parm->getType()); 110 ID.AddInteger(Parm->getFunctionScopeDepth()); 111 ID.AddInteger(Parm->getFunctionScopeIndex()); 112 return; 113 } 114 115 if (const TemplateTypeParmDecl *TTP = 116 dyn_cast<TemplateTypeParmDecl>(D)) { 117 ID.AddInteger(TTP->getDepth()); 118 ID.AddInteger(TTP->getIndex()); 119 ID.AddBoolean(TTP->isParameterPack()); 120 return; 121 } 122 123 if (const TemplateTemplateParmDecl *TTP = 124 dyn_cast<TemplateTemplateParmDecl>(D)) { 125 ID.AddInteger(TTP->getDepth()); 126 ID.AddInteger(TTP->getIndex()); 127 ID.AddBoolean(TTP->isParameterPack()); 128 return; 129 } 130 } 131 132 ID.AddPointer(D ? D->getCanonicalDecl() : nullptr); 133 } 134 135 void VisitType(QualType T) override { 136 if (Canonical && !T.isNull()) 137 T = Context.getCanonicalType(T); 138 139 ID.AddPointer(T.getAsOpaquePtr()); 140 } 141 142 void VisitName(DeclarationName Name, bool /*TreatAsDecl*/) override { 143 ID.AddPointer(Name.getAsOpaquePtr()); 144 } 145 146 void VisitIdentifierInfo(IdentifierInfo *II) override { 147 ID.AddPointer(II); 148 } 149 150 void VisitNestedNameSpecifier(NestedNameSpecifier *NNS) override { 151 if (Canonical) 152 NNS = Context.getCanonicalNestedNameSpecifier(NNS); 153 ID.AddPointer(NNS); 154 } 155 156 void VisitTemplateName(TemplateName Name) override { 157 if (Canonical) 158 Name = Context.getCanonicalTemplateName(Name); 159 160 Name.Profile(ID); 161 } 162 }; 163 164 class StmtProfilerWithoutPointers : public StmtProfiler { 165 ODRHash &Hash; 166 public: 167 StmtProfilerWithoutPointers(llvm::FoldingSetNodeID &ID, ODRHash &Hash) 168 : StmtProfiler(ID, false), Hash(Hash) {} 169 170 private: 171 void HandleStmtClass(Stmt::StmtClass SC) override { 172 if (SC == Stmt::UnresolvedLookupExprClass) { 173 // Pretend that the name looked up is a Decl due to how templates 174 // handle some Decl lookups. 175 ID.AddInteger(Stmt::DeclRefExprClass); 176 } else { 177 ID.AddInteger(SC); 178 } 179 } 180 181 void VisitType(QualType T) override { 182 Hash.AddQualType(T); 183 } 184 185 void VisitName(DeclarationName Name, bool TreatAsDecl) override { 186 if (TreatAsDecl) { 187 // A Decl can be null, so each Decl is preceded by a boolean to 188 // store its nullness. Add a boolean here to match. 189 ID.AddBoolean(true); 190 } 191 Hash.AddDeclarationName(Name, TreatAsDecl); 192 } 193 void VisitIdentifierInfo(IdentifierInfo *II) override { 194 ID.AddBoolean(II); 195 if (II) { 196 Hash.AddIdentifierInfo(II); 197 } 198 } 199 void VisitDecl(const Decl *D) override { 200 ID.AddBoolean(D); 201 if (D) { 202 Hash.AddDecl(D); 203 } 204 } 205 void VisitTemplateName(TemplateName Name) override { 206 Hash.AddTemplateName(Name); 207 } 208 void VisitNestedNameSpecifier(NestedNameSpecifier *NNS) override { 209 ID.AddBoolean(NNS); 210 if (NNS) { 211 Hash.AddNestedNameSpecifier(NNS); 212 } 213 } 214 }; 215 } 216 217 void StmtProfiler::VisitStmt(const Stmt *S) { 218 assert(S && "Requires non-null Stmt pointer"); 219 220 HandleStmtClass(S->getStmtClass()); 221 222 for (const Stmt *SubStmt : S->children()) { 223 if (SubStmt) 224 Visit(SubStmt); 225 else 226 ID.AddInteger(0); 227 } 228 } 229 230 void StmtProfiler::VisitDeclStmt(const DeclStmt *S) { 231 VisitStmt(S); 232 for (const auto *D : S->decls()) 233 VisitDecl(D); 234 } 235 236 void StmtProfiler::VisitNullStmt(const NullStmt *S) { 237 VisitStmt(S); 238 } 239 240 void StmtProfiler::VisitCompoundStmt(const CompoundStmt *S) { 241 VisitStmt(S); 242 } 243 244 void StmtProfiler::VisitCaseStmt(const CaseStmt *S) { 245 VisitStmt(S); 246 } 247 248 void StmtProfiler::VisitDefaultStmt(const DefaultStmt *S) { 249 VisitStmt(S); 250 } 251 252 void StmtProfiler::VisitLabelStmt(const LabelStmt *S) { 253 VisitStmt(S); 254 VisitDecl(S->getDecl()); 255 } 256 257 void StmtProfiler::VisitAttributedStmt(const AttributedStmt *S) { 258 VisitStmt(S); 259 // TODO: maybe visit attributes? 260 } 261 262 void StmtProfiler::VisitIfStmt(const IfStmt *S) { 263 VisitStmt(S); 264 VisitDecl(S->getConditionVariable()); 265 } 266 267 void StmtProfiler::VisitSwitchStmt(const SwitchStmt *S) { 268 VisitStmt(S); 269 VisitDecl(S->getConditionVariable()); 270 } 271 272 void StmtProfiler::VisitWhileStmt(const WhileStmt *S) { 273 VisitStmt(S); 274 VisitDecl(S->getConditionVariable()); 275 } 276 277 void StmtProfiler::VisitDoStmt(const DoStmt *S) { 278 VisitStmt(S); 279 } 280 281 void StmtProfiler::VisitForStmt(const ForStmt *S) { 282 VisitStmt(S); 283 } 284 285 void StmtProfiler::VisitGotoStmt(const GotoStmt *S) { 286 VisitStmt(S); 287 VisitDecl(S->getLabel()); 288 } 289 290 void StmtProfiler::VisitIndirectGotoStmt(const IndirectGotoStmt *S) { 291 VisitStmt(S); 292 } 293 294 void StmtProfiler::VisitContinueStmt(const ContinueStmt *S) { 295 VisitStmt(S); 296 } 297 298 void StmtProfiler::VisitBreakStmt(const BreakStmt *S) { 299 VisitStmt(S); 300 } 301 302 void StmtProfiler::VisitReturnStmt(const ReturnStmt *S) { 303 VisitStmt(S); 304 } 305 306 void StmtProfiler::VisitGCCAsmStmt(const GCCAsmStmt *S) { 307 VisitStmt(S); 308 ID.AddBoolean(S->isVolatile()); 309 ID.AddBoolean(S->isSimple()); 310 VisitStringLiteral(S->getAsmString()); 311 ID.AddInteger(S->getNumOutputs()); 312 for (unsigned I = 0, N = S->getNumOutputs(); I != N; ++I) { 313 ID.AddString(S->getOutputName(I)); 314 VisitStringLiteral(S->getOutputConstraintLiteral(I)); 315 } 316 ID.AddInteger(S->getNumInputs()); 317 for (unsigned I = 0, N = S->getNumInputs(); I != N; ++I) { 318 ID.AddString(S->getInputName(I)); 319 VisitStringLiteral(S->getInputConstraintLiteral(I)); 320 } 321 ID.AddInteger(S->getNumClobbers()); 322 for (unsigned I = 0, N = S->getNumClobbers(); I != N; ++I) 323 VisitStringLiteral(S->getClobberStringLiteral(I)); 324 ID.AddInteger(S->getNumLabels()); 325 for (auto *L : S->labels()) 326 VisitDecl(L->getLabel()); 327 } 328 329 void StmtProfiler::VisitMSAsmStmt(const MSAsmStmt *S) { 330 // FIXME: Implement MS style inline asm statement profiler. 331 VisitStmt(S); 332 } 333 334 void StmtProfiler::VisitCXXCatchStmt(const CXXCatchStmt *S) { 335 VisitStmt(S); 336 VisitType(S->getCaughtType()); 337 } 338 339 void StmtProfiler::VisitCXXTryStmt(const CXXTryStmt *S) { 340 VisitStmt(S); 341 } 342 343 void StmtProfiler::VisitCXXForRangeStmt(const CXXForRangeStmt *S) { 344 VisitStmt(S); 345 } 346 347 void StmtProfiler::VisitMSDependentExistsStmt(const MSDependentExistsStmt *S) { 348 VisitStmt(S); 349 ID.AddBoolean(S->isIfExists()); 350 VisitNestedNameSpecifier(S->getQualifierLoc().getNestedNameSpecifier()); 351 VisitName(S->getNameInfo().getName()); 352 } 353 354 void StmtProfiler::VisitSEHTryStmt(const SEHTryStmt *S) { 355 VisitStmt(S); 356 } 357 358 void StmtProfiler::VisitSEHFinallyStmt(const SEHFinallyStmt *S) { 359 VisitStmt(S); 360 } 361 362 void StmtProfiler::VisitSEHExceptStmt(const SEHExceptStmt *S) { 363 VisitStmt(S); 364 } 365 366 void StmtProfiler::VisitSEHLeaveStmt(const SEHLeaveStmt *S) { 367 VisitStmt(S); 368 } 369 370 void StmtProfiler::VisitCapturedStmt(const CapturedStmt *S) { 371 VisitStmt(S); 372 } 373 374 void StmtProfiler::VisitObjCForCollectionStmt(const ObjCForCollectionStmt *S) { 375 VisitStmt(S); 376 } 377 378 void StmtProfiler::VisitObjCAtCatchStmt(const ObjCAtCatchStmt *S) { 379 VisitStmt(S); 380 ID.AddBoolean(S->hasEllipsis()); 381 if (S->getCatchParamDecl()) 382 VisitType(S->getCatchParamDecl()->getType()); 383 } 384 385 void StmtProfiler::VisitObjCAtFinallyStmt(const ObjCAtFinallyStmt *S) { 386 VisitStmt(S); 387 } 388 389 void StmtProfiler::VisitObjCAtTryStmt(const ObjCAtTryStmt *S) { 390 VisitStmt(S); 391 } 392 393 void 394 StmtProfiler::VisitObjCAtSynchronizedStmt(const ObjCAtSynchronizedStmt *S) { 395 VisitStmt(S); 396 } 397 398 void StmtProfiler::VisitObjCAtThrowStmt(const ObjCAtThrowStmt *S) { 399 VisitStmt(S); 400 } 401 402 void 403 StmtProfiler::VisitObjCAutoreleasePoolStmt(const ObjCAutoreleasePoolStmt *S) { 404 VisitStmt(S); 405 } 406 407 namespace { 408 class OMPClauseProfiler : public ConstOMPClauseVisitor<OMPClauseProfiler> { 409 StmtProfiler *Profiler; 410 /// Process clauses with list of variables. 411 template <typename T> 412 void VisitOMPClauseList(T *Node); 413 414 public: 415 OMPClauseProfiler(StmtProfiler *P) : Profiler(P) { } 416 #define OPENMP_CLAUSE(Name, Class) \ 417 void Visit##Class(const Class *C); 418 #include "clang/Basic/OpenMPKinds.def" 419 void VistOMPClauseWithPreInit(const OMPClauseWithPreInit *C); 420 void VistOMPClauseWithPostUpdate(const OMPClauseWithPostUpdate *C); 421 }; 422 423 void OMPClauseProfiler::VistOMPClauseWithPreInit( 424 const OMPClauseWithPreInit *C) { 425 if (auto *S = C->getPreInitStmt()) 426 Profiler->VisitStmt(S); 427 } 428 429 void OMPClauseProfiler::VistOMPClauseWithPostUpdate( 430 const OMPClauseWithPostUpdate *C) { 431 VistOMPClauseWithPreInit(C); 432 if (auto *E = C->getPostUpdateExpr()) 433 Profiler->VisitStmt(E); 434 } 435 436 void OMPClauseProfiler::VisitOMPIfClause(const OMPIfClause *C) { 437 VistOMPClauseWithPreInit(C); 438 if (C->getCondition()) 439 Profiler->VisitStmt(C->getCondition()); 440 } 441 442 void OMPClauseProfiler::VisitOMPFinalClause(const OMPFinalClause *C) { 443 VistOMPClauseWithPreInit(C); 444 if (C->getCondition()) 445 Profiler->VisitStmt(C->getCondition()); 446 } 447 448 void OMPClauseProfiler::VisitOMPNumThreadsClause(const OMPNumThreadsClause *C) { 449 VistOMPClauseWithPreInit(C); 450 if (C->getNumThreads()) 451 Profiler->VisitStmt(C->getNumThreads()); 452 } 453 454 void OMPClauseProfiler::VisitOMPSafelenClause(const OMPSafelenClause *C) { 455 if (C->getSafelen()) 456 Profiler->VisitStmt(C->getSafelen()); 457 } 458 459 void OMPClauseProfiler::VisitOMPSimdlenClause(const OMPSimdlenClause *C) { 460 if (C->getSimdlen()) 461 Profiler->VisitStmt(C->getSimdlen()); 462 } 463 464 void OMPClauseProfiler::VisitOMPAllocatorClause(const OMPAllocatorClause *C) { 465 if (C->getAllocator()) 466 Profiler->VisitStmt(C->getAllocator()); 467 } 468 469 void OMPClauseProfiler::VisitOMPCollapseClause(const OMPCollapseClause *C) { 470 if (C->getNumForLoops()) 471 Profiler->VisitStmt(C->getNumForLoops()); 472 } 473 474 void OMPClauseProfiler::VisitOMPDefaultClause(const OMPDefaultClause *C) { } 475 476 void OMPClauseProfiler::VisitOMPProcBindClause(const OMPProcBindClause *C) { } 477 478 void OMPClauseProfiler::VisitOMPUnifiedAddressClause( 479 const OMPUnifiedAddressClause *C) {} 480 481 void OMPClauseProfiler::VisitOMPUnifiedSharedMemoryClause( 482 const OMPUnifiedSharedMemoryClause *C) {} 483 484 void OMPClauseProfiler::VisitOMPReverseOffloadClause( 485 const OMPReverseOffloadClause *C) {} 486 487 void OMPClauseProfiler::VisitOMPDynamicAllocatorsClause( 488 const OMPDynamicAllocatorsClause *C) {} 489 490 void OMPClauseProfiler::VisitOMPAtomicDefaultMemOrderClause( 491 const OMPAtomicDefaultMemOrderClause *C) {} 492 493 void OMPClauseProfiler::VisitOMPScheduleClause(const OMPScheduleClause *C) { 494 VistOMPClauseWithPreInit(C); 495 if (auto *S = C->getChunkSize()) 496 Profiler->VisitStmt(S); 497 } 498 499 void OMPClauseProfiler::VisitOMPOrderedClause(const OMPOrderedClause *C) { 500 if (auto *Num = C->getNumForLoops()) 501 Profiler->VisitStmt(Num); 502 } 503 504 void OMPClauseProfiler::VisitOMPNowaitClause(const OMPNowaitClause *) {} 505 506 void OMPClauseProfiler::VisitOMPUntiedClause(const OMPUntiedClause *) {} 507 508 void OMPClauseProfiler::VisitOMPMergeableClause(const OMPMergeableClause *) {} 509 510 void OMPClauseProfiler::VisitOMPReadClause(const OMPReadClause *) {} 511 512 void OMPClauseProfiler::VisitOMPWriteClause(const OMPWriteClause *) {} 513 514 void OMPClauseProfiler::VisitOMPUpdateClause(const OMPUpdateClause *) {} 515 516 void OMPClauseProfiler::VisitOMPCaptureClause(const OMPCaptureClause *) {} 517 518 void OMPClauseProfiler::VisitOMPSeqCstClause(const OMPSeqCstClause *) {} 519 520 void OMPClauseProfiler::VisitOMPThreadsClause(const OMPThreadsClause *) {} 521 522 void OMPClauseProfiler::VisitOMPSIMDClause(const OMPSIMDClause *) {} 523 524 void OMPClauseProfiler::VisitOMPNogroupClause(const OMPNogroupClause *) {} 525 526 template<typename T> 527 void OMPClauseProfiler::VisitOMPClauseList(T *Node) { 528 for (auto *E : Node->varlists()) { 529 if (E) 530 Profiler->VisitStmt(E); 531 } 532 } 533 534 void OMPClauseProfiler::VisitOMPPrivateClause(const OMPPrivateClause *C) { 535 VisitOMPClauseList(C); 536 for (auto *E : C->private_copies()) { 537 if (E) 538 Profiler->VisitStmt(E); 539 } 540 } 541 void 542 OMPClauseProfiler::VisitOMPFirstprivateClause(const OMPFirstprivateClause *C) { 543 VisitOMPClauseList(C); 544 VistOMPClauseWithPreInit(C); 545 for (auto *E : C->private_copies()) { 546 if (E) 547 Profiler->VisitStmt(E); 548 } 549 for (auto *E : C->inits()) { 550 if (E) 551 Profiler->VisitStmt(E); 552 } 553 } 554 void 555 OMPClauseProfiler::VisitOMPLastprivateClause(const OMPLastprivateClause *C) { 556 VisitOMPClauseList(C); 557 VistOMPClauseWithPostUpdate(C); 558 for (auto *E : C->source_exprs()) { 559 if (E) 560 Profiler->VisitStmt(E); 561 } 562 for (auto *E : C->destination_exprs()) { 563 if (E) 564 Profiler->VisitStmt(E); 565 } 566 for (auto *E : C->assignment_ops()) { 567 if (E) 568 Profiler->VisitStmt(E); 569 } 570 } 571 void OMPClauseProfiler::VisitOMPSharedClause(const OMPSharedClause *C) { 572 VisitOMPClauseList(C); 573 } 574 void OMPClauseProfiler::VisitOMPReductionClause( 575 const OMPReductionClause *C) { 576 Profiler->VisitNestedNameSpecifier( 577 C->getQualifierLoc().getNestedNameSpecifier()); 578 Profiler->VisitName(C->getNameInfo().getName()); 579 VisitOMPClauseList(C); 580 VistOMPClauseWithPostUpdate(C); 581 for (auto *E : C->privates()) { 582 if (E) 583 Profiler->VisitStmt(E); 584 } 585 for (auto *E : C->lhs_exprs()) { 586 if (E) 587 Profiler->VisitStmt(E); 588 } 589 for (auto *E : C->rhs_exprs()) { 590 if (E) 591 Profiler->VisitStmt(E); 592 } 593 for (auto *E : C->reduction_ops()) { 594 if (E) 595 Profiler->VisitStmt(E); 596 } 597 } 598 void OMPClauseProfiler::VisitOMPTaskReductionClause( 599 const OMPTaskReductionClause *C) { 600 Profiler->VisitNestedNameSpecifier( 601 C->getQualifierLoc().getNestedNameSpecifier()); 602 Profiler->VisitName(C->getNameInfo().getName()); 603 VisitOMPClauseList(C); 604 VistOMPClauseWithPostUpdate(C); 605 for (auto *E : C->privates()) { 606 if (E) 607 Profiler->VisitStmt(E); 608 } 609 for (auto *E : C->lhs_exprs()) { 610 if (E) 611 Profiler->VisitStmt(E); 612 } 613 for (auto *E : C->rhs_exprs()) { 614 if (E) 615 Profiler->VisitStmt(E); 616 } 617 for (auto *E : C->reduction_ops()) { 618 if (E) 619 Profiler->VisitStmt(E); 620 } 621 } 622 void OMPClauseProfiler::VisitOMPInReductionClause( 623 const OMPInReductionClause *C) { 624 Profiler->VisitNestedNameSpecifier( 625 C->getQualifierLoc().getNestedNameSpecifier()); 626 Profiler->VisitName(C->getNameInfo().getName()); 627 VisitOMPClauseList(C); 628 VistOMPClauseWithPostUpdate(C); 629 for (auto *E : C->privates()) { 630 if (E) 631 Profiler->VisitStmt(E); 632 } 633 for (auto *E : C->lhs_exprs()) { 634 if (E) 635 Profiler->VisitStmt(E); 636 } 637 for (auto *E : C->rhs_exprs()) { 638 if (E) 639 Profiler->VisitStmt(E); 640 } 641 for (auto *E : C->reduction_ops()) { 642 if (E) 643 Profiler->VisitStmt(E); 644 } 645 for (auto *E : C->taskgroup_descriptors()) { 646 if (E) 647 Profiler->VisitStmt(E); 648 } 649 } 650 void OMPClauseProfiler::VisitOMPLinearClause(const OMPLinearClause *C) { 651 VisitOMPClauseList(C); 652 VistOMPClauseWithPostUpdate(C); 653 for (auto *E : C->privates()) { 654 if (E) 655 Profiler->VisitStmt(E); 656 } 657 for (auto *E : C->inits()) { 658 if (E) 659 Profiler->VisitStmt(E); 660 } 661 for (auto *E : C->updates()) { 662 if (E) 663 Profiler->VisitStmt(E); 664 } 665 for (auto *E : C->finals()) { 666 if (E) 667 Profiler->VisitStmt(E); 668 } 669 if (C->getStep()) 670 Profiler->VisitStmt(C->getStep()); 671 if (C->getCalcStep()) 672 Profiler->VisitStmt(C->getCalcStep()); 673 } 674 void OMPClauseProfiler::VisitOMPAlignedClause(const OMPAlignedClause *C) { 675 VisitOMPClauseList(C); 676 if (C->getAlignment()) 677 Profiler->VisitStmt(C->getAlignment()); 678 } 679 void OMPClauseProfiler::VisitOMPCopyinClause(const OMPCopyinClause *C) { 680 VisitOMPClauseList(C); 681 for (auto *E : C->source_exprs()) { 682 if (E) 683 Profiler->VisitStmt(E); 684 } 685 for (auto *E : C->destination_exprs()) { 686 if (E) 687 Profiler->VisitStmt(E); 688 } 689 for (auto *E : C->assignment_ops()) { 690 if (E) 691 Profiler->VisitStmt(E); 692 } 693 } 694 void 695 OMPClauseProfiler::VisitOMPCopyprivateClause(const OMPCopyprivateClause *C) { 696 VisitOMPClauseList(C); 697 for (auto *E : C->source_exprs()) { 698 if (E) 699 Profiler->VisitStmt(E); 700 } 701 for (auto *E : C->destination_exprs()) { 702 if (E) 703 Profiler->VisitStmt(E); 704 } 705 for (auto *E : C->assignment_ops()) { 706 if (E) 707 Profiler->VisitStmt(E); 708 } 709 } 710 void OMPClauseProfiler::VisitOMPFlushClause(const OMPFlushClause *C) { 711 VisitOMPClauseList(C); 712 } 713 void OMPClauseProfiler::VisitOMPDependClause(const OMPDependClause *C) { 714 VisitOMPClauseList(C); 715 } 716 void OMPClauseProfiler::VisitOMPDeviceClause(const OMPDeviceClause *C) { 717 if (C->getDevice()) 718 Profiler->VisitStmt(C->getDevice()); 719 } 720 void OMPClauseProfiler::VisitOMPMapClause(const OMPMapClause *C) { 721 VisitOMPClauseList(C); 722 } 723 void OMPClauseProfiler::VisitOMPAllocateClause(const OMPAllocateClause *C) { 724 if (Expr *Allocator = C->getAllocator()) 725 Profiler->VisitStmt(Allocator); 726 VisitOMPClauseList(C); 727 } 728 void OMPClauseProfiler::VisitOMPNumTeamsClause(const OMPNumTeamsClause *C) { 729 VistOMPClauseWithPreInit(C); 730 if (C->getNumTeams()) 731 Profiler->VisitStmt(C->getNumTeams()); 732 } 733 void OMPClauseProfiler::VisitOMPThreadLimitClause( 734 const OMPThreadLimitClause *C) { 735 VistOMPClauseWithPreInit(C); 736 if (C->getThreadLimit()) 737 Profiler->VisitStmt(C->getThreadLimit()); 738 } 739 void OMPClauseProfiler::VisitOMPPriorityClause(const OMPPriorityClause *C) { 740 VistOMPClauseWithPreInit(C); 741 if (C->getPriority()) 742 Profiler->VisitStmt(C->getPriority()); 743 } 744 void OMPClauseProfiler::VisitOMPGrainsizeClause(const OMPGrainsizeClause *C) { 745 VistOMPClauseWithPreInit(C); 746 if (C->getGrainsize()) 747 Profiler->VisitStmt(C->getGrainsize()); 748 } 749 void OMPClauseProfiler::VisitOMPNumTasksClause(const OMPNumTasksClause *C) { 750 VistOMPClauseWithPreInit(C); 751 if (C->getNumTasks()) 752 Profiler->VisitStmt(C->getNumTasks()); 753 } 754 void OMPClauseProfiler::VisitOMPHintClause(const OMPHintClause *C) { 755 if (C->getHint()) 756 Profiler->VisitStmt(C->getHint()); 757 } 758 void OMPClauseProfiler::VisitOMPToClause(const OMPToClause *C) { 759 VisitOMPClauseList(C); 760 } 761 void OMPClauseProfiler::VisitOMPFromClause(const OMPFromClause *C) { 762 VisitOMPClauseList(C); 763 } 764 void OMPClauseProfiler::VisitOMPUseDevicePtrClause( 765 const OMPUseDevicePtrClause *C) { 766 VisitOMPClauseList(C); 767 } 768 void OMPClauseProfiler::VisitOMPIsDevicePtrClause( 769 const OMPIsDevicePtrClause *C) { 770 VisitOMPClauseList(C); 771 } 772 } 773 774 void 775 StmtProfiler::VisitOMPExecutableDirective(const OMPExecutableDirective *S) { 776 VisitStmt(S); 777 OMPClauseProfiler P(this); 778 ArrayRef<OMPClause *> Clauses = S->clauses(); 779 for (ArrayRef<OMPClause *>::iterator I = Clauses.begin(), E = Clauses.end(); 780 I != E; ++I) 781 if (*I) 782 P.Visit(*I); 783 } 784 785 void StmtProfiler::VisitOMPLoopDirective(const OMPLoopDirective *S) { 786 VisitOMPExecutableDirective(S); 787 } 788 789 void StmtProfiler::VisitOMPParallelDirective(const OMPParallelDirective *S) { 790 VisitOMPExecutableDirective(S); 791 } 792 793 void StmtProfiler::VisitOMPSimdDirective(const OMPSimdDirective *S) { 794 VisitOMPLoopDirective(S); 795 } 796 797 void StmtProfiler::VisitOMPForDirective(const OMPForDirective *S) { 798 VisitOMPLoopDirective(S); 799 } 800 801 void StmtProfiler::VisitOMPForSimdDirective(const OMPForSimdDirective *S) { 802 VisitOMPLoopDirective(S); 803 } 804 805 void StmtProfiler::VisitOMPSectionsDirective(const OMPSectionsDirective *S) { 806 VisitOMPExecutableDirective(S); 807 } 808 809 void StmtProfiler::VisitOMPSectionDirective(const OMPSectionDirective *S) { 810 VisitOMPExecutableDirective(S); 811 } 812 813 void StmtProfiler::VisitOMPSingleDirective(const OMPSingleDirective *S) { 814 VisitOMPExecutableDirective(S); 815 } 816 817 void StmtProfiler::VisitOMPMasterDirective(const OMPMasterDirective *S) { 818 VisitOMPExecutableDirective(S); 819 } 820 821 void StmtProfiler::VisitOMPCriticalDirective(const OMPCriticalDirective *S) { 822 VisitOMPExecutableDirective(S); 823 VisitName(S->getDirectiveName().getName()); 824 } 825 826 void 827 StmtProfiler::VisitOMPParallelForDirective(const OMPParallelForDirective *S) { 828 VisitOMPLoopDirective(S); 829 } 830 831 void StmtProfiler::VisitOMPParallelForSimdDirective( 832 const OMPParallelForSimdDirective *S) { 833 VisitOMPLoopDirective(S); 834 } 835 836 void StmtProfiler::VisitOMPParallelMasterDirective( 837 const OMPParallelMasterDirective *S) { 838 VisitOMPExecutableDirective(S); 839 } 840 841 void StmtProfiler::VisitOMPParallelSectionsDirective( 842 const OMPParallelSectionsDirective *S) { 843 VisitOMPExecutableDirective(S); 844 } 845 846 void StmtProfiler::VisitOMPTaskDirective(const OMPTaskDirective *S) { 847 VisitOMPExecutableDirective(S); 848 } 849 850 void StmtProfiler::VisitOMPTaskyieldDirective(const OMPTaskyieldDirective *S) { 851 VisitOMPExecutableDirective(S); 852 } 853 854 void StmtProfiler::VisitOMPBarrierDirective(const OMPBarrierDirective *S) { 855 VisitOMPExecutableDirective(S); 856 } 857 858 void StmtProfiler::VisitOMPTaskwaitDirective(const OMPTaskwaitDirective *S) { 859 VisitOMPExecutableDirective(S); 860 } 861 862 void StmtProfiler::VisitOMPTaskgroupDirective(const OMPTaskgroupDirective *S) { 863 VisitOMPExecutableDirective(S); 864 if (const Expr *E = S->getReductionRef()) 865 VisitStmt(E); 866 } 867 868 void StmtProfiler::VisitOMPFlushDirective(const OMPFlushDirective *S) { 869 VisitOMPExecutableDirective(S); 870 } 871 872 void StmtProfiler::VisitOMPOrderedDirective(const OMPOrderedDirective *S) { 873 VisitOMPExecutableDirective(S); 874 } 875 876 void StmtProfiler::VisitOMPAtomicDirective(const OMPAtomicDirective *S) { 877 VisitOMPExecutableDirective(S); 878 } 879 880 void StmtProfiler::VisitOMPTargetDirective(const OMPTargetDirective *S) { 881 VisitOMPExecutableDirective(S); 882 } 883 884 void StmtProfiler::VisitOMPTargetDataDirective(const OMPTargetDataDirective *S) { 885 VisitOMPExecutableDirective(S); 886 } 887 888 void StmtProfiler::VisitOMPTargetEnterDataDirective( 889 const OMPTargetEnterDataDirective *S) { 890 VisitOMPExecutableDirective(S); 891 } 892 893 void StmtProfiler::VisitOMPTargetExitDataDirective( 894 const OMPTargetExitDataDirective *S) { 895 VisitOMPExecutableDirective(S); 896 } 897 898 void StmtProfiler::VisitOMPTargetParallelDirective( 899 const OMPTargetParallelDirective *S) { 900 VisitOMPExecutableDirective(S); 901 } 902 903 void StmtProfiler::VisitOMPTargetParallelForDirective( 904 const OMPTargetParallelForDirective *S) { 905 VisitOMPExecutableDirective(S); 906 } 907 908 void StmtProfiler::VisitOMPTeamsDirective(const OMPTeamsDirective *S) { 909 VisitOMPExecutableDirective(S); 910 } 911 912 void StmtProfiler::VisitOMPCancellationPointDirective( 913 const OMPCancellationPointDirective *S) { 914 VisitOMPExecutableDirective(S); 915 } 916 917 void StmtProfiler::VisitOMPCancelDirective(const OMPCancelDirective *S) { 918 VisitOMPExecutableDirective(S); 919 } 920 921 void StmtProfiler::VisitOMPTaskLoopDirective(const OMPTaskLoopDirective *S) { 922 VisitOMPLoopDirective(S); 923 } 924 925 void StmtProfiler::VisitOMPTaskLoopSimdDirective( 926 const OMPTaskLoopSimdDirective *S) { 927 VisitOMPLoopDirective(S); 928 } 929 930 void StmtProfiler::VisitOMPMasterTaskLoopDirective( 931 const OMPMasterTaskLoopDirective *S) { 932 VisitOMPLoopDirective(S); 933 } 934 935 void StmtProfiler::VisitOMPMasterTaskLoopSimdDirective( 936 const OMPMasterTaskLoopSimdDirective *S) { 937 VisitOMPLoopDirective(S); 938 } 939 940 void StmtProfiler::VisitOMPParallelMasterTaskLoopDirective( 941 const OMPParallelMasterTaskLoopDirective *S) { 942 VisitOMPLoopDirective(S); 943 } 944 945 void StmtProfiler::VisitOMPParallelMasterTaskLoopSimdDirective( 946 const OMPParallelMasterTaskLoopSimdDirective *S) { 947 VisitOMPLoopDirective(S); 948 } 949 950 void StmtProfiler::VisitOMPDistributeDirective( 951 const OMPDistributeDirective *S) { 952 VisitOMPLoopDirective(S); 953 } 954 955 void OMPClauseProfiler::VisitOMPDistScheduleClause( 956 const OMPDistScheduleClause *C) { 957 VistOMPClauseWithPreInit(C); 958 if (auto *S = C->getChunkSize()) 959 Profiler->VisitStmt(S); 960 } 961 962 void OMPClauseProfiler::VisitOMPDefaultmapClause(const OMPDefaultmapClause *) {} 963 964 void StmtProfiler::VisitOMPTargetUpdateDirective( 965 const OMPTargetUpdateDirective *S) { 966 VisitOMPExecutableDirective(S); 967 } 968 969 void StmtProfiler::VisitOMPDistributeParallelForDirective( 970 const OMPDistributeParallelForDirective *S) { 971 VisitOMPLoopDirective(S); 972 } 973 974 void StmtProfiler::VisitOMPDistributeParallelForSimdDirective( 975 const OMPDistributeParallelForSimdDirective *S) { 976 VisitOMPLoopDirective(S); 977 } 978 979 void StmtProfiler::VisitOMPDistributeSimdDirective( 980 const OMPDistributeSimdDirective *S) { 981 VisitOMPLoopDirective(S); 982 } 983 984 void StmtProfiler::VisitOMPTargetParallelForSimdDirective( 985 const OMPTargetParallelForSimdDirective *S) { 986 VisitOMPLoopDirective(S); 987 } 988 989 void StmtProfiler::VisitOMPTargetSimdDirective( 990 const OMPTargetSimdDirective *S) { 991 VisitOMPLoopDirective(S); 992 } 993 994 void StmtProfiler::VisitOMPTeamsDistributeDirective( 995 const OMPTeamsDistributeDirective *S) { 996 VisitOMPLoopDirective(S); 997 } 998 999 void StmtProfiler::VisitOMPTeamsDistributeSimdDirective( 1000 const OMPTeamsDistributeSimdDirective *S) { 1001 VisitOMPLoopDirective(S); 1002 } 1003 1004 void StmtProfiler::VisitOMPTeamsDistributeParallelForSimdDirective( 1005 const OMPTeamsDistributeParallelForSimdDirective *S) { 1006 VisitOMPLoopDirective(S); 1007 } 1008 1009 void StmtProfiler::VisitOMPTeamsDistributeParallelForDirective( 1010 const OMPTeamsDistributeParallelForDirective *S) { 1011 VisitOMPLoopDirective(S); 1012 } 1013 1014 void StmtProfiler::VisitOMPTargetTeamsDirective( 1015 const OMPTargetTeamsDirective *S) { 1016 VisitOMPExecutableDirective(S); 1017 } 1018 1019 void StmtProfiler::VisitOMPTargetTeamsDistributeDirective( 1020 const OMPTargetTeamsDistributeDirective *S) { 1021 VisitOMPLoopDirective(S); 1022 } 1023 1024 void StmtProfiler::VisitOMPTargetTeamsDistributeParallelForDirective( 1025 const OMPTargetTeamsDistributeParallelForDirective *S) { 1026 VisitOMPLoopDirective(S); 1027 } 1028 1029 void StmtProfiler::VisitOMPTargetTeamsDistributeParallelForSimdDirective( 1030 const OMPTargetTeamsDistributeParallelForSimdDirective *S) { 1031 VisitOMPLoopDirective(S); 1032 } 1033 1034 void StmtProfiler::VisitOMPTargetTeamsDistributeSimdDirective( 1035 const OMPTargetTeamsDistributeSimdDirective *S) { 1036 VisitOMPLoopDirective(S); 1037 } 1038 1039 void StmtProfiler::VisitExpr(const Expr *S) { 1040 VisitStmt(S); 1041 } 1042 1043 void StmtProfiler::VisitConstantExpr(const ConstantExpr *S) { 1044 VisitExpr(S); 1045 } 1046 1047 void StmtProfiler::VisitDeclRefExpr(const DeclRefExpr *S) { 1048 VisitExpr(S); 1049 if (!Canonical) 1050 VisitNestedNameSpecifier(S->getQualifier()); 1051 VisitDecl(S->getDecl()); 1052 if (!Canonical) { 1053 ID.AddBoolean(S->hasExplicitTemplateArgs()); 1054 if (S->hasExplicitTemplateArgs()) 1055 VisitTemplateArguments(S->getTemplateArgs(), S->getNumTemplateArgs()); 1056 } 1057 } 1058 1059 void StmtProfiler::VisitPredefinedExpr(const PredefinedExpr *S) { 1060 VisitExpr(S); 1061 ID.AddInteger(S->getIdentKind()); 1062 } 1063 1064 void StmtProfiler::VisitIntegerLiteral(const IntegerLiteral *S) { 1065 VisitExpr(S); 1066 S->getValue().Profile(ID); 1067 ID.AddInteger(S->getType()->castAs<BuiltinType>()->getKind()); 1068 } 1069 1070 void StmtProfiler::VisitFixedPointLiteral(const FixedPointLiteral *S) { 1071 VisitExpr(S); 1072 S->getValue().Profile(ID); 1073 ID.AddInteger(S->getType()->castAs<BuiltinType>()->getKind()); 1074 } 1075 1076 void StmtProfiler::VisitCharacterLiteral(const CharacterLiteral *S) { 1077 VisitExpr(S); 1078 ID.AddInteger(S->getKind()); 1079 ID.AddInteger(S->getValue()); 1080 } 1081 1082 void StmtProfiler::VisitFloatingLiteral(const FloatingLiteral *S) { 1083 VisitExpr(S); 1084 S->getValue().Profile(ID); 1085 ID.AddBoolean(S->isExact()); 1086 ID.AddInteger(S->getType()->castAs<BuiltinType>()->getKind()); 1087 } 1088 1089 void StmtProfiler::VisitImaginaryLiteral(const ImaginaryLiteral *S) { 1090 VisitExpr(S); 1091 } 1092 1093 void StmtProfiler::VisitStringLiteral(const StringLiteral *S) { 1094 VisitExpr(S); 1095 ID.AddString(S->getBytes()); 1096 ID.AddInteger(S->getKind()); 1097 } 1098 1099 void StmtProfiler::VisitParenExpr(const ParenExpr *S) { 1100 VisitExpr(S); 1101 } 1102 1103 void StmtProfiler::VisitParenListExpr(const ParenListExpr *S) { 1104 VisitExpr(S); 1105 } 1106 1107 void StmtProfiler::VisitUnaryOperator(const UnaryOperator *S) { 1108 VisitExpr(S); 1109 ID.AddInteger(S->getOpcode()); 1110 } 1111 1112 void StmtProfiler::VisitOffsetOfExpr(const OffsetOfExpr *S) { 1113 VisitType(S->getTypeSourceInfo()->getType()); 1114 unsigned n = S->getNumComponents(); 1115 for (unsigned i = 0; i < n; ++i) { 1116 const OffsetOfNode &ON = S->getComponent(i); 1117 ID.AddInteger(ON.getKind()); 1118 switch (ON.getKind()) { 1119 case OffsetOfNode::Array: 1120 // Expressions handled below. 1121 break; 1122 1123 case OffsetOfNode::Field: 1124 VisitDecl(ON.getField()); 1125 break; 1126 1127 case OffsetOfNode::Identifier: 1128 VisitIdentifierInfo(ON.getFieldName()); 1129 break; 1130 1131 case OffsetOfNode::Base: 1132 // These nodes are implicit, and therefore don't need profiling. 1133 break; 1134 } 1135 } 1136 1137 VisitExpr(S); 1138 } 1139 1140 void 1141 StmtProfiler::VisitUnaryExprOrTypeTraitExpr(const UnaryExprOrTypeTraitExpr *S) { 1142 VisitExpr(S); 1143 ID.AddInteger(S->getKind()); 1144 if (S->isArgumentType()) 1145 VisitType(S->getArgumentType()); 1146 } 1147 1148 void StmtProfiler::VisitArraySubscriptExpr(const ArraySubscriptExpr *S) { 1149 VisitExpr(S); 1150 } 1151 1152 void StmtProfiler::VisitOMPArraySectionExpr(const OMPArraySectionExpr *S) { 1153 VisitExpr(S); 1154 } 1155 1156 void StmtProfiler::VisitCallExpr(const CallExpr *S) { 1157 VisitExpr(S); 1158 } 1159 1160 void StmtProfiler::VisitMemberExpr(const MemberExpr *S) { 1161 VisitExpr(S); 1162 VisitDecl(S->getMemberDecl()); 1163 if (!Canonical) 1164 VisitNestedNameSpecifier(S->getQualifier()); 1165 ID.AddBoolean(S->isArrow()); 1166 } 1167 1168 void StmtProfiler::VisitCompoundLiteralExpr(const CompoundLiteralExpr *S) { 1169 VisitExpr(S); 1170 ID.AddBoolean(S->isFileScope()); 1171 } 1172 1173 void StmtProfiler::VisitCastExpr(const CastExpr *S) { 1174 VisitExpr(S); 1175 } 1176 1177 void StmtProfiler::VisitImplicitCastExpr(const ImplicitCastExpr *S) { 1178 VisitCastExpr(S); 1179 ID.AddInteger(S->getValueKind()); 1180 } 1181 1182 void StmtProfiler::VisitExplicitCastExpr(const ExplicitCastExpr *S) { 1183 VisitCastExpr(S); 1184 VisitType(S->getTypeAsWritten()); 1185 } 1186 1187 void StmtProfiler::VisitCStyleCastExpr(const CStyleCastExpr *S) { 1188 VisitExplicitCastExpr(S); 1189 } 1190 1191 void StmtProfiler::VisitBinaryOperator(const BinaryOperator *S) { 1192 VisitExpr(S); 1193 ID.AddInteger(S->getOpcode()); 1194 } 1195 1196 void 1197 StmtProfiler::VisitCompoundAssignOperator(const CompoundAssignOperator *S) { 1198 VisitBinaryOperator(S); 1199 } 1200 1201 void StmtProfiler::VisitConditionalOperator(const ConditionalOperator *S) { 1202 VisitExpr(S); 1203 } 1204 1205 void StmtProfiler::VisitBinaryConditionalOperator( 1206 const BinaryConditionalOperator *S) { 1207 VisitExpr(S); 1208 } 1209 1210 void StmtProfiler::VisitAddrLabelExpr(const AddrLabelExpr *S) { 1211 VisitExpr(S); 1212 VisitDecl(S->getLabel()); 1213 } 1214 1215 void StmtProfiler::VisitStmtExpr(const StmtExpr *S) { 1216 VisitExpr(S); 1217 } 1218 1219 void StmtProfiler::VisitShuffleVectorExpr(const ShuffleVectorExpr *S) { 1220 VisitExpr(S); 1221 } 1222 1223 void StmtProfiler::VisitConvertVectorExpr(const ConvertVectorExpr *S) { 1224 VisitExpr(S); 1225 } 1226 1227 void StmtProfiler::VisitChooseExpr(const ChooseExpr *S) { 1228 VisitExpr(S); 1229 } 1230 1231 void StmtProfiler::VisitGNUNullExpr(const GNUNullExpr *S) { 1232 VisitExpr(S); 1233 } 1234 1235 void StmtProfiler::VisitVAArgExpr(const VAArgExpr *S) { 1236 VisitExpr(S); 1237 } 1238 1239 void StmtProfiler::VisitInitListExpr(const InitListExpr *S) { 1240 if (S->getSyntacticForm()) { 1241 VisitInitListExpr(S->getSyntacticForm()); 1242 return; 1243 } 1244 1245 VisitExpr(S); 1246 } 1247 1248 void StmtProfiler::VisitDesignatedInitExpr(const DesignatedInitExpr *S) { 1249 VisitExpr(S); 1250 ID.AddBoolean(S->usesGNUSyntax()); 1251 for (const DesignatedInitExpr::Designator &D : S->designators()) { 1252 if (D.isFieldDesignator()) { 1253 ID.AddInteger(0); 1254 VisitName(D.getFieldName()); 1255 continue; 1256 } 1257 1258 if (D.isArrayDesignator()) { 1259 ID.AddInteger(1); 1260 } else { 1261 assert(D.isArrayRangeDesignator()); 1262 ID.AddInteger(2); 1263 } 1264 ID.AddInteger(D.getFirstExprIndex()); 1265 } 1266 } 1267 1268 // Seems that if VisitInitListExpr() only works on the syntactic form of an 1269 // InitListExpr, then a DesignatedInitUpdateExpr is not encountered. 1270 void StmtProfiler::VisitDesignatedInitUpdateExpr( 1271 const DesignatedInitUpdateExpr *S) { 1272 llvm_unreachable("Unexpected DesignatedInitUpdateExpr in syntactic form of " 1273 "initializer"); 1274 } 1275 1276 void StmtProfiler::VisitArrayInitLoopExpr(const ArrayInitLoopExpr *S) { 1277 VisitExpr(S); 1278 } 1279 1280 void StmtProfiler::VisitArrayInitIndexExpr(const ArrayInitIndexExpr *S) { 1281 VisitExpr(S); 1282 } 1283 1284 void StmtProfiler::VisitNoInitExpr(const NoInitExpr *S) { 1285 llvm_unreachable("Unexpected NoInitExpr in syntactic form of initializer"); 1286 } 1287 1288 void StmtProfiler::VisitImplicitValueInitExpr(const ImplicitValueInitExpr *S) { 1289 VisitExpr(S); 1290 } 1291 1292 void StmtProfiler::VisitExtVectorElementExpr(const ExtVectorElementExpr *S) { 1293 VisitExpr(S); 1294 VisitName(&S->getAccessor()); 1295 } 1296 1297 void StmtProfiler::VisitBlockExpr(const BlockExpr *S) { 1298 VisitExpr(S); 1299 VisitDecl(S->getBlockDecl()); 1300 } 1301 1302 void StmtProfiler::VisitGenericSelectionExpr(const GenericSelectionExpr *S) { 1303 VisitExpr(S); 1304 for (const GenericSelectionExpr::ConstAssociation Assoc : 1305 S->associations()) { 1306 QualType T = Assoc.getType(); 1307 if (T.isNull()) 1308 ID.AddPointer(nullptr); 1309 else 1310 VisitType(T); 1311 VisitExpr(Assoc.getAssociationExpr()); 1312 } 1313 } 1314 1315 void StmtProfiler::VisitPseudoObjectExpr(const PseudoObjectExpr *S) { 1316 VisitExpr(S); 1317 for (PseudoObjectExpr::const_semantics_iterator 1318 i = S->semantics_begin(), e = S->semantics_end(); i != e; ++i) 1319 // Normally, we would not profile the source expressions of OVEs. 1320 if (const OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(*i)) 1321 Visit(OVE->getSourceExpr()); 1322 } 1323 1324 void StmtProfiler::VisitAtomicExpr(const AtomicExpr *S) { 1325 VisitExpr(S); 1326 ID.AddInteger(S->getOp()); 1327 } 1328 1329 void StmtProfiler::VisitConceptSpecializationExpr( 1330 const ConceptSpecializationExpr *S) { 1331 VisitExpr(S); 1332 VisitDecl(S->getFoundDecl()); 1333 VisitTemplateArguments(S->getTemplateArgsAsWritten()->getTemplateArgs(), 1334 S->getTemplateArgsAsWritten()->NumTemplateArgs); 1335 } 1336 1337 static Stmt::StmtClass DecodeOperatorCall(const CXXOperatorCallExpr *S, 1338 UnaryOperatorKind &UnaryOp, 1339 BinaryOperatorKind &BinaryOp) { 1340 switch (S->getOperator()) { 1341 case OO_None: 1342 case OO_New: 1343 case OO_Delete: 1344 case OO_Array_New: 1345 case OO_Array_Delete: 1346 case OO_Arrow: 1347 case OO_Call: 1348 case OO_Conditional: 1349 case NUM_OVERLOADED_OPERATORS: 1350 llvm_unreachable("Invalid operator call kind"); 1351 1352 case OO_Plus: 1353 if (S->getNumArgs() == 1) { 1354 UnaryOp = UO_Plus; 1355 return Stmt::UnaryOperatorClass; 1356 } 1357 1358 BinaryOp = BO_Add; 1359 return Stmt::BinaryOperatorClass; 1360 1361 case OO_Minus: 1362 if (S->getNumArgs() == 1) { 1363 UnaryOp = UO_Minus; 1364 return Stmt::UnaryOperatorClass; 1365 } 1366 1367 BinaryOp = BO_Sub; 1368 return Stmt::BinaryOperatorClass; 1369 1370 case OO_Star: 1371 if (S->getNumArgs() == 1) { 1372 UnaryOp = UO_Deref; 1373 return Stmt::UnaryOperatorClass; 1374 } 1375 1376 BinaryOp = BO_Mul; 1377 return Stmt::BinaryOperatorClass; 1378 1379 case OO_Slash: 1380 BinaryOp = BO_Div; 1381 return Stmt::BinaryOperatorClass; 1382 1383 case OO_Percent: 1384 BinaryOp = BO_Rem; 1385 return Stmt::BinaryOperatorClass; 1386 1387 case OO_Caret: 1388 BinaryOp = BO_Xor; 1389 return Stmt::BinaryOperatorClass; 1390 1391 case OO_Amp: 1392 if (S->getNumArgs() == 1) { 1393 UnaryOp = UO_AddrOf; 1394 return Stmt::UnaryOperatorClass; 1395 } 1396 1397 BinaryOp = BO_And; 1398 return Stmt::BinaryOperatorClass; 1399 1400 case OO_Pipe: 1401 BinaryOp = BO_Or; 1402 return Stmt::BinaryOperatorClass; 1403 1404 case OO_Tilde: 1405 UnaryOp = UO_Not; 1406 return Stmt::UnaryOperatorClass; 1407 1408 case OO_Exclaim: 1409 UnaryOp = UO_LNot; 1410 return Stmt::UnaryOperatorClass; 1411 1412 case OO_Equal: 1413 BinaryOp = BO_Assign; 1414 return Stmt::BinaryOperatorClass; 1415 1416 case OO_Less: 1417 BinaryOp = BO_LT; 1418 return Stmt::BinaryOperatorClass; 1419 1420 case OO_Greater: 1421 BinaryOp = BO_GT; 1422 return Stmt::BinaryOperatorClass; 1423 1424 case OO_PlusEqual: 1425 BinaryOp = BO_AddAssign; 1426 return Stmt::CompoundAssignOperatorClass; 1427 1428 case OO_MinusEqual: 1429 BinaryOp = BO_SubAssign; 1430 return Stmt::CompoundAssignOperatorClass; 1431 1432 case OO_StarEqual: 1433 BinaryOp = BO_MulAssign; 1434 return Stmt::CompoundAssignOperatorClass; 1435 1436 case OO_SlashEqual: 1437 BinaryOp = BO_DivAssign; 1438 return Stmt::CompoundAssignOperatorClass; 1439 1440 case OO_PercentEqual: 1441 BinaryOp = BO_RemAssign; 1442 return Stmt::CompoundAssignOperatorClass; 1443 1444 case OO_CaretEqual: 1445 BinaryOp = BO_XorAssign; 1446 return Stmt::CompoundAssignOperatorClass; 1447 1448 case OO_AmpEqual: 1449 BinaryOp = BO_AndAssign; 1450 return Stmt::CompoundAssignOperatorClass; 1451 1452 case OO_PipeEqual: 1453 BinaryOp = BO_OrAssign; 1454 return Stmt::CompoundAssignOperatorClass; 1455 1456 case OO_LessLess: 1457 BinaryOp = BO_Shl; 1458 return Stmt::BinaryOperatorClass; 1459 1460 case OO_GreaterGreater: 1461 BinaryOp = BO_Shr; 1462 return Stmt::BinaryOperatorClass; 1463 1464 case OO_LessLessEqual: 1465 BinaryOp = BO_ShlAssign; 1466 return Stmt::CompoundAssignOperatorClass; 1467 1468 case OO_GreaterGreaterEqual: 1469 BinaryOp = BO_ShrAssign; 1470 return Stmt::CompoundAssignOperatorClass; 1471 1472 case OO_EqualEqual: 1473 BinaryOp = BO_EQ; 1474 return Stmt::BinaryOperatorClass; 1475 1476 case OO_ExclaimEqual: 1477 BinaryOp = BO_NE; 1478 return Stmt::BinaryOperatorClass; 1479 1480 case OO_LessEqual: 1481 BinaryOp = BO_LE; 1482 return Stmt::BinaryOperatorClass; 1483 1484 case OO_GreaterEqual: 1485 BinaryOp = BO_GE; 1486 return Stmt::BinaryOperatorClass; 1487 1488 case OO_Spaceship: 1489 // FIXME: Update this once we support <=> expressions. 1490 llvm_unreachable("<=> expressions not supported yet"); 1491 1492 case OO_AmpAmp: 1493 BinaryOp = BO_LAnd; 1494 return Stmt::BinaryOperatorClass; 1495 1496 case OO_PipePipe: 1497 BinaryOp = BO_LOr; 1498 return Stmt::BinaryOperatorClass; 1499 1500 case OO_PlusPlus: 1501 UnaryOp = S->getNumArgs() == 1? UO_PreInc 1502 : UO_PostInc; 1503 return Stmt::UnaryOperatorClass; 1504 1505 case OO_MinusMinus: 1506 UnaryOp = S->getNumArgs() == 1? UO_PreDec 1507 : UO_PostDec; 1508 return Stmt::UnaryOperatorClass; 1509 1510 case OO_Comma: 1511 BinaryOp = BO_Comma; 1512 return Stmt::BinaryOperatorClass; 1513 1514 case OO_ArrowStar: 1515 BinaryOp = BO_PtrMemI; 1516 return Stmt::BinaryOperatorClass; 1517 1518 case OO_Subscript: 1519 return Stmt::ArraySubscriptExprClass; 1520 1521 case OO_Coawait: 1522 UnaryOp = UO_Coawait; 1523 return Stmt::UnaryOperatorClass; 1524 } 1525 1526 llvm_unreachable("Invalid overloaded operator expression"); 1527 } 1528 1529 #if defined(_MSC_VER) && !defined(__clang__) 1530 #if _MSC_VER == 1911 1531 // Work around https://developercommunity.visualstudio.com/content/problem/84002/clang-cl-when-built-with-vc-2017-crashes-cause-vc.html 1532 // MSVC 2017 update 3 miscompiles this function, and a clang built with it 1533 // will crash in stage 2 of a bootstrap build. 1534 #pragma optimize("", off) 1535 #endif 1536 #endif 1537 1538 void StmtProfiler::VisitCXXOperatorCallExpr(const CXXOperatorCallExpr *S) { 1539 if (S->isTypeDependent()) { 1540 // Type-dependent operator calls are profiled like their underlying 1541 // syntactic operator. 1542 // 1543 // An operator call to operator-> is always implicit, so just skip it. The 1544 // enclosing MemberExpr will profile the actual member access. 1545 if (S->getOperator() == OO_Arrow) 1546 return Visit(S->getArg(0)); 1547 1548 UnaryOperatorKind UnaryOp = UO_Extension; 1549 BinaryOperatorKind BinaryOp = BO_Comma; 1550 Stmt::StmtClass SC = DecodeOperatorCall(S, UnaryOp, BinaryOp); 1551 1552 ID.AddInteger(SC); 1553 for (unsigned I = 0, N = S->getNumArgs(); I != N; ++I) 1554 Visit(S->getArg(I)); 1555 if (SC == Stmt::UnaryOperatorClass) 1556 ID.AddInteger(UnaryOp); 1557 else if (SC == Stmt::BinaryOperatorClass || 1558 SC == Stmt::CompoundAssignOperatorClass) 1559 ID.AddInteger(BinaryOp); 1560 else 1561 assert(SC == Stmt::ArraySubscriptExprClass); 1562 1563 return; 1564 } 1565 1566 VisitCallExpr(S); 1567 ID.AddInteger(S->getOperator()); 1568 } 1569 1570 void StmtProfiler::VisitCXXRewrittenBinaryOperator( 1571 const CXXRewrittenBinaryOperator *S) { 1572 // If a rewritten operator were ever to be type-dependent, we should profile 1573 // it following its syntactic operator. 1574 assert(!S->isTypeDependent() && 1575 "resolved rewritten operator should never be type-dependent"); 1576 ID.AddBoolean(S->isReversed()); 1577 VisitExpr(S->getSemanticForm()); 1578 } 1579 1580 #if defined(_MSC_VER) && !defined(__clang__) 1581 #if _MSC_VER == 1911 1582 #pragma optimize("", on) 1583 #endif 1584 #endif 1585 1586 void StmtProfiler::VisitCXXMemberCallExpr(const CXXMemberCallExpr *S) { 1587 VisitCallExpr(S); 1588 } 1589 1590 void StmtProfiler::VisitCUDAKernelCallExpr(const CUDAKernelCallExpr *S) { 1591 VisitCallExpr(S); 1592 } 1593 1594 void StmtProfiler::VisitAsTypeExpr(const AsTypeExpr *S) { 1595 VisitExpr(S); 1596 } 1597 1598 void StmtProfiler::VisitCXXNamedCastExpr(const CXXNamedCastExpr *S) { 1599 VisitExplicitCastExpr(S); 1600 } 1601 1602 void StmtProfiler::VisitCXXStaticCastExpr(const CXXStaticCastExpr *S) { 1603 VisitCXXNamedCastExpr(S); 1604 } 1605 1606 void StmtProfiler::VisitCXXDynamicCastExpr(const CXXDynamicCastExpr *S) { 1607 VisitCXXNamedCastExpr(S); 1608 } 1609 1610 void 1611 StmtProfiler::VisitCXXReinterpretCastExpr(const CXXReinterpretCastExpr *S) { 1612 VisitCXXNamedCastExpr(S); 1613 } 1614 1615 void StmtProfiler::VisitCXXConstCastExpr(const CXXConstCastExpr *S) { 1616 VisitCXXNamedCastExpr(S); 1617 } 1618 1619 void StmtProfiler::VisitBuiltinBitCastExpr(const BuiltinBitCastExpr *S) { 1620 VisitExpr(S); 1621 VisitType(S->getTypeInfoAsWritten()->getType()); 1622 } 1623 1624 void StmtProfiler::VisitUserDefinedLiteral(const UserDefinedLiteral *S) { 1625 VisitCallExpr(S); 1626 } 1627 1628 void StmtProfiler::VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *S) { 1629 VisitExpr(S); 1630 ID.AddBoolean(S->getValue()); 1631 } 1632 1633 void StmtProfiler::VisitCXXNullPtrLiteralExpr(const CXXNullPtrLiteralExpr *S) { 1634 VisitExpr(S); 1635 } 1636 1637 void StmtProfiler::VisitCXXStdInitializerListExpr( 1638 const CXXStdInitializerListExpr *S) { 1639 VisitExpr(S); 1640 } 1641 1642 void StmtProfiler::VisitCXXTypeidExpr(const CXXTypeidExpr *S) { 1643 VisitExpr(S); 1644 if (S->isTypeOperand()) 1645 VisitType(S->getTypeOperandSourceInfo()->getType()); 1646 } 1647 1648 void StmtProfiler::VisitCXXUuidofExpr(const CXXUuidofExpr *S) { 1649 VisitExpr(S); 1650 if (S->isTypeOperand()) 1651 VisitType(S->getTypeOperandSourceInfo()->getType()); 1652 } 1653 1654 void StmtProfiler::VisitMSPropertyRefExpr(const MSPropertyRefExpr *S) { 1655 VisitExpr(S); 1656 VisitDecl(S->getPropertyDecl()); 1657 } 1658 1659 void StmtProfiler::VisitMSPropertySubscriptExpr( 1660 const MSPropertySubscriptExpr *S) { 1661 VisitExpr(S); 1662 } 1663 1664 void StmtProfiler::VisitCXXThisExpr(const CXXThisExpr *S) { 1665 VisitExpr(S); 1666 ID.AddBoolean(S->isImplicit()); 1667 } 1668 1669 void StmtProfiler::VisitCXXThrowExpr(const CXXThrowExpr *S) { 1670 VisitExpr(S); 1671 } 1672 1673 void StmtProfiler::VisitCXXDefaultArgExpr(const CXXDefaultArgExpr *S) { 1674 VisitExpr(S); 1675 VisitDecl(S->getParam()); 1676 } 1677 1678 void StmtProfiler::VisitCXXDefaultInitExpr(const CXXDefaultInitExpr *S) { 1679 VisitExpr(S); 1680 VisitDecl(S->getField()); 1681 } 1682 1683 void StmtProfiler::VisitCXXBindTemporaryExpr(const CXXBindTemporaryExpr *S) { 1684 VisitExpr(S); 1685 VisitDecl( 1686 const_cast<CXXDestructorDecl *>(S->getTemporary()->getDestructor())); 1687 } 1688 1689 void StmtProfiler::VisitCXXConstructExpr(const CXXConstructExpr *S) { 1690 VisitExpr(S); 1691 VisitDecl(S->getConstructor()); 1692 ID.AddBoolean(S->isElidable()); 1693 } 1694 1695 void StmtProfiler::VisitCXXInheritedCtorInitExpr( 1696 const CXXInheritedCtorInitExpr *S) { 1697 VisitExpr(S); 1698 VisitDecl(S->getConstructor()); 1699 } 1700 1701 void StmtProfiler::VisitCXXFunctionalCastExpr(const CXXFunctionalCastExpr *S) { 1702 VisitExplicitCastExpr(S); 1703 } 1704 1705 void 1706 StmtProfiler::VisitCXXTemporaryObjectExpr(const CXXTemporaryObjectExpr *S) { 1707 VisitCXXConstructExpr(S); 1708 } 1709 1710 void 1711 StmtProfiler::VisitLambdaExpr(const LambdaExpr *S) { 1712 VisitExpr(S); 1713 for (LambdaExpr::capture_iterator C = S->explicit_capture_begin(), 1714 CEnd = S->explicit_capture_end(); 1715 C != CEnd; ++C) { 1716 if (C->capturesVLAType()) 1717 continue; 1718 1719 ID.AddInteger(C->getCaptureKind()); 1720 switch (C->getCaptureKind()) { 1721 case LCK_StarThis: 1722 case LCK_This: 1723 break; 1724 case LCK_ByRef: 1725 case LCK_ByCopy: 1726 VisitDecl(C->getCapturedVar()); 1727 ID.AddBoolean(C->isPackExpansion()); 1728 break; 1729 case LCK_VLAType: 1730 llvm_unreachable("VLA type in explicit captures."); 1731 } 1732 } 1733 // Note: If we actually needed to be able to match lambda 1734 // expressions, we would have to consider parameters and return type 1735 // here, among other things. 1736 VisitStmt(S->getBody()); 1737 } 1738 1739 void 1740 StmtProfiler::VisitCXXScalarValueInitExpr(const CXXScalarValueInitExpr *S) { 1741 VisitExpr(S); 1742 } 1743 1744 void StmtProfiler::VisitCXXDeleteExpr(const CXXDeleteExpr *S) { 1745 VisitExpr(S); 1746 ID.AddBoolean(S->isGlobalDelete()); 1747 ID.AddBoolean(S->isArrayForm()); 1748 VisitDecl(S->getOperatorDelete()); 1749 } 1750 1751 void StmtProfiler::VisitCXXNewExpr(const CXXNewExpr *S) { 1752 VisitExpr(S); 1753 VisitType(S->getAllocatedType()); 1754 VisitDecl(S->getOperatorNew()); 1755 VisitDecl(S->getOperatorDelete()); 1756 ID.AddBoolean(S->isArray()); 1757 ID.AddInteger(S->getNumPlacementArgs()); 1758 ID.AddBoolean(S->isGlobalNew()); 1759 ID.AddBoolean(S->isParenTypeId()); 1760 ID.AddInteger(S->getInitializationStyle()); 1761 } 1762 1763 void 1764 StmtProfiler::VisitCXXPseudoDestructorExpr(const CXXPseudoDestructorExpr *S) { 1765 VisitExpr(S); 1766 ID.AddBoolean(S->isArrow()); 1767 VisitNestedNameSpecifier(S->getQualifier()); 1768 ID.AddBoolean(S->getScopeTypeInfo() != nullptr); 1769 if (S->getScopeTypeInfo()) 1770 VisitType(S->getScopeTypeInfo()->getType()); 1771 ID.AddBoolean(S->getDestroyedTypeInfo() != nullptr); 1772 if (S->getDestroyedTypeInfo()) 1773 VisitType(S->getDestroyedType()); 1774 else 1775 VisitIdentifierInfo(S->getDestroyedTypeIdentifier()); 1776 } 1777 1778 void StmtProfiler::VisitOverloadExpr(const OverloadExpr *S) { 1779 VisitExpr(S); 1780 VisitNestedNameSpecifier(S->getQualifier()); 1781 VisitName(S->getName(), /*TreatAsDecl*/ true); 1782 ID.AddBoolean(S->hasExplicitTemplateArgs()); 1783 if (S->hasExplicitTemplateArgs()) 1784 VisitTemplateArguments(S->getTemplateArgs(), S->getNumTemplateArgs()); 1785 } 1786 1787 void 1788 StmtProfiler::VisitUnresolvedLookupExpr(const UnresolvedLookupExpr *S) { 1789 VisitOverloadExpr(S); 1790 } 1791 1792 void StmtProfiler::VisitTypeTraitExpr(const TypeTraitExpr *S) { 1793 VisitExpr(S); 1794 ID.AddInteger(S->getTrait()); 1795 ID.AddInteger(S->getNumArgs()); 1796 for (unsigned I = 0, N = S->getNumArgs(); I != N; ++I) 1797 VisitType(S->getArg(I)->getType()); 1798 } 1799 1800 void StmtProfiler::VisitArrayTypeTraitExpr(const ArrayTypeTraitExpr *S) { 1801 VisitExpr(S); 1802 ID.AddInteger(S->getTrait()); 1803 VisitType(S->getQueriedType()); 1804 } 1805 1806 void StmtProfiler::VisitExpressionTraitExpr(const ExpressionTraitExpr *S) { 1807 VisitExpr(S); 1808 ID.AddInteger(S->getTrait()); 1809 VisitExpr(S->getQueriedExpression()); 1810 } 1811 1812 void StmtProfiler::VisitDependentScopeDeclRefExpr( 1813 const DependentScopeDeclRefExpr *S) { 1814 VisitExpr(S); 1815 VisitName(S->getDeclName()); 1816 VisitNestedNameSpecifier(S->getQualifier()); 1817 ID.AddBoolean(S->hasExplicitTemplateArgs()); 1818 if (S->hasExplicitTemplateArgs()) 1819 VisitTemplateArguments(S->getTemplateArgs(), S->getNumTemplateArgs()); 1820 } 1821 1822 void StmtProfiler::VisitExprWithCleanups(const ExprWithCleanups *S) { 1823 VisitExpr(S); 1824 } 1825 1826 void StmtProfiler::VisitCXXUnresolvedConstructExpr( 1827 const CXXUnresolvedConstructExpr *S) { 1828 VisitExpr(S); 1829 VisitType(S->getTypeAsWritten()); 1830 ID.AddInteger(S->isListInitialization()); 1831 } 1832 1833 void StmtProfiler::VisitCXXDependentScopeMemberExpr( 1834 const CXXDependentScopeMemberExpr *S) { 1835 ID.AddBoolean(S->isImplicitAccess()); 1836 if (!S->isImplicitAccess()) { 1837 VisitExpr(S); 1838 ID.AddBoolean(S->isArrow()); 1839 } 1840 VisitNestedNameSpecifier(S->getQualifier()); 1841 VisitName(S->getMember()); 1842 ID.AddBoolean(S->hasExplicitTemplateArgs()); 1843 if (S->hasExplicitTemplateArgs()) 1844 VisitTemplateArguments(S->getTemplateArgs(), S->getNumTemplateArgs()); 1845 } 1846 1847 void StmtProfiler::VisitUnresolvedMemberExpr(const UnresolvedMemberExpr *S) { 1848 ID.AddBoolean(S->isImplicitAccess()); 1849 if (!S->isImplicitAccess()) { 1850 VisitExpr(S); 1851 ID.AddBoolean(S->isArrow()); 1852 } 1853 VisitNestedNameSpecifier(S->getQualifier()); 1854 VisitName(S->getMemberName()); 1855 ID.AddBoolean(S->hasExplicitTemplateArgs()); 1856 if (S->hasExplicitTemplateArgs()) 1857 VisitTemplateArguments(S->getTemplateArgs(), S->getNumTemplateArgs()); 1858 } 1859 1860 void StmtProfiler::VisitCXXNoexceptExpr(const CXXNoexceptExpr *S) { 1861 VisitExpr(S); 1862 } 1863 1864 void StmtProfiler::VisitPackExpansionExpr(const PackExpansionExpr *S) { 1865 VisitExpr(S); 1866 } 1867 1868 void StmtProfiler::VisitSizeOfPackExpr(const SizeOfPackExpr *S) { 1869 VisitExpr(S); 1870 VisitDecl(S->getPack()); 1871 if (S->isPartiallySubstituted()) { 1872 auto Args = S->getPartialArguments(); 1873 ID.AddInteger(Args.size()); 1874 for (const auto &TA : Args) 1875 VisitTemplateArgument(TA); 1876 } else { 1877 ID.AddInteger(0); 1878 } 1879 } 1880 1881 void StmtProfiler::VisitSubstNonTypeTemplateParmPackExpr( 1882 const SubstNonTypeTemplateParmPackExpr *S) { 1883 VisitExpr(S); 1884 VisitDecl(S->getParameterPack()); 1885 VisitTemplateArgument(S->getArgumentPack()); 1886 } 1887 1888 void StmtProfiler::VisitSubstNonTypeTemplateParmExpr( 1889 const SubstNonTypeTemplateParmExpr *E) { 1890 // Profile exactly as the replacement expression. 1891 Visit(E->getReplacement()); 1892 } 1893 1894 void StmtProfiler::VisitFunctionParmPackExpr(const FunctionParmPackExpr *S) { 1895 VisitExpr(S); 1896 VisitDecl(S->getParameterPack()); 1897 ID.AddInteger(S->getNumExpansions()); 1898 for (FunctionParmPackExpr::iterator I = S->begin(), E = S->end(); I != E; ++I) 1899 VisitDecl(*I); 1900 } 1901 1902 void StmtProfiler::VisitMaterializeTemporaryExpr( 1903 const MaterializeTemporaryExpr *S) { 1904 VisitExpr(S); 1905 } 1906 1907 void StmtProfiler::VisitCXXFoldExpr(const CXXFoldExpr *S) { 1908 VisitExpr(S); 1909 ID.AddInteger(S->getOperator()); 1910 } 1911 1912 void StmtProfiler::VisitCoroutineBodyStmt(const CoroutineBodyStmt *S) { 1913 VisitStmt(S); 1914 } 1915 1916 void StmtProfiler::VisitCoreturnStmt(const CoreturnStmt *S) { 1917 VisitStmt(S); 1918 } 1919 1920 void StmtProfiler::VisitCoawaitExpr(const CoawaitExpr *S) { 1921 VisitExpr(S); 1922 } 1923 1924 void StmtProfiler::VisitDependentCoawaitExpr(const DependentCoawaitExpr *S) { 1925 VisitExpr(S); 1926 } 1927 1928 void StmtProfiler::VisitCoyieldExpr(const CoyieldExpr *S) { 1929 VisitExpr(S); 1930 } 1931 1932 void StmtProfiler::VisitOpaqueValueExpr(const OpaqueValueExpr *E) { 1933 VisitExpr(E); 1934 } 1935 1936 void StmtProfiler::VisitTypoExpr(const TypoExpr *E) { 1937 VisitExpr(E); 1938 } 1939 1940 void StmtProfiler::VisitSourceLocExpr(const SourceLocExpr *E) { 1941 VisitExpr(E); 1942 } 1943 1944 void StmtProfiler::VisitObjCStringLiteral(const ObjCStringLiteral *S) { 1945 VisitExpr(S); 1946 } 1947 1948 void StmtProfiler::VisitObjCBoxedExpr(const ObjCBoxedExpr *E) { 1949 VisitExpr(E); 1950 } 1951 1952 void StmtProfiler::VisitObjCArrayLiteral(const ObjCArrayLiteral *E) { 1953 VisitExpr(E); 1954 } 1955 1956 void StmtProfiler::VisitObjCDictionaryLiteral(const ObjCDictionaryLiteral *E) { 1957 VisitExpr(E); 1958 } 1959 1960 void StmtProfiler::VisitObjCEncodeExpr(const ObjCEncodeExpr *S) { 1961 VisitExpr(S); 1962 VisitType(S->getEncodedType()); 1963 } 1964 1965 void StmtProfiler::VisitObjCSelectorExpr(const ObjCSelectorExpr *S) { 1966 VisitExpr(S); 1967 VisitName(S->getSelector()); 1968 } 1969 1970 void StmtProfiler::VisitObjCProtocolExpr(const ObjCProtocolExpr *S) { 1971 VisitExpr(S); 1972 VisitDecl(S->getProtocol()); 1973 } 1974 1975 void StmtProfiler::VisitObjCIvarRefExpr(const ObjCIvarRefExpr *S) { 1976 VisitExpr(S); 1977 VisitDecl(S->getDecl()); 1978 ID.AddBoolean(S->isArrow()); 1979 ID.AddBoolean(S->isFreeIvar()); 1980 } 1981 1982 void StmtProfiler::VisitObjCPropertyRefExpr(const ObjCPropertyRefExpr *S) { 1983 VisitExpr(S); 1984 if (S->isImplicitProperty()) { 1985 VisitDecl(S->getImplicitPropertyGetter()); 1986 VisitDecl(S->getImplicitPropertySetter()); 1987 } else { 1988 VisitDecl(S->getExplicitProperty()); 1989 } 1990 if (S->isSuperReceiver()) { 1991 ID.AddBoolean(S->isSuperReceiver()); 1992 VisitType(S->getSuperReceiverType()); 1993 } 1994 } 1995 1996 void StmtProfiler::VisitObjCSubscriptRefExpr(const ObjCSubscriptRefExpr *S) { 1997 VisitExpr(S); 1998 VisitDecl(S->getAtIndexMethodDecl()); 1999 VisitDecl(S->setAtIndexMethodDecl()); 2000 } 2001 2002 void StmtProfiler::VisitObjCMessageExpr(const ObjCMessageExpr *S) { 2003 VisitExpr(S); 2004 VisitName(S->getSelector()); 2005 VisitDecl(S->getMethodDecl()); 2006 } 2007 2008 void StmtProfiler::VisitObjCIsaExpr(const ObjCIsaExpr *S) { 2009 VisitExpr(S); 2010 ID.AddBoolean(S->isArrow()); 2011 } 2012 2013 void StmtProfiler::VisitObjCBoolLiteralExpr(const ObjCBoolLiteralExpr *S) { 2014 VisitExpr(S); 2015 ID.AddBoolean(S->getValue()); 2016 } 2017 2018 void StmtProfiler::VisitObjCIndirectCopyRestoreExpr( 2019 const ObjCIndirectCopyRestoreExpr *S) { 2020 VisitExpr(S); 2021 ID.AddBoolean(S->shouldCopy()); 2022 } 2023 2024 void StmtProfiler::VisitObjCBridgedCastExpr(const ObjCBridgedCastExpr *S) { 2025 VisitExplicitCastExpr(S); 2026 ID.AddBoolean(S->getBridgeKind()); 2027 } 2028 2029 void StmtProfiler::VisitObjCAvailabilityCheckExpr( 2030 const ObjCAvailabilityCheckExpr *S) { 2031 VisitExpr(S); 2032 } 2033 2034 void StmtProfiler::VisitTemplateArguments(const TemplateArgumentLoc *Args, 2035 unsigned NumArgs) { 2036 ID.AddInteger(NumArgs); 2037 for (unsigned I = 0; I != NumArgs; ++I) 2038 VisitTemplateArgument(Args[I].getArgument()); 2039 } 2040 2041 void StmtProfiler::VisitTemplateArgument(const TemplateArgument &Arg) { 2042 // Mostly repetitive with TemplateArgument::Profile! 2043 ID.AddInteger(Arg.getKind()); 2044 switch (Arg.getKind()) { 2045 case TemplateArgument::Null: 2046 break; 2047 2048 case TemplateArgument::Type: 2049 VisitType(Arg.getAsType()); 2050 break; 2051 2052 case TemplateArgument::Template: 2053 case TemplateArgument::TemplateExpansion: 2054 VisitTemplateName(Arg.getAsTemplateOrTemplatePattern()); 2055 break; 2056 2057 case TemplateArgument::Declaration: 2058 VisitDecl(Arg.getAsDecl()); 2059 break; 2060 2061 case TemplateArgument::NullPtr: 2062 VisitType(Arg.getNullPtrType()); 2063 break; 2064 2065 case TemplateArgument::Integral: 2066 Arg.getAsIntegral().Profile(ID); 2067 VisitType(Arg.getIntegralType()); 2068 break; 2069 2070 case TemplateArgument::Expression: 2071 Visit(Arg.getAsExpr()); 2072 break; 2073 2074 case TemplateArgument::Pack: 2075 for (const auto &P : Arg.pack_elements()) 2076 VisitTemplateArgument(P); 2077 break; 2078 } 2079 } 2080 2081 void Stmt::Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context, 2082 bool Canonical) const { 2083 StmtProfilerWithPointers Profiler(ID, Context, Canonical); 2084 Profiler.Visit(this); 2085 } 2086 2087 void Stmt::ProcessODRHash(llvm::FoldingSetNodeID &ID, 2088 class ODRHash &Hash) const { 2089 StmtProfilerWithoutPointers Profiler(ID, Hash); 2090 Profiler.Visit(this); 2091 } 2092