Coverage Report

Created: 2018-12-11 17:59

/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/ADT/STLExtras.h"
26
#include "llvm/Support/Casting.h"
27
#include "llvm/Support/ErrorHandling.h"
28
#include <utility>
29
30
namespace clang {
31
/// StmtVisitorBase - This class implements a simple visitor for Stmt
32
/// subclasses. Since Expr derives from Stmt, this also includes support for
33
/// visiting Exprs.
34
template<template <typename> class Ptr, typename ImplClass, typename RetTy=void,
35
         class... ParamTys>
36
class StmtVisitorBase {
37
public:
38
#define PTR(CLASS) typename Ptr<CLASS>::type
39
#define DISPATCH(NAME, CLASS) \
40
292M
  return static_cast<ImplClass*>(this)->Visit ## NAME( \
41
292M
    static_cast<PTR(CLASS)>(S), std::forward<ParamTys>(P)...)
42
43
185M
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
185M
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
185M
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
185M
    // below.
47
185M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
18.6M
      switch (BinOp->getOpcode()) {
49
18.6M
      
case BO_PtrMemD: 92.2k
DISPATCH92.2k
(BinPtrMemD, BinaryOperator);
50
18.6M
      
case BO_PtrMemI: 479
DISPATCH479
(BinPtrMemI, BinaryOperator);
51
18.6M
      
case BO_Mul: 767k
DISPATCH767k
(BinMul, BinaryOperator);
52
18.6M
      
case BO_Div: 567k
DISPATCH567k
(BinDiv, BinaryOperator);
53
18.6M
      
case BO_Rem: 63.8k
DISPATCH63.8k
(BinRem, BinaryOperator);
54
18.6M
      
case BO_Add: 1.76M
DISPATCH1.76M
(BinAdd, BinaryOperator);
55
18.6M
      
case BO_Sub: 1.97M
DISPATCH1.97M
(BinSub, BinaryOperator);
56
18.6M
      
case BO_Shl: 718k
DISPATCH718k
(BinShl, BinaryOperator);
57
18.6M
      
case BO_Shr: 287k
DISPATCH287k
(BinShr, BinaryOperator);
58
18.6M
59
18.6M
      
case BO_LT: 1.24M
DISPATCH1.24M
(BinLT, BinaryOperator);
60
18.6M
      
case BO_GT: 825k
DISPATCH825k
(BinGT, BinaryOperator);
61
18.6M
      
case BO_LE: 377k
DISPATCH377k
(BinLE, BinaryOperator);
62
18.6M
      
case BO_GE: 266k
DISPATCH266k
(BinGE, BinaryOperator);
63
18.6M
      
case BO_EQ: 1.59M
DISPATCH1.59M
(BinEQ, BinaryOperator);
64
18.6M
      
case BO_NE: 691k
DISPATCH691k
(BinNE, BinaryOperator);
65
18.6M
      
case BO_Cmp: 477
DISPATCH477
(BinCmp, BinaryOperator);
66
18.6M
67
18.6M
      
case BO_And: 467k
DISPATCH467k
(BinAnd, BinaryOperator);
68
18.6M
      
case BO_Xor: 95.1k
DISPATCH95.1k
(BinXor, BinaryOperator);
69
18.6M
      
case BO_Or : 252k
DISPATCH252k
(BinOr, BinaryOperator);
70
18.6M
      
case BO_LAnd: 1.38M
DISPATCH1.38M
(BinLAnd, BinaryOperator);
71
18.6M
      
case BO_LOr : 571k
DISPATCH571k
(BinLOr, BinaryOperator);
72
18.6M
      
case BO_Assign: 4.05M
DISPATCH4.05M
(BinAssign, BinaryOperator);
73
18.6M
      
case BO_MulAssign: 14.9k
DISPATCH14.9k
(BinMulAssign, CompoundAssignOperator);
74
18.6M
      
case BO_DivAssign: 5.64k
DISPATCH5.64k
(BinDivAssign, CompoundAssignOperator);
75
18.6M
      
case BO_RemAssign: 770
DISPATCH770
(BinRemAssign, CompoundAssignOperator);
76
18.6M
      
case BO_AddAssign: 205k
DISPATCH205k
(BinAddAssign, CompoundAssignOperator);
77
18.6M
      
case BO_SubAssign: 26.7k
DISPATCH26.7k
(BinSubAssign, CompoundAssignOperator);
78
18.6M
      
case BO_ShlAssign: 12.0k
DISPATCH12.0k
(BinShlAssign, CompoundAssignOperator);
79
18.6M
      
case BO_ShrAssign: 5.98k
DISPATCH5.98k
(BinShrAssign, CompoundAssignOperator);
80
18.6M
      
case BO_AndAssign: 14.7k
DISPATCH14.7k
(BinAndAssign, CompoundAssignOperator);
81
18.6M
      
case BO_OrAssign: 58.5k
DISPATCH58.5k
(BinOrAssign, CompoundAssignOperator);
82
18.6M
      
case BO_XorAssign: 8.29k
DISPATCH8.29k
(BinXorAssign, CompoundAssignOperator);
83
18.6M
      
case BO_Comma: 225k
DISPATCH225k
(BinComma, BinaryOperator);
84
166M
      }
85
166M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
6.99M
      switch (UnOp->getOpcode()) {
87
6.99M
      
case UO_PostInc: 383k
DISPATCH383k
(UnaryPostInc, UnaryOperator);
88
6.99M
      
case UO_PostDec: 32.5k
DISPATCH32.5k
(UnaryPostDec, UnaryOperator);
89
6.99M
      
case UO_PreInc: 235k
DISPATCH235k
(UnaryPreInc, UnaryOperator);
90
6.99M
      
case UO_PreDec: 42.9k
DISPATCH42.9k
(UnaryPreDec, UnaryOperator);
91
6.99M
      
case UO_AddrOf: 777k
DISPATCH777k
(UnaryAddrOf, UnaryOperator);
92
6.99M
      
case UO_Deref: 722k
DISPATCH722k
(UnaryDeref, UnaryOperator);
93
6.99M
      
case UO_Plus: 1.29k
DISPATCH1.29k
(UnaryPlus, UnaryOperator);
94
6.99M
      
case UO_Minus: 609k
DISPATCH609k
(UnaryMinus, UnaryOperator);
95
6.99M
      
case UO_Not: 118k
DISPATCH118k
(UnaryNot, UnaryOperator);
96
6.99M
      
case UO_LNot: 4.02M
DISPATCH4.02M
(UnaryLNot, UnaryOperator);
97
6.99M
      
case UO_Real: 6.28k
DISPATCH6.28k
(UnaryReal, UnaryOperator);
98
6.99M
      
case UO_Imag: 6.23k
DISPATCH6.23k
(UnaryImag, UnaryOperator);
99
6.99M
      
case UO_Extension: 34.7k
DISPATCH34.7k
(UnaryExtension, UnaryOperator);
100
6.99M
      
case UO_Coawait: 10
DISPATCH10
(UnaryCoawait, UnaryOperator);
101
159M
      }
102
159M
    }
103
159M
104
159M
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
159M
    switch (S->getStmtClass()) {
106
159M
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
107
159M
#define ABSTRACT_STMT(STMT)
108
159M
#define STMT(CLASS, PARENT)                              \
109
159M
    case Stmt::CLASS ## Class: 
DISPATCH159M
(CLASS, CLASS);
110
159M
#include 
"clang/AST/StmtNodes.inc"85.1k
111
159M
    }
112
159M
  }
CGClass.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::DynamicThisUseChecker, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
40.0k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
40.0k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
40.0k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
40.0k
    // below.
47
40.0k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
11
      switch (BinOp->getOpcode()) {
49
11
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
50
11
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
51
11
      
case BO_Mul: 1
DISPATCH1
(BinMul, BinaryOperator);
52
11
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
53
11
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
54
11
      
case BO_Add: 10
DISPATCH10
(BinAdd, BinaryOperator);
55
11
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
56
11
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
57
11
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
58
11
59
11
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
60
11
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
61
11
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
62
11
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
63
11
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
64
11
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
65
11
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
66
11
67
11
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
68
11
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
69
11
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
70
11
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
71
11
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
72
11
      
case BO_Assign: 0
DISPATCH0
(BinAssign, BinaryOperator);
73
11
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
74
11
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
75
11
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
76
11
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
77
11
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
78
11
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
79
11
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
80
11
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
81
11
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
82
11
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
83
11
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
84
40.0k
      }
85
40.0k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
162
      switch (UnOp->getOpcode()) {
87
162
      
case UO_PostInc: 0
DISPATCH0
(UnaryPostInc, UnaryOperator);
88
162
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
89
162
      
case UO_PreInc: 0
DISPATCH0
(UnaryPreInc, UnaryOperator);
90
162
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
91
162
      
case UO_AddrOf: 157
DISPATCH157
(UnaryAddrOf, UnaryOperator);
92
162
      
case UO_Deref: 5
DISPATCH5
(UnaryDeref, UnaryOperator);
93
162
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
94
162
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
95
162
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
96
162
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
97
162
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
98
162
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
99
162
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
100
162
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
101
39.9k
      }
102
39.9k
    }
103
39.9k
104
39.9k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
39.9k
    switch (S->getStmtClass()) {
106
39.9k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
107
39.9k
#define ABSTRACT_STMT(STMT)
108
39.9k
#define STMT(CLASS, PARENT)                              \
109
39.9k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
39.9k
#include 
"clang/AST/StmtNodes.inc"0
111
39.9k
    }
112
39.9k
  }
CGCoroutine.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::GetParamRef, void>::Visit(clang::Stmt*)
Line
Count
Source
43
70
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
70
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
70
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
70
    // below.
47
70
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
0
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
0
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
0
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
70
      }
85
70
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
0
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
70
      }
102
70
    }
103
70
104
70
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
70
    switch (S->getStmtClass()) {
106
70
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
107
70
#define ABSTRACT_STMT(STMT)
108
70
#define STMT(CLASS, PARENT)                              \
109
70
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
70
#include 
"clang/AST/StmtNodes.inc"0
111
70
    }
112
70
  }
CGException.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::CaptureFinder, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
400
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
400
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
400
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
400
    // below.
47
400
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
24
      switch (BinOp->getOpcode()) {
49
24
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
50
24
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
51
24
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
52
24
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
53
24
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
54
24
      
case BO_Add: 0
DISPATCH0
(BinAdd, BinaryOperator);
55
24
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
56
24
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
57
24
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
58
24
59
24
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
60
24
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
61
24
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
62
24
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
63
24
      
case BO_EQ: 12
DISPATCH12
(BinEQ, BinaryOperator);
64
24
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
65
24
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
66
24
67
24
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
68
24
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
69
24
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
70
24
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
71
24
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
72
24
      
case BO_Assign: 12
DISPATCH12
(BinAssign, BinaryOperator);
73
24
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
74
24
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
75
24
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
76
24
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
77
24
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
78
24
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
79
24
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
80
24
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
81
24
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
82
24
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
83
24
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
84
376
      }
85
376
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
10
      switch (UnOp->getOpcode()) {
87
10
      
case UO_PostInc: 0
DISPATCH0
(UnaryPostInc, UnaryOperator);
88
10
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
89
10
      
case UO_PreInc: 5
DISPATCH5
(UnaryPreInc, UnaryOperator);
90
10
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
91
10
      
case UO_AddrOf: 0
DISPATCH0
(UnaryAddrOf, UnaryOperator);
92
10
      
case UO_Deref: 0
DISPATCH0
(UnaryDeref, UnaryOperator);
93
10
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
94
10
      
case UO_Minus: 5
DISPATCH5
(UnaryMinus, UnaryOperator);
95
10
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
96
10
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
97
10
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
98
10
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
99
10
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
100
10
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
101
366
      }
102
366
    }
103
366
104
366
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
366
    switch (S->getStmtClass()) {
106
366
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
107
366
#define ABSTRACT_STMT(STMT)
108
366
#define STMT(CLASS, PARENT)                              \
109
366
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
366
#include 
"clang/AST/StmtNodes.inc"0
111
366
    }
112
366
  }
CGExprAgg.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::AggExprEmitter, void>::Visit(clang::Stmt*)
Line
Count
Source
43
262k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
262k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
262k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
262k
    // below.
47
262k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
1.40k
      switch (BinOp->getOpcode()) {
49
1.40k
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
50
1.40k
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
51
1.40k
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
52
1.40k
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
53
1.40k
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
54
1.40k
      
case BO_Add: 0
DISPATCH0
(BinAdd, BinaryOperator);
55
1.40k
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
56
1.40k
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
57
1.40k
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
58
1.40k
59
1.40k
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
60
1.40k
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
61
1.40k
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
62
1.40k
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
63
1.40k
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
64
1.40k
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
65
1.40k
      
case BO_Cmp: 17
DISPATCH17
(BinCmp, BinaryOperator);
66
1.40k
67
1.40k
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
68
1.40k
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
69
1.40k
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
70
1.40k
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
71
1.40k
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
72
1.40k
      
case BO_Assign: 1.33k
DISPATCH1.33k
(BinAssign, BinaryOperator);
73
1.40k
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
74
1.40k
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
75
1.40k
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
76
1.40k
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
77
1.40k
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
78
1.40k
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
79
1.40k
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
80
1.40k
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
81
1.40k
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
82
1.40k
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
83
1.40k
      
case BO_Comma: 52
DISPATCH52
(BinComma, BinaryOperator);
84
261k
      }
85
261k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
1.09k
      switch (UnOp->getOpcode()) {
87
1.09k
      
case UO_PostInc: 0
DISPATCH0
(UnaryPostInc, UnaryOperator);
88
1.09k
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
89
1.09k
      
case UO_PreInc: 0
DISPATCH0
(UnaryPreInc, UnaryOperator);
90
1.09k
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
91
1.09k
      
case UO_AddrOf: 0
DISPATCH0
(UnaryAddrOf, UnaryOperator);
92
1.09k
      
case UO_Deref: 274
DISPATCH274
(UnaryDeref, UnaryOperator);
93
1.09k
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
94
1.09k
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
95
1.09k
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
96
1.09k
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
97
1.09k
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
98
1.09k
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
99
1.09k
      
case UO_Extension: 825
DISPATCH825
(UnaryExtension, UnaryOperator);
100
1.09k
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
101
260k
      }
102
260k
    }
103
260k
104
260k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
260k
    switch (S->getStmtClass()) {
106
260k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
107
260k
#define ABSTRACT_STMT(STMT)
108
260k
#define STMT(CLASS, PARENT)                              \
109
260k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
260k
#include 
"clang/AST/StmtNodes.inc"0
111
260k
    }
112
260k
  }
CGExprComplex.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::ComplexExprEmitter, std::__1::pair<llvm::Value*, llvm::Value*> >::Visit(clang::Stmt*)
Line
Count
Source
43
4.59k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
4.59k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
4.59k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
4.59k
    // below.
47
4.59k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
705
      switch (BinOp->getOpcode()) {
49
705
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
50
705
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
51
705
      
case BO_Mul: 122
DISPATCH122
(BinMul, BinaryOperator);
52
705
      
case BO_Div: 86
DISPATCH86
(BinDiv, BinaryOperator);
53
705
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
54
705
      
case BO_Add: 209
DISPATCH209
(BinAdd, BinaryOperator);
55
705
      
case BO_Sub: 112
DISPATCH112
(BinSub, BinaryOperator);
56
705
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
57
705
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
58
705
59
705
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
60
705
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
61
705
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
62
705
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
63
705
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
64
705
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
65
705
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
66
705
67
705
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
68
705
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
69
705
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
70
705
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
71
705
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
72
705
      
case BO_Assign: 160
DISPATCH160
(BinAssign, BinaryOperator);
73
705
      
case BO_MulAssign: 1
DISPATCH1
(BinMulAssign, CompoundAssignOperator);
74
705
      
case BO_DivAssign: 4
DISPATCH4
(BinDivAssign, CompoundAssignOperator);
75
705
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
76
705
      
case BO_AddAssign: 11
DISPATCH11
(BinAddAssign, CompoundAssignOperator);
77
705
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
78
705
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
79
705
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
80
705
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
81
705
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
82
705
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
83
705
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
84
3.88k
      }
85
3.88k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
36
      switch (UnOp->getOpcode()) {
87
36
      
case UO_PostInc: 2
DISPATCH2
(UnaryPostInc, UnaryOperator);
88
36
      
case UO_PostDec: 2
DISPATCH2
(UnaryPostDec, UnaryOperator);
89
36
      
case UO_PreInc: 2
DISPATCH2
(UnaryPreInc, UnaryOperator);
90
36
      
case UO_PreDec: 2
DISPATCH2
(UnaryPreDec, UnaryOperator);
91
36
      
case UO_AddrOf: 0
DISPATCH0
(UnaryAddrOf, UnaryOperator);
92
36
      
case UO_Deref: 4
DISPATCH4
(UnaryDeref, UnaryOperator);
93
36
      
case UO_Plus: 5
DISPATCH5
(UnaryPlus, UnaryOperator);
94
36
      
case UO_Minus: 4
DISPATCH4
(UnaryMinus, UnaryOperator);
95
36
      
case UO_Not: 3
DISPATCH3
(UnaryNot, UnaryOperator);
96
36
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
97
36
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
98
36
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
99
36
      
case UO_Extension: 12
DISPATCH12
(UnaryExtension, UnaryOperator);
100
36
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
101
3.85k
      }
102
3.85k
    }
103
3.85k
104
3.85k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
3.85k
    switch (S->getStmtClass()) {
106
3.85k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
107
3.85k
#define ABSTRACT_STMT(STMT)
108
3.85k
#define STMT(CLASS, PARENT)                              \
109
3.85k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
3.85k
#include 
"clang/AST/StmtNodes.inc"0
111
3.85k
    }
112
3.85k
  }
CGExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::ConstantLValueEmitter, (anonymous namespace)::ConstantLValue>::Visit(clang::Stmt const*)
Line
Count
Source
43
17.5k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
17.5k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
17.5k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
17.5k
    // below.
47
17.5k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
0
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
0
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
0
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
17.5k
      }
85
17.5k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
0
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
17.5k
      }
102
17.5k
    }
103
17.5k
104
17.5k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
17.5k
    switch (S->getStmtClass()) {
106
17.5k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
107
17.5k
#define ABSTRACT_STMT(STMT)
108
17.5k
#define STMT(CLASS, PARENT)                              \
109
17.5k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
17.5k
#include 
"clang/AST/StmtNodes.inc"0
111
17.5k
    }
112
17.5k
  }
CGExprConstant.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::ConstExprEmitter, llvm::Constant*, clang::QualType>::Visit(clang::Stmt*, clang::QualType)
Line
Count
Source
43
38.5k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
38.5k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
38.5k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
38.5k
    // below.
47
38.5k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
132
      switch (BinOp->getOpcode()) {
49
132
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
50
132
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
51
132
      
case BO_Mul: 4
DISPATCH4
(BinMul, BinaryOperator);
52
132
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
53
132
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
54
132
      
case BO_Add: 95
DISPATCH95
(BinAdd, BinaryOperator);
55
132
      
case BO_Sub: 7
DISPATCH7
(BinSub, BinaryOperator);
56
132
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
57
132
      
case BO_Shr: 1
DISPATCH1
(BinShr, BinaryOperator);
58
132
59
132
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
60
132
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
61
132
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
62
132
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
63
132
      
case BO_EQ: 12
DISPATCH12
(BinEQ, BinaryOperator);
64
132
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
65
132
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
66
132
67
132
      
case BO_And: 1
DISPATCH1
(BinAnd, BinaryOperator);
68
132
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
69
132
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
70
132
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
71
132
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
72
132
      
case BO_Assign: 5
DISPATCH5
(BinAssign, BinaryOperator);
73
132
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
74
132
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
75
132
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
76
132
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
77
132
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
78
132
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
79
132
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
80
132
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
81
132
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
82
132
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
83
132
      
case BO_Comma: 7
DISPATCH7
(BinComma, BinaryOperator);
84
38.4k
      }
85
38.4k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
50
      switch (UnOp->getOpcode()) {
87
50
      
case UO_PostInc: 1
DISPATCH1
(UnaryPostInc, UnaryOperator);
88
50
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
89
50
      
case UO_PreInc: 2
DISPATCH2
(UnaryPreInc, UnaryOperator);
90
50
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
91
50
      
case UO_AddrOf: 29
DISPATCH29
(UnaryAddrOf, UnaryOperator);
92
50
      
case UO_Deref: 15
DISPATCH15
(UnaryDeref, UnaryOperator);
93
50
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
94
50
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
95
50
      
case UO_Not: 3
DISPATCH3
(UnaryNot, UnaryOperator);
96
50
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
97
50
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
98
50
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
99
50
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
100
50
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
101
38.4k
      }
102
38.4k
    }
103
38.4k
104
38.4k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
38.4k
    switch (S->getStmtClass()) {
106
38.4k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
107
38.4k
#define ABSTRACT_STMT(STMT)
108
38.4k
#define STMT(CLASS, PARENT)                              \
109
38.4k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
38.4k
#include 
"clang/AST/StmtNodes.inc"0
111
38.4k
    }
112
38.4k
  }
CGExprScalar.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::ScalarExprEmitter, llvm::Value*>::Visit(clang::Stmt*)
Line
Count
Source
43
12.7M
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
12.7M
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
12.7M
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
12.7M
    // below.
47
12.7M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
1.30M
      switch (BinOp->getOpcode()) {
49
1.30M
      
case BO_PtrMemD: 22
DISPATCH22
(BinPtrMemD, BinaryOperator);
50
1.30M
      
case BO_PtrMemI: 15
DISPATCH15
(BinPtrMemI, BinaryOperator);
51
1.30M
      
case BO_Mul: 87.2k
DISPATCH87.2k
(BinMul, BinaryOperator);
52
1.30M
      
case BO_Div: 47.5k
DISPATCH47.5k
(BinDiv, BinaryOperator);
53
1.30M
      
case BO_Rem: 4.80k
DISPATCH4.80k
(BinRem, BinaryOperator);
54
1.30M
      
case BO_Add: 178k
DISPATCH178k
(BinAdd, BinaryOperator);
55
1.30M
      
case BO_Sub: 191k
DISPATCH191k
(BinSub, BinaryOperator);
56
1.30M
      
case BO_Shl: 46.7k
DISPATCH46.7k
(BinShl, BinaryOperator);
57
1.30M
      
case BO_Shr: 31.3k
DISPATCH31.3k
(BinShr, BinaryOperator);
58
1.30M
59
1.30M
      
case BO_LT: 68.6k
DISPATCH68.6k
(BinLT, BinaryOperator);
60
1.30M
      
case BO_GT: 45.1k
DISPATCH45.1k
(BinGT, BinaryOperator);
61
1.30M
      
case BO_LE: 22.4k
DISPATCH22.4k
(BinLE, BinaryOperator);
62
1.30M
      
case BO_GE: 18.8k
DISPATCH18.8k
(BinGE, BinaryOperator);
63
1.30M
      
case BO_EQ: 105k
DISPATCH105k
(BinEQ, BinaryOperator);
64
1.30M
      
case BO_NE: 56.2k
DISPATCH56.2k
(BinNE, BinaryOperator);
65
1.30M
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
66
1.30M
67
1.30M
      
case BO_And: 39.3k
DISPATCH39.3k
(BinAnd, BinaryOperator);
68
1.30M
      
case BO_Xor: 11.1k
DISPATCH11.1k
(BinXor, BinaryOperator);
69
1.30M
      
case BO_Or : 17.4k
DISPATCH17.4k
(BinOr, BinaryOperator);
70
1.30M
      
case BO_LAnd: 8.65k
DISPATCH8.65k
(BinLAnd, BinaryOperator);
71
1.30M
      
case BO_LOr : 3.15k
DISPATCH3.15k
(BinLOr, BinaryOperator);
72
1.30M
      
case BO_Assign: 270k
DISPATCH270k
(BinAssign, BinaryOperator);
73
1.30M
      
case BO_MulAssign: 996
DISPATCH996
(BinMulAssign, CompoundAssignOperator);
74
1.30M
      
case BO_DivAssign: 498
DISPATCH498
(BinDivAssign, CompoundAssignOperator);
75
1.30M
      
case BO_RemAssign: 149
DISPATCH149
(BinRemAssign, CompoundAssignOperator);
76
1.30M
      
case BO_AddAssign: 18.5k
DISPATCH18.5k
(BinAddAssign, CompoundAssignOperator);
77
1.30M
      
case BO_SubAssign: 3.20k
DISPATCH3.20k
(BinSubAssign, CompoundAssignOperator);
78
1.30M
      
case BO_ShlAssign: 1.42k
DISPATCH1.42k
(BinShlAssign, CompoundAssignOperator);
79
1.30M
      
case BO_ShrAssign: 1.26k
DISPATCH1.26k
(BinShrAssign, CompoundAssignOperator);
80
1.30M
      
case BO_AndAssign: 976
DISPATCH976
(BinAndAssign, CompoundAssignOperator);
81
1.30M
      
case BO_OrAssign: 3.77k
DISPATCH3.77k
(BinOrAssign, CompoundAssignOperator);
82
1.30M
      
case BO_XorAssign: 999
DISPATCH999
(BinXorAssign, CompoundAssignOperator);
83
1.30M
      
case BO_Comma: 14.5k
DISPATCH14.5k
(BinComma, BinaryOperator);
84
11.4M
      }
85
11.4M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
397k
      switch (UnOp->getOpcode()) {
87
397k
      
case UO_PostInc: 49.1k
DISPATCH49.1k
(UnaryPostInc, UnaryOperator);
88
397k
      
case UO_PostDec: 4.54k
DISPATCH4.54k
(UnaryPostDec, UnaryOperator);
89
397k
      
case UO_PreInc: 4.28k
DISPATCH4.28k
(UnaryPreInc, UnaryOperator);
90
397k
      
case UO_PreDec: 3.61k
DISPATCH3.61k
(UnaryPreDec, UnaryOperator);
91
397k
      
case UO_AddrOf: 108k
DISPATCH108k
(UnaryAddrOf, UnaryOperator);
92
397k
      
case UO_Deref: 32.7k
DISPATCH32.7k
(UnaryDeref, UnaryOperator);
93
397k
      
case UO_Plus: 182
DISPATCH182
(UnaryPlus, UnaryOperator);
94
397k
      
case UO_Minus: 36.1k
DISPATCH36.1k
(UnaryMinus, UnaryOperator);
95
397k
      
case UO_Not: 8.31k
DISPATCH8.31k
(UnaryNot, UnaryOperator);
96
397k
      
case UO_LNot: 139k
DISPATCH139k
(UnaryLNot, UnaryOperator);
97
397k
      
case UO_Real: 362
DISPATCH362
(UnaryReal, UnaryOperator);
98
397k
      
case UO_Imag: 349
DISPATCH349
(UnaryImag, UnaryOperator);
99
397k
      
case UO_Extension: 9.48k
DISPATCH9.48k
(UnaryExtension, UnaryOperator);
100
397k
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
101
11.0M
      }
102
11.0M
    }
103
11.0M
104
11.0M
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
11.0M
    switch (S->getStmtClass()) {
106
11.0M
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
107
11.0M
#define ABSTRACT_STMT(STMT)
108
11.0M
#define STMT(CLASS, PARENT)                              \
109
11.0M
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
11.0M
#include 
"clang/AST/StmtNodes.inc"0
111
11.0M
    }
112
11.0M
  }
CGOpenMPRuntimeNVPTX.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::CheckVarsEscapingDeclContext, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
1.54k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
1.54k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
1.54k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
1.54k
    // below.
47
1.54k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
205
      switch (BinOp->getOpcode()) {
49
205
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
50
205
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
51
205
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
52
205
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
53
205
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
54
205
      
case BO_Add: 35
DISPATCH35
(BinAdd, BinaryOperator);
55
205
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
56
205
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
57
205
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
58
205
59
205
      
case BO_LT: 7
DISPATCH7
(BinLT, BinaryOperator);
60
205
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
61
205
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
62
205
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
63
205
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
64
205
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
65
205
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
66
205
67
205
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
68
205
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
69
205
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
70
205
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
71
205
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
72
205
      
case BO_Assign: 68
DISPATCH68
(BinAssign, BinaryOperator);
73
205
      
case BO_MulAssign: 3
DISPATCH3
(BinMulAssign, CompoundAssignOperator);
74
205
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
75
205
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
76
205
      
case BO_AddAssign: 89
DISPATCH89
(BinAddAssign, CompoundAssignOperator);
77
205
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
78
205
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
79
205
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
80
205
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
81
205
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
82
205
      
case BO_XorAssign: 3
DISPATCH3
(BinXorAssign, CompoundAssignOperator);
83
205
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
84
1.33k
      }
85
1.33k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
42
      switch (UnOp->getOpcode()) {
87
42
      
case UO_PostInc: 5
DISPATCH5
(UnaryPostInc, UnaryOperator);
88
42
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
89
42
      
case UO_PreInc: 15
DISPATCH15
(UnaryPreInc, UnaryOperator);
90
42
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
91
42
      
case UO_AddrOf: 16
DISPATCH16
(UnaryAddrOf, UnaryOperator);
92
42
      
case UO_Deref: 6
DISPATCH6
(UnaryDeref, UnaryOperator);
93
42
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
94
42
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
95
42
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
96
42
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
97
42
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
98
42
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
99
42
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
100
42
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
101
1.29k
      }
102
1.29k
    }
103
1.29k
104
1.29k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
1.29k
    switch (S->getStmtClass()) {
106
1.29k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
107
1.29k
#define ABSTRACT_STMT(STMT)
108
1.29k
#define STMT(CLASS, PARENT)                              \
109
1.29k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
1.29k
#include 
"clang/AST/StmtNodes.inc"0
111
1.29k
    }
112
1.29k
  }
CodeGenPGO.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::ComputeRegionCounts, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
3.30k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
3.30k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
3.30k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
3.30k
    // below.
47
3.30k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
310
      switch (BinOp->getOpcode()) {
49
310
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
50
310
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
51
310
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
52
310
      
case BO_Div: 4
DISPATCH4
(BinDiv, BinaryOperator);
53
310
      
case BO_Rem: 33
DISPATCH33
(BinRem, BinaryOperator);
54
310
      
case BO_Add: 16
DISPATCH16
(BinAdd, BinaryOperator);
55
310
      
case BO_Sub: 10
DISPATCH10
(BinSub, BinaryOperator);
56
310
      
case BO_Shl: 3
DISPATCH3
(BinShl, BinaryOperator);
57
310
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
58
310
59
310
      
case BO_LT: 83
DISPATCH83
(BinLT, BinaryOperator);
60
310
      
case BO_GT: 22
DISPATCH22
(BinGT, BinaryOperator);
61
310
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
62
310
      
case BO_GE: 1
DISPATCH1
(BinGE, BinaryOperator);
63
310
      
case BO_EQ: 5
DISPATCH5
(BinEQ, BinaryOperator);
64
310
      
case BO_NE: 9
DISPATCH9
(BinNE, BinaryOperator);
65
310
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
66
310
67
310
      
case BO_And: 2
DISPATCH2
(BinAnd, BinaryOperator);
68
310
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
69
310
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
70
310
      
case BO_LAnd: 19
DISPATCH19
(BinLAnd, BinaryOperator);
71
310
      
case BO_LOr : 18
DISPATCH18
(BinLOr, BinaryOperator);
72
310
      
case BO_Assign: 76
DISPATCH76
(BinAssign, BinaryOperator);
73
310
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
74
310
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
75
310
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
76
310
      
case BO_AddAssign: 9
DISPATCH9
(BinAddAssign, CompoundAssignOperator);
77
310
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
78
310
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
79
310
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
80
310
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
81
310
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
82
310
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
83
310
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
84
2.99k
      }
85
2.99k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
142
      switch (UnOp->getOpcode()) {
87
142
      
case UO_PostInc: 27
DISPATCH27
(UnaryPostInc, UnaryOperator);
88
142
      
case UO_PostDec: 9
DISPATCH9
(UnaryPostDec, UnaryOperator);
89
142
      
case UO_PreInc: 82
DISPATCH82
(UnaryPreInc, UnaryOperator);
90
142
      
case UO_PreDec: 8
DISPATCH8
(UnaryPreDec, UnaryOperator);
91
142
      
case UO_AddrOf: 0
DISPATCH0
(UnaryAddrOf, UnaryOperator);
92
142
      
case UO_Deref: 9
DISPATCH9
(UnaryDeref, UnaryOperator);
93
142
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
94
142
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
95
142
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
96
142
      
case UO_LNot: 7
DISPATCH7
(UnaryLNot, UnaryOperator);
97
142
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
98
142
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
99
142
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
100
142
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
101
2.85k
      }
102
2.85k
    }
103
2.85k
104
2.85k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
2.85k
    switch (S->getStmtClass()) {
106
2.85k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
107
2.85k
#define ABSTRACT_STMT(STMT)
108
2.85k
#define STMT(CLASS, PARENT)                              \
109
2.85k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
2.85k
#include 
"clang/AST/StmtNodes.inc"0
111
2.85k
    }
112
2.85k
  }
CoverageMappingGen.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::CounterCoverageMappingBuilder, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
2.59k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
2.59k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
2.59k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
2.59k
    // below.
47
2.59k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
226
      switch (BinOp->getOpcode()) {
49
226
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
50
226
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
51
226
      
case BO_Mul: 3
DISPATCH3
(BinMul, BinaryOperator);
52
226
      
case BO_Div: 1
DISPATCH1
(BinDiv, BinaryOperator);
53
226
      
case BO_Rem: 3
DISPATCH3
(BinRem, BinaryOperator);
54
226
      
case BO_Add: 12
DISPATCH12
(BinAdd, BinaryOperator);
55
226
      
case BO_Sub: 2
DISPATCH2
(BinSub, BinaryOperator);
56
226
      
case BO_Shl: 1
DISPATCH1
(BinShl, BinaryOperator);
57
226
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
58
226
59
226
      
case BO_LT: 43
DISPATCH43
(BinLT, BinaryOperator);
60
226
      
case BO_GT: 4
DISPATCH4
(BinGT, BinaryOperator);
61
226
      
case BO_LE: 1
DISPATCH1
(BinLE, BinaryOperator);
62
226
      
case BO_GE: 2
DISPATCH2
(BinGE, BinaryOperator);
63
226
      
case BO_EQ: 39
DISPATCH39
(BinEQ, BinaryOperator);
64
226
      
case BO_NE: 3
DISPATCH3
(BinNE, BinaryOperator);
65
226
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
66
226
67
226
      
case BO_And: 2
DISPATCH2
(BinAnd, BinaryOperator);
68
226
      
case BO_Xor: 1
DISPATCH1
(BinXor, BinaryOperator);
69
226
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
70
226
      
case BO_LAnd: 3
DISPATCH3
(BinLAnd, BinaryOperator);
71
226
      
case BO_LOr : 5
DISPATCH5
(BinLOr, BinaryOperator);
72
226
      
case BO_Assign: 98
DISPATCH98
(BinAssign, BinaryOperator);
73
226
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
74
226
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
75
226
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
76
226
      
case BO_AddAssign: 1
DISPATCH1
(BinAddAssign, CompoundAssignOperator);
77
226
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
78
226
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
79
226
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
80
226
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
81
226
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
82
226
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
83
226
      
case BO_Comma: 2
DISPATCH2
(BinComma, BinaryOperator);
84
2.36k
      }
85
2.36k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
59
      switch (UnOp->getOpcode()) {
87
59
      
case UO_PostInc: 3
DISPATCH3
(UnaryPostInc, UnaryOperator);
88
59
      
case UO_PostDec: 1
DISPATCH1
(UnaryPostDec, UnaryOperator);
89
59
      
case UO_PreInc: 40
DISPATCH40
(UnaryPreInc, UnaryOperator);
90
59
      
case UO_PreDec: 2
DISPATCH2
(UnaryPreDec, UnaryOperator);
91
59
      
case UO_AddrOf: 0
DISPATCH0
(UnaryAddrOf, UnaryOperator);
92
59
      
case UO_Deref: 2
DISPATCH2
(UnaryDeref, UnaryOperator);
93
59
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
94
59
      
case UO_Minus: 1
DISPATCH1
(UnaryMinus, UnaryOperator);
95
59
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
96
59
      
case UO_LNot: 10
DISPATCH10
(UnaryLNot, UnaryOperator);
97
59
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
98
59
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
99
59
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
100
59
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
101
2.30k
      }
102
2.30k
    }
103
2.30k
104
2.30k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
2.30k
    switch (S->getStmtClass()) {
106
2.30k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
107
2.30k
#define ABSTRACT_STMT(STMT)
108
2.30k
#define STMT(CLASS, PARENT)                              \
109
2.30k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
2.30k
#include 
"clang/AST/StmtNodes.inc"0
111
2.30k
    }
112
2.30k
  }
TransEmptyStatementsAndDealloc.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::EmptyChecker, bool>::Visit(clang::Stmt*)
Line
Count
Source
43
1.07k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
1.07k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
1.07k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
1.07k
    // below.
47
1.07k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
67
      switch (BinOp->getOpcode()) {
49
67
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
50
67
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
51
67
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
52
67
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
53
67
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
54
67
      
case BO_Add: 0
DISPATCH0
(BinAdd, BinaryOperator);
55
67
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
56
67
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
57
67
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
58
67
59
67
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
60
67
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
61
67
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
62
67
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
63
67
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
64
67
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
65
67
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
66
67
67
67
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
68
67
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
69
67
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
70
67
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
71
67
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
72
67
      
case BO_Assign: 64
DISPATCH64
(BinAssign, BinaryOperator);
73
67
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
74
67
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
75
67
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
76
67
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
77
67
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
78
67
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
79
67
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
80
67
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
81
67
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
82
67
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
83
67
      
case BO_Comma: 3
DISPATCH3
(BinComma, BinaryOperator);
84
1.01k
      }
85
1.01k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
12
      switch (UnOp->getOpcode()) {
87
12
      
case UO_PostInc: 2
DISPATCH2
(UnaryPostInc, UnaryOperator);
88
12
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
89
12
      
case UO_PreInc: 10
DISPATCH10
(UnaryPreInc, UnaryOperator);
90
12
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
91
12
      
case UO_AddrOf: 0
DISPATCH0
(UnaryAddrOf, UnaryOperator);
92
12
      
case UO_Deref: 0
DISPATCH0
(UnaryDeref, UnaryOperator);
93
12
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
94
12
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
95
12
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
96
12
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
97
12
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
98
12
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
99
12
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
100
12
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
101
1.00k
      }
102
1.00k
    }
103
1.00k
104
1.00k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
1.00k
    switch (S->getStmtClass()) {
106
1.00k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
107
1.00k
#define ABSTRACT_STMT(STMT)
108
1.00k
#define STMT(CLASS, PARENT)                              \
109
1.00k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
1.00k
#include 
"clang/AST/StmtNodes.inc"0
111
1.00k
    }
112
1.00k
  }
CStringSyntaxChecker.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::WalkAST, void>::Visit(clang::Stmt*)
Line
Count
Source
43
37.3k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
37.3k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
37.3k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
37.3k
    // below.
47
37.3k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
2.03k
      switch (BinOp->getOpcode()) {
49
2.03k
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
50
2.03k
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
51
2.03k
      
case BO_Mul: 116
DISPATCH116
(BinMul, BinaryOperator);
52
2.03k
      
case BO_Div: 26
DISPATCH26
(BinDiv, BinaryOperator);
53
2.03k
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
54
2.03k
      
case BO_Add: 218
DISPATCH218
(BinAdd, BinaryOperator);
55
2.03k
      
case BO_Sub: 50
DISPATCH50
(BinSub, BinaryOperator);
56
2.03k
      
case BO_Shl: 2
DISPATCH2
(BinShl, BinaryOperator);
57
2.03k
      
case BO_Shr: 2
DISPATCH2
(BinShr, BinaryOperator);
58
2.03k
59
2.03k
      
case BO_LT: 169
DISPATCH169
(BinLT, BinaryOperator);
60
2.03k
      
case BO_GT: 102
DISPATCH102
(BinGT, BinaryOperator);
61
2.03k
      
case BO_LE: 43
DISPATCH43
(BinLE, BinaryOperator);
62
2.03k
      
case BO_GE: 103
DISPATCH103
(BinGE, BinaryOperator);
63
2.03k
      
case BO_EQ: 921
DISPATCH921
(BinEQ, BinaryOperator);
64
2.03k
      
case BO_NE: 86
DISPATCH86
(BinNE, BinaryOperator);
65
2.03k
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
66
2.03k
67
2.03k
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
68
2.03k
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
69
2.03k
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
70
2.03k
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
71
2.03k
      
case BO_LOr : 1
DISPATCH1
(BinLOr, BinaryOperator);
72
2.03k
      
case BO_Assign: 173
DISPATCH173
(BinAssign, BinaryOperator);
73
2.03k
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
74
2.03k
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
75
2.03k
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
76
2.03k
      
case BO_AddAssign: 13
DISPATCH13
(BinAddAssign, CompoundAssignOperator);
77
2.03k
      
case BO_SubAssign: 5
DISPATCH5
(BinSubAssign, CompoundAssignOperator);
78
2.03k
      
case BO_ShlAssign: 4
DISPATCH4
(BinShlAssign, CompoundAssignOperator);
79
2.03k
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
80
2.03k
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
81
2.03k
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
82
2.03k
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
83
2.03k
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
84
35.2k
      }
85
35.2k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
533
      switch (UnOp->getOpcode()) {
87
533
      
case UO_PostInc: 38
DISPATCH38
(UnaryPostInc, UnaryOperator);
88
533
      
case UO_PostDec: 6
DISPATCH6
(UnaryPostDec, UnaryOperator);
89
533
      
case UO_PreInc: 0
DISPATCH0
(UnaryPreInc, UnaryOperator);
90
533
      
case UO_PreDec: 1
DISPATCH1
(UnaryPreDec, UnaryOperator);
91
533
      
case UO_AddrOf: 202
DISPATCH202
(UnaryAddrOf, UnaryOperator);
92
533
      
case UO_Deref: 43
DISPATCH43
(UnaryDeref, UnaryOperator);
93
533
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
94
533
      
case UO_Minus: 231
DISPATCH231
(UnaryMinus, UnaryOperator);
95
533
      
case UO_Not: 4
DISPATCH4
(UnaryNot, UnaryOperator);
96
533
      
case UO_LNot: 8
DISPATCH8
(UnaryLNot, UnaryOperator);
97
533
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
98
533
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
99
533
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
100
533
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
101
34.7k
      }
102
34.7k
    }
103
34.7k
104
34.7k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
34.7k
    switch (S->getStmtClass()) {
106
34.7k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
107
34.7k
#define ABSTRACT_STMT(STMT)
108
34.7k
#define STMT(CLASS, PARENT)                              \
109
34.7k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
34.7k
#include 
"clang/AST/StmtNodes.inc"0
111
34.7k
    }
112
34.7k
  }
CheckSecuritySyntaxOnly.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::WalkAST, void>::Visit(clang::Stmt*)
Line
Count
Source
43
3.32k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
3.32k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
3.32k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
3.32k
    // below.
47
3.32k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
140
      switch (BinOp->getOpcode()) {
49
140
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
50
140
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
51
140
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
52
140
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
53
140
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
54
140
      
case BO_Add: 8
DISPATCH8
(BinAdd, BinaryOperator);
55
140
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
56
140
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
57
140
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
58
140
59
140
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
60
140
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
61
140
      
case BO_LE: 56
DISPATCH56
(BinLE, BinaryOperator);
62
140
      
case BO_GE: 8
DISPATCH8
(BinGE, BinaryOperator);
63
140
      
case BO_EQ: 6
DISPATCH6
(BinEQ, BinaryOperator);
64
140
      
case BO_NE: 10
DISPATCH10
(BinNE, BinaryOperator);
65
140
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
66
140
67
140
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
68
140
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
69
140
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
70
140
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
71
140
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
72
140
      
case BO_Assign: 28
DISPATCH28
(BinAssign, BinaryOperator);
73
140
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
74
140
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
75
140
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
76
140
      
case BO_AddAssign: 16
DISPATCH16
(BinAddAssign, CompoundAssignOperator);
77
140
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
78
140
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
79
140
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
80
140
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
81
140
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
82
140
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
83
140
      
case BO_Comma: 8
DISPATCH8
(BinComma, BinaryOperator);
84
3.18k
      }
85
3.18k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
77
      switch (UnOp->getOpcode()) {
87
77
      
case UO_PostInc: 40
DISPATCH40
(UnaryPostInc, UnaryOperator);
88
77
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
89
77
      
case UO_PreInc: 8
DISPATCH8
(UnaryPreInc, UnaryOperator);
90
77
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
91
77
      
case UO_AddrOf: 9
DISPATCH9
(UnaryAddrOf, UnaryOperator);
92
77
      
case UO_Deref: 4
DISPATCH4
(UnaryDeref, UnaryOperator);
93
77
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
94
77
      
case UO_Minus: 16
DISPATCH16
(UnaryMinus, UnaryOperator);
95
77
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
96
77
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
97
77
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
98
77
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
99
77
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
100
77
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
101
3.11k
      }
102
3.11k
    }
103
3.11k
104
3.11k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
3.11k
    switch (S->getStmtClass()) {
106
3.11k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
107
3.11k
#define ABSTRACT_STMT(STMT)
108
3.11k
#define STMT(CLASS, PARENT)                              \
109
3.11k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
3.11k
#include 
"clang/AST/StmtNodes.inc"0
111
3.11k
    }
112
3.11k
  }
CheckSizeofPointer.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::WalkAST, void>::Visit(clang::Stmt*)
Line
Count
Source
43
19.4k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
19.4k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
19.4k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
19.4k
    // below.
47
19.4k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
1.19k
      switch (BinOp->getOpcode()) {
49
1.19k
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
50
1.19k
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
51
1.19k
      
case BO_Mul: 1
DISPATCH1
(BinMul, BinaryOperator);
52
1.19k
      
case BO_Div: 15
DISPATCH15
(BinDiv, BinaryOperator);
53
1.19k
      
case BO_Rem: 6
DISPATCH6
(BinRem, BinaryOperator);
54
1.19k
      
case BO_Add: 44
DISPATCH44
(BinAdd, BinaryOperator);
55
1.19k
      
case BO_Sub: 20
DISPATCH20
(BinSub, BinaryOperator);
56
1.19k
      
case BO_Shl: 14
DISPATCH14
(BinShl, BinaryOperator);
57
1.19k
      
case BO_Shr: 2
DISPATCH2
(BinShr, BinaryOperator);
58
1.19k
59
1.19k
      
case BO_LT: 47
DISPATCH47
(BinLT, BinaryOperator);
60
1.19k
      
case BO_GT: 14
DISPATCH14
(BinGT, BinaryOperator);
61
1.19k
      
case BO_LE: 2
DISPATCH2
(BinLE, BinaryOperator);
62
1.19k
      
case BO_GE: 3
DISPATCH3
(BinGE, BinaryOperator);
63
1.19k
      
case BO_EQ: 344
DISPATCH344
(BinEQ, BinaryOperator);
64
1.19k
      
case BO_NE: 99
DISPATCH99
(BinNE, BinaryOperator);
65
1.19k
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
66
1.19k
67
1.19k
      
case BO_And: 10
DISPATCH10
(BinAnd, BinaryOperator);
68
1.19k
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
69
1.19k
      
case BO_Or : 5
DISPATCH5
(BinOr, BinaryOperator);
70
1.19k
      
case BO_LAnd: 31
DISPATCH31
(BinLAnd, BinaryOperator);
71
1.19k
      
case BO_LOr : 8
DISPATCH8
(BinLOr, BinaryOperator);
72
1.19k
      
case BO_Assign: 480
DISPATCH480
(BinAssign, BinaryOperator);
73
1.19k
      
case BO_MulAssign: 8
DISPATCH8
(BinMulAssign, CompoundAssignOperator);
74
1.19k
      
case BO_DivAssign: 12
DISPATCH12
(BinDivAssign, CompoundAssignOperator);
75
1.19k
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
76
1.19k
      
case BO_AddAssign: 11
DISPATCH11
(BinAddAssign, CompoundAssignOperator);
77
1.19k
      
case BO_SubAssign: 2
DISPATCH2
(BinSubAssign, CompoundAssignOperator);
78
1.19k
      
case BO_ShlAssign: 2
DISPATCH2
(BinShlAssign, CompoundAssignOperator);
79
1.19k
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
80
1.19k
      
case BO_AndAssign: 6
DISPATCH6
(BinAndAssign, CompoundAssignOperator);
81
1.19k
      
case BO_OrAssign: 3
DISPATCH3
(BinOrAssign, CompoundAssignOperator);
82
1.19k
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
83
1.19k
      
case BO_Comma: 7
DISPATCH7
(BinComma, BinaryOperator);
84
18.2k
      }
85
18.2k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
768
      switch (UnOp->getOpcode()) {
87
768
      
case UO_PostInc: 44
DISPATCH44
(UnaryPostInc, UnaryOperator);
88
768
      
case UO_PostDec: 7
DISPATCH7
(UnaryPostDec, UnaryOperator);
89
768
      
case UO_PreInc: 36
DISPATCH36
(UnaryPreInc, UnaryOperator);
90
768
      
case UO_PreDec: 4
DISPATCH4
(UnaryPreDec, UnaryOperator);
91
768
      
case UO_AddrOf: 180
DISPATCH180
(UnaryAddrOf, UnaryOperator);
92
768
      
case UO_Deref: 310
DISPATCH310
(UnaryDeref, UnaryOperator);
93
768
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
94
768
      
case UO_Minus: 18
DISPATCH18
(UnaryMinus, UnaryOperator);
95
768
      
case UO_Not: 10
DISPATCH10
(UnaryNot, UnaryOperator);
96
768
      
case UO_LNot: 145
DISPATCH145
(UnaryLNot, UnaryOperator);
97
768
      
case UO_Real: 6
DISPATCH6
(UnaryReal, UnaryOperator);
98
768
      
case UO_Imag: 4
DISPATCH4
(UnaryImag, UnaryOperator);
99
768
      
case UO_Extension: 4
DISPATCH4
(UnaryExtension, UnaryOperator);
100
768
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
101
17.4k
      }
102
17.4k
    }
103
17.4k
104
17.4k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
17.4k
    switch (S->getStmtClass()) {
106
17.4k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
107
17.4k
#define ABSTRACT_STMT(STMT)
108
17.4k
#define STMT(CLASS, PARENT)                              \
109
17.4k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
17.4k
#include 
"clang/AST/StmtNodes.inc"0
111
17.4k
    }
112
17.4k
  }
DirectIvarAssignment.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::DirectIvarAssignment::MethodCrawler, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
19
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
19
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
19
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
19
    // below.
47
19
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
14
      switch (BinOp->getOpcode()) {
49
14
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
50
14
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
51
14
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
52
14
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
53
14
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
54
14
      
case BO_Add: 0
DISPATCH0
(BinAdd, BinaryOperator);
55
14
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
56
14
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
57
14
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
58
14
59
14
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
60
14
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
61
14
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
62
14
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
63
14
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
64
14
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
65
14
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
66
14
67
14
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
68
14
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
69
14
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
70
14
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
71
14
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
72
14
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
14
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
74
14
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
75
14
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
76
14
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
77
14
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
78
14
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
79
14
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
80
14
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
81
14
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
82
14
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
83
14
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
84
5
      }
85
5
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
0
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
5
      }
102
5
    }
103
5
104
5
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
5
    switch (S->getStmtClass()) {
106
5
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
107
5
#define ABSTRACT_STMT(STMT)
108
5
#define STMT(CLASS, PARENT)                              \
109
5
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
5
#include 
"clang/AST/StmtNodes.inc"0
111
5
    }
112
5
  }
IvarInvalidationChecker.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::IvarInvalidationCheckerImpl::MethodCrawler, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
408
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
408
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
408
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
408
    // below.
47
408
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
19
      switch (BinOp->getOpcode()) {
49
19
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
50
19
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
51
19
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
52
19
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
53
19
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
54
19
      
case BO_Add: 0
DISPATCH0
(BinAdd, BinaryOperator);
55
19
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
56
19
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
57
19
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
58
19
59
19
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
60
19
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
61
19
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
62
19
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
63
19
      
case BO_EQ: 3
DISPATCH3
(BinEQ, BinaryOperator);
64
19
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
65
19
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
66
19
67
19
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
68
19
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
69
19
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
70
19
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
71
19
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
72
19
      
case BO_Assign: 16
DISPATCH16
(BinAssign, BinaryOperator);
73
19
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
74
19
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
75
19
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
76
19
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
77
19
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
78
19
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
79
19
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
80
19
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
81
19
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
82
19
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
83
19
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
84
389
      }
85
389
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
1
      switch (UnOp->getOpcode()) {
87
1
      
case UO_PostInc: 0
DISPATCH0
(UnaryPostInc, UnaryOperator);
88
1
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
89
1
      
case UO_PreInc: 0
DISPATCH0
(UnaryPreInc, UnaryOperator);
90
1
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
91
1
      
case UO_AddrOf: 0
DISPATCH0
(UnaryAddrOf, UnaryOperator);
92
1
      
case UO_Deref: 0
DISPATCH0
(UnaryDeref, UnaryOperator);
93
1
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
94
1
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
95
1
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
96
1
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
1
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
98
1
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
99
1
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
100
1
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
101
388
      }
102
388
    }
103
388
104
388
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
388
    switch (S->getStmtClass()) {
106
388
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
107
388
#define ABSTRACT_STMT(STMT)
108
388
#define STMT(CLASS, PARENT)                              \
109
388
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
388
#include 
"clang/AST/StmtNodes.inc"0
111
388
    }
112
388
  }
LLVMConventionsChecker.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::StringRefCheckerVisitor, void>::Visit(clang::Stmt*)
Line
Count
Source
43
192
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
192
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
192
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
192
    // below.
47
192
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
22
      switch (BinOp->getOpcode()) {
49
22
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
50
22
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
51
22
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
52
22
      
case BO_Div: 3
DISPATCH3
(BinDiv, BinaryOperator);
53
22
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
54
22
      
case BO_Add: 0
DISPATCH0
(BinAdd, BinaryOperator);
55
22
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
56
22
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
57
22
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
58
22
59
22
      
case BO_LT: 3
DISPATCH3
(BinLT, BinaryOperator);
60
22
      
case BO_GT: 2
DISPATCH2
(BinGT, BinaryOperator);
61
22
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
62
22
      
case BO_GE: 1
DISPATCH1
(BinGE, BinaryOperator);
63
22
      
case BO_EQ: 3
DISPATCH3
(BinEQ, BinaryOperator);
64
22
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
65
22
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
66
22
67
22
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
68
22
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
69
22
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
70
22
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
71
22
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
72
22
      
case BO_Assign: 7
DISPATCH7
(BinAssign, BinaryOperator);
73
22
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
74
22
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
75
22
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
76
22
      
case BO_AddAssign: 1
DISPATCH1
(BinAddAssign, CompoundAssignOperator);
77
22
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
78
22
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
79
22
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
80
22
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
81
22
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
82
22
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
83
22
      
case BO_Comma: 2
DISPATCH2
(BinComma, BinaryOperator);
84
170
      }
85
170
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
9
      switch (UnOp->getOpcode()) {
87
9
      
case UO_PostInc: 0
DISPATCH0
(UnaryPostInc, UnaryOperator);
88
9
      
case UO_PostDec: 3
DISPATCH3
(UnaryPostDec, UnaryOperator);
89
9
      
case UO_PreInc: 4
DISPATCH4
(UnaryPreInc, UnaryOperator);
90
9
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
91
9
      
case UO_AddrOf: 0
DISPATCH0
(UnaryAddrOf, UnaryOperator);
92
9
      
case UO_Deref: 2
DISPATCH2
(UnaryDeref, UnaryOperator);
93
9
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
94
9
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
95
9
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
96
9
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
97
9
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
98
9
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
99
9
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
100
9
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
101
161
      }
102
161
    }
103
161
104
161
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
161
    switch (S->getStmtClass()) {
106
161
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
107
161
#define ABSTRACT_STMT(STMT)
108
161
#define STMT(CLASS, PARENT)                              \
109
161
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
161
#include 
"clang/AST/StmtNodes.inc"0
111
161
    }
112
161
  }
LocalizationChecker.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::EmptyLocalizationContextChecker::MethodCrawler, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
171
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
171
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
171
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
171
    // below.
47
171
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
4
      switch (BinOp->getOpcode()) {
49
4
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
50
4
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
51
4
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
52
4
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
53
4
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
54
4
      
case BO_Add: 0
DISPATCH0
(BinAdd, BinaryOperator);
55
4
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
56
4
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
57
4
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
58
4
59
4
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
60
4
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
61
4
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
62
4
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
63
4
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
64
4
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
65
4
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
66
4
67
4
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
68
4
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
69
4
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
70
4
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
71
4
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
72
4
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
4
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
74
4
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
75
4
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
76
4
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
77
4
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
78
4
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
79
4
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
80
4
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
81
4
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
82
4
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
83
4
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
84
167
      }
85
167
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
0
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
167
      }
102
167
    }
103
167
104
167
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
167
    switch (S->getStmtClass()) {
106
167
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
107
167
#define ABSTRACT_STMT(STMT)
108
167
#define STMT(CLASS, PARENT)                              \
109
167
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
167
#include 
"clang/AST/StmtNodes.inc"0
111
167
    }
112
167
  }
MallocOverflowSecurityChecker.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::CheckOverflowOps, void>::Visit(clang::Stmt*)
Line
Count
Source
43
445
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
445
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
445
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
445
    // below.
47
445
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
52
      switch (BinOp->getOpcode()) {
49
52
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
50
52
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
51
52
      
case BO_Mul: 21
DISPATCH21
(BinMul, BinaryOperator);
52
52
      
case BO_Div: 4
DISPATCH4
(BinDiv, BinaryOperator);
53
52
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
54
52
      
case BO_Add: 5
DISPATCH5
(BinAdd, BinaryOperator);
55
52
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
56
52
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
57
52
      
case BO_Shr: 2
DISPATCH2
(BinShr, BinaryOperator);
58
52
59
52
      
case BO_LT: 2
DISPATCH2
(BinLT, BinaryOperator);
60
52
      
case BO_GT: 3
DISPATCH3
(BinGT, BinaryOperator);
61
52
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
62
52
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
63
52
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
64
52
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
65
52
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
66
52
67
52
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
68
52
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
69
52
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
70
52
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
71
52
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
72
52
      
case BO_Assign: 15
DISPATCH15
(BinAssign, BinaryOperator);
73
52
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
74
52
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
75
52
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
76
52
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
77
52
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
78
52
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
79
52
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
80
52
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
81
52
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
82
52
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
83
52
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
84
393
      }
85
393
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
3
      switch (UnOp->getOpcode()) {
87
3
      
case UO_PostInc: 2
DISPATCH2
(UnaryPostInc, UnaryOperator);
88
3
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
89
3
      
case UO_PreInc: 0
DISPATCH0
(UnaryPreInc, UnaryOperator);
90
3
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
91
3
      
case UO_AddrOf: 0
DISPATCH0
(UnaryAddrOf, UnaryOperator);
92
3
      
case UO_Deref: 1
DISPATCH1
(UnaryDeref, UnaryOperator);
93
3
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
94
3
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
95
3
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
96
3
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
97
3
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
98
3
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
99
3
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
100
3
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
101
390
      }
102
390
    }
103
390
104
390
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
390
    switch (S->getStmtClass()) {
106
390
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
107
390
#define ABSTRACT_STMT(STMT)
108
390
#define STMT(CLASS, PARENT)                              \
109
390
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
390
#include 
"clang/AST/StmtNodes.inc"0
111
390
    }
112
390
  }
MallocSizeofChecker.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::CastedAllocFinder, std::__1::pair<clang::TypeSourceInfo const*, clang::CallExpr const*> >::Visit(clang::Stmt const*)
Line
Count
Source
43
2.40k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
2.40k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
2.40k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
2.40k
    // below.
47
2.40k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
178
      switch (BinOp->getOpcode()) {
49
178
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
50
178
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
51
178
      
case BO_Mul: 19
DISPATCH19
(BinMul, BinaryOperator);
52
178
      
case BO_Div: 12
DISPATCH12
(BinDiv, BinaryOperator);
53
178
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
54
178
      
case BO_Add: 29
DISPATCH29
(BinAdd, BinaryOperator);
55
178
      
case BO_Sub: 4
DISPATCH4
(BinSub, BinaryOperator);
56
178
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
57
178
      
case BO_Shr: 2
DISPATCH2
(BinShr, BinaryOperator);
58
178
59
178
      
case BO_LT: 9
DISPATCH9
(BinLT, BinaryOperator);
60
178
      
case BO_GT: 1
DISPATCH1
(BinGT, BinaryOperator);
61
178
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
62
178
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
63
178
      
case BO_EQ: 11
DISPATCH11
(BinEQ, BinaryOperator);
64
178
      
case BO_NE: 1
DISPATCH1
(BinNE, BinaryOperator);
65
178
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
66
178
67
178
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
68
178
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
69
178
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
70
178
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
71
178
      
case BO_LOr : 1
DISPATCH1
(BinLOr, BinaryOperator);
72
178
      
case BO_Assign: 80
DISPATCH80
(BinAssign, BinaryOperator);
73
178
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
74
178
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
75
178
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
76
178
      
case BO_AddAssign: 4
DISPATCH4
(BinAddAssign, CompoundAssignOperator);
77
178
      
case BO_SubAssign: 5
DISPATCH5
(BinSubAssign, CompoundAssignOperator);
78
178
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
79
178
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
80
178
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
81
178
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
82
178
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
83
178
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
84
2.22k
      }
85
2.22k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
77
      switch (UnOp->getOpcode()) {
87
77
      
case UO_PostInc: 38
DISPATCH38
(UnaryPostInc, UnaryOperator);
88
77
      
case UO_PostDec: 6
DISPATCH6
(UnaryPostDec, UnaryOperator);
89
77
      
case UO_PreInc: 0
DISPATCH0
(UnaryPreInc, UnaryOperator);
90
77
      
case UO_PreDec: 1
DISPATCH1
(UnaryPreDec, UnaryOperator);
91
77
      
case UO_AddrOf: 3
DISPATCH3
(UnaryAddrOf, UnaryOperator);
92
77
      
case UO_Deref: 22
DISPATCH22
(UnaryDeref, UnaryOperator);
93
77
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
94
77
      
case UO_Minus: 5
DISPATCH5
(UnaryMinus, UnaryOperator);
95
77
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
96
77
      
case UO_LNot: 2
DISPATCH2
(UnaryLNot, UnaryOperator);
97
77
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
98
77
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
99
77
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
100
77
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
101
2.14k
      }
102
2.14k
    }
103
2.14k
104
2.14k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
2.14k
    switch (S->getStmtClass()) {
106
2.14k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
107
2.14k
#define ABSTRACT_STMT(STMT)
108
2.14k
#define STMT(CLASS, PARENT)                              \
109
2.14k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
2.14k
#include 
"clang/AST/StmtNodes.inc"0
111
2.14k
    }
112
2.14k
  }
MallocSizeofChecker.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::SizeofFinder, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
109
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
109
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
109
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
109
    // below.
47
109
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
12
      switch (BinOp->getOpcode()) {
49
12
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
50
12
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
51
12
      
case BO_Mul: 10
DISPATCH10
(BinMul, BinaryOperator);
52
12
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
53
12
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
54
12
      
case BO_Add: 2
DISPATCH2
(BinAdd, BinaryOperator);
55
12
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
56
12
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
57
12
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
58
12
59
12
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
60
12
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
61
12
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
62
12
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
63
12
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
64
12
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
65
12
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
66
12
67
12
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
68
12
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
69
12
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
70
12
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
71
12
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
72
12
      
case BO_Assign: 0
DISPATCH0
(BinAssign, BinaryOperator);
73
12
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
74
12
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
75
12
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
76
12
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
77
12
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
78
12
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
79
12
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
80
12
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
81
12
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
82
12
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
83
12
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
84
97
      }
85
97
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
0
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
97
      }
102
97
    }
103
97
104
97
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
97
    switch (S->getStmtClass()) {
106
97
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
107
97
#define ABSTRACT_STMT(STMT)
108
97
#define STMT(CLASS, PARENT)                              \
109
97
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
97
#include 
"clang/AST/StmtNodes.inc"0
111
97
    }
112
97
  }
ObjCContainersASTChecker.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::WalkAST, void>::Visit(clang::Stmt*)
Line
Count
Source
43
2.18k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
2.18k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
2.18k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
2.18k
    // below.
47
2.18k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
85
      switch (BinOp->getOpcode()) {
49
85
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
50
85
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
51
85
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
52
85
      
case BO_Div: 19
DISPATCH19
(BinDiv, BinaryOperator);
53
85
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
54
85
      
case BO_Add: 8
DISPATCH8
(BinAdd, BinaryOperator);
55
85
      
case BO_Sub: 1
DISPATCH1
(BinSub, BinaryOperator);
56
85
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
57
85
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
58
85
59
85
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
60
85
      
case BO_GT: 1
DISPATCH1
(BinGT, BinaryOperator);
61
85
      
case BO_LE: 1
DISPATCH1
(BinLE, BinaryOperator);
62
85
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
63
85
      
case BO_EQ: 7
DISPATCH7
(BinEQ, BinaryOperator);
64
85
      
case BO_NE: 3
DISPATCH3
(BinNE, BinaryOperator);
65
85
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
66
85
67
85
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
68
85
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
69
85
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
70
85
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
71
85
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
72
85
      
case BO_Assign: 44
DISPATCH44
(BinAssign, BinaryOperator);
73
85
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
74
85
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
75
85
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
76
85
      
case BO_AddAssign: 1
DISPATCH1
(BinAddAssign, CompoundAssignOperator);
77
85
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
78
85
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
79
85
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
80
85
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
81
85
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
82
85
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
83
85
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
84
2.09k
      }
85
2.09k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
41
      switch (UnOp->getOpcode()) {
87
41
      
case UO_PostInc: 0
DISPATCH0
(UnaryPostInc, UnaryOperator);
88
41
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
89
41
      
case UO_PreInc: 0
DISPATCH0
(UnaryPreInc, UnaryOperator);
90
41
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
91
41
      
case UO_AddrOf: 25
DISPATCH25
(UnaryAddrOf, UnaryOperator);
92
41
      
case UO_Deref: 14
DISPATCH14
(UnaryDeref, UnaryOperator);
93
41
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
94
41
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
95
41
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
96
41
      
case UO_LNot: 2
DISPATCH2
(UnaryLNot, UnaryOperator);
97
41
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
98
41
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
99
41
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
100
41
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
101
2.05k
      }
102
2.05k
    }
103
2.05k
104
2.05k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
2.05k
    switch (S->getStmtClass()) {
106
2.05k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
107
2.05k
#define ABSTRACT_STMT(STMT)
108
2.05k
#define STMT(CLASS, PARENT)                              \
109
2.05k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
2.05k
#include 
"clang/AST/StmtNodes.inc"0
111
2.05k
    }
112
2.05k
  }
clang::StmtVisitorBase<std::__1::add_pointer, clang::ASTStmtReader, void>::Visit(clang::Stmt*)
Line
Count
Source
43
557k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
557k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
557k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
557k
    // below.
47
557k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
108k
      switch (BinOp->getOpcode()) {
49
108k
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
50
108k
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
51
108k
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
52
108k
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
53
108k
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
54
108k
      
case BO_Add: 0
DISPATCH0
(BinAdd, BinaryOperator);
55
108k
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
56
108k
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
57
108k
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
58
108k
59
108k
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
60
108k
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
61
108k
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
62
108k
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
63
108k
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
64
108k
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
65
108k
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
66
108k
67
108k
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
68
108k
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
69
108k
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
70
108k
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
71
108k
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
72
108k
      
case BO_Assign: 0
DISPATCH0
(BinAssign, BinaryOperator);
73
108k
      
case BO_MulAssign: 4.24k
DISPATCH4.24k
(BinMulAssign, CompoundAssignOperator);
74
108k
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
75
108k
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
76
108k
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
77
108k
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
78
108k
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
79
108k
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
80
108k
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
81
108k
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
82
108k
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
83
108k
      
case BO_Comma: 104k
DISPATCH104k
(BinComma, BinaryOperator);
84
448k
      }
85
448k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
9.91k
      switch (UnOp->getOpcode()) {
87
9.91k
      
case UO_PostInc: 0
DISPATCH0
(UnaryPostInc, UnaryOperator);
88
9.91k
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
89
9.91k
      
case UO_PreInc: 0
DISPATCH0
(UnaryPreInc, UnaryOperator);
90
9.91k
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
91
9.91k
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
9.91k
      
case UO_Deref: 0
DISPATCH0
(UnaryDeref, UnaryOperator);
93
9.91k
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
94
9.91k
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
95
9.91k
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
96
9.91k
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
97
9.91k
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
98
9.91k
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
99
9.91k
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
100
9.91k
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
101
438k
      }
102
438k
    }
103
438k
104
438k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
438k
    switch (S->getStmtClass()) {
106
438k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
107
438k
#define ABSTRACT_STMT(STMT)
108
438k
#define STMT(CLASS, PARENT)                              \
109
438k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
438k
#include 
"clang/AST/StmtNodes.inc"3
111
438k
    }
112
438k
  }
clang::StmtVisitorBase<std::__1::add_pointer, clang::ASTStmtWriter, void>::Visit(clang::Stmt*)
Line
Count
Source
43
917k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
917k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
917k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
917k
    // below.
47
917k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
117k
      switch (BinOp->getOpcode()) {
49
117k
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
50
117k
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
51
117k
      
case BO_Mul: 6.66k
DISPATCH6.66k
(BinMul, BinaryOperator);
52
117k
      
case BO_Div: 6.17k
DISPATCH6.17k
(BinDiv, BinaryOperator);
53
117k
      
case BO_Rem: 155
DISPATCH155
(BinRem, BinaryOperator);
54
117k
      
case BO_Add: 26.5k
DISPATCH26.5k
(BinAdd, BinaryOperator);
55
117k
      
case BO_Sub: 16.9k
DISPATCH16.9k
(BinSub, BinaryOperator);
56
117k
      
case BO_Shl: 31
DISPATCH31
(BinShl, BinaryOperator);
57
117k
      
case BO_Shr: 56
DISPATCH56
(BinShr, BinaryOperator);
58
117k
59
117k
      
case BO_LT: 8.24k
DISPATCH8.24k
(BinLT, BinaryOperator);
60
117k
      
case BO_GT: 4.95k
DISPATCH4.95k
(BinGT, BinaryOperator);
61
117k
      
case BO_LE: 4.29k
DISPATCH4.29k
(BinLE, BinaryOperator);
62
117k
      
case BO_GE: 208
DISPATCH208
(BinGE, BinaryOperator);
63
117k
      
case BO_EQ: 145
DISPATCH145
(BinEQ, BinaryOperator);
64
117k
      
case BO_NE: 34
DISPATCH34
(BinNE, BinaryOperator);
65
117k
      
case BO_Cmp: 2
DISPATCH2
(BinCmp, BinaryOperator);
66
117k
67
117k
      
case BO_And: 378
DISPATCH378
(BinAnd, BinaryOperator);
68
117k
      
case BO_Xor: 132
DISPATCH132
(BinXor, BinaryOperator);
69
117k
      
case BO_Or : 303
DISPATCH303
(BinOr, BinaryOperator);
70
117k
      
case BO_LAnd: 213
DISPATCH213
(BinLAnd, BinaryOperator);
71
117k
      
case BO_LOr : 10
DISPATCH10
(BinLOr, BinaryOperator);
72
117k
      
case BO_Assign: 37.1k
DISPATCH37.1k
(BinAssign, BinaryOperator);
73
117k
      
case BO_MulAssign: 58
DISPATCH58
(BinMulAssign, CompoundAssignOperator);
74
117k
      
case BO_DivAssign: 54
DISPATCH54
(BinDivAssign, CompoundAssignOperator);
75
117k
      
case BO_RemAssign: 4
DISPATCH4
(BinRemAssign, CompoundAssignOperator);
76
117k
      
case BO_AddAssign: 4.04k
DISPATCH4.04k
(BinAddAssign, CompoundAssignOperator);
77
117k
      
case BO_SubAssign: 116
DISPATCH116
(BinSubAssign, CompoundAssignOperator);
78
117k
      
case BO_ShlAssign: 4
DISPATCH4
(BinShlAssign, CompoundAssignOperator);
79
117k
      
case BO_ShrAssign: 4
DISPATCH4
(BinShrAssign, CompoundAssignOperator);
80
117k
      
case BO_AndAssign: 4
DISPATCH4
(BinAndAssign, CompoundAssignOperator);
81
117k
      
case BO_OrAssign: 8
DISPATCH8
(BinOrAssign, CompoundAssignOperator);
82
117k
      
case BO_XorAssign: 8
DISPATCH8
(BinXorAssign, CompoundAssignOperator);
83
117k
      
case BO_Comma: 74
DISPATCH74
(BinComma, BinaryOperator);
84
800k
      }
85
800k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
13.2k
      switch (UnOp->getOpcode()) {
87
13.2k
      
case UO_PostInc: 1.79k
DISPATCH1.79k
(UnaryPostInc, UnaryOperator);
88
13.2k
      
case UO_PostDec: 40
DISPATCH40
(UnaryPostDec, UnaryOperator);
89
13.2k
      
case UO_PreInc: 4.26k
DISPATCH4.26k
(UnaryPreInc, UnaryOperator);
90
13.2k
      
case UO_PreDec: 50
DISPATCH50
(UnaryPreDec, UnaryOperator);
91
13.2k
      
case UO_AddrOf: 517
DISPATCH517
(UnaryAddrOf, UnaryOperator);
92
13.2k
      
case UO_Deref: 3.56k
DISPATCH3.56k
(UnaryDeref, UnaryOperator);
93
13.2k
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
94
13.2k
      
case UO_Minus: 2.48k
DISPATCH2.48k
(UnaryMinus, UnaryOperator);
95
13.2k
      
case UO_Not: 218
DISPATCH218
(UnaryNot, UnaryOperator);
96
13.2k
      
case UO_LNot: 20
DISPATCH20
(UnaryLNot, UnaryOperator);
97
13.2k
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
98
13.2k
      
case UO_Imag: 2
DISPATCH2
(UnaryImag, UnaryOperator);
99
13.2k
      
case UO_Extension: 277
DISPATCH277
(UnaryExtension, UnaryOperator);
100
13.2k
      
case UO_Coawait: 5
DISPATCH5
(UnaryCoawait, UnaryOperator);
101
787k
      }
102
787k
    }
103
787k
104
787k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
787k
    switch (S->getStmtClass()) {
106
787k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
107
787k
#define ABSTRACT_STMT(STMT)
108
787k
#define STMT(CLASS, PARENT)                              \
109
787k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
787k
#include 
"clang/AST/StmtNodes.inc"37
111
787k
    }
112
787k
  }
AnalysisBasedWarnings.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::ContainsReference, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
401
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
401
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
401
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
401
    // below.
47
401
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
30
      switch (BinOp->getOpcode()) {
49
30
      
case BO_PtrMemD: 1
DISPATCH1
(BinPtrMemD, BinaryOperator);
50
30
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
51
30
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
52
30
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
53
30
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
54
30
      
case BO_Add: 10
DISPATCH10
(BinAdd, BinaryOperator);
55
30
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
56
30
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
57
30
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
58
30
59
30
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
60
30
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
61
30
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
62
30
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
63
30
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
64
30
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
65
30
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
66
30
67
30
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
68
30
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
69
30
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
70
30
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
71
30
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
72
30
      
case BO_Assign: 0
DISPATCH0
(BinAssign, BinaryOperator);
73
30
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
74
30
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
75
30
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
76
30
      
case BO_AddAssign: 6
DISPATCH6
(BinAddAssign, CompoundAssignOperator);
77
30
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
78
30
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
79
30
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
80
30
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
81
30
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
82
30
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
83
30
      
case BO_Comma: 13
DISPATCH13
(BinComma, BinaryOperator);
84
371
      }
85
371
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
8
      switch (UnOp->getOpcode()) {
87
8
      
case UO_PostInc: 4
DISPATCH4
(UnaryPostInc, UnaryOperator);
88
8
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
89
8
      
case UO_PreInc: 2
DISPATCH2
(UnaryPreInc, UnaryOperator);
90
8
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
91
8
      
case UO_AddrOf: 0
DISPATCH0
(UnaryAddrOf, UnaryOperator);
92
8
      
case UO_Deref: 0
DISPATCH0
(UnaryDeref, UnaryOperator);
93
8
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
94
8
      
case UO_Minus: 2
DISPATCH2
(UnaryMinus, UnaryOperator);
95
8
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
96
8
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
97
8
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
98
8
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
99
8
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
100
8
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
101
363
      }
102
363
    }
103
363
104
363
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
363
    switch (S->getStmtClass()) {
106
363
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
107
363
#define ABSTRACT_STMT(STMT)
108
363
#define STMT(CLASS, PARENT)                              \
109
363
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
363
#include 
"clang/AST/StmtNodes.inc"0
111
363
    }
112
363
  }
SemaChecking.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::SequenceChecker, void>::Visit(clang::Stmt*)
Line
Count
Source
43
68.0M
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
68.0M
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
68.0M
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
68.0M
    // below.
47
68.0M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
5.81M
      switch (BinOp->getOpcode()) {
49
5.81M
      
case BO_PtrMemD: 289
DISPATCH289
(BinPtrMemD, BinaryOperator);
50
5.81M
      
case BO_PtrMemI: 253
DISPATCH253
(BinPtrMemI, BinaryOperator);
51
5.81M
      
case BO_Mul: 247k
DISPATCH247k
(BinMul, BinaryOperator);
52
5.81M
      
case BO_Div: 251k
DISPATCH251k
(BinDiv, BinaryOperator);
53
5.81M
      
case BO_Rem: 20.0k
DISPATCH20.0k
(BinRem, BinaryOperator);
54
5.81M
      
case BO_Add: 750k
DISPATCH750k
(BinAdd, BinaryOperator);
55
5.81M
      
case BO_Sub: 792k
DISPATCH792k
(BinSub, BinaryOperator);
56
5.81M
      
case BO_Shl: 173k
DISPATCH173k
(BinShl, BinaryOperator);
57
5.81M
      
case BO_Shr: 90.2k
DISPATCH90.2k
(BinShr, BinaryOperator);
58
5.81M
59
5.81M
      
case BO_LT: 301k
DISPATCH301k
(BinLT, BinaryOperator);
60
5.81M
      
case BO_GT: 231k
DISPATCH231k
(BinGT, BinaryOperator);
61
5.81M
      
case BO_LE: 90.6k
DISPATCH90.6k
(BinLE, BinaryOperator);
62
5.81M
      
case BO_GE: 66.6k
DISPATCH66.6k
(BinGE, BinaryOperator);
63
5.81M
      
case BO_EQ: 377k
DISPATCH377k
(BinEQ, BinaryOperator);
64
5.81M
      
case BO_NE: 176k
DISPATCH176k
(BinNE, BinaryOperator);
65
5.81M
      
case BO_Cmp: 181
DISPATCH181
(BinCmp, BinaryOperator);
66
5.81M
67
5.81M
      
case BO_And: 156k
DISPATCH156k
(BinAnd, BinaryOperator);
68
5.81M
      
case BO_Xor: 30.1k
DISPATCH30.1k
(BinXor, BinaryOperator);
69
5.81M
      
case BO_Or : 93.7k
DISPATCH93.7k
(BinOr, BinaryOperator);
70
5.81M
      
case BO_LAnd: 150k
DISPATCH150k
(BinLAnd, BinaryOperator);
71
5.81M
      
case BO_LOr : 86.3k
DISPATCH86.3k
(BinLOr, BinaryOperator);
72
5.81M
      
case BO_Assign: 1.58M
DISPATCH1.58M
(BinAssign, BinaryOperator);
73
5.81M
      
case BO_MulAssign: 4.08k
DISPATCH4.08k
(BinMulAssign, CompoundAssignOperator);
74
5.81M
      
case BO_DivAssign: 2.09k
DISPATCH2.09k
(BinDivAssign, CompoundAssignOperator);
75
5.81M
      
case BO_RemAssign: 258
DISPATCH258
(BinRemAssign, CompoundAssignOperator);
76
5.81M
      
case BO_AddAssign: 66.9k
DISPATCH66.9k
(BinAddAssign, CompoundAssignOperator);
77
5.81M
      
case BO_SubAssign: 9.36k
DISPATCH9.36k
(BinSubAssign, CompoundAssignOperator);
78
5.81M
      
case BO_ShlAssign: 3.33k
DISPATCH3.33k
(BinShlAssign, CompoundAssignOperator);
79
5.81M
      
case BO_ShrAssign: 1.47k
DISPATCH1.47k
(BinShrAssign, CompoundAssignOperator);
80
5.81M
      
case BO_AndAssign: 4.34k
DISPATCH4.34k
(BinAndAssign, CompoundAssignOperator);
81
5.81M
      
case BO_OrAssign: 24.0k
DISPATCH24.0k
(BinOrAssign, CompoundAssignOperator);
82
5.81M
      
case BO_XorAssign: 3.03k
DISPATCH3.03k
(BinXorAssign, CompoundAssignOperator);
83
5.81M
      
case BO_Comma: 25.3k
DISPATCH25.3k
(BinComma, BinaryOperator);
84
62.2M
      }
85
62.2M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
2.05M
      switch (UnOp->getOpcode()) {
87
2.05M
      
case UO_PostInc: 174k
DISPATCH174k
(UnaryPostInc, UnaryOperator);
88
2.05M
      
case UO_PostDec: 13.3k
DISPATCH13.3k
(UnaryPostDec, UnaryOperator);
89
2.05M
      
case UO_PreInc: 118k
DISPATCH118k
(UnaryPreInc, UnaryOperator);
90
2.05M
      
case UO_PreDec: 21.1k
DISPATCH21.1k
(UnaryPreDec, UnaryOperator);
91
2.05M
      
case UO_AddrOf: 271k
DISPATCH271k
(UnaryAddrOf, UnaryOperator);
92
2.05M
      
case UO_Deref: 258k
DISPATCH258k
(UnaryDeref, UnaryOperator);
93
2.05M
      
case UO_Plus: 541
DISPATCH541
(UnaryPlus, UnaryOperator);
94
2.05M
      
case UO_Minus: 222k
DISPATCH222k
(UnaryMinus, UnaryOperator);
95
2.05M
      
case UO_Not: 44.8k
DISPATCH44.8k
(UnaryNot, UnaryOperator);
96
2.05M
      
case UO_LNot: 904k
DISPATCH904k
(UnaryLNot, UnaryOperator);
97
2.05M
      
case UO_Real: 1.28k
DISPATCH1.28k
(UnaryReal, UnaryOperator);
98
2.05M
      
case UO_Imag: 1.26k
DISPATCH1.26k
(UnaryImag, UnaryOperator);
99
2.05M
      
case UO_Extension: 21.7k
DISPATCH21.7k
(UnaryExtension, UnaryOperator);
100
2.05M
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
101
60.2M
      }
102
60.2M
    }
103
60.2M
104
60.2M
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
60.2M
    switch (S->getStmtClass()) {
106
60.2M
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
107
60.2M
#define ABSTRACT_STMT(STMT)
108
60.2M
#define STMT(CLASS, PARENT)                              \
109
60.2M
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
60.2M
#include 
"clang/AST/StmtNodes.inc"0
111
60.2M
    }
112
60.2M
  }
SemaChecking.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::FindCaptureVisitor, void>::Visit(clang::Stmt*)
Line
Count
Source
43
140
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
140
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
140
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
140
    // below.
47
140
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
2
      switch (BinOp->getOpcode()) {
49
2
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
50
2
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
51
2
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
52
2
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
53
2
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
54
2
      
case BO_Add: 0
DISPATCH0
(BinAdd, BinaryOperator);
55
2
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
56
2
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
57
2
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
58
2
59
2
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
60
2
      
case BO_GT: 1
DISPATCH1
(BinGT, BinaryOperator);
61
2
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
62
2
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
63
2
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
64
2
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
65
2
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
66
2
67
2
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
68
2
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
69
2
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
70
2
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
71
2
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
72
2
      
case BO_Assign: 1
DISPATCH1
(BinAssign, BinaryOperator);
73
2
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
74
2
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
75
2
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
76
2
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
77
2
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
78
2
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
79
2
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
80
2
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
81
2
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
82
2
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
83
2
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
84
138
      }
85
138
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
0
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
138
      }
102
138
    }
103
138
104
138
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
138
    switch (S->getStmtClass()) {
106
138
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
107
138
#define ABSTRACT_STMT(STMT)
108
138
#define STMT(CLASS, PARENT)                              \
109
138
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
138
#include 
"clang/AST/StmtNodes.inc"0
111
138
    }
112
138
  }
SemaDecl.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::SelfReferenceChecker, void>::Visit(clang::Stmt*)
Line
Count
Source
43
3.88M
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
3.88M
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
3.88M
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
3.88M
    // below.
47
3.88M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
276k
      switch (BinOp->getOpcode()) {
49
276k
      
case BO_PtrMemD: 25
DISPATCH25
(BinPtrMemD, BinaryOperator);
50
276k
      
case BO_PtrMemI: 3
DISPATCH3
(BinPtrMemI, BinaryOperator);
51
276k
      
case BO_Mul: 29.8k
DISPATCH29.8k
(BinMul, BinaryOperator);
52
276k
      
case BO_Div: 40.5k
DISPATCH40.5k
(BinDiv, BinaryOperator);
53
276k
      
case BO_Rem: 316
DISPATCH316
(BinRem, BinaryOperator);
54
276k
      
case BO_Add: 26.0k
DISPATCH26.0k
(BinAdd, BinaryOperator);
55
276k
      
case BO_Sub: 32.5k
DISPATCH32.5k
(BinSub, BinaryOperator);
56
276k
      
case BO_Shl: 68.8k
DISPATCH68.8k
(BinShl, BinaryOperator);
57
276k
      
case BO_Shr: 4.25k
DISPATCH4.25k
(BinShr, BinaryOperator);
58
276k
59
276k
      
case BO_LT: 14.7k
DISPATCH14.7k
(BinLT, BinaryOperator);
60
276k
      
case BO_GT: 74
DISPATCH74
(BinGT, BinaryOperator);
61
276k
      
case BO_LE: 13.4k
DISPATCH13.4k
(BinLE, BinaryOperator);
62
276k
      
case BO_GE: 755
DISPATCH755
(BinGE, BinaryOperator);
63
276k
      
case BO_EQ: 11.4k
DISPATCH11.4k
(BinEQ, BinaryOperator);
64
276k
      
case BO_NE: 2.02k
DISPATCH2.02k
(BinNE, BinaryOperator);
65
276k
      
case BO_Cmp: 40
DISPATCH40
(BinCmp, BinaryOperator);
66
276k
67
276k
      
case BO_And: 12.3k
DISPATCH12.3k
(BinAnd, BinaryOperator);
68
276k
      
case BO_Xor: 2.66k
DISPATCH2.66k
(BinXor, BinaryOperator);
69
276k
      
case BO_Or : 10.7k
DISPATCH10.7k
(BinOr, BinaryOperator);
70
276k
      
case BO_LAnd: 4.82k
DISPATCH4.82k
(BinLAnd, BinaryOperator);
71
276k
      
case BO_LOr : 408
DISPATCH408
(BinLOr, BinaryOperator);
72
276k
      
case BO_Assign: 13
DISPATCH13
(BinAssign, BinaryOperator);
73
276k
      
case BO_MulAssign: 7
DISPATCH7
(BinMulAssign, CompoundAssignOperator);
74
276k
      
case BO_DivAssign: 1
DISPATCH1
(BinDivAssign, CompoundAssignOperator);
75
276k
      
case BO_RemAssign: 4
DISPATCH4
(BinRemAssign, CompoundAssignOperator);
76
276k
      
case BO_AddAssign: 14
DISPATCH14
(BinAddAssign, CompoundAssignOperator);
77
276k
      
case BO_SubAssign: 1
DISPATCH1
(BinSubAssign, CompoundAssignOperator);
78
276k
      
case BO_ShlAssign: 4
DISPATCH4
(BinShlAssign, CompoundAssignOperator);
79
276k
      
case BO_ShrAssign: 1
DISPATCH1
(BinShrAssign, CompoundAssignOperator);
80
276k
      
case BO_AndAssign: 1
DISPATCH1
(BinAndAssign, CompoundAssignOperator);
81
276k
      
case BO_OrAssign: 1
DISPATCH1
(BinOrAssign, CompoundAssignOperator);
82
276k
      
case BO_XorAssign: 1
DISPATCH1
(BinXorAssign, CompoundAssignOperator);
83
276k
      
case BO_Comma: 130
DISPATCH130
(BinComma, BinaryOperator);
84
3.61M
      }
85
3.61M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
158k
      switch (UnOp->getOpcode()) {
87
158k
      
case UO_PostInc: 127
DISPATCH127
(UnaryPostInc, UnaryOperator);
88
158k
      
case UO_PostDec: 2
DISPATCH2
(UnaryPostDec, UnaryOperator);
89
158k
      
case UO_PreInc: 43
DISPATCH43
(UnaryPreInc, UnaryOperator);
90
158k
      
case UO_PreDec: 31
DISPATCH31
(UnaryPreDec, UnaryOperator);
91
158k
      
case UO_AddrOf: 35.8k
DISPATCH35.8k
(UnaryAddrOf, UnaryOperator);
92
158k
      
case UO_Deref: 20.9k
DISPATCH20.9k
(UnaryDeref, UnaryOperator);
93
158k
      
case UO_Plus: 76
DISPATCH76
(UnaryPlus, UnaryOperator);
94
158k
      
case UO_Minus: 81.4k
DISPATCH81.4k
(UnaryMinus, UnaryOperator);
95
158k
      
case UO_Not: 13.4k
DISPATCH13.4k
(UnaryNot, UnaryOperator);
96
158k
      
case UO_LNot: 6.47k
DISPATCH6.47k
(UnaryLNot, UnaryOperator);
97
158k
      
case UO_Real: 3
DISPATCH3
(UnaryReal, UnaryOperator);
98
158k
      
case UO_Imag: 3
DISPATCH3
(UnaryImag, UnaryOperator);
99
158k
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
100
158k
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
101
3.45M
      }
102
3.45M
    }
103
3.45M
104
3.45M
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
3.45M
    switch (S->getStmtClass()) {
106
3.45M
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
107
3.45M
#define ABSTRACT_STMT(STMT)
108
3.45M
#define STMT(CLASS, PARENT)                              \
109
3.45M
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
3.45M
#include 
"clang/AST/StmtNodes.inc"0
111
3.45M
    }
112
3.45M
  }
SemaDeclCXX.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::UninitializedFieldVisitor, void>::Visit(clang::Stmt*)
Line
Count
Source
43
282k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
282k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
282k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
282k
    // below.
47
282k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
1.59k
      switch (BinOp->getOpcode()) {
49
1.59k
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
50
1.59k
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
51
1.59k
      
case BO_Mul: 17
DISPATCH17
(BinMul, BinaryOperator);
52
1.59k
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
53
1.59k
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
54
1.59k
      
case BO_Add: 1.50k
DISPATCH1.50k
(BinAdd, BinaryOperator);
55
1.59k
      
case BO_Sub: 4
DISPATCH4
(BinSub, BinaryOperator);
56
1.59k
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
57
1.59k
      
case BO_Shr: 24
DISPATCH24
(BinShr, BinaryOperator);
58
1.59k
59
1.59k
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
60
1.59k
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
61
1.59k
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
62
1.59k
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
63
1.59k
      
case BO_EQ: 6
DISPATCH6
(BinEQ, BinaryOperator);
64
1.59k
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
65
1.59k
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
66
1.59k
67
1.59k
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
68
1.59k
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
69
1.59k
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
70
1.59k
      
case BO_LAnd: 4
DISPATCH4
(BinLAnd, BinaryOperator);
71
1.59k
      
case BO_LOr : 19
DISPATCH19
(BinLOr, BinaryOperator);
72
1.59k
      
case BO_Assign: 10
DISPATCH10
(BinAssign, BinaryOperator);
73
1.59k
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
74
1.59k
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
75
1.59k
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
76
1.59k
      
case BO_AddAssign: 3
DISPATCH3
(BinAddAssign, CompoundAssignOperator);
77
1.59k
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
78
1.59k
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
79
1.59k
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
80
1.59k
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
81
1.59k
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
82
1.59k
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
83
1.59k
      
case BO_Comma: 7
DISPATCH7
(BinComma, BinaryOperator);
84
280k
      }
85
280k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
1.22k
      switch (UnOp->getOpcode()) {
87
1.22k
      
case UO_PostInc: 17
DISPATCH17
(UnaryPostInc, UnaryOperator);
88
1.22k
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
89
1.22k
      
case UO_PreInc: 12
DISPATCH12
(UnaryPreInc, UnaryOperator);
90
1.22k
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
91
1.22k
      
case UO_AddrOf: 389
DISPATCH389
(UnaryAddrOf, UnaryOperator);
92
1.22k
      
case UO_Deref: 213
DISPATCH213
(UnaryDeref, UnaryOperator);
93
1.22k
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
94
1.22k
      
case UO_Minus: 578
DISPATCH578
(UnaryMinus, UnaryOperator);
95
1.22k
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
96
1.22k
      
case UO_LNot: 13
DISPATCH13
(UnaryLNot, UnaryOperator);
97
1.22k
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
98
1.22k
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
99
1.22k
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
100
1.22k
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
101
279k
      }
102
279k
    }
103
279k
104
279k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
279k
    switch (S->getStmtClass()) {
106
279k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
107
279k
#define ABSTRACT_STMT(STMT)
108
279k
#define STMT(CLASS, PARENT)                              \
109
279k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
279k
#include 
"clang/AST/StmtNodes.inc"0
111
279k
    }
112
279k
  }
SemaDeclCXX.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::CheckDefaultArgumentVisitor, bool>::Visit(clang::Stmt*)
Line
Count
Source
43
241k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
241k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
241k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
241k
    // below.
47
241k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
8.14k
      switch (BinOp->getOpcode()) {
49
8.14k
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
50
8.14k
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
51
8.14k
      
case BO_Mul: 3
DISPATCH3
(BinMul, BinaryOperator);
52
8.14k
      
case BO_Div: 15
DISPATCH15
(BinDiv, BinaryOperator);
53
8.14k
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
54
8.14k
      
case BO_Add: 22
DISPATCH22
(BinAdd, BinaryOperator);
55
8.14k
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
56
8.14k
      
case BO_Shl: 5.21k
DISPATCH5.21k
(BinShl, BinaryOperator);
57
8.14k
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
58
8.14k
59
8.14k
      
case BO_LT: 14
DISPATCH14
(BinLT, BinaryOperator);
60
8.14k
      
case BO_GT: 4
DISPATCH4
(BinGT, BinaryOperator);
61
8.14k
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
62
8.14k
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
63
8.14k
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
64
8.14k
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
65
8.14k
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
66
8.14k
67
8.14k
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
68
8.14k
      
case BO_Xor: 5
DISPATCH5
(BinXor, BinaryOperator);
69
8.14k
      
case BO_Or : 2.86k
DISPATCH2.86k
(BinOr, BinaryOperator);
70
8.14k
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
71
8.14k
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
72
8.14k
      
case BO_Assign: 0
DISPATCH0
(BinAssign, BinaryOperator);
73
8.14k
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
74
8.14k
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
75
8.14k
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
76
8.14k
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
77
8.14k
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
78
8.14k
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
79
8.14k
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
80
8.14k
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
81
8.14k
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
82
8.14k
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
83
8.14k
      
case BO_Comma: 7
DISPATCH7
(BinComma, BinaryOperator);
84
233k
      }
85
233k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
6.74k
      switch (UnOp->getOpcode()) {
87
6.74k
      
case UO_PostInc: 0
DISPATCH0
(UnaryPostInc, UnaryOperator);
88
6.74k
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
89
6.74k
      
case UO_PreInc: 0
DISPATCH0
(UnaryPreInc, UnaryOperator);
90
6.74k
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
91
6.74k
      
case UO_AddrOf: 5.22k
DISPATCH5.22k
(UnaryAddrOf, UnaryOperator);
92
6.74k
      
case UO_Deref: 0
DISPATCH0
(UnaryDeref, UnaryOperator);
93
6.74k
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
94
6.74k
      
case UO_Minus: 1.52k
DISPATCH1.52k
(UnaryMinus, UnaryOperator);
95
6.74k
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
96
6.74k
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
97
6.74k
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
98
6.74k
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
99
6.74k
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
100
6.74k
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
101
226k
      }
102
226k
    }
103
226k
104
226k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
226k
    switch (S->getStmtClass()) {
106
226k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
107
226k
#define ABSTRACT_STMT(STMT)
108
226k
#define STMT(CLASS, PARENT)                              \
109
226k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
226k
#include 
"clang/AST/StmtNodes.inc"0
111
226k
    }
112
226k
  }
SemaExpr.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::RebuildUnknownAnyFunction, clang::ActionResult<clang::Expr*, true> >::Visit(clang::Stmt*)
Line
Count
Source
43
5
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
5
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
5
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
5
    // below.
47
5
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
0
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
0
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
0
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
5
      }
85
5
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
0
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
5
      }
102
5
    }
103
5
104
5
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
5
    switch (S->getStmtClass()) {
106
5
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
107
5
#define ABSTRACT_STMT(STMT)
108
5
#define STMT(CLASS, PARENT)                              \
109
5
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
5
#include 
"clang/AST/StmtNodes.inc"0
111
5
    }
112
5
  }
SemaExpr.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::EvaluatedExprMarker, void>::Visit(clang::Stmt*)
Line
Count
Source
43
158k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
158k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
158k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
158k
    // below.
47
158k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
319
      switch (BinOp->getOpcode()) {
49
319
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
50
319
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
51
319
      
case BO_Mul: 7
DISPATCH7
(BinMul, BinaryOperator);
52
319
      
case BO_Div: 1
DISPATCH1
(BinDiv, BinaryOperator);
53
319
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
54
319
      
case BO_Add: 8
DISPATCH8
(BinAdd, BinaryOperator);
55
319
      
case BO_Sub: 20
DISPATCH20
(BinSub, BinaryOperator);
56
319
      
case BO_Shl: 48
DISPATCH48
(BinShl, BinaryOperator);
57
319
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
58
319
59
319
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
60
319
      
case BO_GT: 72
DISPATCH72
(BinGT, BinaryOperator);
61
319
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
62
319
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
63
319
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
64
319
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
65
319
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
66
319
67
319
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
68
319
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
69
319
      
case BO_Or : 153
DISPATCH153
(BinOr, BinaryOperator);
70
319
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
71
319
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
72
319
      
case BO_Assign: 0
DISPATCH0
(BinAssign, BinaryOperator);
73
319
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
74
319
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
75
319
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
76
319
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
77
319
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
78
319
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
79
319
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
80
319
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
81
319
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
82
319
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
83
319
      
case BO_Comma: 10
DISPATCH10
(BinComma, BinaryOperator);
84
158k
      }
85
158k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
621
      switch (UnOp->getOpcode()) {
87
621
      
case UO_PostInc: 0
DISPATCH0
(UnaryPostInc, UnaryOperator);
88
621
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
89
621
      
case UO_PreInc: 0
DISPATCH0
(UnaryPreInc, UnaryOperator);
90
621
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
91
621
      
case UO_AddrOf: 169
DISPATCH169
(UnaryAddrOf, UnaryOperator);
92
621
      
case UO_Deref: 0
DISPATCH0
(UnaryDeref, UnaryOperator);
93
621
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
94
621
      
case UO_Minus: 452
DISPATCH452
(UnaryMinus, UnaryOperator);
95
621
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
96
621
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
97
621
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
98
621
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
99
621
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
100
621
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
101
157k
      }
102
157k
    }
103
157k
104
157k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
157k
    switch (S->getStmtClass()) {
106
157k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
107
157k
#define ABSTRACT_STMT(STMT)
108
157k
#define STMT(CLASS, PARENT)                              \
109
157k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
157k
#include 
"clang/AST/StmtNodes.inc"0
111
157k
    }
112
157k
  }
SemaExpr.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::RebuildUnknownAnyExpr, clang::ActionResult<clang::Expr*, true> >::Visit(clang::Stmt*)
Line
Count
Source
43
126
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
126
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
126
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
126
    // below.
47
126
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
0
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
0
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
0
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
126
      }
85
126
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
4
      switch (UnOp->getOpcode()) {
87
4
      
case UO_PostInc: 0
DISPATCH0
(UnaryPostInc, UnaryOperator);
88
4
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
89
4
      
case UO_PreInc: 0
DISPATCH0
(UnaryPreInc, UnaryOperator);
90
4
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
91
4
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
4
      
case UO_Deref: 0
DISPATCH0
(UnaryDeref, UnaryOperator);
93
4
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
94
4
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
95
4
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
96
4
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
97
4
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
98
4
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
99
4
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
100
4
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
101
122
      }
102
122
    }
103
122
104
122
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
122
    switch (S->getStmtClass()) {
106
122
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
107
122
#define ABSTRACT_STMT(STMT)
108
122
#define STMT(CLASS, PARENT)                              \
109
122
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
122
#include 
"clang/AST/StmtNodes.inc"0
111
122
    }
112
122
  }
SemaExprObjC.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::ARCCastChecker, (anonymous namespace)::ACCResult>::Visit(clang::Stmt*)
Line
Count
Source
43
1.70k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
1.70k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
1.70k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
1.70k
    // below.
47
1.70k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
3
      switch (BinOp->getOpcode()) {
49
3
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
50
3
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
51
3
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
52
3
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
53
3
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
54
3
      
case BO_Add: 0
DISPATCH0
(BinAdd, BinaryOperator);
55
3
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
56
3
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
57
3
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
58
3
59
3
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
60
3
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
61
3
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
62
3
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
63
3
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
64
3
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
65
3
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
66
3
67
3
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
68
3
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
69
3
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
70
3
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
71
3
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
72
3
      
case BO_Assign: 0
DISPATCH0
(BinAssign, BinaryOperator);
73
3
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
74
3
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
75
3
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
76
3
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
77
3
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
78
3
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
79
3
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
80
3
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
81
3
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
82
3
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
83
3
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
1.70k
      }
85
1.70k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
3
      switch (UnOp->getOpcode()) {
87
3
      
case UO_PostInc: 0
DISPATCH0
(UnaryPostInc, UnaryOperator);
88
3
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
89
3
      
case UO_PreInc: 0
DISPATCH0
(UnaryPreInc, UnaryOperator);
90
3
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
91
3
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
3
      
case UO_Deref: 0
DISPATCH0
(UnaryDeref, UnaryOperator);
93
3
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
94
3
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
95
3
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
96
3
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
97
3
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
98
3
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
99
3
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
100
3
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
101
1.70k
      }
102
1.70k
    }
103
1.70k
104
1.70k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
1.70k
    switch (S->getStmtClass()) {
106
1.70k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
107
1.70k
#define ABSTRACT_STMT(STMT)
108
1.70k
#define STMT(CLASS, PARENT)                              \
109
1.70k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
1.70k
#include 
"clang/AST/StmtNodes.inc"0
111
1.70k
    }
112
1.70k
  }
SemaOpenMP.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::DSARefChecker, bool>::Visit(clang::Stmt*)
Line
Count
Source
43
6.60k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
6.60k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
6.60k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
6.60k
    // below.
47
6.60k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
0
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
0
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
0
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
6.60k
      }
85
6.60k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
0
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
6.60k
      }
102
6.60k
    }
103
6.60k
104
6.60k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
6.60k
    switch (S->getStmtClass()) {
106
6.60k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
107
6.60k
#define ABSTRACT_STMT(STMT)
108
6.60k
#define STMT(CLASS, PARENT)                              \
109
6.60k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
6.60k
#include 
"clang/AST/StmtNodes.inc"0
111
6.60k
    }
112
6.60k
  }
SemaOpenMP.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::LocalVarRefChecker, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
1.52k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
1.52k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
1.52k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
1.52k
    // below.
47
1.52k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
0
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
0
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
0
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
1.52k
      }
85
1.52k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
0
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
1.52k
      }
102
1.52k
    }
103
1.52k
104
1.52k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
1.52k
    switch (S->getStmtClass()) {
106
1.52k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
107
1.52k
#define ABSTRACT_STMT(STMT)
108
1.52k
#define STMT(CLASS, PARENT)                              \
109
1.52k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
1.52k
#include 
"clang/AST/StmtNodes.inc"0
111
1.52k
    }
112
1.52k
  }
SemaOpenMP.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::DSAAttrChecker, void>::Visit(clang::Stmt*)
Line
Count
Source
43
1.25M
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
1.25M
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
1.25M
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
1.25M
    // below.
47
1.25M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
120k
      switch (BinOp->getOpcode()) {
49
120k
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
50
120k
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
51
120k
      
case BO_Mul: 909
DISPATCH909
(BinMul, BinaryOperator);
52
120k
      
case BO_Div: 132
DISPATCH132
(BinDiv, BinaryOperator);
53
120k
      
case BO_Rem: 8
DISPATCH8
(BinRem, BinaryOperator);
54
120k
      
case BO_Add: 4.13k
DISPATCH4.13k
(BinAdd, BinaryOperator);
55
120k
      
case BO_Sub: 16.8k
DISPATCH16.8k
(BinSub, BinaryOperator);
56
120k
      
case BO_Shl: 26
DISPATCH26
(BinShl, BinaryOperator);
57
120k
      
case BO_Shr: 26
DISPATCH26
(BinShr, BinaryOperator);
58
120k
59
120k
      
case BO_LT: 54.9k
DISPATCH54.9k
(BinLT, BinaryOperator);
60
120k
      
case BO_GT: 764
DISPATCH764
(BinGT, BinaryOperator);
61
120k
      
case BO_LE: 226
DISPATCH226
(BinLE, BinaryOperator);
62
120k
      
case BO_GE: 296
DISPATCH296
(BinGE, BinaryOperator);
63
120k
      
case BO_EQ: 196
DISPATCH196
(BinEQ, BinaryOperator);
64
120k
      
case BO_NE: 110
DISPATCH110
(BinNE, BinaryOperator);
65
120k
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
66
120k
67
120k
      
case BO_And: 42
DISPATCH42
(BinAnd, BinaryOperator);
68
120k
      
case BO_Xor: 18
DISPATCH18
(BinXor, BinaryOperator);
69
120k
      
case BO_Or : 26
DISPATCH26
(BinOr, BinaryOperator);
70
120k
      
case BO_LAnd: 14
DISPATCH14
(BinLAnd, BinaryOperator);
71
120k
      
case BO_LOr : 14
DISPATCH14
(BinLOr, BinaryOperator);
72
120k
      
case BO_Assign: 32.1k
DISPATCH32.1k
(BinAssign, BinaryOperator);
73
120k
      
case BO_MulAssign: 81
DISPATCH81
(BinMulAssign, CompoundAssignOperator);
74
120k
      
case BO_DivAssign: 158
DISPATCH158
(BinDivAssign, CompoundAssignOperator);
75
120k
      
case BO_RemAssign: 34
DISPATCH34
(BinRemAssign, CompoundAssignOperator);
76
120k
      
case BO_AddAssign: 8.72k
DISPATCH8.72k
(BinAddAssign, CompoundAssignOperator);
77
120k
      
case BO_SubAssign: 426
DISPATCH426
(BinSubAssign, CompoundAssignOperator);
78
120k
      
case BO_ShlAssign: 26
DISPATCH26
(BinShlAssign, CompoundAssignOperator);
79
120k
      
case BO_ShrAssign: 26
DISPATCH26
(BinShrAssign, CompoundAssignOperator);
80
120k
      
case BO_AndAssign: 26
DISPATCH26
(BinAndAssign, CompoundAssignOperator);
81
120k
      
case BO_OrAssign: 48
DISPATCH48
(BinOrAssign, CompoundAssignOperator);
82
120k
      
case BO_XorAssign: 36
DISPATCH36
(BinXorAssign, CompoundAssignOperator);
83
120k
      
case BO_Comma: 244
DISPATCH244
(BinComma, BinaryOperator);
84
1.13M
      }
85
1.13M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
63.4k
      switch (UnOp->getOpcode()) {
87
63.4k
      
case UO_PostInc: 19.3k
DISPATCH19.3k
(UnaryPostInc, UnaryOperator);
88
63.4k
      
case UO_PostDec: 202
DISPATCH202
(UnaryPostDec, UnaryOperator);
89
63.4k
      
case UO_PreInc: 42.5k
DISPATCH42.5k
(UnaryPreInc, UnaryOperator);
90
63.4k
      
case UO_PreDec: 158
DISPATCH158
(UnaryPreDec, UnaryOperator);
91
63.4k
      
case UO_AddrOf: 128
DISPATCH128
(UnaryAddrOf, UnaryOperator);
92
63.4k
      
case UO_Deref: 520
DISPATCH520
(UnaryDeref, UnaryOperator);
93
63.4k
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
94
63.4k
      
case UO_Minus: 384
DISPATCH384
(UnaryMinus, UnaryOperator);
95
63.4k
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
96
63.4k
      
case UO_LNot: 122
DISPATCH122
(UnaryLNot, UnaryOperator);
97
63.4k
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
98
63.4k
      
case UO_Imag: 4
DISPATCH4
(UnaryImag, UnaryOperator);
99
63.4k
      
case UO_Extension: 24
DISPATCH24
(UnaryExtension, UnaryOperator);
100
63.4k
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
101
1.07M
      }
102
1.07M
    }
103
1.07M
104
1.07M
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
1.07M
    switch (S->getStmtClass()) {
106
1.07M
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
107
1.07M
#define ABSTRACT_STMT(STMT)
108
1.07M
#define STMT(CLASS, PARENT)                              \
109
1.07M
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
1.07M
#include 
"clang/AST/StmtNodes.inc"0
111
1.07M
    }
112
1.07M
  }
SemaStmt.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::BreakContinueFinder, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
257k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
257k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
257k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
257k
    // below.
47
257k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
37.6k
      switch (BinOp->getOpcode()) {
49
37.6k
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
50
37.6k
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
51
37.6k
      
case BO_Mul: 720
DISPATCH720
(BinMul, BinaryOperator);
52
37.6k
      
case BO_Div: 370
DISPATCH370
(BinDiv, BinaryOperator);
53
37.6k
      
case BO_Rem: 54
DISPATCH54
(BinRem, BinaryOperator);
54
37.6k
      
case BO_Add: 1.39k
DISPATCH1.39k
(BinAdd, BinaryOperator);
55
37.6k
      
case BO_Sub: 833
DISPATCH833
(BinSub, BinaryOperator);
56
37.6k
      
case BO_Shl: 140
DISPATCH140
(BinShl, BinaryOperator);
57
37.6k
      
case BO_Shr: 67
DISPATCH67
(BinShr, BinaryOperator);
58
37.6k
59
37.6k
      
case BO_LT: 18.3k
DISPATCH18.3k
(BinLT, BinaryOperator);
60
37.6k
      
case BO_GT: 1.26k
DISPATCH1.26k
(BinGT, BinaryOperator);
61
37.6k
      
case BO_LE: 2.44k
DISPATCH2.44k
(BinLE, BinaryOperator);
62
37.6k
      
case BO_GE: 722
DISPATCH722
(BinGE, BinaryOperator);
63
37.6k
      
case BO_EQ: 1.50k
DISPATCH1.50k
(BinEQ, BinaryOperator);
64
37.6k
      
case BO_NE: 2.73k
DISPATCH2.73k
(BinNE, BinaryOperator);
65
37.6k
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
66
37.6k
67
37.6k
      
case BO_And: 125
DISPATCH125
(BinAnd, BinaryOperator);
68
37.6k
      
case BO_Xor: 2
DISPATCH2
(BinXor, BinaryOperator);
69
37.6k
      
case BO_Or : 9
DISPATCH9
(BinOr, BinaryOperator);
70
37.6k
      
case BO_LAnd: 1.55k
DISPATCH1.55k
(BinLAnd, BinaryOperator);
71
37.6k
      
case BO_LOr : 237
DISPATCH237
(BinLOr, BinaryOperator);
72
37.6k
      
case BO_Assign: 3.23k
DISPATCH3.23k
(BinAssign, BinaryOperator);
73
37.6k
      
case BO_MulAssign: 14
DISPATCH14
(BinMulAssign, CompoundAssignOperator);
74
37.6k
      
case BO_DivAssign: 7
DISPATCH7
(BinDivAssign, CompoundAssignOperator);
75
37.6k
      
case BO_RemAssign: 4
DISPATCH4
(BinRemAssign, CompoundAssignOperator);
76
37.6k
      
case BO_AddAssign: 859
DISPATCH859
(BinAddAssign, CompoundAssignOperator);
77
37.6k
      
case BO_SubAssign: 46
DISPATCH46
(BinSubAssign, CompoundAssignOperator);
78
37.6k
      
case BO_ShlAssign: 25
DISPATCH25
(BinShlAssign, CompoundAssignOperator);
79
37.6k
      
case BO_ShrAssign: 33
DISPATCH33
(BinShrAssign, CompoundAssignOperator);
80
37.6k
      
case BO_AndAssign: 6
DISPATCH6
(BinAndAssign, CompoundAssignOperator);
81
37.6k
      
case BO_OrAssign: 4
DISPATCH4
(BinOrAssign, CompoundAssignOperator);
82
37.6k
      
case BO_XorAssign: 4
DISPATCH4
(BinXorAssign, CompoundAssignOperator);
83
37.6k
      
case BO_Comma: 932
DISPATCH932
(BinComma, BinaryOperator);
84
220k
      }
85
220k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
25.2k
      switch (UnOp->getOpcode()) {
87
25.2k
      
case UO_PostInc: 16.1k
DISPATCH16.1k
(UnaryPostInc, UnaryOperator);
88
25.2k
      
case UO_PostDec: 931
DISPATCH931
(UnaryPostDec, UnaryOperator);
89
25.2k
      
case UO_PreInc: 4.16k
DISPATCH4.16k
(UnaryPreInc, UnaryOperator);
90
25.2k
      
case UO_PreDec: 516
DISPATCH516
(UnaryPreDec, UnaryOperator);
91
25.2k
      
case UO_AddrOf: 152
DISPATCH152
(UnaryAddrOf, UnaryOperator);
92
25.2k
      
case UO_Deref: 1.39k
DISPATCH1.39k
(UnaryDeref, UnaryOperator);
93
25.2k
      
case UO_Plus: 1
DISPATCH1
(UnaryPlus, UnaryOperator);
94
25.2k
      
case UO_Minus: 353
DISPATCH353
(UnaryMinus, UnaryOperator);
95
25.2k
      
case UO_Not: 1
DISPATCH1
(UnaryNot, UnaryOperator);
96
25.2k
      
case UO_LNot: 1.63k
DISPATCH1.63k
(UnaryLNot, UnaryOperator);
97
25.2k
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
98
25.2k
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
99
25.2k
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
100
25.2k
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
101
194k
      }
102
194k
    }
103
194k
104
194k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
194k
    switch (S->getStmtClass()) {
106
194k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
107
194k
#define ABSTRACT_STMT(STMT)
108
194k
#define STMT(CLASS, PARENT)                              \
109
194k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
194k
#include 
"clang/AST/StmtNodes.inc"0
111
194k
    }
112
194k
  }
SemaStmt.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::DeclExtractor, void>::Visit(clang::Stmt*)
Line
Count
Source
43
482k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
482k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
482k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
482k
    // below.
47
482k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
106k
      switch (BinOp->getOpcode()) {
49
106k
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
50
106k
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
51
106k
      
case BO_Mul: 3.13k
DISPATCH3.13k
(BinMul, BinaryOperator);
52
106k
      
case BO_Div: 2.58k
DISPATCH2.58k
(BinDiv, BinaryOperator);
53
106k
      
case BO_Rem: 16
DISPATCH16
(BinRem, BinaryOperator);
54
106k
      
case BO_Add: 4.62k
DISPATCH4.62k
(BinAdd, BinaryOperator);
55
106k
      
case BO_Sub: 112
DISPATCH112
(BinSub, BinaryOperator);
56
106k
      
case BO_Shl: 32
DISPATCH32
(BinShl, BinaryOperator);
57
106k
      
case BO_Shr: 16
DISPATCH16
(BinShr, BinaryOperator);
58
106k
59
106k
      
case BO_LT: 79.9k
DISPATCH79.9k
(BinLT, BinaryOperator);
60
106k
      
case BO_GT: 7.30k
DISPATCH7.30k
(BinGT, BinaryOperator);
61
106k
      
case BO_LE: 3.37k
DISPATCH3.37k
(BinLE, BinaryOperator);
62
106k
      
case BO_GE: 3.53k
DISPATCH3.53k
(BinGE, BinaryOperator);
63
106k
      
case BO_EQ: 134
DISPATCH134
(BinEQ, BinaryOperator);
64
106k
      
case BO_NE: 530
DISPATCH530
(BinNE, BinaryOperator);
65
106k
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
66
106k
67
106k
      
case BO_And: 80
DISPATCH80
(BinAnd, BinaryOperator);
68
106k
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
69
106k
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
70
106k
      
case BO_LAnd: 1.21k
DISPATCH1.21k
(BinLAnd, BinaryOperator);
71
106k
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
72
106k
      
case BO_Assign: 0
DISPATCH0
(BinAssign, BinaryOperator);
73
106k
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
74
106k
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
75
106k
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
76
106k
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
77
106k
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
78
106k
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
79
106k
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
80
106k
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
81
106k
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
82
106k
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
83
106k
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
84
375k
      }
85
375k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
212
      switch (UnOp->getOpcode()) {
87
212
      
case UO_PostInc: 0
DISPATCH0
(UnaryPostInc, UnaryOperator);
88
212
      
case UO_PostDec: 8
DISPATCH8
(UnaryPostDec, UnaryOperator);
89
212
      
case UO_PreInc: 0
DISPATCH0
(UnaryPreInc, UnaryOperator);
90
212
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
91
212
      
case UO_AddrOf: 8
DISPATCH8
(UnaryAddrOf, UnaryOperator);
92
212
      
case UO_Deref: 193
DISPATCH193
(UnaryDeref, UnaryOperator);
93
212
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
94
212
      
case UO_Minus: 2
DISPATCH2
(UnaryMinus, UnaryOperator);
95
212
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
96
212
      
case UO_LNot: 1
DISPATCH1
(UnaryLNot, UnaryOperator);
97
212
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
98
212
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
99
212
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
100
212
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
101
375k
      }
102
375k
    }
103
375k
104
375k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
375k
    switch (S->getStmtClass()) {
106
375k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
107
375k
#define ABSTRACT_STMT(STMT)
108
375k
#define STMT(CLASS, PARENT)                              \
109
375k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
375k
#include 
"clang/AST/StmtNodes.inc"0
111
375k
    }
112
375k
  }
SemaStmt.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::DeclMatcher, void>::Visit(clang::Stmt*)
Line
Count
Source
43
262k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
262k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
262k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
262k
    // below.
47
262k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
64.4k
      switch (BinOp->getOpcode()) {
49
64.4k
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
50
64.4k
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
51
64.4k
      
case BO_Mul: 3.12k
DISPATCH3.12k
(BinMul, BinaryOperator);
52
64.4k
      
case BO_Div: 1.51k
DISPATCH1.51k
(BinDiv, BinaryOperator);
53
64.4k
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
54
64.4k
      
case BO_Add: 3.13k
DISPATCH3.13k
(BinAdd, BinaryOperator);
55
64.4k
      
case BO_Sub: 80
DISPATCH80
(BinSub, BinaryOperator);
56
64.4k
      
case BO_Shl: 192
DISPATCH192
(BinShl, BinaryOperator);
57
64.4k
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
58
64.4k
59
64.4k
      
case BO_LT: 30.4k
DISPATCH30.4k
(BinLT, BinaryOperator);
60
64.4k
      
case BO_GT: 7.33k
DISPATCH7.33k
(BinGT, BinaryOperator);
61
64.4k
      
case BO_LE: 1.72k
DISPATCH1.72k
(BinLE, BinaryOperator);
62
64.4k
      
case BO_GE: 3.37k
DISPATCH3.37k
(BinGE, BinaryOperator);
63
64.4k
      
case BO_EQ: 38
DISPATCH38
(BinEQ, BinaryOperator);
64
64.4k
      
case BO_NE: 166
DISPATCH166
(BinNE, BinaryOperator);
65
64.4k
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
66
64.4k
67
64.4k
      
case BO_And: 80
DISPATCH80
(BinAnd, BinaryOperator);
68
64.4k
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
69
64.4k
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
70
64.4k
      
case BO_LAnd: 264
DISPATCH264
(BinLAnd, BinaryOperator);
71
64.4k
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
72
64.4k
      
case BO_Assign: 5.93k
DISPATCH5.93k
(BinAssign, BinaryOperator);
73
64.4k
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
74
64.4k
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
75
64.4k
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
76
64.4k
      
case BO_AddAssign: 4.93k
DISPATCH4.93k
(BinAddAssign, CompoundAssignOperator);
77
64.4k
      
case BO_SubAssign: 32
DISPATCH32
(BinSubAssign, CompoundAssignOperator);
78
64.4k
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
79
64.4k
      
case BO_ShrAssign: 80
DISPATCH80
(BinShrAssign, CompoundAssignOperator);
80
64.4k
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
81
64.4k
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
82
64.4k
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
83
64.4k
      
case BO_Comma: 2.07k
DISPATCH2.07k
(BinComma, BinaryOperator);
84
197k
      }
85
197k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
34.4k
      switch (UnOp->getOpcode()) {
87
34.4k
      
case UO_PostInc: 25.2k
DISPATCH25.2k
(UnaryPostInc, UnaryOperator);
88
34.4k
      
case UO_PostDec: 7.73k
DISPATCH7.73k
(UnaryPostDec, UnaryOperator);
89
34.4k
      
case UO_PreInc: 1.23k
DISPATCH1.23k
(UnaryPreInc, UnaryOperator);
90
34.4k
      
case UO_PreDec: 157
DISPATCH157
(UnaryPreDec, UnaryOperator);
91
34.4k
      
case UO_AddrOf: 2
DISPATCH2
(UnaryAddrOf, UnaryOperator);
92
34.4k
      
case UO_Deref: 34
DISPATCH34
(UnaryDeref, UnaryOperator);
93
34.4k
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
94
34.4k
      
case UO_Minus: 2
DISPATCH2
(UnaryMinus, UnaryOperator);
95
34.4k
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
96
34.4k
      
case UO_LNot: 48
DISPATCH48
(UnaryLNot, UnaryOperator);
97
34.4k
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
98
34.4k
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
99
34.4k
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
100
34.4k
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
101
163k
      }
102
163k
    }
103
163k
104
163k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
163k
    switch (S->getStmtClass()) {
106
163k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
107
163k
#define ABSTRACT_STMT(STMT)
108
163k
#define STMT(CLASS, PARENT)                              \
109
163k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
163k
#include 
"clang/AST/StmtNodes.inc"0
111
163k
    }
112
163k
  }
SemaStmt.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::CommaVisitor, void>::Visit(clang::Stmt*)
Line
Count
Source
43
822
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
822
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
822
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
822
    // below.
47
822
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
180
      switch (BinOp->getOpcode()) {
49
180
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
50
180
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
51
180
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
52
180
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
53
180
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
54
180
      
case BO_Add: 0
DISPATCH0
(BinAdd, BinaryOperator);
55
180
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
56
180
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
57
180
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
58
180
59
180
      
case BO_LT: 140
DISPATCH140
(BinLT, BinaryOperator);
60
180
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
61
180
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
62
180
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
63
180
      
case BO_EQ: 5
DISPATCH5
(BinEQ, BinaryOperator);
64
180
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
65
180
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
66
180
67
180
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
68
180
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
69
180
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
70
180
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
71
180
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
72
180
      
case BO_Assign: 0
DISPATCH0
(BinAssign, BinaryOperator);
73
180
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
74
180
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
75
180
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
76
180
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
77
180
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
78
180
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
79
180
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
80
180
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
81
180
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
82
180
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
83
180
      
case BO_Comma: 35
DISPATCH35
(BinComma, BinaryOperator);
84
642
      }
85
642
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
0
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
642
      }
102
642
    }
103
642
104
642
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
642
    switch (S->getStmtClass()) {
106
642
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
107
642
#define ABSTRACT_STMT(STMT)
108
642
#define STMT(CLASS, PARENT)                              \
109
642
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
642
#include 
"clang/AST/StmtNodes.inc"0
111
642
    }
112
642
  }
AnalysisDeclContext.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::FindBlockDeclRefExprsVals, void>::Visit(clang::Stmt*)
Line
Count
Source
43
2.32k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
2.32k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
2.32k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
2.32k
    // below.
47
2.32k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
164
      switch (BinOp->getOpcode()) {
49
164
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
50
164
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
51
164
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
52
164
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
53
164
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
54
164
      
case BO_Add: 22
DISPATCH22
(BinAdd, BinaryOperator);
55
164
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
56
164
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
57
164
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
58
164
59
164
      
case BO_LT: 4
DISPATCH4
(BinLT, BinaryOperator);
60
164
      
case BO_GT: 6
DISPATCH6
(BinGT, BinaryOperator);
61
164
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
62
164
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
63
164
      
case BO_EQ: 12
DISPATCH12
(BinEQ, BinaryOperator);
64
164
      
case BO_NE: 2
DISPATCH2
(BinNE, BinaryOperator);
65
164
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
66
164
67
164
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
68
164
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
69
164
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
70
164
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
71
164
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
72
164
      
case BO_Assign: 118
DISPATCH118
(BinAssign, BinaryOperator);
73
164
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
74
164
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
75
164
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
76
164
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
77
164
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
78
164
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
79
164
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
80
164
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
81
164
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
82
164
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
83
164
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
84
2.16k
      }
85
2.16k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
75
      switch (UnOp->getOpcode()) {
87
75
      
case UO_PostInc: 2
DISPATCH2
(UnaryPostInc, UnaryOperator);
88
75
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
89
75
      
case UO_PreInc: 12
DISPATCH12
(UnaryPreInc, UnaryOperator);
90
75
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
91
75
      
case UO_AddrOf: 9
DISPATCH9
(UnaryAddrOf, UnaryOperator);
92
75
      
case UO_Deref: 52
DISPATCH52
(UnaryDeref, UnaryOperator);
93
75
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
94
75
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
95
75
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
96
75
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
97
75
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
98
75
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
99
75
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
100
75
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
101
2.08k
      }
102
2.08k
    }
103
2.08k
104
2.08k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
2.08k
    switch (S->getStmtClass()) {
106
2.08k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
107
2.08k
#define ABSTRACT_STMT(STMT)
108
2.08k
#define STMT(CLASS, PARENT)                              \
109
2.08k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
2.08k
#include 
"clang/AST/StmtNodes.inc"0
111
2.08k
    }
112
2.08k
  }
CFG.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::CFGBlockTerminatorPrint, void>::Visit(clang::Stmt*)
Line
Count
Source
43
519
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
519
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
519
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
519
    // below.
47
519
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
36
      switch (BinOp->getOpcode()) {
49
36
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
50
36
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
51
36
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
52
36
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
53
36
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
54
36
      
case BO_Add: 0
DISPATCH0
(BinAdd, BinaryOperator);
55
36
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
56
36
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
57
36
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
58
36
59
36
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
60
36
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
61
36
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
62
36
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
63
36
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
64
36
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
65
36
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
66
36
67
36
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
68
36
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
69
36
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
70
36
      
case BO_LAnd: 8
DISPATCH8
(BinLAnd, BinaryOperator);
71
36
      
case BO_LOr : 28
DISPATCH28
(BinLOr, BinaryOperator);
72
36
      
case BO_Assign: 0
DISPATCH0
(BinAssign, BinaryOperator);
73
36
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
74
36
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
75
36
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
76
36
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
77
36
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
78
36
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
79
36
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
80
36
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
81
36
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
82
36
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
83
36
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
84
483
      }
85
483
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
0
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
483
      }
102
483
    }
103
483
104
483
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
483
    switch (S->getStmtClass()) {
106
483
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
107
483
#define ABSTRACT_STMT(STMT)
108
483
#define STMT(CLASS, PARENT)                              \
109
483
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
483
#include 
"clang/AST/StmtNodes.inc"0
111
483
    }
112
483
  }
CallGraph.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::CGBuilder, void>::Visit(clang::Stmt*)
Line
Count
Source
43
261k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
261k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
261k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
261k
    // below.
47
261k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
15.2k
      switch (BinOp->getOpcode()) {
49
15.2k
      
case BO_PtrMemD: 22
DISPATCH22
(BinPtrMemD, BinaryOperator);
50
15.2k
      
case BO_PtrMemI: 6
DISPATCH6
(BinPtrMemI, BinaryOperator);
51
15.2k
      
case BO_Mul: 359
DISPATCH359
(BinMul, BinaryOperator);
52
15.2k
      
case BO_Div: 426
DISPATCH426
(BinDiv, BinaryOperator);
53
15.2k
      
case BO_Rem: 26
DISPATCH26
(BinRem, BinaryOperator);
54
15.2k
      
case BO_Add: 1.08k
DISPATCH1.08k
(BinAdd, BinaryOperator);
55
15.2k
      
case BO_Sub: 483
DISPATCH483
(BinSub, BinaryOperator);
56
15.2k
      
case BO_Shl: 57
DISPATCH57
(BinShl, BinaryOperator);
57
15.2k
      
case BO_Shr: 47
DISPATCH47
(BinShr, BinaryOperator);
58
15.2k
59
15.2k
      
case BO_LT: 871
DISPATCH871
(BinLT, BinaryOperator);
60
15.2k
      
case BO_GT: 494
DISPATCH494
(BinGT, BinaryOperator);
61
15.2k
      
case BO_LE: 281
DISPATCH281
(BinLE, BinaryOperator);
62
15.2k
      
case BO_GE: 229
DISPATCH229
(BinGE, BinaryOperator);
63
15.2k
      
case BO_EQ: 4.37k
DISPATCH4.37k
(BinEQ, BinaryOperator);
64
15.2k
      
case BO_NE: 675
DISPATCH675
(BinNE, BinaryOperator);
65
15.2k
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
66
15.2k
67
15.2k
      
case BO_And: 79
DISPATCH79
(BinAnd, BinaryOperator);
68
15.2k
      
case BO_Xor: 4
DISPATCH4
(BinXor, BinaryOperator);
69
15.2k
      
case BO_Or : 71
DISPATCH71
(BinOr, BinaryOperator);
70
15.2k
      
case BO_LAnd: 226
DISPATCH226
(BinLAnd, BinaryOperator);
71
15.2k
      
case BO_LOr : 221
DISPATCH221
(BinLOr, BinaryOperator);
72
15.2k
      
case BO_Assign: 4.71k
DISPATCH4.71k
(BinAssign, BinaryOperator);
73
15.2k
      
case BO_MulAssign: 14
DISPATCH14
(BinMulAssign, CompoundAssignOperator);
74
15.2k
      
case BO_DivAssign: 21
DISPATCH21
(BinDivAssign, CompoundAssignOperator);
75
15.2k
      
case BO_RemAssign: 5
DISPATCH5
(BinRemAssign, CompoundAssignOperator);
76
15.2k
      
case BO_AddAssign: 212
DISPATCH212
(BinAddAssign, CompoundAssignOperator);
77
15.2k
      
case BO_SubAssign: 92
DISPATCH92
(BinSubAssign, CompoundAssignOperator);
78
15.2k
      
case BO_ShlAssign: 8
DISPATCH8
(BinShlAssign, CompoundAssignOperator);
79
15.2k
      
case BO_ShrAssign: 2
DISPATCH2
(BinShrAssign, CompoundAssignOperator);
80
15.2k
      
case BO_AndAssign: 11
DISPATCH11
(BinAndAssign, CompoundAssignOperator);
81
15.2k
      
case BO_OrAssign: 9
DISPATCH9
(BinOrAssign, CompoundAssignOperator);
82
15.2k
      
case BO_XorAssign: 18
DISPATCH18
(BinXorAssign, CompoundAssignOperator);
83
15.2k
      
case BO_Comma: 97
DISPATCH97
(BinComma, BinaryOperator);
84
246k
      }
85
246k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {