Coverage Report

Created: 2018-09-25 23:22

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/tools/clang/include/clang/AST/StmtVisitor.h
Line
Count
Source (jump to first uncovered line)
1
//===- StmtVisitor.h - Visitor for Stmt subclasses --------------*- C++ -*-===//
2
//
3
//                     The LLVM Compiler Infrastructure
4
//
5
// This file is distributed under the University of Illinois Open Source
6
// License. See LICENSE.TXT for details.
7
//
8
//===----------------------------------------------------------------------===//
9
//
10
//  This file defines the StmtVisitor and ConstStmtVisitor interfaces.
11
//
12
//===----------------------------------------------------------------------===//
13
14
#ifndef LLVM_CLANG_AST_STMTVISITOR_H
15
#define LLVM_CLANG_AST_STMTVISITOR_H
16
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/Support/Casting.h"
26
#include "llvm/Support/ErrorHandling.h"
27
#include <utility>
28
29
namespace clang {
30
31
template <typename T> struct make_ptr { using type = T *; };
32
template <typename T> struct make_const_ptr { using type = const T *; };
33
34
/// StmtVisitorBase - This class implements a simple visitor for Stmt
35
/// subclasses. Since Expr derives from Stmt, this also includes support for
36
/// visiting Exprs.
37
template<template <typename> class Ptr, typename ImplClass, typename RetTy=void,
38
         class... ParamTys>
39
class StmtVisitorBase {
40
public:
41
#define PTR(CLASS) typename Ptr<CLASS>::type
42
#define DISPATCH(NAME, CLASS) \
43
211M
  return static_cast<ImplClass*>(this)->Visit ## NAME( \
44
211M
    static_cast<PTR(CLASS)>(S), std::forward<ParamTys>(P)...)
45
46
134M
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
134M
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
134M
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
134M
    // below.
50
134M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
13.8M
      switch (BinOp->getOpcode()) {
52
13.8M
      
case BO_PtrMemD: 71.3k
DISPATCH71.3k
(BinPtrMemD, BinaryOperator);
53
13.8M
      
case BO_PtrMemI: 398
DISPATCH398
(BinPtrMemI, BinaryOperator);
54
13.8M
      
case BO_Mul: 540k
DISPATCH540k
(BinMul, BinaryOperator);
55
13.8M
      
case BO_Div: 464k
DISPATCH464k
(BinDiv, BinaryOperator);
56
13.8M
      
case BO_Rem: 43.0k
DISPATCH43.0k
(BinRem, BinaryOperator);
57
13.8M
      
case BO_Add: 1.45M
DISPATCH1.45M
(BinAdd, BinaryOperator);
58
13.8M
      
case BO_Sub: 1.57M
DISPATCH1.57M
(BinSub, BinaryOperator);
59
13.8M
      
case BO_Shl: 411k
DISPATCH411k
(BinShl, BinaryOperator);
60
13.8M
      
case BO_Shr: 174k
DISPATCH174k
(BinShr, BinaryOperator);
61
13.8M
62
13.8M
      
case BO_LT: 894k
DISPATCH894k
(BinLT, BinaryOperator);
63
13.8M
      
case BO_GT: 622k
DISPATCH622k
(BinGT, BinaryOperator);
64
13.8M
      
case BO_LE: 235k
DISPATCH235k
(BinLE, BinaryOperator);
65
13.8M
      
case BO_GE: 172k
DISPATCH172k
(BinGE, BinaryOperator);
66
13.8M
      
case BO_EQ: 1.07M
DISPATCH1.07M
(BinEQ, BinaryOperator);
67
13.8M
      
case BO_NE: 466k
DISPATCH466k
(BinNE, BinaryOperator);
68
13.8M
      
case BO_Cmp: 477
DISPATCH477
(BinCmp, BinaryOperator);
69
13.8M
70
13.8M
      
case BO_And: 295k
DISPATCH295k
(BinAnd, BinaryOperator);
71
13.8M
      
case BO_Xor: 60.6k
DISPATCH60.6k
(BinXor, BinaryOperator);
72
13.8M
      
case BO_Or : 165k
DISPATCH165k
(BinOr, BinaryOperator);
73
13.8M
      
case BO_LAnd: 914k
DISPATCH914k
(BinLAnd, BinaryOperator);
74
13.8M
      
case BO_LOr : 412k
DISPATCH412k
(BinLOr, BinaryOperator);
75
13.8M
      
case BO_Assign: 3.31M
DISPATCH3.31M
(BinAssign, BinaryOperator);
76
13.8M
      
case BO_MulAssign: 13.4k
DISPATCH13.4k
(BinMulAssign, CompoundAssignOperator);
77
13.8M
      
case BO_DivAssign: 4.39k
DISPATCH4.39k
(BinDivAssign, CompoundAssignOperator);
78
13.8M
      
case BO_RemAssign: 442
DISPATCH442
(BinRemAssign, CompoundAssignOperator);
79
13.8M
      
case BO_AddAssign: 159k
DISPATCH159k
(BinAddAssign, CompoundAssignOperator);
80
13.8M
      
case BO_SubAssign: 21.5k
DISPATCH21.5k
(BinSubAssign, CompoundAssignOperator);
81
13.8M
      
case BO_ShlAssign: 7.42k
DISPATCH7.42k
(BinShlAssign, CompoundAssignOperator);
82
13.8M
      
case BO_ShrAssign: 3.71k
DISPATCH3.71k
(BinShrAssign, CompoundAssignOperator);
83
13.8M
      
case BO_AndAssign: 8.76k
DISPATCH8.76k
(BinAndAssign, CompoundAssignOperator);
84
13.8M
      
case BO_OrAssign: 40.7k
DISPATCH40.7k
(BinOrAssign, CompoundAssignOperator);
85
13.8M
      
case BO_XorAssign: 5.84k
DISPATCH5.84k
(BinXorAssign, CompoundAssignOperator);
86
13.8M
      
case BO_Comma: 202k
DISPATCH202k
(BinComma, BinaryOperator);
87
120M
      }
88
120M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
4.58M
      switch (UnOp->getOpcode()) {
90
4.58M
      
case UO_PostInc: 284k
DISPATCH284k
(UnaryPostInc, UnaryOperator);
91
4.58M
      
case UO_PostDec: 21.5k
DISPATCH21.5k
(UnaryPostDec, UnaryOperator);
92
4.58M
      
case UO_PreInc: 211k
DISPATCH211k
(UnaryPreInc, UnaryOperator);
93
4.58M
      
case UO_PreDec: 33.4k
DISPATCH33.4k
(UnaryPreDec, UnaryOperator);
94
4.58M
      
case UO_AddrOf: 473k
DISPATCH473k
(UnaryAddrOf, UnaryOperator);
95
4.58M
      
case UO_Deref: 508k
DISPATCH508k
(UnaryDeref, UnaryOperator);
96
4.58M
      
case UO_Plus: 1.17k
DISPATCH1.17k
(UnaryPlus, UnaryOperator);
97
4.58M
      
case UO_Minus: 546k
DISPATCH546k
(UnaryMinus, UnaryOperator);
98
4.58M
      
case UO_Not: 84.4k
DISPATCH84.4k
(UnaryNot, UnaryOperator);
99
4.58M
      
case UO_LNot: 2.38M
DISPATCH2.38M
(UnaryLNot, UnaryOperator);
100
4.58M
      
case UO_Real: 3.60k
DISPATCH3.60k
(UnaryReal, UnaryOperator);
101
4.58M
      
case UO_Imag: 3.55k
DISPATCH3.55k
(UnaryImag, UnaryOperator);
102
4.58M
      
case UO_Extension: 32.9k
DISPATCH32.9k
(UnaryExtension, UnaryOperator);
103
4.58M
      
case UO_Coawait: 10
DISPATCH10
(UnaryCoawait, UnaryOperator);
104
115M
      }
105
115M
    }
106
115M
107
115M
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
115M
    switch (S->getStmtClass()) {
109
115M
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
115M
#define ABSTRACT_STMT(STMT)
111
115M
#define STMT(CLASS, PARENT)                              \
112
115M
    case Stmt::CLASS ## Class: 
DISPATCH115M
(CLASS, CLASS);
113
115M
#include 
"clang/AST/StmtNodes.inc"47.7k
114
115M
    }
115
115M
  }
CGClass.cpp:clang::StmtVisitorBase<clang::make_const_ptr, (anonymous namespace)::DynamicThisUseChecker, void>::Visit(clang::Stmt const*)
Line
Count
Source
46
30.6k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
30.6k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
30.6k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
30.6k
    // below.
50
30.6k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
11
      switch (BinOp->getOpcode()) {
52
11
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
11
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
11
      
case BO_Mul: 1
DISPATCH1
(BinMul, BinaryOperator);
55
11
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
56
11
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
57
11
      
case BO_Add: 10
DISPATCH10
(BinAdd, BinaryOperator);
58
11
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
59
11
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
60
11
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
61
11
62
11
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
63
11
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
64
11
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
65
11
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
66
11
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
67
11
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
68
11
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
11
70
11
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
71
11
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
72
11
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
73
11
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
74
11
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
75
11
      
case BO_Assign: 0
DISPATCH0
(BinAssign, BinaryOperator);
76
11
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
77
11
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
78
11
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
11
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
80
11
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
81
11
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
82
11
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
11
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
11
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
11
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
11
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
87
30.6k
      }
88
30.6k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
113
      switch (UnOp->getOpcode()) {
90
113
      
case UO_PostInc: 0
DISPATCH0
(UnaryPostInc, UnaryOperator);
91
113
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
92
113
      
case UO_PreInc: 0
DISPATCH0
(UnaryPreInc, UnaryOperator);
93
113
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
94
113
      
case UO_AddrOf: 108
DISPATCH108
(UnaryAddrOf, UnaryOperator);
95
113
      
case UO_Deref: 5
DISPATCH5
(UnaryDeref, UnaryOperator);
96
113
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
97
113
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
98
113
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
99
113
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
100
113
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
101
113
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
102
113
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
103
113
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
30.5k
      }
105
30.5k
    }
106
30.5k
107
30.5k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
30.5k
    switch (S->getStmtClass()) {
109
30.5k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
30.5k
#define ABSTRACT_STMT(STMT)
111
30.5k
#define STMT(CLASS, PARENT)                              \
112
30.5k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
30.5k
#include 
"clang/AST/StmtNodes.inc"0
114
30.5k
    }
115
30.5k
  }
CGCoroutine.cpp:clang::StmtVisitorBase<clang::make_ptr, (anonymous namespace)::GetParamRef, void>::Visit(clang::Stmt*)
Line
Count
Source
46
70
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
70
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
70
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
70
    // below.
50
70
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
0
      switch (BinOp->getOpcode()) {
52
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
53
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
54
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
55
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
56
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
57
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
58
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
59
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
60
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
61
0
62
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
63
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
64
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
65
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
66
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
67
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
68
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
69
0
70
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
71
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
72
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
73
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
74
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
75
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
76
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
77
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
78
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
79
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
80
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
81
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
82
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
83
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
84
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
85
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
86
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
87
70
      }
88
70
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
0
      switch (UnOp->getOpcode()) {
90
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
91
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
92
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
93
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
94
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
95
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
96
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
97
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
98
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
99
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
100
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
101
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
102
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
103
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
104
70
      }
105
70
    }
106
70
107
70
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
70
    switch (S->getStmtClass()) {
109
70
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
70
#define ABSTRACT_STMT(STMT)
111
70
#define STMT(CLASS, PARENT)                              \
112
70
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
70
#include 
"clang/AST/StmtNodes.inc"0
114
70
    }
115
70
  }
CGException.cpp:clang::StmtVisitorBase<clang::make_const_ptr, (anonymous namespace)::CaptureFinder, void>::Visit(clang::Stmt const*)
Line
Count
Source
46
400
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
400
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
400
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
400
    // below.
50
400
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
24
      switch (BinOp->getOpcode()) {
52
24
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
24
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
24
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
55
24
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
56
24
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
57
24
      
case BO_Add: 0
DISPATCH0
(BinAdd, BinaryOperator);
58
24
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
59
24
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
60
24
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
61
24
62
24
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
63
24
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
64
24
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
65
24
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
66
24
      
case BO_EQ: 12
DISPATCH12
(BinEQ, BinaryOperator);
67
24
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
68
24
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
24
70
24
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
71
24
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
72
24
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
73
24
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
74
24
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
75
24
      
case BO_Assign: 12
DISPATCH12
(BinAssign, BinaryOperator);
76
24
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
77
24
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
78
24
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
24
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
80
24
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
81
24
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
82
24
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
24
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
24
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
24
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
24
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
87
376
      }
88
376
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
10
      switch (UnOp->getOpcode()) {
90
10
      
case UO_PostInc: 0
DISPATCH0
(UnaryPostInc, UnaryOperator);
91
10
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
92
10
      
case UO_PreInc: 5
DISPATCH5
(UnaryPreInc, UnaryOperator);
93
10
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
94
10
      
case UO_AddrOf: 0
DISPATCH0
(UnaryAddrOf, UnaryOperator);
95
10
      
case UO_Deref: 0
DISPATCH0
(UnaryDeref, UnaryOperator);
96
10
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
97
10
      
case UO_Minus: 5
DISPATCH5
(UnaryMinus, UnaryOperator);
98
10
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
99
10
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
100
10
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
101
10
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
102
10
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
103
10
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
366
      }
105
366
    }
106
366
107
366
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
366
    switch (S->getStmtClass()) {
109
366
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
366
#define ABSTRACT_STMT(STMT)
111
366
#define STMT(CLASS, PARENT)                              \
112
366
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
366
#include 
"clang/AST/StmtNodes.inc"0
114
366
    }
115
366
  }
CGExprAgg.cpp:clang::StmtVisitorBase<clang::make_ptr, (anonymous namespace)::AggExprEmitter, void>::Visit(clang::Stmt*)
Line
Count
Source
46
205k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
205k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
205k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
205k
    // below.
50
205k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
1.39k
      switch (BinOp->getOpcode()) {
52
1.39k
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
1.39k
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
1.39k
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
55
1.39k
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
56
1.39k
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
57
1.39k
      
case BO_Add: 0
DISPATCH0
(BinAdd, BinaryOperator);
58
1.39k
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
59
1.39k
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
60
1.39k
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
61
1.39k
62
1.39k
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
63
1.39k
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
64
1.39k
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
65
1.39k
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
66
1.39k
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
67
1.39k
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
68
1.39k
      
case BO_Cmp: 17
DISPATCH17
(BinCmp, BinaryOperator);
69
1.39k
70
1.39k
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
71
1.39k
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
72
1.39k
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
73
1.39k
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
74
1.39k
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
75
1.39k
      
case BO_Assign: 1.33k
DISPATCH1.33k
(BinAssign, BinaryOperator);
76
1.39k
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
77
1.39k
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
78
1.39k
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
1.39k
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
80
1.39k
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
81
1.39k
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
82
1.39k
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
1.39k
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
1.39k
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
1.39k
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
1.39k
      
case BO_Comma: 52
DISPATCH52
(BinComma, BinaryOperator);
87
204k
      }
88
204k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
1.09k
      switch (UnOp->getOpcode()) {
90
1.09k
      
case UO_PostInc: 0
DISPATCH0
(UnaryPostInc, UnaryOperator);
91
1.09k
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
92
1.09k
      
case UO_PreInc: 0
DISPATCH0
(UnaryPreInc, UnaryOperator);
93
1.09k
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
94
1.09k
      
case UO_AddrOf: 0
DISPATCH0
(UnaryAddrOf, UnaryOperator);
95
1.09k
      
case UO_Deref: 274
DISPATCH274
(UnaryDeref, UnaryOperator);
96
1.09k
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
97
1.09k
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
98
1.09k
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
99
1.09k
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
100
1.09k
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
101
1.09k
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
102
1.09k
      
case UO_Extension: 825
DISPATCH825
(UnaryExtension, UnaryOperator);
103
1.09k
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
203k
      }
105
203k
    }
106
203k
107
203k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
203k
    switch (S->getStmtClass()) {
109
203k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
203k
#define ABSTRACT_STMT(STMT)
111
203k
#define STMT(CLASS, PARENT)                              \
112
203k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
203k
#include 
"clang/AST/StmtNodes.inc"0
114
203k
    }
115
203k
  }
CGExprComplex.cpp:clang::StmtVisitorBase<clang::make_ptr, (anonymous namespace)::ComplexExprEmitter, std::__1::pair<llvm::Value*, llvm::Value*> >::Visit(clang::Stmt*)
Line
Count
Source
46
4.32k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
4.32k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
4.32k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
4.32k
    // below.
50
4.32k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
699
      switch (BinOp->getOpcode()) {
52
699
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
699
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
699
      
case BO_Mul: 122
DISPATCH122
(BinMul, BinaryOperator);
55
699
      
case BO_Div: 86
DISPATCH86
(BinDiv, BinaryOperator);
56
699
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
57
699
      
case BO_Add: 203
DISPATCH203
(BinAdd, BinaryOperator);
58
699
      
case BO_Sub: 112
DISPATCH112
(BinSub, BinaryOperator);
59
699
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
60
699
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
61
699
62
699
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
63
699
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
64
699
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
65
699
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
66
699
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
67
699
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
68
699
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
699
70
699
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
71
699
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
72
699
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
73
699
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
74
699
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
75
699
      
case BO_Assign: 160
DISPATCH160
(BinAssign, BinaryOperator);
76
699
      
case BO_MulAssign: 1
DISPATCH1
(BinMulAssign, CompoundAssignOperator);
77
699
      
case BO_DivAssign: 4
DISPATCH4
(BinDivAssign, CompoundAssignOperator);
78
699
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
699
      
case BO_AddAssign: 11
DISPATCH11
(BinAddAssign, CompoundAssignOperator);
80
699
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
81
699
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
82
699
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
699
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
699
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
699
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
699
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
87
3.62k
      }
88
3.62k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
36
      switch (UnOp->getOpcode()) {
90
36
      
case UO_PostInc: 2
DISPATCH2
(UnaryPostInc, UnaryOperator);
91
36
      
case UO_PostDec: 2
DISPATCH2
(UnaryPostDec, UnaryOperator);
92
36
      
case UO_PreInc: 2
DISPATCH2
(UnaryPreInc, UnaryOperator);
93
36
      
case UO_PreDec: 2
DISPATCH2
(UnaryPreDec, UnaryOperator);
94
36
      
case UO_AddrOf: 0
DISPATCH0
(UnaryAddrOf, UnaryOperator);
95
36
      
case UO_Deref: 4
DISPATCH4
(UnaryDeref, UnaryOperator);
96
36
      
case UO_Plus: 5
DISPATCH5
(UnaryPlus, UnaryOperator);
97
36
      
case UO_Minus: 4
DISPATCH4
(UnaryMinus, UnaryOperator);
98
36
      
case UO_Not: 3
DISPATCH3
(UnaryNot, UnaryOperator);
99
36
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
100
36
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
101
36
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
102
36
      
case UO_Extension: 12
DISPATCH12
(UnaryExtension, UnaryOperator);
103
36
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
3.58k
      }
105
3.58k
    }
106
3.58k
107
3.58k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
3.58k
    switch (S->getStmtClass()) {
109
3.58k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
3.58k
#define ABSTRACT_STMT(STMT)
111
3.58k
#define STMT(CLASS, PARENT)                              \
112
3.58k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
3.58k
#include 
"clang/AST/StmtNodes.inc"0
114
3.58k
    }
115
3.58k
  }
CGExprConstant.cpp:clang::StmtVisitorBase<clang::make_const_ptr, (anonymous namespace)::ConstantLValueEmitter, (anonymous namespace)::ConstantLValue>::Visit(clang::Stmt const*)
Line
Count
Source
46
14.6k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
14.6k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
14.6k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
14.6k
    // below.
50
14.6k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
0
      switch (BinOp->getOpcode()) {
52
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
53
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
54
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
55
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
56
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
57
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
58
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
59
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
60
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
61
0
62
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
63
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
64
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
65
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
66
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
67
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
68
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
69
0
70
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
71
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
72
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
73
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
74
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
75
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
76
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
77
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
78
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
79
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
80
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
81
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
82
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
83
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
84
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
85
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
86
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
87
14.6k
      }
88
14.6k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
0
      switch (UnOp->getOpcode()) {
90
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
91
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
92
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
93
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
94
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
95
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
96
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
97
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
98
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
99
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
100
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
101
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
102
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
103
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
104
14.6k
      }
105
14.6k
    }
106
14.6k
107
14.6k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
14.6k
    switch (S->getStmtClass()) {
109
14.6k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
14.6k
#define ABSTRACT_STMT(STMT)
111
14.6k
#define STMT(CLASS, PARENT)                              \
112
14.6k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
14.6k
#include 
"clang/AST/StmtNodes.inc"0
114
14.6k
    }
115
14.6k
  }
CGExprConstant.cpp:clang::StmtVisitorBase<clang::make_ptr, (anonymous namespace)::ConstExprEmitter, llvm::Constant*, clang::QualType>::Visit(clang::Stmt*, clang::QualType)
Line
Count
Source
46
37.6k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
37.6k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
37.6k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
37.6k
    // below.
50
37.6k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
128
      switch (BinOp->getOpcode()) {
52
128
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
128
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
128
      
case BO_Mul: 4
DISPATCH4
(BinMul, BinaryOperator);
55
128
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
56
128
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
57
128
      
case BO_Add: 91
DISPATCH91
(BinAdd, BinaryOperator);
58
128
      
case BO_Sub: 7
DISPATCH7
(BinSub, BinaryOperator);
59
128
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
60
128
      
case BO_Shr: 1
DISPATCH1
(BinShr, BinaryOperator);
61
128
62
128
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
63
128
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
64
128
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
65
128
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
66
128
      
case BO_EQ: 12
DISPATCH12
(BinEQ, BinaryOperator);
67
128
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
68
128
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
128
70
128
      
case BO_And: 1
DISPATCH1
(BinAnd, BinaryOperator);
71
128
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
72
128
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
73
128
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
74
128
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
75
128
      
case BO_Assign: 5
DISPATCH5
(BinAssign, BinaryOperator);
76
128
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
77
128
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
78
128
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
128
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
80
128
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
81
128
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
82
128
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
128
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
128
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
128
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
128
      
case BO_Comma: 7
DISPATCH7
(BinComma, BinaryOperator);
87
37.5k
      }
88
37.5k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
50
      switch (UnOp->getOpcode()) {
90
50
      
case UO_PostInc: 1
DISPATCH1
(UnaryPostInc, UnaryOperator);
91
50
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
92
50
      
case UO_PreInc: 2
DISPATCH2
(UnaryPreInc, UnaryOperator);
93
50
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
94
50
      
case UO_AddrOf: 29
DISPATCH29
(UnaryAddrOf, UnaryOperator);
95
50
      
case UO_Deref: 15
DISPATCH15
(UnaryDeref, UnaryOperator);
96
50
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
97
50
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
98
50
      
case UO_Not: 3
DISPATCH3
(UnaryNot, UnaryOperator);
99
50
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
100
50
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
101
50
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
102
50
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
103
50
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
37.4k
      }
105
37.4k
    }
106
37.4k
107
37.4k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
37.4k
    switch (S->getStmtClass()) {
109
37.4k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
37.4k
#define ABSTRACT_STMT(STMT)
111
37.4k
#define STMT(CLASS, PARENT)                              \
112
37.4k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
37.4k
#include 
"clang/AST/StmtNodes.inc"0
114
37.4k
    }
115
37.4k
  }
CGExprScalar.cpp:clang::StmtVisitorBase<clang::make_ptr, (anonymous namespace)::ScalarExprEmitter, llvm::Value*>::Visit(clang::Stmt*)
Line
Count
Source
46
9.53M
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
9.53M
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
9.53M
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
9.53M
    // below.
50
9.53M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
1.06M
      switch (BinOp->getOpcode()) {
52
1.06M
      
case BO_PtrMemD: 22
DISPATCH22
(BinPtrMemD, BinaryOperator);
53
1.06M
      
case BO_PtrMemI: 15
DISPATCH15
(BinPtrMemI, BinaryOperator);
54
1.06M
      
case BO_Mul: 69.9k
DISPATCH69.9k
(BinMul, BinaryOperator);
55
1.06M
      
case BO_Div: 42.9k
DISPATCH42.9k
(BinDiv, BinaryOperator);
56
1.06M
      
case BO_Rem: 3.66k
DISPATCH3.66k
(BinRem, BinaryOperator);
57
1.06M
      
case BO_Add: 149k
DISPATCH149k
(BinAdd, BinaryOperator);
58
1.06M
      
case BO_Sub: 152k
DISPATCH152k
(BinSub, BinaryOperator);
59
1.06M
      
case BO_Shl: 29.8k
DISPATCH29.8k
(BinShl, BinaryOperator);
60
1.06M
      
case BO_Shr: 21.1k
DISPATCH21.1k
(BinShr, BinaryOperator);
61
1.06M
62
1.06M
      
case BO_LT: 54.7k
DISPATCH54.7k
(BinLT, BinaryOperator);
63
1.06M
      
case BO_GT: 34.3k
DISPATCH34.3k
(BinGT, BinaryOperator);
64
1.06M
      
case BO_LE: 18.8k
DISPATCH18.8k
(BinLE, BinaryOperator);
65
1.06M
      
case BO_GE: 13.2k
DISPATCH13.2k
(BinGE, BinaryOperator);
66
1.06M
      
case BO_EQ: 80.2k
DISPATCH80.2k
(BinEQ, BinaryOperator);
67
1.06M
      
case BO_NE: 41.4k
DISPATCH41.4k
(BinNE, BinaryOperator);
68
1.06M
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
1.06M
70
1.06M
      
case BO_And: 26.8k
DISPATCH26.8k
(BinAnd, BinaryOperator);
71
1.06M
      
case BO_Xor: 7.28k
DISPATCH7.28k
(BinXor, BinaryOperator);
72
1.06M
      
case BO_Or : 11.9k
DISPATCH11.9k
(BinOr, BinaryOperator);
73
1.06M
      
case BO_LAnd: 5.95k
DISPATCH5.95k
(BinLAnd, BinaryOperator);
74
1.06M
      
case BO_LOr : 2.06k
DISPATCH2.06k
(BinLOr, BinaryOperator);
75
1.06M
      
case BO_Assign: 255k
DISPATCH255k
(BinAssign, BinaryOperator);
76
1.06M
      
case BO_MulAssign: 785
DISPATCH785
(BinMulAssign, CompoundAssignOperator);
77
1.06M
      
case BO_DivAssign: 348
DISPATCH348
(BinDivAssign, CompoundAssignOperator);
78
1.06M
      
case BO_RemAssign: 53
DISPATCH53
(BinRemAssign, CompoundAssignOperator);
79
1.06M
      
case BO_AddAssign: 17.0k
DISPATCH17.0k
(BinAddAssign, CompoundAssignOperator);
80
1.06M
      
case BO_SubAssign: 2.75k
DISPATCH2.75k
(BinSubAssign, CompoundAssignOperator);
81
1.06M
      
case BO_ShlAssign: 923
DISPATCH923
(BinShlAssign, CompoundAssignOperator);
82
1.06M
      
case BO_ShrAssign: 812
DISPATCH812
(BinShrAssign, CompoundAssignOperator);
83
1.06M
      
case BO_AndAssign: 686
DISPATCH686
(BinAndAssign, CompoundAssignOperator);
84
1.06M
      
case BO_OrAssign: 2.56k
DISPATCH2.56k
(BinOrAssign, CompoundAssignOperator);
85
1.06M
      
case BO_XorAssign: 730
DISPATCH730
(BinXorAssign, CompoundAssignOperator);
86
1.06M
      
case BO_Comma: 14.1k
DISPATCH14.1k
(BinComma, BinaryOperator);
87
8.46M
      }
88
8.46M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
268k
      switch (UnOp->getOpcode()) {
90
268k
      
case UO_PostInc: 40.9k
DISPATCH40.9k
(UnaryPostInc, UnaryOperator);
91
268k
      
case UO_PostDec: 3.70k
DISPATCH3.70k
(UnaryPostDec, UnaryOperator);
92
268k
      
case UO_PreInc: 3.62k
DISPATCH3.62k
(UnaryPreInc, UnaryOperator);
93
268k
      
case UO_PreDec: 2.88k
DISPATCH2.88k
(UnaryPreDec, UnaryOperator);
94
268k
      
case UO_AddrOf: 67.7k
DISPATCH67.7k
(UnaryAddrOf, UnaryOperator);
95
268k
      
case UO_Deref: 25.1k
DISPATCH25.1k
(UnaryDeref, UnaryOperator);
96
268k
      
case UO_Plus: 152
DISPATCH152
(UnaryPlus, UnaryOperator);
97
268k
      
case UO_Minus: 31.6k
DISPATCH31.6k
(UnaryMinus, UnaryOperator);
98
268k
      
case UO_Not: 5.89k
DISPATCH5.89k
(UnaryNot, UnaryOperator);
99
268k
      
case UO_LNot: 77.1k
DISPATCH77.1k
(UnaryLNot, UnaryOperator);
100
268k
      
case UO_Real: 236
DISPATCH236
(UnaryReal, UnaryOperator);
101
268k
      
case UO_Imag: 223
DISPATCH223
(UnaryImag, UnaryOperator);
102
268k
      
case UO_Extension: 9.16k
DISPATCH9.16k
(UnaryExtension, UnaryOperator);
103
268k
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
8.19M
      }
105
8.19M
    }
106
8.19M
107
8.19M
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
8.19M
    switch (S->getStmtClass()) {
109
8.19M
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
8.19M
#define ABSTRACT_STMT(STMT)
111
8.19M
#define STMT(CLASS, PARENT)                              \
112
8.19M
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
8.19M
#include 
"clang/AST/StmtNodes.inc"0
114
8.19M
    }
115
8.19M
  }
CGOpenMPRuntimeNVPTX.cpp:clang::StmtVisitorBase<clang::make_const_ptr, (anonymous namespace)::CheckVarsEscapingDeclContext, void>::Visit(clang::Stmt const*)
Line
Count
Source
46
1.37k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
1.37k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
1.37k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
1.37k
    // below.
50
1.37k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
190
      switch (BinOp->getOpcode()) {
52
190
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
190
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
190
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
55
190
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
56
190
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
57
190
      
case BO_Add: 23
DISPATCH23
(BinAdd, BinaryOperator);
58
190
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
59
190
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
60
190
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
61
190
62
190
      
case BO_LT: 3
DISPATCH3
(BinLT, BinaryOperator);
63
190
      
case BO_GT: 3
DISPATCH3
(BinGT, BinaryOperator);
64
190
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
65
190
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
66
190
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
67
190
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
68
190
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
190
70
190
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
71
190
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
72
190
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
73
190
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
74
190
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
75
190
      
case BO_Assign: 65
DISPATCH65
(BinAssign, BinaryOperator);
76
190
      
case BO_MulAssign: 3
DISPATCH3
(BinMulAssign, CompoundAssignOperator);
77
190
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
78
190
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
190
      
case BO_AddAssign: 87
DISPATCH87
(BinAddAssign, CompoundAssignOperator);
80
190
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
81
190
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
82
190
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
190
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
190
      
case BO_OrAssign: 3
DISPATCH3
(BinOrAssign, CompoundAssignOperator);
85
190
      
case BO_XorAssign: 3
DISPATCH3
(BinXorAssign, CompoundAssignOperator);
86
190
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
87
1.18k
      }
88
1.18k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
29
      switch (UnOp->getOpcode()) {
90
29
      
case UO_PostInc: 4
DISPATCH4
(UnaryPostInc, UnaryOperator);
91
29
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
92
29
      
case UO_PreInc: 9
DISPATCH9
(UnaryPreInc, UnaryOperator);
93
29
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
94
29
      
case UO_AddrOf: 16
DISPATCH16
(UnaryAddrOf, UnaryOperator);
95
29
      
case UO_Deref: 0
DISPATCH0
(UnaryDeref, UnaryOperator);
96
29
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
97
29
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
98
29
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
99
29
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
100
29
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
101
29
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
102
29
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
103
29
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
1.15k
      }
105
1.15k
    }
106
1.15k
107
1.15k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
1.15k
    switch (S->getStmtClass()) {
109
1.15k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
1.15k
#define ABSTRACT_STMT(STMT)
111
1.15k
#define STMT(CLASS, PARENT)                              \
112
1.15k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
1.15k
#include 
"clang/AST/StmtNodes.inc"0
114
1.15k
    }
115
1.15k
  }
CodeGenPGO.cpp:clang::StmtVisitorBase<clang::make_const_ptr, (anonymous namespace)::ComputeRegionCounts, void>::Visit(clang::Stmt const*)
Line
Count
Source
46
3.30k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
3.30k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
3.30k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
3.30k
    // below.
50
3.30k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
310
      switch (BinOp->getOpcode()) {
52
310
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
310
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
310
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
55
310
      
case BO_Div: 4
DISPATCH4
(BinDiv, BinaryOperator);
56
310
      
case BO_Rem: 33
DISPATCH33
(BinRem, BinaryOperator);
57
310
      
case BO_Add: 16
DISPATCH16
(BinAdd, BinaryOperator);
58
310
      
case BO_Sub: 10
DISPATCH10
(BinSub, BinaryOperator);
59
310
      
case BO_Shl: 3
DISPATCH3
(BinShl, BinaryOperator);
60
310
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
61
310
62
310
      
case BO_LT: 83
DISPATCH83
(BinLT, BinaryOperator);
63
310
      
case BO_GT: 22
DISPATCH22
(BinGT, BinaryOperator);
64
310
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
65
310
      
case BO_GE: 1
DISPATCH1
(BinGE, BinaryOperator);
66
310
      
case BO_EQ: 5
DISPATCH5
(BinEQ, BinaryOperator);
67
310
      
case BO_NE: 9
DISPATCH9
(BinNE, BinaryOperator);
68
310
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
310
70
310
      
case BO_And: 2
DISPATCH2
(BinAnd, BinaryOperator);
71
310
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
72
310
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
73
310
      
case BO_LAnd: 19
DISPATCH19
(BinLAnd, BinaryOperator);
74
310
      
case BO_LOr : 18
DISPATCH18
(BinLOr, BinaryOperator);
75
310
      
case BO_Assign: 76
DISPATCH76
(BinAssign, BinaryOperator);
76
310
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
77
310
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
78
310
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
310
      
case BO_AddAssign: 9
DISPATCH9
(BinAddAssign, CompoundAssignOperator);
80
310
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
81
310
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
82
310
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
310
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
310
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
310
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
310
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
87
2.99k
      }
88
2.99k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
142
      switch (UnOp->getOpcode()) {
90
142
      
case UO_PostInc: 27
DISPATCH27
(UnaryPostInc, UnaryOperator);
91
142
      
case UO_PostDec: 9
DISPATCH9
(UnaryPostDec, UnaryOperator);
92
142
      
case UO_PreInc: 82
DISPATCH82
(UnaryPreInc, UnaryOperator);
93
142
      
case UO_PreDec: 8
DISPATCH8
(UnaryPreDec, UnaryOperator);
94
142
      
case UO_AddrOf: 0
DISPATCH0
(UnaryAddrOf, UnaryOperator);
95
142
      
case UO_Deref: 9
DISPATCH9
(UnaryDeref, UnaryOperator);
96
142
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
97
142
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
98
142
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
99
142
      
case UO_LNot: 7
DISPATCH7
(UnaryLNot, UnaryOperator);
100
142
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
101
142
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
102
142
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
103
142
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
2.85k
      }
105
2.85k
    }
106
2.85k
107
2.85k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
2.85k
    switch (S->getStmtClass()) {
109
2.85k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
2.85k
#define ABSTRACT_STMT(STMT)
111
2.85k
#define STMT(CLASS, PARENT)                              \
112
2.85k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
2.85k
#include 
"clang/AST/StmtNodes.inc"0
114
2.85k
    }
115
2.85k
  }
CoverageMappingGen.cpp:clang::StmtVisitorBase<clang::make_const_ptr, (anonymous namespace)::CounterCoverageMappingBuilder, void>::Visit(clang::Stmt const*)
Line
Count
Source
46
2.58k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
2.58k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
2.58k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
2.58k
    // below.
50
2.58k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
226
      switch (BinOp->getOpcode()) {
52
226
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
226
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
226
      
case BO_Mul: 3
DISPATCH3
(BinMul, BinaryOperator);
55
226
      
case BO_Div: 1
DISPATCH1
(BinDiv, BinaryOperator);
56
226
      
case BO_Rem: 3
DISPATCH3
(BinRem, BinaryOperator);
57
226
      
case BO_Add: 12
DISPATCH12
(BinAdd, BinaryOperator);
58
226
      
case BO_Sub: 2
DISPATCH2
(BinSub, BinaryOperator);
59
226
      
case BO_Shl: 1
DISPATCH1
(BinShl, BinaryOperator);
60
226
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
61
226
62
226
      
case BO_LT: 43
DISPATCH43
(BinLT, BinaryOperator);
63
226
      
case BO_GT: 4
DISPATCH4
(BinGT, BinaryOperator);
64
226
      
case BO_LE: 1
DISPATCH1
(BinLE, BinaryOperator);
65
226
      
case BO_GE: 2
DISPATCH2
(BinGE, BinaryOperator);
66
226
      
case BO_EQ: 39
DISPATCH39
(BinEQ, BinaryOperator);
67
226
      
case BO_NE: 3
DISPATCH3
(BinNE, BinaryOperator);
68
226
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
226
70
226
      
case BO_And: 2
DISPATCH2
(BinAnd, BinaryOperator);
71
226
      
case BO_Xor: 1
DISPATCH1
(BinXor, BinaryOperator);
72
226
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
73
226
      
case BO_LAnd: 3
DISPATCH3
(BinLAnd, BinaryOperator);
74
226
      
case BO_LOr : 5
DISPATCH5
(BinLOr, BinaryOperator);
75
226
      
case BO_Assign: 98
DISPATCH98
(BinAssign, BinaryOperator);
76
226
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
77
226
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
78
226
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
226
      
case BO_AddAssign: 1
DISPATCH1
(BinAddAssign, CompoundAssignOperator);
80
226
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
81
226
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
82
226
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
226
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
226
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
226
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
226
      
case BO_Comma: 2
DISPATCH2
(BinComma, BinaryOperator);
87
2.36k
      }
88
2.36k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
60
      switch (UnOp->getOpcode()) {
90
60
      
case UO_PostInc: 3
DISPATCH3
(UnaryPostInc, UnaryOperator);
91
60
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
92
60
      
case UO_PreInc: 40
DISPATCH40
(UnaryPreInc, UnaryOperator);
93
60
      
case UO_PreDec: 2
DISPATCH2
(UnaryPreDec, UnaryOperator);
94
60
      
case UO_AddrOf: 0
DISPATCH0
(UnaryAddrOf, UnaryOperator);
95
60
      
case UO_Deref: 4
DISPATCH4
(UnaryDeref, UnaryOperator);
96
60
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
97
60
      
case UO_Minus: 1
DISPATCH1
(UnaryMinus, UnaryOperator);
98
60
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
99
60
      
case UO_LNot: 10
DISPATCH10
(UnaryLNot, UnaryOperator);
100
60
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
101
60
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
102
60
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
103
60
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
2.30k
      }
105
2.30k
    }
106
2.30k
107
2.30k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
2.30k
    switch (S->getStmtClass()) {
109
2.30k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
2.30k
#define ABSTRACT_STMT(STMT)
111
2.30k
#define STMT(CLASS, PARENT)                              \
112
2.30k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
2.30k
#include 
"clang/AST/StmtNodes.inc"0
114
2.30k
    }
115
2.30k
  }
TransEmptyStatementsAndDealloc.cpp:clang::StmtVisitorBase<clang::make_ptr, (anonymous namespace)::EmptyChecker, bool>::Visit(clang::Stmt*)
Line
Count
Source
46
1.07k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
1.07k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
1.07k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
1.07k
    // below.
50
1.07k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
67
      switch (BinOp->getOpcode()) {
52
67
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
67
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
67
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
55
67
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
56
67
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
57
67
      
case BO_Add: 0
DISPATCH0
(BinAdd, BinaryOperator);
58
67
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
59
67
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
60
67
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
61
67
62
67
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
63
67
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
64
67
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
65
67
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
66
67
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
67
67
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
68
67
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
67
70
67
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
71
67
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
72
67
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
73
67
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
74
67
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
75
67
      
case BO_Assign: 64
DISPATCH64
(BinAssign, BinaryOperator);
76
67
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
77
67
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
78
67
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
67
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
80
67
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
81
67
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
82
67
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
67
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
67
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
67
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
67
      
case BO_Comma: 3
DISPATCH3
(BinComma, BinaryOperator);
87
1.01k
      }
88
1.01k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
12
      switch (UnOp->getOpcode()) {
90
12
      
case UO_PostInc: 2
DISPATCH2
(UnaryPostInc, UnaryOperator);
91
12
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
92
12
      
case UO_PreInc: 10
DISPATCH10
(UnaryPreInc, UnaryOperator);
93
12
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
94
12
      
case UO_AddrOf: 0
DISPATCH0
(UnaryAddrOf, UnaryOperator);
95
12
      
case UO_Deref: 0
DISPATCH0
(UnaryDeref, UnaryOperator);
96
12
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
97
12
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
98
12
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
99
12
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
100
12
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
101
12
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
102
12
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
103
12
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
1.00k
      }
105
1.00k
    }
106
1.00k
107
1.00k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
1.00k
    switch (S->getStmtClass()) {
109
1.00k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
1.00k
#define ABSTRACT_STMT(STMT)
111
1.00k
#define STMT(CLASS, PARENT)                              \
112
1.00k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
1.00k
#include 
"clang/AST/StmtNodes.inc"0
114
1.00k
    }
115
1.00k
  }
CStringSyntaxChecker.cpp:clang::StmtVisitorBase<clang::make_ptr, (anonymous namespace)::WalkAST, void>::Visit(clang::Stmt*)
Line
Count
Source
46
37.3k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
37.3k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
37.3k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
37.3k
    // below.
50
37.3k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
2.03k
      switch (BinOp->getOpcode()) {
52
2.03k
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
2.03k
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
2.03k
      
case BO_Mul: 116
DISPATCH116
(BinMul, BinaryOperator);
55
2.03k
      
case BO_Div: 26
DISPATCH26
(BinDiv, BinaryOperator);
56
2.03k
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
57
2.03k
      
case BO_Add: 218
DISPATCH218
(BinAdd, BinaryOperator);
58
2.03k
      
case BO_Sub: 50
DISPATCH50
(BinSub, BinaryOperator);
59
2.03k
      
case BO_Shl: 2
DISPATCH2
(BinShl, BinaryOperator);
60
2.03k
      
case BO_Shr: 2
DISPATCH2
(BinShr, BinaryOperator);
61
2.03k
62
2.03k
      
case BO_LT: 169
DISPATCH169
(BinLT, BinaryOperator);
63
2.03k
      
case BO_GT: 102
DISPATCH102
(BinGT, BinaryOperator);
64
2.03k
      
case BO_LE: 43
DISPATCH43
(BinLE, BinaryOperator);
65
2.03k
      
case BO_GE: 103
DISPATCH103
(BinGE, BinaryOperator);
66
2.03k
      
case BO_EQ: 921
DISPATCH921
(BinEQ, BinaryOperator);
67
2.03k
      
case BO_NE: 86
DISPATCH86
(BinNE, BinaryOperator);
68
2.03k
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
2.03k
70
2.03k
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
71
2.03k
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
72
2.03k
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
73
2.03k
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
74
2.03k
      
case BO_LOr : 1
DISPATCH1
(BinLOr, BinaryOperator);
75
2.03k
      
case BO_Assign: 173
DISPATCH173
(BinAssign, BinaryOperator);
76
2.03k
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
77
2.03k
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
78
2.03k
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
2.03k
      
case BO_AddAssign: 13
DISPATCH13
(BinAddAssign, CompoundAssignOperator);
80
2.03k
      
case BO_SubAssign: 5
DISPATCH5
(BinSubAssign, CompoundAssignOperator);
81
2.03k
      
case BO_ShlAssign: 4
DISPATCH4
(BinShlAssign, CompoundAssignOperator);
82
2.03k
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
2.03k
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
2.03k
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
2.03k
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
2.03k
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
87
35.2k
      }
88
35.2k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
533
      switch (UnOp->getOpcode()) {
90
533
      
case UO_PostInc: 38
DISPATCH38
(UnaryPostInc, UnaryOperator);
91
533
      
case UO_PostDec: 6
DISPATCH6
(UnaryPostDec, UnaryOperator);
92
533
      
case UO_PreInc: 0
DISPATCH0
(UnaryPreInc, UnaryOperator);
93
533
      
case UO_PreDec: 1
DISPATCH1
(UnaryPreDec, UnaryOperator);
94
533
      
case UO_AddrOf: 202
DISPATCH202
(UnaryAddrOf, UnaryOperator);
95
533
      
case UO_Deref: 43
DISPATCH43
(UnaryDeref, UnaryOperator);
96
533
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
97
533
      
case UO_Minus: 231
DISPATCH231
(UnaryMinus, UnaryOperator);
98
533
      
case UO_Not: 4
DISPATCH4
(UnaryNot, UnaryOperator);
99
533
      
case UO_LNot: 8
DISPATCH8
(UnaryLNot, UnaryOperator);
100
533
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
101
533
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
102
533
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
103
533
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
34.7k
      }
105
34.7k
    }
106
34.7k
107
34.7k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
34.7k
    switch (S->getStmtClass()) {
109
34.7k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
34.7k
#define ABSTRACT_STMT(STMT)
111
34.7k
#define STMT(CLASS, PARENT)                              \
112
34.7k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
34.7k
#include 
"clang/AST/StmtNodes.inc"0
114
34.7k
    }
115
34.7k
  }
CheckSecuritySyntaxOnly.cpp:clang::StmtVisitorBase<clang::make_ptr, (anonymous namespace)::WalkAST, void>::Visit(clang::Stmt*)
Line
Count
Source
46
3.30k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
3.30k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
3.30k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
3.30k
    // below.
50
3.30k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
140
      switch (BinOp->getOpcode()) {
52
140
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
140
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
140
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
55
140
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
56
140
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
57
140
      
case BO_Add: 8
DISPATCH8
(BinAdd, BinaryOperator);
58
140
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
59
140
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
60
140
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
61
140
62
140
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
63
140
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
64
140
      
case BO_LE: 56
DISPATCH56
(BinLE, BinaryOperator);
65
140
      
case BO_GE: 8
DISPATCH8
(BinGE, BinaryOperator);
66
140
      
case BO_EQ: 6
DISPATCH6
(BinEQ, BinaryOperator);
67
140
      
case BO_NE: 10
DISPATCH10
(BinNE, BinaryOperator);
68
140
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
140
70
140
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
71
140
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
72
140
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
73
140
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
74
140
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
75
140
      
case BO_Assign: 28
DISPATCH28
(BinAssign, BinaryOperator);
76
140
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
77
140
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
78
140
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
140
      
case BO_AddAssign: 16
DISPATCH16
(BinAddAssign, CompoundAssignOperator);
80
140
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
81
140
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
82
140
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
140
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
140
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
140
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
140
      
case BO_Comma: 8
DISPATCH8
(BinComma, BinaryOperator);
87
3.16k
      }
88
3.16k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
77
      switch (UnOp->getOpcode()) {
90
77
      
case UO_PostInc: 40
DISPATCH40
(UnaryPostInc, UnaryOperator);
91
77
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
92
77
      
case UO_PreInc: 8
DISPATCH8
(UnaryPreInc, UnaryOperator);
93
77
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
94
77
      
case UO_AddrOf: 9
DISPATCH9
(UnaryAddrOf, UnaryOperator);
95
77
      
case UO_Deref: 4
DISPATCH4
(UnaryDeref, UnaryOperator);
96
77
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
97
77
      
case UO_Minus: 16
DISPATCH16
(UnaryMinus, UnaryOperator);
98
77
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
99
77
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
100
77
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
101
77
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
102
77
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
103
77
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
3.09k
      }
105
3.09k
    }
106
3.09k
107
3.09k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
3.09k
    switch (S->getStmtClass()) {
109
3.09k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
3.09k
#define ABSTRACT_STMT(STMT)
111
3.09k
#define STMT(CLASS, PARENT)                              \
112
3.09k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
3.09k
#include 
"clang/AST/StmtNodes.inc"0
114
3.09k
    }
115
3.09k
  }
CheckSizeofPointer.cpp:clang::StmtVisitorBase<clang::make_ptr, (anonymous namespace)::WalkAST, void>::Visit(clang::Stmt*)
Line
Count
Source
46
19.3k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
19.3k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
19.3k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
19.3k
    // below.
50
19.3k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
1.19k
      switch (BinOp->getOpcode()) {
52
1.19k
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
1.19k
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
1.19k
      
case BO_Mul: 1
DISPATCH1
(BinMul, BinaryOperator);
55
1.19k
      
case BO_Div: 15
DISPATCH15
(BinDiv, BinaryOperator);
56
1.19k
      
case BO_Rem: 6
DISPATCH6
(BinRem, BinaryOperator);
57
1.19k
      
case BO_Add: 44
DISPATCH44
(BinAdd, BinaryOperator);
58
1.19k
      
case BO_Sub: 20
DISPATCH20
(BinSub, BinaryOperator);
59
1.19k
      
case BO_Shl: 14
DISPATCH14
(BinShl, BinaryOperator);
60
1.19k
      
case BO_Shr: 2
DISPATCH2
(BinShr, BinaryOperator);
61
1.19k
62
1.19k
      
case BO_LT: 47
DISPATCH47
(BinLT, BinaryOperator);
63
1.19k
      
case BO_GT: 14
DISPATCH14
(BinGT, BinaryOperator);
64
1.19k
      
case BO_LE: 2
DISPATCH2
(BinLE, BinaryOperator);
65
1.19k
      
case BO_GE: 3
DISPATCH3
(BinGE, BinaryOperator);
66
1.19k
      
case BO_EQ: 344
DISPATCH344
(BinEQ, BinaryOperator);
67
1.19k
      
case BO_NE: 99
DISPATCH99
(BinNE, BinaryOperator);
68
1.19k
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
1.19k
70
1.19k
      
case BO_And: 10
DISPATCH10
(BinAnd, BinaryOperator);
71
1.19k
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
72
1.19k
      
case BO_Or : 5
DISPATCH5
(BinOr, BinaryOperator);
73
1.19k
      
case BO_LAnd: 31
DISPATCH31
(BinLAnd, BinaryOperator);
74
1.19k
      
case BO_LOr : 8
DISPATCH8
(BinLOr, BinaryOperator);
75
1.19k
      
case BO_Assign: 480
DISPATCH480
(BinAssign, BinaryOperator);
76
1.19k
      
case BO_MulAssign: 8
DISPATCH8
(BinMulAssign, CompoundAssignOperator);
77
1.19k
      
case BO_DivAssign: 12
DISPATCH12
(BinDivAssign, CompoundAssignOperator);
78
1.19k
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
1.19k
      
case BO_AddAssign: 11
DISPATCH11
(BinAddAssign, CompoundAssignOperator);
80
1.19k
      
case BO_SubAssign: 2
DISPATCH2
(BinSubAssign, CompoundAssignOperator);
81
1.19k
      
case BO_ShlAssign: 2
DISPATCH2
(BinShlAssign, CompoundAssignOperator);
82
1.19k
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
1.19k
      
case BO_AndAssign: 6
DISPATCH6
(BinAndAssign, CompoundAssignOperator);
84
1.19k
      
case BO_OrAssign: 3
DISPATCH3
(BinOrAssign, CompoundAssignOperator);
85
1.19k
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
1.19k
      
case BO_Comma: 7
DISPATCH7
(BinComma, BinaryOperator);
87
18.1k
      }
88
18.1k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
768
      switch (UnOp->getOpcode()) {
90
768
      
case UO_PostInc: 44
DISPATCH44
(UnaryPostInc, UnaryOperator);
91
768
      
case UO_PostDec: 7
DISPATCH7
(UnaryPostDec, UnaryOperator);
92
768
      
case UO_PreInc: 36
DISPATCH36
(UnaryPreInc, UnaryOperator);
93
768
      
case UO_PreDec: 4
DISPATCH4
(UnaryPreDec, UnaryOperator);
94
768
      
case UO_AddrOf: 180
DISPATCH180
(UnaryAddrOf, UnaryOperator);
95
768
      
case UO_Deref: 310
DISPATCH310
(UnaryDeref, UnaryOperator);
96
768
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
97
768
      
case UO_Minus: 18
DISPATCH18
(UnaryMinus, UnaryOperator);
98
768
      
case UO_Not: 10
DISPATCH10
(UnaryNot, UnaryOperator);
99
768
      
case UO_LNot: 145
DISPATCH145
(UnaryLNot, UnaryOperator);
100
768
      
case UO_Real: 6
DISPATCH6
(UnaryReal, UnaryOperator);
101
768
      
case UO_Imag: 4
DISPATCH4
(UnaryImag, UnaryOperator);
102
768
      
case UO_Extension: 4
DISPATCH4
(UnaryExtension, UnaryOperator);
103
768
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
17.4k
      }
105
17.4k
    }
106
17.4k
107
17.4k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
17.4k
    switch (S->getStmtClass()) {
109
17.4k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
17.4k
#define ABSTRACT_STMT(STMT)
111
17.4k
#define STMT(CLASS, PARENT)                              \
112
17.4k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
17.4k
#include 
"clang/AST/StmtNodes.inc"0
114
17.4k
    }
115
17.4k
  }
DirectIvarAssignment.cpp:clang::StmtVisitorBase<clang::make_const_ptr, (anonymous namespace)::DirectIvarAssignment::MethodCrawler, void>::Visit(clang::Stmt const*)
Line
Count
Source
46
19
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
19
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
19
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
19
    // below.
50
19
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
14
      switch (BinOp->getOpcode()) {
52
14
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
14
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
14
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
55
14
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
56
14
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
57
14
      
case BO_Add: 0
DISPATCH0
(BinAdd, BinaryOperator);
58
14
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
59
14
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
60
14
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
61
14
62
14
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
63
14
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
64
14
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
65
14
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
66
14
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
67
14
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
68
14
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
14
70
14
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
71
14
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
72
14
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
73
14
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
74
14
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
75
14
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
76
14
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
77
14
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
78
14
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
14
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
80
14
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
81
14
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
82
14
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
14
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
14
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
14
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
14
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
87
5
      }
88
5
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
0
      switch (UnOp->getOpcode()) {
90
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
91
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
92
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
93
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
94
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
95
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
96
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
97
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
98
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
99
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
100
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
101
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
102
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
103
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
104
5
      }
105
5
    }
106
5
107
5
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
5
    switch (S->getStmtClass()) {
109
5
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
5
#define ABSTRACT_STMT(STMT)
111
5
#define STMT(CLASS, PARENT)                              \
112
5
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
5
#include 
"clang/AST/StmtNodes.inc"0
114
5
    }
115
5
  }
IvarInvalidationChecker.cpp:clang::StmtVisitorBase<clang::make_const_ptr, (anonymous namespace)::IvarInvalidationCheckerImpl::MethodCrawler, void>::Visit(clang::Stmt const*)
Line
Count
Source
46
408
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
408
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
408
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
408
    // below.
50
408
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
19
      switch (BinOp->getOpcode()) {
52
19
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
19
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
19
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
55
19
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
56
19
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
57
19
      
case BO_Add: 0
DISPATCH0
(BinAdd, BinaryOperator);
58
19
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
59
19
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
60
19
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
61
19
62
19
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
63
19
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
64
19
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
65
19
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
66
19
      
case BO_EQ: 3
DISPATCH3
(BinEQ, BinaryOperator);
67
19
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
68
19
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
19
70
19
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
71
19
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
72
19
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
73
19
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
74
19
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
75
19
      
case BO_Assign: 16
DISPATCH16
(BinAssign, BinaryOperator);
76
19
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
77
19
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
78
19
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
19
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
80
19
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
81
19
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
82
19
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
19
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
19
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
19
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
19
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
87
389
      }
88
389
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
1
      switch (UnOp->getOpcode()) {
90
1
      
case UO_PostInc: 0
DISPATCH0
(UnaryPostInc, UnaryOperator);
91
1
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
92
1
      
case UO_PreInc: 0
DISPATCH0
(UnaryPreInc, UnaryOperator);
93
1
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
94
1
      
case UO_AddrOf: 0
DISPATCH0
(UnaryAddrOf, UnaryOperator);
95
1
      
case UO_Deref: 0
DISPATCH0
(UnaryDeref, UnaryOperator);
96
1
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
97
1
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
98
1
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
99
1
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
100
1
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
101
1
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
102
1
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
103
1
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
388
      }
105
388
    }
106
388
107
388
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
388
    switch (S->getStmtClass()) {
109
388
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
388
#define ABSTRACT_STMT(STMT)
111
388
#define STMT(CLASS, PARENT)                              \
112
388
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
388
#include 
"clang/AST/StmtNodes.inc"0
114
388
    }
115
388
  }
Unexecuted instantiation: LLVMConventionsChecker.cpp:clang::StmtVisitorBase<clang::make_ptr, (anonymous namespace)::StringRefCheckerVisitor, void>::Visit(clang::Stmt*)
LocalizationChecker.cpp:clang::StmtVisitorBase<clang::make_const_ptr, (anonymous namespace)::EmptyLocalizationContextChecker::MethodCrawler, void>::Visit(clang::Stmt const*)
Line
Count
Source
46
171
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
171
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
171
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
171
    // below.
50
171
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
4
      switch (BinOp->getOpcode()) {
52
4
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
4
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
4
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
55
4
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
56
4
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
57
4
      
case BO_Add: 0
DISPATCH0
(BinAdd, BinaryOperator);
58
4
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
59
4
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
60
4
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
61
4
62
4
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
63
4
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
64
4
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
65
4
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
66
4
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
67
4
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
68
4
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
4
70
4
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
71
4
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
72
4
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
73
4
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
74
4
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
75
4
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
76
4
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
77
4
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
78
4
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
4
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
80
4
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
81
4
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
82
4
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
4
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
4
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
4
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
4
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
87
167
      }
88
167
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
0
      switch (UnOp->getOpcode()) {
90
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
91
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
92
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
93
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
94
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
95
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
96
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
97
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
98
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
99
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
100
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
101
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
102
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
103
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
104
167
      }
105
167
    }
106
167
107
167
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
167
    switch (S->getStmtClass()) {
109
167
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
167
#define ABSTRACT_STMT(STMT)
111
167
#define STMT(CLASS, PARENT)                              \
112
167
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
167
#include 
"clang/AST/StmtNodes.inc"0
114
167
    }
115
167
  }
MallocOverflowSecurityChecker.cpp:clang::StmtVisitorBase<clang::make_ptr, (anonymous namespace)::CheckOverflowOps, void>::Visit(clang::Stmt*)
Line
Count
Source
46
445
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
445
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
445
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
445
    // below.
50
445
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
52
      switch (BinOp->getOpcode()) {
52
52
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
52
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
52
      
case BO_Mul: 21
DISPATCH21
(BinMul, BinaryOperator);
55
52
      
case BO_Div: 4
DISPATCH4
(BinDiv, BinaryOperator);
56
52
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
57
52
      
case BO_Add: 5
DISPATCH5
(BinAdd, BinaryOperator);
58
52
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
59
52
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
60
52
      
case BO_Shr: 2
DISPATCH2
(BinShr, BinaryOperator);
61
52
62
52
      
case BO_LT: 2
DISPATCH2
(BinLT, BinaryOperator);
63
52
      
case BO_GT: 3
DISPATCH3
(BinGT, BinaryOperator);
64
52
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
65
52
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
66
52
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
67
52
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
68
52
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
52
70
52
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
71
52
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
72
52
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
73
52
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
74
52
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
75
52
      
case BO_Assign: 15
DISPATCH15
(BinAssign, BinaryOperator);
76
52
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
77
52
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
78
52
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
52
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
80
52
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
81
52
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
82
52
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
52
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
52
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
52
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
52
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
87
393
      }
88
393
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
3
      switch (UnOp->getOpcode()) {
90
3
      
case UO_PostInc: 2
DISPATCH2
(UnaryPostInc, UnaryOperator);
91
3
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
92
3
      
case UO_PreInc: 0
DISPATCH0
(UnaryPreInc, UnaryOperator);
93
3
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
94
3
      
case UO_AddrOf: 0
DISPATCH0
(UnaryAddrOf, UnaryOperator);
95
3
      
case UO_Deref: 1
DISPATCH1
(UnaryDeref, UnaryOperator);
96
3
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
97
3
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
98
3
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
99
3
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
100
3
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
101
3
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
102
3
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
103
3
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
390
      }
105
390
    }
106
390
107
390
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
390
    switch (S->getStmtClass()) {
109
390
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
390
#define ABSTRACT_STMT(STMT)
111
390
#define STMT(CLASS, PARENT)                              \
112
390
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
390
#include 
"clang/AST/StmtNodes.inc"0
114
390
    }
115
390
  }
MallocSizeofChecker.cpp:clang::StmtVisitorBase<clang::make_const_ptr, (anonymous namespace)::CastedAllocFinder, std::__1::pair<clang::TypeSourceInfo const*, clang::CallExpr const*> >::Visit(clang::Stmt const*)
Line
Count
Source
46
2.40k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
2.40k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
2.40k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
2.40k
    // below.
50
2.40k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
178
      switch (BinOp->getOpcode()) {
52
178
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
178
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
178
      
case BO_Mul: 19
DISPATCH19
(BinMul, BinaryOperator);
55
178
      
case BO_Div: 12
DISPATCH12
(BinDiv, BinaryOperator);
56
178
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
57
178
      
case BO_Add: 29
DISPATCH29
(BinAdd, BinaryOperator);
58
178
      
case BO_Sub: 4
DISPATCH4
(BinSub, BinaryOperator);
59
178
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
60
178
      
case BO_Shr: 2
DISPATCH2
(BinShr, BinaryOperator);
61
178
62
178
      
case BO_LT: 9
DISPATCH9
(BinLT, BinaryOperator);
63
178
      
case BO_GT: 1
DISPATCH1
(BinGT, BinaryOperator);
64
178
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
65
178
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
66
178
      
case BO_EQ: 11
DISPATCH11
(BinEQ, BinaryOperator);
67
178
      
case BO_NE: 1
DISPATCH1
(BinNE, BinaryOperator);
68
178
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
178
70
178
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
71
178
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
72
178
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
73
178
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
74
178
      
case BO_LOr : 1
DISPATCH1
(BinLOr, BinaryOperator);
75
178
      
case BO_Assign: 80
DISPATCH80
(BinAssign, BinaryOperator);
76
178
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
77
178
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
78
178
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
178
      
case BO_AddAssign: 4
DISPATCH4
(BinAddAssign, CompoundAssignOperator);
80
178
      
case BO_SubAssign: 5
DISPATCH5
(BinSubAssign, CompoundAssignOperator);
81
178
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
82
178
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
178
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
178
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
178
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
178
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
87
2.22k
      }
88
2.22k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
77
      switch (UnOp->getOpcode()) {
90
77
      
case UO_PostInc: 38
DISPATCH38
(UnaryPostInc, UnaryOperator);
91
77
      
case UO_PostDec: 6
DISPATCH6
(UnaryPostDec, UnaryOperator);
92
77
      
case UO_PreInc: 0
DISPATCH0
(UnaryPreInc, UnaryOperator);
93
77
      
case UO_PreDec: 1
DISPATCH1
(UnaryPreDec, UnaryOperator);
94
77
      
case UO_AddrOf: 3
DISPATCH3
(UnaryAddrOf, UnaryOperator);
95
77
      
case UO_Deref: 22
DISPATCH22
(UnaryDeref, UnaryOperator);
96
77
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
97
77
      
case UO_Minus: 5
DISPATCH5
(UnaryMinus, UnaryOperator);
98
77
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
99
77
      
case UO_LNot: 2
DISPATCH2
(UnaryLNot, UnaryOperator);
100
77
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
101
77
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
102
77
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
103
77
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
2.14k
      }
105
2.14k
    }
106
2.14k
107
2.14k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
2.14k
    switch (S->getStmtClass()) {
109
2.14k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
2.14k
#define ABSTRACT_STMT(STMT)
111
2.14k
#define STMT(CLASS, PARENT)                              \
112
2.14k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
2.14k
#include 
"clang/AST/StmtNodes.inc"0
114
2.14k
    }
115
2.14k
  }
MallocSizeofChecker.cpp:clang::StmtVisitorBase<clang::make_const_ptr, (anonymous namespace)::SizeofFinder, void>::Visit(clang::Stmt const*)
Line
Count
Source
46
109
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
109
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
109
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
109
    // below.
50
109
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
12
      switch (BinOp->getOpcode()) {
52
12
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
12
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
12
      
case BO_Mul: 10
DISPATCH10
(BinMul, BinaryOperator);
55
12
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
56
12
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
57
12
      
case BO_Add: 2
DISPATCH2
(BinAdd, BinaryOperator);
58
12
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
59
12
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
60
12
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
61
12
62
12
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
63
12
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
64
12
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
65
12
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
66
12
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
67
12
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
68
12
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
12
70
12
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
71
12
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
72
12
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
73
12
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
74
12
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
75
12
      
case BO_Assign: 0
DISPATCH0
(BinAssign, BinaryOperator);
76
12
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
77
12
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
78
12
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
12
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
80
12
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
81
12
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
82
12
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
12
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
12
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
12
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
12
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
87
97
      }
88
97
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
0
      switch (UnOp->getOpcode()) {
90
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
91
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
92
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
93
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
94
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
95
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
96
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
97
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
98
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
99
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
100
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
101
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
102
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
103
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
104
97
      }
105
97
    }
106
97
107
97
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
97
    switch (S->getStmtClass()) {
109
97
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
97
#define ABSTRACT_STMT(STMT)
111
97
#define STMT(CLASS, PARENT)                              \
112
97
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
97
#include 
"clang/AST/StmtNodes.inc"0
114
97
    }
115
97
  }
ObjCContainersASTChecker.cpp:clang::StmtVisitorBase<clang::make_ptr, (anonymous namespace)::WalkAST, void>::Visit(clang::Stmt*)
Line
Count
Source
46
1.36k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
1.36k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
1.36k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
1.36k
    // below.
50
1.36k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
83
      switch (BinOp->getOpcode()) {
52
83
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
83
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
83
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
55
83
      
case BO_Div: 19
DISPATCH19
(BinDiv, BinaryOperator);
56
83
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
57
83
      
case BO_Add: 8
DISPATCH8
(BinAdd, BinaryOperator);
58
83
      
case BO_Sub: 1
DISPATCH1
(BinSub, BinaryOperator);
59
83
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
60
83
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
61
83
62
83
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
63
83
      
case BO_GT: 1
DISPATCH1
(BinGT, BinaryOperator);
64
83
      
case BO_LE: 1
DISPATCH1
(BinLE, BinaryOperator);
65
83
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
66
83
      
case BO_EQ: 7
DISPATCH7
(BinEQ, BinaryOperator);
67
83
      
case BO_NE: 3
DISPATCH3
(BinNE, BinaryOperator);
68
83
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
83
70
83
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
71
83
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
72
83
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
73
83
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
74
83
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
75
83
      
case BO_Assign: 42
DISPATCH42
(BinAssign, BinaryOperator);
76
83
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
77
83
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
78
83
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
83
      
case BO_AddAssign: 1
DISPATCH1
(BinAddAssign, CompoundAssignOperator);
80
83
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
81
83
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
82
83
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
83
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
83
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
83
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
83
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
87
1.27k
      }
88
1.27k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
38
      switch (UnOp->getOpcode()) {
90
38
      
case UO_PostInc: 0
DISPATCH0
(UnaryPostInc, UnaryOperator);
91
38
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
92
38
      
case UO_PreInc: 0
DISPATCH0
(UnaryPreInc, UnaryOperator);
93
38
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
94
38
      
case UO_AddrOf: 24
DISPATCH24
(UnaryAddrOf, UnaryOperator);
95
38
      
case UO_Deref: 14
DISPATCH14
(UnaryDeref, UnaryOperator);
96
38
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
97
38
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
98
38
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
99
38
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
100
38
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
101
38
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
102
38
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
103
38
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
1.24k
      }
105
1.24k
    }
106
1.24k
107
1.24k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
1.24k
    switch (S->getStmtClass()) {
109
1.24k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
1.24k
#define ABSTRACT_STMT(STMT)
111
1.24k
#define STMT(CLASS, PARENT)                              \
112
1.24k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
1.24k
#include 
"clang/AST/StmtNodes.inc"0
114
1.24k
    }
115
1.24k
  }
clang::StmtVisitorBase<clang::make_ptr, clang::ASTStmtReader, void>::Visit(clang::Stmt*)
Line
Count
Source
46
534k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
534k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
534k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
534k
    // below.
50
534k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
106k
      switch (BinOp->getOpcode()) {
52
106k
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
106k
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
106k
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
55
106k
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
56
106k
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
57
106k
      
case BO_Add: 0
DISPATCH0
(BinAdd, BinaryOperator);
58
106k
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
59
106k
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
60
106k
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
61
106k
62
106k
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
63
106k
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
64
106k
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
65
106k
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
66
106k
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
67
106k
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
68
106k
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
106k
70
106k
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
71
106k
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
72
106k
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
73
106k
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
74
106k
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
75
106k
      
case BO_Assign: 0
DISPATCH0
(BinAssign, BinaryOperator);
76
106k
      
case BO_MulAssign: 4.24k
DISPATCH4.24k
(BinMulAssign, CompoundAssignOperator);
77
106k
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
78
106k
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
106k
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
80
106k
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
81
106k
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
82
106k
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
106k
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
106k
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
106k
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
106k
      
case BO_Comma: 102k
DISPATCH102k
(BinComma, BinaryOperator);
87
428k
      }
88
428k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
9.89k
      switch (UnOp->getOpcode()) {
90
9.89k
      
case UO_PostInc: 0
DISPATCH0
(UnaryPostInc, UnaryOperator);
91
9.89k
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
92
9.89k
      
case UO_PreInc: 0
DISPATCH0
(UnaryPreInc, UnaryOperator);
93
9.89k
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
94
9.89k
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
95
9.89k
      
case UO_Deref: 0
DISPATCH0
(UnaryDeref, UnaryOperator);
96
9.89k
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
97
9.89k
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
98
9.89k
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
99
9.89k
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
100
9.89k
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
101
9.89k
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
102
9.89k
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
103
9.89k
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
418k
      }
105
418k
    }
106
418k
107
418k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
418k
    switch (S->getStmtClass()) {
109
418k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
418k
#define ABSTRACT_STMT(STMT)
111
418k
#define STMT(CLASS, PARENT)                              \
112
418k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
418k
#include 
"clang/AST/StmtNodes.inc"2
114
418k
    }
115
418k
  }
clang::StmtVisitorBase<clang::make_ptr, clang::ASTStmtWriter, void>::Visit(clang::Stmt*)
Line
Count
Source
46
892k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
892k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
892k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
892k
    // below.
50
892k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
114k
      switch (BinOp->getOpcode()) {
52
114k
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
114k
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
114k
      
case BO_Mul: 6.64k
DISPATCH6.64k
(BinMul, BinaryOperator);
55
114k
      
case BO_Div: 6.15k
DISPATCH6.15k
(BinDiv, BinaryOperator);
56
114k
      
case BO_Rem: 155
DISPATCH155
(BinRem, BinaryOperator);
57
114k
      
case BO_Add: 26.5k
DISPATCH26.5k
(BinAdd, BinaryOperator);
58
114k
      
case BO_Sub: 16.9k
DISPATCH16.9k
(BinSub, BinaryOperator);
59
114k
      
case BO_Shl: 31
DISPATCH31
(BinShl, BinaryOperator);
60
114k
      
case BO_Shr: 56
DISPATCH56
(BinShr, BinaryOperator);
61
114k
62
114k
      
case BO_LT: 7.37k
DISPATCH7.37k
(BinLT, BinaryOperator);
63
114k
      
case BO_GT: 4.94k
DISPATCH4.94k
(BinGT, BinaryOperator);
64
114k
      
case BO_LE: 3.42k
DISPATCH3.42k
(BinLE, BinaryOperator);
65
114k
      
case BO_GE: 208
DISPATCH208
(BinGE, BinaryOperator);
66
114k
      
case BO_EQ: 145
DISPATCH145
(BinEQ, BinaryOperator);
67
114k
      
case BO_NE: 25
DISPATCH25
(BinNE, BinaryOperator);
68
114k
      
case BO_Cmp: 2
DISPATCH2
(BinCmp, BinaryOperator);
69
114k
70
114k
      
case BO_And: 346
DISPATCH346
(BinAnd, BinaryOperator);
71
114k
      
case BO_Xor: 116
DISPATCH116
(BinXor, BinaryOperator);
72
114k
      
case BO_Or : 287
DISPATCH287
(BinOr, BinaryOperator);
73
114k
      
case BO_LAnd: 213
DISPATCH213
(BinLAnd, BinaryOperator);
74
114k
      
case BO_LOr : 10
DISPATCH10
(BinLOr, BinaryOperator);
75
114k
      
case BO_Assign: 37.0k
DISPATCH37.0k
(BinAssign, BinaryOperator);
76
114k
      
case BO_MulAssign: 58
DISPATCH58
(BinMulAssign, CompoundAssignOperator);
77
114k
      
case BO_DivAssign: 54
DISPATCH54
(BinDivAssign, CompoundAssignOperator);
78
114k
      
case BO_RemAssign: 4
DISPATCH4
(BinRemAssign, CompoundAssignOperator);
79
114k
      
case BO_AddAssign: 4.04k
DISPATCH4.04k
(BinAddAssign, CompoundAssignOperator);
80
114k
      
case BO_SubAssign: 116
DISPATCH116
(BinSubAssign, CompoundAssignOperator);
81
114k
      
case BO_ShlAssign: 4
DISPATCH4
(BinShlAssign, CompoundAssignOperator);
82
114k
      
case BO_ShrAssign: 4
DISPATCH4
(BinShrAssign, CompoundAssignOperator);
83
114k
      
case BO_AndAssign: 4
DISPATCH4
(BinAndAssign, CompoundAssignOperator);
84
114k
      
case BO_OrAssign: 8
DISPATCH8
(BinOrAssign, CompoundAssignOperator);
85
114k
      
case BO_XorAssign: 8
DISPATCH8
(BinXorAssign, CompoundAssignOperator);
86
114k
      
case BO_Comma: 74
DISPATCH74
(BinComma, BinaryOperator);
87
777k
      }
88
777k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
13.1k
      switch (UnOp->getOpcode()) {
90
13.1k
      
case UO_PostInc: 1.79k
DISPATCH1.79k
(UnaryPostInc, UnaryOperator);
91
13.1k
      
case UO_PostDec: 40
DISPATCH40
(UnaryPostDec, UnaryOperator);
92
13.1k
      
case UO_PreInc: 4.25k
DISPATCH4.25k
(UnaryPreInc, UnaryOperator);
93
13.1k
      
case UO_PreDec: 46
DISPATCH46
(UnaryPreDec, UnaryOperator);
94
13.1k
      
case UO_AddrOf: 516
DISPATCH516
(UnaryAddrOf, UnaryOperator);
95
13.1k
      
case UO_Deref: 3.53k
DISPATCH3.53k
(UnaryDeref, UnaryOperator);
96
13.1k
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
97
13.1k
      
case UO_Minus: 2.48k
DISPATCH2.48k
(UnaryMinus, UnaryOperator);
98
13.1k
      
case UO_Not: 202
DISPATCH202
(UnaryNot, UnaryOperator);
99
13.1k
      
case UO_LNot: 20
DISPATCH20
(UnaryLNot, UnaryOperator);
100
13.1k
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
101
13.1k
      
case UO_Imag: 2
DISPATCH2
(UnaryImag, UnaryOperator);
102
13.1k
      
case UO_Extension: 269
DISPATCH269
(UnaryExtension, UnaryOperator);
103
13.1k
      
case UO_Coawait: 5
DISPATCH5
(UnaryCoawait, UnaryOperator);
104
763k
      }
105
763k
    }
106
763k
107
763k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
763k
    switch (S->getStmtClass()) {
109
763k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
763k
#define ABSTRACT_STMT(STMT)
111
763k
#define STMT(CLASS, PARENT)                              \
112
763k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
763k
#include 
"clang/AST/StmtNodes.inc"36
114
763k
    }
115
763k
  }
AnalysisBasedWarnings.cpp:clang::StmtVisitorBase<clang::make_const_ptr, (anonymous namespace)::ContainsReference, void>::Visit(clang::Stmt const*)
Line
Count
Source
46
401
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
401
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
401
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
401
    // below.
50
401
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
30
      switch (BinOp->getOpcode()) {
52
30
      
case BO_PtrMemD: 1
DISPATCH1
(BinPtrMemD, BinaryOperator);
53
30
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
30
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
55
30
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
56
30
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
57
30
      
case BO_Add: 10
DISPATCH10
(BinAdd, BinaryOperator);
58
30
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
59
30
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
60
30
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
61
30
62
30
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
63
30
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
64
30
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
65
30
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
66
30
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
67
30
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
68
30
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
30
70
30
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
71
30
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
72
30
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
73
30
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
74
30
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
75
30
      
case BO_Assign: 0
DISPATCH0
(BinAssign, BinaryOperator);
76
30
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
77
30
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
78
30
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
30
      
case BO_AddAssign: 6
DISPATCH6
(BinAddAssign, CompoundAssignOperator);
80
30
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
81
30
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
82
30
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
30
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
30
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
30
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
30
      
case BO_Comma: 13
DISPATCH13
(BinComma, BinaryOperator);
87
371
      }
88
371
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
8
      switch (UnOp->getOpcode()) {
90
8
      
case UO_PostInc: 4
DISPATCH4
(UnaryPostInc, UnaryOperator);
91
8
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
92
8
      
case UO_PreInc: 2
DISPATCH2
(UnaryPreInc, UnaryOperator);
93
8
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
94
8
      
case UO_AddrOf: 0
DISPATCH0
(UnaryAddrOf, UnaryOperator);
95
8
      
case UO_Deref: 0
DISPATCH0
(UnaryDeref, UnaryOperator);
96
8
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
97
8
      
case UO_Minus: 2
DISPATCH2
(UnaryMinus, UnaryOperator);
98
8
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
99
8
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
100
8
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
101
8
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
102
8
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
103
8
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
363
      }
105
363
    }
106
363
107
363
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
363
    switch (S->getStmtClass()) {
109
363
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
363
#define ABSTRACT_STMT(STMT)
111
363
#define STMT(CLASS, PARENT)                              \
112
363
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
363
#include 
"clang/AST/StmtNodes.inc"0
114
363
    }
115
363
  }
SemaChecking.cpp:clang::StmtVisitorBase<clang::make_ptr, (anonymous namespace)::SequenceChecker, void>::Visit(clang::Stmt*)
Line
Count
Source
46
52.4M
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
52.4M
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
52.4M
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
52.4M
    // below.
50
52.4M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
4.61M
      switch (BinOp->getOpcode()) {
52
4.61M
      
case BO_PtrMemD: 285
DISPATCH285
(BinPtrMemD, BinaryOperator);
53
4.61M
      
case BO_PtrMemI: 230
DISPATCH230
(BinPtrMemI, BinaryOperator);
54
4.61M
      
case BO_Mul: 184k
DISPATCH184k
(BinMul, BinaryOperator);
55
4.61M
      
case BO_Div: 224k
DISPATCH224k
(BinDiv, BinaryOperator);
56
4.61M
      
case BO_Rem: 12.8k
DISPATCH12.8k
(BinRem, BinaryOperator);
57
4.61M
      
case BO_Add: 657k
DISPATCH657k
(BinAdd, BinaryOperator);
58
4.61M
      
case BO_Sub: 685k
DISPATCH685k
(BinSub, BinaryOperator);
59
4.61M
      
case BO_Shl: 100k
DISPATCH100k
(BinShl, BinaryOperator);
60
4.61M
      
case BO_Shr: 55.6k
DISPATCH55.6k
(BinShr, BinaryOperator);
61
4.61M
62
4.61M
      
case BO_LT: 227k
DISPATCH227k
(BinLT, BinaryOperator);
63
4.61M
      
case BO_GT: 179k
DISPATCH179k
(BinGT, BinaryOperator);
64
4.61M
      
case BO_LE: 57.6k
DISPATCH57.6k
(BinLE, BinaryOperator);
65
4.61M
      
case BO_GE: 46.0k
DISPATCH46.0k
(BinGE, BinaryOperator);
66
4.61M
      
case BO_EQ: 256k
DISPATCH256k
(BinEQ, BinaryOperator);
67
4.61M
      
case BO_NE: 120k
DISPATCH120k
(BinNE, BinaryOperator);
68
4.61M
      
case BO_Cmp: 181
DISPATCH181
(BinCmp, BinaryOperator);
69
4.61M
70
4.61M
      
case BO_And: 101k
DISPATCH101k
(BinAnd, BinaryOperator);
71
4.61M
      
case BO_Xor: 20.4k
DISPATCH20.4k
(BinXor, BinaryOperator);
72
4.61M
      
case BO_Or : 60.7k
DISPATCH60.7k
(BinOr, BinaryOperator);
73
4.61M
      
case BO_LAnd: 106k
DISPATCH106k
(BinLAnd, BinaryOperator);
74
4.61M
      
case BO_LOr : 55.4k
DISPATCH55.4k
(BinLOr, BinaryOperator);
75
4.61M
      
case BO_Assign: 1.34M
DISPATCH1.34M
(BinAssign, BinaryOperator);
76
4.61M
      
case BO_MulAssign: 3.63k
DISPATCH3.63k
(BinMulAssign, CompoundAssignOperator);
77
4.61M
      
case BO_DivAssign: 1.69k
DISPATCH1.69k
(BinDivAssign, CompoundAssignOperator);
78
4.61M
      
case BO_RemAssign: 150
DISPATCH150
(BinRemAssign, CompoundAssignOperator);
79
4.61M
      
case BO_AddAssign: 53.4k
DISPATCH53.4k
(BinAddAssign, CompoundAssignOperator);
80
4.61M
      
case BO_SubAssign: 7.92k
DISPATCH7.92k
(BinSubAssign, CompoundAssignOperator);
81
4.61M
      
case BO_ShlAssign: 2.18k
DISPATCH2.18k
(BinShlAssign, CompoundAssignOperator);
82
4.61M
      
case BO_ShrAssign: 978
DISPATCH978
(BinShrAssign, CompoundAssignOperator);
83
4.61M
      
case BO_AndAssign: 2.69k
DISPATCH2.69k
(BinAndAssign, CompoundAssignOperator);
84
4.61M
      
case BO_OrAssign: 17.3k
DISPATCH17.3k
(BinOrAssign, CompoundAssignOperator);
85
4.61M
      
case BO_XorAssign: 2.21k
DISPATCH2.21k
(BinXorAssign, CompoundAssignOperator);
86
4.61M
      
case BO_Comma: 22.3k
DISPATCH22.3k
(BinComma, BinaryOperator);
87
47.8M
      }
88
47.8M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
1.39M
      switch (UnOp->getOpcode()) {
90
1.39M
      
case UO_PostInc: 127k
DISPATCH127k
(UnaryPostInc, UnaryOperator);
91
1.39M
      
case UO_PostDec: 8.95k
DISPATCH8.95k
(UnaryPostDec, UnaryOperator);
92
1.39M
      
case UO_PreInc: 104k
DISPATCH104k
(UnaryPreInc, UnaryOperator);
93
1.39M
      
case UO_PreDec: 16.1k
DISPATCH16.1k
(UnaryPreDec, UnaryOperator);
94
1.39M
      
case UO_AddrOf: 172k
DISPATCH172k
(UnaryAddrOf, UnaryOperator);
95
1.39M
      
case UO_Deref: 190k
DISPATCH190k
(UnaryDeref, UnaryOperator);
96
1.39M
      
case UO_Plus: 511
DISPATCH511
(UnaryPlus, UnaryOperator);
97
1.39M
      
case UO_Minus: 202k
DISPATCH202k
(UnaryMinus, UnaryOperator);
98
1.39M
      
case UO_Not: 34.1k
DISPATCH34.1k
(UnaryNot, UnaryOperator);
99
1.39M
      
case UO_LNot: 512k
DISPATCH512k
(UnaryLNot, UnaryOperator);
100
1.39M
      
case UO_Real: 769
DISPATCH769
(UnaryReal, UnaryOperator);
101
1.39M
      
case UO_Imag: 748
DISPATCH748
(UnaryImag, UnaryOperator);
102
1.39M
      
case UO_Extension: 20.3k
DISPATCH20.3k
(UnaryExtension, UnaryOperator);
103
1.39M
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
46.4M
      }
105
46.4M
    }
106
46.4M
107
46.4M
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
46.4M
    switch (S->getStmtClass()) {
109
46.4M
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
46.4M
#define ABSTRACT_STMT(STMT)
111
46.4M
#define STMT(CLASS, PARENT)                              \
112
46.4M
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
46.4M
#include 
"clang/AST/StmtNodes.inc"0
114
46.4M
    }
115
46.4M
  }
SemaChecking.cpp:clang::StmtVisitorBase<clang::make_ptr, (anonymous namespace)::FindCaptureVisitor, void>::Visit(clang::Stmt*)
Line
Count
Source
46
140
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
140
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
140
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
140
    // below.
50
140
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
2
      switch (BinOp->getOpcode()) {
52
2
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
2
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
2
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
55
2
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
56
2
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
57
2
      
case BO_Add: 0
DISPATCH0
(BinAdd, BinaryOperator);
58
2
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
59
2
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
60
2
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
61
2
62
2
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
63
2
      
case BO_GT: 1
DISPATCH1
(BinGT, BinaryOperator);
64
2
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
65
2
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
66
2
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
67
2
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
68
2
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
2
70
2
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
71
2
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
72
2
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
73
2
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
74
2
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
75
2
      
case BO_Assign: 1
DISPATCH1
(BinAssign, BinaryOperator);
76
2
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
77
2
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
78
2
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
2
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
80
2
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
81
2
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
82
2
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
2
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
2
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
2
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
2
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
87
138
      }
88
138
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
0
      switch (UnOp->getOpcode()) {
90
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
91
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
92
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
93
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
94
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
95
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
96
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
97
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
98
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
99
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
100
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
101
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
102
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
103
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
104
138
      }
105
138
    }
106
138
107
138
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
138
    switch (S->getStmtClass()) {
109
138
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
138
#define ABSTRACT_STMT(STMT)
111
138
#define STMT(CLASS, PARENT)                              \
112
138
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
138
#include 
"clang/AST/StmtNodes.inc"0
114
138
    }
115
138
  }
SemaDecl.cpp:clang::StmtVisitorBase<clang::make_ptr, (anonymous namespace)::SelfReferenceChecker, void>::Visit(clang::Stmt*)
Line
Count
Source
46
3.09M
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
3.09M
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
3.09M
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
3.09M
    // below.
50
3.09M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
183k
      switch (BinOp->getOpcode()) {
52
183k
      
case BO_PtrMemD: 24
DISPATCH24
(BinPtrMemD, BinaryOperator);
53
183k
      
case BO_PtrMemI: 2
DISPATCH2
(BinPtrMemI, BinaryOperator);
54
183k
      
case BO_Mul: 22.4k
DISPATCH22.4k
(BinMul, BinaryOperator);
55
183k
      
case BO_Div: 29.5k
DISPATCH29.5k
(BinDiv, BinaryOperator);
56
183k
      
case BO_Rem: 228
DISPATCH228
(BinRem, BinaryOperator);
57
183k
      
case BO_Add: 17.3k
DISPATCH17.3k
(BinAdd, BinaryOperator);
58
183k
      
case BO_Sub: 19.8k
DISPATCH19.8k
(BinSub, BinaryOperator);
59
183k
      
case BO_Shl: 39.8k
DISPATCH39.8k
(BinShl, BinaryOperator);
60
183k
      
case BO_Shr: 2.70k
DISPATCH2.70k
(BinShr, BinaryOperator);
61
183k
62
183k
      
case BO_LT: 11.3k
DISPATCH11.3k
(BinLT, BinaryOperator);
63
183k
      
case BO_GT: 54
DISPATCH54
(BinGT, BinaryOperator);
64
183k
      
case BO_LE: 8.80k
DISPATCH8.80k
(BinLE, BinaryOperator);
65
183k
      
case BO_GE: 577
DISPATCH577
(BinGE, BinaryOperator);
66
183k
      
case BO_EQ: 8.63k
DISPATCH8.63k
(BinEQ, BinaryOperator);
67
183k
      
case BO_NE: 1.07k
DISPATCH1.07k
(BinNE, BinaryOperator);
68
183k
      
case BO_Cmp: 40
DISPATCH40
(BinCmp, BinaryOperator);
69
183k
70
183k
      
case BO_And: 6.77k
DISPATCH6.77k
(BinAnd, BinaryOperator);
71
183k
      
case BO_Xor: 2.11k
DISPATCH2.11k
(BinXor, BinaryOperator);
72
183k
      
case BO_Or : 7.13k
DISPATCH7.13k
(BinOr, BinaryOperator);
73
183k
      
case BO_LAnd: 4.05k
DISPATCH4.05k
(BinLAnd, BinaryOperator);
74
183k
      
case BO_LOr : 304
DISPATCH304
(BinLOr, BinaryOperator);
75
183k
      
case BO_Assign: 13
DISPATCH13
(BinAssign, BinaryOperator);
76
183k
      
case BO_MulAssign: 7
DISPATCH7
(BinMulAssign, CompoundAssignOperator);
77
183k
      
case BO_DivAssign: 1
DISPATCH1
(BinDivAssign, CompoundAssignOperator);
78
183k
      
case BO_RemAssign: 4
DISPATCH4
(BinRemAssign, CompoundAssignOperator);
79
183k
      
case BO_AddAssign: 14
DISPATCH14
(BinAddAssign, CompoundAssignOperator);
80
183k
      
case BO_SubAssign: 1
DISPATCH1
(BinSubAssign, CompoundAssignOperator);
81
183k
      
case BO_ShlAssign: 4
DISPATCH4
(BinShlAssign, CompoundAssignOperator);
82
183k
      
case BO_ShrAssign: 1
DISPATCH1
(BinShrAssign, CompoundAssignOperator);
83
183k
      
case BO_AndAssign: 1
DISPATCH1
(BinAndAssign, CompoundAssignOperator);
84
183k
      
case BO_OrAssign: 1
DISPATCH1
(BinOrAssign, CompoundAssignOperator);
85
183k
      
case BO_XorAssign: 1
DISPATCH1
(BinXorAssign, CompoundAssignOperator);
86
183k
      
case BO_Comma: 129
DISPATCH129
(BinComma, BinaryOperator);
87
2.91M
      }
88
2.91M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
126k
      switch (UnOp->getOpcode()) {
90
126k
      
case UO_PostInc: 117
DISPATCH117
(UnaryPostInc, UnaryOperator);
91
126k
      
case UO_PostDec: 2
DISPATCH2
(UnaryPostDec, UnaryOperator);
92
126k
      
case UO_PreInc: 36
DISPATCH36
(UnaryPreInc, UnaryOperator);
93
126k
      
case UO_PreDec: 31
DISPATCH31
(UnaryPreDec, UnaryOperator);
94
126k
      
case UO_AddrOf: 20.5k
DISPATCH20.5k
(UnaryAddrOf, UnaryOperator);
95
126k
      
case UO_Deref: 15.1k
DISPATCH15.1k
(UnaryDeref, UnaryOperator);
96
126k
      
case UO_Plus: 76
DISPATCH76
(UnaryPlus, UnaryOperator);
97
126k
      
case UO_Minus: 75.8k
DISPATCH75.8k
(UnaryMinus, UnaryOperator);
98
126k
      
case UO_Not: 9.32k
DISPATCH9.32k
(UnaryNot, UnaryOperator);
99
126k
      
case UO_LNot: 5.10k
DISPATCH5.10k
(UnaryLNot, UnaryOperator);
100
126k
      
case UO_Real: 3
DISPATCH3
(UnaryReal, UnaryOperator);
101
126k
      
case UO_Imag: 3
DISPATCH3
(UnaryImag, UnaryOperator);
102
126k
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
103
126k
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
2.78M
      }
105
2.78M
    }
106
2.78M
107
2.78M
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
2.78M
    switch (S->getStmtClass()) {
109
2.78M
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
2.78M
#define ABSTRACT_STMT(STMT)
111
2.78M
#define STMT(CLASS, PARENT)                              \
112
2.78M
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
2.78M
#include 
"clang/AST/StmtNodes.inc"0
114
2.78M
    }
115
2.78M
  }
SemaDeclCXX.cpp:clang::StmtVisitorBase<clang::make_ptr, (anonymous namespace)::UninitializedFieldVisitor, void>::Visit(clang::Stmt*)
Line
Count
Source
46
168k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
168k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
168k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
168k
    // below.
50
168k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
1.55k
      switch (BinOp->getOpcode()) {
52
1.55k
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
1.55k
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
1.55k
      
case BO_Mul: 17
DISPATCH17
(BinMul, BinaryOperator);
55
1.55k
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
56
1.55k
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
57
1.55k
      
case BO_Add: 1.48k
DISPATCH1.48k
(BinAdd, BinaryOperator);
58
1.55k
      
case BO_Sub: 4
DISPATCH4
(BinSub, BinaryOperator);
59
1.55k
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
60
1.55k
      
case BO_Shr: 12
DISPATCH12
(BinShr, BinaryOperator);
61
1.55k
62
1.55k
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
63
1.55k
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
64
1.55k
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
65
1.55k
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
66
1.55k
      
case BO_EQ: 6
DISPATCH6
(BinEQ, BinaryOperator);
67
1.55k
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
68
1.55k
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
1.55k
70
1.55k
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
71
1.55k
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
72
1.55k
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
73
1.55k
      
case BO_LAnd: 4
DISPATCH4
(BinLAnd, BinaryOperator);
74
1.55k
      
case BO_LOr : 12
DISPATCH12
(BinLOr, BinaryOperator);
75
1.55k
      
case BO_Assign: 10
DISPATCH10
(BinAssign, BinaryOperator);
76
1.55k
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
77
1.55k
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
78
1.55k
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
1.55k
      
case BO_AddAssign: 3
DISPATCH3
(BinAddAssign, CompoundAssignOperator);
80
1.55k
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
81
1.55k
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
82
1.55k
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
1.55k
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
1.55k
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
1.55k
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
1.55k
      
case BO_Comma: 7
DISPATCH7
(BinComma, BinaryOperator);
87
167k
      }
88
167k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
691
      switch (UnOp->getOpcode()) {
90
691
      
case UO_PostInc: 17
DISPATCH17
(UnaryPostInc, UnaryOperator);
91
691
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
92
691
      
case UO_PreInc: 12
DISPATCH12
(UnaryPreInc, UnaryOperator);
93
691
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
94
691
      
case UO_AddrOf: 233
DISPATCH233
(UnaryAddrOf, UnaryOperator);
95
691
      
case UO_Deref: 122
DISPATCH122
(UnaryDeref, UnaryOperator);
96
691
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
97
691
      
case UO_Minus: 300
DISPATCH300
(UnaryMinus, UnaryOperator);
98
691
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
99
691
      
case UO_LNot: 7
DISPATCH7
(UnaryLNot, UnaryOperator);
100
691
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
101
691
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
102
691
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
103
691
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
166k
      }
105
166k
    }
106
166k
107
166k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
166k
    switch (S->getStmtClass()) {
109
166k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
166k
#define ABSTRACT_STMT(STMT)
111
166k
#define STMT(CLASS, PARENT)                              \
112
166k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
166k
#include 
"clang/AST/StmtNodes.inc"0
114
166k
    }
115
166k
  }
SemaDeclCXX.cpp:clang::StmtVisitorBase<clang::make_ptr, (anonymous namespace)::CheckDefaultArgumentVisitor, bool>::Visit(clang::Stmt*)
Line
Count
Source
46
161k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
161k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
161k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
161k
    // below.
50
161k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
5.17k
      switch (BinOp->getOpcode()) {
52
5.17k
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
5.17k
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
5.17k
      
case BO_Mul: 3
DISPATCH3
(BinMul, BinaryOperator);
55
5.17k
      
case BO_Div: 15
DISPATCH15
(BinDiv, BinaryOperator);
56
5.17k
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
57
5.17k
      
case BO_Add: 22
DISPATCH22
(BinAdd, BinaryOperator);
58
5.17k
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
59
5.17k
      
case BO_Shl: 2.87k
DISPATCH2.87k
(BinShl, BinaryOperator);
60
5.17k
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
61
5.17k
62
5.17k
      
case BO_LT: 14
DISPATCH14
(BinLT, BinaryOperator);
63
5.17k
      
case BO_GT: 4
DISPATCH4
(BinGT, BinaryOperator);
64
5.17k
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
65
5.17k
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
66
5.17k
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
67
5.17k
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
68
5.17k
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
5.17k
70
5.17k
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
71
5.17k
      
case BO_Xor: 5
DISPATCH5
(BinXor, BinaryOperator);
72
5.17k
      
case BO_Or : 2.22k
DISPATCH2.22k
(BinOr, BinaryOperator);
73
5.17k
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
74
5.17k
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
75
5.17k
      
case BO_Assign: 0
DISPATCH0
(BinAssign, BinaryOperator);
76
5.17k
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
77
5.17k
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
78
5.17k
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
5.17k
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
80
5.17k
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
81
5.17k
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
82
5.17k
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
5.17k
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
5.17k
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
5.17k
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
5.17k
      
case BO_Comma: 7
DISPATCH7
(BinComma, BinaryOperator);
87
156k
      }
88
156k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
3.76k
      switch (UnOp->getOpcode()) {
90
3.76k
      
case UO_PostInc: 0
DISPATCH0
(UnaryPostInc, UnaryOperator);
91
3.76k
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
92
3.76k
      
case UO_PreInc: 0
DISPATCH0
(UnaryPreInc, UnaryOperator);
93
3.76k
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
94
3.76k
      
case UO_AddrOf: 2.88k
DISPATCH2.88k
(UnaryAddrOf, UnaryOperator);
95
3.76k
      
case UO_Deref: 0
DISPATCH0
(UnaryDeref, UnaryOperator);
96
3.76k
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
97
3.76k
      
case UO_Minus: 884
DISPATCH884
(UnaryMinus, UnaryOperator);
98
3.76k
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
99
3.76k
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
100
3.76k
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
101
3.76k
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
102
3.76k
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
103
3.76k
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
152k
      }
105
152k
    }
106
152k
107
152k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
152k
    switch (S->getStmtClass()) {
109
152k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
152k
#define ABSTRACT_STMT(STMT)
111
152k
#define STMT(CLASS, PARENT)                              \
112
152k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
152k
#include 
"clang/AST/StmtNodes.inc"0
114
152k
    }
115
152k
  }
SemaExpr.cpp:clang::StmtVisitorBase<clang::make_ptr, (anonymous namespace)::RebuildUnknownAnyFunction, clang::ActionResult<clang::Expr*, true> >::Visit(clang::Stmt*)
Line
Count
Source
46
5
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
5
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
5
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
5
    // below.
50
5
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
0
      switch (BinOp->getOpcode()) {
52
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
53
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
54
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
55
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
56
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
57
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
58
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
59
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
60
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
61
0
62
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
63
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
64
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
65
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
66
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
67
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
68
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
69
0
70
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
71
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
72
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
73
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
74
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
75
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
76
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
77
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
78
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
79
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
80
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
81
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
82
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
83
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
84
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
85
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
86
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
87
5
      }
88
5
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
0
      switch (UnOp->getOpcode()) {
90
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
91
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
92
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
93
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
94
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
95
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
96
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
97
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
98
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
99
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
100
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
101
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
102
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
103
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
104
5
      }
105
5
    }
106
5
107
5
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
5
    switch (S->getStmtClass()) {
109
5
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
5
#define ABSTRACT_STMT(STMT)
111
5
#define STMT(CLASS, PARENT)                              \
112
5
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
5
#include 
"clang/AST/StmtNodes.inc"0
114
5
    }
115
5
  }
SemaExpr.cpp:clang::StmtVisitorBase<clang::make_ptr, (anonymous namespace)::EvaluatedExprMarker, void>::Visit(clang::Stmt*)
Line
Count
Source
46
121k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
121k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
121k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
121k
    // below.
50
121k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
262
      switch (BinOp->getOpcode()) {
52
262
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
262
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
262
      
case BO_Mul: 7
DISPATCH7
(BinMul, BinaryOperator);
55
262
      
case BO_Div: 1
DISPATCH1
(BinDiv, BinaryOperator);
56
262
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
57
262
      
case BO_Add: 8
DISPATCH8
(BinAdd, BinaryOperator);
58
262
      
case BO_Sub: 20
DISPATCH20
(BinSub, BinaryOperator);
59
262
      
case BO_Shl: 27
DISPATCH27
(BinShl, BinaryOperator);
60
262
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
61
262
62
262
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
63
262
      
case BO_GT: 72
DISPATCH72
(BinGT, BinaryOperator);
64
262
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
65
262
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
66
262
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
67
262
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
68
262
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
262
70
262
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
71
262
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
72
262
      
case BO_Or : 117
DISPATCH117
(BinOr, BinaryOperator);
73
262
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
74
262
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
75
262
      
case BO_Assign: 0
DISPATCH0
(BinAssign, BinaryOperator);
76
262
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
77
262
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
78
262
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
262
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
80
262
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
81
262
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
82
262
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
262
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
262
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
262
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
262
      
case BO_Comma: 10
DISPATCH10
(BinComma, BinaryOperator);
87
120k
      }
88
120k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
536
      switch (UnOp->getOpcode()) {
90
536
      
case UO_PostInc: 0
DISPATCH0
(UnaryPostInc, UnaryOperator);
91
536
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
92
536
      
case UO_PreInc: 0
DISPATCH0
(UnaryPreInc, UnaryOperator);
93
536
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
94
536
      
case UO_AddrOf: 98
DISPATCH98
(UnaryAddrOf, UnaryOperator);
95
536
      
case UO_Deref: 0
DISPATCH0
(UnaryDeref, UnaryOperator);
96
536
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
97
536
      
case UO_Minus: 438
DISPATCH438
(UnaryMinus, UnaryOperator);
98
536
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
99
536
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
100
536
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
101
536
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
102
536
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
103
536
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
120k
      }
105
120k
    }
106
120k
107
120k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
120k
    switch (S->getStmtClass()) {
109
120k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
120k
#define ABSTRACT_STMT(STMT)
111
120k
#define STMT(CLASS, PARENT)                              \
112
120k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
120k
#include 
"clang/AST/StmtNodes.inc"0
114
120k
    }
115
120k
  }
SemaExpr.cpp:clang::StmtVisitorBase<clang::make_ptr, (anonymous namespace)::RebuildUnknownAnyExpr, clang::ActionResult<clang::Expr*, true> >::Visit(clang::Stmt*)
Line
Count
Source
46
126
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
126
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
126
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
126
    // below.
50
126
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
0
      switch (BinOp->getOpcode()) {
52
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
53
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
54
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
55
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
56
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
57
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
58
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
59
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
60
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
61
0
62
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
63
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
64
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
65
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
66
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
67
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
68
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
69
0
70
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
71
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
72
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
73
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
74
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
75
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
76
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
77
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
78
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
79
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
80
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
81
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
82
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
83
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
84
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
85
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
86
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
87
126
      }
88
126
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
4
      switch (UnOp->getOpcode()) {
90
4
      
case UO_PostInc: 0
DISPATCH0
(UnaryPostInc, UnaryOperator);
91
4
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
92
4
      
case UO_PreInc: 0
DISPATCH0
(UnaryPreInc, UnaryOperator);
93
4
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
94
4
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
95
4
      
case UO_Deref: 0
DISPATCH0
(UnaryDeref, UnaryOperator);
96
4
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
97
4
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
98
4
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
99
4
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
100
4
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
101
4
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
102
4
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
103
4
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
122
      }
105
122
    }
106
122
107
122
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
122
    switch (S->getStmtClass()) {
109
122
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
122
#define ABSTRACT_STMT(STMT)
111
122
#define STMT(CLASS, PARENT)                              \
112
122
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
122
#include 
"clang/AST/StmtNodes.inc"0
114
122
    }
115
122
  }
SemaExprObjC.cpp:clang::StmtVisitorBase<clang::make_ptr, (anonymous namespace)::ARCCastChecker, (anonymous namespace)::ACCResult>::Visit(clang::Stmt*)
Line
Count
Source
46
1.69k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
1.69k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
1.69k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
1.69k
    // below.
50
1.69k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
3
      switch (BinOp->getOpcode()) {
52
3
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
3
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
3
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
55
3
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
56
3
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
57
3
      
case BO_Add: 0
DISPATCH0
(BinAdd, BinaryOperator);
58
3
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
59
3
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
60
3
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
61
3
62
3
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
63
3
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
64
3
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
65
3
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
66
3
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
67
3
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
68
3
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
3
70
3
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
71
3
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
72
3
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
73
3
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
74
3
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
75
3
      
case BO_Assign: 0
DISPATCH0
(BinAssign, BinaryOperator);
76
3
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
77
3
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
78
3
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
3
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
80
3
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
81
3
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
82
3
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
3
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
3
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
3
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
3
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
87
1.69k
      }
88
1.69k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
3
      switch (UnOp->getOpcode()) {
90
3
      
case UO_PostInc: 0
DISPATCH0
(UnaryPostInc, UnaryOperator);
91
3
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
92
3
      
case UO_PreInc: 0
DISPATCH0
(UnaryPreInc, UnaryOperator);
93
3
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
94
3
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
95
3
      
case UO_Deref: 0
DISPATCH0
(UnaryDeref, UnaryOperator);
96
3
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
97
3
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
98
3
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
99
3
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
100
3
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
101
3
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
102
3
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
103
3
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
1.68k
      }
105
1.68k
    }
106
1.68k
107
1.68k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
1.68k
    switch (S->getStmtClass()) {
109
1.68k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
1.68k
#define ABSTRACT_STMT(STMT)
111
1.68k
#define STMT(CLASS, PARENT)                              \
112
1.68k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
1.68k
#include 
"clang/AST/StmtNodes.inc"0
114
1.68k
    }
115
1.68k
  }
SemaOpenMP.cpp:clang::StmtVisitorBase<clang::make_ptr, (anonymous namespace)::DSARefChecker, bool>::Visit(clang::Stmt*)
Line
Count
Source
46
6.60k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
6.60k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
6.60k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
6.60k
    // below.
50
6.60k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
0
      switch (BinOp->getOpcode()) {
52
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
53
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
54
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
55
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
56
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
57
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
58
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
59
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
60
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
61
0
62
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
63
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
64
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
65
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
66
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
67
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
68
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
69
0
70
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
71
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
72
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
73
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
74
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
75
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
76
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
77
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
78
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
79
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
80
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
81
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
82
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
83
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
84
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
85
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
86
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
87
6.60k
      }
88
6.60k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
0
      switch (UnOp->getOpcode()) {
90
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
91
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
92
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
93
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
94
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
95
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
96
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
97
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
98
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
99
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
100
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
101
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
102
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
103
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
104
6.60k
      }
105
6.60k
    }
106
6.60k
107
6.60k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
6.60k
    switch (S->getStmtClass()) {
109
6.60k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
6.60k
#define ABSTRACT_STMT(STMT)
111
6.60k
#define STMT(CLASS, PARENT)                              \
112
6.60k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
6.60k
#include 
"clang/AST/StmtNodes.inc"0
114
6.60k
    }
115
6.60k
  }
SemaOpenMP.cpp:clang::StmtVisitorBase<clang::make_const_ptr, (anonymous namespace)::LocalVarRefChecker, bool>::Visit(clang::Stmt const*)
Line
Count
Source
46
1.52k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
1.52k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
1.52k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
1.52k
    // below.
50
1.52k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
0
      switch (BinOp->getOpcode()) {
52
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
53
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
54
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
55
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
56
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
57
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
58
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
59
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
60
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
61
0
62
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
63
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
64
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
65
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
66
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
67
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
68
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
69
0
70
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
71
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
72
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
73
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
74
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
75
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
76
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
77
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
78
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
79
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
80
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
81
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
82
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
83
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
84
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
85
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
86
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
87
1.52k
      }
88
1.52k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
0
      switch (UnOp->getOpcode()) {
90
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
91
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
92
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
93
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
94
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
95
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
96
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
97
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
98
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
99
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
100
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
101
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
102
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
103
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
104
1.52k
      }
105
1.52k
    }
106
1.52k
107
1.52k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
1.52k
    switch (S->getStmtClass()) {
109
1.52k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
1.52k
#define ABSTRACT_STMT(STMT)
111
1.52k
#define STMT(CLASS, PARENT)                              \
112
1.52k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
1.52k
#include 
"clang/AST/StmtNodes.inc"0
114
1.52k
    }
115
1.52k
  }
SemaOpenMP.cpp:clang::StmtVisitorBase<clang::make_ptr, (anonymous namespace)::DSAAttrChecker, void>::Visit(clang::Stmt*)
Line
Count
Source
46
1.22M
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
1.22M
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
1.22M
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
1.22M
    // below.
50
1.22M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
120k
      switch (BinOp->getOpcode()) {
52
120k
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
120k
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
120k
      
case BO_Mul: 909
DISPATCH909
(BinMul, BinaryOperator);
55
120k
      
case BO_Div: 132
DISPATCH132
(BinDiv, BinaryOperator);
56
120k
      
case BO_Rem: 8
DISPATCH8
(BinRem, BinaryOperator);
57
120k
      
case BO_Add: 4.13k
DISPATCH4.13k
(BinAdd, BinaryOperator);
58
120k
      
case BO_Sub: 16.8k
DISPATCH16.8k
(BinSub, BinaryOperator);
59
120k
      
case BO_Shl: 26
DISPATCH26
(BinShl, BinaryOperator);
60
120k
      
case BO_Shr: 26
DISPATCH26
(BinShr, BinaryOperator);
61
120k
62
120k
      
case BO_LT: 54.9k
DISPATCH54.9k
(BinLT, BinaryOperator);
63
120k
      
case BO_GT: 764
DISPATCH764
(BinGT, BinaryOperator);
64
120k
      
case BO_LE: 226
DISPATCH226
(BinLE, BinaryOperator);
65
120k
      
case BO_GE: 296
DISPATCH296
(BinGE, BinaryOperator);
66
120k
      
case BO_EQ: 196
DISPATCH196
(BinEQ, BinaryOperator);
67
120k
      
case BO_NE: 86
DISPATCH86
(BinNE, BinaryOperator);
68
120k
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
120k
70
120k
      
case BO_And: 42
DISPATCH42
(BinAnd, BinaryOperator);
71
120k
      
case BO_Xor: 18
DISPATCH18
(BinXor, BinaryOperator);
72
120k
      
case BO_Or : 26
DISPATCH26
(BinOr, BinaryOperator);
73
120k
      
case BO_LAnd: 14
DISPATCH14
(BinLAnd, BinaryOperator);
74
120k
      
case BO_LOr : 14
DISPATCH14
(BinLOr, BinaryOperator);
75
120k
      
case BO_Assign: 32.0k
DISPATCH32.0k
(BinAssign, BinaryOperator);
76
120k
      
case BO_MulAssign: 81
DISPATCH81
(BinMulAssign, CompoundAssignOperator);
77
120k
      
case BO_DivAssign: 158
DISPATCH158
(BinDivAssign, CompoundAssignOperator);
78
120k
      
case BO_RemAssign: 34
DISPATCH34
(BinRemAssign, CompoundAssignOperator);
79
120k
      
case BO_AddAssign: 8.71k
DISPATCH8.71k
(BinAddAssign, CompoundAssignOperator);
80
120k
      
case BO_SubAssign: 426
DISPATCH426
(BinSubAssign, CompoundAssignOperator);
81
120k
      
case BO_ShlAssign: 26
DISPATCH26
(BinShlAssign, CompoundAssignOperator);
82
120k
      
case BO_ShrAssign: 26
DISPATCH26
(BinShrAssign, CompoundAssignOperator);
83
120k
      
case BO_AndAssign: 26
DISPATCH26
(BinAndAssign, CompoundAssignOperator);
84
120k
      
case BO_OrAssign: 48
DISPATCH48
(BinOrAssign, CompoundAssignOperator);
85
120k
      
case BO_XorAssign: 36
DISPATCH36
(BinXorAssign, CompoundAssignOperator);
86
120k
      
case BO_Comma: 244
DISPATCH244
(BinComma, BinaryOperator);
87
1.09M
      }
88
1.09M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
63.3k
      switch (UnOp->getOpcode()) {
90
63.3k
      
case UO_PostInc: 19.3k
DISPATCH19.3k
(UnaryPostInc, UnaryOperator);
91
63.3k
      
case UO_PostDec: 202
DISPATCH202
(UnaryPostDec, UnaryOperator);
92
63.3k
      
case UO_PreInc: 42.4k
DISPATCH42.4k
(UnaryPreInc, UnaryOperator);
93
63.3k
      
case UO_PreDec: 146
DISPATCH146
(UnaryPreDec, UnaryOperator);
94
63.3k
      
case UO_AddrOf: 128
DISPATCH128
(UnaryAddrOf, UnaryOperator);
95
63.3k
      
case UO_Deref: 510
DISPATCH510
(UnaryDeref, UnaryOperator);
96
63.3k
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
97
63.3k
      
case UO_Minus: 384
DISPATCH384
(UnaryMinus, UnaryOperator);
98
63.3k
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
99
63.3k
      
case UO_LNot: 122
DISPATCH122
(UnaryLNot, UnaryOperator);
100
63.3k
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
101
63.3k
      
case UO_Imag: 4
DISPATCH4
(UnaryImag, UnaryOperator);
102
63.3k
      
case UO_Extension: 24
DISPATCH24
(UnaryExtension, UnaryOperator);
103
63.3k
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
1.03M
      }
105
1.03M
    }
106
1.03M
107
1.03M
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
1.03M
    switch (S->getStmtClass()) {
109
1.03M
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
1.03M
#define ABSTRACT_STMT(STMT)
111
1.03M
#define STMT(CLASS, PARENT)                              \
112
1.03M
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
1.03M
#include 
"clang/AST/StmtNodes.inc"0
114
1.03M
    }
115
1.03M
  }
SemaStmt.cpp:clang::StmtVisitorBase<clang::make_const_ptr, (anonymous namespace)::BreakContinueFinder, void>::Visit(clang::Stmt const*)
Line
Count
Source
46
253k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
253k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
253k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
253k
    // below.
50
253k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
37.1k
      switch (BinOp->getOpcode()) {
52
37.1k
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
37.1k
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
37.1k
      
case BO_Mul: 720
DISPATCH720
(BinMul, BinaryOperator);
55
37.1k
      
case BO_Div: 370
DISPATCH370
(BinDiv, BinaryOperator);
56
37.1k
      
case BO_Rem: 54
DISPATCH54
(BinRem, BinaryOperator);
57
37.1k
      
case BO_Add: 1.39k
DISPATCH1.39k
(BinAdd, BinaryOperator);
58
37.1k
      
case BO_Sub: 833
DISPATCH833
(BinSub, BinaryOperator);
59
37.1k
      
case BO_Shl: 140
DISPATCH140
(BinShl, BinaryOperator);
60
37.1k
      
case BO_Shr: 67
DISPATCH67
(BinShr, BinaryOperator);
61
37.1k
62
37.1k
      
case BO_LT: 18.0k
DISPATCH18.0k
(BinLT, BinaryOperator);
63
37.1k
      
case BO_GT: 1.22k
DISPATCH1.22k
(BinGT, BinaryOperator);
64
37.1k
      
case BO_LE: 2.37k
DISPATCH2.37k
(BinLE, BinaryOperator);
65
37.1k
      
case BO_GE: 722
DISPATCH722
(BinGE, BinaryOperator);
66
37.1k
      
case BO_EQ: 1.49k
DISPATCH1.49k
(BinEQ, BinaryOperator);
67
37.1k
      
case BO_NE: 2.71k
DISPATCH2.71k
(BinNE, BinaryOperator);
68
37.1k
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
37.1k
70
37.1k
      
case BO_And: 114
DISPATCH114
(BinAnd, BinaryOperator);
71
37.1k
      
case BO_Xor: 2
DISPATCH2
(BinXor, BinaryOperator);
72
37.1k
      
case BO_Or : 9
DISPATCH9
(BinOr, BinaryOperator);
73
37.1k
      
case BO_LAnd: 1.55k
DISPATCH1.55k
(BinLAnd, BinaryOperator);
74
37.1k
      
case BO_LOr : 237
DISPATCH237
(BinLOr, BinaryOperator);
75
37.1k
      
case BO_Assign: 3.22k
DISPATCH3.22k
(BinAssign, BinaryOperator);
76
37.1k
      
case BO_MulAssign: 10
DISPATCH10
(BinMulAssign, CompoundAssignOperator);
77
37.1k
      
case BO_DivAssign: 3
DISPATCH3
(BinDivAssign, CompoundAssignOperator);
78
37.1k
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
37.1k
      
case BO_AddAssign: 855
DISPATCH855
(BinAddAssign, CompoundAssignOperator);
80
37.1k
      
case BO_SubAssign: 42
DISPATCH42
(BinSubAssign, CompoundAssignOperator);
81
37.1k
      
case BO_ShlAssign: 21
DISPATCH21
(BinShlAssign, CompoundAssignOperator);
82
37.1k
      
case BO_ShrAssign: 29
DISPATCH29
(BinShrAssign, CompoundAssignOperator);
83
37.1k
      
case BO_AndAssign: 2
DISPATCH2
(BinAndAssign, CompoundAssignOperator);
84
37.1k
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
37.1k
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
37.1k
      
case BO_Comma: 830
DISPATCH830
(BinComma, BinaryOperator);
87
216k
      }
88
216k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
24.8k
      switch (UnOp->getOpcode()) {
90
24.8k
      
case UO_PostInc: 15.9k
DISPATCH15.9k
(UnaryPostInc, UnaryOperator);
91
24.8k
      
case UO_PostDec: 927
DISPATCH927
(UnaryPostDec, UnaryOperator);
92
24.8k
      
case UO_PreInc: 3.96k
DISPATCH3.96k
(UnaryPreInc, UnaryOperator);
93
24.8k
      
case UO_PreDec: 470
DISPATCH470
(UnaryPreDec, UnaryOperator);
94
24.8k
      
case UO_AddrOf: 138
DISPATCH138
(UnaryAddrOf, UnaryOperator);
95
24.8k
      
case UO_Deref: 1.38k
DISPATCH1.38k
(UnaryDeref, UnaryOperator);
96
24.8k
      
case UO_Plus: 1
DISPATCH1
(UnaryPlus, UnaryOperator);
97
24.8k
      
case UO_Minus: 339
DISPATCH339
(UnaryMinus, UnaryOperator);
98
24.8k
      
case UO_Not: 1
DISPATCH1
(UnaryNot, UnaryOperator);
99
24.8k
      
case UO_LNot: 1.63k
DISPATCH1.63k
(UnaryLNot, UnaryOperator);
100
24.8k
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
101
24.8k
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
102
24.8k
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
103
24.8k
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
191k
      }
105
191k
    }
106
191k
107
191k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
191k
    switch (S->getStmtClass()) {
109
191k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
191k
#define ABSTRACT_STMT(STMT)
111
191k
#define STMT(CLASS, PARENT)                              \
112
191k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
191k
#include 
"clang/AST/StmtNodes.inc"0
114
191k
    }
115
191k
  }
SemaStmt.cpp:clang::StmtVisitorBase<clang::make_ptr, (anonymous namespace)::DeclExtractor, void>::Visit(clang::Stmt*)
Line
Count
Source
46
261k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
261k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
261k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
261k
    // below.
50
261k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
57.7k
      switch (BinOp->getOpcode()) {
52
57.7k
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
57.7k
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
57.7k
      
case BO_Mul: 1.69k
DISPATCH1.69k
(BinMul, BinaryOperator);
55
57.7k
      
case BO_Div: 1.35k
DISPATCH1.35k
(BinDiv, BinaryOperator);
56
57.7k
      
case BO_Rem: 8
DISPATCH8
(BinRem, BinaryOperator);
57
57.7k
      
case BO_Add: 2.54k
DISPATCH2.54k
(BinAdd, BinaryOperator);
58
57.7k
      
case BO_Sub: 61
DISPATCH61
(BinSub, BinaryOperator);
59
57.7k
      
case BO_Shl: 18
DISPATCH18
(BinShl, BinaryOperator);
60
57.7k
      
case BO_Shr: 8
DISPATCH8
(BinShr, BinaryOperator);
61
57.7k
62
57.7k
      
case BO_LT: 43.2k
DISPATCH43.2k
(BinLT, BinaryOperator);
63
57.7k
      
case BO_GT: 4.03k
DISPATCH4.03k
(BinGT, BinaryOperator);
64
57.7k
      
case BO_LE: 1.82k
DISPATCH1.82k
(BinLE, BinaryOperator);
65
57.7k
      
case BO_GE: 1.92k
DISPATCH1.92k
(BinGE, BinaryOperator);
66
57.7k
      
case BO_EQ: 73
DISPATCH73
(BinEQ, BinaryOperator);
67
57.7k
      
case BO_NE: 289
DISPATCH289
(BinNE, BinaryOperator);
68
57.7k
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
57.7k
70
57.7k
      
case BO_And: 40
DISPATCH40
(BinAnd, BinaryOperator);
71
57.7k
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
72
57.7k
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
73
57.7k
      
case BO_LAnd: 613
DISPATCH613
(BinLAnd, BinaryOperator);
74
57.7k
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
75
57.7k
      
case BO_Assign: 0
DISPATCH0
(BinAssign, BinaryOperator);
76
57.7k
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
77
57.7k
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
78
57.7k
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
57.7k
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
80
57.7k
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
81
57.7k
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
82
57.7k
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
57.7k
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
57.7k
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
57.7k
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
57.7k
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
87
203k
      }
88
203k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
120
      switch (UnOp->getOpcode()) {
90
120
      
case UO_PostInc: 0
DISPATCH0
(UnaryPostInc, UnaryOperator);
91
120
      
case UO_PostDec: 4
DISPATCH4
(UnaryPostDec, UnaryOperator);
92
120
      
case UO_PreInc: 0
DISPATCH0
(UnaryPreInc, UnaryOperator);
93
120
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
94
120
      
case UO_AddrOf: 4
DISPATCH4
(UnaryAddrOf, UnaryOperator);
95
120
      
case UO_Deref: 109
DISPATCH109
(UnaryDeref, UnaryOperator);
96
120
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
97
120
      
case UO_Minus: 2
DISPATCH2
(UnaryMinus, UnaryOperator);
98
120
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
99
120
      
case UO_LNot: 1
DISPATCH1
(UnaryLNot, UnaryOperator);
100
120
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
101
120
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
102
120
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
103
120
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
203k
      }
105
203k
    }
106
203k
107
203k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
203k
    switch (S->getStmtClass()) {
109
203k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
203k
#define ABSTRACT_STMT(STMT)
111
203k
#define STMT(CLASS, PARENT)                              \
112
203k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
203k
#include 
"clang/AST/StmtNodes.inc"0
114
203k
    }
115
203k
  }
SemaStmt.cpp:clang::StmtVisitorBase<clang::make_ptr, (anonymous namespace)::DeclMatcher, void>::Visit(clang::Stmt*)
Line
Count
Source
46
166k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
166k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
166k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
166k
    // below.
50
166k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
39.1k
      switch (BinOp->getOpcode()) {
52
39.1k
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
39.1k
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
39.1k
      
case BO_Mul: 1.68k
DISPATCH1.68k
(BinMul, BinaryOperator);
55
39.1k
      
case BO_Div: 817
DISPATCH817
(BinDiv, BinaryOperator);
56
39.1k
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
57
39.1k
      
case BO_Add: 1.74k
DISPATCH1.74k
(BinAdd, BinaryOperator);
58
39.1k
      
case BO_Sub: 43
DISPATCH43
(BinSub, BinaryOperator);
59
39.1k
      
case BO_Shl: 106
DISPATCH106
(BinShl, BinaryOperator);
60
39.1k
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
61
39.1k
62
39.1k
      
case BO_LT: 20.4k
DISPATCH20.4k
(BinLT, BinaryOperator);
63
39.1k
      
case BO_GT: 4.05k
DISPATCH4.05k
(BinGT, BinaryOperator);
64
39.1k
      
case BO_LE: 1.02k
DISPATCH1.02k
(BinLE, BinaryOperator);
65
39.1k
      
case BO_GE: 1.83k
DISPATCH1.83k
(BinGE, BinaryOperator);
66
39.1k
      
case BO_EQ: 24
DISPATCH24
(BinEQ, BinaryOperator);
67
39.1k
      
case BO_NE: 89
DISPATCH89
(BinNE, BinaryOperator);
68
39.1k
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
39.1k
70
39.1k
      
case BO_And: 40
DISPATCH40
(BinAnd, BinaryOperator);
71
39.1k
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
72
39.1k
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
73
39.1k
      
case BO_LAnd: 121
DISPATCH121
(BinLAnd, BinaryOperator);
74
39.1k
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
75
39.1k
      
case BO_Assign: 3.26k
DISPATCH3.26k
(BinAssign, BinaryOperator);
76
39.1k
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
77
39.1k
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
78
39.1k
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
39.1k
      
case BO_AddAssign: 2.66k
DISPATCH2.66k
(BinAddAssign, CompoundAssignOperator);
80
39.1k
      
case BO_SubAssign: 16
DISPATCH16
(BinSubAssign, CompoundAssignOperator);
81
39.1k
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
82
39.1k
      
case BO_ShrAssign: 40
DISPATCH40
(BinShrAssign, CompoundAssignOperator);
83
39.1k
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
39.1k
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
39.1k
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
39.1k
      
case BO_Comma: 1.12k
DISPATCH1.12k
(BinComma, BinaryOperator);
87
127k
      }
88
127k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
22.7k
      switch (UnOp->getOpcode()) {
90
22.7k
      
case UO_PostInc: 17.6k
DISPATCH17.6k
(UnaryPostInc, UnaryOperator);
91
22.7k
      
case UO_PostDec: 4.22k
DISPATCH4.22k
(UnaryPostDec, UnaryOperator);
92
22.7k
      
case UO_PreInc: 704
DISPATCH704
(UnaryPreInc, UnaryOperator);
93
22.7k
      
case UO_PreDec: 105
DISPATCH105
(UnaryPreDec, UnaryOperator);
94
22.7k
      
case UO_AddrOf: 2
DISPATCH2
(UnaryAddrOf, UnaryOperator);
95
22.7k
      
case UO_Deref: 20
DISPATCH20
(UnaryDeref, UnaryOperator);
96
22.7k
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
97
22.7k
      
case UO_Minus: 2
DISPATCH2
(UnaryMinus, UnaryOperator);
98
22.7k
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
99
22.7k
      
case UO_LNot: 25
DISPATCH25
(UnaryLNot, UnaryOperator);
100
22.7k
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
101
22.7k
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
102
22.7k
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
103
22.7k
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
104k
      }
105
104k
    }
106
104k
107
104k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
104k
    switch (S->getStmtClass()) {
109
104k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
104k
#define ABSTRACT_STMT(STMT)
111
104k
#define STMT(CLASS, PARENT)                              \
112
104k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
104k
#include 
"clang/AST/StmtNodes.inc"0
114
104k
    }
115
104k
  }
SemaStmt.cpp:clang::StmtVisitorBase<clang::make_ptr, (anonymous namespace)::CommaVisitor, void>::Visit(clang::Stmt*)
Line
Count
Source
46
400
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
400
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
400
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
400
    // below.
50
400
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
88
      switch (BinOp->getOpcode()) {
52
88
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
88
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
88
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
55
88
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
56
88
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
57
88
      
case BO_Add: 0
DISPATCH0
(BinAdd, BinaryOperator);
58
88
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
59
88
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
60
88
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
61
88
62
88
      
case BO_LT: 74
DISPATCH74
(BinLT, BinaryOperator);
63
88
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
64
88
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
65
88
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
66
88
      
case BO_EQ: 2
DISPATCH2
(BinEQ, BinaryOperator);
67
88
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
68
88
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
88
70
88
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
71
88
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
72
88
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
73
88
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
74
88
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
75
88
      
case BO_Assign: 0
DISPATCH0
(BinAssign, BinaryOperator);
76
88
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
77
88
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
78
88
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
88
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
80
88
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
81
88
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
82
88
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
88
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
88
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
88
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
88
      
case BO_Comma: 12
DISPATCH12
(BinComma, BinaryOperator);
87
312
      }
88
312
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
0
      switch (UnOp->getOpcode()) {
90
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
91
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
92
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
93
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
94
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
95
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
96
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
97
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
98
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
99
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
100
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
101
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
102
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
103
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
104
312
      }
105
312
    }
106
312
107
312
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
312
    switch (S->getStmtClass()) {
109
312
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
312
#define ABSTRACT_STMT(STMT)
111
312
#define STMT(CLASS, PARENT)                              \
112
312
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
312
#include 
"clang/AST/StmtNodes.inc"0
114
312
    }
115
312
  }
AnalysisDeclContext.cpp:clang::StmtVisitorBase<clang::make_ptr, (anonymous namespace)::FindBlockDeclRefExprsVals, void>::Visit(clang::Stmt*)
Line
Count
Source
46
2.31k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
2.31k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
2.31k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
2.31k
    // below.
50
2.31k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
164
      switch (BinOp->getOpcode()) {
52
164
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
164
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
164
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
55
164
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
56
164
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
57
164
      
case BO_Add: 22
DISPATCH22
(BinAdd, BinaryOperator);
58
164
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
59
164
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
60
164
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
61
164
62
164
      
case BO_LT: 4
DISPATCH4
(BinLT, BinaryOperator);
63
164
      
case BO_GT: 6
DISPATCH6
(BinGT, BinaryOperator);
64
164
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
65
164
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
66
164
      
case BO_EQ: 12
DISPATCH12
(BinEQ, BinaryOperator);
67
164
      
case BO_NE: 2
DISPATCH2
(BinNE, BinaryOperator);
68
164
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
164
70
164
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
71
164
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
72
164
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
73
164
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
74
164
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
75
164
      
case BO_Assign: 118
DISPATCH118
(BinAssign, BinaryOperator);
76
164
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
77
164
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
78
164
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
164
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
80
164
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
81
164
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
82
164
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
164
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
164
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
164
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
164
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
87
2.15k
      }
88
2.15k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
75
      switch (UnOp->getOpcode()) {
90
75
      
case UO_PostInc: 2
DISPATCH2
(UnaryPostInc, UnaryOperator);
91
75
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
92
75
      
case UO_PreInc: 12
DISPATCH12
(UnaryPreInc, UnaryOperator);
93
75
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
94
75
      
case UO_AddrOf: 9
DISPATCH9
(UnaryAddrOf, UnaryOperator);
95
75
      
case UO_Deref: 52
DISPATCH52
(UnaryDeref, UnaryOperator);
96
75
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
97
75
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
98
75
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
99
75
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
100
75
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
101
75
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
102
75
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
103
75
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
2.07k
      }
105
2.07k
    }
106
2.07k
107
2.07k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
2.07k
    switch (S->getStmtClass()) {
109
2.07k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
2.07k
#define ABSTRACT_STMT(STMT)
111
2.07k
#define STMT(CLASS, PARENT)                              \
112
2.07k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
2.07k
#include 
"clang/AST/StmtNodes.inc"0
114
2.07k
    }
115
2.07k
  }
CFG.cpp:clang::StmtVisitorBase<clang::make_ptr, (anonymous namespace)::CFGBlockTerminatorPrint, void>::Visit(clang::Stmt*)
Line
Count
Source
46
519
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
519
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
519
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
519
    // below.
50
519
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
36
      switch (BinOp->getOpcode()) {
52
36
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
36
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
36
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
55
36
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
56
36
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
57
36
      
case BO_Add: 0
DISPATCH0
(BinAdd, BinaryOperator);
58
36
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
59
36
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
60
36
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
61
36
62
36
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
63
36
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
64
36
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
65
36
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
66
36
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
67
36
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
68
36
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
36
70
36
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
71
36
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
72
36
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
73
36
      
case BO_LAnd: 8
DISPATCH8
(BinLAnd, BinaryOperator);
74
36
      
case BO_LOr : 28
DISPATCH28
(BinLOr, BinaryOperator);
75
36
      
case BO_Assign: 0
DISPATCH0
(BinAssign, BinaryOperator);
76
36
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
77
36
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
78
36
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
36
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
80
36
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
81
36
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
82
36
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
36
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
36
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
36
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
36
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
87
483
      }
88
483
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
0
      switch (UnOp->getOpcode()) {
90
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
91
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
92
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
93
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
94
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
95
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
96
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
97
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
98
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
99
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
100
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
101
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
102
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
103
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
104
483
      }
105
483
    }
106
483
107
483
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
483
    switch (S->getStmtClass()) {
109
483
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
483
#define ABSTRACT_STMT(STMT)
111
483
#define STMT(CLASS, PARENT)                              \
112
483
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
483
#include 
"clang/AST/StmtNodes.inc"0
114
483
    }
115
483
  }
CallGraph.cpp:clang::StmtVisitorBase<clang::make_ptr, (anonymous namespace)::CGBuilder, void>::Visit(clang::Stmt*)
Line
Count
Source
46
252k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
252k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
252k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
252k
    // below.
50
252k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
14.9k
      switch (BinOp->getOpcode()) {
52
14.9k
      
case BO_PtrMemD: 22
DISPATCH22
(BinPtrMemD, BinaryOperator);
53
14.9k
      
case BO_PtrMemI: 6
DISPATCH6
(BinPtrMemI, BinaryOperator);
54
14.9k
      
case BO_Mul: 359
DISPATCH359
(BinMul, BinaryOperator);
55
14.9k
      
case BO_Div: 418
DISPATCH418
(BinDiv, BinaryOperator);
56
14.9k
      
case BO_Rem: 26
DISPATCH26
(BinRem, BinaryOperator);
57
14.9k
      
case BO_Add: 1.08k
DISPATCH1.08k
(BinAdd, BinaryOperator);
58
14.9k
      
case BO_Sub: 476
DISPATCH476
(BinSub, BinaryOperator);
59
14.9k
      
case BO_Shl: 53
DISPATCH53
(BinShl, BinaryOperator);
60
14.9k
      
case BO_Shr: 47
DISPATCH47
(BinShr, BinaryOperator);
61
14.9k
62
14.9k
      
case BO_LT: 835
DISPATCH835
(BinLT, BinaryOperator);
63
14.9k
      
case BO_GT: 461
DISPATCH461
(BinGT, BinaryOperator);
64
14.9k
      
case BO_LE: 275
DISPATCH275
(BinLE, BinaryOperator);
65
14.9k
      
case BO_GE: 224
DISPATCH224
(BinGE, BinaryOperator);
66
14.9k
      
case BO_EQ: 4.34k
DISPATCH4.34k
(BinEQ, BinaryOperator);
67
14.9k
      
case BO_NE: 674
DISPATCH674
(BinNE, BinaryOperator);
68
14.9k
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
14.9k
70
14.9k
      
case BO_And: 79
DISPATCH79
(BinAnd, BinaryOperator);
71
14.9k
      
case BO_Xor: 4
DISPATCH4
(BinXor, BinaryOperator);
72
14.9k
      
case BO_Or : 71
DISPATCH71
(BinOr, BinaryOperator);
73
14.9k
      
case BO_LAnd: 214
DISPATCH214
(BinLAnd, BinaryOperator);
74
14.9k
      
case BO_LOr : 217
DISPATCH217
(BinLOr, BinaryOperator);
75
14.9k
      
case BO_Assign: 4.54k
DISPATCH4.54k
(BinAssign, BinaryOperator);
76
14.9k
      
case BO_MulAssign: 14
DISPATCH14
(BinMulAssign, CompoundAssignOperator);
77
14.9k
      
case BO_DivAssign: 21
DISPATCH21
(BinDivAssign, CompoundAssignOperator);
78
14.9k
      
case BO_RemAssign: 5
DISPATCH5
(BinRemAssign, CompoundAssignOperator);
79
14.9k
      
case BO_AddAssign: 211
DISPATCH211
(BinAddAssign, CompoundAssignOperator);
80
14.9k
      
case BO_SubAssign: 92
DISPATCH92
(BinSubAssign, CompoundAssignOperator);
81
14.9k
      
case BO_ShlAssign: 8
DISPATCH8
(BinShlAssign, CompoundAssignOperator);
82
14.9k
      
case BO_ShrAssign: 2
DISPATCH2
(BinShrAssign, CompoundAssignOperator);
83
14.9k
      
case BO_AndAssign: 11
DISPATCH11
(BinAndAssign, CompoundAssignOperator);
84
14.9k
      
case BO_OrAssign: 9
DISPATCH9
(BinOrAssign, CompoundAssignOperator);
85
14.9k
      
case BO_XorAssign: 18
DISPATCH18
(BinXorAssign, CompoundAssignOperator);
86
14.9k
      
case BO_Comma: 97
DISPATCH97
(BinComma, BinaryOperator);
87
237k
      }
88
237k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
6.16k
      switch (UnOp->getOpcode()) {
90
6.16k
      
case UO_PostInc: 502
DISPATCH502
(UnaryPostInc, UnaryOperator);
91
6.16k
      
case UO_PostDec: 42
DISPATCH42
(UnaryPostDec, UnaryOperator);
92
6.16k
      
case UO_PreInc: 464
DISPATCH464
(UnaryPreInc, UnaryOperator);
93
6.16k
      
case UO_PreDec: 85
DISPATCH85
(UnaryPreDec, UnaryOperator);
94
6.16k
      
case UO_AddrOf: 2.18k
DISPATCH2.18k
(UnaryAddrOf, UnaryOperator);
95
6.16k
      
case UO_Deref: 1.72k
DISPATCH1.72k
(UnaryDeref, UnaryOperator);
96
6.16k
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
97
6.16k
      
case UO_Minus: 500
DISPATCH500
(UnaryMinus, UnaryOperator);
98
6.16k
      
case UO_Not: 150
DISPATCH150
(UnaryNot, UnaryOperator);
99
6.16k
      
case UO_LNot: 469
DISPATCH469
(UnaryLNot, UnaryOperator);
100
6.16k
      
case UO_Real: 7
DISPATCH7
(UnaryReal, UnaryOperator);
101
6.16k
      
case UO_Imag: 5
DISPATCH5
(UnaryImag, UnaryOperator);
102
6.16k
      
case UO_Extension: 29
DISPATCH29
(UnaryExtension, UnaryOperator);
103
6.16k
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
231k
      }
105
231k
    }
106
231k
107
231k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
231k
    switch (S->getStmtClass()) {
109
231k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
231k
#define ABSTRACT_STMT(STMT)
111
231k
#define STMT(CLASS, PARENT)                              \
112
231k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
231k
#include 
"clang/AST/StmtNodes.inc"6
114
231k
    }
115
231k
  }
CloneDetection.cpp:clang::StmtVisitorBase<clang::make_const_ptr, (anonymous namespace)::CloneTypeIIStmtDataCollector<llvm::MD5>, void>::Visit(clang::Stmt const*)
Line
Count
Source
46
1.83k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
1.83k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
1.83k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
1.83k
    // below.
50
1.83k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
285
      switch (BinOp->getOpcode()) {
52
285
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
285
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
285
      
case BO_Mul: 21
DISPATCH21
(BinMul, BinaryOperator);
55
285
      
case BO_Div: 16
DISPATCH16
(BinDiv, BinaryOperator);
56
285
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
57
285
      
case BO_Add: 86
DISPATCH86
(BinAdd, BinaryOperator);
58
285
      
case BO_Sub: 11
DISPATCH11
(BinSub, BinaryOperator);
59
285
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
60
285
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
61
285
62
285
      
case BO_LT: 26
DISPATCH26
(BinLT, BinaryOperator);
63
285
      
case BO_GT: 49
DISPATCH49
(BinGT, BinaryOperator);
64
285
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
65
285
      
case BO_GE: 1
DISPATCH1
(BinGE, BinaryOperator);
66
285
      
case BO_EQ: 3
DISPATCH3
(BinEQ, BinaryOperator);
67
285
      
case BO_NE: 4
DISPATCH4
(BinNE, BinaryOperator);
68
285
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
285
70
285
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
71
285
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
72
285
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
73
285
      
case BO_LAnd: 3
DISPATCH3
(BinLAnd, BinaryOperator);
74
285
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
75
285
      
case BO_Assign: 48
DISPATCH48
(BinAssign, BinaryOperator);
76
285
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
77
285
      
case BO_DivAssign: 2
DISPATCH2
(BinDivAssign, CompoundAssignOperator);
78
285
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
285
      
case BO_AddAssign: 9
DISPATCH9
(BinAddAssign, CompoundAssignOperator);
80
285
      
case BO_SubAssign: 4
DISPATCH4
(BinSubAssign, CompoundAssignOperator);
81
285
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
82
285
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
285
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
285
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
285
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
285
      
case BO_Comma: 2
DISPATCH