StmtProfile.cpp revision 360660 
1//===---- StmtProfile.cpp - Profile implementation for Stmt ASTs ----------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements the Stmt::Profile method, which builds a unique bit
10// representation that identifies a statement/expression.
11//
12//===----------------------------------------------------------------------===//
13#include "clang/AST/ASTContext.h"
14#include "clang/AST/DeclCXX.h"
15#include "clang/AST/DeclObjC.h"
16#include "clang/AST/DeclTemplate.h"
17#include "clang/AST/Expr.h"
18#include "clang/AST/ExprCXX.h"
19#include "clang/AST/ExprObjC.h"
20#include "clang/AST/ExprOpenMP.h"
21#include "clang/AST/ODRHash.h"
22#include "clang/AST/StmtVisitor.h"
23#include "llvm/ADT/FoldingSet.h"
24using namespace clang;
25
26namespace {
27  class StmtProfiler : public ConstStmtVisitor<StmtProfiler> {
28  protected:
29    llvm::FoldingSetNodeID &ID;
30    bool Canonical;
31
32  public:
33    StmtProfiler(llvm::FoldingSetNodeID &ID, bool Canonical)
34        : ID(ID), Canonical(Canonical) {}
35
36    virtual ~StmtProfiler() {}
37
38    void VisitStmt(const Stmt *S);
39
40    virtual void HandleStmtClass(Stmt::StmtClass SC) = 0;
41
42#define STMT(Node, Base) void Visit##Node(const Node *S);
43#include "clang/AST/StmtNodes.inc"
44
45    /// Visit a declaration that is referenced within an expression
46    /// or statement.
47    virtual void VisitDecl(const Decl *D) = 0;
48
49    /// Visit a type that is referenced within an expression or
50    /// statement.
51    virtual void VisitType(QualType T) = 0;
52
53    /// Visit a name that occurs within an expression or statement.
54    virtual void VisitName(DeclarationName Name, bool TreatAsDecl = false) = 0;
55
56    /// Visit identifiers that are not in Decl's or Type's.
57    virtual void VisitIdentifierInfo(IdentifierInfo *II) = 0;
58
59    /// Visit a nested-name-specifier that occurs within an expression
60    /// or statement.
61    virtual void VisitNestedNameSpecifier(NestedNameSpecifier *NNS) = 0;
62
63    /// Visit a template name that occurs within an expression or
64    /// statement.
65    virtual void VisitTemplateName(TemplateName Name) = 0;
66
67    /// Visit template arguments that occur within an expression or
68    /// statement.
69    void VisitTemplateArguments(const TemplateArgumentLoc *Args,
70                                unsigned NumArgs);
71
72    /// Visit a single template argument.
73    void VisitTemplateArgument(const TemplateArgument &Arg);
74  };
75
76  class StmtProfilerWithPointers : public StmtProfiler {
77    const ASTContext &Context;
78
79  public:
80    StmtProfilerWithPointers(llvm::FoldingSetNodeID &ID,
81                             const ASTContext &Context, bool Canonical)
82        : StmtProfiler(ID, Canonical), Context(Context) {}
83  private:
84    void HandleStmtClass(Stmt::StmtClass SC) override {
85      ID.AddInteger(SC);
86    }
87
88    void VisitDecl(const Decl *D) override {
89      ID.AddInteger(D ? D->getKind() : 0);
90
91      if (Canonical && D) {
92        if (const NonTypeTemplateParmDecl *NTTP =
93                dyn_cast<NonTypeTemplateParmDecl>(D)) {
94          ID.AddInteger(NTTP->getDepth());
95          ID.AddInteger(NTTP->getIndex());
96          ID.AddBoolean(NTTP->isParameterPack());
97          VisitType(NTTP->getType());
98          return;
99        }
100
101        if (const ParmVarDecl *Parm = dyn_cast<ParmVarDecl>(D)) {
102          // The Itanium C++ ABI uses the type, scope depth, and scope
103          // index of a parameter when mangling expressions that involve
104          // function parameters, so we will use the parameter's type for
105          // establishing function parameter identity. That way, our
106          // definition of "equivalent" (per C++ [temp.over.link]) is at
107          // least as strong as the definition of "equivalent" used for
108          // name mangling.
109          VisitType(Parm->getType());
110          ID.AddInteger(Parm->getFunctionScopeDepth());
111          ID.AddInteger(Parm->getFunctionScopeIndex());
112          return;
113        }
114
115        if (const TemplateTypeParmDecl *TTP =
116                dyn_cast<TemplateTypeParmDecl>(D)) {
117          ID.AddInteger(TTP->getDepth());
118          ID.AddInteger(TTP->getIndex());
119          ID.AddBoolean(TTP->isParameterPack());
120          return;
121        }
122
123        if (const TemplateTemplateParmDecl *TTP =
124                dyn_cast<TemplateTemplateParmDecl>(D)) {
125          ID.AddInteger(TTP->getDepth());
126          ID.AddInteger(TTP->getIndex());
127          ID.AddBoolean(TTP->isParameterPack());
128          return;
129        }
130      }
131
132      ID.AddPointer(D ? D->getCanonicalDecl() : nullptr);
133    }
134
135    void VisitType(QualType T) override {
136      if (Canonical && !T.isNull())
137        T = Context.getCanonicalType(T);
138
139      ID.AddPointer(T.getAsOpaquePtr());
140    }
141
142    void VisitName(DeclarationName Name, bool /*TreatAsDecl*/) override {
143      ID.AddPointer(Name.getAsOpaquePtr());
144    }
145
146    void VisitIdentifierInfo(IdentifierInfo *II) override {
147      ID.AddPointer(II);
148    }
149
150    void VisitNestedNameSpecifier(NestedNameSpecifier *NNS) override {
151      if (Canonical)
152        NNS = Context.getCanonicalNestedNameSpecifier(NNS);
153      ID.AddPointer(NNS);
154    }
155
156    void VisitTemplateName(TemplateName Name) override {
157      if (Canonical)
158        Name = Context.getCanonicalTemplateName(Name);
159
160      Name.Profile(ID);
161    }
162  };
163
164  class StmtProfilerWithoutPointers : public StmtProfiler {
165    ODRHash &Hash;
166  public:
167    StmtProfilerWithoutPointers(llvm::FoldingSetNodeID &ID, ODRHash &Hash)
168        : StmtProfiler(ID, false), Hash(Hash) {}
169
170  private:
171    void HandleStmtClass(Stmt::StmtClass SC) override {
172      if (SC == Stmt::UnresolvedLookupExprClass) {
173        // Pretend that the name looked up is a Decl due to how templates
174        // handle some Decl lookups.
175        ID.AddInteger(Stmt::DeclRefExprClass);
176      } else {
177        ID.AddInteger(SC);
178      }
179    }
180
181    void VisitType(QualType T) override {
182      Hash.AddQualType(T);
183    }
184
185    void VisitName(DeclarationName Name, bool TreatAsDecl) override {
186      if (TreatAsDecl) {
187        // A Decl can be null, so each Decl is preceded by a boolean to
188        // store its nullness.  Add a boolean here to match.
189        ID.AddBoolean(true);
190      }
191      Hash.AddDeclarationName(Name, TreatAsDecl);
192    }
193    void VisitIdentifierInfo(IdentifierInfo *II) override {
194      ID.AddBoolean(II);
195      if (II) {
196        Hash.AddIdentifierInfo(II);
197      }
198    }
199    void VisitDecl(const Decl *D) override {
200      ID.AddBoolean(D);
201      if (D) {
202        Hash.AddDecl(D);
203      }
204    }
205    void VisitTemplateName(TemplateName Name) override {
206      Hash.AddTemplateName(Name);
207    }
208    void VisitNestedNameSpecifier(NestedNameSpecifier *NNS) override {
209      ID.AddBoolean(NNS);
210      if (NNS) {
211        Hash.AddNestedNameSpecifier(NNS);
212      }
213    }
214  };
215}
216
217void StmtProfiler::VisitStmt(const Stmt *S) {
218  assert(S && "Requires non-null Stmt pointer");
219
220  HandleStmtClass(S->getStmtClass());
221
222  for (const Stmt *SubStmt : S->children()) {
223    if (SubStmt)
224      Visit(SubStmt);
225    else
226      ID.AddInteger(0);
227  }
228}
229
230void StmtProfiler::VisitDeclStmt(const DeclStmt *S) {
231  VisitStmt(S);
232  for (const auto *D : S->decls())
233    VisitDecl(D);
234}
235
236void StmtProfiler::VisitNullStmt(const NullStmt *S) {
237  VisitStmt(S);
238}
239
240void StmtProfiler::VisitCompoundStmt(const CompoundStmt *S) {
241  VisitStmt(S);
242}
243
244void StmtProfiler::VisitCaseStmt(const CaseStmt *S) {
245  VisitStmt(S);
246}
247
248void StmtProfiler::VisitDefaultStmt(const DefaultStmt *S) {
249  VisitStmt(S);
250}
251
252void StmtProfiler::VisitLabelStmt(const LabelStmt *S) {
253  VisitStmt(S);
254  VisitDecl(S->getDecl());
255}
256
257void StmtProfiler::VisitAttributedStmt(const AttributedStmt *S) {
258  VisitStmt(S);
259  // TODO: maybe visit attributes?
260}
261
262void StmtProfiler::VisitIfStmt(const IfStmt *S) {
263  VisitStmt(S);
264  VisitDecl(S->getConditionVariable());
265}
266
267void StmtProfiler::VisitSwitchStmt(const SwitchStmt *S) {
268  VisitStmt(S);
269  VisitDecl(S->getConditionVariable());
270}
271
272void StmtProfiler::VisitWhileStmt(const WhileStmt *S) {
273  VisitStmt(S);
274  VisitDecl(S->getConditionVariable());
275}
276
277void StmtProfiler::VisitDoStmt(const DoStmt *S) {
278  VisitStmt(S);
279}
280
281void StmtProfiler::VisitForStmt(const ForStmt *S) {
282  VisitStmt(S);
283}
284
285void StmtProfiler::VisitGotoStmt(const GotoStmt *S) {
286  VisitStmt(S);
287  VisitDecl(S->getLabel());
288}
289
290void StmtProfiler::VisitIndirectGotoStmt(const IndirectGotoStmt *S) {
291  VisitStmt(S);
292}
293
294void StmtProfiler::VisitContinueStmt(const ContinueStmt *S) {
295  VisitStmt(S);
296}
297
298void StmtProfiler::VisitBreakStmt(const BreakStmt *S) {
299  VisitStmt(S);
300}
301
302void StmtProfiler::VisitReturnStmt(const ReturnStmt *S) {
303  VisitStmt(S);
304}
305
306void StmtProfiler::VisitGCCAsmStmt(const GCCAsmStmt *S) {
307  VisitStmt(S);
308  ID.AddBoolean(S->isVolatile());
309  ID.AddBoolean(S->isSimple());
310  VisitStringLiteral(S->getAsmString());
311  ID.AddInteger(S->getNumOutputs());
312  for (unsigned I = 0, N = S->getNumOutputs(); I != N; ++I) {
313    ID.AddString(S->getOutputName(I));
314    VisitStringLiteral(S->getOutputConstraintLiteral(I));
315  }
316  ID.AddInteger(S->getNumInputs());
317  for (unsigned I = 0, N = S->getNumInputs(); I != N; ++I) {
318    ID.AddString(S->getInputName(I));
319    VisitStringLiteral(S->getInputConstraintLiteral(I));
320  }
321  ID.AddInteger(S->getNumClobbers());
322  for (unsigned I = 0, N = S->getNumClobbers(); I != N; ++I)
323    VisitStringLiteral(S->getClobberStringLiteral(I));
324  ID.AddInteger(S->getNumLabels());
325  for (auto *L : S->labels())
326    VisitDecl(L->getLabel());
327}
328
329void StmtProfiler::VisitMSAsmStmt(const MSAsmStmt *S) {
330  // FIXME: Implement MS style inline asm statement profiler.
331  VisitStmt(S);
332}
333
334void StmtProfiler::VisitCXXCatchStmt(const CXXCatchStmt *S) {
335  VisitStmt(S);
336  VisitType(S->getCaughtType());
337}
338
339void StmtProfiler::VisitCXXTryStmt(const CXXTryStmt *S) {
340  VisitStmt(S);
341}
342
343void StmtProfiler::VisitCXXForRangeStmt(const CXXForRangeStmt *S) {
344  VisitStmt(S);
345}
346
347void StmtProfiler::VisitMSDependentExistsStmt(const MSDependentExistsStmt *S) {
348  VisitStmt(S);
349  ID.AddBoolean(S->isIfExists());
350  VisitNestedNameSpecifier(S->getQualifierLoc().getNestedNameSpecifier());
351  VisitName(S->getNameInfo().getName());
352}
353
354void StmtProfiler::VisitSEHTryStmt(const SEHTryStmt *S) {
355  VisitStmt(S);
356}
357
358void StmtProfiler::VisitSEHFinallyStmt(const SEHFinallyStmt *S) {
359  VisitStmt(S);
360}
361
362void StmtProfiler::VisitSEHExceptStmt(const SEHExceptStmt *S) {
363  VisitStmt(S);
364}
365
366void StmtProfiler::VisitSEHLeaveStmt(const SEHLeaveStmt *S) {
367  VisitStmt(S);
368}
369
370void StmtProfiler::VisitCapturedStmt(const CapturedStmt *S) {
371  VisitStmt(S);
372}
373
374void StmtProfiler::VisitObjCForCollectionStmt(const ObjCForCollectionStmt *S) {
375  VisitStmt(S);
376}
377
378void StmtProfiler::VisitObjCAtCatchStmt(const ObjCAtCatchStmt *S) {
379  VisitStmt(S);
380  ID.AddBoolean(S->hasEllipsis());
381  if (S->getCatchParamDecl())
382    VisitType(S->getCatchParamDecl()->getType());
383}
384
385void StmtProfiler::VisitObjCAtFinallyStmt(const ObjCAtFinallyStmt *S) {
386  VisitStmt(S);
387}
388
389void StmtProfiler::VisitObjCAtTryStmt(const ObjCAtTryStmt *S) {
390  VisitStmt(S);
391}
392
393void
394StmtProfiler::VisitObjCAtSynchronizedStmt(const ObjCAtSynchronizedStmt *S) {
395  VisitStmt(S);
396}
397
398void StmtProfiler::VisitObjCAtThrowStmt(const ObjCAtThrowStmt *S) {
399  VisitStmt(S);
400}
401
402void
403StmtProfiler::VisitObjCAutoreleasePoolStmt(const ObjCAutoreleasePoolStmt *S) {
404  VisitStmt(S);
405}
406
407namespace {
408class OMPClauseProfiler : public ConstOMPClauseVisitor<OMPClauseProfiler> {
409  StmtProfiler *Profiler;
410  /// Process clauses with list of variables.
411  template <typename T>
412  void VisitOMPClauseList(T *Node);
413
414public:
415  OMPClauseProfiler(StmtProfiler *P) : Profiler(P) { }
416#define OPENMP_CLAUSE(Name, Class)                                             \
417  void Visit##Class(const Class *C);
418#include "clang/Basic/OpenMPKinds.def"
419  void VistOMPClauseWithPreInit(const OMPClauseWithPreInit *C);
420  void VistOMPClauseWithPostUpdate(const OMPClauseWithPostUpdate *C);
421};
422
423void OMPClauseProfiler::VistOMPClauseWithPreInit(
424    const OMPClauseWithPreInit *C) {
425  if (auto *S = C->getPreInitStmt())
426    Profiler->VisitStmt(S);
427}
428
429void OMPClauseProfiler::VistOMPClauseWithPostUpdate(
430    const OMPClauseWithPostUpdate *C) {
431  VistOMPClauseWithPreInit(C);
432  if (auto *E = C->getPostUpdateExpr())
433    Profiler->VisitStmt(E);
434}
435
436void OMPClauseProfiler::VisitOMPIfClause(const OMPIfClause *C) {
437  VistOMPClauseWithPreInit(C);
438  if (C->getCondition())
439    Profiler->VisitStmt(C->getCondition());
440}
441
442void OMPClauseProfiler::VisitOMPFinalClause(const OMPFinalClause *C) {
443  if (C->getCondition())
444    Profiler->VisitStmt(C->getCondition());
445}
446
447void OMPClauseProfiler::VisitOMPNumThreadsClause(const OMPNumThreadsClause *C) {
448  VistOMPClauseWithPreInit(C);
449  if (C->getNumThreads())
450    Profiler->VisitStmt(C->getNumThreads());
451}
452
453void OMPClauseProfiler::VisitOMPSafelenClause(const OMPSafelenClause *C) {
454  if (C->getSafelen())
455    Profiler->VisitStmt(C->getSafelen());
456}
457
458void OMPClauseProfiler::VisitOMPSimdlenClause(const OMPSimdlenClause *C) {
459  if (C->getSimdlen())
460    Profiler->VisitStmt(C->getSimdlen());
461}
462
463void OMPClauseProfiler::VisitOMPAllocatorClause(const OMPAllocatorClause *C) {
464  if (C->getAllocator())
465    Profiler->VisitStmt(C->getAllocator());
466}
467
468void OMPClauseProfiler::VisitOMPCollapseClause(const OMPCollapseClause *C) {
469  if (C->getNumForLoops())
470    Profiler->VisitStmt(C->getNumForLoops());
471}
472
473void OMPClauseProfiler::VisitOMPDefaultClause(const OMPDefaultClause *C) { }
474
475void OMPClauseProfiler::VisitOMPProcBindClause(const OMPProcBindClause *C) { }
476
477void OMPClauseProfiler::VisitOMPUnifiedAddressClause(
478    const OMPUnifiedAddressClause *C) {}
479
480void OMPClauseProfiler::VisitOMPUnifiedSharedMemoryClause(
481    const OMPUnifiedSharedMemoryClause *C) {}
482
483void OMPClauseProfiler::VisitOMPReverseOffloadClause(
484    const OMPReverseOffloadClause *C) {}
485
486void OMPClauseProfiler::VisitOMPDynamicAllocatorsClause(
487    const OMPDynamicAllocatorsClause *C) {}
488
489void OMPClauseProfiler::VisitOMPAtomicDefaultMemOrderClause(
490    const OMPAtomicDefaultMemOrderClause *C) {}
491
492void OMPClauseProfiler::VisitOMPScheduleClause(const OMPScheduleClause *C) {
493  VistOMPClauseWithPreInit(C);
494  if (auto *S = C->getChunkSize())
495    Profiler->VisitStmt(S);
496}
497
498void OMPClauseProfiler::VisitOMPOrderedClause(const OMPOrderedClause *C) {
499  if (auto *Num = C->getNumForLoops())
500    Profiler->VisitStmt(Num);
501}
502
503void OMPClauseProfiler::VisitOMPNowaitClause(const OMPNowaitClause *) {}
504
505void OMPClauseProfiler::VisitOMPUntiedClause(const OMPUntiedClause *) {}
506
507void OMPClauseProfiler::VisitOMPMergeableClause(const OMPMergeableClause *) {}
508
509void OMPClauseProfiler::VisitOMPReadClause(const OMPReadClause *) {}
510
511void OMPClauseProfiler::VisitOMPWriteClause(const OMPWriteClause *) {}
512
513void OMPClauseProfiler::VisitOMPUpdateClause(const OMPUpdateClause *) {}
514
515void OMPClauseProfiler::VisitOMPCaptureClause(const OMPCaptureClause *) {}
516
517void OMPClauseProfiler::VisitOMPSeqCstClause(const OMPSeqCstClause *) {}
518
519void OMPClauseProfiler::VisitOMPThreadsClause(const OMPThreadsClause *) {}
520
521void OMPClauseProfiler::VisitOMPSIMDClause(const OMPSIMDClause *) {}
522
523void OMPClauseProfiler::VisitOMPNogroupClause(const OMPNogroupClause *) {}
524
525template<typename T>
526void OMPClauseProfiler::VisitOMPClauseList(T *Node) {
527  for (auto *E : Node->varlists()) {
528    if (E)
529      Profiler->VisitStmt(E);
530  }
531}
532
533void OMPClauseProfiler::VisitOMPPrivateClause(const OMPPrivateClause *C) {
534  VisitOMPClauseList(C);
535  for (auto *E : C->private_copies()) {
536    if (E)
537      Profiler->VisitStmt(E);
538  }
539}
540void
541OMPClauseProfiler::VisitOMPFirstprivateClause(const OMPFirstprivateClause *C) {
542  VisitOMPClauseList(C);
543  VistOMPClauseWithPreInit(C);
544  for (auto *E : C->private_copies()) {
545    if (E)
546      Profiler->VisitStmt(E);
547  }
548  for (auto *E : C->inits()) {
549    if (E)
550      Profiler->VisitStmt(E);
551  }
552}
553void
554OMPClauseProfiler::VisitOMPLastprivateClause(const OMPLastprivateClause *C) {
555  VisitOMPClauseList(C);
556  VistOMPClauseWithPostUpdate(C);
557  for (auto *E : C->source_exprs()) {
558    if (E)
559      Profiler->VisitStmt(E);
560  }
561  for (auto *E : C->destination_exprs()) {
562    if (E)
563      Profiler->VisitStmt(E);
564  }
565  for (auto *E : C->assignment_ops()) {
566    if (E)
567      Profiler->VisitStmt(E);
568  }
569}
570void OMPClauseProfiler::VisitOMPSharedClause(const OMPSharedClause *C) {
571  VisitOMPClauseList(C);
572}
573void OMPClauseProfiler::VisitOMPReductionClause(
574                                         const OMPReductionClause *C) {
575  Profiler->VisitNestedNameSpecifier(
576      C->getQualifierLoc().getNestedNameSpecifier());
577  Profiler->VisitName(C->getNameInfo().getName());
578  VisitOMPClauseList(C);
579  VistOMPClauseWithPostUpdate(C);
580  for (auto *E : C->privates()) {
581    if (E)
582      Profiler->VisitStmt(E);
583  }
584  for (auto *E : C->lhs_exprs()) {
585    if (E)
586      Profiler->VisitStmt(E);
587  }
588  for (auto *E : C->rhs_exprs()) {
589    if (E)
590      Profiler->VisitStmt(E);
591  }
592  for (auto *E : C->reduction_ops()) {
593    if (E)
594      Profiler->VisitStmt(E);
595  }
596}
597void OMPClauseProfiler::VisitOMPTaskReductionClause(
598    const OMPTaskReductionClause *C) {
599  Profiler->VisitNestedNameSpecifier(
600      C->getQualifierLoc().getNestedNameSpecifier());
601  Profiler->VisitName(C->getNameInfo().getName());
602  VisitOMPClauseList(C);
603  VistOMPClauseWithPostUpdate(C);
604  for (auto *E : C->privates()) {
605    if (E)
606      Profiler->VisitStmt(E);
607  }
608  for (auto *E : C->lhs_exprs()) {
609    if (E)
610      Profiler->VisitStmt(E);
611  }
612  for (auto *E : C->rhs_exprs()) {
613    if (E)
614      Profiler->VisitStmt(E);
615  }
616  for (auto *E : C->reduction_ops()) {
617    if (E)
618      Profiler->VisitStmt(E);
619  }
620}
621void OMPClauseProfiler::VisitOMPInReductionClause(
622    const OMPInReductionClause *C) {
623  Profiler->VisitNestedNameSpecifier(
624      C->getQualifierLoc().getNestedNameSpecifier());
625  Profiler->VisitName(C->getNameInfo().getName());
626  VisitOMPClauseList(C);
627  VistOMPClauseWithPostUpdate(C);
628  for (auto *E : C->privates()) {
629    if (E)
630      Profiler->VisitStmt(E);
631  }
632  for (auto *E : C->lhs_exprs()) {
633    if (E)
634      Profiler->VisitStmt(E);
635  }
636  for (auto *E : C->rhs_exprs()) {
637    if (E)
638      Profiler->VisitStmt(E);
639  }
640  for (auto *E : C->reduction_ops()) {
641    if (E)
642      Profiler->VisitStmt(E);
643  }
644  for (auto *E : C->taskgroup_descriptors()) {
645    if (E)
646      Profiler->VisitStmt(E);
647  }
648}
649void OMPClauseProfiler::VisitOMPLinearClause(const OMPLinearClause *C) {
650  VisitOMPClauseList(C);
651  VistOMPClauseWithPostUpdate(C);
652  for (auto *E : C->privates()) {
653    if (E)
654      Profiler->VisitStmt(E);
655  }
656  for (auto *E : C->inits()) {
657    if (E)
658      Profiler->VisitStmt(E);
659  }
660  for (auto *E : C->updates()) {
661    if (E)
662      Profiler->VisitStmt(E);
663  }
664  for (auto *E : C->finals()) {
665    if (E)
666      Profiler->VisitStmt(E);
667  }
668  if (C->getStep())
669    Profiler->VisitStmt(C->getStep());
670  if (C->getCalcStep())
671    Profiler->VisitStmt(C->getCalcStep());
672}
673void OMPClauseProfiler::VisitOMPAlignedClause(const OMPAlignedClause *C) {
674  VisitOMPClauseList(C);
675  if (C->getAlignment())
676    Profiler->VisitStmt(C->getAlignment());
677}
678void OMPClauseProfiler::VisitOMPCopyinClause(const OMPCopyinClause *C) {
679  VisitOMPClauseList(C);
680  for (auto *E : C->source_exprs()) {
681    if (E)
682      Profiler->VisitStmt(E);
683  }
684  for (auto *E : C->destination_exprs()) {
685    if (E)
686      Profiler->VisitStmt(E);
687  }
688  for (auto *E : C->assignment_ops()) {
689    if (E)
690      Profiler->VisitStmt(E);
691  }
692}
693void
694OMPClauseProfiler::VisitOMPCopyprivateClause(const OMPCopyprivateClause *C) {
695  VisitOMPClauseList(C);
696  for (auto *E : C->source_exprs()) {
697    if (E)
698      Profiler->VisitStmt(E);
699  }
700  for (auto *E : C->destination_exprs()) {
701    if (E)
702      Profiler->VisitStmt(E);
703  }
704  for (auto *E : C->assignment_ops()) {
705    if (E)
706      Profiler->VisitStmt(E);
707  }
708}
709void OMPClauseProfiler::VisitOMPFlushClause(const OMPFlushClause *C) {
710  VisitOMPClauseList(C);
711}
712void OMPClauseProfiler::VisitOMPDependClause(const OMPDependClause *C) {
713  VisitOMPClauseList(C);
714}
715void OMPClauseProfiler::VisitOMPDeviceClause(const OMPDeviceClause *C) {
716  if (C->getDevice())
717    Profiler->VisitStmt(C->getDevice());
718}
719void OMPClauseProfiler::VisitOMPMapClause(const OMPMapClause *C) {
720  VisitOMPClauseList(C);
721}
722void OMPClauseProfiler::VisitOMPAllocateClause(const OMPAllocateClause *C) {
723  if (Expr *Allocator = C->getAllocator())
724    Profiler->VisitStmt(Allocator);
725  VisitOMPClauseList(C);
726}
727void OMPClauseProfiler::VisitOMPNumTeamsClause(const OMPNumTeamsClause *C) {
728  VistOMPClauseWithPreInit(C);
729  if (C->getNumTeams())
730    Profiler->VisitStmt(C->getNumTeams());
731}
732void OMPClauseProfiler::VisitOMPThreadLimitClause(
733    const OMPThreadLimitClause *C) {
734  VistOMPClauseWithPreInit(C);
735  if (C->getThreadLimit())
736    Profiler->VisitStmt(C->getThreadLimit());
737}
738void OMPClauseProfiler::VisitOMPPriorityClause(const OMPPriorityClause *C) {
739  if (C->getPriority())
740    Profiler->VisitStmt(C->getPriority());
741}
742void OMPClauseProfiler::VisitOMPGrainsizeClause(const OMPGrainsizeClause *C) {
743  if (C->getGrainsize())
744    Profiler->VisitStmt(C->getGrainsize());
745}
746void OMPClauseProfiler::VisitOMPNumTasksClause(const OMPNumTasksClause *C) {
747  if (C->getNumTasks())
748    Profiler->VisitStmt(C->getNumTasks());
749}
750void OMPClauseProfiler::VisitOMPHintClause(const OMPHintClause *C) {
751  if (C->getHint())
752    Profiler->VisitStmt(C->getHint());
753}
754void OMPClauseProfiler::VisitOMPToClause(const OMPToClause *C) {
755  VisitOMPClauseList(C);
756}
757void OMPClauseProfiler::VisitOMPFromClause(const OMPFromClause *C) {
758  VisitOMPClauseList(C);
759}
760void OMPClauseProfiler::VisitOMPUseDevicePtrClause(
761    const OMPUseDevicePtrClause *C) {
762  VisitOMPClauseList(C);
763}
764void OMPClauseProfiler::VisitOMPIsDevicePtrClause(
765    const OMPIsDevicePtrClause *C) {
766  VisitOMPClauseList(C);
767}
768}
769
770void
771StmtProfiler::VisitOMPExecutableDirective(const OMPExecutableDirective *S) {
772  VisitStmt(S);
773  OMPClauseProfiler P(this);
774  ArrayRef<OMPClause *> Clauses = S->clauses();
775  for (ArrayRef<OMPClause *>::iterator I = Clauses.begin(), E = Clauses.end();
776       I != E; ++I)
777    if (*I)
778      P.Visit(*I);
779}
780
781void StmtProfiler::VisitOMPLoopDirective(const OMPLoopDirective *S) {
782  VisitOMPExecutableDirective(S);
783}
784
785void StmtProfiler::VisitOMPParallelDirective(const OMPParallelDirective *S) {
786  VisitOMPExecutableDirective(S);
787}
788
789void StmtProfiler::VisitOMPSimdDirective(const OMPSimdDirective *S) {
790  VisitOMPLoopDirective(S);
791}
792
793void StmtProfiler::VisitOMPForDirective(const OMPForDirective *S) {
794  VisitOMPLoopDirective(S);
795}
796
797void StmtProfiler::VisitOMPForSimdDirective(const OMPForSimdDirective *S) {
798  VisitOMPLoopDirective(S);
799}
800
801void StmtProfiler::VisitOMPSectionsDirective(const OMPSectionsDirective *S) {
802  VisitOMPExecutableDirective(S);
803}
804
805void StmtProfiler::VisitOMPSectionDirective(const OMPSectionDirective *S) {
806  VisitOMPExecutableDirective(S);
807}
808
809void StmtProfiler::VisitOMPSingleDirective(const OMPSingleDirective *S) {
810  VisitOMPExecutableDirective(S);
811}
812
813void StmtProfiler::VisitOMPMasterDirective(const OMPMasterDirective *S) {
814  VisitOMPExecutableDirective(S);
815}
816
817void StmtProfiler::VisitOMPCriticalDirective(const OMPCriticalDirective *S) {
818  VisitOMPExecutableDirective(S);
819  VisitName(S->getDirectiveName().getName());
820}
821
822void
823StmtProfiler::VisitOMPParallelForDirective(const OMPParallelForDirective *S) {
824  VisitOMPLoopDirective(S);
825}
826
827void StmtProfiler::VisitOMPParallelForSimdDirective(
828    const OMPParallelForSimdDirective *S) {
829  VisitOMPLoopDirective(S);
830}
831
832void StmtProfiler::VisitOMPParallelSectionsDirective(
833    const OMPParallelSectionsDirective *S) {
834  VisitOMPExecutableDirective(S);
835}
836
837void StmtProfiler::VisitOMPTaskDirective(const OMPTaskDirective *S) {
838  VisitOMPExecutableDirective(S);
839}
840
841void StmtProfiler::VisitOMPTaskyieldDirective(const OMPTaskyieldDirective *S) {
842  VisitOMPExecutableDirective(S);
843}
844
845void StmtProfiler::VisitOMPBarrierDirective(const OMPBarrierDirective *S) {
846  VisitOMPExecutableDirective(S);
847}
848
849void StmtProfiler::VisitOMPTaskwaitDirective(const OMPTaskwaitDirective *S) {
850  VisitOMPExecutableDirective(S);
851}
852
853void StmtProfiler::VisitOMPTaskgroupDirective(const OMPTaskgroupDirective *S) {
854  VisitOMPExecutableDirective(S);
855  if (const Expr *E = S->getReductionRef())
856    VisitStmt(E);
857}
858
859void StmtProfiler::VisitOMPFlushDirective(const OMPFlushDirective *S) {
860  VisitOMPExecutableDirective(S);
861}
862
863void StmtProfiler::VisitOMPOrderedDirective(const OMPOrderedDirective *S) {
864  VisitOMPExecutableDirective(S);
865}
866
867void StmtProfiler::VisitOMPAtomicDirective(const OMPAtomicDirective *S) {
868  VisitOMPExecutableDirective(S);
869}
870
871void StmtProfiler::VisitOMPTargetDirective(const OMPTargetDirective *S) {
872  VisitOMPExecutableDirective(S);
873}
874
875void StmtProfiler::VisitOMPTargetDataDirective(const OMPTargetDataDirective *S) {
876  VisitOMPExecutableDirective(S);
877}
878
879void StmtProfiler::VisitOMPTargetEnterDataDirective(
880    const OMPTargetEnterDataDirective *S) {
881  VisitOMPExecutableDirective(S);
882}
883
884void StmtProfiler::VisitOMPTargetExitDataDirective(
885    const OMPTargetExitDataDirective *S) {
886  VisitOMPExecutableDirective(S);
887}
888
889void StmtProfiler::VisitOMPTargetParallelDirective(
890    const OMPTargetParallelDirective *S) {
891  VisitOMPExecutableDirective(S);
892}
893
894void StmtProfiler::VisitOMPTargetParallelForDirective(
895    const OMPTargetParallelForDirective *S) {
896  VisitOMPExecutableDirective(S);
897}
898
899void StmtProfiler::VisitOMPTeamsDirective(const OMPTeamsDirective *S) {
900  VisitOMPExecutableDirective(S);
901}
902
903void StmtProfiler::VisitOMPCancellationPointDirective(
904    const OMPCancellationPointDirective *S) {
905  VisitOMPExecutableDirective(S);
906}
907
908void StmtProfiler::VisitOMPCancelDirective(const OMPCancelDirective *S) {
909  VisitOMPExecutableDirective(S);
910}
911
912void StmtProfiler::VisitOMPTaskLoopDirective(const OMPTaskLoopDirective *S) {
913  VisitOMPLoopDirective(S);
914}
915
916void StmtProfiler::VisitOMPTaskLoopSimdDirective(
917    const OMPTaskLoopSimdDirective *S) {
918  VisitOMPLoopDirective(S);
919}
920
921void StmtProfiler::VisitOMPDistributeDirective(
922    const OMPDistributeDirective *S) {
923  VisitOMPLoopDirective(S);
924}
925
926void OMPClauseProfiler::VisitOMPDistScheduleClause(
927    const OMPDistScheduleClause *C) {
928  VistOMPClauseWithPreInit(C);
929  if (auto *S = C->getChunkSize())
930    Profiler->VisitStmt(S);
931}
932
933void OMPClauseProfiler::VisitOMPDefaultmapClause(const OMPDefaultmapClause *) {}
934
935void StmtProfiler::VisitOMPTargetUpdateDirective(
936    const OMPTargetUpdateDirective *S) {
937  VisitOMPExecutableDirective(S);
938}
939
940void StmtProfiler::VisitOMPDistributeParallelForDirective(
941    const OMPDistributeParallelForDirective *S) {
942  VisitOMPLoopDirective(S);
943}
944
945void StmtProfiler::VisitOMPDistributeParallelForSimdDirective(
946    const OMPDistributeParallelForSimdDirective *S) {
947  VisitOMPLoopDirective(S);
948}
949
950void StmtProfiler::VisitOMPDistributeSimdDirective(
951    const OMPDistributeSimdDirective *S) {
952  VisitOMPLoopDirective(S);
953}
954
955void StmtProfiler::VisitOMPTargetParallelForSimdDirective(
956    const OMPTargetParallelForSimdDirective *S) {
957  VisitOMPLoopDirective(S);
958}
959
960void StmtProfiler::VisitOMPTargetSimdDirective(
961    const OMPTargetSimdDirective *S) {
962  VisitOMPLoopDirective(S);
963}
964
965void StmtProfiler::VisitOMPTeamsDistributeDirective(
966    const OMPTeamsDistributeDirective *S) {
967  VisitOMPLoopDirective(S);
968}
969
970void StmtProfiler::VisitOMPTeamsDistributeSimdDirective(
971    const OMPTeamsDistributeSimdDirective *S) {
972  VisitOMPLoopDirective(S);
973}
974
975void StmtProfiler::VisitOMPTeamsDistributeParallelForSimdDirective(
976    const OMPTeamsDistributeParallelForSimdDirective *S) {
977  VisitOMPLoopDirective(S);
978}
979
980void StmtProfiler::VisitOMPTeamsDistributeParallelForDirective(
981    const OMPTeamsDistributeParallelForDirective *S) {
982  VisitOMPLoopDirective(S);
983}
984
985void StmtProfiler::VisitOMPTargetTeamsDirective(
986    const OMPTargetTeamsDirective *S) {
987  VisitOMPExecutableDirective(S);
988}
989
990void StmtProfiler::VisitOMPTargetTeamsDistributeDirective(
991    const OMPTargetTeamsDistributeDirective *S) {
992  VisitOMPLoopDirective(S);
993}
994
995void StmtProfiler::VisitOMPTargetTeamsDistributeParallelForDirective(
996    const OMPTargetTeamsDistributeParallelForDirective *S) {
997  VisitOMPLoopDirective(S);
998}
999
1000void StmtProfiler::VisitOMPTargetTeamsDistributeParallelForSimdDirective(
1001    const OMPTargetTeamsDistributeParallelForSimdDirective *S) {
1002  VisitOMPLoopDirective(S);
1003}
1004
1005void StmtProfiler::VisitOMPTargetTeamsDistributeSimdDirective(
1006    const OMPTargetTeamsDistributeSimdDirective *S) {
1007  VisitOMPLoopDirective(S);
1008}
1009
1010void StmtProfiler::VisitExpr(const Expr *S) {
1011  VisitStmt(S);
1012}
1013
1014void StmtProfiler::VisitConstantExpr(const ConstantExpr *S) {
1015  VisitExpr(S);
1016}
1017
1018void StmtProfiler::VisitDeclRefExpr(const DeclRefExpr *S) {
1019  VisitExpr(S);
1020  if (!Canonical)
1021    VisitNestedNameSpecifier(S->getQualifier());
1022  VisitDecl(S->getDecl());
1023  if (!Canonical) {
1024    ID.AddBoolean(S->hasExplicitTemplateArgs());
1025    if (S->hasExplicitTemplateArgs())
1026      VisitTemplateArguments(S->getTemplateArgs(), S->getNumTemplateArgs());
1027  }
1028}
1029
1030void StmtProfiler::VisitPredefinedExpr(const PredefinedExpr *S) {
1031  VisitExpr(S);
1032  ID.AddInteger(S->getIdentKind());
1033}
1034
1035void StmtProfiler::VisitIntegerLiteral(const IntegerLiteral *S) {
1036  VisitExpr(S);
1037  S->getValue().Profile(ID);
1038  ID.AddInteger(S->getType()->castAs<BuiltinType>()->getKind());
1039}
1040
1041void StmtProfiler::VisitFixedPointLiteral(const FixedPointLiteral *S) {
1042  VisitExpr(S);
1043  S->getValue().Profile(ID);
1044  ID.AddInteger(S->getType()->castAs<BuiltinType>()->getKind());
1045}
1046
1047void StmtProfiler::VisitCharacterLiteral(const CharacterLiteral *S) {
1048  VisitExpr(S);
1049  ID.AddInteger(S->getKind());
1050  ID.AddInteger(S->getValue());
1051}
1052
1053void StmtProfiler::VisitFloatingLiteral(const FloatingLiteral *S) {
1054  VisitExpr(S);
1055  S->getValue().Profile(ID);
1056  ID.AddBoolean(S->isExact());
1057  ID.AddInteger(S->getType()->castAs<BuiltinType>()->getKind());
1058}
1059
1060void StmtProfiler::VisitImaginaryLiteral(const ImaginaryLiteral *S) {
1061  VisitExpr(S);
1062}
1063
1064void StmtProfiler::VisitStringLiteral(const StringLiteral *S) {
1065  VisitExpr(S);
1066  ID.AddString(S->getBytes());
1067  ID.AddInteger(S->getKind());
1068}
1069
1070void StmtProfiler::VisitParenExpr(const ParenExpr *S) {
1071  VisitExpr(S);
1072}
1073
1074void StmtProfiler::VisitParenListExpr(const ParenListExpr *S) {
1075  VisitExpr(S);
1076}
1077
1078void StmtProfiler::VisitUnaryOperator(const UnaryOperator *S) {
1079  VisitExpr(S);
1080  ID.AddInteger(S->getOpcode());
1081}
1082
1083void StmtProfiler::VisitOffsetOfExpr(const OffsetOfExpr *S) {
1084  VisitType(S->getTypeSourceInfo()->getType());
1085  unsigned n = S->getNumComponents();
1086  for (unsigned i = 0; i < n; ++i) {
1087    const OffsetOfNode &ON = S->getComponent(i);
1088    ID.AddInteger(ON.getKind());
1089    switch (ON.getKind()) {
1090    case OffsetOfNode::Array:
1091      // Expressions handled below.
1092      break;
1093
1094    case OffsetOfNode::Field:
1095      VisitDecl(ON.getField());
1096      break;
1097
1098    case OffsetOfNode::Identifier:
1099      VisitIdentifierInfo(ON.getFieldName());
1100      break;
1101
1102    case OffsetOfNode::Base:
1103      // These nodes are implicit, and therefore don't need profiling.
1104      break;
1105    }
1106  }
1107
1108  VisitExpr(S);
1109}
1110
1111void
1112StmtProfiler::VisitUnaryExprOrTypeTraitExpr(const UnaryExprOrTypeTraitExpr *S) {
1113  VisitExpr(S);
1114  ID.AddInteger(S->getKind());
1115  if (S->isArgumentType())
1116    VisitType(S->getArgumentType());
1117}
1118
1119void StmtProfiler::VisitArraySubscriptExpr(const ArraySubscriptExpr *S) {
1120  VisitExpr(S);
1121}
1122
1123void StmtProfiler::VisitOMPArraySectionExpr(const OMPArraySectionExpr *S) {
1124  VisitExpr(S);
1125}
1126
1127void StmtProfiler::VisitCallExpr(const CallExpr *S) {
1128  VisitExpr(S);
1129}
1130
1131void StmtProfiler::VisitMemberExpr(const MemberExpr *S) {
1132  VisitExpr(S);
1133  VisitDecl(S->getMemberDecl());
1134  if (!Canonical)
1135    VisitNestedNameSpecifier(S->getQualifier());
1136  ID.AddBoolean(S->isArrow());
1137}
1138
1139void StmtProfiler::VisitCompoundLiteralExpr(const CompoundLiteralExpr *S) {
1140  VisitExpr(S);
1141  ID.AddBoolean(S->isFileScope());
1142}
1143
1144void StmtProfiler::VisitCastExpr(const CastExpr *S) {
1145  VisitExpr(S);
1146}
1147
1148void StmtProfiler::VisitImplicitCastExpr(const ImplicitCastExpr *S) {
1149  VisitCastExpr(S);
1150  ID.AddInteger(S->getValueKind());
1151}
1152
1153void StmtProfiler::VisitExplicitCastExpr(const ExplicitCastExpr *S) {
1154  VisitCastExpr(S);
1155  VisitType(S->getTypeAsWritten());
1156}
1157
1158void StmtProfiler::VisitCStyleCastExpr(const CStyleCastExpr *S) {
1159  VisitExplicitCastExpr(S);
1160}
1161
1162void StmtProfiler::VisitBinaryOperator(const BinaryOperator *S) {
1163  VisitExpr(S);
1164  ID.AddInteger(S->getOpcode());
1165}
1166
1167void
1168StmtProfiler::VisitCompoundAssignOperator(const CompoundAssignOperator *S) {
1169  VisitBinaryOperator(S);
1170}
1171
1172void StmtProfiler::VisitConditionalOperator(const ConditionalOperator *S) {
1173  VisitExpr(S);
1174}
1175
1176void StmtProfiler::VisitBinaryConditionalOperator(
1177    const BinaryConditionalOperator *S) {
1178  VisitExpr(S);
1179}
1180
1181void StmtProfiler::VisitAddrLabelExpr(const AddrLabelExpr *S) {
1182  VisitExpr(S);
1183  VisitDecl(S->getLabel());
1184}
1185
1186void StmtProfiler::VisitStmtExpr(const StmtExpr *S) {
1187  VisitExpr(S);
1188}
1189
1190void StmtProfiler::VisitShuffleVectorExpr(const ShuffleVectorExpr *S) {
1191  VisitExpr(S);
1192}
1193
1194void StmtProfiler::VisitConvertVectorExpr(const ConvertVectorExpr *S) {
1195  VisitExpr(S);
1196}
1197
1198void StmtProfiler::VisitChooseExpr(const ChooseExpr *S) {
1199  VisitExpr(S);
1200}
1201
1202void StmtProfiler::VisitGNUNullExpr(const GNUNullExpr *S) {
1203  VisitExpr(S);
1204}
1205
1206void StmtProfiler::VisitVAArgExpr(const VAArgExpr *S) {
1207  VisitExpr(S);
1208}
1209
1210void StmtProfiler::VisitInitListExpr(const InitListExpr *S) {
1211  if (S->getSyntacticForm()) {
1212    VisitInitListExpr(S->getSyntacticForm());
1213    return;
1214  }
1215
1216  VisitExpr(S);
1217}
1218
1219void StmtProfiler::VisitDesignatedInitExpr(const DesignatedInitExpr *S) {
1220  VisitExpr(S);
1221  ID.AddBoolean(S->usesGNUSyntax());
1222  for (const DesignatedInitExpr::Designator &D : S->designators()) {
1223    if (D.isFieldDesignator()) {
1224      ID.AddInteger(0);
1225      VisitName(D.getFieldName());
1226      continue;
1227    }
1228
1229    if (D.isArrayDesignator()) {
1230      ID.AddInteger(1);
1231    } else {
1232      assert(D.isArrayRangeDesignator());
1233      ID.AddInteger(2);
1234    }
1235    ID.AddInteger(D.getFirstExprIndex());
1236  }
1237}
1238
1239// Seems that if VisitInitListExpr() only works on the syntactic form of an
1240// InitListExpr, then a DesignatedInitUpdateExpr is not encountered.
1241void StmtProfiler::VisitDesignatedInitUpdateExpr(
1242    const DesignatedInitUpdateExpr *S) {
1243  llvm_unreachable("Unexpected DesignatedInitUpdateExpr in syntactic form of "
1244                   "initializer");
1245}
1246
1247void StmtProfiler::VisitArrayInitLoopExpr(const ArrayInitLoopExpr *S) {
1248  VisitExpr(S);
1249}
1250
1251void StmtProfiler::VisitArrayInitIndexExpr(const ArrayInitIndexExpr *S) {
1252  VisitExpr(S);
1253}
1254
1255void StmtProfiler::VisitNoInitExpr(const NoInitExpr *S) {
1256  llvm_unreachable("Unexpected NoInitExpr in syntactic form of initializer");
1257}
1258
1259void StmtProfiler::VisitImplicitValueInitExpr(const ImplicitValueInitExpr *S) {
1260  VisitExpr(S);
1261}
1262
1263void StmtProfiler::VisitExtVectorElementExpr(const ExtVectorElementExpr *S) {
1264  VisitExpr(S);
1265  VisitName(&S->getAccessor());
1266}
1267
1268void StmtProfiler::VisitBlockExpr(const BlockExpr *S) {
1269  VisitExpr(S);
1270  VisitDecl(S->getBlockDecl());
1271}
1272
1273void StmtProfiler::VisitGenericSelectionExpr(const GenericSelectionExpr *S) {
1274  VisitExpr(S);
1275  for (const GenericSelectionExpr::ConstAssociation &Assoc :
1276       S->associations()) {
1277    QualType T = Assoc.getType();
1278    if (T.isNull())
1279      ID.AddPointer(nullptr);
1280    else
1281      VisitType(T);
1282    VisitExpr(Assoc.getAssociationExpr());
1283  }
1284}
1285
1286void StmtProfiler::VisitPseudoObjectExpr(const PseudoObjectExpr *S) {
1287  VisitExpr(S);
1288  for (PseudoObjectExpr::const_semantics_iterator
1289         i = S->semantics_begin(), e = S->semantics_end(); i != e; ++i)
1290    // Normally, we would not profile the source expressions of OVEs.
1291    if (const OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(*i))
1292      Visit(OVE->getSourceExpr());
1293}
1294
1295void StmtProfiler::VisitAtomicExpr(const AtomicExpr *S) {
1296  VisitExpr(S);
1297  ID.AddInteger(S->getOp());
1298}
1299
1300static Stmt::StmtClass DecodeOperatorCall(const CXXOperatorCallExpr *S,
1301                                          UnaryOperatorKind &UnaryOp,
1302                                          BinaryOperatorKind &BinaryOp) {
1303  switch (S->getOperator()) {
1304  case OO_None:
1305  case OO_New:
1306  case OO_Delete:
1307  case OO_Array_New:
1308  case OO_Array_Delete:
1309  case OO_Arrow:
1310  case OO_Call:
1311  case OO_Conditional:
1312  case NUM_OVERLOADED_OPERATORS:
1313    llvm_unreachable("Invalid operator call kind");
1314
1315  case OO_Plus:
1316    if (S->getNumArgs() == 1) {
1317      UnaryOp = UO_Plus;
1318      return Stmt::UnaryOperatorClass;
1319    }
1320
1321    BinaryOp = BO_Add;
1322    return Stmt::BinaryOperatorClass;
1323
1324  case OO_Minus:
1325    if (S->getNumArgs() == 1) {
1326      UnaryOp = UO_Minus;
1327      return Stmt::UnaryOperatorClass;
1328    }
1329
1330    BinaryOp = BO_Sub;
1331    return Stmt::BinaryOperatorClass;
1332
1333  case OO_Star:
1334    if (S->getNumArgs() == 1) {
1335      UnaryOp = UO_Deref;
1336      return Stmt::UnaryOperatorClass;
1337    }
1338
1339    BinaryOp = BO_Mul;
1340    return Stmt::BinaryOperatorClass;
1341
1342  case OO_Slash:
1343    BinaryOp = BO_Div;
1344    return Stmt::BinaryOperatorClass;
1345
1346  case OO_Percent:
1347    BinaryOp = BO_Rem;
1348    return Stmt::BinaryOperatorClass;
1349
1350  case OO_Caret:
1351    BinaryOp = BO_Xor;
1352    return Stmt::BinaryOperatorClass;
1353
1354  case OO_Amp:
1355    if (S->getNumArgs() == 1) {
1356      UnaryOp = UO_AddrOf;
1357      return Stmt::UnaryOperatorClass;
1358    }
1359
1360    BinaryOp = BO_And;
1361    return Stmt::BinaryOperatorClass;
1362
1363  case OO_Pipe:
1364    BinaryOp = BO_Or;
1365    return Stmt::BinaryOperatorClass;
1366
1367  case OO_Tilde:
1368    UnaryOp = UO_Not;
1369    return Stmt::UnaryOperatorClass;
1370
1371  case OO_Exclaim:
1372    UnaryOp = UO_LNot;
1373    return Stmt::UnaryOperatorClass;
1374
1375  case OO_Equal:
1376    BinaryOp = BO_Assign;
1377    return Stmt::BinaryOperatorClass;
1378
1379  case OO_Less:
1380    BinaryOp = BO_LT;
1381    return Stmt::BinaryOperatorClass;
1382
1383  case OO_Greater:
1384    BinaryOp = BO_GT;
1385    return Stmt::BinaryOperatorClass;
1386
1387  case OO_PlusEqual:
1388    BinaryOp = BO_AddAssign;
1389    return Stmt::CompoundAssignOperatorClass;
1390
1391  case OO_MinusEqual:
1392    BinaryOp = BO_SubAssign;
1393    return Stmt::CompoundAssignOperatorClass;
1394
1395  case OO_StarEqual:
1396    BinaryOp = BO_MulAssign;
1397    return Stmt::CompoundAssignOperatorClass;
1398
1399  case OO_SlashEqual:
1400    BinaryOp = BO_DivAssign;
1401    return Stmt::CompoundAssignOperatorClass;
1402
1403  case OO_PercentEqual:
1404    BinaryOp = BO_RemAssign;
1405    return Stmt::CompoundAssignOperatorClass;
1406
1407  case OO_CaretEqual:
1408    BinaryOp = BO_XorAssign;
1409    return Stmt::CompoundAssignOperatorClass;
1410
1411  case OO_AmpEqual:
1412    BinaryOp = BO_AndAssign;
1413    return Stmt::CompoundAssignOperatorClass;
1414
1415  case OO_PipeEqual:
1416    BinaryOp = BO_OrAssign;
1417    return Stmt::CompoundAssignOperatorClass;
1418
1419  case OO_LessLess:
1420    BinaryOp = BO_Shl;
1421    return Stmt::BinaryOperatorClass;
1422
1423  case OO_GreaterGreater:
1424    BinaryOp = BO_Shr;
1425    return Stmt::BinaryOperatorClass;
1426
1427  case OO_LessLessEqual:
1428    BinaryOp = BO_ShlAssign;
1429    return Stmt::CompoundAssignOperatorClass;
1430
1431  case OO_GreaterGreaterEqual:
1432    BinaryOp = BO_ShrAssign;
1433    return Stmt::CompoundAssignOperatorClass;
1434
1435  case OO_EqualEqual:
1436    BinaryOp = BO_EQ;
1437    return Stmt::BinaryOperatorClass;
1438
1439  case OO_ExclaimEqual:
1440    BinaryOp = BO_NE;
1441    return Stmt::BinaryOperatorClass;
1442
1443  case OO_LessEqual:
1444    BinaryOp = BO_LE;
1445    return Stmt::BinaryOperatorClass;
1446
1447  case OO_GreaterEqual:
1448    BinaryOp = BO_GE;
1449    return Stmt::BinaryOperatorClass;
1450
1451  case OO_Spaceship:
1452    // FIXME: Update this once we support <=> expressions.
1453    llvm_unreachable("<=> expressions not supported yet");
1454
1455  case OO_AmpAmp:
1456    BinaryOp = BO_LAnd;
1457    return Stmt::BinaryOperatorClass;
1458
1459  case OO_PipePipe:
1460    BinaryOp = BO_LOr;
1461    return Stmt::BinaryOperatorClass;
1462
1463  case OO_PlusPlus:
1464    UnaryOp = S->getNumArgs() == 1? UO_PreInc
1465                                  : UO_PostInc;
1466    return Stmt::UnaryOperatorClass;
1467
1468  case OO_MinusMinus:
1469    UnaryOp = S->getNumArgs() == 1? UO_PreDec
1470                                  : UO_PostDec;
1471    return Stmt::UnaryOperatorClass;
1472
1473  case OO_Comma:
1474    BinaryOp = BO_Comma;
1475    return Stmt::BinaryOperatorClass;
1476
1477  case OO_ArrowStar:
1478    BinaryOp = BO_PtrMemI;
1479    return Stmt::BinaryOperatorClass;
1480
1481  case OO_Subscript:
1482    return Stmt::ArraySubscriptExprClass;
1483
1484  case OO_Coawait:
1485    UnaryOp = UO_Coawait;
1486    return Stmt::UnaryOperatorClass;
1487  }
1488
1489  llvm_unreachable("Invalid overloaded operator expression");
1490}
1491
1492#if defined(_MSC_VER) && !defined(__clang__)
1493#if _MSC_VER == 1911
1494// Work around https://developercommunity.visualstudio.com/content/problem/84002/clang-cl-when-built-with-vc-2017-crashes-cause-vc.html
1495// MSVC 2017 update 3 miscompiles this function, and a clang built with it
1496// will crash in stage 2 of a bootstrap build.
1497#pragma optimize("", off)
1498#endif
1499#endif
1500
1501void StmtProfiler::VisitCXXOperatorCallExpr(const CXXOperatorCallExpr *S) {
1502  if (S->isTypeDependent()) {
1503    // Type-dependent operator calls are profiled like their underlying
1504    // syntactic operator.
1505    //
1506    // An operator call to operator-> is always implicit, so just skip it. The
1507    // enclosing MemberExpr will profile the actual member access.
1508    if (S->getOperator() == OO_Arrow)
1509      return Visit(S->getArg(0));
1510
1511    UnaryOperatorKind UnaryOp = UO_Extension;
1512    BinaryOperatorKind BinaryOp = BO_Comma;
1513    Stmt::StmtClass SC = DecodeOperatorCall(S, UnaryOp, BinaryOp);
1514
1515    ID.AddInteger(SC);
1516    for (unsigned I = 0, N = S->getNumArgs(); I != N; ++I)
1517      Visit(S->getArg(I));
1518    if (SC == Stmt::UnaryOperatorClass)
1519      ID.AddInteger(UnaryOp);
1520    else if (SC == Stmt::BinaryOperatorClass ||
1521             SC == Stmt::CompoundAssignOperatorClass)
1522      ID.AddInteger(BinaryOp);
1523    else
1524      assert(SC == Stmt::ArraySubscriptExprClass);
1525
1526    return;
1527  }
1528
1529  VisitCallExpr(S);
1530  ID.AddInteger(S->getOperator());
1531}
1532
1533#if defined(_MSC_VER) && !defined(__clang__)
1534#if _MSC_VER == 1911
1535#pragma optimize("", on)
1536#endif
1537#endif
1538
1539void StmtProfiler::VisitCXXMemberCallExpr(const CXXMemberCallExpr *S) {
1540  VisitCallExpr(S);
1541}
1542
1543void StmtProfiler::VisitCUDAKernelCallExpr(const CUDAKernelCallExpr *S) {
1544  VisitCallExpr(S);
1545}
1546
1547void StmtProfiler::VisitAsTypeExpr(const AsTypeExpr *S) {
1548  VisitExpr(S);
1549}
1550
1551void StmtProfiler::VisitCXXNamedCastExpr(const CXXNamedCastExpr *S) {
1552  VisitExplicitCastExpr(S);
1553}
1554
1555void StmtProfiler::VisitCXXStaticCastExpr(const CXXStaticCastExpr *S) {
1556  VisitCXXNamedCastExpr(S);
1557}
1558
1559void StmtProfiler::VisitCXXDynamicCastExpr(const CXXDynamicCastExpr *S) {
1560  VisitCXXNamedCastExpr(S);
1561}
1562
1563void
1564StmtProfiler::VisitCXXReinterpretCastExpr(const CXXReinterpretCastExpr *S) {
1565  VisitCXXNamedCastExpr(S);
1566}
1567
1568void StmtProfiler::VisitCXXConstCastExpr(const CXXConstCastExpr *S) {
1569  VisitCXXNamedCastExpr(S);
1570}
1571
1572void StmtProfiler::VisitBuiltinBitCastExpr(const BuiltinBitCastExpr *S) {
1573  VisitExpr(S);
1574  VisitType(S->getTypeInfoAsWritten()->getType());
1575}
1576
1577void StmtProfiler::VisitUserDefinedLiteral(const UserDefinedLiteral *S) {
1578  VisitCallExpr(S);
1579}
1580
1581void StmtProfiler::VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *S) {
1582  VisitExpr(S);
1583  ID.AddBoolean(S->getValue());
1584}
1585
1586void StmtProfiler::VisitCXXNullPtrLiteralExpr(const CXXNullPtrLiteralExpr *S) {
1587  VisitExpr(S);
1588}
1589
1590void StmtProfiler::VisitCXXStdInitializerListExpr(
1591    const CXXStdInitializerListExpr *S) {
1592  VisitExpr(S);
1593}
1594
1595void StmtProfiler::VisitCXXTypeidExpr(const CXXTypeidExpr *S) {
1596  VisitExpr(S);
1597  if (S->isTypeOperand())
1598    VisitType(S->getTypeOperandSourceInfo()->getType());
1599}
1600
1601void StmtProfiler::VisitCXXUuidofExpr(const CXXUuidofExpr *S) {
1602  VisitExpr(S);
1603  if (S->isTypeOperand())
1604    VisitType(S->getTypeOperandSourceInfo()->getType());
1605}
1606
1607void StmtProfiler::VisitMSPropertyRefExpr(const MSPropertyRefExpr *S) {
1608  VisitExpr(S);
1609  VisitDecl(S->getPropertyDecl());
1610}
1611
1612void StmtProfiler::VisitMSPropertySubscriptExpr(
1613    const MSPropertySubscriptExpr *S) {
1614  VisitExpr(S);
1615}
1616
1617void StmtProfiler::VisitCXXThisExpr(const CXXThisExpr *S) {
1618  VisitExpr(S);
1619  ID.AddBoolean(S->isImplicit());
1620}
1621
1622void StmtProfiler::VisitCXXThrowExpr(const CXXThrowExpr *S) {
1623  VisitExpr(S);
1624}
1625
1626void StmtProfiler::VisitCXXDefaultArgExpr(const CXXDefaultArgExpr *S) {
1627  VisitExpr(S);
1628  VisitDecl(S->getParam());
1629}
1630
1631void StmtProfiler::VisitCXXDefaultInitExpr(const CXXDefaultInitExpr *S) {
1632  VisitExpr(S);
1633  VisitDecl(S->getField());
1634}
1635
1636void StmtProfiler::VisitCXXBindTemporaryExpr(const CXXBindTemporaryExpr *S) {
1637  VisitExpr(S);
1638  VisitDecl(
1639         const_cast<CXXDestructorDecl *>(S->getTemporary()->getDestructor()));
1640}
1641
1642void StmtProfiler::VisitCXXConstructExpr(const CXXConstructExpr *S) {
1643  VisitExpr(S);
1644  VisitDecl(S->getConstructor());
1645  ID.AddBoolean(S->isElidable());
1646}
1647
1648void StmtProfiler::VisitCXXInheritedCtorInitExpr(
1649    const CXXInheritedCtorInitExpr *S) {
1650  VisitExpr(S);
1651  VisitDecl(S->getConstructor());
1652}
1653
1654void StmtProfiler::VisitCXXFunctionalCastExpr(const CXXFunctionalCastExpr *S) {
1655  VisitExplicitCastExpr(S);
1656}
1657
1658void
1659StmtProfiler::VisitCXXTemporaryObjectExpr(const CXXTemporaryObjectExpr *S) {
1660  VisitCXXConstructExpr(S);
1661}
1662
1663void
1664StmtProfiler::VisitLambdaExpr(const LambdaExpr *S) {
1665  VisitExpr(S);
1666  for (LambdaExpr::capture_iterator C = S->explicit_capture_begin(),
1667                                 CEnd = S->explicit_capture_end();
1668       C != CEnd; ++C) {
1669    if (C->capturesVLAType())
1670      continue;
1671
1672    ID.AddInteger(C->getCaptureKind());
1673    switch (C->getCaptureKind()) {
1674    case LCK_StarThis:
1675    case LCK_This:
1676      break;
1677    case LCK_ByRef:
1678    case LCK_ByCopy:
1679      VisitDecl(C->getCapturedVar());
1680      ID.AddBoolean(C->isPackExpansion());
1681      break;
1682    case LCK_VLAType:
1683      llvm_unreachable("VLA type in explicit captures.");
1684    }
1685  }
1686  // Note: If we actually needed to be able to match lambda
1687  // expressions, we would have to consider parameters and return type
1688  // here, among other things.
1689  VisitStmt(S->getBody());
1690}
1691
1692void
1693StmtProfiler::VisitCXXScalarValueInitExpr(const CXXScalarValueInitExpr *S) {
1694  VisitExpr(S);
1695}
1696
1697void StmtProfiler::VisitCXXDeleteExpr(const CXXDeleteExpr *S) {
1698  VisitExpr(S);
1699  ID.AddBoolean(S->isGlobalDelete());
1700  ID.AddBoolean(S->isArrayForm());
1701  VisitDecl(S->getOperatorDelete());
1702}
1703
1704void StmtProfiler::VisitCXXNewExpr(const CXXNewExpr *S) {
1705  VisitExpr(S);
1706  VisitType(S->getAllocatedType());
1707  VisitDecl(S->getOperatorNew());
1708  VisitDecl(S->getOperatorDelete());
1709  ID.AddBoolean(S->isArray());
1710  ID.AddInteger(S->getNumPlacementArgs());
1711  ID.AddBoolean(S->isGlobalNew());
1712  ID.AddBoolean(S->isParenTypeId());
1713  ID.AddInteger(S->getInitializationStyle());
1714}
1715
1716void
1717StmtProfiler::VisitCXXPseudoDestructorExpr(const CXXPseudoDestructorExpr *S) {
1718  VisitExpr(S);
1719  ID.AddBoolean(S->isArrow());
1720  VisitNestedNameSpecifier(S->getQualifier());
1721  ID.AddBoolean(S->getScopeTypeInfo() != nullptr);
1722  if (S->getScopeTypeInfo())
1723    VisitType(S->getScopeTypeInfo()->getType());
1724  ID.AddBoolean(S->getDestroyedTypeInfo() != nullptr);
1725  if (S->getDestroyedTypeInfo())
1726    VisitType(S->getDestroyedType());
1727  else
1728    VisitIdentifierInfo(S->getDestroyedTypeIdentifier());
1729}
1730
1731void StmtProfiler::VisitOverloadExpr(const OverloadExpr *S) {
1732  VisitExpr(S);
1733  VisitNestedNameSpecifier(S->getQualifier());
1734  VisitName(S->getName(), /*TreatAsDecl*/ true);
1735  ID.AddBoolean(S->hasExplicitTemplateArgs());
1736  if (S->hasExplicitTemplateArgs())
1737    VisitTemplateArguments(S->getTemplateArgs(), S->getNumTemplateArgs());
1738}
1739
1740void
1741StmtProfiler::VisitUnresolvedLookupExpr(const UnresolvedLookupExpr *S) {
1742  VisitOverloadExpr(S);
1743}
1744
1745void StmtProfiler::VisitTypeTraitExpr(const TypeTraitExpr *S) {
1746  VisitExpr(S);
1747  ID.AddInteger(S->getTrait());
1748  ID.AddInteger(S->getNumArgs());
1749  for (unsigned I = 0, N = S->getNumArgs(); I != N; ++I)
1750    VisitType(S->getArg(I)->getType());
1751}
1752
1753void StmtProfiler::VisitArrayTypeTraitExpr(const ArrayTypeTraitExpr *S) {
1754  VisitExpr(S);
1755  ID.AddInteger(S->getTrait());
1756  VisitType(S->getQueriedType());
1757}
1758
1759void StmtProfiler::VisitExpressionTraitExpr(const ExpressionTraitExpr *S) {
1760  VisitExpr(S);
1761  ID.AddInteger(S->getTrait());
1762  VisitExpr(S->getQueriedExpression());
1763}
1764
1765void StmtProfiler::VisitDependentScopeDeclRefExpr(
1766    const DependentScopeDeclRefExpr *S) {
1767  VisitExpr(S);
1768  VisitName(S->getDeclName());
1769  VisitNestedNameSpecifier(S->getQualifier());
1770  ID.AddBoolean(S->hasExplicitTemplateArgs());
1771  if (S->hasExplicitTemplateArgs())
1772    VisitTemplateArguments(S->getTemplateArgs(), S->getNumTemplateArgs());
1773}
1774
1775void StmtProfiler::VisitExprWithCleanups(const ExprWithCleanups *S) {
1776  VisitExpr(S);
1777}
1778
1779void StmtProfiler::VisitCXXUnresolvedConstructExpr(
1780    const CXXUnresolvedConstructExpr *S) {
1781  VisitExpr(S);
1782  VisitType(S->getTypeAsWritten());
1783  ID.AddInteger(S->isListInitialization());
1784}
1785
1786void StmtProfiler::VisitCXXDependentScopeMemberExpr(
1787    const CXXDependentScopeMemberExpr *S) {
1788  ID.AddBoolean(S->isImplicitAccess());
1789  if (!S->isImplicitAccess()) {
1790    VisitExpr(S);
1791    ID.AddBoolean(S->isArrow());
1792  }
1793  VisitNestedNameSpecifier(S->getQualifier());
1794  VisitName(S->getMember());
1795  ID.AddBoolean(S->hasExplicitTemplateArgs());
1796  if (S->hasExplicitTemplateArgs())
1797    VisitTemplateArguments(S->getTemplateArgs(), S->getNumTemplateArgs());
1798}
1799
1800void StmtProfiler::VisitUnresolvedMemberExpr(const UnresolvedMemberExpr *S) {
1801  ID.AddBoolean(S->isImplicitAccess());
1802  if (!S->isImplicitAccess()) {
1803    VisitExpr(S);
1804    ID.AddBoolean(S->isArrow());
1805  }
1806  VisitNestedNameSpecifier(S->getQualifier());
1807  VisitName(S->getMemberName());
1808  ID.AddBoolean(S->hasExplicitTemplateArgs());
1809  if (S->hasExplicitTemplateArgs())
1810    VisitTemplateArguments(S->getTemplateArgs(), S->getNumTemplateArgs());
1811}
1812
1813void StmtProfiler::VisitCXXNoexceptExpr(const CXXNoexceptExpr *S) {
1814  VisitExpr(S);
1815}
1816
1817void StmtProfiler::VisitPackExpansionExpr(const PackExpansionExpr *S) {
1818  VisitExpr(S);
1819}
1820
1821void StmtProfiler::VisitSizeOfPackExpr(const SizeOfPackExpr *S) {
1822  VisitExpr(S);
1823  VisitDecl(S->getPack());
1824  if (S->isPartiallySubstituted()) {
1825    auto Args = S->getPartialArguments();
1826    ID.AddInteger(Args.size());
1827    for (const auto &TA : Args)
1828      VisitTemplateArgument(TA);
1829  } else {
1830    ID.AddInteger(0);
1831  }
1832}
1833
1834void StmtProfiler::VisitSubstNonTypeTemplateParmPackExpr(
1835    const SubstNonTypeTemplateParmPackExpr *S) {
1836  VisitExpr(S);
1837  VisitDecl(S->getParameterPack());
1838  VisitTemplateArgument(S->getArgumentPack());
1839}
1840
1841void StmtProfiler::VisitSubstNonTypeTemplateParmExpr(
1842    const SubstNonTypeTemplateParmExpr *E) {
1843  // Profile exactly as the replacement expression.
1844  Visit(E->getReplacement());
1845}
1846
1847void StmtProfiler::VisitFunctionParmPackExpr(const FunctionParmPackExpr *S) {
1848  VisitExpr(S);
1849  VisitDecl(S->getParameterPack());
1850  ID.AddInteger(S->getNumExpansions());
1851  for (FunctionParmPackExpr::iterator I = S->begin(), E = S->end(); I != E; ++I)
1852    VisitDecl(*I);
1853}
1854
1855void StmtProfiler::VisitMaterializeTemporaryExpr(
1856                                           const MaterializeTemporaryExpr *S) {
1857  VisitExpr(S);
1858}
1859
1860void StmtProfiler::VisitCXXFoldExpr(const CXXFoldExpr *S) {
1861  VisitExpr(S);
1862  ID.AddInteger(S->getOperator());
1863}
1864
1865void StmtProfiler::VisitCoroutineBodyStmt(const CoroutineBodyStmt *S) {
1866  VisitStmt(S);
1867}
1868
1869void StmtProfiler::VisitCoreturnStmt(const CoreturnStmt *S) {
1870  VisitStmt(S);
1871}
1872
1873void StmtProfiler::VisitCoawaitExpr(const CoawaitExpr *S) {
1874  VisitExpr(S);
1875}
1876
1877void StmtProfiler::VisitDependentCoawaitExpr(const DependentCoawaitExpr *S) {
1878  VisitExpr(S);
1879}
1880
1881void StmtProfiler::VisitCoyieldExpr(const CoyieldExpr *S) {
1882  VisitExpr(S);
1883}
1884
1885void StmtProfiler::VisitOpaqueValueExpr(const OpaqueValueExpr *E) {
1886  VisitExpr(E);
1887}
1888
1889void StmtProfiler::VisitTypoExpr(const TypoExpr *E) {
1890  VisitExpr(E);
1891}
1892
1893void StmtProfiler::VisitSourceLocExpr(const SourceLocExpr *E) {
1894  VisitExpr(E);
1895}
1896
1897void StmtProfiler::VisitObjCStringLiteral(const ObjCStringLiteral *S) {
1898  VisitExpr(S);
1899}
1900
1901void StmtProfiler::VisitObjCBoxedExpr(const ObjCBoxedExpr *E) {
1902  VisitExpr(E);
1903}
1904
1905void StmtProfiler::VisitObjCArrayLiteral(const ObjCArrayLiteral *E) {
1906  VisitExpr(E);
1907}
1908
1909void StmtProfiler::VisitObjCDictionaryLiteral(const ObjCDictionaryLiteral *E) {
1910  VisitExpr(E);
1911}
1912
1913void StmtProfiler::VisitObjCEncodeExpr(const ObjCEncodeExpr *S) {
1914  VisitExpr(S);
1915  VisitType(S->getEncodedType());
1916}
1917
1918void StmtProfiler::VisitObjCSelectorExpr(const ObjCSelectorExpr *S) {
1919  VisitExpr(S);
1920  VisitName(S->getSelector());
1921}
1922
1923void StmtProfiler::VisitObjCProtocolExpr(const ObjCProtocolExpr *S) {
1924  VisitExpr(S);
1925  VisitDecl(S->getProtocol());
1926}
1927
1928void StmtProfiler::VisitObjCIvarRefExpr(const ObjCIvarRefExpr *S) {
1929  VisitExpr(S);
1930  VisitDecl(S->getDecl());
1931  ID.AddBoolean(S->isArrow());
1932  ID.AddBoolean(S->isFreeIvar());
1933}
1934
1935void StmtProfiler::VisitObjCPropertyRefExpr(const ObjCPropertyRefExpr *S) {
1936  VisitExpr(S);
1937  if (S->isImplicitProperty()) {
1938    VisitDecl(S->getImplicitPropertyGetter());
1939    VisitDecl(S->getImplicitPropertySetter());
1940  } else {
1941    VisitDecl(S->getExplicitProperty());
1942  }
1943  if (S->isSuperReceiver()) {
1944    ID.AddBoolean(S->isSuperReceiver());
1945    VisitType(S->getSuperReceiverType());
1946  }
1947}
1948
1949void StmtProfiler::VisitObjCSubscriptRefExpr(const ObjCSubscriptRefExpr *S) {
1950  VisitExpr(S);
1951  VisitDecl(S->getAtIndexMethodDecl());
1952  VisitDecl(S->setAtIndexMethodDecl());
1953}
1954
1955void StmtProfiler::VisitObjCMessageExpr(const ObjCMessageExpr *S) {
1956  VisitExpr(S);
1957  VisitName(S->getSelector());
1958  VisitDecl(S->getMethodDecl());
1959}
1960
1961void StmtProfiler::VisitObjCIsaExpr(const ObjCIsaExpr *S) {
1962  VisitExpr(S);
1963  ID.AddBoolean(S->isArrow());
1964}
1965
1966void StmtProfiler::VisitObjCBoolLiteralExpr(const ObjCBoolLiteralExpr *S) {
1967  VisitExpr(S);
1968  ID.AddBoolean(S->getValue());
1969}
1970
1971void StmtProfiler::VisitObjCIndirectCopyRestoreExpr(
1972    const ObjCIndirectCopyRestoreExpr *S) {
1973  VisitExpr(S);
1974  ID.AddBoolean(S->shouldCopy());
1975}
1976
1977void StmtProfiler::VisitObjCBridgedCastExpr(const ObjCBridgedCastExpr *S) {
1978  VisitExplicitCastExpr(S);
1979  ID.AddBoolean(S->getBridgeKind());
1980}
1981
1982void StmtProfiler::VisitObjCAvailabilityCheckExpr(
1983    const ObjCAvailabilityCheckExpr *S) {
1984  VisitExpr(S);
1985}
1986
1987void StmtProfiler::VisitTemplateArguments(const TemplateArgumentLoc *Args,
1988                                          unsigned NumArgs) {
1989  ID.AddInteger(NumArgs);
1990  for (unsigned I = 0; I != NumArgs; ++I)
1991    VisitTemplateArgument(Args[I].getArgument());
1992}
1993
1994void StmtProfiler::VisitTemplateArgument(const TemplateArgument &Arg) {
1995  // Mostly repetitive with TemplateArgument::Profile!
1996  ID.AddInteger(Arg.getKind());
1997  switch (Arg.getKind()) {
1998  case TemplateArgument::Null:
1999    break;
2000
2001  case TemplateArgument::Type:
2002    VisitType(Arg.getAsType());
2003    break;
2004
2005  case TemplateArgument::Template:
2006  case TemplateArgument::TemplateExpansion:
2007    VisitTemplateName(Arg.getAsTemplateOrTemplatePattern());
2008    break;
2009
2010  case TemplateArgument::Declaration:
2011    VisitDecl(Arg.getAsDecl());
2012    break;
2013
2014  case TemplateArgument::NullPtr:
2015    VisitType(Arg.getNullPtrType());
2016    break;
2017
2018  case TemplateArgument::Integral:
2019    Arg.getAsIntegral().Profile(ID);
2020    VisitType(Arg.getIntegralType());
2021    break;
2022
2023  case TemplateArgument::Expression:
2024    Visit(Arg.getAsExpr());
2025    break;
2026
2027  case TemplateArgument::Pack:
2028    for (const auto &P : Arg.pack_elements())
2029      VisitTemplateArgument(P);
2030    break;
2031  }
2032}
2033
2034void Stmt::Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
2035                   bool Canonical) const {
2036  StmtProfilerWithPointers Profiler(ID, Context, Canonical);
2037  Profiler.Visit(this);
2038}
2039
2040void Stmt::ProcessODRHash(llvm::FoldingSetNodeID &ID,
2041                          class ODRHash &Hash) const {
2042  StmtProfilerWithoutPointers Profiler(ID, Hash);
2043  Profiler.Visit(this);
2044}
2045