Coverage Report

Created: 2020-09-22 08:39

/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
192M
  return static_cast<ImplClass*>(this)->Visit ## NAME( \
41
192M
    static_cast<PTR(CLASS)>(S), std::forward<ParamTys>(P)...)
42
43
129M
  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
129M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
13.2M
      switch (BinOp->getOpcode()) {
49
88.3k
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
485
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
412k
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
721k
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
35.8k
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
2.14M
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
1.89M
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
392k
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
30.9k
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
802k
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
550k
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
94.0k
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
61.8k
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
485k
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
189k
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
784
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
181k
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
36.9k
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
156k
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
1.19M
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
289k
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
2.92M
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
17.6k
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
5.50k
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
948
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
130k
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
14.4k
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
1.55k
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
1.00k
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
3.85k
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
24.8k
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
3.70k
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
335k
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
116M
      }
85
116M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
3.63M
      switch (UnOp->getOpcode()) {
87
119k
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
2.08k
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
425k
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
28.7k
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
225k
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
336k
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
690
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
1.43M
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
93.1k
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
916k
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
578
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
501
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
46.3k
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
10
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
112M
      }
102
112M
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
112M
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
112M
    case Stmt::CLASS ## Class: 
DISPATCH112M
(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
112M
    }
112
112M
  }
clang::StmtVisitorBase<llvm::make_const_ptr, clang::JSONDumper, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
2.11k
  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.11k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
140
      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
1
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
48
      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
1.97k
      }
85
1.97k
    } 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
1.93k
      }
102
1.93k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
1.93k
    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.93k
    }
112
1.93k
  }
clang::StmtVisitorBase<llvm::make_const_ptr, clang::ASTDumper, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
23.8k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
23.8k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
1.41k
      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
281
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
170
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
2
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
2
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
708
      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
32
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
12
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
2
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
4
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
2
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
2
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
2
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
57
      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
9
      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
6
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
22.4k
      }
85
22.4k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
946
      switch (UnOp->getOpcode()) {
87
709
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
1
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
35
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
8
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
66
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
42
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
4
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
59
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
4
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
10
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
4
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
2
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
2
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
21.5k
      }
102
21.5k
    }
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
  }
Expr.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::SideEffectFinder, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
102
  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
102
    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
102
      }
85
102
    } 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
97
      }
102
97
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
97
    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
97
    }
112
97
  }
Expr.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::NonTrivialCallFinder, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
19.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
19.4k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
3.61k
      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
413
      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
11
      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.40k
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
27
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
1.73k
      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
11
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
15
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
15.8k
      }
85
15.8k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
435
      switch (UnOp->getOpcode()) {
87
192
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
159
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
84
      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
15.3k
      }
102
15.3k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
15.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
15.3k
    }
112
15.3k
  }
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::LValueExprEvaluator, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
9.72M
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
9.72M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
908k
      switch (BinOp->getOpcode()) {
49
227
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
112
      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
847k
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
2.48k
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
910
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
109
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
35.8k
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
2.90k
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
328
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
96
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
602
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
9.99k
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
1.36k
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
5.91k
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
8.81M
      }
85
8.81M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
130k
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
45.3k
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
7.44k
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
76.8k
      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
81
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
80
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
197
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
8.68M
      }
102
8.68M
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
8.68M
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
8.68M
    }
112
8.68M
  }
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::PointerExprEvaluator, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
1.62M
  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.62M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
34.7k
      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
27.5k
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
2.06k
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
4.94k
      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
80
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
18
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
85
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
1.59M
      }
85
1.59M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
29.4k
      switch (UnOp->getOpcode()) {
87
3.27k
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
18
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
28
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
21
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
26.0k
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
8
      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
1.56M
      }
102
1.56M
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
1.56M
    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.56M
    }
112
1.56M
  }
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::MemberPointerExprEvaluator, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
2.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
2.77k
    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
2.77k
      }
85
2.77k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
1.15k
      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.15k
      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.62k
      }
102
1.62k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
1.62k
    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.62k
    }
112
1.62k
  }
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.19M
      switch (BinOp->getOpcode()) {
49
2
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
76.0k
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
97.0k
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
8.93k
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
737k
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
580k
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
295k
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
7.66k
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
308k
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
338k
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
17.7k
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
22.1k
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
196k
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
84.0k
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
50.4k
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
5.02k
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
62.4k
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
156k
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
43.5k
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
94.0k
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
647
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
168
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
133
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
886
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
502
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
128
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
123
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
598
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
526
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
180
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
5.94k
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
23.8M
      }
