Coverage Report

Created: 2022-05-14 11:35

/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
221M
  return static_cast<ImplClass*>(this)->Visit ## NAME( \
41
221M
    static_cast<PTR(CLASS)>(S), std::forward<ParamTys>(P)...)
42
43
154M
  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
154M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
14.4M
      switch (BinOp->getOpcode()) {
49
30.8k
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
632
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
422k
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
753k
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
45.5k
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
2.24M
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
1.97M
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
337k
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
34.5k
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
731k
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
580k
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
102k
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
157k
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
488k
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
176k
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
1.11k
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
153k
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
35.8k
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
136k
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
1.41M
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
313k
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
3.25M
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
54.9k
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
6.81k
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
1.77k
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
141k
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
22.6k
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
2.28k
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
1.49k
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
6.18k
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
31.1k
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
4.72k
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
818k
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
14.4M
      }
85
140M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
4.05M
      switch (UnOp->getOpcode()) {
87
119k
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
2.13k
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
442k
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
42.8k
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
547k
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
415k
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
900
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
1.19M
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
83.5k
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
1.15M
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
521
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
474
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
48.2k
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
10
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
4.05M
      }
102
4.05M
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
136M
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
136M
    case Stmt::CLASS ## Class: 
DISPATCH135M
(CLASS, CLASS);
110
136M
#include 
"clang/AST/StmtNodes.inc"0
111
136M
    }
112
136M
  }
clang::StmtVisitorBase<llvm::make_const_ptr, clang::JSONDumper, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
2.48k
  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.48k
    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.33k
    } 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.28k
    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.28k
    }
112
2.28k
  }
clang::StmtVisitorBase<llvm::make_const_ptr, clang::ASTDumper, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
33.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
33.3k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
1.83k
      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
326
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
172
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
2
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
2
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
870
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
2
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
2
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
2
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
50
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
12
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
1
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
2
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
4
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
2
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
2
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
5
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
174
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
5
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
1
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
76
      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.83k
      }
85
31.5k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
1.13k
      switch (UnOp->getOpcode()) {
87
731
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
3
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
139
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
8
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
84
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
69
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
15
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
65
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
4
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
10
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
4
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
2
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
2
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
1.13k
      }
102
1.13k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
30.4k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
30.4k
    }
112
30.4k
  }
Expr.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::SideEffectFinder, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
104
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
104
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
0
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
0
      }
85
104
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
5
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
5
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
5
      }
102
5
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
99
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
99
    }
112
99
  }
Expr.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::NonTrivialCallFinder, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
24.7k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
24.7k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
4.66k
      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.71k
      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.66k
      }
85
20.1k
    } 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.4k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
19.4k
    }
112
19.4k
  }
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::LValueExprEvaluator, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
10.9M
  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
10.9M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
980k
      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
914k
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
5.38k
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
1.01k
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
152
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
37.1k
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
2.83k
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
345
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
127
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
681
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
9.48k
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
1.48k
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
6.72k
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
980k
      }
85
10.0M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
172k
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
53.6k
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
7.04k
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
111k
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
132
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
111
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
264
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
172k
      }
102
172k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
9.83M
    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
9.83M
    }
112
9.83M
  }
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::PointerExprEvaluator, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
2.08M
  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.08M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
67.6k
      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
52.1k
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
10.2k
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
5.00k
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
99
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
20
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
97
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
67.6k
      }
85
2.01M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
55.6k
      switch (UnOp->getOpcode()) {
87
3.38k
      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
52.1k
      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
55.6k
      }
102
55.6k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
1.96M
    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.96M
    }
112
1.96M
  }
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::MemberPointerExprEvaluator, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
3.79k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
3.79k
    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.79k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
1.65k
      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.65k
      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.65k
      }
102
1.65k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
2.14k
    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.14k
    }
