Coverage Report

Created: 2018-07-20 23:04

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/tools/clang/include/clang/AST/StmtVisitor.h
Line
Count
Source (jump to first uncovered line)
1
//===- StmtVisitor.h - Visitor for Stmt subclasses --------------*- C++ -*-===//
2
//
3
//                     The LLVM Compiler Infrastructure
4
//
5
// This file is distributed under the University of Illinois Open Source
6
// License. See LICENSE.TXT for details.
7
//
8
//===----------------------------------------------------------------------===//
9
//
10
//  This file defines the StmtVisitor and ConstStmtVisitor interfaces.
11
//
12
//===----------------------------------------------------------------------===//
13
14
#ifndef LLVM_CLANG_AST_STMTVISITOR_H
15
#define LLVM_CLANG_AST_STMTVISITOR_H
16
17
#include "clang/AST/ExprCXX.h"
18
#include "clang/AST/ExprObjC.h"
19
#include "clang/AST/ExprOpenMP.h"
20
#include "clang/AST/Stmt.h"
21
#include "clang/AST/StmtCXX.h"
22
#include "clang/AST/StmtObjC.h"
23
#include "clang/AST/StmtOpenMP.h"
24
#include "clang/Basic/LLVM.h"
25
#include "llvm/Support/Casting.h"
26
#include "llvm/Support/ErrorHandling.h"
27
#include <utility>
28
29
namespace clang {
30
31
template <typename T> struct make_ptr { using type = T *; };
32
template <typename T> struct make_const_ptr { using type = const T *; };
33
34
/// StmtVisitorBase - This class implements a simple visitor for Stmt
35
/// subclasses. Since Expr derives from Stmt, this also includes support for
36
/// visiting Exprs.
37
template<template <typename> class Ptr, typename ImplClass, typename RetTy=void,
38
         class... ParamTys>
39
class StmtVisitorBase {
40
public:
41
#define PTR(CLASS) typename Ptr<CLASS>::type
42
#define DISPATCH(NAME, CLASS) \
43
200M
  return static_cast<ImplClass*>(this)->Visit ## NAME( \
44
200M
    static_cast<PTR(CLASS)>(S), std::forward<ParamTys>(P)...)
45
46
127M
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
127M
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
127M
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
127M
    // below.
50
127M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
13.0M
      switch (BinOp->getOpcode()) {
52
13.0M
      
case BO_PtrMemD: 65.7k
DISPATCH65.7k
(BinPtrMemD, BinaryOperator);
53
13.0M
      
case BO_PtrMemI: 396
DISPATCH396
(BinPtrMemI, BinaryOperator);
54
13.0M
      
case BO_Mul: 503k
DISPATCH503k
(BinMul, BinaryOperator);
55
13.0M
      
case BO_Div: 447k
DISPATCH447k
(BinDiv, BinaryOperator);
56
13.0M
      
case BO_Rem: 40.0k
DISPATCH40.0k
(BinRem, BinaryOperator);
57
13.0M
      
case BO_Add: 1.41M
DISPATCH1.41M
(BinAdd, BinaryOperator);
58
13.0M
      
case BO_Sub: 1.45M
DISPATCH1.45M
(BinSub, BinaryOperator);
59
13.0M
      
case BO_Shl: 375k
DISPATCH375k
(BinShl, BinaryOperator);
60
13.0M
      
case BO_Shr: 157k
DISPATCH157k
(BinShr, BinaryOperator);
61
13.0M
62
13.0M
      
case BO_LT: 869k
DISPATCH869k
(BinLT, BinaryOperator);
63
13.0M
      
case BO_GT: 618k
DISPATCH618k
(BinGT, BinaryOperator);
64
13.0M
      
case BO_LE: 229k
DISPATCH229k
(BinLE, BinaryOperator);
65
13.0M
      
case BO_GE: 169k
DISPATCH169k
(BinGE, BinaryOperator);
66
13.0M
      
case BO_EQ: 1.01M
DISPATCH1.01M
(BinEQ, BinaryOperator);
67
13.0M
      
case BO_NE: 446k
DISPATCH446k
(BinNE, BinaryOperator);
68
13.0M
      
case BO_Cmp: 477
DISPATCH477
(BinCmp, BinaryOperator);
69
13.0M
70
13.0M
      
case BO_And: 278k
DISPATCH278k
(BinAnd, BinaryOperator);
71
13.0M
      
case BO_Xor: 50.2k
DISPATCH50.2k
(BinXor, BinaryOperator);
72
13.0M
      
case BO_Or : 154k
DISPATCH154k
(BinOr, BinaryOperator);
73
13.0M
      
case BO_LAnd: 805k
DISPATCH805k
(BinLAnd, BinaryOperator);
74
13.0M
      
case BO_LOr : 378k
DISPATCH378k
(BinLOr, BinaryOperator);
75
13.0M
      
case BO_Assign: 3.14M
DISPATCH3.14M
(BinAssign, BinaryOperator);
76
13.0M
      
case BO_MulAssign: 13.3k
DISPATCH13.3k
(BinMulAssign, CompoundAssignOperator);
77
13.0M
      
case BO_DivAssign: 4.33k
DISPATCH4.33k
(BinDivAssign, CompoundAssignOperator);
78
13.0M
      
case BO_RemAssign: 429
DISPATCH429
(BinRemAssign, CompoundAssignOperator);
79
13.0M
      
case BO_AddAssign: 155k
DISPATCH155k
(BinAddAssign, CompoundAssignOperator);
80
13.0M
      
case BO_SubAssign: 20.5k
DISPATCH20.5k
(BinSubAssign, CompoundAssignOperator);
81
13.0M
      
case BO_ShlAssign: 7.03k
DISPATCH7.03k
(BinShlAssign, CompoundAssignOperator);
82
13.0M
      
case BO_ShrAssign: 3.67k
DISPATCH3.67k
(BinShrAssign, CompoundAssignOperator);
83
13.0M
      
case BO_AndAssign: 5.25k
DISPATCH5.25k
(BinAndAssign, CompoundAssignOperator);
84
13.0M
      
case BO_OrAssign: 39.0k
DISPATCH39.0k
(BinOrAssign, CompoundAssignOperator);
85
13.0M
      
case BO_XorAssign: 5.65k
DISPATCH5.65k
(BinXorAssign, CompoundAssignOperator);
86
13.0M
      
case BO_Comma: 194k
DISPATCH194k
(BinComma, BinaryOperator);
87
114M
      }
88
114M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
4.42M
      switch (UnOp->getOpcode()) {
90
4.42M
      
case UO_PostInc: 279k
DISPATCH279k
(UnaryPostInc, UnaryOperator);
91
4.42M
      
case UO_PostDec: 21.5k
DISPATCH21.5k
(UnaryPostDec, UnaryOperator);
92
4.42M
      
case UO_PreInc: 204k
DISPATCH204k
(UnaryPreInc, UnaryOperator);
93
4.42M
      
case UO_PreDec: 32.0k
DISPATCH32.0k
(UnaryPreDec, UnaryOperator);
94
4.42M
      
case UO_AddrOf: 457k
DISPATCH457k
(UnaryAddrOf, UnaryOperator);
95
4.42M
      
case UO_Deref: 478k
DISPATCH478k
(UnaryDeref, UnaryOperator);
96
4.42M
      
case UO_Plus: 1.13k
DISPATCH1.13k
(UnaryPlus, UnaryOperator);
97
4.42M
      
case UO_Minus: 538k
DISPATCH538k
(UnaryMinus, UnaryOperator);
98
4.42M
      
case UO_Not: 81.0k
DISPATCH81.0k
(UnaryNot, UnaryOperator);
99
4.42M
      
case UO_LNot: 2.29M
DISPATCH2.29M
(UnaryLNot, UnaryOperator);
100
4.42M
      
case UO_Real: 3.65k
DISPATCH3.65k
(UnaryReal, UnaryOperator);
101
4.42M
      
case UO_Imag: 3.60k
DISPATCH3.60k
(UnaryImag, UnaryOperator);
102
4.42M
      
case UO_Extension: 32.4k
DISPATCH32.4k
(UnaryExtension, UnaryOperator);
103
4.42M
      
case UO_Coawait: 10
DISPATCH10
(UnaryCoawait, UnaryOperator);
104
109M
      }
105
109M
    }
106
109M
107
109M
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
109M
    switch (S->getStmtClass()) {
109
109M
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
109M
#define ABSTRACT_STMT(STMT)
111
109M
#define STMT(CLASS, PARENT)                              \
112
109M
    case Stmt::CLASS ## Class: 
DISPATCH109M
(CLASS, CLASS);
113
109M
#include 
"clang/AST/StmtNodes.inc"47.5k
114
109M
    }
115
109M
  }
CGClass.cpp:clang::StmtVisitorBase<clang::make_const_ptr, (anonymous namespace)::DynamicThisUseChecker, void>::Visit(clang::Stmt const*)
Line
Count
Source
46
27.0k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
27.0k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
27.0k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
27.0k
    // below.
50
27.0k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
11
      switch (BinOp->getOpcode()) {
52
11
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
11
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
11
      
case BO_Mul: 1
DISPATCH1
(BinMul, BinaryOperator);
55
11
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
56
11
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
57
11
      
case BO_Add: 10
DISPATCH10
(BinAdd, BinaryOperator);
58
11
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
59
11
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
60
11
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
61
11
62
11
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
63
11
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
64
11
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
65
11
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
66
11
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
67
11
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
68
11
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
11
70
11
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
71
11
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
72
11
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
73
11
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
74
11
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
75
11
      
case BO_Assign: 0
DISPATCH0
(BinAssign, BinaryOperator);
76
11
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
77
11
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
78
11
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
11
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
80
11
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
81
11
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
82
11
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
11
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
11
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
11
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
11
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
87
27.0k
      }
88
27.0k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
88
      switch (UnOp->getOpcode()) {
90
88
      
case UO_PostInc: 0
DISPATCH0
(UnaryPostInc, UnaryOperator);
91
88
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
92
88
      
case UO_PreInc: 0
DISPATCH0
(UnaryPreInc, UnaryOperator);
93
88
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
94
88
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
95
88
      
case UO_Deref: 0
DISPATCH0
(UnaryDeref, UnaryOperator);
96
88
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
97
88
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
98
88
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
99
88
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
100
88
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
101
88
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
102
88
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
103
88
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
26.9k
      }
105
26.9k
    }
106
26.9k
107
26.9k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
26.9k
    switch (S->getStmtClass()) {
109
26.9k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
26.9k
#define ABSTRACT_STMT(STMT)
111
26.9k
#define STMT(CLASS, PARENT)                              \
112
26.9k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
26.9k
#include 
"clang/AST/StmtNodes.inc"0
114
26.9k
    }
115
26.9k
  }
CGCoroutine.cpp:clang::StmtVisitorBase<clang::make_ptr, (anonymous namespace)::GetParamRef, void>::Visit(clang::Stmt*)
Line
Count
Source
46
70
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
70
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
70
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
70
    // below.
50
70
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
0
      switch (BinOp->getOpcode()) {
52
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
53
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
54
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
55
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
56
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
57
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
58
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
59
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
60
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
61
0
62
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
63
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
64
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
65
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
66
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
67
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
68
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
69
0
70
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
71
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
72
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
73
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
74
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
75
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
76
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
77
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
78
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
79
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
80
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
81
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
82
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
83
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
84
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
85
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
86
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
87
70
      }
88
70
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
0
      switch (UnOp->getOpcode()) {
90
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
91
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
92
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
93
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
94
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
95
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
96
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
97
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
98
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
99
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
100
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
101
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
102
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
103
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
104
70
      }
105
70
    }
106
70
107
70
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
70
    switch (S->getStmtClass()) {
109
70
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
70
#define ABSTRACT_STMT(STMT)
111
70
#define STMT(CLASS, PARENT)                              \
112
70
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
70
#include 
"clang/AST/StmtNodes.inc"0
114
70
    }
115
70
  }
CGException.cpp:clang::StmtVisitorBase<clang::make_const_ptr, (anonymous namespace)::CaptureFinder, void>::Visit(clang::Stmt const*)
Line
Count
Source
46
319
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
319
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
319
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
319
    // below.
50
319
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
20
      switch (BinOp->getOpcode()) {
52
20
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
20
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
20
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
55
20
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
56
20
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
57
20
      
case BO_Add: 0
DISPATCH0
(BinAdd, BinaryOperator);
58
20
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
59
20
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
60
20
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
61
20
62
20
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
63
20
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
64
20
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
65
20
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
66
20
      
case BO_EQ: 10
DISPATCH10
(BinEQ, BinaryOperator);
67
20
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
68
20
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
20
70
20
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
71
20
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
72
20
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
73
20
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
74
20
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
75
20
      
case BO_Assign: 10
DISPATCH10
(BinAssign, BinaryOperator);
76
20
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
77
20
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
78
20
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
20
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
80
20
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
81
20
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
82
20
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
20
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
20
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
20
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
20
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
87
299
      }
88
299
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
8
      switch (UnOp->getOpcode()) {
90
8
      
case UO_PostInc: 0
DISPATCH0
(UnaryPostInc, UnaryOperator);
91
8
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
92
8
      
case UO_PreInc: 4
DISPATCH4
(UnaryPreInc, UnaryOperator);
93
8
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
94
8
      
case UO_AddrOf: 0
DISPATCH0
(UnaryAddrOf, UnaryOperator);
95
8
      
case UO_Deref: 0
DISPATCH0
(UnaryDeref, UnaryOperator);
96
8
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
97
8
      
case UO_Minus: 4
DISPATCH4
(UnaryMinus, UnaryOperator);
98
8
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
99
8
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
100
8
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
101
8
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
102
8
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
103
8
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
291
      }
105
291
    }
106
291
107
291
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
291
    switch (S->getStmtClass()) {
109
291
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
291
#define ABSTRACT_STMT(STMT)
111
291
#define STMT(CLASS, PARENT)                              \
112
291
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
291
#include 
"clang/AST/StmtNodes.inc"0
114
291
    }
115
291
  }
CGExprAgg.cpp:clang::StmtVisitorBase<clang::make_ptr, (anonymous namespace)::AggExprEmitter, void>::Visit(clang::Stmt*)
Line
Count
Source
46
172k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
172k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
172k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
172k
    // below.
50
172k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
1.36k
      switch (BinOp->getOpcode()) {
52
1.36k
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
1.36k
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
1.36k
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
55
1.36k
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
56
1.36k
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
57
1.36k
      
case BO_Add: 0
DISPATCH0
(BinAdd, BinaryOperator);
58
1.36k
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
59
1.36k
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
60
1.36k
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
61
1.36k
62
1.36k
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
63
1.36k
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
64
1.36k
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
65
1.36k
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
66
1.36k
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
67
1.36k
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
68
1.36k
      
case BO_Cmp: 17
DISPATCH17
(BinCmp, BinaryOperator);
69
1.36k
70
1.36k
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
71
1.36k
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
72
1.36k
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
73
1.36k
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
74
1.36k
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
75
1.36k
      
case BO_Assign: 1.30k
DISPATCH1.30k
(BinAssign, BinaryOperator);
76
1.36k
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
77
1.36k
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
78
1.36k
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
1.36k
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
80
1.36k
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
81
1.36k
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
82
1.36k
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
1.36k
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
1.36k
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
1.36k
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
1.36k
      
case BO_Comma: 46
DISPATCH46
(BinComma, BinaryOperator);
87
171k
      }
88
171k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
1.09k
      switch (UnOp->getOpcode()) {
90
1.09k
      
case UO_PostInc: 0
DISPATCH0
(UnaryPostInc, UnaryOperator);
91
1.09k
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
92
1.09k
      
case UO_PreInc: 0
DISPATCH0
(UnaryPreInc, UnaryOperator);
93
1.09k
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
94
1.09k
      
case UO_AddrOf: 0
DISPATCH0
(UnaryAddrOf, UnaryOperator);
95
1.09k
      
case UO_Deref: 274
DISPATCH274
(UnaryDeref, UnaryOperator);
96
1.09k
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
97
1.09k
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
98
1.09k
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
99
1.09k
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
100
1.09k
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
101
1.09k
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
102
1.09k
      
case UO_Extension: 825
DISPATCH825
(UnaryExtension, UnaryOperator);
103
1.09k
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
170k
      }
105
170k
    }
106
170k
107
170k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
170k
    switch (S->getStmtClass()) {
109
170k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
170k
#define ABSTRACT_STMT(STMT)
111
170k
#define STMT(CLASS, PARENT)                              \
112
170k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
170k
#include 
"clang/AST/StmtNodes.inc"0
114
170k
    }
115
170k
  }
CGExprComplex.cpp:clang::StmtVisitorBase<clang::make_ptr, (anonymous namespace)::ComplexExprEmitter, std::__1::pair<llvm::Value*, llvm::Value*> >::Visit(clang::Stmt*)
Line
Count
Source
46
4.29k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
4.29k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
4.29k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
4.29k
    // below.
50
4.29k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
697
      switch (BinOp->getOpcode()) {
52
697
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
697
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
697
      
case BO_Mul: 122
DISPATCH122
(BinMul, BinaryOperator);
55
697
      
case BO_Div: 86
DISPATCH86
(BinDiv, BinaryOperator);
56
697
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
57
697
      
case BO_Add: 201
DISPATCH201
(BinAdd, BinaryOperator);
58
697
      
case BO_Sub: 112
DISPATCH112
(BinSub, BinaryOperator);
59
697
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
60
697
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
61
697
62
697
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
63
697
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
64
697
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
65
697
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
66
697
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
67
697
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
68
697
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
697
70
697
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
71
697
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
72
697
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
73
697
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
74
697
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
75
697
      
case BO_Assign: 160
DISPATCH160
(BinAssign, BinaryOperator);
76
697
      
case BO_MulAssign: 1
DISPATCH1
(BinMulAssign, CompoundAssignOperator);
77
697
      
case BO_DivAssign: 4
DISPATCH4
(BinDivAssign, CompoundAssignOperator);
78
697
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
697
      
case BO_AddAssign: 11
DISPATCH11
(BinAddAssign, CompoundAssignOperator);
80
697
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
81
697
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
82
697
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
697
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
697
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
697
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
697
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
87
3.60k
      }