85
23.8M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
1.31M
      switch (UnOp->getOpcode()) {
87
1.42k
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
113
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
270
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
1.95k
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
96
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
1.14M
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
19.3k
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
147k
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
15
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
8
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
242
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
22.5M
      }
102
22.5M
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
22.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
22.5M
    }
112
22.5M
  }
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::ComplexExprEvaluator, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
4.75k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
4.75k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
1.56k
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
314
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
194
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
602
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
239
      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
204
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
1
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
4
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
4
      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
3.18k
      }
85
3.18k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
51
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
2
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
9
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
3
      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
37
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
3.13k
      }
102
3.13k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
3.13k
    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.13k
    }
112
3.13k
  }
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::FloatExprEvaluator, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
229k
  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
229k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
56.4k
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
4.76k
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
4.85k
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
12.2k
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
5.01k
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
25.2k
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
1.05k
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
1.03k
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
1.09k
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
1.04k
      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
8
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
172k
      }
85
172k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
2.29k
      switch (UnOp->getOpcode()) {
87
42
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
7
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
7
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
22
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
1.89k
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
42
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
28
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
248
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
170k
      }
102
170k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
170k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
170k
    }
112
170k
  }
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::FixedPointExprEvaluator, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
3.89k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
3.89k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
1.20k
      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
434
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
4
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
4
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
24
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
4
      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
2.69k
      }
85
2.69k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
274
      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
274
      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
2.41k
      }
102
2.41k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
2.41k
    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.41k
    }
112
2.41k
  }
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::RecordExprEvaluator, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
88.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
88.3k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
445
      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
410
      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
20
      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
15
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
87.9k
      }
85
87.9k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
0
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
87.9k
      }
102
87.9k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
87.9k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
87.9k
    }
112
87.9k
  }
Unexecuted instantiation: ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::TemporaryExprEvaluator, bool>::Visit(clang::Stmt const*)
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::ArrayExprEvaluator, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
6.96k
  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.96k
    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
6.96k
      }
85
6.96k
    } 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
6.96k
      }
102
6.96k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
6.96k
    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.96k
    }
112
6.96k
  }
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::AtomicExprEvaluator, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
435
  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
435
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
107
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
37
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
7
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
5
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
1
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
12
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
13
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
3
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
1
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
10
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
9
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
9
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
328
      }
85
328
    } 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
328
      }
102
328
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
328
    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
328
    }
112
328
  }
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::VectorExprEvaluator, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
1.64M
  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.64M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
521k
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
26.2k
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
3.29k
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
489
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
32.6k
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
21.8k
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
509
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
459
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
3.37k
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
6.24k
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
3.35k
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
3.44k
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
6.90k
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
182
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
32.2k
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
10.9k
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
21.6k
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
55
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
43
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
347k
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
91
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
30
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
20
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
153
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
40
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
81
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
51
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
35
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
31
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
30
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
1.12M
      }
85
1.12M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
25.4k
      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
20
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
1.85k
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
20.7k
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
14
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
2.83k
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
1.09M
      }
102
1.09M
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
1.09M
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
1.09M
    }
112
1.09M
  }
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::VoidExprEvaluator, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
6.34k
  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.34k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
78
      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
78
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
6.26k
      }
85
6.26k
    } 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
6.26k
      }
102
6.26k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
6.26k
    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.26k
    }
112
6.26k
  }
clang::StmtVisitorBase<llvm::make_const_ptr, clang::interp::ByteCodeExprGen<clang::interp::ByteCodeEmitter>, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
9
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
9
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
3
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
2
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
1
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
6
      }
85
6
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
0
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
6
      }
102
6
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
6
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
6
    }
112
6
  }
clang::StmtVisitorBase<llvm::make_const_ptr, clang::interp::ByteCodeExprGen<clang::interp::EvalEmitter>, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
19
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
19
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
5
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
2
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
3
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
14
      }
85
14
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
0
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
14
      }
102
14
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
14
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
14
    }
112
14
  }
clang::StmtVisitorBase<llvm::make_const_ptr, clang::JSONNodeDumper, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
2.11k
  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.11k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
140
      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
1
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
48
      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
1.97k
      }
85
1.97k
    } 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
1.93k
      }
102
1.93k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
1.93k
    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.93k
    }
112
1.93k
  }
StmtPrinter.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::StmtPrinter, void>::Visit(clang::Stmt*)
Line
Count
Source
43
246k
  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
246k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
15.7k
      switch (BinOp->getOpcode()) {
49
8
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
59
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
8
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
5
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
1.56k
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
681
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
50
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
6.76k
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
960
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
8
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
10
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
160
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
228
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
1
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
14
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
8
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
219
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
2.25k
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
2.05k
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
26
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
6
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
2
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
377
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
26
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
2
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
2
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
2
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
2
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
2
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
220
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
230k
      }
85
230k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
23.6k
      switch (UnOp->getOpcode()) {
87
1.56k
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
4
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
7.03k
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
18
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
1.09k
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
635
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
11
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
117
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
13.1k
      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
207k
      }
102
207k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
207k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
207k
    }
112
207k
  }
StmtProfile.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::StmtProfiler, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
16.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
16.6M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
1.62M
      switch (BinOp->getOpcode()) {
49
87.1k
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
38
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
15.9k
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
56.9k
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
14.4k
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
37.6k
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
24.6k
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
15.1k
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
2.08k
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
19.9k
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
1.69k
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
19.9k
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
11.9k
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
117k
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
50.5k
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
6
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
7.71k
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
541
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
8.38k
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
853k
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
187k
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
39.1k
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
212
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
247
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
114
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
4.04k
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
1.44k
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
107
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
108
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
355
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
1.50k
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
51
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
46.8k
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
14.9M
      }
85
14.9M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
712k
      switch (UnOp->getOpcode()) {
87
1.13k
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
21
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
13.8k
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
3.01k
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
5.68k
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
69.2k
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
118
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
37.8k
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
3.15k
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
576k
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
2
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
1.60k
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
5
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
14.2M
      }
102
14.2M
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
14.2M
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
14.2M
    }
112
14.2M
  }
clang::StmtVisitorBase<llvm::make_const_ptr, clang::TextNodeDumper, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
23.8k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
23.8k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
1.41k
      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
281
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
170
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
2
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
2
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
708
      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
32
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
12
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
2
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
4
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
2
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
2
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
2
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
57
      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
9
      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
6
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
22.4k
      }
85
22.4k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
946
      switch (UnOp->getOpcode()) {
87
709
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
1
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
35
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
8
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
66
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
42
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
4
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
59
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
4
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
10
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
4
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
2
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
2
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
21.5k
      }
102
21.5k
    }
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
  }
clang::StmtVisitorBase<std::__1::add_pointer, clang::ASTStmtReader, void>::Visit(clang::Stmt*)
Line
Count
Source
43
2.19M
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
2.19M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
265k
      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
9.12k
      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
256k
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
1.93M
      }
85
1.93M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
66.7k
      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
66.7k
      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.86M
      }
102
1.86M
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
1.86M
    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.86M
    }
112
1.86M
  }
clang::StmtVisitorBase<std::__1::add_pointer, clang::ASTStmtWriter, void>::Visit(clang::Stmt*)
Line
Count
Source
43
5.05M
  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.05M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
353k
      switch (BinOp->getOpcode()) {
49
434
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
38
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
18.8k
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
14.8k
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
1.74k
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
51.5k
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
33.3k
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
15.6k
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
2.24k
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
17.5k
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
8.92k
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
7.65k
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
1.30k
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
7.82k
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
3.67k
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
3
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
6.93k
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
719
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
8.36k
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
35.5k
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
9.39k
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
87.6k
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
425
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
343
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
114
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
9.75k
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
1.80k
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
107
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
108
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
375
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
1.51k
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
189
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
4.27k
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
4.70M
      }
85
4.70M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
133k
      switch (UnOp->getOpcode()) {
87
3.71k
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
93
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
19.4k
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
3.26k
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
5.52k
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
25.3k
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
47
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
35.6k
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
3.40k
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
35.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.62k
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
5
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
4.56M
      }
102
4.56M
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
4.56M
    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.56M
    }
112
4.56M
  }
AnalysisBasedWarnings.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::ContainsReference, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
450
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
450
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
32
      switch (BinOp->getOpcode()) {
49
1
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
11
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
1
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
6
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
13
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
418
      }
