Coverage Report

Created: 2021-09-21 08:58

/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
218M
  return static_cast<ImplClass*>(this)->Visit ## NAME( \
41
218M
    static_cast<PTR(CLASS)>(S), std::forward<ParamTys>(P)...)
42
43
148M
  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
148M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
14.1M
      switch (BinOp->getOpcode()) {
49
101k
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
646
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
429k
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
769k
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
42.5k
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
2.25M
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
1.98M
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
331k
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
32.0k
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
843k
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
569k
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
108k
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
145k
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
510k
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
153k
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
1.09k
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
197k
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
42.3k
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
149k
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
1.21M
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
285k
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
3.14M
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
41.8k
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
5.96k
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
1.45k
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
139k
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
21.6k
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
1.91k
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
1.11k
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
6.11k
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
27.7k
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
4.32k
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
548k
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
14.1M
      }
85
134M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
3.85M
      switch (UnOp->getOpcode()) {
87
130k
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
2.31k
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
471k
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
38.5k
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
429k
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
425k
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
941
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
1.16M
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
109k
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
1.03M
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
909
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
802
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
46.1k
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
10
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
3.85M
      }
102
3.85M
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
130M
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
130M
    case Stmt::CLASS ## Class: 
DISPATCH130M
(CLASS, CLASS);
110
130M
#include 
"clang/AST/StmtNodes.inc"0
111
130M
    }
112
130M
  }
clang::StmtVisitorBase<llvm::make_const_ptr, clang::JSONDumper, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
2.47k
  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.47k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
151
      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
25
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
5
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
1
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
1
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
18
      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
4
      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
151
      }
85
2.32k
    } 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.27k
    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.27k
    }
112
2.27k
  }
clang::StmtVisitorBase<llvm::make_const_ptr, clang::ASTDumper, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
28.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
28.2k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
1.54k
      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
300
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
170
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
2
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
2
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
744
      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
33
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
12
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      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
94
      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
46
      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.54k
      }
85
26.6k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
998
      switch (UnOp->getOpcode()) {
87
715
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
3
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
36
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
8
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
80
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
61
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
14
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
59
      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
998
      }
102
998
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
25.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
25.6k
    }
112
25.6k
  }
Expr.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::SideEffectFinder, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
190
  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
190
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
42
      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
42
      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
42
      }
85
148
    } 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
143
    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
143
    }
112
143
  }
Expr.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::NonTrivialCallFinder, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
25.1k
  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
25.1k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
4.70k
      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
1.74k
      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
4.70k
      }
85
20.4k
    } 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
19.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
19.7k
    }
112
19.7k
  }
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::LValueExprEvaluator, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
11.1M
  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
11.1M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
956k
      switch (BinOp->getOpcode()) {
49
295
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
208
      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
890k
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
5.35k
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
966
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
162
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
36.7k
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
3.34k
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
335
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
111
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
646
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
9.41k
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
1.43k
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
6.56k
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
956k
      }
85
10.1M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
164k
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
54.0k
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
8.01k
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
101k
      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
259
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
224
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
219
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
164k
      }
102
164k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
10.0M
    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.0M
    }
112
10.0M
  }
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::PointerExprEvaluator, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
2.06M
  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.06M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
64.4k
      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
49.4k
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
9.95k
      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
4.91k
      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
91
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
18
      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
64.4k
      }
85
2.00M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
57.3k
      switch (UnOp->getOpcode()) {
87
3.35k
      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
53.9k
      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
57.3k
      }
102
57.3k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
1.94M
    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.94M
    }
112
1.94M
  }
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::MemberPointerExprEvaluator, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
3.75k
  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.75k
    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.75k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
1.64k
      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.64k
      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.64k
      }
102
1.64k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
2.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
2.11k
    }
112
2.11k
  }
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::IntExprEvaluator, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
27.3M
  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.3M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
3.25M
      switch (BinOp->getOpcode()) {
49
2
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
84.5k
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
109k
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
9.87k
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
747k
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
611k
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
233k
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
8.68k
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
340k
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
348k
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
26.8k
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
42.9k
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
201k
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
77.7k
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
54.4k
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
6.14k
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
55.0k
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
153k
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
39.2k
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
96.6k
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
815
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
189
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
147
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
961
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
455
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
132
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
131
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
600
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
536
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
188
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
2.43k
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
3.25M
      }
