StmtProfile.cpp revision 4ca8ac2e61c37ddadf37024af86f3e1019af8532
1//===---- StmtProfile.cpp - Profile implementation for Stmt ASTs ----------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file implements the Stmt::Profile method, which builds a unique bit 11// representation that identifies a statement/expression. 12// 13//===----------------------------------------------------------------------===// 14#include "clang/AST/ASTContext.h" 15#include "clang/AST/DeclCXX.h" 16#include "clang/AST/DeclObjC.h" 17#include "clang/AST/DeclTemplate.h" 18#include "clang/AST/Expr.h" 19#include "clang/AST/ExprCXX.h" 20#include "clang/AST/ExprObjC.h" 21#include "clang/AST/StmtVisitor.h" 22#include "llvm/ADT/FoldingSet.h" 23using namespace clang; 24 25namespace { 26 class StmtProfiler : public ConstStmtVisitor<StmtProfiler> { 27 llvm::FoldingSetNodeID &ID; 28 const ASTContext &Context; 29 bool Canonical; 30 31 public: 32 StmtProfiler(llvm::FoldingSetNodeID &ID, const ASTContext &Context, 33 bool Canonical) 34 : ID(ID), Context(Context), Canonical(Canonical) { } 35 36 void VisitStmt(const Stmt *S); 37 38#define STMT(Node, Base) void Visit##Node(const Node *S); 39#include "clang/AST/StmtNodes.inc" 40 41 /// \brief Visit a declaration that is referenced within an expression 42 /// or statement. 43 void VisitDecl(const Decl *D); 44 45 /// \brief Visit a type that is referenced within an expression or 46 /// statement. 47 void VisitType(QualType T); 48 49 /// \brief Visit a name that occurs within an expression or statement. 50 void VisitName(DeclarationName Name); 51 52 /// \brief Visit a nested-name-specifier that occurs within an expression 53 /// or statement. 54 void VisitNestedNameSpecifier(NestedNameSpecifier *NNS); 55 56 /// \brief Visit a template name that occurs within an expression or 57 /// statement. 58 void VisitTemplateName(TemplateName Name); 59 60 /// \brief Visit template arguments that occur within an expression or 61 /// statement. 62 void VisitTemplateArguments(const TemplateArgumentLoc *Args, 63 unsigned NumArgs); 64 65 /// \brief Visit a single template argument. 66 void VisitTemplateArgument(const TemplateArgument &Arg); 67 }; 68} 69 70void StmtProfiler::VisitStmt(const Stmt *S) { 71 ID.AddInteger(S->getStmtClass()); 72 for (Stmt::const_child_range C = S->children(); C; ++C) 73 Visit(*C); 74} 75 76void StmtProfiler::VisitDeclStmt(const DeclStmt *S) { 77 VisitStmt(S); 78 for (DeclStmt::const_decl_iterator D = S->decl_begin(), DEnd = S->decl_end(); 79 D != DEnd; ++D) 80 VisitDecl(*D); 81} 82 83void StmtProfiler::VisitNullStmt(const NullStmt *S) { 84 VisitStmt(S); 85} 86 87void StmtProfiler::VisitCompoundStmt(const CompoundStmt *S) { 88 VisitStmt(S); 89} 90 91void StmtProfiler::VisitSwitchCase(const SwitchCase *S) { 92 VisitStmt(S); 93} 94 95void StmtProfiler::VisitCaseStmt(const CaseStmt *S) { 96 VisitStmt(S); 97} 98 99void StmtProfiler::VisitDefaultStmt(const DefaultStmt *S) { 100 VisitStmt(S); 101} 102 103void StmtProfiler::VisitLabelStmt(const LabelStmt *S) { 104 VisitStmt(S); 105 VisitDecl(S->getDecl()); 106} 107 108void StmtProfiler::VisitIfStmt(const IfStmt *S) { 109 VisitStmt(S); 110 VisitDecl(S->getConditionVariable()); 111} 112 113void StmtProfiler::VisitSwitchStmt(const SwitchStmt *S) { 114 VisitStmt(S); 115 VisitDecl(S->getConditionVariable()); 116} 117 118void StmtProfiler::VisitWhileStmt(const WhileStmt *S) { 119 VisitStmt(S); 120 VisitDecl(S->getConditionVariable()); 121} 122 123void StmtProfiler::VisitDoStmt(const DoStmt *S) { 124 VisitStmt(S); 125} 126 127void StmtProfiler::VisitForStmt(const ForStmt *S) { 128 VisitStmt(S); 129} 130 131void StmtProfiler::VisitGotoStmt(const GotoStmt *S) { 132 VisitStmt(S); 133 VisitDecl(S->getLabel()); 134} 135 136void StmtProfiler::VisitIndirectGotoStmt(const IndirectGotoStmt *S) { 137 VisitStmt(S); 138} 139 140void StmtProfiler::VisitContinueStmt(const ContinueStmt *S) { 141 VisitStmt(S); 142} 143 144void StmtProfiler::VisitBreakStmt(const BreakStmt *S) { 145 VisitStmt(S); 146} 147 148void StmtProfiler::VisitReturnStmt(const ReturnStmt *S) { 149 VisitStmt(S); 150} 151 152void StmtProfiler::VisitAsmStmt(const AsmStmt *S) { 153 VisitStmt(S); 154 ID.AddBoolean(S->isVolatile()); 155 ID.AddBoolean(S->isSimple()); 156 VisitStringLiteral(S->getAsmString()); 157 ID.AddInteger(S->getNumOutputs()); 158 for (unsigned I = 0, N = S->getNumOutputs(); I != N; ++I) { 159 ID.AddString(S->getOutputName(I)); 160 VisitStringLiteral(S->getOutputConstraintLiteral(I)); 161 } 162 ID.AddInteger(S->getNumInputs()); 163 for (unsigned I = 0, N = S->getNumInputs(); I != N; ++I) { 164 ID.AddString(S->getInputName(I)); 165 VisitStringLiteral(S->getInputConstraintLiteral(I)); 166 } 167 ID.AddInteger(S->getNumClobbers()); 168 for (unsigned I = 0, N = S->getNumClobbers(); I != N; ++I) 169 VisitStringLiteral(S->getClobber(I)); 170} 171 172void StmtProfiler::VisitCXXCatchStmt(const CXXCatchStmt *S) { 173 VisitStmt(S); 174 VisitType(S->getCaughtType()); 175} 176 177void StmtProfiler::VisitCXXTryStmt(const CXXTryStmt *S) { 178 VisitStmt(S); 179} 180 181void StmtProfiler::VisitCXXForRangeStmt(const CXXForRangeStmt *S) { 182 VisitStmt(S); 183} 184 185void StmtProfiler::VisitMSDependentExistsStmt(const MSDependentExistsStmt *S) { 186 VisitStmt(S); 187 ID.AddBoolean(S->isIfExists()); 188 VisitNestedNameSpecifier(S->getQualifierLoc().getNestedNameSpecifier()); 189 VisitName(S->getNameInfo().getName()); 190} 191 192void StmtProfiler::VisitSEHTryStmt(const SEHTryStmt *S) { 193 VisitStmt(S); 194} 195 196void StmtProfiler::VisitSEHFinallyStmt(const SEHFinallyStmt *S) { 197 VisitStmt(S); 198} 199 200void StmtProfiler::VisitSEHExceptStmt(const SEHExceptStmt *S) { 201 VisitStmt(S); 202} 203 204void StmtProfiler::VisitObjCForCollectionStmt(const ObjCForCollectionStmt *S) { 205 VisitStmt(S); 206} 207 208void StmtProfiler::VisitObjCAtCatchStmt(const ObjCAtCatchStmt *S) { 209 VisitStmt(S); 210 ID.AddBoolean(S->hasEllipsis()); 211 if (S->getCatchParamDecl()) 212 VisitType(S->getCatchParamDecl()->getType()); 213} 214 215void StmtProfiler::VisitObjCAtFinallyStmt(const ObjCAtFinallyStmt *S) { 216 VisitStmt(S); 217} 218 219void StmtProfiler::VisitObjCAtTryStmt(const ObjCAtTryStmt *S) { 220 VisitStmt(S); 221} 222 223void 224StmtProfiler::VisitObjCAtSynchronizedStmt(const ObjCAtSynchronizedStmt *S) { 225 VisitStmt(S); 226} 227 228void StmtProfiler::VisitObjCAtThrowStmt(const ObjCAtThrowStmt *S) { 229 VisitStmt(S); 230} 231 232void 233StmtProfiler::VisitObjCAutoreleasePoolStmt(const ObjCAutoreleasePoolStmt *S) { 234 VisitStmt(S); 235} 236 237void StmtProfiler::VisitExpr(const Expr *S) { 238 VisitStmt(S); 239} 240 241void StmtProfiler::VisitDeclRefExpr(const DeclRefExpr *S) { 242 VisitExpr(S); 243 if (!Canonical) 244 VisitNestedNameSpecifier(S->getQualifier()); 245 VisitDecl(S->getDecl()); 246 if (!Canonical) 247 VisitTemplateArguments(S->getTemplateArgs(), S->getNumTemplateArgs()); 248} 249 250void StmtProfiler::VisitPredefinedExpr(const PredefinedExpr *S) { 251 VisitExpr(S); 252 ID.AddInteger(S->getIdentType()); 253} 254 255void StmtProfiler::VisitIntegerLiteral(const IntegerLiteral *S) { 256 VisitExpr(S); 257 S->getValue().Profile(ID); 258} 259 260void StmtProfiler::VisitCharacterLiteral(const CharacterLiteral *S) { 261 VisitExpr(S); 262 ID.AddInteger(S->getKind()); 263 ID.AddInteger(S->getValue()); 264} 265 266void StmtProfiler::VisitFloatingLiteral(const FloatingLiteral *S) { 267 VisitExpr(S); 268 S->getValue().Profile(ID); 269 ID.AddBoolean(S->isExact()); 270} 271 272void StmtProfiler::VisitImaginaryLiteral(const ImaginaryLiteral *S) { 273 VisitExpr(S); 274} 275 276void StmtProfiler::VisitStringLiteral(const StringLiteral *S) { 277 VisitExpr(S); 278 ID.AddString(S->getBytes()); 279 ID.AddInteger(S->getKind()); 280} 281 282void StmtProfiler::VisitParenExpr(const ParenExpr *S) { 283 VisitExpr(S); 284} 285 286void StmtProfiler::VisitParenListExpr(const ParenListExpr *S) { 287 VisitExpr(S); 288} 289 290void StmtProfiler::VisitUnaryOperator(const UnaryOperator *S) { 291 VisitExpr(S); 292 ID.AddInteger(S->getOpcode()); 293} 294 295void StmtProfiler::VisitOffsetOfExpr(const OffsetOfExpr *S) { 296 VisitType(S->getTypeSourceInfo()->getType()); 297 unsigned n = S->getNumComponents(); 298 for (unsigned i = 0; i < n; ++i) { 299 const OffsetOfExpr::OffsetOfNode& ON = S->getComponent(i); 300 ID.AddInteger(ON.getKind()); 301 switch (ON.getKind()) { 302 case OffsetOfExpr::OffsetOfNode::Array: 303 // Expressions handled below. 304 break; 305 306 case OffsetOfExpr::OffsetOfNode::Field: 307 VisitDecl(ON.getField()); 308 break; 309 310 case OffsetOfExpr::OffsetOfNode::Identifier: 311 ID.AddPointer(ON.getFieldName()); 312 break; 313 314 case OffsetOfExpr::OffsetOfNode::Base: 315 // These nodes are implicit, and therefore don't need profiling. 316 break; 317 } 318 } 319 320 VisitExpr(S); 321} 322 323void 324StmtProfiler::VisitUnaryExprOrTypeTraitExpr(const UnaryExprOrTypeTraitExpr *S) { 325 VisitExpr(S); 326 ID.AddInteger(S->getKind()); 327 if (S->isArgumentType()) 328 VisitType(S->getArgumentType()); 329} 330 331void StmtProfiler::VisitArraySubscriptExpr(const ArraySubscriptExpr *S) { 332 VisitExpr(S); 333} 334 335void StmtProfiler::VisitCallExpr(const CallExpr *S) { 336 VisitExpr(S); 337} 338 339void StmtProfiler::VisitMemberExpr(const MemberExpr *S) { 340 VisitExpr(S); 341 VisitDecl(S->getMemberDecl()); 342 if (!Canonical) 343 VisitNestedNameSpecifier(S->getQualifier()); 344 ID.AddBoolean(S->isArrow()); 345} 346 347void StmtProfiler::VisitCompoundLiteralExpr(const CompoundLiteralExpr *S) { 348 VisitExpr(S); 349 ID.AddBoolean(S->isFileScope()); 350} 351 352void StmtProfiler::VisitCastExpr(const CastExpr *S) { 353 VisitExpr(S); 354} 355 356void StmtProfiler::VisitImplicitCastExpr(const ImplicitCastExpr *S) { 357 VisitCastExpr(S); 358 ID.AddInteger(S->getValueKind()); 359} 360 361void StmtProfiler::VisitExplicitCastExpr(const ExplicitCastExpr *S) { 362 VisitCastExpr(S); 363 VisitType(S->getTypeAsWritten()); 364} 365 366void StmtProfiler::VisitCStyleCastExpr(const CStyleCastExpr *S) { 367 VisitExplicitCastExpr(S); 368} 369 370void StmtProfiler::VisitBinaryOperator(const BinaryOperator *S) { 371 VisitExpr(S); 372 ID.AddInteger(S->getOpcode()); 373} 374 375void 376StmtProfiler::VisitCompoundAssignOperator(const CompoundAssignOperator *S) { 377 VisitBinaryOperator(S); 378} 379 380void StmtProfiler::VisitConditionalOperator(const ConditionalOperator *S) { 381 VisitExpr(S); 382} 383 384void StmtProfiler::VisitBinaryConditionalOperator( 385 const BinaryConditionalOperator *S) { 386 VisitExpr(S); 387} 388 389void StmtProfiler::VisitAddrLabelExpr(const AddrLabelExpr *S) { 390 VisitExpr(S); 391 VisitDecl(S->getLabel()); 392} 393 394void StmtProfiler::VisitStmtExpr(const StmtExpr *S) { 395 VisitExpr(S); 396} 397 398void StmtProfiler::VisitShuffleVectorExpr(const ShuffleVectorExpr *S) { 399 VisitExpr(S); 400} 401 402void StmtProfiler::VisitChooseExpr(const ChooseExpr *S) { 403 VisitExpr(S); 404} 405 406void StmtProfiler::VisitGNUNullExpr(const GNUNullExpr *S) { 407 VisitExpr(S); 408} 409 410void StmtProfiler::VisitVAArgExpr(const VAArgExpr *S) { 411 VisitExpr(S); 412} 413 414void StmtProfiler::VisitInitListExpr(const InitListExpr *S) { 415 if (S->getSyntacticForm()) { 416 VisitInitListExpr(S->getSyntacticForm()); 417 return; 418 } 419 420 VisitExpr(S); 421} 422 423void StmtProfiler::VisitDesignatedInitExpr(const DesignatedInitExpr *S) { 424 VisitExpr(S); 425 ID.AddBoolean(S->usesGNUSyntax()); 426 for (DesignatedInitExpr::const_designators_iterator D = 427 S->designators_begin(), DEnd = S->designators_end(); 428 D != DEnd; ++D) { 429 if (D->isFieldDesignator()) { 430 ID.AddInteger(0); 431 VisitName(D->getFieldName()); 432 continue; 433 } 434 435 if (D->isArrayDesignator()) { 436 ID.AddInteger(1); 437 } else { 438 assert(D->isArrayRangeDesignator()); 439 ID.AddInteger(2); 440 } 441 ID.AddInteger(D->getFirstExprIndex()); 442 } 443} 444 445void StmtProfiler::VisitImplicitValueInitExpr(const ImplicitValueInitExpr *S) { 446 VisitExpr(S); 447} 448 449void StmtProfiler::VisitExtVectorElementExpr(const ExtVectorElementExpr *S) { 450 VisitExpr(S); 451 VisitName(&S->getAccessor()); 452} 453 454void StmtProfiler::VisitBlockExpr(const BlockExpr *S) { 455 VisitExpr(S); 456 VisitDecl(S->getBlockDecl()); 457} 458 459void StmtProfiler::VisitBlockDeclRefExpr(const BlockDeclRefExpr *S) { 460 VisitExpr(S); 461 VisitDecl(S->getDecl()); 462 ID.AddBoolean(S->isByRef()); 463 ID.AddBoolean(S->isConstQualAdded()); 464} 465 466void StmtProfiler::VisitGenericSelectionExpr(const GenericSelectionExpr *S) { 467 VisitExpr(S); 468 for (unsigned i = 0; i != S->getNumAssocs(); ++i) { 469 QualType T = S->getAssocType(i); 470 if (T.isNull()) 471 ID.AddPointer(0); 472 else 473 VisitType(T); 474 VisitExpr(S->getAssocExpr(i)); 475 } 476} 477 478void StmtProfiler::VisitPseudoObjectExpr(const PseudoObjectExpr *S) { 479 VisitExpr(S); 480 for (PseudoObjectExpr::const_semantics_iterator 481 i = S->semantics_begin(), e = S->semantics_end(); i != e; ++i) 482 // Normally, we would not profile the source expressions of OVEs. 483 if (const OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(*i)) 484 Visit(OVE->getSourceExpr()); 485} 486 487void StmtProfiler::VisitAtomicExpr(const AtomicExpr *S) { 488 VisitExpr(S); 489 ID.AddInteger(S->getOp()); 490} 491 492static Stmt::StmtClass DecodeOperatorCall(const CXXOperatorCallExpr *S, 493 UnaryOperatorKind &UnaryOp, 494 BinaryOperatorKind &BinaryOp) { 495 switch (S->getOperator()) { 496 case OO_None: 497 case OO_New: 498 case OO_Delete: 499 case OO_Array_New: 500 case OO_Array_Delete: 501 case OO_Arrow: 502 case OO_Call: 503 case OO_Conditional: 504 case NUM_OVERLOADED_OPERATORS: 505 llvm_unreachable("Invalid operator call kind"); 506 507 case OO_Plus: 508 if (S->getNumArgs() == 1) { 509 UnaryOp = UO_Plus; 510 return Stmt::UnaryOperatorClass; 511 } 512 513 BinaryOp = BO_Add; 514 return Stmt::BinaryOperatorClass; 515 516 case OO_Minus: 517 if (S->getNumArgs() == 1) { 518 UnaryOp = UO_Minus; 519 return Stmt::UnaryOperatorClass; 520 } 521 522 BinaryOp = BO_Sub; 523 return Stmt::BinaryOperatorClass; 524 525 case OO_Star: 526 if (S->getNumArgs() == 1) { 527 UnaryOp = UO_Minus; 528 return Stmt::UnaryOperatorClass; 529 } 530 531 BinaryOp = BO_Sub; 532 return Stmt::BinaryOperatorClass; 533 534 case OO_Slash: 535 BinaryOp = BO_Div; 536 return Stmt::BinaryOperatorClass; 537 538 case OO_Percent: 539 BinaryOp = BO_Rem; 540 return Stmt::BinaryOperatorClass; 541 542 case OO_Caret: 543 BinaryOp = BO_Xor; 544 return Stmt::BinaryOperatorClass; 545 546 case OO_Amp: 547 if (S->getNumArgs() == 1) { 548 UnaryOp = UO_AddrOf; 549 return Stmt::UnaryOperatorClass; 550 } 551 552 BinaryOp = BO_And; 553 return Stmt::BinaryOperatorClass; 554 555 case OO_Pipe: 556 BinaryOp = BO_Or; 557 return Stmt::BinaryOperatorClass; 558 559 case OO_Tilde: 560 UnaryOp = UO_Not; 561 return Stmt::UnaryOperatorClass; 562 563 case OO_Exclaim: 564 UnaryOp = UO_LNot; 565 return Stmt::UnaryOperatorClass; 566 567 case OO_Equal: 568 BinaryOp = BO_Assign; 569 return Stmt::BinaryOperatorClass; 570 571 case OO_Less: 572 BinaryOp = BO_LT; 573 return Stmt::BinaryOperatorClass; 574 575 case OO_Greater: 576 BinaryOp = BO_GT; 577 return Stmt::BinaryOperatorClass; 578 579 case OO_PlusEqual: 580 BinaryOp = BO_AddAssign; 581 return Stmt::CompoundAssignOperatorClass; 582 583 case OO_MinusEqual: 584 BinaryOp = BO_SubAssign; 585 return Stmt::CompoundAssignOperatorClass; 586 587 case OO_StarEqual: 588 BinaryOp = BO_MulAssign; 589 return Stmt::CompoundAssignOperatorClass; 590 591 case OO_SlashEqual: 592 BinaryOp = BO_DivAssign; 593 return Stmt::CompoundAssignOperatorClass; 594 595 case OO_PercentEqual: 596 BinaryOp = BO_RemAssign; 597 return Stmt::CompoundAssignOperatorClass; 598 599 case OO_CaretEqual: 600 BinaryOp = BO_XorAssign; 601 return Stmt::CompoundAssignOperatorClass; 602 603 case OO_AmpEqual: 604 BinaryOp = BO_AndAssign; 605 return Stmt::CompoundAssignOperatorClass; 606 607 case OO_PipeEqual: 608 BinaryOp = BO_OrAssign; 609 return Stmt::CompoundAssignOperatorClass; 610 611 case OO_LessLess: 612 BinaryOp = BO_Shl; 613 return Stmt::BinaryOperatorClass; 614 615 case OO_GreaterGreater: 616 BinaryOp = BO_Shr; 617 return Stmt::BinaryOperatorClass; 618 619 case OO_LessLessEqual: 620 BinaryOp = BO_ShlAssign; 621 return Stmt::CompoundAssignOperatorClass; 622 623 case OO_GreaterGreaterEqual: 624 BinaryOp = BO_ShrAssign; 625 return Stmt::CompoundAssignOperatorClass; 626 627 case OO_EqualEqual: 628 BinaryOp = BO_EQ; 629 return Stmt::BinaryOperatorClass; 630 631 case OO_ExclaimEqual: 632 BinaryOp = BO_NE; 633 return Stmt::BinaryOperatorClass; 634 635 case OO_LessEqual: 636 BinaryOp = BO_LE; 637 return Stmt::BinaryOperatorClass; 638 639 case OO_GreaterEqual: 640 BinaryOp = BO_GE; 641 return Stmt::BinaryOperatorClass; 642 643 case OO_AmpAmp: 644 BinaryOp = BO_LAnd; 645 return Stmt::BinaryOperatorClass; 646 647 case OO_PipePipe: 648 BinaryOp = BO_LOr; 649 return Stmt::BinaryOperatorClass; 650 651 case OO_PlusPlus: 652 UnaryOp = S->getNumArgs() == 1? UO_PreInc 653 : UO_PostInc; 654 return Stmt::UnaryOperatorClass; 655 656 case OO_MinusMinus: 657 UnaryOp = S->getNumArgs() == 1? UO_PreDec 658 : UO_PostDec; 659 return Stmt::UnaryOperatorClass; 660 661 case OO_Comma: 662 BinaryOp = BO_Comma; 663 return Stmt::BinaryOperatorClass; 664 665 666 case OO_ArrowStar: 667 BinaryOp = BO_PtrMemI; 668 return Stmt::BinaryOperatorClass; 669 670 case OO_Subscript: 671 return Stmt::ArraySubscriptExprClass; 672 } 673 674 llvm_unreachable("Invalid overloaded operator expression"); 675} 676 677 678void StmtProfiler::VisitCXXOperatorCallExpr(const CXXOperatorCallExpr *S) { 679 if (S->isTypeDependent()) { 680 // Type-dependent operator calls are profiled like their underlying 681 // syntactic operator. 682 UnaryOperatorKind UnaryOp = UO_Extension; 683 BinaryOperatorKind BinaryOp = BO_Comma; 684 Stmt::StmtClass SC = DecodeOperatorCall(S, UnaryOp, BinaryOp); 685 686 ID.AddInteger(SC); 687 for (unsigned I = 0, N = S->getNumArgs(); I != N; ++I) 688 Visit(S->getArg(I)); 689 if (SC == Stmt::UnaryOperatorClass) 690 ID.AddInteger(UnaryOp); 691 else if (SC == Stmt::BinaryOperatorClass || 692 SC == Stmt::CompoundAssignOperatorClass) 693 ID.AddInteger(BinaryOp); 694 else 695 assert(SC == Stmt::ArraySubscriptExprClass); 696 697 return; 698 } 699 700 VisitCallExpr(S); 701 ID.AddInteger(S->getOperator()); 702} 703 704void StmtProfiler::VisitCXXMemberCallExpr(const CXXMemberCallExpr *S) { 705 VisitCallExpr(S); 706} 707 708void StmtProfiler::VisitCUDAKernelCallExpr(const CUDAKernelCallExpr *S) { 709 VisitCallExpr(S); 710} 711 712void StmtProfiler::VisitAsTypeExpr(const AsTypeExpr *S) { 713 VisitExpr(S); 714} 715 716void StmtProfiler::VisitCXXNamedCastExpr(const CXXNamedCastExpr *S) { 717 VisitExplicitCastExpr(S); 718} 719 720void StmtProfiler::VisitCXXStaticCastExpr(const CXXStaticCastExpr *S) { 721 VisitCXXNamedCastExpr(S); 722} 723 724void StmtProfiler::VisitCXXDynamicCastExpr(const CXXDynamicCastExpr *S) { 725 VisitCXXNamedCastExpr(S); 726} 727 728void 729StmtProfiler::VisitCXXReinterpretCastExpr(const CXXReinterpretCastExpr *S) { 730 VisitCXXNamedCastExpr(S); 731} 732 733void StmtProfiler::VisitCXXConstCastExpr(const CXXConstCastExpr *S) { 734 VisitCXXNamedCastExpr(S); 735} 736 737void StmtProfiler::VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *S) { 738 VisitExpr(S); 739 ID.AddBoolean(S->getValue()); 740} 741 742void StmtProfiler::VisitCXXNullPtrLiteralExpr(const CXXNullPtrLiteralExpr *S) { 743 VisitExpr(S); 744} 745 746void StmtProfiler::VisitCXXTypeidExpr(const CXXTypeidExpr *S) { 747 VisitExpr(S); 748 if (S->isTypeOperand()) 749 VisitType(S->getTypeOperand()); 750} 751 752void StmtProfiler::VisitCXXUuidofExpr(const CXXUuidofExpr *S) { 753 VisitExpr(S); 754 if (S->isTypeOperand()) 755 VisitType(S->getTypeOperand()); 756} 757 758void StmtProfiler::VisitCXXThisExpr(const CXXThisExpr *S) { 759 VisitExpr(S); 760} 761 762void StmtProfiler::VisitCXXThrowExpr(const CXXThrowExpr *S) { 763 VisitExpr(S); 764} 765 766void StmtProfiler::VisitCXXDefaultArgExpr(const CXXDefaultArgExpr *S) { 767 VisitExpr(S); 768 VisitDecl(S->getParam()); 769} 770 771void StmtProfiler::VisitCXXBindTemporaryExpr(const CXXBindTemporaryExpr *S) { 772 VisitExpr(S); 773 VisitDecl( 774 const_cast<CXXDestructorDecl *>(S->getTemporary()->getDestructor())); 775} 776 777void StmtProfiler::VisitCXXConstructExpr(const CXXConstructExpr *S) { 778 VisitExpr(S); 779 VisitDecl(S->getConstructor()); 780 ID.AddBoolean(S->isElidable()); 781} 782 783void StmtProfiler::VisitCXXFunctionalCastExpr(const CXXFunctionalCastExpr *S) { 784 VisitExplicitCastExpr(S); 785} 786 787void 788StmtProfiler::VisitCXXTemporaryObjectExpr(const CXXTemporaryObjectExpr *S) { 789 VisitCXXConstructExpr(S); 790} 791 792void 793StmtProfiler::VisitLambdaExpr(const LambdaExpr *S) { 794 VisitExpr(S); 795 for (LambdaExpr::capture_iterator C = S->explicit_capture_begin(), 796 CEnd = S->explicit_capture_end(); 797 C != CEnd; ++C) { 798 ID.AddInteger(C->getCaptureKind()); 799 if (C->capturesVariable()) { 800 VisitDecl(C->getCapturedVar()); 801 ID.AddBoolean(C->isPackExpansion()); 802 } 803 } 804 // Note: If we actually needed to be able to match lambda 805 // expressions, we would have to consider parameters and return type 806 // here, among other things. 807 VisitStmt(S->getBody()); 808} 809 810void 811StmtProfiler::VisitCXXScalarValueInitExpr(const CXXScalarValueInitExpr *S) { 812 VisitExpr(S); 813} 814 815void StmtProfiler::VisitCXXDeleteExpr(const CXXDeleteExpr *S) { 816 VisitExpr(S); 817 ID.AddBoolean(S->isGlobalDelete()); 818 ID.AddBoolean(S->isArrayForm()); 819 VisitDecl(S->getOperatorDelete()); 820} 821 822 823void StmtProfiler::VisitCXXNewExpr(const CXXNewExpr *S) { 824 VisitExpr(S); 825 VisitType(S->getAllocatedType()); 826 VisitDecl(S->getOperatorNew()); 827 VisitDecl(S->getOperatorDelete()); 828 ID.AddBoolean(S->isArray()); 829 ID.AddInteger(S->getNumPlacementArgs()); 830 ID.AddBoolean(S->isGlobalNew()); 831 ID.AddBoolean(S->isParenTypeId()); 832 ID.AddInteger(S->getInitializationStyle()); 833} 834 835void 836StmtProfiler::VisitCXXPseudoDestructorExpr(const CXXPseudoDestructorExpr *S) { 837 VisitExpr(S); 838 ID.AddBoolean(S->isArrow()); 839 VisitNestedNameSpecifier(S->getQualifier()); 840 VisitType(S->getDestroyedType()); 841} 842 843void StmtProfiler::VisitOverloadExpr(const OverloadExpr *S) { 844 VisitExpr(S); 845 VisitNestedNameSpecifier(S->getQualifier()); 846 VisitName(S->getName()); 847 ID.AddBoolean(S->hasExplicitTemplateArgs()); 848 if (S->hasExplicitTemplateArgs()) 849 VisitTemplateArguments(S->getExplicitTemplateArgs().getTemplateArgs(), 850 S->getExplicitTemplateArgs().NumTemplateArgs); 851} 852 853void 854StmtProfiler::VisitUnresolvedLookupExpr(const UnresolvedLookupExpr *S) { 855 VisitOverloadExpr(S); 856} 857 858void StmtProfiler::VisitUnaryTypeTraitExpr(const UnaryTypeTraitExpr *S) { 859 VisitExpr(S); 860 ID.AddInteger(S->getTrait()); 861 VisitType(S->getQueriedType()); 862} 863 864void StmtProfiler::VisitBinaryTypeTraitExpr(const BinaryTypeTraitExpr *S) { 865 VisitExpr(S); 866 ID.AddInteger(S->getTrait()); 867 VisitType(S->getLhsType()); 868 VisitType(S->getRhsType()); 869} 870 871void StmtProfiler::VisitTypeTraitExpr(const TypeTraitExpr *S) { 872 VisitExpr(S); 873 ID.AddInteger(S->getTrait()); 874 ID.AddInteger(S->getNumArgs()); 875 for (unsigned I = 0, N = S->getNumArgs(); I != N; ++I) 876 VisitType(S->getArg(I)->getType()); 877} 878 879void StmtProfiler::VisitArrayTypeTraitExpr(const ArrayTypeTraitExpr *S) { 880 VisitExpr(S); 881 ID.AddInteger(S->getTrait()); 882 VisitType(S->getQueriedType()); 883} 884 885void StmtProfiler::VisitExpressionTraitExpr(const ExpressionTraitExpr *S) { 886 VisitExpr(S); 887 ID.AddInteger(S->getTrait()); 888 VisitExpr(S->getQueriedExpression()); 889} 890 891void StmtProfiler::VisitDependentScopeDeclRefExpr( 892 const DependentScopeDeclRefExpr *S) { 893 VisitExpr(S); 894 VisitName(S->getDeclName()); 895 VisitNestedNameSpecifier(S->getQualifier()); 896 ID.AddBoolean(S->hasExplicitTemplateArgs()); 897 if (S->hasExplicitTemplateArgs()) 898 VisitTemplateArguments(S->getTemplateArgs(), S->getNumTemplateArgs()); 899} 900 901void StmtProfiler::VisitExprWithCleanups(const ExprWithCleanups *S) { 902 VisitExpr(S); 903} 904 905void StmtProfiler::VisitCXXUnresolvedConstructExpr( 906 const CXXUnresolvedConstructExpr *S) { 907 VisitExpr(S); 908 VisitType(S->getTypeAsWritten()); 909} 910 911void StmtProfiler::VisitCXXDependentScopeMemberExpr( 912 const CXXDependentScopeMemberExpr *S) { 913 ID.AddBoolean(S->isImplicitAccess()); 914 if (!S->isImplicitAccess()) { 915 VisitExpr(S); 916 ID.AddBoolean(S->isArrow()); 917 } 918 VisitNestedNameSpecifier(S->getQualifier()); 919 VisitName(S->getMember()); 920 ID.AddBoolean(S->hasExplicitTemplateArgs()); 921 if (S->hasExplicitTemplateArgs()) 922 VisitTemplateArguments(S->getTemplateArgs(), S->getNumTemplateArgs()); 923} 924 925void StmtProfiler::VisitUnresolvedMemberExpr(const UnresolvedMemberExpr *S) { 926 ID.AddBoolean(S->isImplicitAccess()); 927 if (!S->isImplicitAccess()) { 928 VisitExpr(S); 929 ID.AddBoolean(S->isArrow()); 930 } 931 VisitNestedNameSpecifier(S->getQualifier()); 932 VisitName(S->getMemberName()); 933 ID.AddBoolean(S->hasExplicitTemplateArgs()); 934 if (S->hasExplicitTemplateArgs()) 935 VisitTemplateArguments(S->getTemplateArgs(), S->getNumTemplateArgs()); 936} 937 938void StmtProfiler::VisitCXXNoexceptExpr(const CXXNoexceptExpr *S) { 939 VisitExpr(S); 940} 941 942void StmtProfiler::VisitPackExpansionExpr(const PackExpansionExpr *S) { 943 VisitExpr(S); 944} 945 946void StmtProfiler::VisitSizeOfPackExpr(const SizeOfPackExpr *S) { 947 VisitExpr(S); 948 VisitDecl(S->getPack()); 949} 950 951void StmtProfiler::VisitSubstNonTypeTemplateParmPackExpr( 952 const SubstNonTypeTemplateParmPackExpr *S) { 953 VisitExpr(S); 954 VisitDecl(S->getParameterPack()); 955 VisitTemplateArgument(S->getArgumentPack()); 956} 957 958void StmtProfiler::VisitSubstNonTypeTemplateParmExpr( 959 const SubstNonTypeTemplateParmExpr *E) { 960 // Profile exactly as the replacement expression. 961 Visit(E->getReplacement()); 962} 963 964void StmtProfiler::VisitMaterializeTemporaryExpr( 965 const MaterializeTemporaryExpr *S) { 966 VisitExpr(S); 967} 968 969void StmtProfiler::VisitOpaqueValueExpr(const OpaqueValueExpr *E) { 970 VisitExpr(E); 971} 972 973void StmtProfiler::VisitObjCStringLiteral(const ObjCStringLiteral *S) { 974 VisitExpr(S); 975} 976 977void StmtProfiler::VisitObjCEncodeExpr(const ObjCEncodeExpr *S) { 978 VisitExpr(S); 979 VisitType(S->getEncodedType()); 980} 981 982void StmtProfiler::VisitObjCSelectorExpr(const ObjCSelectorExpr *S) { 983 VisitExpr(S); 984 VisitName(S->getSelector()); 985} 986 987void StmtProfiler::VisitObjCProtocolExpr(const ObjCProtocolExpr *S) { 988 VisitExpr(S); 989 VisitDecl(S->getProtocol()); 990} 991 992void StmtProfiler::VisitObjCIvarRefExpr(const ObjCIvarRefExpr *S) { 993 VisitExpr(S); 994 VisitDecl(S->getDecl()); 995 ID.AddBoolean(S->isArrow()); 996 ID.AddBoolean(S->isFreeIvar()); 997} 998 999void StmtProfiler::VisitObjCPropertyRefExpr(const ObjCPropertyRefExpr *S) { 1000 VisitExpr(S); 1001 if (S->isImplicitProperty()) { 1002 VisitDecl(S->getImplicitPropertyGetter()); 1003 VisitDecl(S->getImplicitPropertySetter()); 1004 } else { 1005 VisitDecl(S->getExplicitProperty()); 1006 } 1007 if (S->isSuperReceiver()) { 1008 ID.AddBoolean(S->isSuperReceiver()); 1009 VisitType(S->getSuperReceiverType()); 1010 } 1011} 1012 1013void StmtProfiler::VisitObjCMessageExpr(const ObjCMessageExpr *S) { 1014 VisitExpr(S); 1015 VisitName(S->getSelector()); 1016 VisitDecl(S->getMethodDecl()); 1017} 1018 1019void StmtProfiler::VisitObjCIsaExpr(const ObjCIsaExpr *S) { 1020 VisitExpr(S); 1021 ID.AddBoolean(S->isArrow()); 1022} 1023 1024void StmtProfiler::VisitObjCIndirectCopyRestoreExpr( 1025 const ObjCIndirectCopyRestoreExpr *S) { 1026 VisitExpr(S); 1027 ID.AddBoolean(S->shouldCopy()); 1028} 1029 1030void StmtProfiler::VisitObjCBridgedCastExpr(const ObjCBridgedCastExpr *S) { 1031 VisitExplicitCastExpr(S); 1032 ID.AddBoolean(S->getBridgeKind()); 1033} 1034 1035void StmtProfiler::VisitDecl(const Decl *D) { 1036 ID.AddInteger(D? D->getKind() : 0); 1037 1038 if (Canonical && D) { 1039 if (const NonTypeTemplateParmDecl *NTTP = 1040 dyn_cast<NonTypeTemplateParmDecl>(D)) { 1041 ID.AddInteger(NTTP->getDepth()); 1042 ID.AddInteger(NTTP->getIndex()); 1043 ID.AddBoolean(NTTP->isParameterPack()); 1044 VisitType(NTTP->getType()); 1045 return; 1046 } 1047 1048 if (const ParmVarDecl *Parm = dyn_cast<ParmVarDecl>(D)) { 1049 // The Itanium C++ ABI uses the type, scope depth, and scope 1050 // index of a parameter when mangling expressions that involve 1051 // function parameters, so we will use the parameter's type for 1052 // establishing function parameter identity. That way, our 1053 // definition of "equivalent" (per C++ [temp.over.link]) is at 1054 // least as strong as the definition of "equivalent" used for 1055 // name mangling. 1056 VisitType(Parm->getType()); 1057 ID.AddInteger(Parm->getFunctionScopeDepth()); 1058 ID.AddInteger(Parm->getFunctionScopeIndex()); 1059 return; 1060 } 1061 1062 if (const TemplateTemplateParmDecl *TTP = 1063 dyn_cast<TemplateTemplateParmDecl>(D)) { 1064 ID.AddInteger(TTP->getDepth()); 1065 ID.AddInteger(TTP->getIndex()); 1066 ID.AddBoolean(TTP->isParameterPack()); 1067 return; 1068 } 1069 } 1070 1071 ID.AddPointer(D? D->getCanonicalDecl() : 0); 1072} 1073 1074void StmtProfiler::VisitType(QualType T) { 1075 if (Canonical) 1076 T = Context.getCanonicalType(T); 1077 1078 ID.AddPointer(T.getAsOpaquePtr()); 1079} 1080 1081void StmtProfiler::VisitName(DeclarationName Name) { 1082 ID.AddPointer(Name.getAsOpaquePtr()); 1083} 1084 1085void StmtProfiler::VisitNestedNameSpecifier(NestedNameSpecifier *NNS) { 1086 if (Canonical) 1087 NNS = Context.getCanonicalNestedNameSpecifier(NNS); 1088 ID.AddPointer(NNS); 1089} 1090 1091void StmtProfiler::VisitTemplateName(TemplateName Name) { 1092 if (Canonical) 1093 Name = Context.getCanonicalTemplateName(Name); 1094 1095 Name.Profile(ID); 1096} 1097 1098void StmtProfiler::VisitTemplateArguments(const TemplateArgumentLoc *Args, 1099 unsigned NumArgs) { 1100 ID.AddInteger(NumArgs); 1101 for (unsigned I = 0; I != NumArgs; ++I) 1102 VisitTemplateArgument(Args[I].getArgument()); 1103} 1104 1105void StmtProfiler::VisitTemplateArgument(const TemplateArgument &Arg) { 1106 // Mostly repetitive with TemplateArgument::Profile! 1107 ID.AddInteger(Arg.getKind()); 1108 switch (Arg.getKind()) { 1109 case TemplateArgument::Null: 1110 break; 1111 1112 case TemplateArgument::Type: 1113 VisitType(Arg.getAsType()); 1114 break; 1115 1116 case TemplateArgument::Template: 1117 case TemplateArgument::TemplateExpansion: 1118 VisitTemplateName(Arg.getAsTemplateOrTemplatePattern()); 1119 break; 1120 1121 case TemplateArgument::Declaration: 1122 VisitDecl(Arg.getAsDecl()); 1123 break; 1124 1125 case TemplateArgument::Integral: 1126 Arg.getAsIntegral()->Profile(ID); 1127 VisitType(Arg.getIntegralType()); 1128 break; 1129 1130 case TemplateArgument::Expression: 1131 Visit(Arg.getAsExpr()); 1132 break; 1133 1134 case TemplateArgument::Pack: 1135 const TemplateArgument *Pack = Arg.pack_begin(); 1136 for (unsigned i = 0, e = Arg.pack_size(); i != e; ++i) 1137 VisitTemplateArgument(Pack[i]); 1138 break; 1139 } 1140} 1141 1142void Stmt::Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context, 1143 bool Canonical) const { 1144 StmtProfiler Profiler(ID, Context, Canonical); 1145 Profiler.Visit(this); 1146} 1147