StmtProfile.cpp revision 243830
1189251Ssam//===---- StmtProfile.cpp - Profile implementation for Stmt ASTs ----------===// 2189251Ssam// 3214734Srpaulo// The LLVM Compiler Infrastructure 4189251Ssam// 5189251Ssam// This file is distributed under the University of Illinois Open Source 6189251Ssam// License. See LICENSE.TXT for details. 7189251Ssam// 8189251Ssam//===----------------------------------------------------------------------===// 9189251Ssam// 10189251Ssam// This file implements the Stmt::Profile method, which builds a unique bit 11189251Ssam// representation that identifies a statement/expression. 12189251Ssam// 13189251Ssam//===----------------------------------------------------------------------===// 14189251Ssam#include "clang/AST/ASTContext.h" 15189251Ssam#include "clang/AST/DeclCXX.h" 16189251Ssam#include "clang/AST/DeclObjC.h" 17189251Ssam#include "clang/AST/DeclTemplate.h" 18189251Ssam#include "clang/AST/Expr.h" 19189251Ssam#include "clang/AST/ExprCXX.h" 20189251Ssam#include "clang/AST/ExprObjC.h" 21189251Ssam#include "clang/AST/StmtVisitor.h" 22189251Ssam#include "llvm/ADT/FoldingSet.h" 23189251Ssamusing namespace clang; 24189251Ssam 25189251Ssamnamespace { 26189251Ssam class StmtProfiler : public ConstStmtVisitor<StmtProfiler> { 27189251Ssam llvm::FoldingSetNodeID &ID; 28189251Ssam const ASTContext &Context; 29189251Ssam bool Canonical; 30189251Ssam 31189251Ssam public: 32189251Ssam StmtProfiler(llvm::FoldingSetNodeID &ID, const ASTContext &Context, 33189251Ssam bool Canonical) 34189251Ssam : ID(ID), Context(Context), Canonical(Canonical) { } 35189251Ssam 36189251Ssam void VisitStmt(const Stmt *S); 37189251Ssam 38189251Ssam#define STMT(Node, Base) void Visit##Node(const Node *S); 39189251Ssam#include "clang/AST/StmtNodes.inc" 40189251Ssam 41189251Ssam /// \brief Visit a declaration that is referenced within an expression 42189251Ssam /// or statement. 43189251Ssam void VisitDecl(const Decl *D); 44189251Ssam 45189251Ssam /// \brief Visit a type that is referenced within an expression or 46189251Ssam /// statement. 47189251Ssam void VisitType(QualType T); 48189251Ssam 49189251Ssam /// \brief Visit a name that occurs within an expression or statement. 50189251Ssam void VisitName(DeclarationName Name); 51189251Ssam 52189251Ssam /// \brief Visit a nested-name-specifier that occurs within an expression 53189251Ssam /// or statement. 54189251Ssam void VisitNestedNameSpecifier(NestedNameSpecifier *NNS); 55189251Ssam 56189251Ssam /// \brief Visit a template name that occurs within an expression or 57189251Ssam /// statement. 58189251Ssam void VisitTemplateName(TemplateName Name); 59189251Ssam 60189251Ssam /// \brief Visit template arguments that occur within an expression or 61189251Ssam /// statement. 62189251Ssam void VisitTemplateArguments(const TemplateArgumentLoc *Args, 63189251Ssam unsigned NumArgs); 64189251Ssam 65189251Ssam /// \brief Visit a single template argument. 66189251Ssam void VisitTemplateArgument(const TemplateArgument &Arg); 67189251Ssam }; 68189251Ssam} 69189251Ssam 70189251Ssamvoid StmtProfiler::VisitStmt(const Stmt *S) { 71189251Ssam ID.AddInteger(S->getStmtClass()); 72189251Ssam for (Stmt::const_child_range C = S->children(); C; ++C) { 73189251Ssam if (*C) 74189251Ssam Visit(*C); 75189251Ssam else 76189251Ssam ID.AddInteger(0); 77189251Ssam } 78189251Ssam} 79189251Ssam 80189251Ssamvoid StmtProfiler::VisitDeclStmt(const DeclStmt *S) { 81189251Ssam VisitStmt(S); 82189251Ssam for (DeclStmt::const_decl_iterator D = S->decl_begin(), DEnd = S->decl_end(); 83189251Ssam D != DEnd; ++D) 84189251Ssam VisitDecl(*D); 85189251Ssam} 86189251Ssam 87189251Ssamvoid StmtProfiler::VisitNullStmt(const NullStmt *S) { 88189251Ssam VisitStmt(S); 89189251Ssam} 90189251Ssam 91189251Ssamvoid StmtProfiler::VisitCompoundStmt(const CompoundStmt *S) { 92189251Ssam VisitStmt(S); 93189251Ssam} 94189251Ssam 95189251Ssamvoid StmtProfiler::VisitSwitchCase(const SwitchCase *S) { 96189251Ssam VisitStmt(S); 97189251Ssam} 98189251Ssam 99189251Ssamvoid StmtProfiler::VisitCaseStmt(const CaseStmt *S) { 100189251Ssam VisitStmt(S); 101189251Ssam} 102189251Ssam 103189251Ssamvoid StmtProfiler::VisitDefaultStmt(const DefaultStmt *S) { 104189251Ssam VisitStmt(S); 105189251Ssam} 106189251Ssam 107189251Ssamvoid StmtProfiler::VisitLabelStmt(const LabelStmt *S) { 108189251Ssam VisitStmt(S); 109189251Ssam VisitDecl(S->getDecl()); 110189251Ssam} 111189251Ssam 112189251Ssamvoid StmtProfiler::VisitAttributedStmt(const AttributedStmt *S) { 113189251Ssam VisitStmt(S); 114189251Ssam // TODO: maybe visit attributes? 115189251Ssam} 116189251Ssam 117189251Ssamvoid StmtProfiler::VisitIfStmt(const IfStmt *S) { 118189251Ssam VisitStmt(S); 119214734Srpaulo VisitDecl(S->getConditionVariable()); 120189251Ssam} 121189251Ssam 122189251Ssamvoid StmtProfiler::VisitSwitchStmt(const SwitchStmt *S) { 123214734Srpaulo VisitStmt(S); 124214734Srpaulo VisitDecl(S->getConditionVariable()); 125214734Srpaulo} 126189251Ssam 127189251Ssamvoid StmtProfiler::VisitWhileStmt(const WhileStmt *S) { 128189251Ssam VisitStmt(S); 129189251Ssam VisitDecl(S->getConditionVariable()); 130189251Ssam} 131189251Ssam 132189251Ssamvoid StmtProfiler::VisitDoStmt(const DoStmt *S) { 133189251Ssam VisitStmt(S); 134189251Ssam} 135189251Ssam 136189251Ssamvoid StmtProfiler::VisitForStmt(const ForStmt *S) { 137189251Ssam VisitStmt(S); 138189251Ssam} 139189251Ssam 140189251Ssamvoid StmtProfiler::VisitGotoStmt(const GotoStmt *S) { 141209158Srpaulo VisitStmt(S); 142209158Srpaulo VisitDecl(S->getLabel()); 143209158Srpaulo} 144189251Ssam 145189251Ssamvoid StmtProfiler::VisitIndirectGotoStmt(const IndirectGotoStmt *S) { 146189251Ssam VisitStmt(S); 147189251Ssam} 148189251Ssam 149189251Ssamvoid StmtProfiler::VisitContinueStmt(const ContinueStmt *S) { 150189251Ssam VisitStmt(S); 151189251Ssam} 152189251Ssam 153189251Ssamvoid StmtProfiler::VisitBreakStmt(const BreakStmt *S) { 154189251Ssam VisitStmt(S); 155189251Ssam} 156189251Ssam 157189251Ssamvoid StmtProfiler::VisitReturnStmt(const ReturnStmt *S) { 158189251Ssam VisitStmt(S); 159189251Ssam} 160189251Ssam 161189251Ssamvoid StmtProfiler::VisitGCCAsmStmt(const GCCAsmStmt *S) { 162189251Ssam VisitStmt(S); 163189251Ssam ID.AddBoolean(S->isVolatile()); 164189251Ssam ID.AddBoolean(S->isSimple()); 165189251Ssam VisitStringLiteral(S->getAsmString()); 166189251Ssam ID.AddInteger(S->getNumOutputs()); 167189251Ssam for (unsigned I = 0, N = S->getNumOutputs(); I != N; ++I) { 168189251Ssam ID.AddString(S->getOutputName(I)); 169189251Ssam VisitStringLiteral(S->getOutputConstraintLiteral(I)); 170189251Ssam } 171189251Ssam ID.AddInteger(S->getNumInputs()); 172189251Ssam for (unsigned I = 0, N = S->getNumInputs(); I != N; ++I) { 173189251Ssam ID.AddString(S->getInputName(I)); 174189251Ssam VisitStringLiteral(S->getInputConstraintLiteral(I)); 175189251Ssam } 176189251Ssam ID.AddInteger(S->getNumClobbers()); 177189251Ssam for (unsigned I = 0, N = S->getNumClobbers(); I != N; ++I) 178189251Ssam VisitStringLiteral(S->getClobberStringLiteral(I)); 179189251Ssam} 180189251Ssam 181189251Ssamvoid StmtProfiler::VisitMSAsmStmt(const MSAsmStmt *S) { 182189251Ssam // FIXME: Implement MS style inline asm statement profiler. 183189251Ssam VisitStmt(S); 184189251Ssam} 185189251Ssam 186189251Ssamvoid StmtProfiler::VisitCXXCatchStmt(const CXXCatchStmt *S) { 187189251Ssam VisitStmt(S); 188189251Ssam VisitType(S->getCaughtType()); 189189251Ssam} 190189251Ssam 191189251Ssamvoid StmtProfiler::VisitCXXTryStmt(const CXXTryStmt *S) { 192189251Ssam VisitStmt(S); 193189251Ssam} 194189251Ssam 195189251Ssamvoid StmtProfiler::VisitCXXForRangeStmt(const CXXForRangeStmt *S) { 196189251Ssam VisitStmt(S); 197189251Ssam} 198189251Ssam 199189251Ssamvoid StmtProfiler::VisitMSDependentExistsStmt(const MSDependentExistsStmt *S) { 200189251Ssam VisitStmt(S); 201189251Ssam ID.AddBoolean(S->isIfExists()); 202189251Ssam VisitNestedNameSpecifier(S->getQualifierLoc().getNestedNameSpecifier()); 203189251Ssam VisitName(S->getNameInfo().getName()); 204189251Ssam} 205189251Ssam 206189251Ssamvoid StmtProfiler::VisitSEHTryStmt(const SEHTryStmt *S) { 207189251Ssam VisitStmt(S); 208189251Ssam} 209189251Ssam 210189251Ssamvoid StmtProfiler::VisitSEHFinallyStmt(const SEHFinallyStmt *S) { 211189251Ssam VisitStmt(S); 212189251Ssam} 213189251Ssam 214189251Ssamvoid StmtProfiler::VisitSEHExceptStmt(const SEHExceptStmt *S) { 215189251Ssam VisitStmt(S); 216189251Ssam} 217209158Srpaulo 218189251Ssamvoid StmtProfiler::VisitObjCForCollectionStmt(const ObjCForCollectionStmt *S) { 219189251Ssam VisitStmt(S); 220209158Srpaulo} 221189251Ssam 222209158Srpaulovoid StmtProfiler::VisitObjCAtCatchStmt(const ObjCAtCatchStmt *S) { 223189251Ssam VisitStmt(S); 224209158Srpaulo ID.AddBoolean(S->hasEllipsis()); 225189251Ssam if (S->getCatchParamDecl()) 226189251Ssam VisitType(S->getCatchParamDecl()->getType()); 227189251Ssam} 228209158Srpaulo 229189251Ssamvoid StmtProfiler::VisitObjCAtFinallyStmt(const ObjCAtFinallyStmt *S) { 230189251Ssam VisitStmt(S); 231189251Ssam} 232189251Ssam 233189251Ssamvoid StmtProfiler::VisitObjCAtTryStmt(const ObjCAtTryStmt *S) { 234189251Ssam VisitStmt(S); 235189251Ssam} 236189251Ssam 237189251Ssamvoid 238189251SsamStmtProfiler::VisitObjCAtSynchronizedStmt(const ObjCAtSynchronizedStmt *S) { 239189251Ssam VisitStmt(S); 240214734Srpaulo} 241214734Srpaulo 242214734Srpaulovoid StmtProfiler::VisitObjCAtThrowStmt(const ObjCAtThrowStmt *S) { 243214734Srpaulo VisitStmt(S); 244214734Srpaulo} 245214734Srpaulo 246214734Srpaulovoid 247214734SrpauloStmtProfiler::VisitObjCAutoreleasePoolStmt(const ObjCAutoreleasePoolStmt *S) { 248214734Srpaulo VisitStmt(S); 249214734Srpaulo} 250214734Srpaulo 251214734Srpaulovoid StmtProfiler::VisitExpr(const Expr *S) { 252214734Srpaulo VisitStmt(S); 253214734Srpaulo} 254214734Srpaulo 255214734Srpaulovoid StmtProfiler::VisitDeclRefExpr(const DeclRefExpr *S) { 256214734Srpaulo VisitExpr(S); 257214734Srpaulo if (!Canonical) 258214734Srpaulo VisitNestedNameSpecifier(S->getQualifier()); 259189251Ssam VisitDecl(S->getDecl()); 260189251Ssam if (!Canonical) 261189251Ssam VisitTemplateArguments(S->getTemplateArgs(), S->getNumTemplateArgs()); 262189251Ssam} 263189251Ssam 264189251Ssamvoid StmtProfiler::VisitPredefinedExpr(const PredefinedExpr *S) { 265189251Ssam VisitExpr(S); 266189251Ssam ID.AddInteger(S->getIdentType()); 267189251Ssam} 268189251Ssam 269189251Ssamvoid StmtProfiler::VisitIntegerLiteral(const IntegerLiteral *S) { 270189251Ssam VisitExpr(S); 271189251Ssam S->getValue().Profile(ID); 272189251Ssam} 273189251Ssam 274189251Ssamvoid StmtProfiler::VisitCharacterLiteral(const CharacterLiteral *S) { 275189251Ssam VisitExpr(S); 276189251Ssam ID.AddInteger(S->getKind()); 277189251Ssam ID.AddInteger(S->getValue()); 278189251Ssam} 279189251Ssam 280189251Ssamvoid StmtProfiler::VisitFloatingLiteral(const FloatingLiteral *S) { 281189251Ssam VisitExpr(S); 282189251Ssam S->getValue().Profile(ID); 283189251Ssam ID.AddBoolean(S->isExact()); 284189251Ssam} 285189251Ssam 286189251Ssamvoid StmtProfiler::VisitImaginaryLiteral(const ImaginaryLiteral *S) { 287189251Ssam VisitExpr(S); 288189251Ssam} 289189251Ssam 290189251Ssamvoid StmtProfiler::VisitStringLiteral(const StringLiteral *S) { 291189251Ssam VisitExpr(S); 292189251Ssam ID.AddString(S->getBytes()); 293189251Ssam ID.AddInteger(S->getKind()); 294189251Ssam} 295189251Ssam 296189251Ssamvoid StmtProfiler::VisitParenExpr(const ParenExpr *S) { 297189251Ssam VisitExpr(S); 298189251Ssam} 299189251Ssam 300189251Ssamvoid StmtProfiler::VisitParenListExpr(const ParenListExpr *S) { 301189251Ssam VisitExpr(S); 302189251Ssam} 303189251Ssam 304189251Ssamvoid StmtProfiler::VisitUnaryOperator(const UnaryOperator *S) { 305189251Ssam VisitExpr(S); 306189251Ssam ID.AddInteger(S->getOpcode()); 307189251Ssam} 308189251Ssam 309189251Ssamvoid StmtProfiler::VisitOffsetOfExpr(const OffsetOfExpr *S) { 310189251Ssam VisitType(S->getTypeSourceInfo()->getType()); 311189251Ssam unsigned n = S->getNumComponents(); 312189251Ssam for (unsigned i = 0; i < n; ++i) { 313189251Ssam const OffsetOfExpr::OffsetOfNode& ON = S->getComponent(i); 314189251Ssam ID.AddInteger(ON.getKind()); 315189251Ssam switch (ON.getKind()) { 316189251Ssam case OffsetOfExpr::OffsetOfNode::Array: 317189251Ssam // Expressions handled below. 318189251Ssam break; 319189251Ssam 320189251Ssam case OffsetOfExpr::OffsetOfNode::Field: 321189251Ssam VisitDecl(ON.getField()); 322189251Ssam break; 323189251Ssam 324189251Ssam case OffsetOfExpr::OffsetOfNode::Identifier: 325189251Ssam ID.AddPointer(ON.getFieldName()); 326189251Ssam break; 327189251Ssam 328209158Srpaulo case OffsetOfExpr::OffsetOfNode::Base: 329189251Ssam // These nodes are implicit, and therefore don't need profiling. 330189251Ssam break; 331189251Ssam } 332189251Ssam } 333189251Ssam 334189251Ssam VisitExpr(S); 335189251Ssam} 336189251Ssam 337189251Ssamvoid 338189251SsamStmtProfiler::VisitUnaryExprOrTypeTraitExpr(const UnaryExprOrTypeTraitExpr *S) { 339189251Ssam VisitExpr(S); 340189251Ssam ID.AddInteger(S->getKind()); 341189251Ssam if (S->isArgumentType()) 342189251Ssam VisitType(S->getArgumentType()); 343189251Ssam} 344189251Ssam 345189251Ssamvoid StmtProfiler::VisitArraySubscriptExpr(const ArraySubscriptExpr *S) { 346189251Ssam VisitExpr(S); 347189251Ssam} 348189251Ssam 349189251Ssamvoid StmtProfiler::VisitCallExpr(const CallExpr *S) { 350189251Ssam VisitExpr(S); 351189251Ssam} 352189251Ssam 353189251Ssamvoid StmtProfiler::VisitMemberExpr(const MemberExpr *S) { 354189251Ssam VisitExpr(S); 355189251Ssam VisitDecl(S->getMemberDecl()); 356189251Ssam if (!Canonical) 357189251Ssam VisitNestedNameSpecifier(S->getQualifier()); 358189251Ssam ID.AddBoolean(S->isArrow()); 359189251Ssam} 360189251Ssam 361189251Ssamvoid StmtProfiler::VisitCompoundLiteralExpr(const CompoundLiteralExpr *S) { 362189251Ssam VisitExpr(S); 363189251Ssam ID.AddBoolean(S->isFileScope()); 364214734Srpaulo} 365214734Srpaulo 366214734Srpaulovoid StmtProfiler::VisitCastExpr(const CastExpr *S) { 367189251Ssam VisitExpr(S); 368214734Srpaulo} 369214734Srpaulo 370214734Srpaulovoid StmtProfiler::VisitImplicitCastExpr(const ImplicitCastExpr *S) { 371189251Ssam VisitCastExpr(S); 372189251Ssam ID.AddInteger(S->getValueKind()); 373189251Ssam} 374189251Ssam 375189251Ssamvoid StmtProfiler::VisitExplicitCastExpr(const ExplicitCastExpr *S) { 376189251Ssam VisitCastExpr(S); 377189251Ssam VisitType(S->getTypeAsWritten()); 378189251Ssam} 379189251Ssam 380189251Ssamvoid StmtProfiler::VisitCStyleCastExpr(const CStyleCastExpr *S) { 381189251Ssam VisitExplicitCastExpr(S); 382214734Srpaulo} 383214734Srpaulo 384214734Srpaulovoid StmtProfiler::VisitBinaryOperator(const BinaryOperator *S) { 385189251Ssam VisitExpr(S); 386214734Srpaulo ID.AddInteger(S->getOpcode()); 387214734Srpaulo} 388214734Srpaulo 389189251Ssamvoid 390189251SsamStmtProfiler::VisitCompoundAssignOperator(const CompoundAssignOperator *S) { 391189251Ssam VisitBinaryOperator(S); 392189251Ssam} 393189251Ssam 394189251Ssamvoid StmtProfiler::VisitConditionalOperator(const ConditionalOperator *S) { 395189251Ssam VisitExpr(S); 396189251Ssam} 397189251Ssam 398189251Ssamvoid StmtProfiler::VisitBinaryConditionalOperator( 399189251Ssam const BinaryConditionalOperator *S) { 400189251Ssam VisitExpr(S); 401189251Ssam} 402189251Ssam 403189251Ssamvoid StmtProfiler::VisitAddrLabelExpr(const AddrLabelExpr *S) { 404189251Ssam VisitExpr(S); 405189251Ssam VisitDecl(S->getLabel()); 406189251Ssam} 407189251Ssam 408189251Ssamvoid StmtProfiler::VisitStmtExpr(const StmtExpr *S) { 409189251Ssam VisitExpr(S); 410189251Ssam} 411189251Ssam 412189251Ssamvoid StmtProfiler::VisitShuffleVectorExpr(const ShuffleVectorExpr *S) { 413189251Ssam VisitExpr(S); 414189251Ssam} 415189251Ssam 416189251Ssamvoid StmtProfiler::VisitChooseExpr(const ChooseExpr *S) { 417189251Ssam VisitExpr(S); 418189251Ssam} 419189251Ssam 420189251Ssamvoid StmtProfiler::VisitGNUNullExpr(const GNUNullExpr *S) { 421189251Ssam VisitExpr(S); 422189251Ssam} 423189251Ssam 424189251Ssamvoid StmtProfiler::VisitVAArgExpr(const VAArgExpr *S) { 425189251Ssam VisitExpr(S); 426189251Ssam} 427189251Ssam 428189251Ssamvoid StmtProfiler::VisitInitListExpr(const InitListExpr *S) { 429189251Ssam if (S->getSyntacticForm()) { 430189251Ssam VisitInitListExpr(S->getSyntacticForm()); 431189251Ssam return; 432189251Ssam } 433189251Ssam 434189251Ssam VisitExpr(S); 435189251Ssam} 436189251Ssam 437189251Ssamvoid StmtProfiler::VisitDesignatedInitExpr(const DesignatedInitExpr *S) { 438189251Ssam VisitExpr(S); 439189251Ssam ID.AddBoolean(S->usesGNUSyntax()); 440189251Ssam for (DesignatedInitExpr::const_designators_iterator D = 441189251Ssam S->designators_begin(), DEnd = S->designators_end(); 442189251Ssam D != DEnd; ++D) { 443189251Ssam if (D->isFieldDesignator()) { 444189251Ssam ID.AddInteger(0); 445189251Ssam VisitName(D->getFieldName()); 446189251Ssam continue; 447189251Ssam } 448189251Ssam 449189251Ssam if (D->isArrayDesignator()) { 450189251Ssam ID.AddInteger(1); 451189251Ssam } else { 452189251Ssam assert(D->isArrayRangeDesignator()); 453189251Ssam ID.AddInteger(2); 454189251Ssam } 455189251Ssam ID.AddInteger(D->getFirstExprIndex()); 456214734Srpaulo } 457214734Srpaulo} 458214734Srpaulo 459214734Srpaulovoid StmtProfiler::VisitImplicitValueInitExpr(const ImplicitValueInitExpr *S) { 460214734Srpaulo VisitExpr(S); 461214734Srpaulo} 462189251Ssam 463189251Ssamvoid StmtProfiler::VisitExtVectorElementExpr(const ExtVectorElementExpr *S) { 464189251Ssam VisitExpr(S); 465189251Ssam VisitName(&S->getAccessor()); 466189251Ssam} 467189251Ssam 468189251Ssamvoid StmtProfiler::VisitBlockExpr(const BlockExpr *S) { 469189251Ssam VisitExpr(S); 470189251Ssam VisitDecl(S->getBlockDecl()); 471189251Ssam} 472189251Ssam 473189251Ssamvoid StmtProfiler::VisitGenericSelectionExpr(const GenericSelectionExpr *S) { 474189251Ssam VisitExpr(S); 475189251Ssam for (unsigned i = 0; i != S->getNumAssocs(); ++i) { 476189251Ssam QualType T = S->getAssocType(i); 477189251Ssam if (T.isNull()) 478189251Ssam ID.AddPointer(0); 479214734Srpaulo else 480214734Srpaulo VisitType(T); 481189251Ssam VisitExpr(S->getAssocExpr(i)); 482209158Srpaulo } 483209158Srpaulo} 484209158Srpaulo 485209158Srpaulovoid StmtProfiler::VisitPseudoObjectExpr(const PseudoObjectExpr *S) { 486209158Srpaulo VisitExpr(S); 487189251Ssam for (PseudoObjectExpr::const_semantics_iterator 488209158Srpaulo i = S->semantics_begin(), e = S->semantics_end(); i != e; ++i) 489209158Srpaulo // Normally, we would not profile the source expressions of OVEs. 490209158Srpaulo if (const OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(*i)) 491189251Ssam Visit(OVE->getSourceExpr()); 492209158Srpaulo} 493209158Srpaulo 494209158Srpaulovoid StmtProfiler::VisitAtomicExpr(const AtomicExpr *S) { 495209158Srpaulo VisitExpr(S); 496209158Srpaulo ID.AddInteger(S->getOp()); 497189251Ssam} 498209158Srpaulo 499209158Srpaulostatic Stmt::StmtClass DecodeOperatorCall(const CXXOperatorCallExpr *S, 500209158Srpaulo UnaryOperatorKind &UnaryOp, 501209158Srpaulo BinaryOperatorKind &BinaryOp) { 502209158Srpaulo switch (S->getOperator()) { 503189251Ssam case OO_None: 504214734Srpaulo case OO_New: 505214734Srpaulo case OO_Delete: 506214734Srpaulo case OO_Array_New: 507214734Srpaulo case OO_Array_Delete: 508214734Srpaulo case OO_Arrow: 509214734Srpaulo case OO_Call: 510214734Srpaulo case OO_Conditional: 511214734Srpaulo case NUM_OVERLOADED_OPERATORS: 512214734Srpaulo llvm_unreachable("Invalid operator call kind"); 513214734Srpaulo 514214734Srpaulo case OO_Plus: 515214734Srpaulo if (S->getNumArgs() == 1) { 516189251Ssam UnaryOp = UO_Plus; 517214734Srpaulo return Stmt::UnaryOperatorClass; 518214734Srpaulo } 519214734Srpaulo 520214734Srpaulo BinaryOp = BO_Add; 521214734Srpaulo return Stmt::BinaryOperatorClass; 522214734Srpaulo 523214734Srpaulo case OO_Minus: 524214734Srpaulo if (S->getNumArgs() == 1) { 525214734Srpaulo UnaryOp = UO_Minus; 526214734Srpaulo return Stmt::UnaryOperatorClass; 527214734Srpaulo } 528214734Srpaulo 529214734Srpaulo BinaryOp = BO_Sub; 530214734Srpaulo return Stmt::BinaryOperatorClass; 531214734Srpaulo 532214734Srpaulo case OO_Star: 533214734Srpaulo if (S->getNumArgs() == 1) { 534214734Srpaulo UnaryOp = UO_Minus; 535214734Srpaulo return Stmt::UnaryOperatorClass; 536214734Srpaulo } 537214734Srpaulo 538214734Srpaulo BinaryOp = BO_Sub; 539214734Srpaulo return Stmt::BinaryOperatorClass; 540214734Srpaulo 541214734Srpaulo case OO_Slash: 542214734Srpaulo BinaryOp = BO_Div; 543214734Srpaulo return Stmt::BinaryOperatorClass; 544214734Srpaulo 545214734Srpaulo case OO_Percent: 546214734Srpaulo BinaryOp = BO_Rem; 547214734Srpaulo return Stmt::BinaryOperatorClass; 548214734Srpaulo 549214734Srpaulo case OO_Caret: 550214734Srpaulo BinaryOp = BO_Xor; 551214734Srpaulo return Stmt::BinaryOperatorClass; 552214734Srpaulo 553214734Srpaulo case OO_Amp: 554214734Srpaulo if (S->getNumArgs() == 1) { 555214734Srpaulo UnaryOp = UO_AddrOf; 556214734Srpaulo return Stmt::UnaryOperatorClass; 557214734Srpaulo } 558214734Srpaulo 559214734Srpaulo BinaryOp = BO_And; 560214734Srpaulo return Stmt::BinaryOperatorClass; 561214734Srpaulo 562214734Srpaulo case OO_Pipe: 563214734Srpaulo BinaryOp = BO_Or; 564214734Srpaulo return Stmt::BinaryOperatorClass; 565214734Srpaulo 566214734Srpaulo case OO_Tilde: 567214734Srpaulo UnaryOp = UO_Not; 568214734Srpaulo return Stmt::UnaryOperatorClass; 569214734Srpaulo 570214734Srpaulo case OO_Exclaim: 571214734Srpaulo UnaryOp = UO_LNot; 572214734Srpaulo return Stmt::UnaryOperatorClass; 573214734Srpaulo 574214734Srpaulo case OO_Equal: 575214734Srpaulo BinaryOp = BO_Assign; 576214734Srpaulo return Stmt::BinaryOperatorClass; 577214734Srpaulo 578214734Srpaulo case OO_Less: 579214734Srpaulo BinaryOp = BO_LT; 580214734Srpaulo return Stmt::BinaryOperatorClass; 581214734Srpaulo 582214734Srpaulo case OO_Greater: 583214734Srpaulo BinaryOp = BO_GT; 584214734Srpaulo return Stmt::BinaryOperatorClass; 585214734Srpaulo 586214734Srpaulo case OO_PlusEqual: 587214734Srpaulo BinaryOp = BO_AddAssign; 588214734Srpaulo return Stmt::CompoundAssignOperatorClass; 589214734Srpaulo 590189251Ssam case OO_MinusEqual: 591189251Ssam BinaryOp = BO_SubAssign; 592189251Ssam return Stmt::CompoundAssignOperatorClass; 593189251Ssam 594214734Srpaulo case OO_StarEqual: 595214734Srpaulo BinaryOp = BO_MulAssign; 596214734Srpaulo return Stmt::CompoundAssignOperatorClass; 597214734Srpaulo 598214734Srpaulo case OO_SlashEqual: 599214734Srpaulo BinaryOp = BO_DivAssign; 600214734Srpaulo return Stmt::CompoundAssignOperatorClass; 601214734Srpaulo 602214734Srpaulo case OO_PercentEqual: 603214734Srpaulo BinaryOp = BO_RemAssign; 604214734Srpaulo return Stmt::CompoundAssignOperatorClass; 605214734Srpaulo 606214734Srpaulo case OO_CaretEqual: 607189251Ssam BinaryOp = BO_XorAssign; 608 return Stmt::CompoundAssignOperatorClass; 609 610 case OO_AmpEqual: 611 BinaryOp = BO_AndAssign; 612 return Stmt::CompoundAssignOperatorClass; 613 614 case OO_PipeEqual: 615 BinaryOp = BO_OrAssign; 616 return Stmt::CompoundAssignOperatorClass; 617 618 case OO_LessLess: 619 BinaryOp = BO_Shl; 620 return Stmt::BinaryOperatorClass; 621 622 case OO_GreaterGreater: 623 BinaryOp = BO_Shr; 624 return Stmt::BinaryOperatorClass; 625 626 case OO_LessLessEqual: 627 BinaryOp = BO_ShlAssign; 628 return Stmt::CompoundAssignOperatorClass; 629 630 case OO_GreaterGreaterEqual: 631 BinaryOp = BO_ShrAssign; 632 return Stmt::CompoundAssignOperatorClass; 633 634 case OO_EqualEqual: 635 BinaryOp = BO_EQ; 636 return Stmt::BinaryOperatorClass; 637 638 case OO_ExclaimEqual: 639 BinaryOp = BO_NE; 640 return Stmt::BinaryOperatorClass; 641 642 case OO_LessEqual: 643 BinaryOp = BO_LE; 644 return Stmt::BinaryOperatorClass; 645 646 case OO_GreaterEqual: 647 BinaryOp = BO_GE; 648 return Stmt::BinaryOperatorClass; 649 650 case OO_AmpAmp: 651 BinaryOp = BO_LAnd; 652 return Stmt::BinaryOperatorClass; 653 654 case OO_PipePipe: 655 BinaryOp = BO_LOr; 656 return Stmt::BinaryOperatorClass; 657 658 case OO_PlusPlus: 659 UnaryOp = S->getNumArgs() == 1? UO_PreInc 660 : UO_PostInc; 661 return Stmt::UnaryOperatorClass; 662 663 case OO_MinusMinus: 664 UnaryOp = S->getNumArgs() == 1? UO_PreDec 665 : UO_PostDec; 666 return Stmt::UnaryOperatorClass; 667 668 case OO_Comma: 669 BinaryOp = BO_Comma; 670 return Stmt::BinaryOperatorClass; 671 672 673 case OO_ArrowStar: 674 BinaryOp = BO_PtrMemI; 675 return Stmt::BinaryOperatorClass; 676 677 case OO_Subscript: 678 return Stmt::ArraySubscriptExprClass; 679 } 680 681 llvm_unreachable("Invalid overloaded operator expression"); 682} 683 684 685void StmtProfiler::VisitCXXOperatorCallExpr(const CXXOperatorCallExpr *S) { 686 if (S->isTypeDependent()) { 687 // Type-dependent operator calls are profiled like their underlying 688 // syntactic operator. 689 UnaryOperatorKind UnaryOp = UO_Extension; 690 BinaryOperatorKind BinaryOp = BO_Comma; 691 Stmt::StmtClass SC = DecodeOperatorCall(S, UnaryOp, BinaryOp); 692 693 ID.AddInteger(SC); 694 for (unsigned I = 0, N = S->getNumArgs(); I != N; ++I) 695 Visit(S->getArg(I)); 696 if (SC == Stmt::UnaryOperatorClass) 697 ID.AddInteger(UnaryOp); 698 else if (SC == Stmt::BinaryOperatorClass || 699 SC == Stmt::CompoundAssignOperatorClass) 700 ID.AddInteger(BinaryOp); 701 else 702 assert(SC == Stmt::ArraySubscriptExprClass); 703 704 return; 705 } 706 707 VisitCallExpr(S); 708 ID.AddInteger(S->getOperator()); 709} 710 711void StmtProfiler::VisitCXXMemberCallExpr(const CXXMemberCallExpr *S) { 712 VisitCallExpr(S); 713} 714 715void StmtProfiler::VisitCUDAKernelCallExpr(const CUDAKernelCallExpr *S) { 716 VisitCallExpr(S); 717} 718 719void StmtProfiler::VisitAsTypeExpr(const AsTypeExpr *S) { 720 VisitExpr(S); 721} 722 723void StmtProfiler::VisitCXXNamedCastExpr(const CXXNamedCastExpr *S) { 724 VisitExplicitCastExpr(S); 725} 726 727void StmtProfiler::VisitCXXStaticCastExpr(const CXXStaticCastExpr *S) { 728 VisitCXXNamedCastExpr(S); 729} 730 731void StmtProfiler::VisitCXXDynamicCastExpr(const CXXDynamicCastExpr *S) { 732 VisitCXXNamedCastExpr(S); 733} 734 735void 736StmtProfiler::VisitCXXReinterpretCastExpr(const CXXReinterpretCastExpr *S) { 737 VisitCXXNamedCastExpr(S); 738} 739 740void StmtProfiler::VisitCXXConstCastExpr(const CXXConstCastExpr *S) { 741 VisitCXXNamedCastExpr(S); 742} 743 744void StmtProfiler::VisitUserDefinedLiteral(const UserDefinedLiteral *S) { 745 VisitCallExpr(S); 746} 747 748void StmtProfiler::VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *S) { 749 VisitExpr(S); 750 ID.AddBoolean(S->getValue()); 751} 752 753void StmtProfiler::VisitCXXNullPtrLiteralExpr(const CXXNullPtrLiteralExpr *S) { 754 VisitExpr(S); 755} 756 757void StmtProfiler::VisitCXXTypeidExpr(const CXXTypeidExpr *S) { 758 VisitExpr(S); 759 if (S->isTypeOperand()) 760 VisitType(S->getTypeOperand()); 761} 762 763void StmtProfiler::VisitCXXUuidofExpr(const CXXUuidofExpr *S) { 764 VisitExpr(S); 765 if (S->isTypeOperand()) 766 VisitType(S->getTypeOperand()); 767} 768 769void StmtProfiler::VisitCXXThisExpr(const CXXThisExpr *S) { 770 VisitExpr(S); 771 ID.AddBoolean(S->isImplicit()); 772} 773 774void StmtProfiler::VisitCXXThrowExpr(const CXXThrowExpr *S) { 775 VisitExpr(S); 776} 777 778void StmtProfiler::VisitCXXDefaultArgExpr(const CXXDefaultArgExpr *S) { 779 VisitExpr(S); 780 VisitDecl(S->getParam()); 781} 782 783void StmtProfiler::VisitCXXBindTemporaryExpr(const CXXBindTemporaryExpr *S) { 784 VisitExpr(S); 785 VisitDecl( 786 const_cast<CXXDestructorDecl *>(S->getTemporary()->getDestructor())); 787} 788 789void StmtProfiler::VisitCXXConstructExpr(const CXXConstructExpr *S) { 790 VisitExpr(S); 791 VisitDecl(S->getConstructor()); 792 ID.AddBoolean(S->isElidable()); 793} 794 795void StmtProfiler::VisitCXXFunctionalCastExpr(const CXXFunctionalCastExpr *S) { 796 VisitExplicitCastExpr(S); 797} 798 799void 800StmtProfiler::VisitCXXTemporaryObjectExpr(const CXXTemporaryObjectExpr *S) { 801 VisitCXXConstructExpr(S); 802} 803 804void 805StmtProfiler::VisitLambdaExpr(const LambdaExpr *S) { 806 VisitExpr(S); 807 for (LambdaExpr::capture_iterator C = S->explicit_capture_begin(), 808 CEnd = S->explicit_capture_end(); 809 C != CEnd; ++C) { 810 ID.AddInteger(C->getCaptureKind()); 811 if (C->capturesVariable()) { 812 VisitDecl(C->getCapturedVar()); 813 ID.AddBoolean(C->isPackExpansion()); 814 } 815 } 816 // Note: If we actually needed to be able to match lambda 817 // expressions, we would have to consider parameters and return type 818 // here, among other things. 819 VisitStmt(S->getBody()); 820} 821 822void 823StmtProfiler::VisitCXXScalarValueInitExpr(const CXXScalarValueInitExpr *S) { 824 VisitExpr(S); 825} 826 827void StmtProfiler::VisitCXXDeleteExpr(const CXXDeleteExpr *S) { 828 VisitExpr(S); 829 ID.AddBoolean(S->isGlobalDelete()); 830 ID.AddBoolean(S->isArrayForm()); 831 VisitDecl(S->getOperatorDelete()); 832} 833 834 835void StmtProfiler::VisitCXXNewExpr(const CXXNewExpr *S) { 836 VisitExpr(S); 837 VisitType(S->getAllocatedType()); 838 VisitDecl(S->getOperatorNew()); 839 VisitDecl(S->getOperatorDelete()); 840 ID.AddBoolean(S->isArray()); 841 ID.AddInteger(S->getNumPlacementArgs()); 842 ID.AddBoolean(S->isGlobalNew()); 843 ID.AddBoolean(S->isParenTypeId()); 844 ID.AddInteger(S->getInitializationStyle()); 845} 846 847void 848StmtProfiler::VisitCXXPseudoDestructorExpr(const CXXPseudoDestructorExpr *S) { 849 VisitExpr(S); 850 ID.AddBoolean(S->isArrow()); 851 VisitNestedNameSpecifier(S->getQualifier()); 852 VisitType(S->getDestroyedType()); 853} 854 855void StmtProfiler::VisitOverloadExpr(const OverloadExpr *S) { 856 VisitExpr(S); 857 VisitNestedNameSpecifier(S->getQualifier()); 858 VisitName(S->getName()); 859 ID.AddBoolean(S->hasExplicitTemplateArgs()); 860 if (S->hasExplicitTemplateArgs()) 861 VisitTemplateArguments(S->getExplicitTemplateArgs().getTemplateArgs(), 862 S->getExplicitTemplateArgs().NumTemplateArgs); 863} 864 865void 866StmtProfiler::VisitUnresolvedLookupExpr(const UnresolvedLookupExpr *S) { 867 VisitOverloadExpr(S); 868} 869 870void StmtProfiler::VisitUnaryTypeTraitExpr(const UnaryTypeTraitExpr *S) { 871 VisitExpr(S); 872 ID.AddInteger(S->getTrait()); 873 VisitType(S->getQueriedType()); 874} 875 876void StmtProfiler::VisitBinaryTypeTraitExpr(const BinaryTypeTraitExpr *S) { 877 VisitExpr(S); 878 ID.AddInteger(S->getTrait()); 879 VisitType(S->getLhsType()); 880 VisitType(S->getRhsType()); 881} 882 883void StmtProfiler::VisitTypeTraitExpr(const TypeTraitExpr *S) { 884 VisitExpr(S); 885 ID.AddInteger(S->getTrait()); 886 ID.AddInteger(S->getNumArgs()); 887 for (unsigned I = 0, N = S->getNumArgs(); I != N; ++I) 888 VisitType(S->getArg(I)->getType()); 889} 890 891void StmtProfiler::VisitArrayTypeTraitExpr(const ArrayTypeTraitExpr *S) { 892 VisitExpr(S); 893 ID.AddInteger(S->getTrait()); 894 VisitType(S->getQueriedType()); 895} 896 897void StmtProfiler::VisitExpressionTraitExpr(const ExpressionTraitExpr *S) { 898 VisitExpr(S); 899 ID.AddInteger(S->getTrait()); 900 VisitExpr(S->getQueriedExpression()); 901} 902 903void StmtProfiler::VisitDependentScopeDeclRefExpr( 904 const DependentScopeDeclRefExpr *S) { 905 VisitExpr(S); 906 VisitName(S->getDeclName()); 907 VisitNestedNameSpecifier(S->getQualifier()); 908 ID.AddBoolean(S->hasExplicitTemplateArgs()); 909 if (S->hasExplicitTemplateArgs()) 910 VisitTemplateArguments(S->getTemplateArgs(), S->getNumTemplateArgs()); 911} 912 913void StmtProfiler::VisitExprWithCleanups(const ExprWithCleanups *S) { 914 VisitExpr(S); 915} 916 917void StmtProfiler::VisitCXXUnresolvedConstructExpr( 918 const CXXUnresolvedConstructExpr *S) { 919 VisitExpr(S); 920 VisitType(S->getTypeAsWritten()); 921} 922 923void StmtProfiler::VisitCXXDependentScopeMemberExpr( 924 const CXXDependentScopeMemberExpr *S) { 925 ID.AddBoolean(S->isImplicitAccess()); 926 if (!S->isImplicitAccess()) { 927 VisitExpr(S); 928 ID.AddBoolean(S->isArrow()); 929 } 930 VisitNestedNameSpecifier(S->getQualifier()); 931 VisitName(S->getMember()); 932 ID.AddBoolean(S->hasExplicitTemplateArgs()); 933 if (S->hasExplicitTemplateArgs()) 934 VisitTemplateArguments(S->getTemplateArgs(), S->getNumTemplateArgs()); 935} 936 937void StmtProfiler::VisitUnresolvedMemberExpr(const UnresolvedMemberExpr *S) { 938 ID.AddBoolean(S->isImplicitAccess()); 939 if (!S->isImplicitAccess()) { 940 VisitExpr(S); 941 ID.AddBoolean(S->isArrow()); 942 } 943 VisitNestedNameSpecifier(S->getQualifier()); 944 VisitName(S->getMemberName()); 945 ID.AddBoolean(S->hasExplicitTemplateArgs()); 946 if (S->hasExplicitTemplateArgs()) 947 VisitTemplateArguments(S->getTemplateArgs(), S->getNumTemplateArgs()); 948} 949 950void StmtProfiler::VisitCXXNoexceptExpr(const CXXNoexceptExpr *S) { 951 VisitExpr(S); 952} 953 954void StmtProfiler::VisitPackExpansionExpr(const PackExpansionExpr *S) { 955 VisitExpr(S); 956} 957 958void StmtProfiler::VisitSizeOfPackExpr(const SizeOfPackExpr *S) { 959 VisitExpr(S); 960 VisitDecl(S->getPack()); 961} 962 963void StmtProfiler::VisitSubstNonTypeTemplateParmPackExpr( 964 const SubstNonTypeTemplateParmPackExpr *S) { 965 VisitExpr(S); 966 VisitDecl(S->getParameterPack()); 967 VisitTemplateArgument(S->getArgumentPack()); 968} 969 970void StmtProfiler::VisitSubstNonTypeTemplateParmExpr( 971 const SubstNonTypeTemplateParmExpr *E) { 972 // Profile exactly as the replacement expression. 973 Visit(E->getReplacement()); 974} 975 976void StmtProfiler::VisitFunctionParmPackExpr(const FunctionParmPackExpr *S) { 977 VisitExpr(S); 978 VisitDecl(S->getParameterPack()); 979 ID.AddInteger(S->getNumExpansions()); 980 for (FunctionParmPackExpr::iterator I = S->begin(), E = S->end(); I != E; ++I) 981 VisitDecl(*I); 982} 983 984void StmtProfiler::VisitMaterializeTemporaryExpr( 985 const MaterializeTemporaryExpr *S) { 986 VisitExpr(S); 987} 988 989void StmtProfiler::VisitOpaqueValueExpr(const OpaqueValueExpr *E) { 990 VisitExpr(E); 991} 992 993void StmtProfiler::VisitObjCStringLiteral(const ObjCStringLiteral *S) { 994 VisitExpr(S); 995} 996 997void StmtProfiler::VisitObjCBoxedExpr(const ObjCBoxedExpr *E) { 998 VisitExpr(E); 999} 1000 1001void StmtProfiler::VisitObjCArrayLiteral(const ObjCArrayLiteral *E) { 1002 VisitExpr(E); 1003} 1004 1005void StmtProfiler::VisitObjCDictionaryLiteral(const ObjCDictionaryLiteral *E) { 1006 VisitExpr(E); 1007} 1008 1009void StmtProfiler::VisitObjCEncodeExpr(const ObjCEncodeExpr *S) { 1010 VisitExpr(S); 1011 VisitType(S->getEncodedType()); 1012} 1013 1014void StmtProfiler::VisitObjCSelectorExpr(const ObjCSelectorExpr *S) { 1015 VisitExpr(S); 1016 VisitName(S->getSelector()); 1017} 1018 1019void StmtProfiler::VisitObjCProtocolExpr(const ObjCProtocolExpr *S) { 1020 VisitExpr(S); 1021 VisitDecl(S->getProtocol()); 1022} 1023 1024void StmtProfiler::VisitObjCIvarRefExpr(const ObjCIvarRefExpr *S) { 1025 VisitExpr(S); 1026 VisitDecl(S->getDecl()); 1027 ID.AddBoolean(S->isArrow()); 1028 ID.AddBoolean(S->isFreeIvar()); 1029} 1030 1031void StmtProfiler::VisitObjCPropertyRefExpr(const ObjCPropertyRefExpr *S) { 1032 VisitExpr(S); 1033 if (S->isImplicitProperty()) { 1034 VisitDecl(S->getImplicitPropertyGetter()); 1035 VisitDecl(S->getImplicitPropertySetter()); 1036 } else { 1037 VisitDecl(S->getExplicitProperty()); 1038 } 1039 if (S->isSuperReceiver()) { 1040 ID.AddBoolean(S->isSuperReceiver()); 1041 VisitType(S->getSuperReceiverType()); 1042 } 1043} 1044 1045void StmtProfiler::VisitObjCSubscriptRefExpr(const ObjCSubscriptRefExpr *S) { 1046 VisitExpr(S); 1047 VisitDecl(S->getAtIndexMethodDecl()); 1048 VisitDecl(S->setAtIndexMethodDecl()); 1049} 1050 1051void StmtProfiler::VisitObjCMessageExpr(const ObjCMessageExpr *S) { 1052 VisitExpr(S); 1053 VisitName(S->getSelector()); 1054 VisitDecl(S->getMethodDecl()); 1055} 1056 1057void StmtProfiler::VisitObjCIsaExpr(const ObjCIsaExpr *S) { 1058 VisitExpr(S); 1059 ID.AddBoolean(S->isArrow()); 1060} 1061 1062void StmtProfiler::VisitObjCBoolLiteralExpr(const ObjCBoolLiteralExpr *S) { 1063 VisitExpr(S); 1064 ID.AddBoolean(S->getValue()); 1065} 1066 1067void StmtProfiler::VisitObjCIndirectCopyRestoreExpr( 1068 const ObjCIndirectCopyRestoreExpr *S) { 1069 VisitExpr(S); 1070 ID.AddBoolean(S->shouldCopy()); 1071} 1072 1073void StmtProfiler::VisitObjCBridgedCastExpr(const ObjCBridgedCastExpr *S) { 1074 VisitExplicitCastExpr(S); 1075 ID.AddBoolean(S->getBridgeKind()); 1076} 1077 1078void StmtProfiler::VisitDecl(const Decl *D) { 1079 ID.AddInteger(D? D->getKind() : 0); 1080 1081 if (Canonical && D) { 1082 if (const NonTypeTemplateParmDecl *NTTP = 1083 dyn_cast<NonTypeTemplateParmDecl>(D)) { 1084 ID.AddInteger(NTTP->getDepth()); 1085 ID.AddInteger(NTTP->getIndex()); 1086 ID.AddBoolean(NTTP->isParameterPack()); 1087 VisitType(NTTP->getType()); 1088 return; 1089 } 1090 1091 if (const ParmVarDecl *Parm = dyn_cast<ParmVarDecl>(D)) { 1092 // The Itanium C++ ABI uses the type, scope depth, and scope 1093 // index of a parameter when mangling expressions that involve 1094 // function parameters, so we will use the parameter's type for 1095 // establishing function parameter identity. That way, our 1096 // definition of "equivalent" (per C++ [temp.over.link]) is at 1097 // least as strong as the definition of "equivalent" used for 1098 // name mangling. 1099 VisitType(Parm->getType()); 1100 ID.AddInteger(Parm->getFunctionScopeDepth()); 1101 ID.AddInteger(Parm->getFunctionScopeIndex()); 1102 return; 1103 } 1104 1105 if (const TemplateTypeParmDecl *TTP = 1106 dyn_cast<TemplateTypeParmDecl>(D)) { 1107 ID.AddInteger(TTP->getDepth()); 1108 ID.AddInteger(TTP->getIndex()); 1109 ID.AddBoolean(TTP->isParameterPack()); 1110 return; 1111 } 1112 1113 if (const TemplateTemplateParmDecl *TTP = 1114 dyn_cast<TemplateTemplateParmDecl>(D)) { 1115 ID.AddInteger(TTP->getDepth()); 1116 ID.AddInteger(TTP->getIndex()); 1117 ID.AddBoolean(TTP->isParameterPack()); 1118 return; 1119 } 1120 } 1121 1122 ID.AddPointer(D? D->getCanonicalDecl() : 0); 1123} 1124 1125void StmtProfiler::VisitType(QualType T) { 1126 if (Canonical) 1127 T = Context.getCanonicalType(T); 1128 1129 ID.AddPointer(T.getAsOpaquePtr()); 1130} 1131 1132void StmtProfiler::VisitName(DeclarationName Name) { 1133 ID.AddPointer(Name.getAsOpaquePtr()); 1134} 1135 1136void StmtProfiler::VisitNestedNameSpecifier(NestedNameSpecifier *NNS) { 1137 if (Canonical) 1138 NNS = Context.getCanonicalNestedNameSpecifier(NNS); 1139 ID.AddPointer(NNS); 1140} 1141 1142void StmtProfiler::VisitTemplateName(TemplateName Name) { 1143 if (Canonical) 1144 Name = Context.getCanonicalTemplateName(Name); 1145 1146 Name.Profile(ID); 1147} 1148 1149void StmtProfiler::VisitTemplateArguments(const TemplateArgumentLoc *Args, 1150 unsigned NumArgs) { 1151 ID.AddInteger(NumArgs); 1152 for (unsigned I = 0; I != NumArgs; ++I) 1153 VisitTemplateArgument(Args[I].getArgument()); 1154} 1155 1156void StmtProfiler::VisitTemplateArgument(const TemplateArgument &Arg) { 1157 // Mostly repetitive with TemplateArgument::Profile! 1158 ID.AddInteger(Arg.getKind()); 1159 switch (Arg.getKind()) { 1160 case TemplateArgument::Null: 1161 break; 1162 1163 case TemplateArgument::Type: 1164 VisitType(Arg.getAsType()); 1165 break; 1166 1167 case TemplateArgument::Template: 1168 case TemplateArgument::TemplateExpansion: 1169 VisitTemplateName(Arg.getAsTemplateOrTemplatePattern()); 1170 break; 1171 1172 case TemplateArgument::Declaration: 1173 VisitDecl(Arg.getAsDecl()); 1174 break; 1175 1176 case TemplateArgument::NullPtr: 1177 VisitType(Arg.getNullPtrType()); 1178 break; 1179 1180 case TemplateArgument::Integral: 1181 Arg.getAsIntegral().Profile(ID); 1182 VisitType(Arg.getIntegralType()); 1183 break; 1184 1185 case TemplateArgument::Expression: 1186 Visit(Arg.getAsExpr()); 1187 break; 1188 1189 case TemplateArgument::Pack: 1190 const TemplateArgument *Pack = Arg.pack_begin(); 1191 for (unsigned i = 0, e = Arg.pack_size(); i != e; ++i) 1192 VisitTemplateArgument(Pack[i]); 1193 break; 1194 } 1195} 1196 1197void Stmt::Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context, 1198 bool Canonical) const { 1199 StmtProfiler Profiler(ID, Context, Canonical); 1200 Profiler.Visit(this); 1201} 1202