Coverage Report

Created: 2022-07-16 07:03

/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/include/clang/AST/StmtVisitor.h
Line
Count
Source (jump to first uncovered line)
1
//===- StmtVisitor.h - Visitor for Stmt subclasses --------------*- C++ -*-===//
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 defines the StmtVisitor and ConstStmtVisitor interfaces.
10
//
11
//===----------------------------------------------------------------------===//
12
13
#ifndef LLVM_CLANG_AST_STMTVISITOR_H
14
#define LLVM_CLANG_AST_STMTVISITOR_H
15
16
#include "clang/AST/ExprConcepts.h"
17
#include "clang/AST/ExprCXX.h"
18
#include "clang/AST/ExprObjC.h"
19
#include "clang/AST/ExprOpenMP.h"
20
#include "clang/AST/Stmt.h"
21
#include "clang/AST/StmtCXX.h"
22
#include "clang/AST/StmtObjC.h"
23
#include "clang/AST/StmtOpenMP.h"
24
#include "clang/Basic/LLVM.h"
25
#include "llvm/ADT/STLExtras.h"
26
#include "llvm/Support/Casting.h"
27
#include "llvm/Support/ErrorHandling.h"
28
#include <utility>
29
30
namespace clang {
31
/// StmtVisitorBase - This class implements a simple visitor for Stmt
32
/// subclasses. Since Expr derives from Stmt, this also includes support for
33
/// visiting Exprs.
34
template<template <typename> class Ptr, typename ImplClass, typename RetTy=void,
35
         class... ParamTys>
36
class StmtVisitorBase {
37
public:
38
#define PTR(CLASS) typename Ptr<CLASS>::type
39
#define DISPATCH(NAME, CLASS) \
40
237M
  return static_cast<ImplClass*>(this)->Visit ## NAME( \
41
237M
    static_cast<PTR(CLASS)>(S), std::forward<ParamTys>(P)...)
42
43
165M
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
165M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
15.7M
      switch (BinOp->getOpcode()) {
49
34.5k
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
640
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
468k
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
818k
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
48.4k
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
2.41M
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
2.18M
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
340k
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
40.4k
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
857k
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
630k
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
118k
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
107k
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
466k
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
176k
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
1.35k
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
158k
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
37.8k
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
139k
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
1.81M
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
376k
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
3.45M
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
54.9k
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
6.93k
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
1.98k
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
142k
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
23.3k
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
2.33k
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
1.45k
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
6.16k
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
32.3k
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
4.86k
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
814k
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
15.7M
      }
85
150M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
4.39M
      switch (UnOp->getOpcode()) {
87
125k
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
2.22k
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
480k
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
37.2k
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
562k
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
472k
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
914
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
1.20M
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
88.5k
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
1.37M
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
521
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
474
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
48.4k
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
11
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
4.39M
      }
102
4.39M
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
145M
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
145M
    case Stmt::CLASS ## Class: 
DISPATCH145M
(CLASS, CLASS);
110
145M
#include 
"clang/AST/StmtNodes.inc"0
111
145M
    }
112
145M
  }
clang::StmtVisitorBase<llvm::make_const_ptr, clang::JSONDumper, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
2.79k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
2.79k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
214
      switch (BinOp->getOpcode()) {
49
2
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
2
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
17
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
1
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
1
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
26
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
6
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
1
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
1
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
19
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
1
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
1
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
1
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
64
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
4
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
1
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
1
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
1
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
1
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
2
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
58
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
1
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
2
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
214
      }
85
2.58k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
46
      switch (UnOp->getOpcode()) {
87
2
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
21
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
6
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
6
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
1
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
5
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
2
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
3
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
46
      }
102
46
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
2.53k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
2.53k
    }
112
2.53k
  }
clang::StmtVisitorBase<llvm::make_const_ptr, clang::ASTDumper, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
34.8k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
34.8k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
1.86k
      switch (BinOp->getOpcode()) {
49
5
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
4
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
32
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
58
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
6
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
344
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
176
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
2
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
2
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
874
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
2
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
2
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
2
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
50
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
12
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
1
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
2
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
4
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
2
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
2
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
5
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
174
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
5
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
1
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
84
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
1
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
1
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
1
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
1
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
1
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
8
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
1.86k
      }
85
32.9k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
1.20k
      switch (UnOp->getOpcode()) {
87
797
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
3
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
139
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
8
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
84
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
69
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
15
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
65
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
4
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
10
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
4
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
2
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
2
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
1.20k
      }
102
1.20k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
31.7k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
31.7k
    }
112
31.7k
  }
Expr.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::SideEffectFinder, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
104
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
104
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
0
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
0
      }
85
104
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
5
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
5
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
5
      }
102
5
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
99
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
99
    }
112
99
  }
Expr.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::NonTrivialCallFinder, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
27.9k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
27.9k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
5.33k
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
581
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
8
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
2.38k
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
28
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
2.32k
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
8
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
12
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
5.33k
      }
85
22.6k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
662
      switch (UnOp->getOpcode()) {
87
326
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
218
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
118
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
662
      }
102
662
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
21.9k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
21.9k
    }
112
21.9k
  }
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::LValueExprEvaluator, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
12.0M
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
12.0M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
1.05M
      switch (BinOp->getOpcode()) {
49
303
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
212
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
990k
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
5.40k
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
1.06k
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
207
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
37.3k
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
3.03k
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
370
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
129
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
700
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
10.1k
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
1.55k
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
3.72k
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
1.05M
      }
85
10.9M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
175k
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
52.1k
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
5.44k
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
117k
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
132
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
111
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
264
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
175k
      }
102
175k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
10.8M
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
10.8M
    }
112
10.8M
  }
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::PointerExprEvaluator, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
2.26M
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
2.26M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
72.9k
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
56.9k
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
10.7k
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
5.08k
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
99
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
20
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
97
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
72.9k
      }
85
2.19M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
58.3k
      switch (UnOp->getOpcode()) {
87
3.62k
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
26
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
32
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
23
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
54.5k
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
19
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
32
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
58.3k
      }
102
58.3k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
2.13M
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
2.13M
    }
112
2.13M
  }
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::MemberPointerExprEvaluator, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
3.89k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
3.89k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
0
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
0
      }
85
3.89k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
1.66k
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
1.66k
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
1.66k
      }
102
1.66k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
2.23k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
2.23k
    }
112
2.23k
  }
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::IntExprEvaluator, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
29.5M
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
29.5M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
3.55M
      switch (BinOp->getOpcode()) {
49
2
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
90.7k
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
105k
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
10.7k
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
789k
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
690k
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
235k
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
9.25k
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
369k
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
380k
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
20.4k
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
49.3k
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
203k
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
85.1k
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
49.0k
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
6.76k
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
57.9k
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
235k
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
49.3k
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
104k
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
306
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
201
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
160
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
996
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
454
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
143
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
136
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
612
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
547
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
201
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
2.36k
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
3.55M
      }
85
26.0M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
1.18M
      switch (UnOp->getOpcode()) {
87
2.23k
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
135
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
311
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
1.89k
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
129
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
899k
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
18.2k
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
259k
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
6
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
9
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
289
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
1.18M
      }
102
1.18M
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
24.8M
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
24.8M
    }
112
24.8M
  }
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::ComplexExprEvaluator, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
5.53k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
5.53k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
1.77k
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
344
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
226
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
681
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
254
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
253
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
1
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
5
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
7
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
4
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
1.77k
      }
85
3.76k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
64
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
4
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
17
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
5
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
38
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
64
      }
102
64
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
3.69k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
3.69k
    }