88
3.60k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
36
      switch (UnOp->getOpcode()) {
90
36
      
case UO_PostInc: 2
DISPATCH2
(UnaryPostInc, UnaryOperator);
91
36
      
case UO_PostDec: 2
DISPATCH2
(UnaryPostDec, UnaryOperator);
92
36
      
case UO_PreInc: 2
DISPATCH2
(UnaryPreInc, UnaryOperator);
93
36
      
case UO_PreDec: 2
DISPATCH2
(UnaryPreDec, UnaryOperator);
94
36
      
case UO_AddrOf: 0
DISPATCH0
(UnaryAddrOf, UnaryOperator);
95
36
      
case UO_Deref: 4
DISPATCH4
(UnaryDeref, UnaryOperator);
96
36
      
case UO_Plus: 5
DISPATCH5
(UnaryPlus, UnaryOperator);
97
36
      
case UO_Minus: 4
DISPATCH4
(UnaryMinus, UnaryOperator);
98
36
      
case UO_Not: 3
DISPATCH3
(UnaryNot, UnaryOperator);
99
36
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
100
36
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
101
36
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
102
36
      
case UO_Extension: 12
DISPATCH12
(UnaryExtension, UnaryOperator);
103
36
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
3.56k
      }
105
3.56k
    }
106
3.56k
107
3.56k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
3.56k
    switch (S->getStmtClass()) {
109
3.56k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
3.56k
#define ABSTRACT_STMT(STMT)
111
3.56k
#define STMT(CLASS, PARENT)                              \
112
3.56k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
3.56k
#include 
"clang/AST/StmtNodes.inc"0
114
3.56k
    }
115
3.56k
  }
CGExprConstant.cpp:clang::StmtVisitorBase<clang::make_const_ptr, (anonymous namespace)::ConstantLValueEmitter, (anonymous namespace)::ConstantLValue>::Visit(clang::Stmt const*)
Line
Count
Source
46
14.6k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
14.6k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
14.6k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
14.6k
    // below.
50
14.6k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
0
      switch (BinOp->getOpcode()) {
52
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
53
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
54
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
55
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
56
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
57
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
58
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
59
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
60
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
61
0
62
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
63
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
64
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
65
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
66
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
67
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
68
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
69
0
70
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
71
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
72
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
73
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
74
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
75
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
76
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
77
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
78
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
79
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
80
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
81
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
82
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
83
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
84
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
85
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
86
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
87
14.6k
      }
88
14.6k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
0
      switch (UnOp->getOpcode()) {
90
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
91
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
92
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
93
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
94
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
95
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
96
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
97
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
98
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
99
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
100
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
101
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
102
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
103
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
104
14.6k
      }
105
14.6k
    }
106
14.6k
107
14.6k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
14.6k
    switch (S->getStmtClass()) {
109
14.6k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
14.6k
#define ABSTRACT_STMT(STMT)
111
14.6k
#define STMT(CLASS, PARENT)                              \
112
14.6k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
14.6k
#include 
"clang/AST/StmtNodes.inc"0
114
14.6k
    }
115
14.6k
  }
CGExprConstant.cpp:clang::StmtVisitorBase<clang::make_ptr, (anonymous namespace)::ConstExprEmitter, llvm::Constant*, clang::QualType>::Visit(clang::Stmt*, clang::QualType)
Line
Count
Source
46
37.1k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
37.1k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
37.1k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
37.1k
    // below.
50
37.1k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
115
      switch (BinOp->getOpcode()) {
52
115
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
115
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
115
      
case BO_Mul: 4
DISPATCH4
(BinMul, BinaryOperator);
55
115
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
56
115
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
57
115
      
case BO_Add: 81
DISPATCH81
(BinAdd, BinaryOperator);
58
115
      
case BO_Sub: 7
DISPATCH7
(BinSub, BinaryOperator);
59
115
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
60
115
      
case BO_Shr: 1
DISPATCH1
(BinShr, BinaryOperator);
61
115
62
115
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
63
115
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
64
115
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
65
115
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
66
115
      
case BO_EQ: 10
DISPATCH10
(BinEQ, BinaryOperator);
67
115
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
68
115
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
115
70
115
      
case BO_And: 1
DISPATCH1
(BinAnd, BinaryOperator);
71
115
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
72
115
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
73
115
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
74
115
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
75
115
      
case BO_Assign: 4
DISPATCH4
(BinAssign, BinaryOperator);
76
115
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
77
115
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
78
115
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
115
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
80
115
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
81
115
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
82
115
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
115
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
115
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
115
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
115
      
case BO_Comma: 7
DISPATCH7
(BinComma, BinaryOperator);
87
37.0k
      }
88
37.0k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
50
      switch (UnOp->getOpcode()) {
90
50
      
case UO_PostInc: 1
DISPATCH1
(UnaryPostInc, UnaryOperator);
91
50
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
92
50
      
case UO_PreInc: 2
DISPATCH2
(UnaryPreInc, UnaryOperator);
93
50
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
94
50
      
case UO_AddrOf: 29
DISPATCH29
(UnaryAddrOf, UnaryOperator);
95
50
      
case UO_Deref: 15
DISPATCH15
(UnaryDeref, UnaryOperator);
96
50
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
97
50
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
98
50
      
case UO_Not: 3
DISPATCH3
(UnaryNot, UnaryOperator);
99
50
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
100
50
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
101
50
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
102
50
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
103
50
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
37.0k
      }
105
37.0k
    }
106
37.0k
107
37.0k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
37.0k
    switch (S->getStmtClass()) {
109
37.0k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
37.0k
#define ABSTRACT_STMT(STMT)
111
37.0k
#define STMT(CLASS, PARENT)                              \
112
37.0k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
37.0k
#include 
"clang/AST/StmtNodes.inc"0
114
37.0k
    }
115
37.0k
  }
CGExprScalar.cpp:clang::StmtVisitorBase<clang::make_ptr, (anonymous namespace)::ScalarExprEmitter, llvm::Value*>::Visit(clang::Stmt*)
Line
Count
Source
46
9.25M
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
9.25M
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
9.25M
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
9.25M
    // below.
50
9.25M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
1.02M
      switch (BinOp->getOpcode()) {
52
1.02M
      
case BO_PtrMemD: 21
DISPATCH21
(BinPtrMemD, BinaryOperator);
53
1.02M
      
case BO_PtrMemI: 15
DISPATCH15
(BinPtrMemI, BinaryOperator);
54
1.02M
      
case BO_Mul: 66.9k
DISPATCH66.9k
(BinMul, BinaryOperator);
55
1.02M
      
case BO_Div: 39.4k
DISPATCH39.4k
(BinDiv, BinaryOperator);
56
1.02M
      
case BO_Rem: 3.41k
DISPATCH3.41k
(BinRem, BinaryOperator);
57
1.02M
      
case BO_Add: 140k
DISPATCH140k
(BinAdd, BinaryOperator);
58
1.02M
      
case BO_Sub: 139k
DISPATCH139k
(BinSub, BinaryOperator);
59
1.02M
      
case BO_Shl: 28.7k
DISPATCH28.7k
(BinShl, BinaryOperator);
60
1.02M
      
case BO_Shr: 20.7k
DISPATCH20.7k
(BinShr, BinaryOperator);
61
1.02M
62
1.02M
      
case BO_LT: 53.1k
DISPATCH53.1k
(BinLT, BinaryOperator);
63
1.02M
      
case BO_GT: 32.7k
DISPATCH32.7k
(BinGT, BinaryOperator);
64
1.02M
      
case BO_LE: 17.5k
DISPATCH17.5k
(BinLE, BinaryOperator);
65
1.02M
      
case BO_GE: 13.1k
DISPATCH13.1k
(BinGE, BinaryOperator);
66
1.02M
      
case BO_EQ: 78.4k
DISPATCH78.4k
(BinEQ, BinaryOperator);
67
1.02M
      
case BO_NE: 40.3k
DISPATCH40.3k
(BinNE, BinaryOperator);
68
1.02M
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
1.02M
70
1.02M
      
case BO_And: 26.3k
DISPATCH26.3k
(BinAnd, BinaryOperator);
71
1.02M
      
case BO_Xor: 7.09k
DISPATCH7.09k
(BinXor, BinaryOperator);
72
1.02M
      
case BO_Or : 11.6k
DISPATCH11.6k
(BinOr, BinaryOperator);
73
1.02M
      
case BO_LAnd: 5.90k
DISPATCH5.90k
(BinLAnd, BinaryOperator);
74
1.02M
      
case BO_LOr : 2.04k
DISPATCH2.04k
(BinLOr, BinaryOperator);
75
1.02M
      
case BO_Assign: 255k
DISPATCH255k
(BinAssign, BinaryOperator);
76
1.02M
      
case BO_MulAssign: 785
DISPATCH785
(BinMulAssign, CompoundAssignOperator);
77
1.02M
      
case BO_DivAssign: 348
DISPATCH348
(BinDivAssign, CompoundAssignOperator);
78
1.02M
      
case BO_RemAssign: 53
DISPATCH53
(BinRemAssign, CompoundAssignOperator);
79
1.02M
      
case BO_AddAssign: 17.0k
DISPATCH17.0k
(BinAddAssign, CompoundAssignOperator);
80
1.02M
      
case BO_SubAssign: 2.75k
DISPATCH2.75k
(BinSubAssign, CompoundAssignOperator);
81
1.02M
      
case BO_ShlAssign: 863
DISPATCH863
(BinShlAssign, CompoundAssignOperator);
82
1.02M
      
case BO_ShrAssign: 812
DISPATCH812
(BinShrAssign, CompoundAssignOperator);
83
1.02M
      
case BO_AndAssign: 626
DISPATCH626
(BinAndAssign, CompoundAssignOperator);
84
1.02M
      
case BO_OrAssign: 2.62k
DISPATCH2.62k
(BinOrAssign, CompoundAssignOperator);
85
1.02M
      
case BO_XorAssign: 730
DISPATCH730
(BinXorAssign, CompoundAssignOperator);
86
1.02M
      
case BO_Comma: 14.1k
DISPATCH14.1k
(BinComma, BinaryOperator);
87
8.23M
      }
88
8.23M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
264k
      switch (UnOp->getOpcode()) {
90
264k
      
case UO_PostInc: 39.6k
DISPATCH39.6k
(UnaryPostInc, UnaryOperator);
91
264k
      
case UO_PostDec: 3.68k
DISPATCH3.68k
(UnaryPostDec, UnaryOperator);
92
264k
      
case UO_PreInc: 3.43k
DISPATCH3.43k
(UnaryPreInc, UnaryOperator);
93
264k
      
case UO_PreDec: 2.72k
DISPATCH2.72k
(UnaryPreDec, UnaryOperator);
94
264k
      
case UO_AddrOf: 66.8k
DISPATCH66.8k
(UnaryAddrOf, UnaryOperator);
95
264k
      
case UO_Deref: 24.3k
DISPATCH24.3k
(UnaryDeref, UnaryOperator);
96
264k
      
case UO_Plus: 147
DISPATCH147
(UnaryPlus, UnaryOperator);
97
264k
      
case UO_Minus: 30.9k
DISPATCH30.9k
(UnaryMinus, UnaryOperator);
98
264k
      
case UO_Not: 5.65k
DISPATCH5.65k
(UnaryNot, UnaryOperator);
99
264k
      
case UO_LNot: 77.1k
DISPATCH77.1k
(UnaryLNot, UnaryOperator);
100
264k
      
case UO_Real: 238
DISPATCH238
(UnaryReal, UnaryOperator);
101
264k
      
case UO_Imag: 225
DISPATCH225
(UnaryImag, UnaryOperator);
102
264k
      
case UO_Extension: 9.02k
DISPATCH9.02k
(UnaryExtension, UnaryOperator);
103
264k
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
7.96M
      }
105
7.96M
    }
106
7.96M
107
7.96M
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
7.96M
    switch (S->getStmtClass()) {
109
7.96M
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
7.96M
#define ABSTRACT_STMT(STMT)
111
7.96M
#define STMT(CLASS, PARENT)                              \
112
7.96M
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
7.96M
#include 
"clang/AST/StmtNodes.inc"0
114
7.96M
    }
115
7.96M
  }
CGOpenMPRuntimeNVPTX.cpp:clang::StmtVisitorBase<clang::make_const_ptr, (anonymous namespace)::CheckVarsEscapingDeclContext, void>::Visit(clang::Stmt const*)
Line
Count
Source
46
1.50k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
1.50k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
1.50k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
1.50k
    // below.
50
1.50k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
207
      switch (BinOp->getOpcode()) {
52
207
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
207
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
207
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
55
207
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
56
207
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
57
207
      
case BO_Add: 30
DISPATCH30
(BinAdd, BinaryOperator);
58
207
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
59
207
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
60
207
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
61
207
62
207
      
case BO_LT: 6
DISPATCH6
(BinLT, BinaryOperator);
63
207
      
case BO_GT: 3
DISPATCH3
(BinGT, BinaryOperator);
64
207
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
65
207
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
66
207
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
67
207
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
68
207
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
207
70
207
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
71
207
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
72
207
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
73
207
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
74
207
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
75
207
      
case BO_Assign: 72
DISPATCH72
(BinAssign, BinaryOperator);
76
207
      
case BO_MulAssign: 3
DISPATCH3
(BinMulAssign, CompoundAssignOperator);
77
207
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
78
207
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
207
      
case BO_AddAssign: 87
DISPATCH87
(BinAddAssign, CompoundAssignOperator);
80
207
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
81
207
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
82
207
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
207
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
207
      
case BO_OrAssign: 3
DISPATCH3
(BinOrAssign, CompoundAssignOperator);
85
207
      
case BO_XorAssign: 3
DISPATCH3
(BinXorAssign, CompoundAssignOperator);
86
207
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
87
1.29k
      }
88
1.29k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
41
      switch (UnOp->getOpcode()) {
90
41
      
case UO_PostInc: 4
DISPATCH4
(UnaryPostInc, UnaryOperator);
91
41
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
92
41
      
case UO_PreInc: 12
DISPATCH12
(UnaryPreInc, UnaryOperator);
93
41
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
94
41
      
case UO_AddrOf: 25
DISPATCH25
(UnaryAddrOf, UnaryOperator);
95
41
      
case UO_Deref: 0
DISPATCH0
(UnaryDeref, UnaryOperator);
96
41
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
97
41
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
98
41
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
99
41
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
100
41
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
101
41
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
102
41
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
103
41
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
1.25k
      }
105
1.25k
    }
106
1.25k
107
1.25k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
1.25k
    switch (S->getStmtClass()) {
109
1.25k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
1.25k
#define ABSTRACT_STMT(STMT)
111
1.25k
#define STMT(CLASS, PARENT)                              \
112
1.25k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
1.25k
#include 
"clang/AST/StmtNodes.inc"0
114
1.25k
    }
115
1.25k
  }
CodeGenPGO.cpp:clang::StmtVisitorBase<clang::make_const_ptr, (anonymous namespace)::ComputeRegionCounts, void>::Visit(clang::Stmt const*)
Line
Count
Source
46
3.30k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
3.30k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
3.30k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
3.30k
    // below.
50
3.30k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
310
      switch (BinOp->getOpcode()) {
52
310
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
310
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
310
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
55
310
      
case BO_Div: 4
DISPATCH4
(BinDiv, BinaryOperator);
56
310
      
case BO_Rem: 33
DISPATCH33
(BinRem, BinaryOperator);
57
310
      
case BO_Add: 16
DISPATCH16
(BinAdd, BinaryOperator);
58
310
      
case BO_Sub: 10
DISPATCH10
(BinSub, BinaryOperator);
59
310
      
case BO_Shl: 3
DISPATCH3
(BinShl, BinaryOperator);
60
310
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
61
310
62
310
      
case BO_LT: 83
DISPATCH83
(BinLT, BinaryOperator);
63
310
      
case BO_GT: 22
DISPATCH22
(BinGT, BinaryOperator);
64
310
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
65
310
      
case BO_GE: 1
DISPATCH1
(BinGE, BinaryOperator);
66
310
      
case BO_EQ: 5
DISPATCH5
(BinEQ, BinaryOperator);
67
310
      
case BO_NE: 9
DISPATCH9
(BinNE, BinaryOperator);
68
310
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
310
70
310
      
case BO_And: 2
DISPATCH2
(BinAnd, BinaryOperator);
71
310
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
72
310
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
73
310
      
case BO_LAnd: 19
DISPATCH19
(BinLAnd, BinaryOperator);
74
310
      
case BO_LOr : 18
DISPATCH18
(BinLOr, BinaryOperator);
75
310
      
case BO_Assign: 76
DISPATCH76
(BinAssign, BinaryOperator);
76
310
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
77
310
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
78
310
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
310
      
case BO_AddAssign: 9
DISPATCH9
(BinAddAssign, CompoundAssignOperator);
80
310
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
81
310
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
82
310
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
310
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
310
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
310
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
310
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
87
2.99k
      }
88
2.99k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
142
      switch (UnOp->getOpcode()) {
90
142
      
case UO_PostInc: 27
DISPATCH27
(UnaryPostInc, UnaryOperator);
91
142
      
case UO_PostDec: 9
DISPATCH9
(UnaryPostDec, UnaryOperator);
92
142
      
case UO_PreInc: 82
DISPATCH82
(UnaryPreInc, UnaryOperator);
93
142
      
case UO_PreDec: 8
DISPATCH8
(UnaryPreDec, UnaryOperator);
94
142
      
case UO_AddrOf: 0
DISPATCH0
(UnaryAddrOf, UnaryOperator);
95
142
      
case UO_Deref: 9
DISPATCH9
(UnaryDeref, UnaryOperator);
96
142
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
97
142
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
98
142
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
99
142
      
case UO_LNot: 7
DISPATCH7
(UnaryLNot, UnaryOperator);
100
142
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
101
142
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
102
142
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
103
142
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
2.85k
      }
105
2.85k
    }
106
2.85k
107
2.85k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
2.85k
    switch (S->getStmtClass()) {
109
2.85k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
2.85k
#define ABSTRACT_STMT(STMT)
111
2.85k
#define STMT(CLASS, PARENT)                              \
112
2.85k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
2.85k
#include 
"clang/AST/StmtNodes.inc"0
114
2.85k
    }
115
2.85k
  }
CoverageMappingGen.cpp:clang::StmtVisitorBase<clang::make_const_ptr, (anonymous namespace)::CounterCoverageMappingBuilder, void>::Visit(clang::Stmt const*)
Line
Count
Source
46
2.56k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
2.56k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
2.56k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
2.56k
    // below.
50
2.56k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
225
      switch (BinOp->getOpcode()) {
52
225
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
225
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
225
      
case BO_Mul: 3
DISPATCH3
(BinMul, BinaryOperator);
55
225
      
case BO_Div: 1
DISPATCH1
(BinDiv, BinaryOperator);
56
225
      
case BO_Rem: 3
DISPATCH3
(BinRem, BinaryOperator);
57
225
      
case BO_Add: 12
DISPATCH12
(BinAdd, BinaryOperator);
58
225
      
case BO_Sub: 2
DISPATCH2
(BinSub, BinaryOperator);
59
225
      
case BO_Shl: 1
DISPATCH1
(BinShl, BinaryOperator);
60
225
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
61
225
62
225
      
case BO_LT: 42
DISPATCH42
(BinLT, BinaryOperator);
63
225
      
case BO_GT: 4
DISPATCH4
(BinGT, BinaryOperator);
64
225
      
case BO_LE: 1
DISPATCH1
(BinLE, BinaryOperator);
65
225
      
case BO_GE: 2
DISPATCH2
(BinGE, BinaryOperator);
66
225
      
case BO_EQ: 39
DISPATCH39
(BinEQ, BinaryOperator);
67
225
      
case BO_NE: 3
DISPATCH3
(BinNE, BinaryOperator);
68
225
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
225
70
225
      
case BO_And: 2
DISPATCH2
(BinAnd, BinaryOperator);
71
225
      
case BO_Xor: 1
DISPATCH1
(BinXor, BinaryOperator);
72
225
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
73
225
      
case BO_LAnd: 3
DISPATCH3
(BinLAnd, BinaryOperator);
74
225
      
case BO_LOr : 5
DISPATCH5
(BinLOr, BinaryOperator);
75
225
      
case BO_Assign: 98
DISPATCH98
(BinAssign, BinaryOperator);
76
225
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
77
225
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
78
225
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
225
      
case BO_AddAssign: 1
DISPATCH1
(BinAddAssign, CompoundAssignOperator);
80
225
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
81
225
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
82
225
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
225
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
225
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
225
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
225
      
case BO_Comma: 2
DISPATCH2
(BinComma, BinaryOperator);
87
2.34k
      }
88
2.34k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
59
      switch (UnOp->getOpcode()) {
90
59
      
case UO_PostInc: 3
DISPATCH3
(UnaryPostInc, UnaryOperator);
91
59
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
92
59
      
case UO_PreInc: 39
DISPATCH39
(UnaryPreInc, UnaryOperator);
93
59
      
case UO_PreDec: 2
DISPATCH2
(UnaryPreDec, UnaryOperator);
94
59
      
case UO_AddrOf: 0
DISPATCH0
(UnaryAddrOf, UnaryOperator);
95
59
      
case UO_Deref: 4
DISPATCH4
(UnaryDeref, UnaryOperator);
96
59
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
97
59
      
case UO_Minus: 1
DISPATCH1
(UnaryMinus, UnaryOperator);
98
59
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
99
59
      
case UO_LNot: 10
DISPATCH10
(UnaryLNot, UnaryOperator);
100
59
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
101
59
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
102
59
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
103
59
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
2.28k
      }
105
2.28k
    }
106
2.28k
107
2.28k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
2.28k
    switch (S->getStmtClass()) {
109
2.28k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
2.28k
#define ABSTRACT_STMT(STMT)
111
2.28k
#define STMT(CLASS, PARENT)                              \
112
2.28k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
2.28k
#include 
"clang/AST/StmtNodes.inc"0
114
2.28k
    }
115
2.28k
  }
TransEmptyStatementsAndDealloc.cpp:clang::StmtVisitorBase<clang::make_ptr, (anonymous namespace)::EmptyChecker, bool>::Visit(clang::Stmt*)
Line
Count
Source
46
1.07k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
1.07k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
1.07k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
1.07k
    // below.
50
1.07k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
67
      switch (BinOp->getOpcode()) {
52
67
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
67
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
67
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
55
67
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
56
67
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
57
67
      
case BO_Add: 0
DISPATCH0
(BinAdd, BinaryOperator);
58
67
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
59
67
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
60
67
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
61
67
62
67
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
63
67
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
64
67
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
65
67
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
66
67
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
67
67
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
68
67
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
67
70
67
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
71
67
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
72
67
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
73
67
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
74
67
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
75
67
      
case BO_Assign: 64
DISPATCH64
(BinAssign, BinaryOperator);
76
67
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
77
67
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
78
67
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
67
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
80
67
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
81
67
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
82
67
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
67
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
67
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
67
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
67
      
case BO_Comma: 3
DISPATCH3
(BinComma, BinaryOperator);
87
1.01k
      }
88
1.01k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
12
      switch (UnOp->getOpcode()) {
90
12
      
case UO_PostInc: 2
DISPATCH2
(UnaryPostInc, UnaryOperator);
91
12
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
92
12
      
case UO_PreInc: 10
DISPATCH10
(UnaryPreInc, UnaryOperator);
93
12
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
94
12
      
case UO_AddrOf: 0
DISPATCH0
(UnaryAddrOf, UnaryOperator);
95
12
      
case UO_Deref: 0
DISPATCH0
(UnaryDeref, UnaryOperator);
96
12
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
97
12
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
98
12
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
99
12
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
100
12
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
101
12
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
102
12
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
103
12
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
1.00k
      }
105
1.00k
    }
106
1.00k
107
1.00k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
1.00k
    switch (S->getStmtClass()) {
109
1.00k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
1.00k
#define ABSTRACT_STMT(STMT)
111
1.00k
#define STMT(CLASS, PARENT)                              \
112
1.00k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
1.00k
#include 
"clang/AST/StmtNodes.inc"0
114
1.00k
    }
115
1.00k
  }
CStringSyntaxChecker.cpp:clang::StmtVisitorBase<clang::make_ptr, (anonymous namespace)::WalkAST, void>::Visit(clang::Stmt*)
Line
Count
Source
46
36.5k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
36.5k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
36.5k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
36.5k
    // below.
50
36.5k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
1.99k
      switch (BinOp->getOpcode()) {
52
1.99k
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
1.99k
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
1.99k
      
case BO_Mul: 116
DISPATCH116
(BinMul, BinaryOperator);
55
1.99k
      
case BO_Div: 22
DISPATCH22
(BinDiv, BinaryOperator);
56
1.99k
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
57
1.99k
      
case BO_Add: 210
DISPATCH210
(BinAdd, BinaryOperator);
58
1.99k
      
case BO_Sub: 26
DISPATCH26
(BinSub, BinaryOperator);
59
1.99k
      
case BO_Shl: 2
DISPATCH2
(BinShl, BinaryOperator);
60
1.99k
      
case BO_Shr: 2
DISPATCH2
(BinShr, BinaryOperator);
61
1.99k
62
1.99k
      
case BO_LT: 169
DISPATCH169
(BinLT, BinaryOperator);
63
1.99k
      
case BO_GT: 102
DISPATCH102
(BinGT, BinaryOperator);
64
1.99k
      
case BO_LE: 43
DISPATCH43
(BinLE, BinaryOperator);
65
1.99k
      
case BO_GE: 103
DISPATCH103
(BinGE, BinaryOperator);
66
1.99k
      
case BO_EQ: 921
DISPATCH921
(BinEQ, BinaryOperator);
67
1.99k
      
case BO_NE: 86
DISPATCH86
(BinNE, BinaryOperator);
68
1.99k
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
1.99k
70
1.99k
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
71
1.99k
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
72
1.99k
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
73
1.99k
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
74
1.99k
      
case BO_LOr : 1
DISPATCH1
(BinLOr, BinaryOperator);
75
1.99k
      
case BO_Assign: 170
DISPATCH170
(BinAssign, BinaryOperator);
76
1.99k
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
77
1.99k
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
78
1.99k
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
1.99k
      
case BO_AddAssign: 13
DISPATCH13
(BinAddAssign, CompoundAssignOperator);
80
1.99k
      
case BO_SubAssign: 5
DISPATCH5
(BinSubAssign, CompoundAssignOperator);
81
1.99k
      
case BO_ShlAssign: 4
DISPATCH4
(BinShlAssign, CompoundAssignOperator);
82
1.99k
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
1.99k
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
1.99k
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
1.99k
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
1.99k
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
87
34.5k
      }
88
34.5k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
530
      switch (UnOp->getOpcode()) {
90
530
      
case UO_PostInc: 38
DISPATCH38
(UnaryPostInc, UnaryOperator);
91
530
      
case UO_PostDec: 6
DISPATCH6
(UnaryPostDec, UnaryOperator);
92
530
      
case UO_PreInc: 0
DISPATCH0
(UnaryPreInc, UnaryOperator);
93
530
      
case UO_PreDec: 1
DISPATCH1
(UnaryPreDec, UnaryOperator);
94
530
      
case UO_AddrOf: 202
DISPATCH202
(UnaryAddrOf, UnaryOperator);
95
530
      
case UO_Deref: 40
DISPATCH40
(UnaryDeref, UnaryOperator);
96
530
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
97
530
      
case UO_Minus: 231
DISPATCH231
(UnaryMinus, UnaryOperator);
98
530
      
case UO_Not: 4
DISPATCH4
(UnaryNot, UnaryOperator);
99
530
      
case UO_LNot: 8
DISPATCH8
(UnaryLNot, UnaryOperator);
100
530
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
101
530
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
102
530
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
103
530
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
34.0k
      }
105
34.0k
    }
106
34.0k
107
34.0k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
34.0k
    switch (S->getStmtClass()) {
109
34.0k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
34.0k
#define ABSTRACT_STMT(STMT)
111
34.0k
#define STMT(CLASS, PARENT)                              \
112
34.0k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
34.0k
#include 
"clang/AST/StmtNodes.inc"0
114
34.0k
    }
115
34.0k
  }
CheckSecuritySyntaxOnly.cpp:clang::StmtVisitorBase<clang::make_ptr, (anonymous namespace)::WalkAST, void>::Visit(clang::Stmt*)
Line
Count
Source
46
3.27k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
3.27k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
3.27k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
3.27k
    // below.
50
3.27k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
137
      switch (BinOp->getOpcode()) {
52
137
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
137
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
137
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
55
137
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
56
137
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
57
137
      
case BO_Add: 8
DISPATCH8
(BinAdd, BinaryOperator);
58
137
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
59
137
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
60
137
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
61
137
62
137
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
63
137
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
64
137
      
case BO_LE: 56
DISPATCH56
(BinLE, BinaryOperator);
65
137
      
case BO_GE: 8
DISPATCH8
(BinGE, BinaryOperator);
66
137
      
case BO_EQ: 6
DISPATCH6
(BinEQ, BinaryOperator);
67
137
      
case BO_NE: 10
DISPATCH10
(BinNE, BinaryOperator);
68
137
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
137
70
137
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
71
137
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
72
137
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
73
137
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
74
137
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
75
137
      
case BO_Assign: 25
DISPATCH25
(BinAssign, BinaryOperator);
76
137
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
77
137
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
78
137
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
137
      
case BO_AddAssign: 16
DISPATCH16
(BinAddAssign, CompoundAssignOperator);
80
137
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
81
137
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
82
137
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
137
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
137
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
137
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
137
      
case BO_Comma: 8
DISPATCH8
(BinComma, BinaryOperator);
87
3.13k
      }
88
3.13k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
74
      switch (UnOp->getOpcode()) {
90
74
      
case UO_PostInc: 40
DISPATCH40
(UnaryPostInc, UnaryOperator);
91
74
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
92
74
      
case UO_PreInc: 8
DISPATCH8
(UnaryPreInc, UnaryOperator);
93
74
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
94
74
      
case UO_AddrOf: 9
DISPATCH9
(UnaryAddrOf, UnaryOperator);
95
74
      
case UO_Deref: 1
DISPATCH1
(UnaryDeref, UnaryOperator);
96
74
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
97
74
      
case UO_Minus: 16
DISPATCH16
(UnaryMinus, UnaryOperator);
98
74
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
99
74
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
100
74
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
101
74
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
102
74
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
103
74
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
3.06k
      }
105
3.06k
    }
106
3.06k
107
3.06k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
3.06k
    switch (S->getStmtClass()) {
109
3.06k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
3.06k
#define ABSTRACT_STMT(STMT)
111
3.06k
#define STMT(CLASS, PARENT)                              \
112
3.06k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
3.06k
#include 
"clang/AST/StmtNodes.inc"0
114
3.06k
    }
115
3.06k
  }
CheckSizeofPointer.cpp:clang::StmtVisitorBase<clang::make_ptr, (anonymous namespace)::WalkAST, void>::Visit(clang::Stmt*)
Line
Count
Source
46
19.3k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
19.3k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
19.3k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
19.3k
    // below.
50
19.3k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
1.17k
      switch (BinOp->getOpcode()) {
52
1.17k
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
1.17k
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
1.17k
      
case BO_Mul: 1
DISPATCH1
(BinMul, BinaryOperator);
55
1.17k
      
case BO_Div: 15
DISPATCH15
(BinDiv, BinaryOperator);
56
1.17k
      
case BO_Rem: 4
DISPATCH4
(BinRem, BinaryOperator);
57
1.17k
      
case BO_Add: 44
DISPATCH44
(BinAdd, BinaryOperator);
58
1.17k
      
case BO_Sub: 18
DISPATCH18
(BinSub, BinaryOperator);
59
1.17k
      
case BO_Shl: 12
DISPATCH12
(BinShl, BinaryOperator);
60
1.17k
      
case BO_Shr: 2
DISPATCH2
(BinShr, BinaryOperator);
61
1.17k
62
1.17k
      
case BO_LT: 45
DISPATCH45
(BinLT, BinaryOperator);
63
1.17k
      
case BO_GT: 14
DISPATCH14
(BinGT, BinaryOperator);
64
1.17k
      
case BO_LE: 2
DISPATCH2
(BinLE, BinaryOperator);
65
1.17k
      
case BO_GE: 3
DISPATCH3
(BinGE, BinaryOperator);
66
1.17k
      
case BO_EQ: 337
DISPATCH337
(BinEQ, BinaryOperator);
67
1.17k
      
case BO_NE: 99
DISPATCH99
(BinNE, BinaryOperator);
68
1.17k
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
1.17k
70
1.17k
      
case BO_And: 10
DISPATCH10
(BinAnd, BinaryOperator);
71
1.17k
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
72
1.17k
      
case BO_Or : 5
DISPATCH5
(BinOr, BinaryOperator);
73
1.17k
      
case BO_LAnd: 31
DISPATCH31
(BinLAnd, BinaryOperator);
74
1.17k
      
case BO_LOr : 8
DISPATCH8
(BinLOr, BinaryOperator);
75
1.17k
      
case BO_Assign: 480
DISPATCH480
(BinAssign, BinaryOperator);
76
1.17k
      
case BO_MulAssign: 8
DISPATCH8
(BinMulAssign, CompoundAssignOperator);
77
1.17k
      
case BO_DivAssign: 12
DISPATCH12
(BinDivAssign, CompoundAssignOperator);
78
1.17k
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
1.17k
      
case BO_AddAssign: 9
DISPATCH9
(BinAddAssign, CompoundAssignOperator);
80
1.17k
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
81
1.17k
      
case BO_ShlAssign: 2
DISPATCH2
(BinShlAssign, CompoundAssignOperator);
82
1.17k
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
1.17k
      
case BO_AndAssign: 6
DISPATCH6
(BinAndAssign, CompoundAssignOperator);
84
1.17k
      
case BO_OrAssign: 3
DISPATCH3
(BinOrAssign, CompoundAssignOperator);
85
1.17k
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
1.17k
      
case BO_Comma: 7
DISPATCH7
(BinComma, BinaryOperator);
87
18.1k
      }
88
18.1k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
768
      switch (UnOp->getOpcode()) {
90
768
      
case UO_PostInc: 44
DISPATCH44
(UnaryPostInc, UnaryOperator);
91
768
      
case UO_PostDec: 7
DISPATCH7
(UnaryPostDec, UnaryOperator);
92
768
      
case UO_PreInc: 36
DISPATCH36
(UnaryPreInc, UnaryOperator);
93
768
      
case UO_PreDec: 4
DISPATCH4
(UnaryPreDec, UnaryOperator);
94
768
      
case UO_AddrOf: 180
DISPATCH180
(UnaryAddrOf, UnaryOperator);
95
768
      
case UO_Deref: 310
DISPATCH310
(UnaryDeref, UnaryOperator);
96
768
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
97
768
      
case UO_Minus: 18
DISPATCH18
(UnaryMinus, UnaryOperator);
98
768
      
case UO_Not: 10
DISPATCH10
(UnaryNot, UnaryOperator);
99
768
      
case UO_LNot: 145
DISPATCH145
(UnaryLNot, UnaryOperator);
100
768
      
case UO_Real: 6
DISPATCH6
(UnaryReal, UnaryOperator);
101
768
      
case UO_Imag: 4
DISPATCH4
(UnaryImag, UnaryOperator);
102
768
      
case UO_Extension: 4
DISPATCH4
(UnaryExtension, UnaryOperator);
103
768
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
17.3k
      }
105
17.3k
    }
106
17.3k
107
17.3k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
17.3k
    switch (S->getStmtClass()) {
109
17.3k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
17.3k
#define ABSTRACT_STMT(STMT)
111
17.3k
#define STMT(CLASS, PARENT)                              \
112
17.3k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
17.3k
#include 
"clang/AST/StmtNodes.inc"0
114
17.3k
    }
115
17.3k
  }
DirectIvarAssignment.cpp:clang::StmtVisitorBase<clang::make_const_ptr, (anonymous namespace)::DirectIvarAssignment::MethodCrawler, void>::Visit(clang::Stmt const*)
Line
Count
Source
46
19
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
19
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
19
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
19
    // below.
50
19
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
14
      switch (BinOp->getOpcode()) {
52
14
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
14
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
14
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
55
14
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
56
14
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
57
14
      
case BO_Add: 0
DISPATCH0
(BinAdd, BinaryOperator);
58
14
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
59
14
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
60
14
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
61
14
62
14
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
63
14
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
64
14
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
65
14
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
66
14
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
67
14
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
68
14
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
14
70
14
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
71
14
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
72
14
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
73
14
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
74
14
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
75
14
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
76
14
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
77
14
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
78
14
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
14
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
80
14
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
81
14
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
82
14
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
14
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
14
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
14
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
14
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
87
5
      }
88
5
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
0
      switch (UnOp->getOpcode()) {
90
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
91
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
92
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
93
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
94
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
95
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
96
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
97
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
98
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
99
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
100
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
101
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
102
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
103
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
104
5
      }
105
5
    }
106
5
107
5
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
5
    switch (S->getStmtClass()) {
109
5
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
5
#define ABSTRACT_STMT(STMT)
111
5
#define STMT(CLASS, PARENT)                              \
112
5
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
5
#include 
"clang/AST/StmtNodes.inc"0
114
5
    }
115
5
  }
IvarInvalidationChecker.cpp:clang::StmtVisitorBase<clang::make_const_ptr, (anonymous namespace)::IvarInvalidationCheckerImpl::MethodCrawler, void>::Visit(clang::Stmt const*)
Line
Count
Source
46
408
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
408
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
408
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
408
    // below.
50
408
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
19
      switch (BinOp->getOpcode()) {
52
19
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
19
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
19
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
55
19
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
56
19
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
57
19
      
case BO_Add: 0
DISPATCH0
(BinAdd, BinaryOperator);
58
19
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
59
19
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
60
19
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
61
19
62
19
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
63
19
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
64
19
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
65
19
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
66
19
      
case BO_EQ: 3
DISPATCH3
(BinEQ, BinaryOperator);
67
19
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
68
19
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
19
70
19
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
71
19
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
72
19
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
73
19
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
74
19
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
75
19
      
case BO_Assign: 16
DISPATCH16
(BinAssign, BinaryOperator);
76
19
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
77
19
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
78
19
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
19
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
80
19
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
81
19
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
82
19
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
19
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
19
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
19
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
19
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
87
389
      }
88
389
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
1
      switch (UnOp->getOpcode()) {
90
1
      
case UO_PostInc: 0
DISPATCH0
(UnaryPostInc, UnaryOperator);
91
1
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
92
1
      
case UO_PreInc: 0
DISPATCH0
(UnaryPreInc, UnaryOperator);
93
1
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
94
1
      
case UO_AddrOf: 0
DISPATCH0
(UnaryAddrOf, UnaryOperator);
95
1
      
case UO_Deref: 0
DISPATCH0
(UnaryDeref, UnaryOperator);
96
1
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
97
1
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
98
1
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
99
1
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
100
1
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
101
1
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
102
1
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
103
1
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
388
      }
105
388
    }
106
388
107
388
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
388
    switch (S->getStmtClass()) {
109
388
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
388
#define ABSTRACT_STMT(STMT)
111
388
#define STMT(CLASS, PARENT)                              \
112
388
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
388
#include 
"clang/AST/StmtNodes.inc"0
114
388
    }
115
388
  }
Unexecuted instantiation: LLVMConventionsChecker.cpp:clang::StmtVisitorBase<clang::make_ptr, (anonymous namespace)::StringRefCheckerVisitor, void>::Visit(clang::Stmt*)
LocalizationChecker.cpp:clang::StmtVisitorBase<clang::make_const_ptr, (anonymous namespace)::EmptyLocalizationContextChecker::MethodCrawler, void>::Visit(clang::Stmt const*)
Line
Count
Source
46
171
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
171
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
171
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
171
    // below.
50
171
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
4
      switch (BinOp->getOpcode()) {
52
4
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
4
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
4
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
55
4
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
56
4
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
57
4
      
case BO_Add: 0
DISPATCH0
(BinAdd, BinaryOperator);
58
4
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
59
4
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
60
4
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
61
4
62
4
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
63
4
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
64
4
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
65
4
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
66
4
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
67
4
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
68
4
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
4
70
4
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
71
4
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
72
4
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
73
4
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
74
4
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
75
4
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
76
4
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
77
4
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
78
4
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
4
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
80
4
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
81
4
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
82
4
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
4
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
4
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
4
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
4
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
87
167
      }
88
167
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
0
      switch (UnOp->getOpcode()) {
90
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
91
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
92
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
93
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
94
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
95
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
96
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
97
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
98
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
99
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
100
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
101
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
102
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
103
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
104
167
      }
105
167
    }
106
167
107
167
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
167
    switch (S->getStmtClass()) {
109
167
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
167
#define ABSTRACT_STMT(STMT)
111
167
#define STMT(CLASS, PARENT)                              \
112
167
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
167
#include 
"clang/AST/StmtNodes.inc"0
114
167
    }
115
167
  }
MallocOverflowSecurityChecker.cpp:clang::StmtVisitorBase<clang::make_ptr, (anonymous namespace)::CheckOverflowOps, void>::Visit(clang::Stmt*)
Line
Count
Source
46
445
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
445
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
445
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
445
    // below.
50
445
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
52
      switch (BinOp->getOpcode()) {
52
52
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
52
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
52
      
case BO_Mul: 21
DISPATCH21
(BinMul, BinaryOperator);
55
52
      
case BO_Div: 4
DISPATCH4
(BinDiv, BinaryOperator);
56
52
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
57
52
      
case BO_Add: 5
DISPATCH5
(BinAdd, BinaryOperator);
58
52
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
59
52
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
60
52
      
case BO_Shr: 2
DISPATCH2
(BinShr, BinaryOperator);
61
52
62
52
      
case BO_LT: 2
DISPATCH2
(BinLT, BinaryOperator);
63
52
      
case BO_GT: 3
DISPATCH3
(BinGT, BinaryOperator);
64
52
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
65
52
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
66
52
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
67
52
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
68
52
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
52
70
52
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
71
52
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
72
52
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
73
52
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
74
52
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
75
52
      
case BO_Assign: 15
DISPATCH15
(BinAssign, BinaryOperator);
76
52
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
77
52
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
78
52
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
52
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
80
52
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
81
52
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
82
52
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
52
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
52
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
52
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
52
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
87
393
      }
88
393
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
3
      switch (UnOp->getOpcode()) {
90
3
      
case UO_PostInc: 2
DISPATCH2
(UnaryPostInc, UnaryOperator);
91
3
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
92
3
      
case UO_PreInc: 0
DISPATCH0
(UnaryPreInc, UnaryOperator);
93
3
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
94
3
      
case UO_AddrOf: 0
DISPATCH0
(UnaryAddrOf, UnaryOperator);
95
3
      
case UO_Deref: 1
DISPATCH1
(UnaryDeref, UnaryOperator);
96
3
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
97
3
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
98
3
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
99
3
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
100
3
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
101
3
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
102
3
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
103
3
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
390
      }
105
390
    }
106
390
107
390
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
390
    switch (S->getStmtClass()) {
109
390
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
390
#define ABSTRACT_STMT(STMT)
111
390
#define STMT(CLASS, PARENT)                              \
112
390
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
390
#include 
"clang/AST/StmtNodes.inc"0
114
390
    }
115
390
  }
MallocSizeofChecker.cpp:clang::StmtVisitorBase<clang::make_const_ptr, (anonymous namespace)::CastedAllocFinder, std::__1::pair<clang::TypeSourceInfo const*, clang::CallExpr const*> >::Visit(clang::Stmt const*)
Line
Count
Source
46
2.36k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
2.36k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
2.36k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
2.36k
    // below.
50
2.36k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
175
      switch (BinOp->getOpcode()) {
52
175
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
175
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
175
      
case BO_Mul: 19
DISPATCH19
(BinMul, BinaryOperator);
55
175
      
case BO_Div: 12
DISPATCH12
(BinDiv, BinaryOperator);
56
175
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
57
175
      
case BO_Add: 29
DISPATCH29
(BinAdd, BinaryOperator);
58
175
      
case BO_Sub: 4
DISPATCH4
(BinSub, BinaryOperator);
59
175
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
60
175
      
case BO_Shr: 2
DISPATCH2
(BinShr, BinaryOperator);
61
175
62
175
      
case BO_LT: 9
DISPATCH9
(BinLT, BinaryOperator);
63
175
      
case BO_GT: 1
DISPATCH1
(BinGT, BinaryOperator);
64
175
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
65
175
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
66
175
      
case BO_EQ: 11
DISPATCH11
(BinEQ, BinaryOperator);
67
175
      
case BO_NE: 1
DISPATCH1
(BinNE, BinaryOperator);
68
175
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
175
70
175
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
71
175
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
72
175
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
73
175
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
74
175
      
case BO_LOr : 1
DISPATCH1
(BinLOr, BinaryOperator);
75
175
      
case BO_Assign: 77
DISPATCH77
(BinAssign, BinaryOperator);
76
175
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
77
175
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
78
175
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
175
      
case BO_AddAssign: 4
DISPATCH4
(BinAddAssign, CompoundAssignOperator);
80
175
      
case BO_SubAssign: 5
DISPATCH5
(BinSubAssign, CompoundAssignOperator);
81
175
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
82
175
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
175
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
175
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
175
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
175
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
87
2.19k
      }
88
2.19k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
74
      switch (UnOp->getOpcode()) {
90
74
      
case UO_PostInc: 38
DISPATCH38
(UnaryPostInc, UnaryOperator);
91
74
      
case UO_PostDec: 6
DISPATCH6
(UnaryPostDec, UnaryOperator);
92
74
      
case UO_PreInc: 0
DISPATCH0
(UnaryPreInc, UnaryOperator);
93
74
      
case UO_PreDec: 1
DISPATCH1
(UnaryPreDec, UnaryOperator);
94
74
      
case UO_AddrOf: 3
DISPATCH3
(UnaryAddrOf, UnaryOperator);
95
74
      
case UO_Deref: 19
DISPATCH19
(UnaryDeref, UnaryOperator);
96
74
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
97
74
      
case UO_Minus: 5
DISPATCH5
(UnaryMinus, UnaryOperator);
98
74
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
99
74
      
case UO_LNot: 2
DISPATCH2
(UnaryLNot, UnaryOperator);
100
74
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
101
74
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
102
74
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
103
74
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
2.12k
      }
105
2.12k
    }
106
2.12k
107
2.12k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
2.12k
    switch (S->getStmtClass()) {
109
2.12k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
2.12k
#define ABSTRACT_STMT(STMT)
111
2.12k
#define STMT(CLASS, PARENT)                              \
112
2.12k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
2.12k
#include 
"clang/AST/StmtNodes.inc"0
114
2.12k
    }
115
2.12k
  }
MallocSizeofChecker.cpp:clang::StmtVisitorBase<clang::make_const_ptr, (anonymous namespace)::SizeofFinder, void>::Visit(clang::Stmt const*)
Line
Count
Source
46
109
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
109
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
109
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
109
    // below.
50
109
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
12
      switch (BinOp->getOpcode()) {
52
12
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
12
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
12
      
case BO_Mul: 10
DISPATCH10
(BinMul, BinaryOperator);
55
12
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
56
12
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
57
12
      
case BO_Add: 2
DISPATCH2
(BinAdd, BinaryOperator);
58
12
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
59
12
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
60
12
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
61
12
62
12
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
63
12
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
64
12
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
65
12
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
66
12
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
67
12
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
68
12
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
12
70
12
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
71
12
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
72
12
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
73
12
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
74
12
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
75
12
      
case BO_Assign: 0
DISPATCH0
(BinAssign, BinaryOperator);
76
12
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
77
12
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
78
12
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
12
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
80
12
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
81
12
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
82
12
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
12
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
12
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
12
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
12
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
87
97
      }
88
97
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
0
      switch (UnOp->getOpcode()) {
90
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
91
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
92
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
93
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
94
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
95
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
96
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
97
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
98
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
99
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
100
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
101
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
102
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
103
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
104
97
      }
105
97
    }
106
97
107
97
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
97
    switch (S->getStmtClass()) {
109
97
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
97
#define ABSTRACT_STMT(STMT)
111
97
#define STMT(CLASS, PARENT)                              \
112
97
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
97
#include 
"clang/AST/StmtNodes.inc"0
114
97
    }
115
97
  }
ObjCContainersASTChecker.cpp:clang::StmtVisitorBase<clang::make_ptr, (anonymous namespace)::WalkAST, void>::Visit(clang::Stmt*)
Line
Count
Source
46
1.32k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
1.32k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
1.32k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
1.32k
    // below.
50
1.32k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
80
      switch (BinOp->getOpcode()) {
52
80
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
80
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
80
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
55
80
      
case BO_Div: 19
DISPATCH19
(BinDiv, BinaryOperator);
56
80
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
57
80
      
case BO_Add: 8
DISPATCH8
(BinAdd, BinaryOperator);
58
80
      
case BO_Sub: 1
DISPATCH1
(BinSub, BinaryOperator);
59
80
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
60
80
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
61
80
62
80
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
63
80
      
case BO_GT: 1
DISPATCH1
(BinGT, BinaryOperator);
64
80
      
case BO_LE: 1
DISPATCH1
(BinLE, BinaryOperator);
65
80
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
66
80
      
case BO_EQ: 7
DISPATCH7
(BinEQ, BinaryOperator);
67
80
      
case BO_NE: 3
DISPATCH3
(BinNE, BinaryOperator);
68
80
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
80
70
80
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
71
80
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
72
80
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
73
80
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
74
80
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
75
80
      
case BO_Assign: 39
DISPATCH39
(BinAssign, BinaryOperator);
76
80
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
77
80
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
78
80
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
80
      
case BO_AddAssign: 1
DISPATCH1
(BinAddAssign, CompoundAssignOperator);
80
80
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
81
80
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
82
80
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
80
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
80
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
80
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
80
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
87
1.24k
      }
88
1.24k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
35
      switch (UnOp->getOpcode()) {
90
35
      
case UO_PostInc: 0
DISPATCH0
(UnaryPostInc, UnaryOperator);
91
35
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
92
35
      
case UO_PreInc: 0
DISPATCH0
(UnaryPreInc, UnaryOperator);
93
35
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
94
35
      
case UO_AddrOf: 24
DISPATCH24
(UnaryAddrOf, UnaryOperator);
95
35
      
case UO_Deref: 11
DISPATCH11
(UnaryDeref, UnaryOperator);
96
35
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
97
35
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
98
35
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
99
35
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
100
35
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
101
35
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
102
35
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
103
35
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
1.21k
      }
105
1.21k
    }
106
1.21k
107
1.21k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
1.21k
    switch (S->getStmtClass()) {
109
1.21k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
1.21k
#define ABSTRACT_STMT(STMT)
111
1.21k
#define STMT(CLASS, PARENT)                              \
112
1.21k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
1.21k
#include 
"clang/AST/StmtNodes.inc"0
114
1.21k
    }
115
1.21k
  }
clang::StmtVisitorBase<clang::make_ptr, clang::ASTStmtReader, void>::Visit(clang::Stmt*)
Line
Count
Source
46
532k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
532k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
532k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
532k
    // below.
50
532k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
106k
      switch (BinOp->getOpcode()) {
52
106k
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
106k
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
106k
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
55
106k
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
56
106k
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
57
106k
      
case BO_Add: 0
DISPATCH0
(BinAdd, BinaryOperator);
58
106k
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
59
106k
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
60
106k
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
61
106k
62
106k
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
63
106k
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
64
106k
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
65
106k
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
66
106k
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
67
106k
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
68
106k
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
106k
70
106k
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
71
106k
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
72
106k
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
73
106k
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
74
106k
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
75
106k
      
case BO_Assign: 0
DISPATCH0
(BinAssign, BinaryOperator);
76
106k
      
case BO_MulAssign: 4.24k
DISPATCH4.24k
(BinMulAssign, CompoundAssignOperator);
77
106k
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
78
106k
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
106k
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
80
106k
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
81
106k
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
82
106k
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
106k
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
106k
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
106k
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
106k
      
case BO_Comma: 102k
DISPATCH102k
(BinComma, BinaryOperator);
87
426k
      }
88
426k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
9.84k
      switch (UnOp->getOpcode()) {
90
9.84k
      
case UO_PostInc: 0
DISPATCH0
(UnaryPostInc, UnaryOperator);
91
9.84k
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
92
9.84k
      
case UO_PreInc: 0
DISPATCH0
(UnaryPreInc, UnaryOperator);
93
9.84k
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
94
9.84k
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
95
9.84k
      
case UO_Deref: 0
DISPATCH0
(UnaryDeref, UnaryOperator);
96
9.84k
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
97
9.84k
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
98
9.84k
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
99
9.84k
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
100
9.84k
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
101
9.84k
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
102
9.84k
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
103
9.84k
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
416k
      }
105
416k
    }
106
416k
107
416k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
416k
    switch (S->getStmtClass()) {
109
416k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
416k
#define ABSTRACT_STMT(STMT)
111
416k
#define STMT(CLASS, PARENT)                              \
112
416k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
416k
#include 
"clang/AST/StmtNodes.inc"2
114
416k
    }
115
416k
  }
clang::StmtVisitorBase<clang::make_ptr, clang::ASTStmtWriter, void>::Visit(clang::Stmt*)
Line
Count
Source
46
886k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
886k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
886k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
886k
    // below.
50
886k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
114k
      switch (BinOp->getOpcode()) {
52
114k
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
114k
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
114k
      
case BO_Mul: 6.65k
DISPATCH6.65k
(BinMul, BinaryOperator);
55
114k
      
case BO_Div: 6.15k
DISPATCH6.15k
(BinDiv, BinaryOperator);
56
114k
      
case BO_Rem: 155
DISPATCH155
(BinRem, BinaryOperator);
57
114k
      
case BO_Add: 26.5k
DISPATCH26.5k
(BinAdd, BinaryOperator);
58
114k
      
case BO_Sub: 16.9k
DISPATCH16.9k
(BinSub, BinaryOperator);
59
114k
      
case BO_Shl: 31
DISPATCH31
(BinShl, BinaryOperator);
60
114k
      
case BO_Shr: 56
DISPATCH56
(BinShr, BinaryOperator);
61
114k
62
114k
      
case BO_LT: 7.37k
DISPATCH7.37k
(BinLT, BinaryOperator);
63
114k
      
case BO_GT: 4.94k
DISPATCH4.94k
(BinGT, BinaryOperator);
64
114k
      
case BO_LE: 3.42k
DISPATCH3.42k
(BinLE, BinaryOperator);
65
114k
      
case BO_GE: 208
DISPATCH208
(BinGE, BinaryOperator);
66
114k
      
case BO_EQ: 143
DISPATCH143
(BinEQ, BinaryOperator);
67
114k
      
case BO_NE: 23
DISPATCH23
(BinNE, BinaryOperator);
68
114k
      
case BO_Cmp: 2
DISPATCH2
(BinCmp, BinaryOperator);
69
114k
70
114k
      
case BO_And: 346
DISPATCH346
(BinAnd, BinaryOperator);
71
114k
      
case BO_Xor: 116
DISPATCH116
(BinXor, BinaryOperator);
72
114k
      
case BO_Or : 287
DISPATCH287
(BinOr, BinaryOperator);
73
114k
      
case BO_LAnd: 213
DISPATCH213
(BinLAnd, BinaryOperator);
74
114k
      
case BO_LOr : 10
DISPATCH10
(BinLOr, BinaryOperator);
75
114k
      
case BO_Assign: 36.9k
DISPATCH36.9k
(BinAssign, BinaryOperator);
76
114k
      
case BO_MulAssign: 58
DISPATCH58
(BinMulAssign, CompoundAssignOperator);
77
114k
      
case BO_DivAssign: 54
DISPATCH54
(BinDivAssign, CompoundAssignOperator);
78
114k
      
case BO_RemAssign: 4
DISPATCH4
(BinRemAssign, CompoundAssignOperator);
79
114k
      
case BO_AddAssign: 4.04k
DISPATCH4.04k
(BinAddAssign, CompoundAssignOperator);
80
114k
      
case BO_SubAssign: 116
DISPATCH116
(BinSubAssign, CompoundAssignOperator);
81
114k
      
case BO_ShlAssign: 4
DISPATCH4
(BinShlAssign, CompoundAssignOperator);
82
114k
      
case BO_ShrAssign: 4
DISPATCH4
(BinShrAssign, CompoundAssignOperator);
83
114k
      
case BO_AndAssign: 4
DISPATCH4
(BinAndAssign, CompoundAssignOperator);
84
114k
      
case BO_OrAssign: 8
DISPATCH8
(BinOrAssign, CompoundAssignOperator);
85
114k
      
case BO_XorAssign: 8
DISPATCH8
(BinXorAssign, CompoundAssignOperator);
86
114k
      
case BO_Comma: 74
DISPATCH74
(BinComma, BinaryOperator);
87
772k
      }
88
772k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
13.0k
      switch (UnOp->getOpcode()) {
90
13.0k
      
case UO_PostInc: 1.78k
DISPATCH1.78k
(UnaryPostInc, UnaryOperator);
91
13.0k
      
case UO_PostDec: 40
DISPATCH40
(UnaryPostDec, UnaryOperator);
92
13.0k
      
case UO_PreInc: 4.25k
DISPATCH4.25k
(UnaryPreInc, UnaryOperator);
93
13.0k
      
case UO_PreDec: 46
DISPATCH46
(UnaryPreDec, UnaryOperator);
94
13.0k
      
case UO_AddrOf: 489
DISPATCH489
(UnaryAddrOf, UnaryOperator);
95
13.0k
      
case UO_Deref: 3.46k
DISPATCH3.46k
(UnaryDeref, UnaryOperator);
96
13.0k
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
97
13.0k
      
case UO_Minus: 2.51k
DISPATCH2.51k
(UnaryMinus, UnaryOperator);
98
13.0k
      
case UO_Not: 202
DISPATCH202
(UnaryNot, UnaryOperator);
99
13.0k
      
case UO_LNot: 20
DISPATCH20
(UnaryLNot, UnaryOperator);
100
13.0k
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
101
13.0k
      
case UO_Imag: 2
DISPATCH2
(UnaryImag, UnaryOperator);
102
13.0k
      
case UO_Extension: 267
DISPATCH267
(UnaryExtension, UnaryOperator);
103
13.0k
      
case UO_Coawait: 5
DISPATCH5
(UnaryCoawait, UnaryOperator);
104
758k
      }
105
758k
    }
106
758k
107
758k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
758k
    switch (S->getStmtClass()) {
109
758k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
758k
#define ABSTRACT_STMT(STMT)
111
758k
#define STMT(CLASS, PARENT)                              \
112
758k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
758k
#include 
"clang/AST/StmtNodes.inc"36
114
758k
    }
115
758k
  }
AnalysisBasedWarnings.cpp:clang::StmtVisitorBase<clang::make_const_ptr, (anonymous namespace)::ContainsReference, void>::Visit(clang::Stmt const*)
Line
Count
Source
46
401
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
401
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
401
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
401
    // below.
50
401
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
30
      switch (BinOp->getOpcode()) {
52
30
      
case BO_PtrMemD: 1
DISPATCH1
(BinPtrMemD, BinaryOperator);
53
30
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
30
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
55
30
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
56
30
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
57
30
      
case BO_Add: 10
DISPATCH10
(BinAdd, BinaryOperator);
58
30
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
59
30
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
60
30
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
61
30
62
30
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
63
30
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
64
30
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
65
30
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
66
30
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
67
30
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
68
30
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
30
70
30
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
71
30
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
72
30
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
73
30
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
74
30
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
75
30
      
case BO_Assign: 0
DISPATCH0
(BinAssign, BinaryOperator);
76
30
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
77
30
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
78
30
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
30
      
case BO_AddAssign: 6
DISPATCH6
(BinAddAssign, CompoundAssignOperator);
80
30
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
81
30
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
82
30
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
30
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
30
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
30
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
30
      
case BO_Comma: 13
DISPATCH13
(BinComma, BinaryOperator);
87
371
      }
88
371
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
8
      switch (UnOp->getOpcode()) {
90
8
      
case UO_PostInc: 4
DISPATCH4
(UnaryPostInc, UnaryOperator);
91
8
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
92
8
      
case UO_PreInc: 2
DISPATCH2
(UnaryPreInc, UnaryOperator);
93
8
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
94
8
      
case UO_AddrOf: 0
DISPATCH0
(UnaryAddrOf, UnaryOperator);
95
8
      
case UO_Deref: 0
DISPATCH0
(UnaryDeref, UnaryOperator);
96
8
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
97
8
      
case UO_Minus: 2
DISPATCH2
(UnaryMinus, UnaryOperator);
98
8
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
99
8
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
100
8
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
101
8
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
102
8
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
103
8
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
363
      }
105
363
    }
106
363
107
363
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
363
    switch (S->getStmtClass()) {
109
363
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
363
#define ABSTRACT_STMT(STMT)
111
363
#define STMT(CLASS, PARENT)                              \
112
363
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
363
#include 
"clang/AST/StmtNodes.inc"0
114
363
    }
115
363
  }
SemaChecking.cpp:clang::StmtVisitorBase<clang::make_ptr, (anonymous namespace)::SequenceChecker, void>::Visit(clang::Stmt*)
Line
Count
Source
46
49.7M
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
49.7M
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
49.7M
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
49.7M
    // below.
50
49.7M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
4.36M
      switch (BinOp->getOpcode()) {
52
4.36M
      
case BO_PtrMemD: 280
DISPATCH280
(BinPtrMemD, BinaryOperator);
53
4.36M
      
case BO_PtrMemI: 229
DISPATCH229
(BinPtrMemI, BinaryOperator);
54
4.36M
      
case BO_Mul: 171k
DISPATCH171k
(BinMul, BinaryOperator);
55
4.36M
      
case BO_Div: 217k
DISPATCH217k
(BinDiv, BinaryOperator);
56
4.36M
      
case BO_Rem: 12.4k
DISPATCH12.4k
(BinRem, BinaryOperator);
57
4.36M
      
case BO_Add: 634k
DISPATCH634k
(BinAdd, BinaryOperator);
58
4.36M
      
case BO_Sub: 642k
DISPATCH642k
(BinSub, BinaryOperator);
59
4.36M
      
case BO_Shl: 89.4k
DISPATCH89.4k
(BinShl, BinaryOperator);
60
4.36M
      
case BO_Shr: 51.2k
DISPATCH51.2k
(BinShr, BinaryOperator);
61
4.36M
62
4.36M
      
case BO_LT: 221k
DISPATCH221k
(BinLT, BinaryOperator);
63
4.36M
      
case BO_GT: 175k
DISPATCH175k
(BinGT, BinaryOperator);
64
4.36M
      
case BO_LE: 54.9k
DISPATCH54.9k
(BinLE, BinaryOperator);
65
4.36M
      
case BO_GE: 45.0k
DISPATCH45.0k
(BinGE, BinaryOperator);
66
4.36M
      
case BO_EQ: 244k
DISPATCH244k
(BinEQ, BinaryOperator);
67
4.36M
      
case BO_NE: 115k
DISPATCH115k
(BinNE, BinaryOperator);
68
4.36M
      
case BO_Cmp: 181
DISPATCH181
(BinCmp, BinaryOperator);
69
4.36M
70
4.36M
      
case BO_And: 95.7k
DISPATCH95.7k
(BinAnd, BinaryOperator);
71
4.36M
      
case BO_Xor: 17.5k
DISPATCH17.5k
(BinXor, BinaryOperator);
72
4.36M
      
case BO_Or : 57.3k
DISPATCH57.3k
(BinOr, BinaryOperator);
73
4.36M
      
case BO_LAnd: 101k
DISPATCH101k
(BinLAnd, BinaryOperator);
74
4.36M
      
case BO_LOr : 53.2k
DISPATCH53.2k
(BinLOr, BinaryOperator);
75
4.36M
      
case BO_Assign: 1.25M
DISPATCH1.25M
(BinAssign, BinaryOperator);
76
4.36M
      
case BO_MulAssign: 3.58k
DISPATCH3.58k
(BinMulAssign, CompoundAssignOperator);
77
4.36M
      
case BO_DivAssign: 1.65k
DISPATCH1.65k
(BinDivAssign, CompoundAssignOperator);
78
4.36M
      
case BO_RemAssign: 144
DISPATCH144
(BinRemAssign, CompoundAssignOperator);
79
4.36M
      
case BO_AddAssign: 52.0k
DISPATCH52.0k
(BinAddAssign, CompoundAssignOperator);
80
4.36M
      
case BO_SubAssign: 7.50k
DISPATCH7.50k
(BinSubAssign, CompoundAssignOperator);
81
4.36M
      
case BO_ShlAssign: 2.08k
DISPATCH2.08k
(BinShlAssign, CompoundAssignOperator);
82
4.36M
      
case BO_ShrAssign: 970
DISPATCH970
(BinShrAssign, CompoundAssignOperator);
83
4.36M
      
case BO_AndAssign: 1.78k
DISPATCH1.78k
(BinAndAssign, CompoundAssignOperator);
84
4.36M
      
case BO_OrAssign: 16.5k
DISPATCH16.5k
(BinOrAssign, CompoundAssignOperator);
85
4.36M
      
case BO_XorAssign: 2.12k
DISPATCH2.12k
(BinXorAssign, CompoundAssignOperator);
86
4.36M
      
case BO_Comma: 21.6k
DISPATCH21.6k
(BinComma, BinaryOperator);
87
45.3M
      }
88
45.3M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
1.34M
      switch (UnOp->getOpcode()) {
90
1.34M
      
case UO_PostInc: 125k
DISPATCH125k
(UnaryPostInc, UnaryOperator);
91
1.34M
      
case UO_PostDec: 8.92k
DISPATCH8.92k
(UnaryPostDec, UnaryOperator);
92
1.34M
      
case UO_PreInc: 99.5k
DISPATCH99.5k
(UnaryPreInc, UnaryOperator);
93
1.34M
      
case UO_PreDec: 15.2k
DISPATCH15.2k
(UnaryPreDec, UnaryOperator);
94
1.34M
      
case UO_AddrOf: 163k
DISPATCH163k
(UnaryAddrOf, UnaryOperator);
95
1.34M
      
case UO_Deref: 175k
DISPATCH175k
(UnaryDeref, UnaryOperator);
96
1.34M
      
case UO_Plus: 495
DISPATCH495
(UnaryPlus, UnaryOperator);
97
1.34M
      
case UO_Minus: 199k
DISPATCH199k
(UnaryMinus, UnaryOperator);
98
1.34M
      
case UO_Not: 32.2k
DISPATCH32.2k
(UnaryNot, UnaryOperator);
99
1.34M
      
case UO_LNot: 504k
DISPATCH504k
(UnaryLNot, UnaryOperator);
100
1.34M
      
case UO_Real: 779
DISPATCH779
(UnaryReal, UnaryOperator);
101
1.34M
      
case UO_Imag: 758
DISPATCH758
(UnaryImag, UnaryOperator);
102
1.34M
      
case UO_Extension: 20.1k
DISPATCH20.1k
(UnaryExtension, UnaryOperator);
103
1.34M
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
43.9M
      }
105
43.9M
    }
106
43.9M
107
43.9M
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
43.9M
    switch (S->getStmtClass()) {
109
43.9M
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
43.9M
#define ABSTRACT_STMT(STMT)
111
43.9M
#define STMT(CLASS, PARENT)                              \
112
43.9M
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
43.9M
#include 
"clang/AST/StmtNodes.inc"0
114
43.9M
    }
115
43.9M
  }
SemaChecking.cpp:clang::StmtVisitorBase<clang::make_ptr, (anonymous namespace)::FindCaptureVisitor, void>::Visit(clang::Stmt*)
Line
Count
Source
46
140
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
140
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
140
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
140
    // below.
50
140
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
2
      switch (BinOp->getOpcode()) {
52
2
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
2
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
2
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
55
2
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
56
2
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
57
2
      
case BO_Add: 0
DISPATCH0
(BinAdd, BinaryOperator);
58
2
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
59
2
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
60
2
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
61
2
62
2
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
63
2
      
case BO_GT: 1
DISPATCH1
(BinGT, BinaryOperator);
64
2
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
65
2
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
66
2
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
67
2
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
68
2
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
2
70
2
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
71
2
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
72
2
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
73
2
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
74
2
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
75
2
      
case BO_Assign: 1
DISPATCH1
(BinAssign, BinaryOperator);
76
2
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
77
2
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
78
2
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
2
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
80
2
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
81
2
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
82
2
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
2
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
2
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
2
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
2
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
87
138
      }
88
138
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
0
      switch (UnOp->getOpcode()) {
90
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
91
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
92
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
93
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
94
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
95
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
96
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
97
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
98
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
99
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
100
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
101
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
102
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
103
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
104
138
      }
105
138
    }
106
138
107
138
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
138
    switch (S->getStmtClass()) {
109
138
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
138
#define ABSTRACT_STMT(STMT)
111
138
#define STMT(CLASS, PARENT)                              \
112
138
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
138
#include 
"clang/AST/StmtNodes.inc"0
114
138
    }
115
138
  }
SemaDecl.cpp:clang::StmtVisitorBase<clang::make_ptr, (anonymous namespace)::SelfReferenceChecker, void>::Visit(clang::Stmt*)
Line
Count
Source
46
3.01M
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
3.01M
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
3.01M
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
3.01M
    // below.
50
3.01M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
172k
      switch (BinOp->getOpcode()) {
52
172k
      
case BO_PtrMemD: 21
DISPATCH21
(BinPtrMemD, BinaryOperator);
53
172k
      
case BO_PtrMemI: 2
DISPATCH2
(BinPtrMemI, BinaryOperator);
54
172k
      
case BO_Mul: 20.9k
DISPATCH20.9k
(BinMul, BinaryOperator);
55
172k
      
case BO_Div: 26.4k
DISPATCH26.4k
(BinDiv, BinaryOperator);
56
172k
      
case BO_Rem: 228
DISPATCH228
(BinRem, BinaryOperator);
57
172k
      
case BO_Add: 16.4k
DISPATCH16.4k
(BinAdd, BinaryOperator);
58
172k
      
case BO_Sub: 19.2k
DISPATCH19.2k
(BinSub, BinaryOperator);
59
172k
      
case BO_Shl: 39.2k
DISPATCH39.2k
(BinShl, BinaryOperator);
60
172k
      
case BO_Shr: 2.58k
DISPATCH2.58k
(BinShr, BinaryOperator);
61
172k
62
172k
      
case BO_LT: 10.5k
DISPATCH10.5k
(BinLT, BinaryOperator);
63
172k
      
case BO_GT: 47
DISPATCH47
(BinGT, BinaryOperator);
64
172k
      
case BO_LE: 7.93k
DISPATCH7.93k
(BinLE, BinaryOperator);
65
172k
      
case BO_GE: 554
DISPATCH554
(BinGE, BinaryOperator);
66
172k
      
case BO_EQ: 6.80k
DISPATCH6.80k
(BinEQ, BinaryOperator);
67
172k
      
case BO_NE: 1.07k
DISPATCH1.07k
(BinNE, BinaryOperator);
68
172k
      
case BO_Cmp: 40
DISPATCH40
(BinCmp, BinaryOperator);
69
172k
70
172k
      
case BO_And: 6.68k
DISPATCH6.68k
(BinAnd, BinaryOperator);
71
172k
      
case BO_Xor: 2.28k
DISPATCH2.28k
(BinXor, BinaryOperator);
72
172k
      
case BO_Or : 6.90k
DISPATCH6.90k
(BinOr, BinaryOperator);
73
172k
      
case BO_LAnd: 3.52k
DISPATCH3.52k
(BinLAnd, BinaryOperator);
74
172k
      
case BO_LOr : 283
DISPATCH283
(BinLOr, BinaryOperator);
75
172k
      
case BO_Assign: 13
DISPATCH13
(BinAssign, BinaryOperator);
76
172k
      
case BO_MulAssign: 7
DISPATCH7
(BinMulAssign, CompoundAssignOperator);
77
172k
      
case BO_DivAssign: 1
DISPATCH1
(BinDivAssign, CompoundAssignOperator);
78
172k
      
case BO_RemAssign: 4
DISPATCH4
(BinRemAssign, CompoundAssignOperator);
79
172k
      
case BO_AddAssign: 14
DISPATCH14
(BinAddAssign, CompoundAssignOperator);
80
172k
      
case BO_SubAssign: 1
DISPATCH1
(BinSubAssign, CompoundAssignOperator);
81
172k
      
case BO_ShlAssign: 4
DISPATCH4
(BinShlAssign, CompoundAssignOperator);
82
172k
      
case BO_ShrAssign: 1
DISPATCH1
(BinShrAssign, CompoundAssignOperator);
83
172k
      
case BO_AndAssign: 1
DISPATCH1
(BinAndAssign, CompoundAssignOperator);
84
172k
      
case BO_OrAssign: 1
DISPATCH1
(BinOrAssign, CompoundAssignOperator);
85
172k
      
case BO_XorAssign: 1
DISPATCH1
(BinXorAssign, CompoundAssignOperator);
86
172k
      
case BO_Comma: 119
DISPATCH119
(BinComma, BinaryOperator);
87
2.84M
      }
88
2.84M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
125k
      switch (UnOp->getOpcode()) {
90
125k
      
case UO_PostInc: 115
DISPATCH115
(UnaryPostInc, UnaryOperator);
91
125k
      
case UO_PostDec: 2
DISPATCH2
(UnaryPostDec, UnaryOperator);
92
125k
      
case UO_PreInc: 36
DISPATCH36
(UnaryPreInc, UnaryOperator);
93
125k
      
case UO_PreDec: 31
DISPATCH31
(UnaryPreDec, UnaryOperator);
94
125k
      
case UO_AddrOf: 20.0k
DISPATCH20.0k
(UnaryAddrOf, UnaryOperator);
95
125k
      
case UO_Deref: 16.2k
DISPATCH16.2k
(UnaryDeref, UnaryOperator);
96
125k
      
case UO_Plus: 71
DISPATCH71
(UnaryPlus, UnaryOperator);
97
125k
      
case UO_Minus: 74.7k
DISPATCH74.7k
(UnaryMinus, UnaryOperator);
98
125k
      
case UO_Not: 9.41k
DISPATCH9.41k
(UnaryNot, UnaryOperator);
99
125k
      
case UO_LNot: 5.09k
DISPATCH5.09k
(UnaryLNot, UnaryOperator);
100
125k
      
case UO_Real: 3
DISPATCH3
(UnaryReal, UnaryOperator);
101
125k
      
case UO_Imag: 3
DISPATCH3
(UnaryImag, UnaryOperator);
102
125k
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
103
125k
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
2.71M
      }
105
2.71M
    }
106
2.71M
107
2.71M
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
2.71M
    switch (S->getStmtClass()) {
109
2.71M
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
2.71M
#define ABSTRACT_STMT(STMT)
111
2.71M
#define STMT(CLASS, PARENT)                              \
112
2.71M
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
2.71M
#include 
"clang/AST/StmtNodes.inc"0
114
2.71M
    }
115
2.71M
  }
SemaDeclCXX.cpp:clang::StmtVisitorBase<clang::make_ptr, (anonymous namespace)::UninitializedFieldVisitor, void>::Visit(clang::Stmt*)
Line
Count
Source
46
167k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
167k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
167k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
167k
    // below.
50
167k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
1.55k
      switch (BinOp->getOpcode()) {
52
1.55k
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
1.55k
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
1.55k
      
case BO_Mul: 15
DISPATCH15
(BinMul, BinaryOperator);
55
1.55k
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
56
1.55k
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
57
1.55k
      
case BO_Add: 1.48k
DISPATCH1.48k
(BinAdd, BinaryOperator);
58
1.55k
      
case BO_Sub: 4
DISPATCH4
(BinSub, BinaryOperator);
59
1.55k
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
60
1.55k
      
case BO_Shr: 12
DISPATCH12
(BinShr, BinaryOperator);
61
1.55k
62
1.55k
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
63
1.55k
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
64
1.55k
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
65
1.55k
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
66
1.55k
      
case BO_EQ: 6
DISPATCH6
(BinEQ, BinaryOperator);
67
1.55k
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
68
1.55k
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
1.55k
70
1.55k
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
71
1.55k
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
72
1.55k
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
73
1.55k
      
case BO_LAnd: 4
DISPATCH4
(BinLAnd, BinaryOperator);
74
1.55k
      
case BO_LOr : 12
DISPATCH12
(BinLOr, BinaryOperator);
75
1.55k
      
case BO_Assign: 10
DISPATCH10
(BinAssign, BinaryOperator);
76
1.55k
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
77
1.55k
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
78
1.55k
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
1.55k
      
case BO_AddAssign: 3
DISPATCH3
(BinAddAssign, CompoundAssignOperator);
80
1.55k
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
81
1.55k
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
82
1.55k
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
1.55k
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
1.55k
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
1.55k
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
1.55k
      
case BO_Comma: 7
DISPATCH7
(BinComma, BinaryOperator);
87
166k
      }
88
166k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
670
      switch (UnOp->getOpcode()) {
90
670
      
case UO_PostInc: 17
DISPATCH17
(UnaryPostInc, UnaryOperator);
91
670
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
92
670
      
case UO_PreInc: 9
DISPATCH9
(UnaryPreInc, UnaryOperator);
93
670
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
94
670
      
case UO_AddrOf: 214
DISPATCH214
(UnaryAddrOf, UnaryOperator);
95
670
      
case UO_Deref: 121
DISPATCH121
(UnaryDeref, UnaryOperator);
96
670
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
97
670
      
case UO_Minus: 302
DISPATCH302
(UnaryMinus, UnaryOperator);
98
670
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
99
670
      
case UO_LNot: 7
DISPATCH7
(UnaryLNot, UnaryOperator);
100
670
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
101
670
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
102
670
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
103
670
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
165k
      }
105
165k
    }
106
165k
107
165k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
165k
    switch (S->getStmtClass()) {
109
165k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
165k
#define ABSTRACT_STMT(STMT)
111
165k
#define STMT(CLASS, PARENT)                              \
112
165k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
165k
#include 
"clang/AST/StmtNodes.inc"0
114
165k
    }
115
165k
  }
SemaDeclCXX.cpp:clang::StmtVisitorBase<clang::make_ptr, (anonymous namespace)::CheckDefaultArgumentVisitor, bool>::Visit(clang::Stmt*)
Line
Count
Source
46
149k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
149k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
149k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
149k
    // below.
50
149k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
4.94k
      switch (BinOp->getOpcode()) {
52
4.94k
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
4.94k
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
4.94k
      
case BO_Mul: 3
DISPATCH3
(BinMul, BinaryOperator);
55
4.94k
      
case BO_Div: 15
DISPATCH15
(BinDiv, BinaryOperator);
56
4.94k
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
57
4.94k
      
case BO_Add: 22
DISPATCH22
(BinAdd, BinaryOperator);
58
4.94k
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
59
4.94k
      
case BO_Shl: 2.86k
DISPATCH2.86k
(BinShl, BinaryOperator);
60
4.94k
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
61
4.94k
62
4.94k
      
case BO_LT: 14
DISPATCH14
(BinLT, BinaryOperator);
63
4.94k
      
case BO_GT: 4
DISPATCH4
(BinGT, BinaryOperator);
64
4.94k
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
65
4.94k
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
66
4.94k
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
67
4.94k
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
68
4.94k
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
4.94k
70
4.94k
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
71
4.94k
      
case BO_Xor: 5
DISPATCH5
(BinXor, BinaryOperator);
72
4.94k
      
case BO_Or : 2.01k
DISPATCH2.01k
(BinOr, BinaryOperator);
73
4.94k
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
74
4.94k
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
75
4.94k
      
case BO_Assign: 0
DISPATCH0
(BinAssign, BinaryOperator);
76
4.94k
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
77
4.94k
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
78
4.94k
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
4.94k
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
80
4.94k
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
81
4.94k
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
82
4.94k
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
4.94k
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
4.94k
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
4.94k
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
4.94k
      
case BO_Comma: 7
DISPATCH7
(BinComma, BinaryOperator);
87
144k
      }
88
144k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
3.73k
      switch (UnOp->getOpcode()) {
90
3.73k
      
case UO_PostInc: 0
DISPATCH0
(UnaryPostInc, UnaryOperator);
91
3.73k
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
92
3.73k
      
case UO_PreInc: 0
DISPATCH0
(UnaryPreInc, UnaryOperator);
93
3.73k
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
94
3.73k
      
case UO_AddrOf: 2.86k
DISPATCH2.86k
(UnaryAddrOf, UnaryOperator);
95
3.73k
      
case UO_Deref: 0
DISPATCH0
(UnaryDeref, UnaryOperator);
96
3.73k
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
97
3.73k
      
case UO_Minus: 866
DISPATCH866
(UnaryMinus, UnaryOperator);
98
3.73k
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
99
3.73k
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
100
3.73k
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
101
3.73k
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
102
3.73k
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
103
3.73k
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
140k
      }
105
140k
    }
106
140k
107
140k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
140k
    switch (S->getStmtClass()) {
109
140k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
140k
#define ABSTRACT_STMT(STMT)
111
140k
#define STMT(CLASS, PARENT)                              \
112
140k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
140k
#include 
"clang/AST/StmtNodes.inc"0
114
140k
    }
115
140k
  }
SemaExpr.cpp:clang::StmtVisitorBase<clang::make_ptr, (anonymous namespace)::RebuildUnknownAnyFunction, clang::ActionResult<clang::Expr*, true> >::Visit(clang::Stmt*)
Line
Count
Source
46
5
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
5
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
5
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
5
    // below.
50
5
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
0
      switch (BinOp->getOpcode()) {
52
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
53
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
54
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
55
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
56
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
57
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
58
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
59
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
60
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
61
0
62
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
63
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
64
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
65
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
66
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
67
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
68
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
69
0
70
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
71
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
72
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
73
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
74
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
75
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
76
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
77
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
78
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
79
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
80
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
81
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
82
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
83
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
84
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
85
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
86
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
87
5
      }
88
5
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
0
      switch (UnOp->getOpcode()) {
90
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
91
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
92
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
93
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
94
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
95
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
96
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
97
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
98
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
99
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
100
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
101
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
102
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
103
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
104
5
      }
105
5
    }
106
5
107
5
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
5
    switch (S->getStmtClass()) {
109
5
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
5
#define ABSTRACT_STMT(STMT)
111
5
#define STMT(CLASS, PARENT)                              \
112
5
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
5
#include 
"clang/AST/StmtNodes.inc"0
114
5
    }
115
5
  }
SemaExpr.cpp:clang::StmtVisitorBase<clang::make_ptr, (anonymous namespace)::EvaluatedExprMarker, void>::Visit(clang::Stmt*)
Line
Count
Source
46
106k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
106k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
106k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
106k
    // below.
50
106k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
217
      switch (BinOp->getOpcode()) {
52
217
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
217
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
217
      
case BO_Mul: 7
DISPATCH7
(BinMul, BinaryOperator);
55
217
      
case BO_Div: 1
DISPATCH1
(BinDiv, BinaryOperator);
56
217
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
57
217
      
case BO_Add: 8
DISPATCH8
(BinAdd, BinaryOperator);
58
217
      
case BO_Sub: 20
DISPATCH20
(BinSub, BinaryOperator);
59
217
      
case BO_Shl: 27
DISPATCH27
(BinShl, BinaryOperator);
60
217
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
61
217
62
217
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
63
217
      
case BO_GT: 72
DISPATCH72
(BinGT, BinaryOperator);
64
217
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
65
217
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
66
217
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
67
217
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
68
217
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
217
70
217
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
71
217
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
72
217
      
case BO_Or : 72
DISPATCH72
(BinOr, BinaryOperator);
73
217
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
74
217
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
75
217
      
case BO_Assign: 0
DISPATCH0
(BinAssign, BinaryOperator);
76
217
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
77
217
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
78
217
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
217
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
80
217
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
81
217
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
82
217
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
217
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
217
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
217
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
217
      
case BO_Comma: 10
DISPATCH10
(BinComma, BinaryOperator);
87
105k
      }
88
105k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
460
      switch (UnOp->getOpcode()) {
90
460
      
case UO_PostInc: 0
DISPATCH0
(UnaryPostInc, UnaryOperator);
91
460
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
92
460
      
case UO_PreInc: 0
DISPATCH0
(UnaryPreInc, UnaryOperator);
93
460
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
94
460
      
case UO_AddrOf: 94
DISPATCH94
(UnaryAddrOf, UnaryOperator);
95
460
      
case UO_Deref: 0
DISPATCH0
(UnaryDeref, UnaryOperator);
96
460
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
97
460
      
case UO_Minus: 366
DISPATCH366
(UnaryMinus, UnaryOperator);
98
460
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
99
460
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
100
460
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
101
460
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
102
460
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
103
460
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
105k
      }
105
105k
    }
106
105k
107
105k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
105k
    switch (S->getStmtClass()) {
109
105k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
105k
#define ABSTRACT_STMT(STMT)
111
105k
#define STMT(CLASS, PARENT)                              \
112
105k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
105k
#include 
"clang/AST/StmtNodes.inc"0
114
105k
    }
115
105k
  }
SemaExpr.cpp:clang::StmtVisitorBase<clang::make_ptr, (anonymous namespace)::RebuildUnknownAnyExpr, clang::ActionResult<clang::Expr*, true> >::Visit(clang::Stmt*)
Line
Count
Source
46
126
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
126
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
126
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
126
    // below.
50
126
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
0
      switch (BinOp->getOpcode()) {
52
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
53
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
54
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
55
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
56
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
57
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
58
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
59
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
60
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
61
0
62
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
63
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
64
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
65
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
66
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
67
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
68
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
69
0
70
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
71
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
72
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
73
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
74
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
75
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
76
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
77
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
78
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
79
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
80
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
81
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
82
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
83
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
84
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
85
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
86
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
87
126
      }
88
126
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
4
      switch (UnOp->getOpcode()) {
90
4
      
case UO_PostInc: 0
DISPATCH0
(UnaryPostInc, UnaryOperator);
91
4
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
92
4
      
case UO_PreInc: 0
DISPATCH0
(UnaryPreInc, UnaryOperator);
93
4
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
94
4
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
95
4
      
case UO_Deref: 0
DISPATCH0
(UnaryDeref, UnaryOperator);
96
4
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
97
4
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
98
4
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
99
4
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
100
4
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
101
4
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
102
4
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
103
4
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
122
      }
105
122
    }
106
122
107
122
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
122
    switch (S->getStmtClass()) {
109
122
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
122
#define ABSTRACT_STMT(STMT)
111
122
#define STMT(CLASS, PARENT)                              \
112
122
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
122
#include 
"clang/AST/StmtNodes.inc"0
114
122
    }
115
122
  }
SemaExprObjC.cpp:clang::StmtVisitorBase<clang::make_ptr, (anonymous namespace)::ARCCastChecker, (anonymous namespace)::ACCResult>::Visit(clang::Stmt*)
Line
Count
Source
46
1.69k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
1.69k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
1.69k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
1.69k
    // below.
50
1.69k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
3
      switch (BinOp->getOpcode()) {
52
3
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
3
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
3
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
55
3
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
56
3
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
57
3
      
case BO_Add: 0
DISPATCH0
(BinAdd, BinaryOperator);
58
3
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
59
3
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
60
3
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
61
3
62
3
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
63
3
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
64
3
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
65
3
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
66
3
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
67
3
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
68
3
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
3
70
3
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
71
3
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
72
3
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
73
3
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
74
3
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
75
3
      
case BO_Assign: 0
DISPATCH0
(BinAssign, BinaryOperator);
76
3
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
77
3
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
78
3
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
3
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
80
3
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
81
3
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
82
3
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
3
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
3
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
3
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
3
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
87
1.68k
      }
88
1.68k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
3
      switch (UnOp->getOpcode()) {
90
3
      
case UO_PostInc: 0
DISPATCH0
(UnaryPostInc, UnaryOperator);
91
3
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
92
3
      
case UO_PreInc: 0
DISPATCH0
(UnaryPreInc, UnaryOperator);
93
3
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
94
3
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
95
3
      
case UO_Deref: 0
DISPATCH0
(UnaryDeref, UnaryOperator);
96
3
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
97
3
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
98
3
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
99
3
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
100
3
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
101
3
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
102
3
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
103
3
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
1.68k
      }
105
1.68k
    }
106
1.68k
107
1.68k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
1.68k
    switch (S->getStmtClass()) {
109
1.68k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
1.68k
#define ABSTRACT_STMT(STMT)
111
1.68k
#define STMT(CLASS, PARENT)                              \
112
1.68k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
1.68k
#include 
"clang/AST/StmtNodes.inc"0
114
1.68k
    }
115
1.68k
  }
SemaOpenMP.cpp:clang::StmtVisitorBase<clang::make_ptr, (anonymous namespace)::DSARefChecker, bool>::Visit(clang::Stmt*)
Line
Count
Source
46
6.60k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
6.60k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
6.60k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
6.60k
    // below.
50
6.60k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
0
      switch (BinOp->getOpcode()) {
52
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
53
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
54
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
55
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
56
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
57
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
58
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
59
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
60
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
61
0
62
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
63
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
64
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
65
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
66
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
67
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
68
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
69
0
70
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
71
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
72
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
73
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
74
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
75
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
76
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
77
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
78
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
79
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
80
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
81
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
82
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
83
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
84
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
85
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
86
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
87
6.60k
      }
88
6.60k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
0
      switch (UnOp->getOpcode()) {
90
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
91
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
92
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
93
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
94
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
95
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
96
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
97
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
98
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
99
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
100
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
101
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
102
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
103
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
104
6.60k
      }
105
6.60k
    }
106
6.60k
107
6.60k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
6.60k
    switch (S->getStmtClass()) {
109
6.60k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
6.60k
#define ABSTRACT_STMT(STMT)
111
6.60k
#define STMT(CLASS, PARENT)                              \
112
6.60k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
6.60k
#include 
"clang/AST/StmtNodes.inc"0
114
6.60k
    }
115
6.60k
  }
SemaOpenMP.cpp:clang::StmtVisitorBase<clang::make_const_ptr, (anonymous namespace)::LocalVarRefChecker, bool>::Visit(clang::Stmt const*)
Line
Count
Source
46
1.52k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
1.52k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
1.52k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
1.52k
    // below.
50
1.52k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
0
      switch (BinOp->getOpcode()) {
52
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
53
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
54
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
55
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
56
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
57
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
58
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
59
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
60
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
61
0
62
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
63
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
64
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
65
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
66
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
67
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
68
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
69
0
70
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
71
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
72
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
73
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
74
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
75
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
76
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
77
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
78
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
79
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
80
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
81
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
82
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
83
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
84
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
85
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
86
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
87
1.52k
      }
88
1.52k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
0
      switch (UnOp->getOpcode()) {
90
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
91
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
92
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
93
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
94
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
95
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
96
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
97
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
98
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
99
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
100
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
101
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
102
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
103
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
104
1.52k
      }
105
1.52k
    }
106
1.52k
107
1.52k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
1.52k
    switch (S->getStmtClass()) {
109
1.52k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
1.52k
#define ABSTRACT_STMT(STMT)
111
1.52k
#define STMT(CLASS, PARENT)                              \
112
1.52k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
1.52k
#include 
"clang/AST/StmtNodes.inc"0
114
1.52k
    }
115
1.52k
  }
SemaOpenMP.cpp:clang::StmtVisitorBase<clang::make_ptr, (anonymous namespace)::DSAAttrChecker, void>::Visit(clang::Stmt*)
Line
Count
Source
46
1.21M
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
1.21M
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
1.21M
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
1.21M
    // below.
50
1.21M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
119k
      switch (BinOp->getOpcode()) {
52
119k
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
119k
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
119k
      
case BO_Mul: 909
DISPATCH909
(BinMul, BinaryOperator);
55
119k
      
case BO_Div: 132
DISPATCH132
(BinDiv, BinaryOperator);
56
119k
      
case BO_Rem: 8
DISPATCH8
(BinRem, BinaryOperator);
57
119k
      
case BO_Add: 4.13k
DISPATCH4.13k
(BinAdd, BinaryOperator);
58
119k
      
case BO_Sub: 16.8k
DISPATCH16.8k
(BinSub, BinaryOperator);
59
119k
      
case BO_Shl: 26
DISPATCH26
(BinShl, BinaryOperator);
60
119k
      
case BO_Shr: 26
DISPATCH26
(BinShr, BinaryOperator);
61
119k
62
119k
      
case BO_LT: 54.2k
DISPATCH54.2k
(BinLT, BinaryOperator);
63
119k
      
case BO_GT: 764
DISPATCH764
(BinGT, BinaryOperator);
64
119k
      
case BO_LE: 226
DISPATCH226
(BinLE, BinaryOperator);
65
119k
      
case BO_GE: 296
DISPATCH296
(BinGE, BinaryOperator);
66
119k
      
case BO_EQ: 196
DISPATCH196
(BinEQ, BinaryOperator);
67
119k
      
case BO_NE: 80
DISPATCH80
(BinNE, BinaryOperator);
68
119k
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
119k
70
119k
      
case BO_And: 42
DISPATCH42
(BinAnd, BinaryOperator);
71
119k
      
case BO_Xor: 18
DISPATCH18
(BinXor, BinaryOperator);
72
119k
      
case BO_Or : 26
DISPATCH26
(BinOr, BinaryOperator);
73
119k
      
case BO_LAnd: 14
DISPATCH14
(BinLAnd, BinaryOperator);
74
119k
      
case BO_LOr : 14
DISPATCH14
(BinLOr, BinaryOperator);
75
119k
      
case BO_Assign: 32.0k
DISPATCH32.0k
(BinAssign, BinaryOperator);
76
119k
      
case BO_MulAssign: 81
DISPATCH81
(BinMulAssign, CompoundAssignOperator);
77
119k
      
case BO_DivAssign: 158
DISPATCH158
(BinDivAssign, CompoundAssignOperator);
78
119k
      
case BO_RemAssign: 34
DISPATCH34
(BinRemAssign, CompoundAssignOperator);
79
119k
      
case BO_AddAssign: 8.71k
DISPATCH8.71k
(BinAddAssign, CompoundAssignOperator);
80
119k
      
case BO_SubAssign: 426
DISPATCH426
(BinSubAssign, CompoundAssignOperator);
81
119k
      
case BO_ShlAssign: 26
DISPATCH26
(BinShlAssign, CompoundAssignOperator);
82
119k
      
case BO_ShrAssign: 26
DISPATCH26
(BinShrAssign, CompoundAssignOperator);
83
119k
      
case BO_AndAssign: 26
DISPATCH26
(BinAndAssign, CompoundAssignOperator);
84
119k
      
case BO_OrAssign: 48
DISPATCH48
(BinOrAssign, CompoundAssignOperator);
85
119k
      
case BO_XorAssign: 36
DISPATCH36
(BinXorAssign, CompoundAssignOperator);
86
119k
      
case BO_Comma: 244
DISPATCH244
(BinComma, BinaryOperator);
87
1.09M
      }
88
1.09M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
62.6k
      switch (UnOp->getOpcode()) {
90
62.6k
      
case UO_PostInc: 19.3k
DISPATCH19.3k
(UnaryPostInc, UnaryOperator);
91
62.6k
      
case UO_PostDec: 202
DISPATCH202
(UnaryPostDec, UnaryOperator);
92
62.6k
      
case UO_PreInc: 41.8k
DISPATCH41.8k
(UnaryPreInc, UnaryOperator);
93
62.6k
      
case UO_PreDec: 146
DISPATCH146
(UnaryPreDec, UnaryOperator);
94
62.6k
      
case UO_AddrOf: 122
DISPATCH122
(UnaryAddrOf, UnaryOperator);
95
62.6k
      
case UO_Deref: 510
DISPATCH510
(UnaryDeref, UnaryOperator);
96
62.6k
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
97
62.6k
      
case UO_Minus: 384
DISPATCH384
(UnaryMinus, UnaryOperator);
98
62.6k
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
99
62.6k
      
case UO_LNot: 122
DISPATCH122
(UnaryLNot, UnaryOperator);
100
62.6k
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
101
62.6k
      
case UO_Imag: 4
DISPATCH4
(UnaryImag, UnaryOperator);
102
62.6k
      
case UO_Extension: 18
DISPATCH18
(UnaryExtension, UnaryOperator);
103
62.6k
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
1.02M
      }
105
1.02M
    }
106
1.02M
107
1.02M
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
1.02M
    switch (S->getStmtClass()) {
109
1.02M
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
1.02M
#define ABSTRACT_STMT(STMT)
111
1.02M
#define STMT(CLASS, PARENT)                              \
112
1.02M
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
1.02M
#include 
"clang/AST/StmtNodes.inc"0
114
1.02M
    }
115
1.02M
  }
SemaStmt.cpp:clang::StmtVisitorBase<clang::make_const_ptr, (anonymous namespace)::BreakContinueFinder, void>::Visit(clang::Stmt const*)
Line
Count
Source
46
252k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
252k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
252k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
252k
    // below.
50
252k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
36.9k
      switch (BinOp->getOpcode()) {
52
36.9k
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
36.9k
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
36.9k
      
case BO_Mul: 718
DISPATCH718
(BinMul, BinaryOperator);
55
36.9k
      
case BO_Div: 370
DISPATCH370
(BinDiv, BinaryOperator);
56
36.9k
      
case BO_Rem: 54
DISPATCH54
(BinRem, BinaryOperator);
57
36.9k
      
case BO_Add: 1.39k
DISPATCH1.39k
(BinAdd, BinaryOperator);
58
36.9k
      
case BO_Sub: 811
DISPATCH811
(BinSub, BinaryOperator);
59
36.9k
      
case BO_Shl: 140
DISPATCH140
(BinShl, BinaryOperator);
60
36.9k
      
case BO_Shr: 67
DISPATCH67
(BinShr, BinaryOperator);
61
36.9k
62
36.9k
      
case BO_LT: 17.9k
DISPATCH17.9k
(BinLT, BinaryOperator);
63
36.9k
      
case BO_GT: 1.22k
DISPATCH1.22k
(BinGT, BinaryOperator);
64
36.9k
      
case BO_LE: 2.33k
DISPATCH2.33k
(BinLE, BinaryOperator);
65
36.9k
      
case BO_GE: 722
DISPATCH722
(BinGE, BinaryOperator);
66
36.9k
      
case BO_EQ: 1.49k
DISPATCH1.49k
(BinEQ, BinaryOperator);
67
36.9k
      
case BO_NE: 2.71k
DISPATCH2.71k
(BinNE, BinaryOperator);
68
36.9k
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
36.9k
70
36.9k
      
case BO_And: 114
DISPATCH114
(BinAnd, BinaryOperator);
71
36.9k
      
case BO_Xor: 2
DISPATCH2
(BinXor, BinaryOperator);
72
36.9k
      
case BO_Or : 9
DISPATCH9
(BinOr, BinaryOperator);
73
36.9k
      
case BO_LAnd: 1.54k
DISPATCH1.54k
(BinLAnd, BinaryOperator);
74
36.9k
      
case BO_LOr : 237
DISPATCH237
(BinLOr, BinaryOperator);
75
36.9k
      
case BO_Assign: 3.22k
DISPATCH3.22k
(BinAssign, BinaryOperator);
76
36.9k
      
case BO_MulAssign: 10
DISPATCH10
(BinMulAssign, CompoundAssignOperator);
77
36.9k
      
case BO_DivAssign: 3
DISPATCH3
(BinDivAssign, CompoundAssignOperator);
78
36.9k
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
36.9k
      
case BO_AddAssign: 855
DISPATCH855
(BinAddAssign, CompoundAssignOperator);
80
36.9k
      
case BO_SubAssign: 42
DISPATCH42
(BinSubAssign, CompoundAssignOperator);
81
36.9k
      
case BO_ShlAssign: 21
DISPATCH21
(BinShlAssign, CompoundAssignOperator);
82
36.9k
      
case BO_ShrAssign: 29
DISPATCH29
(BinShrAssign, CompoundAssignOperator);
83
36.9k
      
case BO_AndAssign: 2
DISPATCH2
(BinAndAssign, CompoundAssignOperator);
84
36.9k
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
36.9k
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
36.9k
      
case BO_Comma: 830
DISPATCH830
(BinComma, BinaryOperator);
87
215k
      }
88
215k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
24.6k
      switch (UnOp->getOpcode()) {
90
24.6k
      
case UO_PostInc: 15.8k
DISPATCH15.8k
(UnaryPostInc, UnaryOperator);
91
24.6k
      
case UO_PostDec: 927
DISPATCH927
(UnaryPostDec, UnaryOperator);
92
24.6k
      
case UO_PreInc: 3.96k
DISPATCH3.96k
(UnaryPreInc, UnaryOperator);
93
24.6k
      
case UO_PreDec: 470
DISPATCH470
(UnaryPreDec, UnaryOperator);
94
24.6k
      
case UO_AddrOf: 138
DISPATCH138
(UnaryAddrOf, UnaryOperator);
95
24.6k
      
case UO_Deref: 1.38k
DISPATCH1.38k
(UnaryDeref, UnaryOperator);
96
24.6k
      
case UO_Plus: 1
DISPATCH1
(UnaryPlus, UnaryOperator);
97
24.6k
      
case UO_Minus: 339
DISPATCH339
(UnaryMinus, UnaryOperator);
98
24.6k
      
case UO_Not: 1
DISPATCH1
(UnaryNot, UnaryOperator);
99
24.6k
      
case UO_LNot: 1.63k
DISPATCH1.63k
(UnaryLNot, UnaryOperator);
100
24.6k
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
101
24.6k
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
102
24.6k
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
103
24.6k
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
190k
      }
105
190k
    }
106
190k
107
190k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
190k
    switch (S->getStmtClass()) {
109
190k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
190k
#define ABSTRACT_STMT(STMT)
111
190k
#define STMT(CLASS, PARENT)                              \
112
190k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
190k
#include 
"clang/AST/StmtNodes.inc"0
114
190k
    }
115
190k
  }
SemaStmt.cpp:clang::StmtVisitorBase<clang::make_ptr, (anonymous namespace)::DeclExtractor, void>::Visit(clang::Stmt*)
Line
Count
Source
46
259k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
259k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
259k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
259k
    // below.
50
259k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
57.3k
      switch (BinOp->getOpcode()) {
52
57.3k
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
57.3k
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
57.3k
      
case BO_Mul: 1.68k
DISPATCH1.68k
(BinMul, BinaryOperator);
55
57.3k
      
case BO_Div: 1.35k
DISPATCH1.35k
(BinDiv, BinaryOperator);
56
57.3k
      
case BO_Rem: 8
DISPATCH8
(BinRem, BinaryOperator);
57
57.3k
      
case BO_Add: 2.53k
DISPATCH2.53k
(BinAdd, BinaryOperator);
58
57.3k
      
case BO_Sub: 61
DISPATCH61
(BinSub, BinaryOperator);
59
57.3k
      
case BO_Shl: 18
DISPATCH18
(BinShl, BinaryOperator);
60
57.3k
      
case BO_Shr: 8
DISPATCH8
(BinShr, BinaryOperator);
61
57.3k
62
57.3k
      
case BO_LT: 42.9k
DISPATCH42.9k
(BinLT, BinaryOperator);
63
57.3k
      
case BO_GT: 4.01k
DISPATCH4.01k
(BinGT, BinaryOperator);
64
57.3k
      
case BO_LE: 1.82k
DISPATCH1.82k
(BinLE, BinaryOperator);
65
57.3k
      
case BO_GE: 1.91k
DISPATCH1.91k
(BinGE, BinaryOperator);
66
57.3k
      
case BO_EQ: 73
DISPATCH73
(BinEQ, BinaryOperator);
67
57.3k
      
case BO_NE: 291
DISPATCH291
(BinNE, BinaryOperator);
68
57.3k
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
57.3k
70
57.3k
      
case BO_And: 36
DISPATCH36
(BinAnd, BinaryOperator);
71
57.3k
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
72
57.3k
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
73
57.3k
      
case BO_LAnd: 609
DISPATCH609
(BinLAnd, BinaryOperator);
74
57.3k
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
75
57.3k
      
case BO_Assign: 0
DISPATCH0
(BinAssign, BinaryOperator);
76
57.3k
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
77
57.3k
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
78
57.3k
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
57.3k
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
80
57.3k
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
81
57.3k
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
82
57.3k
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
57.3k
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
57.3k
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
57.3k
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
57.3k
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
87
201k
      }
88
201k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
116
      switch (UnOp->getOpcode()) {
90
116
      
case UO_PostInc: 0
DISPATCH0
(UnaryPostInc, UnaryOperator);
91
116
      
case UO_PostDec: 4
DISPATCH4
(UnaryPostDec, UnaryOperator);
92
116
      
case UO_PreInc: 0
DISPATCH0
(UnaryPreInc, UnaryOperator);
93
116
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
94
116
      
case UO_AddrOf: 0
DISPATCH0
(UnaryAddrOf, UnaryOperator);
95
116
      
case UO_Deref: 109
DISPATCH109
(UnaryDeref, UnaryOperator);
96
116
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
97
116
      
case UO_Minus: 2
DISPATCH2
(UnaryMinus, UnaryOperator);
98
116
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
99
116
      
case UO_LNot: 1
DISPATCH1
(UnaryLNot, UnaryOperator);
100
116
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
101
116
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
102
116
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
103
116
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
201k
      }
105
201k
    }
106
201k
107
201k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
201k
    switch (S->getStmtClass()) {
109
201k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
201k
#define ABSTRACT_STMT(STMT)
111
201k
#define STMT(CLASS, PARENT)                              \
112
201k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
201k
#include 
"clang/AST/StmtNodes.inc"0
114
201k
    }
115
201k
  }
SemaStmt.cpp:clang::StmtVisitorBase<clang::make_ptr, (anonymous namespace)::DeclMatcher, void>::Visit(clang::Stmt*)
Line
Count
Source
46
164k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
164k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
164k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
164k
    // below.
50
164k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
38.7k
      switch (BinOp->getOpcode()) {
52
38.7k
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
38.7k
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
38.7k
      
case BO_Mul: 1.67k
DISPATCH1.67k
(BinMul, BinaryOperator);
55
38.7k
      
case BO_Div: 815
DISPATCH815
(BinDiv, BinaryOperator);
56
38.7k
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
57
38.7k
      
case BO_Add: 1.73k
DISPATCH1.73k
(BinAdd, BinaryOperator);
58
38.7k
      
case BO_Sub: 43
DISPATCH43
(BinSub, BinaryOperator);
59
38.7k
      
case BO_Shl: 106
DISPATCH106
(BinShl, BinaryOperator);
60
38.7k
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
61
38.7k
62
38.7k
      
case BO_LT: 20.1k
DISPATCH20.1k
(BinLT, BinaryOperator);
63
38.7k
      
case BO_GT: 4.03k
DISPATCH4.03k
(BinGT, BinaryOperator);
64
38.7k
      
case BO_LE: 1.02k
DISPATCH1.02k
(BinLE, BinaryOperator);
65
38.7k
      
case BO_GE: 1.82k
DISPATCH1.82k
(BinGE, BinaryOperator);
66
38.7k
      
case BO_EQ: 24
DISPATCH24
(BinEQ, BinaryOperator);
67
38.7k
      
case BO_NE: 95
DISPATCH95
(BinNE, BinaryOperator);
68
38.7k
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
38.7k
70
38.7k
      
case BO_And: 36
DISPATCH36
(BinAnd, BinaryOperator);
71
38.7k
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
72
38.7k
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
73
38.7k
      
case BO_LAnd: 117
DISPATCH117
(BinLAnd, BinaryOperator);
74
38.7k
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
75
38.7k
      
case BO_Assign: 3.25k
DISPATCH3.25k
(BinAssign, BinaryOperator);
76
38.7k
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
77
38.7k
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
78
38.7k
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
38.7k
      
case BO_AddAssign: 2.63k
DISPATCH2.63k
(BinAddAssign, CompoundAssignOperator);
80
38.7k
      
case BO_SubAssign: 16
DISPATCH16
(BinSubAssign, CompoundAssignOperator);
81
38.7k
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
82
38.7k
      
case BO_ShrAssign: 36
DISPATCH36
(BinShrAssign, CompoundAssignOperator);
83
38.7k
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
38.7k
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
38.7k
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
38.7k
      
case BO_Comma: 1.10k
DISPATCH1.10k
(BinComma, BinaryOperator);
87
125k
      }
88
125k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
22.5k
      switch (UnOp->getOpcode()) {
90
22.5k
      
case UO_PostInc: 17.4k
DISPATCH17.4k
(UnaryPostInc, UnaryOperator);
91
22.5k
      
case UO_PostDec: 4.21k
DISPATCH4.21k
(UnaryPostDec, UnaryOperator);
92
22.5k
      
case UO_PreInc: 710
DISPATCH710
(UnaryPreInc, UnaryOperator);
93
22.5k
      
case UO_PreDec: 101
DISPATCH101
(UnaryPreDec, UnaryOperator);
94
22.5k
      
case UO_AddrOf: 2
DISPATCH2
(UnaryAddrOf, UnaryOperator);
95
22.5k
      
case UO_Deref: 20
DISPATCH20
(UnaryDeref, UnaryOperator);
96
22.5k
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
97
22.5k
      
case UO_Minus: 2
DISPATCH2
(UnaryMinus, UnaryOperator);
98
22.5k
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
99
22.5k
      
case UO_LNot: 25
DISPATCH25
(UnaryLNot, UnaryOperator);
100
22.5k
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
101
22.5k
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
102
22.5k
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
103
22.5k
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
103k
      }
105
103k
    }
106
103k
107
103k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
103k
    switch (S->getStmtClass()) {
109
103k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
103k
#define ABSTRACT_STMT(STMT)
111
103k
#define STMT(CLASS, PARENT)                              \
112
103k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
103k
#include 
"clang/AST/StmtNodes.inc"0
114
103k
    }
115
103k
  }
SemaStmt.cpp:clang::StmtVisitorBase<clang::make_ptr, (anonymous namespace)::CommaVisitor, void>::Visit(clang::Stmt*)
Line
Count
Source
46
400
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
400
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
400
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
400
    // below.
50
400
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
88
      switch (BinOp->getOpcode()) {
52
88
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
88
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
88
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
55
88
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
56
88
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
57
88
      
case BO_Add: 0
DISPATCH0
(BinAdd, BinaryOperator);
58
88
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
59
88
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
60
88
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
61
88
62
88
      
case BO_LT: 74
DISPATCH74
(BinLT, BinaryOperator);
63
88
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
64
88
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
65
88
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
66
88
      
case BO_EQ: 2
DISPATCH2
(BinEQ, BinaryOperator);
67
88
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
68
88
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
88
70
88
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
71
88
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
72
88
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
73
88
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
74
88
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
75
88
      
case BO_Assign: 0
DISPATCH0
(BinAssign, BinaryOperator);
76
88
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
77
88
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
78
88
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
88
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
80
88
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
81
88
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
82
88
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
88
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
88
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
88
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
88
      
case BO_Comma: 12
DISPATCH12
(BinComma, BinaryOperator);
87
312
      }
88
312
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
0
      switch (UnOp->getOpcode()) {
90
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
91
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
92
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
93
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
94
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
95
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
96
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
97
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
98
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
99
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
100
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
101
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
102
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
103
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
104
312
      }
105
312
    }
106
312
107
312
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
312
    switch (S->getStmtClass()) {
109
312
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
312
#define ABSTRACT_STMT(STMT)
111
312
#define STMT(CLASS, PARENT)                              \
112
312
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
312
#include 
"clang/AST/StmtNodes.inc"0
114
312
    }
115
312
  }
AnalysisDeclContext.cpp:clang::StmtVisitorBase<clang::make_ptr, (anonymous namespace)::FindBlockDeclRefExprsVals, void>::Visit(clang::Stmt*)
Line
Count
Source
46
2.33k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
2.33k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
2.33k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
2.33k
    // below.
50
2.33k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
164
      switch (BinOp->getOpcode()) {
52
164
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
164
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
164
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
55
164
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
56
164
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
57
164
      
case BO_Add: 22
DISPATCH22
(BinAdd, BinaryOperator);
58
164
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
59
164
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
60
164
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
61
164
62
164
      
case BO_LT: 4
DISPATCH4
(BinLT, BinaryOperator);
63
164
      
case BO_GT: 6
DISPATCH6
(BinGT, BinaryOperator);
64
164
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
65
164
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
66
164
      
case BO_EQ: 12
DISPATCH12
(BinEQ, BinaryOperator);
67
164
      
case BO_NE: 2
DISPATCH2
(BinNE, BinaryOperator);
68
164
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
164
70
164
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
71
164
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
72
164
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
73
164
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
74
164
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
75
164
      
case BO_Assign: 118
DISPATCH118
(BinAssign, BinaryOperator);
76
164
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
77
164
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
78
164
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
164
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
80
164
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
81
164
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
82
164
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
164
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
164
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
164
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
164
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
87
2.16k
      }
88
2.16k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
75
      switch (UnOp->getOpcode()) {
90
75
      
case UO_PostInc: 2
DISPATCH2
(UnaryPostInc, UnaryOperator);
91
75
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
92
75
      
case UO_PreInc: 12
DISPATCH12
(UnaryPreInc, UnaryOperator);
93
75
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
94
75
      
case UO_AddrOf: 9
DISPATCH9
(UnaryAddrOf, UnaryOperator);
95
75
      
case UO_Deref: 52
DISPATCH52
(UnaryDeref, UnaryOperator);
96
75
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
97
75
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
98
75
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
99
75
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
100
75
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
101
75
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
102
75
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
103
75
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
2.09k
      }
105
2.09k
    }
106
2.09k
107
2.09k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
2.09k
    switch (S->getStmtClass()) {
109
2.09k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
2.09k
#define ABSTRACT_STMT(STMT)
111
2.09k
#define STMT(CLASS, PARENT)                              \
112
2.09k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
2.09k
#include 
"clang/AST/StmtNodes.inc"0
114
2.09k
    }
115
2.09k
  }
CFG.cpp:clang::StmtVisitorBase<clang::make_ptr, (anonymous namespace)::CFGBlockTerminatorPrint, void>::Visit(clang::Stmt*)
Line
Count
Source
46
514
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
514
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
514
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
514
    // below.
50
514
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
36
      switch (BinOp->getOpcode()) {
52
36
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
36
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
36
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
55
36
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
56
36
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
57
36
      
case BO_Add: 0
DISPATCH0
(BinAdd, BinaryOperator);
58
36
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
59
36
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
60
36
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
61
36
62
36
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
63
36
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
64
36
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
65
36
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
66
36
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
67
36
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
68
36
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
36
70
36
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
71
36
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
72
36
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
73
36
      
case BO_LAnd: 8
DISPATCH8
(BinLAnd, BinaryOperator);
74
36
      
case BO_LOr : 28
DISPATCH28
(BinLOr, BinaryOperator);
75
36
      
case BO_Assign: 0
DISPATCH0
(BinAssign, BinaryOperator);
76
36
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
77
36
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
78
36
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
36
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
80
36
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
81
36
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
82
36
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
36
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
36
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
36
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
36
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
87
478
      }
88
478
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
0
      switch (UnOp->getOpcode()) {
90
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
91
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
92
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
93
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
94
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
95
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
96
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
97
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
98
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
99
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
100
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
101
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
102
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
103
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
104
478
      }
105
478
    }
106
478
107
478
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
478
    switch (S->getStmtClass()) {
109
478
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
478
#define ABSTRACT_STMT(STMT)
111
478
#define STMT(CLASS, PARENT)                              \
112
478
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
478
#include 
"clang/AST/StmtNodes.inc"0
114
478
    }
115
478
  }
CallGraph.cpp:clang::StmtVisitorBase<clang::make_ptr, (anonymous namespace)::CGBuilder, void>::Visit(clang::Stmt*)
Line
Count
Source
46
238k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
238k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
238k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
238k
    // below.
50
238k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
14.5k
      switch (BinOp->getOpcode()) {
52
14.5k
      
case BO_PtrMemD: 22
DISPATCH22
(BinPtrMemD, BinaryOperator);
53
14.5k
      
case BO_PtrMemI: 6
DISPATCH6
(BinPtrMemI, BinaryOperator);
54
14.5k
      
case BO_Mul: 359
DISPATCH359
(BinMul, BinaryOperator);
55
14.5k
      
case BO_Div: 414
DISPATCH414
(BinDiv, BinaryOperator);
56
14.5k
      
case BO_Rem: 24
DISPATCH24
(BinRem, BinaryOperator);
57
14.5k
      
case BO_Add: 1.06k
DISPATCH1.06k
(BinAdd, BinaryOperator);
58
14.5k
      
case BO_Sub: 446
DISPATCH446
(BinSub, BinaryOperator);
59
14.5k
      
case BO_Shl: 50
DISPATCH50
(BinShl, BinaryOperator);
60
14.5k
      
case BO_Shr: 47
DISPATCH47
(BinShr, BinaryOperator);
61
14.5k
62
14.5k
      
case BO_LT: 834
DISPATCH834
(BinLT, BinaryOperator);
63
14.5k
      
case BO_GT: 461
DISPATCH461
(BinGT, BinaryOperator);
64
14.5k
      
case BO_LE: 275
DISPATCH275
(BinLE, BinaryOperator);
65
14.5k
      
case BO_GE: 224
DISPATCH224
(BinGE, BinaryOperator);
66
14.5k
      
case BO_EQ: 4.27k
DISPATCH4.27k
(BinEQ, BinaryOperator);
67
14.5k
      
case BO_NE: 666
DISPATCH666
(BinNE, BinaryOperator);
68
14.5k
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
14.5k
70
14.5k
      
case BO_And: 79
DISPATCH79
(BinAnd, BinaryOperator);
71
14.5k
      
case BO_Xor: 4
DISPATCH4
(BinXor, BinaryOperator);
72
14.5k
      
case BO_Or : 71
DISPATCH71
(BinOr, BinaryOperator);
73
14.5k
      
case BO_LAnd: 214
DISPATCH214
(BinLAnd, BinaryOperator);
74
14.5k
      
case BO_LOr : 216
DISPATCH216
(BinLOr, BinaryOperator);
75
14.5k
      
case BO_Assign: 4.45k
DISPATCH4.45k
(BinAssign, BinaryOperator);
76
14.5k
      
case BO_MulAssign: 14
DISPATCH14
(BinMulAssign, CompoundAssignOperator);
77
14.5k
      
case BO_DivAssign: 21
DISPATCH21
(BinDivAssign, CompoundAssignOperator);
78
14.5k
      
case BO_RemAssign: 5
DISPATCH5
(BinRemAssign, CompoundAssignOperator);
79
14.5k
      
case BO_AddAssign: 151
DISPATCH151
(BinAddAssign, CompoundAssignOperator);
80
14.5k
      
case BO_SubAssign: 36
DISPATCH36
(BinSubAssign, CompoundAssignOperator);
81
14.5k
      
case BO_ShlAssign: 8
DISPATCH8
(BinShlAssign, CompoundAssignOperator);
82
14.5k
      
case BO_ShrAssign: 2
DISPATCH2
(BinShrAssign, CompoundAssignOperator);
83
14.5k
      
case BO_AndAssign: 11
DISPATCH11
(BinAndAssign, CompoundAssignOperator);
84
14.5k
      
case BO_OrAssign: 9
DISPATCH9
(BinOrAssign, CompoundAssignOperator);
85
14.5k
      
case BO_XorAssign: 18
DISPATCH18
(BinXorAssign, CompoundAssignOperator);
86
14.5k
      
case BO_Comma: 93
DISPATCH93
(BinComma, BinaryOperator);
87
224k
      }
88
224k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
89
6.05k
      switch (UnOp->getOpcode()) {
90
6.05k
      
case UO_PostInc: 502
DISPATCH502
(UnaryPostInc, UnaryOperator);
91
6.05k
      
case UO_PostDec: 42
DISPATCH42
(UnaryPostDec, UnaryOperator);
92
6.05k
      
case UO_PreInc: 450
DISPATCH450
(UnaryPreInc, UnaryOperator);
93
6.05k
      
case UO_PreDec: 75
DISPATCH75
(UnaryPreDec, UnaryOperator);
94
6.05k
      
case UO_AddrOf: 2.16k
DISPATCH2.16k
(UnaryAddrOf, UnaryOperator);
95
6.05k
      
case UO_Deref: 1.66k
DISPATCH1.66k
(UnaryDeref, UnaryOperator);
96
6.05k
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
97
6.05k
      
case UO_Minus: 500
DISPATCH500
(UnaryMinus, UnaryOperator);
98
6.05k
      
case UO_Not: 150
DISPATCH150
(UnaryNot, UnaryOperator);
99
6.05k
      
case UO_LNot: 459
DISPATCH459
(UnaryLNot, UnaryOperator);
100
6.05k
      
case UO_Real: 7
DISPATCH7
(UnaryReal, UnaryOperator);
101
6.05k
      
case UO_Imag: 5
DISPATCH5
(UnaryImag, UnaryOperator);
102
6.05k
      
case UO_Extension: 29
DISPATCH29
(UnaryExtension, UnaryOperator);
103
6.05k
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
104
217k
      }
105
217k
    }
106
217k
107
217k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
108
217k
    switch (S->getStmtClass()) {
109
217k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
110
217k
#define ABSTRACT_STMT(STMT)
111
217k
#define STMT(CLASS, PARENT)                              \
112
217k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
113
217k
#include 
"clang/AST/StmtNodes.inc"6
114
217k
    }
115
217k
  }
CloneDetection.cpp:clang::StmtVisitorBase<clang::make_const_ptr, (anonymous namespace)::CloneTypeIIStmtDataCollector<llvm::MD5>, void>::Visit(clang::Stmt const*)
Line
Count
Source
46
1.83k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
47
1.83k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
48
1.83k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
49
1.83k
    // below.
50
1.83k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
51
285
      switch (BinOp->getOpcode()) {
52
285
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
53
285
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
54
285
      
case BO_Mul: 21
DISPATCH21
(BinMul, BinaryOperator);
55
285
      
case BO_Div: 16
DISPATCH16
(BinDiv, BinaryOperator);
56
285
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
57
285
      
case BO_Add: 86
DISPATCH86
(BinAdd, BinaryOperator);
58
285
      
case BO_Sub: 11
DISPATCH11
(BinSub, BinaryOperator);
59
285
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
60
285
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
61
285
62
285
      
case BO_LT: 26
DISPATCH26
(BinLT, BinaryOperator);
63
285
      
case BO_GT: 49
DISPATCH49
(BinGT, BinaryOperator);
64
285
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
65
285
      
case BO_GE: 1
DISPATCH1
(BinGE, BinaryOperator);
66
285
      
case BO_EQ: 3
DISPATCH3
(BinEQ, BinaryOperator);
67
285
      
case BO_NE: 4
DISPATCH4
(BinNE, BinaryOperator);
68
285
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
69
285
70
285
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
71
285
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
72
285
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
73
285
      
case BO_LAnd: 3
DISPATCH3
(BinLAnd, BinaryOperator);
74
285
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
75
285
      
case BO_Assign: 48
DISPATCH48
(BinAssign, BinaryOperator);
76
285
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
77
285
      
case BO_DivAssign: 2
DISPATCH2
(BinDivAssign, CompoundAssignOperator);
78
285
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
79
285
      
case BO_AddAssign: 9
DISPATCH9
(BinAddAssign, CompoundAssignOperator);
80
285
      
case BO_SubAssign: 4
DISPATCH4
(BinSubAssign, CompoundAssignOperator);
81
285
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
82
285
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
83
285
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
84
285
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
85
285
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
86
285
      
case BO_Comma: 2
DISPATCH2<