85
418
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
8
      switch (UnOp->getOpcode()) {
87
4
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
2
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
2
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
410
      }
102
410
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
410
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
410
    }
112
410
  }
Sema.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::DeferredDiagnosticsEmitter, void>::Visit(clang::Stmt*)
Line
Count
Source
43
2.68M
  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.68M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
170k
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
1.95k
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
337
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
8
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
10.2k
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
6.69k
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
62
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
88
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
76.1k
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
1.16k
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
388
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
428
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
546
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
153
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
260
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
80
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
62
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
200
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
114
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
48.5k
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
145
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
188
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
44
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
21.5k
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
492
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
36
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
36
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
36
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
61
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
49
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
350
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
2.51M
      }
85
2.51M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
110k
      switch (UnOp->getOpcode()) {
87
17.5k
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
318
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
69.6k
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
189
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
920
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
20.3k
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
16
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
1.04k
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
78
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
76
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
48
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
52
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
40
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
2.40M
      }
102
2.40M
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
2.40M
    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.40M
    }
112
2.40M
  }
SemaChecking.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::SequenceChecker, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
52.4M
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
52.4M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
5.19M
      switch (BinOp->getOpcode()) {
49
344
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
243
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
199k
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
451k
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
9.15k
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
1.09M
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
1.06M
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
50.6k
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
17.2k
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
208k
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
176k
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
22.1k
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
17.0k
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
117k
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
43.3k
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
301
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
77.7k
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
16.8k
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
51.8k
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
136k
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
44.3k
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
1.31M
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
2.82k
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
2.12k
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
265
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
36.0k
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
4.50k
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
532
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
272
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
1.24k
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
10.5k
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
1.57k
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
13.1k
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
47.2M
      }
85
47.2M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
805k
      switch (UnOp->getOpcode()) {
87
52.1k
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
738
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
164k
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
11.0k
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
76.3k
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
109k
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
274
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
182k
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
38.2k
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
134k
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
207
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
178
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
34.7k
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
46.4M
      }
102
46.4M
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
46.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
46.4M
    }
112
46.4M
  }
SemaChecking.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::FindCaptureVisitor, void>::Visit(clang::Stmt*)
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
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
138
      }
85
138
    } 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
138
      }
102
138
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
138
    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
138
    }
112
138
  }
SemaDecl.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::SelfReferenceChecker, void>::Visit(clang::Stmt*)
Line
Count
Source
43
1.41M
  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.41M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
160k
      switch (BinOp->getOpcode()) {
49
25
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
3
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
32.3k
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
38.9k
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
80
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
12.9k
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
12.8k
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
10.8k
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
10
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
24.2k
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
47
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
8.36k
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
521
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
8.60k
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
35
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
51
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
836
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
2.25k
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
1.12k
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
5.75k
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
456
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
373
      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
14
      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
176
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
1.25M
      }
85
1.25M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
43.6k
      switch (UnOp->getOpcode()) {
87
38
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
2
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
35
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
5
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
10.8k
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
5.36k
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
10
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
19.1k
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
4.69k
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
3.55k
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
3
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
3
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
1.20M
      }
102
1.20M
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
1.20M
    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.20M
    }
112
1.20M
  }
SemaDeclCXX.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::UninitializedFieldVisitor, void>::Visit(clang::Stmt*)
Line
Count
Source
43
53.6k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
53.6k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
1.86k
      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
8
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
1.75k
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
4
      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
16
      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
51.7k
      }
85
51.7k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
165
      switch (UnOp->getOpcode()) {
87
20
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
16
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
99
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
18
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
11
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
1
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
51.6k
      }
102
51.6k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
51.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
51.6k
    }
112
51.6k
  }
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
884
      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
817
      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
112k
      }
85
112k
    } 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
13
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
51
      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
112k
      }
102
112k
    }
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)::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
5
      }
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
5
      }
102
5
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
5
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
5
    }
112
5
  }
SemaExpr.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::EvaluatedExprMarker, void>::Visit(clang::Stmt*)
Line
Count
Source
43
160k
  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
160k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
168
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
37
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
13
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
20
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
88
      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
10
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
160k
      }
85
160k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
29
      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
14
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
15
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
160k
      }
102
160k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
160k
    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
160k
    }
112
160k
  }
