lib/AST/StmtProfile.cpp

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