85
24.1M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
1.09M
      switch (UnOp->getOpcode()) {
87
2.11k
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
129
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
302
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
1.83k
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
113
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
887k
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
18.6k
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
181k
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
15
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
8
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
271
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
1.09M
      }
102
1.09M
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
23.0M
    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
23.0M
    }
112
23.0M
  }
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::ComplexExprEvaluator, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
5.71k
  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.71k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
1.79k
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
346
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
228
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
659
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
302
      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
249
      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
5
      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.79k
      }
85
3.91k
    } 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.85k
    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.85k
    }
112
3.85k
  }
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::FloatExprEvaluator, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
267k
  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
267k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
57.4k
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
5.48k
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
7.31k
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
12.6k
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
5.21k
      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
22.6k
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
1.00k
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
974
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
1.05k
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
991
      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
21
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
57.4k
      }
85
210k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
3.15k
      switch (UnOp->getOpcode()) {
87
61
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
12
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
7
      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
33
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
2.63k
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
42
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
28
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
330
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
3.15k
      }
102
3.15k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
207k
    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
207k
    }
112
207k
  }
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
115k
  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
115k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
698
      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
657
      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
17
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
698
      }
85
114k
    } 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
114k
    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
114k
    }
112
114k
  }
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.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
12.2k
    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.2k
    } 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.2k
    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.2k
    }
112
12.2k
  }
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::AtomicExprEvaluator, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
515
  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
515
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
107
      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
37
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
7
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
5
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
1
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
12
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
13
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
3
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
1
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
10
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
9
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
9
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
107
      }
85
408
    } 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
408
    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
408
    }
112
408
  }
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::VectorExprEvaluator, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
1.92M
  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.92M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
550k
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
20.8k
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
3.61k
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
729
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
28.1k
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
23.5k
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
699
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
650
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
3.65k
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
6.49k
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
3.63k
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
3.74k
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
7.34k
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
240
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
35.3k
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
12.6k
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
22.3k
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
55
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
43
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
375k
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
158
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
85
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
132
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
208
      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
82
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
85
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
70
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
1
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
550k
      }
85
1.37M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
31.2k
      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
25
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
3.02k
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
24.8k
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
14
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
3.36k
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
31.2k
      }
102
31.2k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
1.34M
    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.34M
    }
112
1.34M
  }
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::VoidExprEvaluator, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
6.00k
  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.00k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
116
      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
116
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
116
      }
85
5.89k
    } 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.89k
    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.89k
    }
112
5.89k
  }
clang::StmtVisitorBase<llvm::make_const_ptr, clang::interp::ByteCodeExprGen<clang::interp::ByteCodeEmitter>, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
9
  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
9
    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
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
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
3
      }
85
6
    } 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
    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
    }
112
6
  }
clang::StmtVisitorBase<llvm::make_const_ptr, clang::interp::ByteCodeExprGen<clang::interp::EvalEmitter>, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
19
  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
19
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
5
      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
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
5
      }
85
14
    } 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
14
    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
14
    }
112
14
  }
clang::StmtVisitorBase<llvm::make_const_ptr, clang::JSONNodeDumper, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
2.47k
  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.47k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
151
      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
25
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
5
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
1
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
1
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
18
      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
4
      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
151
      }
85
2.32k
    } 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.27k
    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.27k
    }
112
2.27k
  }
StmtPrinter.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::StmtPrinter, void>::Visit(clang::Stmt*)
Line
Count
Source
43
300k
  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
300k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
14.4k
      switch (BinOp->getOpcode()) {
49
8
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
65
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
8
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
5
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
1.59k
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
683
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
42
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
6.92k
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
1.01k
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
8
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
12
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
183
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
294
      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
219
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
626
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
2.13k
      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
418
      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
14.4k
      }
85
286k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
40.4k
      switch (UnOp->getOpcode()) {
87
1.64k
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
4
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
7.20k
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
18
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
1.15k
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
653
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
11
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
117
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
29.6k
      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
40.4k
      }
102
40.4k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
245k
    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
245k
    }
112
245k
  }
StmtProfile.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::StmtProfiler, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
18.3M
  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
