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