112
3.69k
  }
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::FloatExprEvaluator, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
325k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
325k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
63.3k
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
5.64k
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
7.87k
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
14.3k
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
6.03k
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
25.0k
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
1.07k
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
1.04k
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
1.11k
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
1.07k
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
23
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
63.3k
      }
85
262k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
3.28k
      switch (UnOp->getOpcode()) {
87
61
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
12
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
8
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
27
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
2.75k
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
43
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
29
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
349
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
3.28k
      }
102
3.28k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
258k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
258k
    }
112
258k
  }
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::FixedPointExprEvaluator, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
4.03k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
4.03k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
1.27k
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
117
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
184
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
119
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
160
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
105
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
40
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
496
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
6
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
6
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
28
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
6
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
4
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
2
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
3
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
1.27k
      }
85
2.75k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
282
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
282
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
282
      }
102
282
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
2.47k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
2.47k
    }
112
2.47k
  }
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::RecordExprEvaluator, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
134k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
134k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
740
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
690
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
24
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
26
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
740
      }
85
134k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
0
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
0
      }
102
0
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
134k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
134k
    }
112
134k
  }
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::TemporaryExprEvaluator, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
2
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
2
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
0
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
0
      }
85
2
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
0
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
0
      }
102
0
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
2
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
2
    }
112
2
  }
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::ArrayExprEvaluator, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
12.9k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
12.9k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
0
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
0
      }
85
12.9k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
0
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
0
      }
102
0
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
12.9k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
12.9k
    }
112
12.9k
  }
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::AtomicExprEvaluator, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
430
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
430
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
0
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
0
      }
85
430
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
0
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
0
      }
102
0
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
430
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
430
    }
112
430
  }
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::VectorExprEvaluator, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
1.85M
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
1.85M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
528k
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
21.0k
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
3.26k
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
221
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
26.4k
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
22.4k
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
410
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
212
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
3.81k
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
6.95k
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
3.79k
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
3.79k
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
7.78k
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
263
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
20.0k
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
9.15k
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
13.0k
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
55
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
43
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
385k
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
86
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
85
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
60
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
126
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
95
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
161
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
51
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
75
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
71
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
70
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
1
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
528k
      }
85
1.32M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
22.5k
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
1
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
25
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
3.36k
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
15.6k
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
21
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
3.41k
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
22.5k
      }
102
22.5k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
1.30M
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
1.30M
    }
112
1.30M
  }
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::VoidExprEvaluator, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
6.93k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
6.93k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
183
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
183
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
183
      }
85
6.75k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
0
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
0
      }
102
0
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
6.75k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
6.75k
    }
112
6.75k
  }
clang::StmtVisitorBase<llvm::make_const_ptr, clang::interp::ByteCodeExprGen<clang::interp::ByteCodeEmitter>, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
12
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
12
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
4
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
2
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
1
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
1
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
4
      }
85
8
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
0
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
0
      }
102
0
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
8
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
8
    }
112
8
  }
clang::StmtVisitorBase<llvm::make_const_ptr, clang::interp::ByteCodeExprGen<clang::interp::EvalEmitter>, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
31
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
31
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
11
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
2
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
3
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
6
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
11
      }
85
20
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
0
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
0
      }
102
0
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
20
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
20
    }
112
20
  }
clang::StmtVisitorBase<llvm::make_const_ptr, clang::JSONNodeDumper, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
2.79k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
2.79k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
214
      switch (BinOp->getOpcode()) {
49
2
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
2
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
17
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
1
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
1
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
26
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
6
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
1
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
1
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
19
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
1
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
1
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
1
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
64
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
4
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
1
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
1
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
1
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
1
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
2
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
58
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
1
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
2
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
214
      }
85
2.58k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
46
      switch (UnOp->getOpcode()) {
87
2
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
21
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
6
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
6
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
1
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
5
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
2
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
3
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
46
      }
102
46
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
2.53k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
2.53k
    }
112
2.53k
  }