18.3M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
1.65M
      switch (BinOp->getOpcode()) {
49
99.0k
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
38
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
17.5k
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
59.8k
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
15.8k
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
40.7k
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
30.3k
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
12.2k
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
1.90k
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
4.25k
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
2.50k
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
17.6k
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
58.4k
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
127k
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
27.7k
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
7
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
6.90k
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
766
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
6.66k
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
857k
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
188k
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
39.1k
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
212
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
262
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
114
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
4.06k
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
1.44k
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
109
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
110
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
363
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
1.52k
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
53
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
27.6k
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
1.65M
      }
85
16.6M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
731k
      switch (UnOp->getOpcode()) {
87
1.18k
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
23
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
12.8k
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
3.01k
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
5.36k
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
63.6k
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
127
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
29.2k
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
3.12k
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
611k
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
2
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
1.47k
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
5
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
731k
      }
102
731k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
15.9M
    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
15.9M
    }
112
15.9M
  }
clang::StmtVisitorBase<llvm::make_const_ptr, clang::TextNodeDumper, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
28.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
28.2k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
1.54k
      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
300
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
170
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
2
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
2
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
744
      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
33
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
12
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      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
94
      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
46
      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.54k
      }
85
26.6k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
998
      switch (UnOp->getOpcode()) {
87
715
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
3
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
36
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
8
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
80
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
61
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
14
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
59
      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
998
      }
102
998
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
25.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
25.6k
    }
112
25.6k
  }
clang::StmtVisitorBase<std::__1::add_pointer, clang::ASTStmtReader, void>::Visit(clang::Stmt*)
Line
Count
Source
43
6.81M
  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.81M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
519k
      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
29.5k
      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
489k
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
519k
      }
85
6.29M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
208k
      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
208k
      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
208k
      }
102
208k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
6.09M
    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.09M
    }
112
6.09M
  }
clang::StmtVisitorBase<std::__1::add_pointer, clang::ASTStmtWriter, void>::Visit(clang::Stmt*)
Line
Count
Source
43
4.69M
  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.69M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
344k
      switch (BinOp->getOpcode()) {
49
434
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
38
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
19.2k
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
15.7k
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
1.78k
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
53.1k
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
35.8k
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
12.7k
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
2.07k
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
17.1k
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
9.68k
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
7.96k
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
2.28k
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
9.34k
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
3.09k
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
3
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
6.21k
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
698
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
6.43k
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
25.3k
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
5.46k
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
91.6k
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
429
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
358
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
114
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
9.85k
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
1.80k
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
109
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
110
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
383
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
1.53k
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
191
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
3.61k
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
344k
      }
85
4.35M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
116k
      switch (UnOp->getOpcode()) {
87
4.16k
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
95
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
19.6k
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
3.27k
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
5.25k
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
25.4k
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
47
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
26.8k
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
3.16k
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
27.2k
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
2
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
1.49k
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
5
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
116k
      }
102
116k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
4.23M
    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.23M
    }
112
4.23M
  }
AnalysisBasedWarnings.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::ContainsReference, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
450
  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
450
    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
418
    } 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
410
    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
410
    }
112
410
  }
Sema.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::DeferredDiagnosticsEmitter, void>::Visit(clang::Stmt*)
Line
Count
Source
43
2.84M
  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.84M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
177k
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
2
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
2.90k
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
599
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
12
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
10.6k
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
7.01k
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
69
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
116
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
78.1k
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
1.20k
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
444
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
468
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
740
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
153
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
296
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
104
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
69
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
391
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
222
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
50.4k
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
158
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
204
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
44
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
21.7k
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
512
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
40
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
40
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
40
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
66
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
50
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
358
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
177k
      }
85
2.66M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
113k
      switch (UnOp->getOpcode()) {
87
18.6k
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
354
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
70.6k
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
199
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
1.07k
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
20.6k
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
33
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
1.24k
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
103
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
156
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
80
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
84
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
40
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
113k
      }
102
113k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
2.54M
    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.54M
    }
112
2.54M
  }
SemaChecking.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::SequenceChecker, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
57.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
57.0M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
5.33M
      switch (BinOp->getOpcode()) {
49
384
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
298
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
199k
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
463k
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
9.93k
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
1.13M
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
1.08M
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
51.5k
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
16.2k
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
214k
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
181k
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
24.5k
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
24.6k
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
109k
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
33.1k
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
332
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
79.9k
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
18.9k
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
50.7k
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
135k
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
40.8k
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
1.38M
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
3.09k
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
2.19k
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
439
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
36.2k
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
4.89k
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
614
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
286
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
1.33k
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
10.0k
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
1.67k
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
10.2k
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
5.33M
      }
85
51.7M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
864k
      switch (UnOp->getOpcode()) {
87
54.8k
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
814
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
176k
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
11.6k
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
90.8k
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
126k
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
397
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
173k
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
43.7k
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
149k
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
282
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
255
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
34.0k
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
864k
      }
102
864k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
50.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
50.8M
    }
112
50.8M
  }
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.45M
  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.45M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
167k
      switch (BinOp->getOpcode()) {
49
27
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
5
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
33.0k
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
40.6k
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
80
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
14.0k
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
13.0k
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
11.3k
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
10
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
25.7k
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
54
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
8.74k
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
561
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
7.84k
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
38
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
81
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
869
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
1.74k
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
1.03k
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
6.93k
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
488
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
384
      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
225
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
167k
      }
85
1.28M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
46.2k
      switch (UnOp->getOpcode()) {
87
45
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
2
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
43
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
7
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
13.8k
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
5.46k
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
11
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
20.0k
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
3.67k
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
3.21k
      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
46.2k
      }
102
46.2k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
1.24M
    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.24M
    }
112
1.24M
  }
SemaDeclCXX.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::UninitializedFieldVisitor, void>::Visit(clang::Stmt*)
Line
Count
Source
43
56.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
56.8k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
1.87k
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
51
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
8
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
1.76k
      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.87k
      }
85
55.0k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
185
      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
117
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
18
      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
185
      }
102
185
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
54.8k
    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
54.8k
    }
112
54.8k
  }
SemaDeclCXX.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::CheckDefaultArgumentVisitor, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
117k
  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
117k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
822
      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
34
      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
755
      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
822
      }
85
116k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
67
      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
52
      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
67
      }
102
67
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
116k
    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
116k
    }
112
116k
  }
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)::EvaluatedExprMarker, void>::Visit(clang::Stmt*)
Line
Count
Source
43
172k
  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
172k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
1.90k
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
37
      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
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
100
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
1.72k
      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
1.90k
      }
85
170k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
47
      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
12
      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
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
47
      }
102
47
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
170k
    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
170k
    }
112
170k
  }
SemaExpr.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::RebuildUnknownAnyExpr, clang::ActionResult<clang::Expr*, true> >::Visit(clang::Stmt*)
Line
Count
Source
43
788
  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
788
    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
788
    } 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
784
    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
784
    }
112
784
  }
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
312
  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
312
    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
312
    } 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
312
    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
312
    }
112
312
  }
SemaOpenMP.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::(anonymous namespace)::LoopCounterRefChecker, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
350k
  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
350k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
829
      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
474
      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
829
      }
85
349k
    } 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
349k
    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
349k
    }
112
349k
  }
SemaOpenMP.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::DSARefChecker, bool>::Visit(clang::Stmt*)
Line
Count
Source
43
15.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
15.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
15.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
15.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
15.0k
    }
112
15.0k
  }
SemaOpenMP.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::MapBaseChecker, bool>::Visit(clang::Stmt*)
Line
Count
Source
43
73.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
73.3k
    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
72.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.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
72.0k
    }
112
72.0k
  }
SemaOpenMP.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::LocalVarRefChecker, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
2.18k
  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.18k
    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.18k
    } 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.18k
    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.18k
    }
112
2.18k
  }
SemaOpenMP.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::DSAAttrChecker, void>::Visit(clang::Stmt*)
Line
Count
Source
43
2.42M
  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.42M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
211k
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
4
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
1.47k
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
160
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
7.89k
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
19.9k
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
108k
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
1.59k
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
396
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
624
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
336
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
249
      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
53.2k
      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.0k
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
820
      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
211k
      }
85
2.20M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
122k
      switch (UnOp->getOpcode()) {
87
30.8k
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
380
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
89.5k
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
185
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
189
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
678
      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
300
      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
122k
      }
102
122k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
2.08M
    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.08M
    }
112
2.08M
  }
SemaStmt.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::BreakContinueFinder, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
57.6k
  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
57.6k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
9.41k
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
48
      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
76
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
8.60k
      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
111
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
52
      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
30
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
23
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
61
      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.41k
      }
85
48.2k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
8.89k
      switch (UnOp->getOpcode()) {
87
1.22k
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
43
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
7.47k
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
38
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
24
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
69
      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.89k
      }