SemaExpr.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::RebuildUnknownAnyExpr, clang::ActionResult<clang::Expr*, true> >::Visit(clang::Stmt*)
Line
Count
Source
43
1.02k
  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.02k
    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
1.02k
      }
85
1.02k
    } 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
1.02k
      }
102
1.02k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
1.02k
    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.02k
    }
112
1.02k
  }
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
1.77k
      }
85
1.77k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
3
      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
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
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.76k
      }
102
1.76k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
1.76k
    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.76k
    }
112
1.76k
  }
SemaOpenMP.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::AllocatorChecker, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
296
  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
296
    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
296
      }
85
296
    } 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
296
      }
102
296
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
296
    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
296
    }
112
296
  }
SemaOpenMP.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::(anonymous namespace)::LoopCounterRefChecker, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
345k
  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
345k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
564
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
90
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
44
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
378
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
52
      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
344k
      }
85
344k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
499
      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
333
      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
344k
      }
102
344k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
344k
    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
344k
    }
112
344k
  }
SemaOpenMP.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::DSARefChecker, bool>::Visit(clang::Stmt*)
Line
Count
Source
43
14.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
14.9k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
0
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
14.9k
      }
85
14.9k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
0
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
14.9k
      }
102
14.9k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
14.9k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
14.9k
    }
112
14.9k
  }
SemaOpenMP.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::MapBaseChecker, bool>::Visit(clang::Stmt*)
Line
Count
Source
43
62.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
62.3k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
489
      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
486
      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
61.8k
      }
85
61.8k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
631
      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
631
      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
61.1k
      }
102
61.1k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
61.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
61.1k
    }
112
61.1k
  }
SemaOpenMP.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::LocalVarRefChecker, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
2.17k
  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.17k
    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
2.17k
      }
85
2.17k
    } 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
2.17k
      }
102
2.17k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
2.17k
    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.17k
    }
112
2.17k
  }
SemaOpenMP.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::DSAAttrChecker, void>::Visit(clang::Stmt*)
Line
Count
Source
43
2.37M
  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.37M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
209k
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
1.41k
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
156
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
7.93k
      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
106k
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
1.59k
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
388
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
624
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
316
      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
52.7k
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
100
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
138
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
16.0k
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
820
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
17
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
13
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
404
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
2.16M
      }
85
2.16M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
120k
      switch (UnOp->getOpcode()) {
87
29.8k
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
380
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
88.4k
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
179
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
225
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
672
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
712
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
296
      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
2.04M
      }
102
2.04M
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
2.04M
    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.04M
    }
112
2.04M
  }
SemaStmt.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::BreakContinueFinder, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
54.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
54.1k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
8.87k
      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
52
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
8.18k
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
73
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
79
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
23
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
21
      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
30
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
23
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
61
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
4
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
4
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
4
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
22
      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
45.2k
      }
85
45.2k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
8.46k
      switch (UnOp->getOpcode()) {
87
913
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
35
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
7.36k
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
38
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
24
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
63
      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
36.8k
      }
102
36.8k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
36.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
36.8k
    }
112
36.8k
  }
SemaStmt.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::DeclExtractor, void>::Visit(clang::Stmt*)
Line
Count
Source
43
643
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
643
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
141
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
88
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
2
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
40
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
3
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
6
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
2
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
502
      }
85
502
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
4
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
1
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
2
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
1
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
498
      }
102
498
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
498
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
498
    }
112
498
  }
SemaStmt.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::DeclMatcher, void>::Visit(clang::Stmt*)
Line
Count
Source
43
613
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
613
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
157
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
92
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
2
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
33
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
3
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
6
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
2
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
19
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
456
      }
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
424
      }
102
424
    }
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
642
      }
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
642
      }
102
642
    }
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
24
  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
    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
2
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
1
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
21
      }
85
21
    } 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
21
      }
102
21
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
21
    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
    }
112
21
  }
AnalysisDeclContext.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::FindBlockDeclRefExprsVals, void>::Visit(clang::Stmt*)
Line
Count
Source
43
2.44k
  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.44k
    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
2.27k
      }
85
2.27k
    } 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
2.19k
      }
102
2.19k
    }
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
  }
CFG.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::CFGBlockTerminatorPrint, void>::Visit(clang::Stmt*)
Line
Count
Source
43
535
  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
535
    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