StmtPrinter.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::StmtPrinter, void>::Visit(clang::Stmt*)
Line
Count
Source
43
406k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
406k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
21.7k
      switch (BinOp->getOpcode()) {
49
8
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
67
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
8
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
5
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
1.87k
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
688
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
44
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
8.18k
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
1.29k
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
30
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
12
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
666
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
303
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
1
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
20
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
8
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
3.34k
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
963
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
3.52k
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
31
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
11
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
7
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
468
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
31
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
7
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
7
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
7
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
7
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
7
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
85
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
21.7k
      }
85
384k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
51.8k
      switch (UnOp->getOpcode()) {
87
2.15k
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
4
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
8.35k
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
18
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
1.19k
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
667
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
11
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
132
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
39.3k
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
4
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
2
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
2
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
51.8k
      }
102
51.8k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
332k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
332k
    }
112
332k
  }
StmtProfile.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::StmtProfiler, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
21.5M
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
21.5M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
1.99M
      switch (BinOp->getOpcode()) {
49
32.3k
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
30
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
20.7k
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
68.1k
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
18.4k
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
42.7k
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
38.1k
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
14.3k
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
3.43k
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
6.25k
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
4.68k
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
36.2k
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
11.2k
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
78.4k
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
29.5k
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
168
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
7.11k
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
738
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
7.78k
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
1.26M
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
245k
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
48.0k
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
215
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
264
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
169
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
4.11k
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
1.45k
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
97
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
88
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
301
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
1.47k
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
45
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
7.72k
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
1.99M
      }
85
19.5M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
893k
      switch (UnOp->getOpcode()) {
87
1.31k
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
28
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
13.0k
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
3.29k
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
5.39k
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
57.1k
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
124
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
32.9k
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
2.89k
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
775k
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
2
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
1.53k
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
6
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
893k
      }
102
893k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
18.6M
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
18.6M
    }
112
18.6M
  }
clang::StmtVisitorBase<llvm::make_const_ptr, clang::TextNodeDumper, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
34.8k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
34.8k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
1.86k
      switch (BinOp->getOpcode()) {
49
5
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
4
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
32
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
58
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
6
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
344
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
176
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
2
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
2
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
874
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
2
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
2
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
2
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
50
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
12
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
1
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
2
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
4
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
2
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
2
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
5
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
174
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
5
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
1
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
84
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
1
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
1
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
1
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
1
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
1
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
8
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
1.86k
      }
85
32.9k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
1.20k
      switch (UnOp->getOpcode()) {
87
797
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
3
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
139
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
8
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
84
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
69
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
15
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
65
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
4
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
10
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
4
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
2
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
2
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
1.20k
      }
102
1.20k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
31.7k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
31.7k
    }
112
31.7k
  }
clang::StmtVisitorBase<std::__1::add_pointer, clang::ASTStmtReader, void>::Visit(clang::Stmt*)
Line
Count
Source
43
12.4M
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
12.4M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
817k
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
42.9k
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
774k
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
817k
      }
85
11.6M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
349k
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
349k
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
349k
      }
102
349k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
11.3M
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
11.3M
    }
112
11.3M
  }
clang::StmtVisitorBase<std::__1::add_pointer, clang::ASTStmtWriter, void>::Visit(clang::Stmt*)
Line
Count
Source
43
5.19M
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
5.19M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
379k
      switch (BinOp->getOpcode()) {
49
228
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
30
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
22.6k
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
16.8k
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
1.99k
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
55.4k
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
38.5k
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
14.7k
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
2.73k
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
19.2k
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
11.7k
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
8.87k
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
2.26k
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
10.1k
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
3.71k
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
31
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
6.51k
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
717
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
7.15k
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
29.0k
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
6.61k
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
101k
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
432
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
450
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
169
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
9.93k
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
1.85k
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
102
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
88
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
326
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
1.49k
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
175
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
3.21k
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
379k
      }
85
4.81M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
128k
      switch (UnOp->getOpcode()) {
87
4.42k
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
104
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
20.3k
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
3.22k
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
5.31k
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
29.2k
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
47
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
31.0k
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
3.02k
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
29.8k
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
2
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
1.56k
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
5
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
128k
      }
102
128k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
4.68M
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
4.68M
    }
112
4.68M
  }
AnalysisBasedWarnings.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::ContainsReference, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
451
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
451
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
32
      switch (BinOp->getOpcode()) {
49
1
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
11
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
1
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
6
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
13
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
32
      }
85
419
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
8
      switch (UnOp->getOpcode()) {
87
4
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
2
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
2
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
8
      }
102
8
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
411
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
411
    }
112
411
  }
Sema.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::DeferredDiagnosticsEmitter, void>::Visit(clang::Stmt*)
Line
Count
Source
43
834k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
834k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
56.4k
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
1.19k
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
271
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
5.67k
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
230
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
10
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
38
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
11.0k
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
252
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
228
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
400
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
179
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
9
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
80
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
38
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
10
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
198
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
108
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
17.3k
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
66
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
28
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
18.5k
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
364
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
14
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
10
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
100
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
56.4k
      }
85
778k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
32.2k
      switch (UnOp->getOpcode()) {
87
5.38k
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
152
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
9.44k
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
24
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
224
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
16.1k
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
16
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
658
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
46
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
78
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
32
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
32
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
9
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
32.2k
      }
102
32.2k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
745k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
745k
    }
112
745k
  }
SemaChecking.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::SequenceChecker, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
59.0M
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
59.0M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
5.78M
      switch (BinOp->getOpcode()) {
49
394
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
302
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
215k
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
503k
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
10.6k
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
1.22M
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
1.18M
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
49.9k
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
17.7k
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
237k
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
198k
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
21.3k
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
27.4k
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
109k
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
39.2k
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
363
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
59.7k
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
16.0k
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
42.3k
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
192k
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
51.7k
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
1.50M
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
2.63k
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
2.35k
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
426
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
36.7k
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
4.66k
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
659
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
310
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
1.38k
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
10.7k
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
1.79k
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
7.38k
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
5.78M
      }
85
53.2M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
926k
      switch (UnOp->getOpcode()) {
87
57.9k
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
872
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
196k
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
7.86k
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
84.5k
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
136k
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
387
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
186k
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
29.6k
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
190k
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
167
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
160
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
36.1k
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
926k
      }
102
926k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
52.3M
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
52.3M
    }
112
52.3M
  }
SemaChecking.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::FindCaptureVisitor, void>::Visit(clang::Stmt*)
Line
Count
Source
43
148
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
148
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
2
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
1
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
1
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
2
      }
85
146
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
0
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
0
      }
102
0
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
146
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
146
    }
112
146
  }
SemaDecl.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::SelfReferenceChecker, void>::Visit(clang::Stmt*)
Line
Count
Source
43
1.63M
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
1.63M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
164k
      switch (BinOp->getOpcode()) {
49
29
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
5
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
35.3k
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
37.5k
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
83
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
16.8k
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
13.7k
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
11.0k
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
436
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
25.6k
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
56
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
7.03k
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
606
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
3.48k
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
39
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
86
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
927
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
2.64k
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
1.09k
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
6.27k
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
503
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
376
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
7
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
1
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
4
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
19
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
1
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
4
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
1
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
1
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
1
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
1
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
227
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
164k
      }
85
1.47M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
54.4k
      switch (UnOp->getOpcode()) {
87
45
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
2
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
47
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
7
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
13.9k
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
9.40k
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
14
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
21.2k
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
5.51k
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
4.18k
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
9
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
9
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
54.4k
      }
102
54.4k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
1.41M
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
1.41M
    }
112
1.41M
  }
SemaDeclCXX.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::UninitializedFieldVisitor, void>::Visit(clang::Stmt*)
Line
Count
Source
43
63.7k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
63.7k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
1.88k
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
49
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
9
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
1.77k
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
6
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
6
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
3
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
4
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
3
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
18
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
3
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
9
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
1.88k
      }