102
8.89k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
39.3k
    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.3k
    }
112
39.3k
  }
SemaStmt.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::DeclExtractor, void>::Visit(clang::Stmt*)
Line
Count
Source
43
643
  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
643
    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
502
    } 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
498
    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
498
    }
112
498
  }
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
76
  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
76
    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
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
3
      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
1
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
4
      }
85
72
    } 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
72
    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
    }
112
72
  }
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
539
  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
539
    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
502
    } 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
502
    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
502
    }
112
502
  }
clang::StmtVisitorBase<llvm::make_const_ptr, clang::consumed::ConsumedStmtVisitor, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
4.78k
  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.78k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
227
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
52
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
4
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
4
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
38
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
4
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
2
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
2
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
7
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
5
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
4
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
4
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
4
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
4
      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
65
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
2
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
2
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
2
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
2
      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
227
      }
85
4.55k
    } 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
4.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
4.53k
    }
112
4.53k
  }
ThreadSafety.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::VarMapBuilder, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
38.5k
  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
38.5k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
2.10k
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
52
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
4
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
4
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
138
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
4
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
2
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
2
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
42
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
36
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
4
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
4
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
199
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
16
      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
2
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
2
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
2
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
7
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
3
      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.10k
      }
85
36.4k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
848
      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
300
      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
848
      }
102
848
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
35.5k
    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
35.5k
    }
112
35.5k
  }
ThreadSafety.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::BuildLockset, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
38.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
38.3k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
2.10k
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
52
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
4
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
4
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
138
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
4
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
2
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
2
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
42
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
36
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
4
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
4
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
199
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
16
      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
2
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
2
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
2
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
7
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
3
      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.10k
      }
85
36.2k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
840
      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
300
      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
840
      }
102
840
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
35.3k
    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
35.3k
    }
112
35.3k
  }
UninitializedValues.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::TransferFunctions, void>::Visit(clang::Stmt*)
Line
Count
Source
43
59.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
59.9k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
6.15k
      switch (BinOp->getOpcode()) {
49
2
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
89
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
8
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
22
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
203
      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.81k
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
130
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
65
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
65
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
256
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
278
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
81
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
2
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
14
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
9
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
19
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
2.56k
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
13
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
2
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
2
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
189
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
2
      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
6.15k
      }
85
53.7k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
1.53k
      switch (UnOp->getOpcode()) {
87
46
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
966
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
185
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
164
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
153
      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.53k
      }
102
1.53k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
52.2k
    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.2k
    }
112
52.2k
  }
UninitializedValues.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::ClassifyRefs, void>::Visit(clang::Stmt*)
Line
Count
Source
43
43.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
43.9k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
4.71k
      switch (BinOp->getOpcode()) {
49
1
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
89
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
6
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
22
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
102
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
68
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
100
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
11
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
968
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
130
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
63
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
65
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
297
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
114
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
81
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
2
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
14
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
7
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
17
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
2.23k
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
20
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
2
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
2
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
166
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
2
      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
4.71k
      }
85
39.2k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
1.36k
      switch (UnOp->getOpcode()) {
87
34
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
894
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
170
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
83
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
168
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
1
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
13
      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.36k
      }
102
1.36k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
37.8k
    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
37.8k
    }
112
37.8k
  }
clang::StmtVisitorBase<std::__1::add_pointer, clang::ASTNodeImporter, llvm::Expected<clang::Stmt*> >::Visit(clang::Stmt*)
Line
Count
Source
43
3.98M
  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.98M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
203k
      switch (BinOp->getOpcode()) {
49
1.08k
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
6.89k
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
5.23k
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
3.35k
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
8.07k
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
7.67k
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
1.47k
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
1.10k
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
5.20k
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
2.84k
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
912
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
2.44k
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
10.5k
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
3.55k
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
7.16k
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
723
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
4.73k
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
33.1k
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
8.11k
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
61.6k
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
356
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
224
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
120
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
6.99k
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
6.62k
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
182
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
62
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
2.16k
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
4.26k
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
404
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
6.24k
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
203k
      }
85
3.78M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
127k
      switch (UnOp->getOpcode()) {
87
2.54k
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
62
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
20.5k
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
9.08k
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
4.81k
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
42.5k
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
6.11k
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
8.72k
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
33.0k
      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);