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