85
61.8k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
191
      switch (UnOp->getOpcode()) {
87
20
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
18
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
118
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
23
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
11
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
1
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
191
      }
102
191
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
61.6k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
61.6k
    }
112
61.6k
  }
SemaDeclCXX.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::CheckDefaultArgumentVisitor, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
130k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
130k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
882
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
4
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
35
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
14
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
4
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
813
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
12
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
882
      }
85
129k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
65
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
15
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
50
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
65
      }
102
65
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
129k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
129k
    }
112
129k
  }
SemaExpr.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::EvaluatedExprMarker, void>::Visit(clang::Stmt*)
Line
Count
Source
43
176k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
176k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
167
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
4
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
13
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
20
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
2
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
116
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
2
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
10
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
167
      }
85
176k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
51
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
20
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
14
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
15
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
2
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
51
      }
102
51
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
176k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
176k
    }
112
176k
  }
SemaExpr.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::RebuildUnknownAnyFunction, clang::ActionResult<clang::Expr*, true> >::Visit(clang::Stmt*)
Line
Count
Source
43
5
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
5
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
0
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
0
      }
85
5
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
0
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
0
      }
102
0
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
5
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
5
    }
112
5
  }
SemaExpr.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::RebuildUnknownAnyExpr, clang::ActionResult<clang::Expr*, true> >::Visit(clang::Stmt*)
Line
Count
Source
43
796
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
796
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
0
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
0
      }
85
796
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
4
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
4
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
4
      }
102
4
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
792
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
792
    }
112
792
  }
SemaExprObjC.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::ARCCastChecker, (anonymous namespace)::ACCResult>::Visit(clang::Stmt*)
Line
Count
Source
43
1.77k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
1.77k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
3
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
3
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
3
      }
85
1.77k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
4
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
4
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
4
      }
102
4
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
1.77k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
1.77k
    }
112
1.77k
  }
SemaOpenMP.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::AllocatorChecker, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
340
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
340
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
0
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
0
      }
85
340
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
0
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
0
      }
102
0
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
340
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
340
    }
112
340
  }
SemaOpenMP.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::(anonymous namespace)::LoopCounterRefChecker, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
389k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
389k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
845
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
99
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
92
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
490
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
157
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
7
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
845
      }
85
388k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
503
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
4
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
144
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
337
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
18
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
503
      }
102
503
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
388k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
388k
    }
112
388k
  }
SemaOpenMP.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::DSARefChecker, bool>::Visit(clang::Stmt*)
Line
Count
Source
43
17.0k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
17.0k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
0
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
0
      }
85
17.0k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
0
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
0
      }
102
0
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
17.0k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
17.0k
    }
112
17.0k
  }
SemaOpenMP.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::MapBaseChecker, bool>::Visit(clang::Stmt*)
Line
Count
Source
43
74.2k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
74.2k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
569
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
566
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
3
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
569
      }
85
73.7k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
747
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
747
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
747
      }
102
747
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
72.9k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
72.9k
    }
112
72.9k
  }
SemaOpenMP.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::LocalVarRefChecker, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
2.31k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
2.31k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
0
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
0
      }
85
2.31k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
0
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
0
      }
102
0
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
2.31k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
2.31k
    }
112
2.31k
  }
SemaOpenMP.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::DSAAttrChecker, void>::Visit(clang::Stmt*)
Line
Count
Source
43
2.49M
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
2.49M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
232k
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
1.47k
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
158
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
8.51k
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
22.3k
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
120k
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
1.91k
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
396
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
656
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
336
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
281
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
80
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
57.6k
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
105
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
138
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
16
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
16.4k
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
885
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
14
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
10
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
404
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
232k
      }
85
2.25M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
136k
      switch (UnOp->getOpcode()) {
87
32.7k
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
412
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
101k
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
185
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
122
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
694
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
724
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
348
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
40
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
136k
      }
102
136k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
2.12M
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
2.12M
    }
112
2.12M
  }
SemaStmt.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::BreakContinueFinder, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
56.3k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
56.3k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
9.14k
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
49
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
7
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
11
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
32
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
3
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
4
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
8.40k
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
75
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
79
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
23
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
107
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
56
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
26
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
23
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
57
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
4
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
4
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
4
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
23
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
4
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
4
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
15
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
4
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
4
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
4
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
110
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
9.14k
      }
85
47.1k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
8.70k
      switch (UnOp->getOpcode()) {
87
1.01k
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
43
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
7.48k
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
38
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
24
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
75
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
17
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
9
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
8.70k
      }
102
8.70k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
38.4k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
38.4k
    }
112
38.4k
  }
SemaStmt.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::DeclExtractor, void>::Visit(clang::Stmt*)
Line
Count
Source
43
649
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
649
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
141
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
88
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
2
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
40
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
3
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
6
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
2
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
141
      }
85
508
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
4
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
1
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
2
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
1
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
4
      }
102
4
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
504
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
504
    }
112
504
  }
SemaStmt.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::DeclMatcher, void>::Visit(clang::Stmt*)
Line
Count
Source
43
613
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
613
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
157
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
92
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
2
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
33
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
3
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
6
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
2
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
19
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
157
      }
85
456
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
32
      switch (UnOp->getOpcode()) {
87
2
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
23
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
1
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
2
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
2
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
2
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
32
      }
102
32
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
424
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
424
    }
112
424
  }
SemaStmt.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::CommaVisitor, void>::Visit(clang::Stmt*)
Line
Count
Source
43
822
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
822
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
180
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
140
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
5
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
35
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
180
      }
85
642
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
0
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
0
      }
102
0
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
642
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
642
    }
112
642
  }
SemaStmtAttr.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::CallExprFinder, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
140
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
140
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
13
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
10
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
3
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
13
      }
85
127
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
0
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
0
      }
102
0
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
127
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
127
    }
112
127
  }
AnalysisDeclContext.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::FindBlockDeclRefExprsVals, void>::Visit(clang::Stmt*)
Line
Count
Source
43
2.45k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
2.45k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
165
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
22
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
4
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
6
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
12
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
2
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
119
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
165
      }
85
2.29k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
80
      switch (UnOp->getOpcode()) {
87
2
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
12
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
13
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
53
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
80
      }
102
80
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
2.21k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
2.21k
    }
112
2.21k
  }
CalledOnceCheck.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::DeclRefFinder, clang::DeclRefExpr const*>::Visit(clang::Stmt const*)
Line
Count
Source
43
873
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
873
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
11
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
6
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
3
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
1
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
1
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
11
      }
85
862
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
27
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
2
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
25
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
27
      }
102
27
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
835
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
835
    }
112
835
  }
CalledOnceCheck.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::CalledOnceChecker, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
1.16k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
1.16k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
28
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
1
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
2
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
3
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
6
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
3
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
10
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
2
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
1
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
28
      }
85
1.13k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
26
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
3
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
2
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
2
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
19
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
26
      }
102
26
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
1.11k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
1.11k
    }
112
1.11k
  }
CalledOnceCheck.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::NotCalledClarifier, llvm::Optional<(anonymous namespace)::Clarification> >::Visit(clang::Stmt const*)
Line
Count
Source
43
45
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
45
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
2
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
1
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
1
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
2
      }
85
43
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
0
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
0
      }
102
0
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
43
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
43
    }
112
43
  }
CFG.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::CFGBlockTerminatorPrint, void>::Visit(clang::Stmt*)
Line
Count
Source
43
560
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
560
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
37
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
9
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
28
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
37
      }
85
523
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
0
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
0
      }
102
0
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
523
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
523
    }