112
2.14k
  }
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::IntExprEvaluator, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
27.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
27.0M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
3.21M
      switch (BinOp->getOpcode()) {
49
2
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
78.2k
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
97.9k
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
9.79k
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
736k
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
601k
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
236k
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
6.88k
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
306k
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
350k
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
24.0k
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
48.4k
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
202k
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
81.2k
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
47.1k
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
6.41k
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
56.7k
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
174k
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
44.4k
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
95.0k
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
306
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
201
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
160
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
1.00k
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
474
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
143
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
136
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
614
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
549
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
201
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
2.29k
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
3.21M
      }
85
23.8M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
1.11M
      switch (UnOp->getOpcode()) {
87
2.22k
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
135
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
311
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
1.89k
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
123
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
901k
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
16.8k
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
189k
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
6
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
9
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
287
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
1.11M
      }
102
1.11M
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
22.6M
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
22.6M
    }
112
22.6M
  }
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::ComplexExprEvaluator, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
5.46k
  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.46k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
1.74k
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
338
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
220
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
669
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
248
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
253
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
1
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
5
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
7
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
4
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
1.74k
      }
85
3.71k
    } 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.65k
    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.65k
    }
112
3.65k
  }
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::FloatExprEvaluator, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
302k
  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
302k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
58.0k
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
5.28k
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
7.35k
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
12.9k
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
5.23k
      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.9k
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
1.06k
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
1.04k
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
1.11k
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
1.06k
      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
18
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
58.0k
      }
85
244k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
3.18k
      switch (UnOp->getOpcode()) {
87
61
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
12
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
8
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
27
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
2.65k
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
43
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
29
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
349
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
3.18k
      }
102
3.18k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
241k
    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
241k
    }
112
241k
  }
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
120k
  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
120k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
714
      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
664
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
24
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
26
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
714
      }
85
120k
    } 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
120k
    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
120k
    }
112
120k
  }
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.4k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
12.4k
    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.4k
    } 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.4k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
12.4k
    }
112
12.4k
  }
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::AtomicExprEvaluator, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
433
  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
433
    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
433
    } 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
433
    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
433
    }
112
433
  }
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::VectorExprEvaluator, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
1.85M
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
1.85M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
527k
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
20.9k
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
3.18k
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
173
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
26.3k
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
22.3k
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
362
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
164
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
3.78k
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
6.89k
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
3.75k
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
3.75k
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
7.73k
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
229
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
19.9k
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
9.09k
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
13.0k
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
55
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
43
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
384k
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
86
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
85
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
60
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
104
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
95
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
161
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
51
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
75
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
71
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
70
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
1
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
527k
      }
85
1.32M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
22.4k
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
1
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
25
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
3.36k
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
15.6k
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
21
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
3.41k
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
22.4k
      }
102
22.4k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
1.30M
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
1.30M
    }
112
1.30M
  }
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::VoidExprEvaluator, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
6.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
6.16k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
90
      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
90
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
90
      }
85
6.07k
    } 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.07k
    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.07k
    }
112
6.07k
  }
clang::StmtVisitorBase<llvm::make_const_ptr, clang::interp::ByteCodeExprGen<clang::interp::ByteCodeEmitter>, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
12
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
12
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
4
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
2
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
1
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
1
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
4
      }
85
8
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
0
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
0
      }
102
0
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
8
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
8
    }
112
8
  }
clang::StmtVisitorBase<llvm::make_const_ptr, clang::interp::ByteCodeExprGen<clang::interp::EvalEmitter>, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
31
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
31
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
11
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
2
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
3
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
6
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
11
      }
85
20
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
0
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
0
      }
102
0
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
20
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
20
    }
112
20
  }
clang::StmtVisitorBase<llvm::make_const_ptr, clang::JSONNodeDumper, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
2.48k
  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.48k
    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.33k
    } 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.28k
    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.28k
    }
112
2.28k
  }
StmtPrinter.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::StmtPrinter, void>::Visit(clang::Stmt*)
Line
Count
Source
43
338k
  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
338k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
16.6k
      switch (BinOp->getOpcode()) {
49
8
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
66
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
8
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
5
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
1.83k
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
684
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
44
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
7.22k
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
1.20k
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
8
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
12
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
355
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
299
      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
220
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
625
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
3.40k
      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
460
      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
16.6k
      }
85
321k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
39.4k
      switch (UnOp->getOpcode()) {
87
2.10k
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
4
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
7.32k
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
18
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
1.18k
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
660
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
11
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
132
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
28.0k
      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
39.4k
      }
102
39.4k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
282k
    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
282k
    }
112
282k
  }
StmtProfile.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::StmtProfiler, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
18.8M
  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.8M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
1.68M
      switch (BinOp->getOpcode()) {
49
28.6k
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
34
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
17.8k
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
63.8k
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
17.4k
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
40.4k
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
31.1k
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
14.3k
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
2.73k
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
4.52k
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
3.84k
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
16.9k
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
59.8k
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
97.8k
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
35.8k
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
6
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
6.98k
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
583
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
7.54k
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
980k
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
195k
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
41.6k
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
214
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
264
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
114
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
4.05k
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
1.42k
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
100
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
110
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
332
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
1.50k
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
49
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
7.31k
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
1.68M
      }
85
17.1M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
761k
      switch (UnOp->getOpcode()) {
87
1.23k
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
25
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
12.7k
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
3.01k
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
5.33k
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
32.1k
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
125
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
32.1k
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
2.89k
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
670k
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
2
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
1.53k
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
5
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
761k
      }
102
761k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
16.4M
    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
16.4M
    }
112
16.4M
  }
clang::StmtVisitorBase<llvm::make_const_ptr, clang::TextNodeDumper, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
33.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
33.3k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
1.83k
      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
326
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
172
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
2
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
2
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
870
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
2
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
2
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
2
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
50
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
12
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
1
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
2
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
4
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
2
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
2
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
5
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
174
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
5
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
1
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
76
      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.83k
      }
85
31.5k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
1.13k
      switch (UnOp->getOpcode()) {
87
731
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
3
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
139
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
8
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
84
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
69
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
15
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
65
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
4
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
10
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
4
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
2
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
2
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
1.13k
      }
102
1.13k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
30.4k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
30.4k
    }
112
30.4k
  }
clang::StmtVisitorBase<std::__1::add_pointer, clang::ASTStmtReader, void>::Visit(clang::Stmt*)
Line
Count
Source
43
12.2M
  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.2M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
815k
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
42.9k
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
772k
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
815k
      }
85
11.3M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
342k
      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
342k
      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
342k
      }
102
342k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
11.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
11.0M
    }
112
11.0M
  }
clang::StmtVisitorBase<std::__1::add_pointer, clang::ASTStmtWriter, void>::Visit(clang::Stmt*)
Line
Count
Source
43
4.95M
  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.95M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
358k
      switch (BinOp->getOpcode()) {
49
232
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
34
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
20.2k
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
15.7k
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
1.84k
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
53.6k
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
37.1k
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
14.6k
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
2.63k
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
17.9k
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
10.6k
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
8.25k
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
2.54k
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
10.1k
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
3.64k
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
3
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
6.38k
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
706
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
7.00k
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
26.6k
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
6.09k
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
94.5k
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
431
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
426
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
114
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
9.87k
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
1.80k
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
100
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
110
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
351
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
1.51k
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
176
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
3.34k
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
358k
      }
85
4.59M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
116k
      switch (UnOp->getOpcode()) {
87
4.30k
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
97
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
19.6k
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
3.25k
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
5.20k
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
20.1k
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
47
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
30.8k
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
3.07k
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
28.5k
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
2
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
1.56k
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
5
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
116k
      }
102
116k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
4.47M
    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.47M
    }
112
4.47M
  }
AnalysisBasedWarnings.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::ContainsReference, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
451
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
451
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
32
      switch (BinOp->getOpcode()) {
49
1
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
11
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
1
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
6
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
13
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
32
      }
85
419
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
8
      switch (UnOp->getOpcode()) {
87
4
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
2
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
2
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
8
      }
102
8
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
411
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
411
    }
112
411
  }
Sema.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::DeferredDiagnosticsEmitter, void>::Visit(clang::Stmt*)
Line
Count
Source
43
833k
  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
833k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
56.3k
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
1.19k
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
271
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
5.66k
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
230
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
10
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
38
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
11.0k
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
252
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
228
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
400
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
179
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
9
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
80
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
38
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
10
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
198
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
108
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
17.3k
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
66
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
28
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
18.4k
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
364
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
14
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
10
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
100
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
56.3k
      }
85
777k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
32.2k
      switch (UnOp->getOpcode()) {
87
5.37k
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
152
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
9.44k
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
24
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
216
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
16.1k
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
16
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
658
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
46
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
78
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
32
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
32
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
9
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
32.2k
      }
102
32.2k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
745k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
745k
    }
112
745k
  }
SemaChecking.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::SequenceChecker, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
55.6M
  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
55.6M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
5.30M
      switch (BinOp->getOpcode()) {
49
386
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
298
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
194k
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
458k
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
9.36k
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
1.12M
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
1.07M
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
48.2k
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
16.1k
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
204k
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
181k
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
21.1k
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
27.5k
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
108k
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
35.5k
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
337
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
57.8k
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
15.5k
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
41.0k
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
146k
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
44.8k
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
1.41M
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
2.60k
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
2.30k
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
371
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
36.6k
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
4.47k
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
634
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
308
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
1.37k
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
10.0k
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
1.73k
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
9.63k
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
5.30M
      }
85
50.3M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
854k
      switch (UnOp->getOpcode()) {
87
54.9k
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
820
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
169k
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
10.7k
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
81.7k
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
134k
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
381
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
181k
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
28.2k
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
155k
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
167
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
160
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
35.9k
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
854k
      }
102
854k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
49.5M
    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
49.5M
    }
112
49.5M
  }
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.29M
  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.29M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
139k
      switch (BinOp->getOpcode()) {
49
29
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
5
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
30.4k
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
33.9k
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
80
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
15.6k
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
12.0k
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
9.96k
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
43
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
13.2k
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
54
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
6.41k
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
575
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
7.64k
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
38
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
85
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
507
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
1.73k
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
1.02k
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
5.81k
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
111
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
376
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
7
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
1
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
4
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
19
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
1
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
4
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
1
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
1
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
1
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
1
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
226
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
139k
      }
85
1.15M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
45.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
11.3k
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
7.84k
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
11
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
19.0k
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
3.65k
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
3.20k
      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
45.2k
      }
102
45.2k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
1.11M
    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.11M
    }
112
1.11M
  }
SemaDeclCXX.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::UninitializedFieldVisitor, void>::Visit(clang::Stmt*)
Line
Count
Source
43
61.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
61.3k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
1.88k
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
49
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
9
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
1.77k
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
6
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
6
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
3
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
4
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
3
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
18
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
3
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
9
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
1.88k
      }
85
59.4k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
189
      switch (UnOp->getOpcode()) {
87
19
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
18
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
118
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
22
      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
189
      }
102
189
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
59.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
59.2k
    }
112
59.2k
  }
SemaDeclCXX.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::CheckDefaultArgumentVisitor, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
113k
  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
113k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
818
      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
751
      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
818
      }
85
112k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
65
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
15
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
50
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
65
      }
102
65
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
112k
    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
112k
    }
112
112k
  }
SemaExpr.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::EvaluatedExprMarker, void>::Visit(clang::Stmt*)
Line
Count
Source
43
167k
  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
167k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
1.57k
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
24
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
13
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
20
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
2
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
100
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
1.41k
      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.57k
      }
85
166k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
49
      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
2
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
49
      }
102
49
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
165k
    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
165k
    }
112
165k
  }
SemaExpr.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::RebuildUnknownAnyFunction, clang::ActionResult<clang::Expr*, true> >::Visit(clang::Stmt*)
Line
Count
Source
43
5
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
5
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
0
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
0
      }
85
5
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
0
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
0
      }
102
0
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
5
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
5
    }
112
5
  }
SemaExpr.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::RebuildUnknownAnyExpr, clang::ActionResult<clang::Expr*, true> >::Visit(clang::Stmt*)
Line
Count
Source
43
789
  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
789
    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
789
    } 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
785
    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
785
    }
112
785
  }
SemaExprObjC.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::ARCCastChecker, (anonymous namespace)::ACCResult>::Visit(clang::Stmt*)
Line
Count
Source
43
1.77k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
1.77k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
3
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
3
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
3
      }
85
1.77k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
4
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
4
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
4
      }
102
4
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
1.77k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
1.77k
    }
112
1.77k
  }
SemaOpenMP.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::AllocatorChecker, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
340
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
340
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
0
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
0
      }
85
340
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
0
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
0
      }
102
0
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
340
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
340
    }
112
340
  }
SemaOpenMP.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::(anonymous namespace)::LoopCounterRefChecker, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
352k
  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
352k
    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
351k
    } 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
351k
    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
351k
    }
112
351k
  }
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
74.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
74.1k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
569
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
566
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
3
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
569
      }
85
73.5k
    } 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.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
72.8k
    }
112
72.8k
  }
SemaOpenMP.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::LocalVarRefChecker, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
2.19k
  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.19k
    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.19k
    } 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.19k
    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.19k
    }
112
2.19k
  }
SemaOpenMP.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::DSAAttrChecker, void>::Visit(clang::Stmt*)
Line
Count
Source
43
2.27M
  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.27M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
213k
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
1.47k
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
158
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
8.05k
      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.72k
      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.9k
      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.1k
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
821
      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
213k
      }
85
2.06M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
123k
      switch (UnOp->getOpcode()) {
87
31.0k
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
380
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
90.2k
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
185
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
120
      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
123k
      }
102
123k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
1.93M
    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.93M
    }
112
1.93M
  }
SemaStmt.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::BreakContinueFinder, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
56.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
56.1k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
9.12k
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
49
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
7
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
11
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
32
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
3
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
4
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
8.39k
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
75
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
79
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
23
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
107
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
50
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
26
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
23
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
57
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
4
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
4
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
4
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
23
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
4
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
4
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
15
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
4
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
4
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
4
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
110
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
9.12k
      }
85
47.0k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
8.69k
      switch (UnOp->getOpcode()) {
87
1.01k
      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
72
      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.69k
      }
102
8.69k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
38.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
38.3k
    }
112
38.3k
  }
SemaStmt.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::DeclExtractor, void>::Visit(clang::Stmt*)
Line
Count
Source
43
649
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
649
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
141
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
88
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
2
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
40
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
3
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
6
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
2
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
141
      }
85
508
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
4
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
1
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
2
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
1
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
4
      }
102
4
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
504
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
504
    }
112
504
  }
SemaStmt.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::DeclMatcher, void>::Visit(clang::Stmt*)
Line
Count
Source
43
613
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
613
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
157
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
92
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
2
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
33
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
3
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
6
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
2
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
19
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
157
      }
85
456
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
32
      switch (UnOp->getOpcode()) {
87
2
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
23
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
1
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
2
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
2
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
2
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
32
      }
102
32
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
424
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
424
    }
112
424
  }
SemaStmt.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::CommaVisitor, void>::Visit(clang::Stmt*)
Line
Count
Source
43
822
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
822
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
180
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
140
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
5
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
35
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
180
      }
85
642
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
0
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
0
      }
102
0
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
642
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
642
    }
112
642
  }
SemaStmtAttr.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::CallExprFinder, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
140
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
140
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
13
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
10
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
3
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
13
      }
85
127
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
0
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
0
      }
102
0
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
127
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
127
    }
112
127
  }
AnalysisDeclContext.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::FindBlockDeclRefExprsVals, void>::Visit(clang::Stmt*)
Line
Count
Source
43
2.45k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
2.45k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
165
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
22
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
4
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
6
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
12
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
2
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
119
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
165
      }
85
2.29k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
80
      switch (UnOp->getOpcode()) {
87
2
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
12
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
13
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
53
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
80
      }
102
80
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
2.21k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
2.21k
    }
112
2.21k
  }
CalledOnceCheck.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::DeclRefFinder, clang::DeclRefExpr const*>::Visit(clang::Stmt const*)
Line
Count
Source
43
873
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
873
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
11
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
6
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
3
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
1
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
1
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
11
      }
85
862
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
27
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
2
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
25
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
27
      }
102
27
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
835
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
835
    }
112
835
  }
CalledOnceCheck.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::CalledOnceChecker, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
1.16k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
1.16k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
28
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
1
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
2
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
3
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
6
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
3
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
10
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
2
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
1
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
28
      }
85
1.13k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
26
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
3
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
2
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
2
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
19
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
26
      }
102
26
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
1.11k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
1.11k
    }
112
1.11k
  }
CalledOnceCheck.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::NotCalledClarifier, llvm::Optional<(anonymous namespace)::Clarification> >::Visit(clang::Stmt const*)
Line
Count
Source
43
45
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
45
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
2
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
1
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
1
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
2
      }
85
43
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
0
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
0
      }
102
0
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
43
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
43
    }
112
43
  }
CFG.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::CFGBlockTerminatorPrint, void>::Visit(clang::Stmt*)
Line
Count
Source
43
556
  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
556
    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
519
    } 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
519
    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
519
    }
112
519
  }
clang::StmtVisitorBase<llvm::make_const_ptr, clang::consumed::ConsumedStmtVisitor, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
2.31k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
2.31k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
145
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
4
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
4
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
4
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
4
      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
145
      }
85
2.16k
    } 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
2.14k
    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.14k
    }
112
2.14k
  }
ThreadSafety.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::VarMapBuilder, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
36.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
36.5k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
2.03k
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
4
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
4
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
4
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
104
      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.56k
      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.03k
      }
85
34.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
33.6k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
33.6k
    }
112
33.6k
  }
ThreadSafety.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::BuildLockset, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
36.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
36.3k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
2.03k
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
4
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
4
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
4
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
104
      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.56k
      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.03k
      }
85
34.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
33.4k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
33.4k
    }
112
33.4k
  }
UninitializedValues.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::TransferFunctions, void>::Visit(clang::Stmt*)
Line
Count
Source
43
44.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
44.3k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
4.65k
      switch (BinOp->getOpcode()) {
49
2
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
53
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
8
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
22
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
207
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
74
      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
134
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
65
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
65
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
176
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
282
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
124
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
2
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
57
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
9
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
19
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
1.17k
      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
88
      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
4.65k
      }
85
39.6k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
1.51k
      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
148
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
179
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
154
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
1
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
21
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
1.51k
      }
102
1.51k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
38.1k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
38.1k
    }
112
38.1k
  }
UninitializedValues.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::ClassifyRefs, void>::Visit(clang::Stmt*)
Line
Count
Source
43
25.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
25.9k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
3.03k
      switch (BinOp->getOpcode()) {
49
1
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
53
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
6
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
22
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
106
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
72
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
100
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
11
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
968
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
134
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
63
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
65
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
163
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
118
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
124
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
2
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
57
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
7
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
17
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
724
      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
65
      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
3.03k
      }
85
22.9k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
1.31k
      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
125
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
93
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
151
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
1
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
17
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
1.31k
      }
102
1.31k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
21.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
21.5k
    }
112
21.5k
  }
CGClass.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::DynamicThisUseChecker, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
32.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
32.9k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
13
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
3
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
10
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
13
      }
85
32.9k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
12
      switch (UnOp->getOpcode()) {
87
0
      case U