StmtProfile.cpp revision b11382497a923b0d7009e85a1d8eb7bf93ec6d0d
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::VisitSEHTryStmt(const SEHTryStmt *S) { 186 VisitStmt(S); 187} 188 189void StmtProfiler::VisitSEHFinallyStmt(const SEHFinallyStmt *S) { 190 VisitStmt(S); 191} 192 193void StmtProfiler::VisitSEHExceptStmt(const SEHExceptStmt *S) { 194 VisitStmt(S); 195} 196 197void StmtProfiler::VisitObjCForCollectionStmt(const ObjCForCollectionStmt *S) { 198 VisitStmt(S); 199} 200 201void StmtProfiler::VisitObjCAtCatchStmt(const ObjCAtCatchStmt *S) { 202 VisitStmt(S); 203 ID.AddBoolean(S->hasEllipsis()); 204 if (S->getCatchParamDecl()) 205 VisitType(S->getCatchParamDecl()->getType()); 206} 207 208void StmtProfiler::VisitObjCAtFinallyStmt(const ObjCAtFinallyStmt *S) { 209 VisitStmt(S); 210} 211 212void StmtProfiler::VisitObjCAtTryStmt(const ObjCAtTryStmt *S) { 213 VisitStmt(S); 214} 215 216void 217StmtProfiler::VisitObjCAtSynchronizedStmt(const ObjCAtSynchronizedStmt *S) { 218 VisitStmt(S); 219} 220 221void StmtProfiler::VisitObjCAtThrowStmt(const ObjCAtThrowStmt *S) { 222 VisitStmt(S); 223} 224 225void 226StmtProfiler::VisitObjCAutoreleasePoolStmt(const ObjCAutoreleasePoolStmt *S) { 227 VisitStmt(S); 228} 229 230void StmtProfiler::VisitExpr(const Expr *S) { 231 VisitStmt(S); 232} 233 234void StmtProfiler::VisitDeclRefExpr(const DeclRefExpr *S) { 235 VisitExpr(S); 236 if (!Canonical) 237 VisitNestedNameSpecifier(S->getQualifier()); 238 VisitDecl(S->getDecl()); 239 if (!Canonical) 240 VisitTemplateArguments(S->getTemplateArgs(), S->getNumTemplateArgs()); 241} 242 243void StmtProfiler::VisitPredefinedExpr(const PredefinedExpr *S) { 244 VisitExpr(S); 245 ID.AddInteger(S->getIdentType()); 246} 247 248void StmtProfiler::VisitIntegerLiteral(const IntegerLiteral *S) { 249 VisitExpr(S); 250 S->getValue().Profile(ID); 251} 252 253void StmtProfiler::VisitCharacterLiteral(const CharacterLiteral *S) { 254 VisitExpr(S); 255 ID.AddBoolean(S->isWide()); 256 ID.AddInteger(S->getValue()); 257} 258 259void StmtProfiler::VisitFloatingLiteral(const FloatingLiteral *S) { 260 VisitExpr(S); 261 S->getValue().Profile(ID); 262 ID.AddBoolean(S->isExact()); 263} 264 265void StmtProfiler::VisitImaginaryLiteral(const ImaginaryLiteral *S) { 266 VisitExpr(S); 267} 268 269void StmtProfiler::VisitStringLiteral(const StringLiteral *S) { 270 VisitExpr(S); 271 ID.AddString(S->getString()); 272 ID.AddBoolean(S->isWide()); 273} 274 275void StmtProfiler::VisitParenExpr(const ParenExpr *S) { 276 VisitExpr(S); 277} 278 279void StmtProfiler::VisitParenListExpr(const ParenListExpr *S) { 280 VisitExpr(S); 281} 282 283void StmtProfiler::VisitUnaryOperator(const UnaryOperator *S) { 284 VisitExpr(S); 285 ID.AddInteger(S->getOpcode()); 286} 287 288void StmtProfiler::VisitOffsetOfExpr(const OffsetOfExpr *S) { 289 VisitType(S->getTypeSourceInfo()->getType()); 290 unsigned n = S->getNumComponents(); 291 for (unsigned i = 0; i < n; ++i) { 292 const OffsetOfExpr::OffsetOfNode& ON = S->getComponent(i); 293 ID.AddInteger(ON.getKind()); 294 switch (ON.getKind()) { 295 case OffsetOfExpr::OffsetOfNode::Array: 296 // Expressions handled below. 297 break; 298 299 case OffsetOfExpr::OffsetOfNode::Field: 300 VisitDecl(ON.getField()); 301 break; 302 303 case OffsetOfExpr::OffsetOfNode::Identifier: 304 ID.AddPointer(ON.getFieldName()); 305 break; 306 307 case OffsetOfExpr::OffsetOfNode::Base: 308 // These nodes are implicit, and therefore don't need profiling. 309 break; 310 } 311 } 312 313 VisitExpr(S); 314} 315 316void 317StmtProfiler::VisitUnaryExprOrTypeTraitExpr(const UnaryExprOrTypeTraitExpr *S) { 318 VisitExpr(S); 319 ID.AddInteger(S->getKind()); 320 if (S->isArgumentType()) 321 VisitType(S->getArgumentType()); 322} 323 324void StmtProfiler::VisitArraySubscriptExpr(const ArraySubscriptExpr *S) { 325 VisitExpr(S); 326} 327 328void StmtProfiler::VisitCallExpr(const CallExpr *S) { 329 VisitExpr(S); 330} 331 332void StmtProfiler::VisitMemberExpr(const MemberExpr *S) { 333 VisitExpr(S); 334 VisitDecl(S->getMemberDecl()); 335 if (!Canonical) 336 VisitNestedNameSpecifier(S->getQualifier()); 337 ID.AddBoolean(S->isArrow()); 338} 339 340void StmtProfiler::VisitCompoundLiteralExpr(const CompoundLiteralExpr *S) { 341 VisitExpr(S); 342 ID.AddBoolean(S->isFileScope()); 343} 344 345void StmtProfiler::VisitCastExpr(const CastExpr *S) { 346 VisitExpr(S); 347} 348 349void StmtProfiler::VisitImplicitCastExpr(const ImplicitCastExpr *S) { 350 VisitCastExpr(S); 351 ID.AddInteger(S->getValueKind()); 352} 353 354void StmtProfiler::VisitExplicitCastExpr(const ExplicitCastExpr *S) { 355 VisitCastExpr(S); 356 VisitType(S->getTypeAsWritten()); 357} 358 359void StmtProfiler::VisitCStyleCastExpr(const CStyleCastExpr *S) { 360 VisitExplicitCastExpr(S); 361} 362 363void StmtProfiler::VisitBinaryOperator(const BinaryOperator *S) { 364 VisitExpr(S); 365 ID.AddInteger(S->getOpcode()); 366} 367 368void 369StmtProfiler::VisitCompoundAssignOperator(const CompoundAssignOperator *S) { 370 VisitBinaryOperator(S); 371} 372 373void StmtProfiler::VisitConditionalOperator(const ConditionalOperator *S) { 374 VisitExpr(S); 375} 376 377void StmtProfiler::VisitBinaryConditionalOperator( 378 const BinaryConditionalOperator *S){ 379 VisitExpr(S); 380} 381 382void StmtProfiler::VisitAddrLabelExpr(const AddrLabelExpr *S) { 383 VisitExpr(S); 384 VisitDecl(S->getLabel()); 385} 386 387void StmtProfiler::VisitStmtExpr(const StmtExpr *S) { 388 VisitExpr(S); 389} 390 391void StmtProfiler::VisitShuffleVectorExpr(const ShuffleVectorExpr *S) { 392 VisitExpr(S); 393} 394 395void StmtProfiler::VisitChooseExpr(const ChooseExpr *S) { 396 VisitExpr(S); 397} 398 399void StmtProfiler::VisitGNUNullExpr(const GNUNullExpr *S) { 400 VisitExpr(S); 401} 402 403void StmtProfiler::VisitVAArgExpr(const VAArgExpr *S) { 404 VisitExpr(S); 405} 406 407void StmtProfiler::VisitInitListExpr(const InitListExpr *S) { 408 if (S->getSyntacticForm()) { 409 VisitInitListExpr(S->getSyntacticForm()); 410 return; 411 } 412 413 VisitExpr(S); 414} 415 416void StmtProfiler::VisitDesignatedInitExpr(const DesignatedInitExpr *S) { 417 VisitExpr(S); 418 ID.AddBoolean(S->usesGNUSyntax()); 419 for (DesignatedInitExpr::const_designators_iterator D = 420 S->designators_begin(), DEnd = S->designators_end(); 421 D != DEnd; ++D) { 422 if (D->isFieldDesignator()) { 423 ID.AddInteger(0); 424 VisitName(D->getFieldName()); 425 continue; 426 } 427 428 if (D->isArrayDesignator()) { 429 ID.AddInteger(1); 430 } else { 431 assert(D->isArrayRangeDesignator()); 432 ID.AddInteger(2); 433 } 434 ID.AddInteger(D->getFirstExprIndex()); 435 } 436} 437 438void StmtProfiler::VisitImplicitValueInitExpr(const ImplicitValueInitExpr *S) { 439 VisitExpr(S); 440} 441 442void StmtProfiler::VisitExtVectorElementExpr(const ExtVectorElementExpr *S) { 443 VisitExpr(S); 444 VisitName(&S->getAccessor()); 445} 446 447void StmtProfiler::VisitBlockExpr(const BlockExpr *S) { 448 VisitExpr(S); 449 VisitDecl(S->getBlockDecl()); 450} 451 452void StmtProfiler::VisitBlockDeclRefExpr(const BlockDeclRefExpr *S) { 453 VisitExpr(S); 454 VisitDecl(S->getDecl()); 455 ID.AddBoolean(S->isByRef()); 456 ID.AddBoolean(S->isConstQualAdded()); 457} 458 459void StmtProfiler::VisitGenericSelectionExpr(const GenericSelectionExpr *S) { 460 VisitExpr(S); 461 for (unsigned i = 0; i != S->getNumAssocs(); ++i) { 462 QualType T = S->getAssocType(i); 463 if (T.isNull()) 464 ID.AddPointer(0); 465 else 466 VisitType(T); 467 VisitExpr(S->getAssocExpr(i)); 468 } 469} 470 471static Stmt::StmtClass DecodeOperatorCall(const CXXOperatorCallExpr *S, 472 UnaryOperatorKind &UnaryOp, 473 BinaryOperatorKind &BinaryOp) { 474 switch (S->getOperator()) { 475 case OO_None: 476 case OO_New: 477 case OO_Delete: 478 case OO_Array_New: 479 case OO_Array_Delete: 480 case OO_Arrow: 481 case OO_Call: 482 case OO_Conditional: 483 case NUM_OVERLOADED_OPERATORS: 484 llvm_unreachable("Invalid operator call kind"); 485 return Stmt::ArraySubscriptExprClass; 486 487 case OO_Plus: 488 if (S->getNumArgs() == 1) { 489 UnaryOp = UO_Plus; 490 return Stmt::UnaryOperatorClass; 491 } 492 493 BinaryOp = BO_Add; 494 return Stmt::BinaryOperatorClass; 495 496 case OO_Minus: 497 if (S->getNumArgs() == 1) { 498 UnaryOp = UO_Minus; 499 return Stmt::UnaryOperatorClass; 500 } 501 502 BinaryOp = BO_Sub; 503 return Stmt::BinaryOperatorClass; 504 505 case OO_Star: 506 if (S->getNumArgs() == 1) { 507 UnaryOp = UO_Minus; 508 return Stmt::UnaryOperatorClass; 509 } 510 511 BinaryOp = BO_Sub; 512 return Stmt::BinaryOperatorClass; 513 514 case OO_Slash: 515 BinaryOp = BO_Div; 516 return Stmt::BinaryOperatorClass; 517 518 case OO_Percent: 519 BinaryOp = BO_Rem; 520 return Stmt::BinaryOperatorClass; 521 522 case OO_Caret: 523 BinaryOp = BO_Xor; 524 return Stmt::BinaryOperatorClass; 525 526 case OO_Amp: 527 if (S->getNumArgs() == 1) { 528 UnaryOp = UO_AddrOf; 529 return Stmt::UnaryOperatorClass; 530 } 531 532 BinaryOp = BO_And; 533 return Stmt::BinaryOperatorClass; 534 535 case OO_Pipe: 536 BinaryOp = BO_Or; 537 return Stmt::BinaryOperatorClass; 538 539 case OO_Tilde: 540 UnaryOp = UO_Not; 541 return Stmt::UnaryOperatorClass; 542 543 case OO_Exclaim: 544 UnaryOp = UO_LNot; 545 return Stmt::UnaryOperatorClass; 546 547 case OO_Equal: 548 BinaryOp = BO_Assign; 549 return Stmt::BinaryOperatorClass; 550 551 case OO_Less: 552 BinaryOp = BO_LT; 553 return Stmt::BinaryOperatorClass; 554 555 case OO_Greater: 556 BinaryOp = BO_GT; 557 return Stmt::BinaryOperatorClass; 558 559 case OO_PlusEqual: 560 BinaryOp = BO_AddAssign; 561 return Stmt::CompoundAssignOperatorClass; 562 563 case OO_MinusEqual: 564 BinaryOp = BO_SubAssign; 565 return Stmt::CompoundAssignOperatorClass; 566 567 case OO_StarEqual: 568 BinaryOp = BO_MulAssign; 569 return Stmt::CompoundAssignOperatorClass; 570 571 case OO_SlashEqual: 572 BinaryOp = BO_DivAssign; 573 return Stmt::CompoundAssignOperatorClass; 574 575 case OO_PercentEqual: 576 BinaryOp = BO_RemAssign; 577 return Stmt::CompoundAssignOperatorClass; 578 579 case OO_CaretEqual: 580 BinaryOp = BO_XorAssign; 581 return Stmt::CompoundAssignOperatorClass; 582 583 case OO_AmpEqual: 584 BinaryOp = BO_AndAssign; 585 return Stmt::CompoundAssignOperatorClass; 586 587 case OO_PipeEqual: 588 BinaryOp = BO_OrAssign; 589 return Stmt::CompoundAssignOperatorClass; 590 591 case OO_LessLess: 592 BinaryOp = BO_Shl; 593 return Stmt::BinaryOperatorClass; 594 595 case OO_GreaterGreater: 596 BinaryOp = BO_Shr; 597 return Stmt::BinaryOperatorClass; 598 599 case OO_LessLessEqual: 600 BinaryOp = BO_ShlAssign; 601 return Stmt::CompoundAssignOperatorClass; 602 603 case OO_GreaterGreaterEqual: 604 BinaryOp = BO_ShrAssign; 605 return Stmt::CompoundAssignOperatorClass; 606 607 case OO_EqualEqual: 608 BinaryOp = BO_EQ; 609 return Stmt::BinaryOperatorClass; 610 611 case OO_ExclaimEqual: 612 BinaryOp = BO_NE; 613 return Stmt::BinaryOperatorClass; 614 615 case OO_LessEqual: 616 BinaryOp = BO_LE; 617 return Stmt::BinaryOperatorClass; 618 619 case OO_GreaterEqual: 620 BinaryOp = BO_GE; 621 return Stmt::BinaryOperatorClass; 622 623 case OO_AmpAmp: 624 BinaryOp = BO_LAnd; 625 return Stmt::BinaryOperatorClass; 626 627 case OO_PipePipe: 628 BinaryOp = BO_LOr; 629 return Stmt::BinaryOperatorClass; 630 631 case OO_PlusPlus: 632 UnaryOp = S->getNumArgs() == 1? UO_PreInc 633 : UO_PostInc; 634 return Stmt::UnaryOperatorClass; 635 636 case OO_MinusMinus: 637 UnaryOp = S->getNumArgs() == 1? UO_PreDec 638 : UO_PostDec; 639 return Stmt::UnaryOperatorClass; 640 641 case OO_Comma: 642 BinaryOp = BO_Comma; 643 return Stmt::BinaryOperatorClass; 644 645 646 case OO_ArrowStar: 647 BinaryOp = BO_PtrMemI; 648 return Stmt::BinaryOperatorClass; 649 650 case OO_Subscript: 651 return Stmt::ArraySubscriptExprClass; 652 } 653 654 llvm_unreachable("Invalid overloaded operator expression"); 655} 656 657 658void StmtProfiler::VisitCXXOperatorCallExpr(const CXXOperatorCallExpr *S) { 659 if (S->isTypeDependent()) { 660 // Type-dependent operator calls are profiled like their underlying 661 // syntactic operator. 662 UnaryOperatorKind UnaryOp = UO_Extension; 663 BinaryOperatorKind BinaryOp = BO_Comma; 664 Stmt::StmtClass SC = DecodeOperatorCall(S, UnaryOp, BinaryOp); 665 666 ID.AddInteger(SC); 667 for (unsigned I = 0, N = S->getNumArgs(); I != N; ++I) 668 Visit(S->getArg(I)); 669 if (SC == Stmt::UnaryOperatorClass) 670 ID.AddInteger(UnaryOp); 671 else if (SC == Stmt::BinaryOperatorClass || 672 SC == Stmt::CompoundAssignOperatorClass) 673 ID.AddInteger(BinaryOp); 674 else 675 assert(SC == Stmt::ArraySubscriptExprClass); 676 677 return; 678 } 679 680 VisitCallExpr(S); 681 ID.AddInteger(S->getOperator()); 682} 683 684void StmtProfiler::VisitCXXMemberCallExpr(const CXXMemberCallExpr *S) { 685 VisitCallExpr(S); 686} 687 688void StmtProfiler::VisitCUDAKernelCallExpr(const CUDAKernelCallExpr *S) { 689 VisitCallExpr(S); 690} 691 692void StmtProfiler::VisitAsTypeExpr(const AsTypeExpr *S) { 693 VisitExpr(S); 694} 695 696void StmtProfiler::VisitCXXNamedCastExpr(const CXXNamedCastExpr *S) { 697 VisitExplicitCastExpr(S); 698} 699 700void StmtProfiler::VisitCXXStaticCastExpr(const CXXStaticCastExpr *S) { 701 VisitCXXNamedCastExpr(S); 702} 703 704void StmtProfiler::VisitCXXDynamicCastExpr(const CXXDynamicCastExpr *S) { 705 VisitCXXNamedCastExpr(S); 706} 707 708void 709StmtProfiler::VisitCXXReinterpretCastExpr(const CXXReinterpretCastExpr *S) { 710 VisitCXXNamedCastExpr(S); 711} 712 713void StmtProfiler::VisitCXXConstCastExpr(const CXXConstCastExpr *S) { 714 VisitCXXNamedCastExpr(S); 715} 716 717void StmtProfiler::VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *S) { 718 VisitExpr(S); 719 ID.AddBoolean(S->getValue()); 720} 721 722void StmtProfiler::VisitCXXNullPtrLiteralExpr(const CXXNullPtrLiteralExpr *S) { 723 VisitExpr(S); 724} 725 726void StmtProfiler::VisitCXXTypeidExpr(const CXXTypeidExpr *S) { 727 VisitExpr(S); 728 if (S->isTypeOperand()) 729 VisitType(S->getTypeOperand()); 730} 731 732void StmtProfiler::VisitCXXUuidofExpr(const CXXUuidofExpr *S) { 733 VisitExpr(S); 734 if (S->isTypeOperand()) 735 VisitType(S->getTypeOperand()); 736} 737 738void StmtProfiler::VisitCXXThisExpr(const CXXThisExpr *S) { 739 VisitExpr(S); 740} 741 742void StmtProfiler::VisitCXXThrowExpr(const CXXThrowExpr *S) { 743 VisitExpr(S); 744} 745 746void StmtProfiler::VisitCXXDefaultArgExpr(const CXXDefaultArgExpr *S) { 747 VisitExpr(S); 748 VisitDecl(S->getParam()); 749} 750 751void StmtProfiler::VisitCXXBindTemporaryExpr(const CXXBindTemporaryExpr *S) { 752 VisitExpr(S); 753 VisitDecl( 754 const_cast<CXXDestructorDecl *>(S->getTemporary()->getDestructor())); 755} 756 757void StmtProfiler::VisitCXXConstructExpr(const CXXConstructExpr *S) { 758 VisitExpr(S); 759 VisitDecl(S->getConstructor()); 760 ID.AddBoolean(S->isElidable()); 761} 762 763void StmtProfiler::VisitCXXFunctionalCastExpr(const CXXFunctionalCastExpr *S) { 764 VisitExplicitCastExpr(S); 765} 766 767void 768StmtProfiler::VisitCXXTemporaryObjectExpr(const CXXTemporaryObjectExpr *S) { 769 VisitCXXConstructExpr(S); 770} 771 772void 773StmtProfiler::VisitCXXScalarValueInitExpr(const CXXScalarValueInitExpr *S) { 774 VisitExpr(S); 775} 776 777void StmtProfiler::VisitCXXDeleteExpr(const CXXDeleteExpr *S) { 778 VisitExpr(S); 779 ID.AddBoolean(S->isGlobalDelete()); 780 ID.AddBoolean(S->isArrayForm()); 781 VisitDecl(S->getOperatorDelete()); 782} 783 784 785void StmtProfiler::VisitCXXNewExpr(const CXXNewExpr *S) { 786 VisitExpr(S); 787 VisitType(S->getAllocatedType()); 788 VisitDecl(S->getOperatorNew()); 789 VisitDecl(S->getOperatorDelete()); 790 VisitDecl(S->getConstructor()); 791 ID.AddBoolean(S->isArray()); 792 ID.AddInteger(S->getNumPlacementArgs()); 793 ID.AddBoolean(S->isGlobalNew()); 794 ID.AddBoolean(S->isParenTypeId()); 795 ID.AddBoolean(S->hasInitializer()); 796 ID.AddInteger(S->getNumConstructorArgs()); 797} 798 799void 800StmtProfiler::VisitCXXPseudoDestructorExpr(const CXXPseudoDestructorExpr *S) { 801 VisitExpr(S); 802 ID.AddBoolean(S->isArrow()); 803 VisitNestedNameSpecifier(S->getQualifier()); 804 VisitType(S->getDestroyedType()); 805} 806 807void StmtProfiler::VisitOverloadExpr(const OverloadExpr *S) { 808 VisitExpr(S); 809 VisitNestedNameSpecifier(S->getQualifier()); 810 VisitName(S->getName()); 811 ID.AddBoolean(S->hasExplicitTemplateArgs()); 812 if (S->hasExplicitTemplateArgs()) 813 VisitTemplateArguments(S->getExplicitTemplateArgs().getTemplateArgs(), 814 S->getExplicitTemplateArgs().NumTemplateArgs); 815} 816 817void 818StmtProfiler::VisitUnresolvedLookupExpr(const UnresolvedLookupExpr *S) { 819 VisitOverloadExpr(S); 820} 821 822void StmtProfiler::VisitUnaryTypeTraitExpr(const UnaryTypeTraitExpr *S) { 823 VisitExpr(S); 824 ID.AddInteger(S->getTrait()); 825 VisitType(S->getQueriedType()); 826} 827 828void StmtProfiler::VisitBinaryTypeTraitExpr(const BinaryTypeTraitExpr *S) { 829 VisitExpr(S); 830 ID.AddInteger(S->getTrait()); 831 VisitType(S->getLhsType()); 832 VisitType(S->getRhsType()); 833} 834 835void StmtProfiler::VisitArrayTypeTraitExpr(const ArrayTypeTraitExpr *S) { 836 VisitExpr(S); 837 ID.AddInteger(S->getTrait()); 838 VisitType(S->getQueriedType()); 839} 840 841void StmtProfiler::VisitExpressionTraitExpr(const ExpressionTraitExpr *S) { 842 VisitExpr(S); 843 ID.AddInteger(S->getTrait()); 844 VisitExpr(S->getQueriedExpression()); 845} 846 847void StmtProfiler::VisitDependentScopeDeclRefExpr( 848 const DependentScopeDeclRefExpr *S) { 849 VisitExpr(S); 850 VisitName(S->getDeclName()); 851 VisitNestedNameSpecifier(S->getQualifier()); 852 ID.AddBoolean(S->hasExplicitTemplateArgs()); 853 if (S->hasExplicitTemplateArgs()) 854 VisitTemplateArguments(S->getTemplateArgs(), S->getNumTemplateArgs()); 855} 856 857void StmtProfiler::VisitExprWithCleanups(const ExprWithCleanups *S) { 858 VisitExpr(S); 859} 860 861void StmtProfiler::VisitCXXUnresolvedConstructExpr( 862 const CXXUnresolvedConstructExpr *S) { 863 VisitExpr(S); 864 VisitType(S->getTypeAsWritten()); 865} 866 867void StmtProfiler::VisitCXXDependentScopeMemberExpr( 868 const CXXDependentScopeMemberExpr *S) { 869 ID.AddBoolean(S->isImplicitAccess()); 870 if (!S->isImplicitAccess()) { 871 VisitExpr(S); 872 ID.AddBoolean(S->isArrow()); 873 } 874 VisitNestedNameSpecifier(S->getQualifier()); 875 VisitName(S->getMember()); 876 ID.AddBoolean(S->hasExplicitTemplateArgs()); 877 if (S->hasExplicitTemplateArgs()) 878 VisitTemplateArguments(S->getTemplateArgs(), S->getNumTemplateArgs()); 879} 880 881void StmtProfiler::VisitUnresolvedMemberExpr(const UnresolvedMemberExpr *S) { 882 ID.AddBoolean(S->isImplicitAccess()); 883 if (!S->isImplicitAccess()) { 884 VisitExpr(S); 885 ID.AddBoolean(S->isArrow()); 886 } 887 VisitNestedNameSpecifier(S->getQualifier()); 888 VisitName(S->getMemberName()); 889 ID.AddBoolean(S->hasExplicitTemplateArgs()); 890 if (S->hasExplicitTemplateArgs()) 891 VisitTemplateArguments(S->getTemplateArgs(), S->getNumTemplateArgs()); 892} 893 894void StmtProfiler::VisitCXXNoexceptExpr(const CXXNoexceptExpr *S) { 895 VisitExpr(S); 896} 897 898void StmtProfiler::VisitPackExpansionExpr(const PackExpansionExpr *S) { 899 VisitExpr(S); 900} 901 902void StmtProfiler::VisitSizeOfPackExpr(const SizeOfPackExpr *S) { 903 VisitExpr(S); 904 VisitDecl(S->getPack()); 905} 906 907void StmtProfiler::VisitSubstNonTypeTemplateParmPackExpr( 908 const SubstNonTypeTemplateParmPackExpr *S) { 909 VisitExpr(S); 910 VisitDecl(S->getParameterPack()); 911 VisitTemplateArgument(S->getArgumentPack()); 912} 913 914void StmtProfiler::VisitOpaqueValueExpr(const OpaqueValueExpr *E) { 915 VisitExpr(E); 916} 917 918void StmtProfiler::VisitObjCStringLiteral(const ObjCStringLiteral *S) { 919 VisitExpr(S); 920} 921 922void StmtProfiler::VisitObjCEncodeExpr(const ObjCEncodeExpr *S) { 923 VisitExpr(S); 924 VisitType(S->getEncodedType()); 925} 926 927void StmtProfiler::VisitObjCSelectorExpr(const ObjCSelectorExpr *S) { 928 VisitExpr(S); 929 VisitName(S->getSelector()); 930} 931 932void StmtProfiler::VisitObjCProtocolExpr(const ObjCProtocolExpr *S) { 933 VisitExpr(S); 934 VisitDecl(S->getProtocol()); 935} 936 937void StmtProfiler::VisitObjCIvarRefExpr(const ObjCIvarRefExpr *S) { 938 VisitExpr(S); 939 VisitDecl(S->getDecl()); 940 ID.AddBoolean(S->isArrow()); 941 ID.AddBoolean(S->isFreeIvar()); 942} 943 944void StmtProfiler::VisitObjCPropertyRefExpr(const ObjCPropertyRefExpr *S) { 945 VisitExpr(S); 946 if (S->isImplicitProperty()) { 947 VisitDecl(S->getImplicitPropertyGetter()); 948 VisitDecl(S->getImplicitPropertySetter()); 949 } else { 950 VisitDecl(S->getExplicitProperty()); 951 } 952 if (S->isSuperReceiver()) { 953 ID.AddBoolean(S->isSuperReceiver()); 954 VisitType(S->getSuperReceiverType()); 955 } 956} 957 958void StmtProfiler::VisitObjCMessageExpr(const ObjCMessageExpr *S) { 959 VisitExpr(S); 960 VisitName(S->getSelector()); 961 VisitDecl(S->getMethodDecl()); 962} 963 964void StmtProfiler::VisitObjCIsaExpr(const ObjCIsaExpr *S) { 965 VisitExpr(S); 966 ID.AddBoolean(S->isArrow()); 967} 968 969void StmtProfiler::VisitObjCIndirectCopyRestoreExpr( 970 const ObjCIndirectCopyRestoreExpr *S) { 971 VisitExpr(S); 972 ID.AddBoolean(S->shouldCopy()); 973} 974 975void StmtProfiler::VisitObjCBridgedCastExpr(const ObjCBridgedCastExpr *S) { 976 VisitExplicitCastExpr(S); 977 ID.AddBoolean(S->getBridgeKind()); 978} 979 980void StmtProfiler::VisitDecl(const Decl *D) { 981 ID.AddInteger(D? D->getKind() : 0); 982 983 if (Canonical && D) { 984 if (const NonTypeTemplateParmDecl *NTTP = 985 dyn_cast<NonTypeTemplateParmDecl>(D)) { 986 ID.AddInteger(NTTP->getDepth()); 987 ID.AddInteger(NTTP->getIndex()); 988 ID.AddBoolean(NTTP->isParameterPack()); 989 VisitType(NTTP->getType()); 990 return; 991 } 992 993 if (const ParmVarDecl *Parm = dyn_cast<ParmVarDecl>(D)) { 994 // The Itanium C++ ABI uses the type, scope depth, and scope 995 // index of a parameter when mangling expressions that involve 996 // function parameters, so we will use the parameter's type for 997 // establishing function parameter identity. That way, our 998 // definition of "equivalent" (per C++ [temp.over.link]) is at 999 // least as strong as the definition of "equivalent" used for 1000 // name mangling. 1001 VisitType(Parm->getType()); 1002 ID.AddInteger(Parm->getFunctionScopeDepth()); 1003 ID.AddInteger(Parm->getFunctionScopeIndex()); 1004 return; 1005 } 1006 1007 if (const TemplateTemplateParmDecl *TTP = 1008 dyn_cast<TemplateTemplateParmDecl>(D)) { 1009 ID.AddInteger(TTP->getDepth()); 1010 ID.AddInteger(TTP->getIndex()); 1011 ID.AddBoolean(TTP->isParameterPack()); 1012 return; 1013 } 1014 } 1015 1016 ID.AddPointer(D? D->getCanonicalDecl() : 0); 1017} 1018 1019void StmtProfiler::VisitType(QualType T) { 1020 if (Canonical) 1021 T = Context.getCanonicalType(T); 1022 1023 ID.AddPointer(T.getAsOpaquePtr()); 1024} 1025 1026void StmtProfiler::VisitName(DeclarationName Name) { 1027 ID.AddPointer(Name.getAsOpaquePtr()); 1028} 1029 1030void StmtProfiler::VisitNestedNameSpecifier(NestedNameSpecifier *NNS) { 1031 if (Canonical) 1032 NNS = Context.getCanonicalNestedNameSpecifier(NNS); 1033 ID.AddPointer(NNS); 1034} 1035 1036void StmtProfiler::VisitTemplateName(TemplateName Name) { 1037 if (Canonical) 1038 Name = Context.getCanonicalTemplateName(Name); 1039 1040 Name.Profile(ID); 1041} 1042 1043void StmtProfiler::VisitTemplateArguments(const TemplateArgumentLoc *Args, 1044 unsigned NumArgs) { 1045 ID.AddInteger(NumArgs); 1046 for (unsigned I = 0; I != NumArgs; ++I) 1047 VisitTemplateArgument(Args[I].getArgument()); 1048} 1049 1050void StmtProfiler::VisitTemplateArgument(const TemplateArgument &Arg) { 1051 // Mostly repetitive with TemplateArgument::Profile! 1052 ID.AddInteger(Arg.getKind()); 1053 switch (Arg.getKind()) { 1054 case TemplateArgument::Null: 1055 break; 1056 1057 case TemplateArgument::Type: 1058 VisitType(Arg.getAsType()); 1059 break; 1060 1061 case TemplateArgument::Template: 1062 case TemplateArgument::TemplateExpansion: 1063 VisitTemplateName(Arg.getAsTemplateOrTemplatePattern()); 1064 break; 1065 1066 case TemplateArgument::Declaration: 1067 VisitDecl(Arg.getAsDecl()); 1068 break; 1069 1070 case TemplateArgument::Integral: 1071 Arg.getAsIntegral()->Profile(ID); 1072 VisitType(Arg.getIntegralType()); 1073 break; 1074 1075 case TemplateArgument::Expression: 1076 Visit(Arg.getAsExpr()); 1077 break; 1078 1079 case TemplateArgument::Pack: 1080 const TemplateArgument *Pack = Arg.pack_begin(); 1081 for (unsigned i = 0, e = Arg.pack_size(); i != e; ++i) 1082 VisitTemplateArgument(Pack[i]); 1083 break; 1084 } 1085} 1086 1087void Stmt::Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context, 1088 bool Canonical) const { 1089 StmtProfiler Profiler(ID, Context, Canonical); 1090 Profiler.Visit(this); 1091} 1092