498
      }
85
498
    } 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
498
      }
102
498
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
498
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
498
    }
112
498
  }
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
2.16k
      }
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
2.14k
      }
102
2.14k
    }
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
34.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
34.1k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
1.89k
      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
10
      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
171
      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.48k
      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
32.2k
      }
85
32.2k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
746
      switch (UnOp->getOpcode()) {
87
8
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
4
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
12
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
4
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
340
      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
31.5k
      }
102
31.5k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
31.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
31.5k
    }
112
31.5k
  }
ThreadSafety.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::BuildLockset, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
33.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
33.9k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
1.89k
      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
10
      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
171
      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.48k
      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
32.0k
      }
85
32.0k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
738
      switch (UnOp->getOpcode()) {
87
8
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
4
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
12
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
4
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
340
      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
31.3k
      }
102
31.3k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
31.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
31.3k
    }
112
31.3k
  }
UninitializedValues.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::TransferFunctions, void>::Visit(clang::Stmt*)
Line
Count
Source
43
59.9k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
59.9k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
6.09k
      switch (BinOp->getOpcode()) {
49
2
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
89
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
8
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
22
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
203
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
70
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
100
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
11
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
1.77k
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
130
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
65
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
65
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
256
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
278
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
81
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
2
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
14
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
9
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
19
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
2.53k
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
13
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
2
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
2
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
189
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
2
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
19
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
19
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
1
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
29
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
1
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
79
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
53.8k
      }
85
53.8k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
1.52k
      switch (UnOp->getOpcode()) {
87
46
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
948
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
193
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
164
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
153
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
1
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
17
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
52.3k
      }
102
52.3k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
52.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
52.3k
    }
112
52.3k
  }
UninitializedValues.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::ClassifyRefs, void>::Visit(clang::Stmt*)
Line
Count
Source
43
44.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
44.1k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
4.69k
      switch (BinOp->getOpcode()) {
49
1
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
89
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
6
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
22
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
102
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
68
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
100
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
11
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
950
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
130
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
63
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
65
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
297
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
114
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
81
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
2
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
14
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
7
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
17
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
2.23k
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
20
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
2
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
2
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
166
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
2
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
19
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
19
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
1
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
29
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
1
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
57
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
39.4k
      }
85
39.4k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
1.35k
      switch (UnOp->getOpcode()) {
87
34
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
876
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
178
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
83
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
168
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
1
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
13
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
38.1k
      }
102
38.1k
    }
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
  }
CGClass.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::DynamicThisUseChecker, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
32.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
32.4k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
13
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
3
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
10
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
32.4k
      }
85
32.4k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
10
      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
10
      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
32.4k
      }
102
32.4k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
32.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
32.4k
    }
112
32.4k
  }
CGCoroutine.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::GetParamRef, void>::Visit(clang::Stmt*)
Line
Count
Source
43
72
  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
72
    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
72
      }
85
72
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
0
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
72
      }
102
72
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
72
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
72
    }
112
72
  }
CGException.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::CaptureFinder, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
498
  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
498
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
38
      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
13
      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
12
      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
13
      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
460
      }
85
460
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
11
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
5
      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
5
      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
449
      }
102
449
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
449
    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
449
    }
112
449
  }
CGExprAgg.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::AggExprEmitter, void>::Visit(clang::Stmt*)
Line
Count
Source
43
116k
  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
116k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
512
      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
13
      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
456
      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
43
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
116k
      }
85
116k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
733
      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
94
      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
639
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
115k
      }
102
115k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
115k
    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
115k
    }
112
115k
  }
CGExprComplex.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::ComplexExprEmitter, std::__1::pair<llvm::Value*, llvm::Value*> >::Visit(clang::Stmt*)
Line
Count
Source
43
4.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
4.45k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
729
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
121
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
97
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
219
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
129
      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
150
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
1
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
4
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
8
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
3.72k
      }
85
3.72k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
45
      switch (UnOp->getOpcode()) {
87
2
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
2
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
2
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
2
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
8
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
5
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
3
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
3
      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
3.67k
      }
102
3.67k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
3.67k
    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.67k
    }
112
3.67k
  }
CGExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::ConstantLValueEmitter, (anonymous namespace)::ConstantLValue>::Visit(clang::Stmt const*)
Line
Count
Source
43
4.04k
  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.04k
    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,