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