112
523
  }
clang::StmtVisitorBase<llvm::make_const_ptr, clang::consumed::ConsumedStmtVisitor, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
2.09k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
2.09k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
96
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
2
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
2
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
2
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
2
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
2
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
2
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
2
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
5
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
3
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
2
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
2
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
2
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
2
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
2
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
2
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
2
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
3
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
4
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
43
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
1
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
1
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
1
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
1
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
1
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
1
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
1
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
1
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
1
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
1
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
96
      }
85
1.99k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
23
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
1
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
1
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
3
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
1
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
17
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
23
      }
102
23
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
1.97k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
1.97k
    }
112
1.97k
  }
ThreadSafety.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::VarMapBuilder, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
36.4k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
36.4k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
2.01k
      switch (BinOp->getOpcode()) {
49
8
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
4
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
2
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
2
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
2
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
102
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
2
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
2
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
2
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
40
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
34
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
2
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
2
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
197
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
14
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
2
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
2
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
6
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
9
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
5
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
1.55k
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
1
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
1
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
1
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
6
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
2
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
1
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
1
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
1
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
1
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
1
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
2.01k
      }
85
34.4k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
852
      switch (UnOp->getOpcode()) {
87
8
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
4
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
44
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
4
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
410
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
304
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
1
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
77
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
852
      }
102
852
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
33.6k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
33.6k
    }
112
33.6k
  }
ThreadSafety.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::BuildLockset, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
36.2k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
36.2k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
2.01k
      switch (BinOp->getOpcode()) {
49
8
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
4
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
2
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
2
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
2
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
102
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
2
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
2
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
2
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
40
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
34
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
2
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
2
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
197
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
14
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
2
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
2
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
6
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
9
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
5
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
1.55k
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
1
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
1
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
1
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
6
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
2
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
1
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
1
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
1
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
1
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
1
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
2.01k
      }
85
34.2k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
844
      switch (UnOp->getOpcode()) {
87
8
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
4
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
44
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
4
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
410
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
304
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
1
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
69
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
844
      }
102
844
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
33.4k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
33.4k
    }
112
33.4k
  }
UninitializedValues.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::TransferFunctions, void>::Visit(clang::Stmt*)
Line
Count
Source
43
45.4k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
45.4k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
4.75k
      switch (BinOp->getOpcode()) {
49
2
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
51
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
6
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
20
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
205
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
72
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
100
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
11
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
1.94k
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
132
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
63
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
63
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
174
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
280
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
124
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
2
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
57
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
9
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
19
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
1.16k
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
12
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
1
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
1
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
87
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
1
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
19
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
19
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
1
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
29
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
1
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
79
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
4.75k
      }
85
40.7k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
1.58k
      switch (UnOp->getOpcode()) {
87
46
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
1.03k
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
148
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
179
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
154
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
1
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
21
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
1.58k
      }
102
1.58k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
39.1k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
39.1k
    }
112
39.1k
  }
UninitializedValues.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::ClassifyRefs, void>::Visit(clang::Stmt*)
Line
Count
Source
43
26.4k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
26.4k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
3.05k
      switch (BinOp->getOpcode()) {
49
1
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
51
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
4
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
20
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
104
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
70
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
100
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
11
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
1.03k
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
132
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
61
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
63
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
161
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
116
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
124
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
2
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
57
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
7
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
17
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
708
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
19
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
1
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
1
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
64
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
1
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
19
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
19
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
1
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
29
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
1
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
57
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
3.05k
      }
85
23.3k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
1.38k
      switch (UnOp->getOpcode()) {
87
34
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
962
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
125
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
93
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
151
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
1
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
17
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
1.38k
      }
102
1.38k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
21.9k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
21.9k
    }
112
21.9k
  }
CGClass.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::DynamicThisUseChecker, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
33.4k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
33.4k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
13
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
3
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
10
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
13
      }
85
33.4k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
16
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec: