Coverage Report

Created: 2019-03-22 08:08

/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
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4
// See https://llvm.org/LICENSE.txt for license information.
5
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6
//
7
//===----------------------------------------------------------------------===//
8
//
9
//  This file defines the StmtVisitor and ConstStmtVisitor interfaces.
10
//
11
//===----------------------------------------------------------------------===//
12
13
#ifndef LLVM_CLANG_AST_STMTVISITOR_H
14
#define LLVM_CLANG_AST_STMTVISITOR_H
15
16
#include "clang/AST/ExprCXX.h"
17
#include "clang/AST/ExprObjC.h"
18
#include "clang/AST/ExprOpenMP.h"
19
#include "clang/AST/Stmt.h"
20
#include "clang/AST/StmtCXX.h"
21
#include "clang/AST/StmtObjC.h"
22
#include "clang/AST/StmtOpenMP.h"
23
#include "clang/Basic/LLVM.h"
24
#include "llvm/ADT/STLExtras.h"
25
#include "llvm/Support/Casting.h"
26
#include "llvm/Support/ErrorHandling.h"
27
#include <utility>
28
29
namespace clang {
30
/// StmtVisitorBase - This class implements a simple visitor for Stmt
31
/// subclasses. Since Expr derives from Stmt, this also includes support for
32
/// visiting Exprs.
33
template<template <typename> class Ptr, typename ImplClass, typename RetTy=void,
34
         class... ParamTys>
35
class StmtVisitorBase {
36
public:
37
#define PTR(CLASS) typename Ptr<CLASS>::type
38
#define DISPATCH(NAME, CLASS) \
39
214M
  return static_cast<ImplClass*>(this)->Visit ## NAME( \
40
214M
    static_cast<PTR(CLASS)>(S), std::forward<ParamTys>(P)...)
41
42
137M
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
137M
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
137M
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
137M
    // below.
46
137M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
13.9M
      switch (BinOp->getOpcode()) {
48
13.9M
      
case BO_PtrMemD: 70.6k
DISPATCH70.6k
(BinPtrMemD, BinaryOperator);
49
13.9M
      
case BO_PtrMemI: 411
DISPATCH411
(BinPtrMemI, BinaryOperator);
50
13.9M
      
case BO_Mul: 543k
DISPATCH543k
(BinMul, BinaryOperator);
51
13.9M
      
case BO_Div: 477k
DISPATCH477k
(BinDiv, BinaryOperator);
52
13.9M
      
case BO_Rem: 40.6k
DISPATCH40.6k
(BinRem, BinaryOperator);
53
13.9M
      
case BO_Add: 1.48M
DISPATCH1.48M
(BinAdd, BinaryOperator);
54
13.9M
      
case BO_Sub: 1.56M
DISPATCH1.56M
(BinSub, BinaryOperator);
55
13.9M
      
case BO_Shl: 397k
DISPATCH397k
(BinShl, BinaryOperator);
56
13.9M
      
case BO_Shr: 167k
DISPATCH167k
(BinShr, BinaryOperator);
57
13.9M
58
13.9M
      
case BO_LT: 871k
DISPATCH871k
(BinLT, BinaryOperator);
59
13.9M
      
case BO_GT: 618k
DISPATCH618k
(BinGT, BinaryOperator);
60
13.9M
      
case BO_LE: 233k
DISPATCH233k
(BinLE, BinaryOperator);
61
13.9M
      
case BO_GE: 166k
DISPATCH166k
(BinGE, BinaryOperator);
62
13.9M
      
case BO_EQ: 1.04M
DISPATCH1.04M
(BinEQ, BinaryOperator);
63
13.9M
      
case BO_NE: 452k
DISPATCH452k
(BinNE, BinaryOperator);
64
13.9M
      
case BO_Cmp: 477
DISPATCH477
(BinCmp, BinaryOperator);
65
13.9M
66
13.9M
      
case BO_And: 302k
DISPATCH302k
(BinAnd, BinaryOperator);
67
13.9M
      
case BO_Xor: 61.2k
DISPATCH61.2k
(BinXor, BinaryOperator);
68
13.9M
      
case BO_Or : 173k
DISPATCH173k
(BinOr, BinaryOperator);
69
13.9M
      
case BO_LAnd: 1.03M
DISPATCH1.03M
(BinLAnd, BinaryOperator);
70
13.9M
      
case BO_LOr : 421k
DISPATCH421k
(BinLOr, BinaryOperator);
71
13.9M
      
case BO_Assign: 3.32M
DISPATCH3.32M
(BinAssign, BinaryOperator);
72
13.9M
      
case BO_MulAssign: 13.6k
DISPATCH13.6k
(BinMulAssign, CompoundAssignOperator);
73
13.9M
      
case BO_DivAssign: 4.81k
DISPATCH4.81k
(BinDivAssign, CompoundAssignOperator);
74
13.9M
      
case BO_RemAssign: 749
DISPATCH749
(BinRemAssign, CompoundAssignOperator);
75
13.9M
      
case BO_AddAssign: 158k
DISPATCH158k
(BinAddAssign, CompoundAssignOperator);
76
13.9M
      
case BO_SubAssign: 21.9k
DISPATCH21.9k
(BinSubAssign, CompoundAssignOperator);
77
13.9M
      
case BO_ShlAssign: 7.51k
DISPATCH7.51k
(BinShlAssign, CompoundAssignOperator);
78
13.9M
      
case BO_ShrAssign: 3.90k
DISPATCH3.90k
(BinShrAssign, CompoundAssignOperator);
79
13.9M
      
case BO_AndAssign: 9.05k
DISPATCH9.05k
(BinAndAssign, CompoundAssignOperator);
80
13.9M
      
case BO_OrAssign: 41.6k
DISPATCH41.6k
(BinOrAssign, CompoundAssignOperator);
81
13.9M
      
case BO_XorAssign: 5.85k
DISPATCH5.85k
(BinXorAssign, CompoundAssignOperator);
82
13.9M
      
case BO_Comma: 207k
DISPATCH207k
(BinComma, BinaryOperator);
83
123M
      }
84
123M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
4.46M
      switch (UnOp->getOpcode()) {
86
4.46M
      
case UO_PostInc: 275k
DISPATCH275k
(UnaryPostInc, UnaryOperator);
87
4.46M
      
case UO_PostDec: 20.4k
DISPATCH20.4k
(UnaryPostDec, UnaryOperator);
88
4.46M
      
case UO_PreInc: 212k
DISPATCH212k
(UnaryPreInc, UnaryOperator);
89
4.46M
      
case UO_PreDec: 33.4k
DISPATCH33.4k
(UnaryPreDec, UnaryOperator);
90
4.46M
      
case UO_AddrOf: 441k
DISPATCH441k
(UnaryAddrOf, UnaryOperator);
91
4.46M
      
case UO_Deref: 503k
DISPATCH503k
(UnaryDeref, UnaryOperator);
92
4.46M
      
case UO_Plus: 1.19k
DISPATCH1.19k
(UnaryPlus, UnaryOperator);
93
4.46M
      
case UO_Minus: 563k
DISPATCH563k
(UnaryMinus, UnaryOperator);
94
4.46M
      
case UO_Not: 86.3k
DISPATCH86.3k
(UnaryNot, UnaryOperator);
95
4.46M
      
case UO_LNot: 2.28M
DISPATCH2.28M
(UnaryLNot, UnaryOperator);
96
4.46M
      
case UO_Real: 3.30k
DISPATCH3.30k
(UnaryReal, UnaryOperator);
97
4.46M
      
case UO_Imag: 3.25k
DISPATCH3.25k
(UnaryImag, UnaryOperator);
98
4.46M
      
case UO_Extension: 36.2k
DISPATCH36.2k
(UnaryExtension, UnaryOperator);
99
4.46M
      
case UO_Coawait: 10
DISPATCH10
(UnaryCoawait, UnaryOperator);
100
118M
      }
101
118M
    }
102
118M
103
118M
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
118M
    switch (S->getStmtClass()) {
105
118M
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
118M
#define ABSTRACT_STMT(STMT)
107
118M
#define STMT(CLASS, PARENT)                              \
108
118M
    case Stmt::CLASS ## Class: 
DISPATCH118M
(CLASS, CLASS);
109
118M
#include 
"clang/AST/StmtNodes.inc"42.6k
110
118M
    }
111
118M
  }
CGClass.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::DynamicThisUseChecker, void>::Visit(clang::Stmt const*)
Line
Count
Source
42
31.4k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
31.4k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
31.4k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
31.4k
    // below.
46
31.4k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
11
      switch (BinOp->getOpcode()) {
48
11
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
49
11
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
50
11
      
case BO_Mul: 1
DISPATCH1
(BinMul, BinaryOperator);
51
11
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
52
11
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
53
11
      
case BO_Add: 10
DISPATCH10
(BinAdd, BinaryOperator);
54
11
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
55
11
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
56
11
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
57
11
58
11
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
59
11
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
60
11
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
61
11
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
62
11
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
63
11
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
64
11
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
65
11
66
11
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
67
11
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
68
11
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
69
11
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
70
11
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
71
11
      
case BO_Assign: 0
DISPATCH0
(BinAssign, BinaryOperator);
72
11
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
73
11
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
74
11
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
75
11
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
76
11
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
77
11
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
78
11
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
79
11
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
80
11
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
81
11
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
82
11
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
83
31.3k
      }
84
31.3k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
118
      switch (UnOp->getOpcode()) {
86
118
      
case UO_PostInc: 0
DISPATCH0
(UnaryPostInc, UnaryOperator);
87
118
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
88
118
      
case UO_PreInc: 0
DISPATCH0
(UnaryPreInc, UnaryOperator);
89
118
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
90
118
      
case UO_AddrOf: 113
DISPATCH113
(UnaryAddrOf, UnaryOperator);
91
118
      
case UO_Deref: 5
DISPATCH5
(UnaryDeref, UnaryOperator);
92
118
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
93
118
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
94
118
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
95
118
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
96
118
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
97
118
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
98
118
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
99
118
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
100
31.2k
      }
101
31.2k
    }
102
31.2k
103
31.2k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
31.2k
    switch (S->getStmtClass()) {
105
31.2k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
31.2k
#define ABSTRACT_STMT(STMT)
107
31.2k
#define STMT(CLASS, PARENT)                              \
108
31.2k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
31.2k
#include 
"clang/AST/StmtNodes.inc"0
110
31.2k
    }
111
31.2k
  }
CGCoroutine.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::GetParamRef, void>::Visit(clang::Stmt*)
Line
Count
Source
42
70
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
70
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
70
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
70
    // below.
46
70
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
0
      switch (BinOp->getOpcode()) {
48
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
49
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
50
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
51
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
52
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
53
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
54
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
55
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
56
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
57
0
58
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
59
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
60
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
61
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
62
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
63
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
64
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
65
0
66
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
67
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
68
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
69
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
70
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
71
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
72
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
73
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
74
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
75
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
76
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
77
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
78
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
79
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
80
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
81
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
82
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
83
70
      }
84
70
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
0
      switch (UnOp->getOpcode()) {
86
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
87
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
88
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
89
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
90
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
91
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
92
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
93
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
94
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
95
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
96
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
97
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
98
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
99
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
100
70
      }
101
70
    }
102
70
103
70
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
70
    switch (S->getStmtClass()) {
105
70
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
70
#define ABSTRACT_STMT(STMT)
107
70
#define STMT(CLASS, PARENT)                              \
108
70
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
70
#include 
"clang/AST/StmtNodes.inc"0
110
70
    }
111
70
  }
CGException.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::CaptureFinder, void>::Visit(clang::Stmt const*)
Line
Count
Source
42
445
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
445
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
445
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
445
    // below.
46
445
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
33
      switch (BinOp->getOpcode()) {
48
33
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
49
33
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
50
33
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
51
33
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
52
33
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
53
33
      
case BO_Add: 0
DISPATCH0
(BinAdd, BinaryOperator);
54
33
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
55
33
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
56
33
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
57
33
58
33
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
59
33
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
60
33
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
61
33
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
62
33
      
case BO_EQ: 12
DISPATCH12
(BinEQ, BinaryOperator);
63
33
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
64
33
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
65
33
66
33
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
67
33
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
68
33
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
69
33
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
70
33
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
71
33
      
case BO_Assign: 12
DISPATCH12
(BinAssign, BinaryOperator);
72
33
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
73
33
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
74
33
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
75
33
      
case BO_AddAssign: 9
DISPATCH9
(BinAddAssign, CompoundAssignOperator);
76
33
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
77
33
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
78
33
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
79
33
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
80
33
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
81
33
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
82
33
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
83
412
      }
84
412
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
10
      switch (UnOp->getOpcode()) {
86
10
      
case UO_PostInc: 0
DISPATCH0
(UnaryPostInc, UnaryOperator);
87
10
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
88
10
      
case UO_PreInc: 5
DISPATCH5
(UnaryPreInc, UnaryOperator);
89
10
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
90
10
      
case UO_AddrOf: 0
DISPATCH0
(UnaryAddrOf, UnaryOperator);
91
10
      
case UO_Deref: 0
DISPATCH0
(UnaryDeref, UnaryOperator);
92
10
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
93
10
      
case UO_Minus: 5
DISPATCH5
(UnaryMinus, UnaryOperator);
94
10
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
95
10
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
96
10
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
97
10
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
98
10
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
99
10
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
100
402
      }
101
402
    }
102
402
103
402
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
402
    switch (S->getStmtClass()) {
105
402
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
402
#define ABSTRACT_STMT(STMT)
107
402
#define STMT(CLASS, PARENT)                              \
108
402
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
402
#include 
"clang/AST/StmtNodes.inc"0
110
402
    }
111
402
  }
CGExprAgg.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::AggExprEmitter, void>::Visit(clang::Stmt*)
Line
Count
Source
42
209k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
209k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
209k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
209k
    // below.
46
209k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
1.40k
      switch (BinOp->getOpcode()) {
48
1.40k
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
49
1.40k
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
50
1.40k
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
51
1.40k
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
52
1.40k
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
53
1.40k
      
case BO_Add: 0
DISPATCH0
(BinAdd, BinaryOperator);
54
1.40k
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
55
1.40k
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
56
1.40k
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
57
1.40k
58
1.40k
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
59
1.40k
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
60
1.40k
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
61
1.40k
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
62
1.40k
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
63
1.40k
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
64
1.40k
      
case BO_Cmp: 17
DISPATCH17
(BinCmp, BinaryOperator);
65
1.40k
66
1.40k
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
67
1.40k
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
68
1.40k
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
69
1.40k
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
70
1.40k
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
71
1.40k
      
case BO_Assign: 1.33k
DISPATCH1.33k
(BinAssign, BinaryOperator);
72
1.40k
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
73
1.40k
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
74
1.40k
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
75
1.40k
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
76
1.40k
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
77
1.40k
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
78
1.40k
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
79
1.40k
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
80
1.40k
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
81
1.40k
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
82
1.40k
      
case BO_Comma: 52
DISPATCH52
(BinComma, BinaryOperator);
83
208k
      }
84
208k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
1.09k
      switch (UnOp->getOpcode()) {
86
1.09k
      
case UO_PostInc: 0
DISPATCH0
(UnaryPostInc, UnaryOperator);
87
1.09k
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
88
1.09k
      
case UO_PreInc: 0
DISPATCH0
(UnaryPreInc, UnaryOperator);
89
1.09k
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
90
1.09k
      
case UO_AddrOf: 0
DISPATCH0
(UnaryAddrOf, UnaryOperator);
91
1.09k
      
case UO_Deref: 274
DISPATCH274
(UnaryDeref, UnaryOperator);
92
1.09k
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
93
1.09k
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
94
1.09k
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
95
1.09k
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
96
1.09k
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
97
1.09k
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
98
1.09k
      
case UO_Extension: 825
DISPATCH825
(UnaryExtension, UnaryOperator);
99
1.09k
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
100
207k
      }
101
207k
    }
102
207k
103
207k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
207k
    switch (S->getStmtClass()) {
105
207k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
207k
#define ABSTRACT_STMT(STMT)
107
207k
#define STMT(CLASS, PARENT)                              \
108
207k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
207k
#include 
"clang/AST/StmtNodes.inc"0
110
207k
    }
111
207k
  }
CGExprComplex.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::ComplexExprEmitter, std::__1::pair<llvm::Value*, llvm::Value*> >::Visit(clang::Stmt*)
Line
Count
Source
42
4.49k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
4.49k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
4.49k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
4.49k
    // below.
46
4.49k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
742
      switch (BinOp->getOpcode()) {
48
742
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
49
742
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
50
742
      
case BO_Mul: 132
DISPATCH132
(BinMul, BinaryOperator);
51
742
      
case BO_Div: 95
DISPATCH95
(BinDiv, BinaryOperator);
52
742
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
53
742
      
case BO_Add: 218
DISPATCH218
(BinAdd, BinaryOperator);
54
742
      
case BO_Sub: 121
DISPATCH121
(BinSub, BinaryOperator);
55
742
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
56
742
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
57
742
58
742
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
59
742
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
60
742
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
61
742
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
62
742
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
63
742
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
64
742
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
65
742
66
742
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
67
742
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
68
742
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
69
742
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
70
742
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
71
742
      
case BO_Assign: 160
DISPATCH160
(BinAssign, BinaryOperator);
72
742
      
case BO_MulAssign: 1
DISPATCH1
(BinMulAssign, CompoundAssignOperator);
73
742
      
case BO_DivAssign: 4
DISPATCH4
(BinDivAssign, CompoundAssignOperator);
74
742
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
75
742
      
case BO_AddAssign: 11
DISPATCH11
(BinAddAssign, CompoundAssignOperator);
76
742
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
77
742
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
78
742
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
79
742
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
80
742
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
81
742
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
82
742
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
83
3.75k
      }
84
3.75k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
36
      switch (UnOp->getOpcode()) {
86
36
      
case UO_PostInc: 2
DISPATCH2
(UnaryPostInc, UnaryOperator);
87
36
      
case UO_PostDec: 2
DISPATCH2
(UnaryPostDec, UnaryOperator);
88
36
      
case UO_PreInc: 2
DISPATCH2
(UnaryPreInc, UnaryOperator);
89
36
      
case UO_PreDec: 2
DISPATCH2
(UnaryPreDec, UnaryOperator);
90
36
      
case UO_AddrOf: 0
DISPATCH0
(UnaryAddrOf, UnaryOperator);
91
36
      
case UO_Deref: 4
DISPATCH4
(UnaryDeref, UnaryOperator);
92
36
      
case UO_Plus: 5
DISPATCH5
(UnaryPlus, UnaryOperator);
93
36
      
case UO_Minus: 4
DISPATCH4
(UnaryMinus, UnaryOperator);
94
36
      
case UO_Not: 3
DISPATCH3
(UnaryNot, UnaryOperator);
95
36
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
96
36
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
97
36
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
98
36
      
case UO_Extension: 12
DISPATCH12
(UnaryExtension, UnaryOperator);
99
36
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
100
3.71k
      }
101
3.71k
    }
102
3.71k
103
3.71k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
3.71k
    switch (S->getStmtClass()) {
105
3.71k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
3.71k
#define ABSTRACT_STMT(STMT)
107
3.71k
#define STMT(CLASS, PARENT)                              \
108
3.71k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
3.71k
#include 
"clang/AST/StmtNodes.inc"0
110
3.71k
    }
111
3.71k
  }
CGExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::ConstantLValueEmitter, (anonymous namespace)::ConstantLValue>::Visit(clang::Stmt const*)
Line
Count
Source
42
14.5k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
14.5k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
14.5k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
14.5k
    // below.
46
14.5k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
0
      switch (BinOp->getOpcode()) {
48
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
49
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
50
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
51
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
52
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
53
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
54
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
55
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
56
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
57
0
58
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
59
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
60
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
61
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
62
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
63
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
64
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
65
0
66
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
67
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
68
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
69
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
70
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
71
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
72
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
73
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
74
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
75
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
76
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
77
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
78
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
79
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
80
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
81
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
82
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
83
14.5k
      }
84
14.5k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
0
      switch (UnOp->getOpcode()) {
86
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
87
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
88
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
89
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
90
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
91
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
92
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
93
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
94
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
95
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
96
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
97
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
98
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
99
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
100
14.5k
      }
101
14.5k
    }
102
14.5k
103
14.5k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
14.5k
    switch (S->getStmtClass()) {
105
14.5k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
14.5k
#define ABSTRACT_STMT(STMT)
107
14.5k
#define STMT(CLASS, PARENT)                              \
108
14.5k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
14.5k
#include 
"clang/AST/StmtNodes.inc"0
110
14.5k
    }
111
14.5k
  }
CGExprConstant.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::ConstExprEmitter, llvm::Constant*, clang::QualType>::Visit(clang::Stmt*, clang::QualType)
Line
Count
Source
42
37.3k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
37.3k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
37.3k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
37.3k
    // below.
46
37.3k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
128
      switch (BinOp->getOpcode()) {
48
128
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
49
128
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
50
128
      
case BO_Mul: 4
DISPATCH4
(BinMul, BinaryOperator);
51
128
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
52
128
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
53
128
      
case BO_Add: 91
DISPATCH91
(BinAdd, BinaryOperator);
54
128
      
case BO_Sub: 7
DISPATCH7
(BinSub, BinaryOperator);
55
128
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
56
128
      
case BO_Shr: 1
DISPATCH1
(BinShr, BinaryOperator);
57
128
58
128
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
59
128
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
60
128
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
61
128
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
62
128
      
case BO_EQ: 12
DISPATCH12
(BinEQ, BinaryOperator);
63
128
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
64
128
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
65
128
66
128
      
case BO_And: 1
DISPATCH1
(BinAnd, BinaryOperator);
67
128
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
68
128
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
69
128
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
70
128
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
71
128
      
case BO_Assign: 5
DISPATCH5
(BinAssign, BinaryOperator);
72
128
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
73
128
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
74
128
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
75
128
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
76
128
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
77
128
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
78
128
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
79
128
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
80
128
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
81
128
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
82
128
      
case BO_Comma: 7
DISPATCH7
(BinComma, BinaryOperator);
83
37.2k
      }
84
37.2k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
55
      switch (UnOp->getOpcode()) {
86
55
      
case UO_PostInc: 1
DISPATCH1
(UnaryPostInc, UnaryOperator);
87
55
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
88
55
      
case UO_PreInc: 2
DISPATCH2
(UnaryPreInc, UnaryOperator);
89
55
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
90
55
      
case UO_AddrOf: 33
DISPATCH33
(UnaryAddrOf, UnaryOperator);
91
55
      
case UO_Deref: 15
DISPATCH15
(UnaryDeref, UnaryOperator);
92
55
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
93
55
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
94
55
      
case UO_Not: 3
DISPATCH3
(UnaryNot, UnaryOperator);
95
55
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
96
55
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
97
55
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
98
55
      
case UO_Extension: 1
DISPATCH1
(UnaryExtension, UnaryOperator);
99
55
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
100
37.1k
      }
101
37.1k
    }
102
37.1k
103
37.1k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
37.1k
    switch (S->getStmtClass()) {
105
37.1k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
37.1k
#define ABSTRACT_STMT(STMT)
107
37.1k
#define STMT(CLASS, PARENT)                              \
108
37.1k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
37.1k
#include 
"clang/AST/StmtNodes.inc"0
110
37.1k
    }
111
37.1k
  }
CGExprScalar.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::ScalarExprEmitter, llvm::Value*>::Visit(clang::Stmt*)
Line
Count
Source
42
9.56M
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
9.56M
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
9.56M
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
9.56M
    // below.
46
9.56M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
1.07M
      switch (BinOp->getOpcode()) {
48
1.07M
      
case BO_PtrMemD: 22
DISPATCH22
(BinPtrMemD, BinaryOperator);
49
1.07M
      
case BO_PtrMemI: 15
DISPATCH15
(BinPtrMemI, BinaryOperator);
50
1.07M
      
case BO_Mul: 72.4k
DISPATCH72.4k
(BinMul, BinaryOperator);
51
1.07M
      
case BO_Div: 47.7k
DISPATCH47.7k
(BinDiv, BinaryOperator);
52
1.07M
      
case BO_Rem: 3.37k
DISPATCH3.37k
(BinRem, BinaryOperator);
53
1.07M
      
case BO_Add: 154k
DISPATCH154k
(BinAdd, BinaryOperator);
54
1.07M
      
case BO_Sub: 159k
DISPATCH159k
(BinSub, BinaryOperator);
55
1.07M
      
case BO_Shl: 28.7k
DISPATCH28.7k
(BinShl, BinaryOperator);
56
1.07M
      
case BO_Shr: 20.3k
DISPATCH20.3k
(BinShr, BinaryOperator);
57
1.07M
58
1.07M
      
case BO_LT: 54.3k
DISPATCH54.3k
(BinLT, BinaryOperator);
59
1.07M
      
case BO_GT: 34.3k
DISPATCH34.3k
(BinGT, BinaryOperator);
60
1.07M
      
case BO_LE: 18.3k
DISPATCH18.3k
(BinLE, BinaryOperator);
61
1.07M
      
case BO_GE: 12.9k
DISPATCH12.9k
(BinGE, BinaryOperator);
62
1.07M
      
case BO_EQ: 78.7k
DISPATCH78.7k
(BinEQ, BinaryOperator);
63
1.07M
      
case BO_NE: 40.8k
DISPATCH40.8k
(BinNE, BinaryOperator);
64
1.07M
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
65
1.07M
66
1.07M
      
case BO_And: 26.6k
DISPATCH26.6k
(BinAnd, BinaryOperator);
67
1.07M
      
case BO_Xor: 7.05k
DISPATCH7.05k
(BinXor, BinaryOperator);
68
1.07M
      
case BO_Or : 11.7k
DISPATCH11.7k
(BinOr, BinaryOperator);
69
1.07M
      
case BO_LAnd: 5.68k
DISPATCH5.68k
(BinLAnd, BinaryOperator);
70
1.07M
      
case BO_LOr : 2.44k
DISPATCH2.44k
(BinLOr, BinaryOperator);
71
1.07M
      
case BO_Assign: 257k
DISPATCH257k
(BinAssign, BinaryOperator);
72
1.07M
      
case BO_MulAssign: 882
DISPATCH882
(BinMulAssign, CompoundAssignOperator);
73
1.07M
      
case BO_DivAssign: 445
DISPATCH445
(BinDivAssign, CompoundAssignOperator);
74
1.07M
      
case BO_RemAssign: 150
DISPATCH150
(BinRemAssign, CompoundAssignOperator);
75
1.07M
      
case BO_AddAssign: 17.1k
DISPATCH17.1k
(BinAddAssign, CompoundAssignOperator);
76
1.07M
      
case BO_SubAssign: 2.82k
DISPATCH2.82k
(BinSubAssign, CompoundAssignOperator);
77
1.07M
      
case BO_ShlAssign: 999
DISPATCH999
(BinShlAssign, CompoundAssignOperator);
78
1.07M
      
case BO_ShrAssign: 888
DISPATCH888
(BinShrAssign, CompoundAssignOperator);
79
1.07M
      
case BO_AndAssign: 772
DISPATCH772
(BinAndAssign, CompoundAssignOperator);
80
1.07M
      
case BO_OrAssign: 2.57k
DISPATCH2.57k
(BinOrAssign, CompoundAssignOperator);
81
1.07M
      
case BO_XorAssign: 814
DISPATCH814
(BinXorAssign, CompoundAssignOperator);
82
1.07M
      
case BO_Comma: 14.3k
DISPATCH14.3k
(BinComma, BinaryOperator);
83
8.48M
      }
84
8.48M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
257k
      switch (UnOp->getOpcode()) {
86
257k
      
case UO_PostInc: 40.3k
DISPATCH40.3k
(UnaryPostInc, UnaryOperator);
87
257k
      
case UO_PostDec: 3.61k
DISPATCH3.61k
(UnaryPostDec, UnaryOperator);
88
257k
      
case UO_PreInc: 3.68k
DISPATCH3.68k
(UnaryPreInc, UnaryOperator);
89
257k
      
case UO_PreDec: 2.98k
DISPATCH2.98k
(UnaryPreDec, UnaryOperator);
90
257k
      
case UO_AddrOf: 60.0k
DISPATCH60.0k
(UnaryAddrOf, UnaryOperator);
91
257k
      
case UO_Deref: 25.1k
DISPATCH25.1k
(UnaryDeref, UnaryOperator);
92
257k
      
case UO_Plus: 156
DISPATCH156
(UnaryPlus, UnaryOperator);
93
257k
      
case UO_Minus: 31.7k
DISPATCH31.7k
(UnaryMinus, UnaryOperator);
94
257k
      
case UO_Not: 5.98k
DISPATCH5.98k
(UnaryNot, UnaryOperator);
95
257k
      
case UO_LNot: 73.8k
DISPATCH73.8k
(UnaryLNot, UnaryOperator);
96
257k
      
case UO_Real: 222
DISPATCH222
(UnaryReal, UnaryOperator);
97
257k
      
case UO_Imag: 209
DISPATCH209
(UnaryImag, UnaryOperator);
98
257k
      
case UO_Extension: 9.44k
DISPATCH9.44k
(UnaryExtension, UnaryOperator);
99
257k
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
100
8.22M
      }
101
8.22M
    }
102
8.22M
103
8.22M
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
8.22M
    switch (S->getStmtClass()) {
105
8.22M
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
8.22M
#define ABSTRACT_STMT(STMT)
107
8.22M
#define STMT(CLASS, PARENT)                              \
108
8.22M
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
8.22M
#include 
"clang/AST/StmtNodes.inc"0
110
8.22M
    }
111
8.22M
  }
CGOpenMPRuntimeNVPTX.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::CheckVarsEscapingDeclContext, void>::Visit(clang::Stmt const*)
Line
Count
Source
42
1.64k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
1.64k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
1.64k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
1.64k
    // below.
46
1.64k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
211
      switch (BinOp->getOpcode()) {
48
211
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
49
211
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
50
211
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
51
211
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
52
211
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
53
211
      
case BO_Add: 35
DISPATCH35
(BinAdd, BinaryOperator);
54
211
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
55
211
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
56
211
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
57
211
58
211
      
case BO_LT: 7
DISPATCH7
(BinLT, BinaryOperator);
59
211
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
60
211
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
61
211
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
62
211
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
63
211
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
64
211
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
65
211
66
211
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
67
211
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
68
211
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
69
211
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
70
211
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
71
211
      
case BO_Assign: 70
DISPATCH70
(BinAssign, BinaryOperator);
72
211
      
case BO_MulAssign: 3
DISPATCH3
(BinMulAssign, CompoundAssignOperator);
73
211
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
74
211
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
75
211
      
case BO_AddAssign: 93
DISPATCH93
(BinAddAssign, CompoundAssignOperator);
76
211
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
77
211
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
78
211
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
79
211
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
80
211
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
81
211
      
case BO_XorAssign: 3
DISPATCH3
(BinXorAssign, CompoundAssignOperator);
82
211
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
83
1.43k
      }
84
1.43k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
42
      switch (UnOp->getOpcode()) {
86
42
      
case UO_PostInc: 5
DISPATCH5
(UnaryPostInc, UnaryOperator);
87
42
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
88
42
      
case UO_PreInc: 15
DISPATCH15
(UnaryPreInc, UnaryOperator);
89
42
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
90
42
      
case UO_AddrOf: 16
DISPATCH16
(UnaryAddrOf, UnaryOperator);
91
42
      
case UO_Deref: 6
DISPATCH6
(UnaryDeref, UnaryOperator);
92
42
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
93
42
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
94
42
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
95
42
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
96
42
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
97
42
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
98
42
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
99
42
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
100
1.39k
      }
101
1.39k
    }
102
1.39k
103
1.39k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
1.39k
    switch (S->getStmtClass()) {
105
1.39k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
1.39k
#define ABSTRACT_STMT(STMT)
107
1.39k
#define STMT(CLASS, PARENT)                              \
108
1.39k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
1.39k
#include 
"clang/AST/StmtNodes.inc"0
110
1.39k
    }
111
1.39k
  }
CodeGenModule.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::FunctionIsDirectlyRecursive, bool>::Visit(clang::Stmt const*)
Line
Count
Source
42
4.53k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
4.53k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
4.53k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
4.53k
    // below.
46
4.53k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
455
      switch (BinOp->getOpcode()) {
48
455
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
49
455
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
50
455
      
case BO_Mul: 4
DISPATCH4
(BinMul, BinaryOperator);
51
455
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
52
455
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
53
455
      
case BO_Add: 5
DISPATCH5
(BinAdd, BinaryOperator);
54
455
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
55
455
      
case BO_Shl: 50
DISPATCH50
(BinShl, BinaryOperator);
56
455
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
57
455
58
455
      
case BO_LT: 53
DISPATCH53
(BinLT, BinaryOperator);
59
455
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
60
455
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
61
455
      
case BO_GE: 50
DISPATCH50
(BinGE, BinaryOperator);
62
455
      
case BO_EQ: 63
DISPATCH63
(BinEQ, BinaryOperator);
63
455
      
case BO_NE: 6
DISPATCH6
(BinNE, BinaryOperator);
64
455
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
65
455
66
455
      
case BO_And: 168
DISPATCH168
(BinAnd, BinaryOperator);
67
455
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
68
455
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
69
455
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
70
455
      
case BO_LOr : 50
DISPATCH50
(BinLOr, BinaryOperator);
71
455
      
case BO_Assign: 6
DISPATCH6
(BinAssign, BinaryOperator);
72
455
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
73
455
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
74
455
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
75
455
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
76
455
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
77
455
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
78
455
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
79
455
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
80
455
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
81
455
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
82
455
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
83
4.08k
      }
84
4.08k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
396
      switch (UnOp->getOpcode()) {
86
396
      
case UO_PostInc: 0
DISPATCH0
(UnaryPostInc, UnaryOperator);
87
396
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
88
396
      
case UO_PreInc: 3
DISPATCH3
(UnaryPreInc, UnaryOperator);
89
396
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
90
396
      
case UO_AddrOf: 0
DISPATCH0
(UnaryAddrOf, UnaryOperator);
91
396
      
case UO_Deref: 1
DISPATCH1
(UnaryDeref, UnaryOperator);
92
396
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
93
396
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
94
396
      
case UO_Not: 60
DISPATCH60
(UnaryNot, UnaryOperator);
95
396
      
case UO_LNot: 332
DISPATCH332
(UnaryLNot, UnaryOperator);
96
396
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
97
396
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
98
396
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
99
396
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
100
3.68k
      }
101
3.68k
    }
102
3.68k
103
3.68k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
3.68k
    switch (S->getStmtClass()) {
105
3.68k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
3.68k
#define ABSTRACT_STMT(STMT)
107
3.68k
#define STMT(CLASS, PARENT)                              \
108
3.68k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
3.68k
#include 
"clang/AST/StmtNodes.inc"0
110
3.68k
    }
111
3.68k
  }
CodeGenPGO.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::ComputeRegionCounts, void>::Visit(clang::Stmt const*)
Line
Count
Source
42
3.30k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
3.30k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
3.30k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
3.30k
    // below.
46
3.30k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
310
      switch (BinOp->getOpcode()) {
48
310
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
49
310
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
50
310
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
51
310
      
case BO_Div: 4
DISPATCH4
(BinDiv, BinaryOperator);
52
310
      
case BO_Rem: 33
DISPATCH33
(BinRem, BinaryOperator);
53
310
      
case BO_Add: 16
DISPATCH16
(BinAdd, BinaryOperator);
54
310
      
case BO_Sub: 10
DISPATCH10
(BinSub, BinaryOperator);
55
310
      
case BO_Shl: 3
DISPATCH3
(BinShl, BinaryOperator);
56
310
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
57
310
58
310
      
case BO_LT: 83
DISPATCH83
(BinLT, BinaryOperator);
59
310
      
case BO_GT: 22
DISPATCH22
(BinGT, BinaryOperator);
60
310
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
61
310
      
case BO_GE: 1
DISPATCH1
(BinGE, BinaryOperator);
62
310
      
case BO_EQ: 5
DISPATCH5
(BinEQ, BinaryOperator);
63
310
      
case BO_NE: 9
DISPATCH9
(BinNE, BinaryOperator);
64
310
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
65
310
66
310
      
case BO_And: 2
DISPATCH2
(BinAnd, BinaryOperator);
67
310
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
68
310
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
69
310
      
case BO_LAnd: 19
DISPATCH19
(BinLAnd, BinaryOperator);
70
310
      
case BO_LOr : 18
DISPATCH18
(BinLOr, BinaryOperator);
71
310
      
case BO_Assign: 76
DISPATCH76
(BinAssign, BinaryOperator);
72
310
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
73
310
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
74
310
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
75
310
      
case BO_AddAssign: 9
DISPATCH9
(BinAddAssign, CompoundAssignOperator);
76
310
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
77
310
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
78
310
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
79
310
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
80
310
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
81
310
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
82
310
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
83
2.99k
      }
84
2.99k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
142
      switch (UnOp->getOpcode()) {
86
142
      
case UO_PostInc: 27
DISPATCH27
(UnaryPostInc, UnaryOperator);
87
142
      
case UO_PostDec: 9
DISPATCH9
(UnaryPostDec, UnaryOperator);
88
142
      
case UO_PreInc: 82
DISPATCH82
(UnaryPreInc, UnaryOperator);
89
142
      
case UO_PreDec: 8
DISPATCH8
(UnaryPreDec, UnaryOperator);
90
142
      
case UO_AddrOf: 0
DISPATCH0
(UnaryAddrOf, UnaryOperator);
91
142
      
case UO_Deref: 9
DISPATCH9
(UnaryDeref, UnaryOperator);
92
142
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
93
142
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
94
142
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
95
142
      
case UO_LNot: 7
DISPATCH7
(UnaryLNot, UnaryOperator);
96
142
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
97
142
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
98
142
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
99
142
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
100
2.85k
      }
101
2.85k
    }
102
2.85k
103
2.85k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
2.85k
    switch (S->getStmtClass()) {
105
2.85k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
2.85k
#define ABSTRACT_STMT(STMT)
107
2.85k
#define STMT(CLASS, PARENT)                              \
108
2.85k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
2.85k
#include 
"clang/AST/StmtNodes.inc"0
110
2.85k
    }
111
2.85k
  }
CoverageMappingGen.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::CounterCoverageMappingBuilder, void>::Visit(clang::Stmt const*)
Line
Count
Source
42
2.60k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
2.60k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
2.60k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
2.60k
    // below.
46
2.60k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
226
      switch (BinOp->getOpcode()) {
48
226
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
49
226
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
50
226
      
case BO_Mul: 3
DISPATCH3
(BinMul, BinaryOperator);
51
226
      
case BO_Div: 1
DISPATCH1
(BinDiv, BinaryOperator);
52
226
      
case BO_Rem: 3
DISPATCH3
(BinRem, BinaryOperator);
53
226
      
case BO_Add: 12
DISPATCH12
(BinAdd, BinaryOperator);
54
226
      
case BO_Sub: 2
DISPATCH2
(BinSub, BinaryOperator);
55
226
      
case BO_Shl: 1
DISPATCH1
(BinShl, BinaryOperator);
56
226
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
57
226
58
226
      
case BO_LT: 43
DISPATCH43
(BinLT, BinaryOperator);
59
226
      
case BO_GT: 4
DISPATCH4
(BinGT, BinaryOperator);
60
226
      
case BO_LE: 1
DISPATCH1
(BinLE, BinaryOperator);
61
226
      
case BO_GE: 2
DISPATCH2
(BinGE, BinaryOperator);
62
226
      
case BO_EQ: 39
DISPATCH39
(BinEQ, BinaryOperator);
63
226
      
case BO_NE: 3
DISPATCH3
(BinNE, BinaryOperator);
64
226
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
65
226
66
226
      
case BO_And: 2
DISPATCH2
(BinAnd, BinaryOperator);
67
226
      
case BO_Xor: 1
DISPATCH1
(BinXor, BinaryOperator);
68
226
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
69
226
      
case BO_LAnd: 3
DISPATCH3
(BinLAnd, BinaryOperator);
70
226
      
case BO_LOr : 5
DISPATCH5
(BinLOr, BinaryOperator);
71
226
      
case BO_Assign: 98
DISPATCH98
(BinAssign, BinaryOperator);
72
226
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
73
226
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
74
226
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
75
226
      
case BO_AddAssign: 1
DISPATCH1
(BinAddAssign, CompoundAssignOperator);
76
226
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
77
226
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
78
226
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
79
226
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
80
226
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
81
226
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
82
226
      
case BO_Comma: 2
DISPATCH2
(BinComma, BinaryOperator);
83
2.37k
      }
84
2.37k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
59
      switch (UnOp->getOpcode()) {
86
59
      
case UO_PostInc: 3
DISPATCH3
(UnaryPostInc, UnaryOperator);
87
59
      
case UO_PostDec: 1
DISPATCH1
(UnaryPostDec, UnaryOperator);
88
59
      
case UO_PreInc: 40
DISPATCH40
(UnaryPreInc, UnaryOperator);
89
59
      
case UO_PreDec: 2
DISPATCH2
(UnaryPreDec, UnaryOperator);
90
59
      
case UO_AddrOf: 0
DISPATCH0
(UnaryAddrOf, UnaryOperator);
91
59
      
case UO_Deref: 2
DISPATCH2
(UnaryDeref, UnaryOperator);
92
59
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
93
59
      
case UO_Minus: 1
DISPATCH1
(UnaryMinus, UnaryOperator);
94
59
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
95
59
      
case UO_LNot: 10
DISPATCH10
(UnaryLNot, UnaryOperator);
96
59
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
97
59
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
98
59
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
99
59
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
100
2.31k
      }
101
2.31k
    }
102
2.31k
103
2.31k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
2.31k
    switch (S->getStmtClass()) {
105
2.31k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
2.31k
#define ABSTRACT_STMT(STMT)
107
2.31k
#define STMT(CLASS, PARENT)                              \
108
2.31k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
2.31k
#include 
"clang/AST/StmtNodes.inc"0
110
2.31k
    }
111
2.31k
  }
clang::StmtVisitorBase<std::__1::add_pointer, clang::ASTStmtReader, void>::Visit(clang::Stmt*)
Line
Count
Source
42
560k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
560k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
560k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
560k
    // below.
46
560k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
108k
      switch (BinOp->getOpcode()) {
48
108k
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
49
108k
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
50
108k
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
51
108k
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
52
108k
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
53
108k
      
case BO_Add: 0
DISPATCH0
(BinAdd, BinaryOperator);
54
108k
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
55
108k
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
56
108k
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
57
108k
58
108k
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
59
108k
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
60
108k
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
61
108k
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
62
108k
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
63
108k
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
64
108k
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
65
108k
66
108k
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
67
108k
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
68
108k
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
69
108k
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
70
108k
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
71
108k
      
case BO_Assign: 0
DISPATCH0
(BinAssign, BinaryOperator);
72
108k
      
case BO_MulAssign: 4.24k
DISPATCH4.24k
(BinMulAssign, CompoundAssignOperator);
73
108k
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
74
108k
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
75
108k
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
76
108k
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
77
108k
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
78
108k
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
79
108k
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
80
108k
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
81
108k
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
82
108k
      
case BO_Comma: 104k
DISPATCH104k
(BinComma, BinaryOperator);
83
451k
      }
84
451k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
9.96k
      switch (UnOp->getOpcode()) {
86
9.96k
      
case UO_PostInc: 0
DISPATCH0
(UnaryPostInc, UnaryOperator);
87
9.96k
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
88
9.96k
      
case UO_PreInc: 0
DISPATCH0
(UnaryPreInc, UnaryOperator);
89
9.96k
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
90
9.96k
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
91
9.96k
      
case UO_Deref: 0
DISPATCH0
(UnaryDeref, UnaryOperator);
92
9.96k
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
93
9.96k
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
94
9.96k
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
95
9.96k
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
96
9.96k
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
97
9.96k
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
98
9.96k
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
99
9.96k
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
100
441k
      }
101
441k
    }
102
441k
103
441k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
441k
    switch (S->getStmtClass()) {
105
441k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
441k
#define ABSTRACT_STMT(STMT)
107
441k
#define STMT(CLASS, PARENT)                              \
108
441k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
441k
#include 
"clang/AST/StmtNodes.inc"1
110
441k
    }
111
441k
  }
clang::StmtVisitorBase<std::__1::add_pointer, clang::ASTStmtWriter, void>::Visit(clang::Stmt*)
Line
Count
Source
42
921k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
921k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
921k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
921k
    // below.
46
921k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
117k
      switch (BinOp->getOpcode()) {
48
117k
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
49
117k
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
50
117k
      
case BO_Mul: 6.94k
DISPATCH6.94k
(BinMul, BinaryOperator);
51
117k
      
case BO_Div: 6.12k
DISPATCH6.12k
(BinDiv, BinaryOperator);
52
117k
      
case BO_Rem: 21
DISPATCH21
(BinRem, BinaryOperator);
53
117k
      
case BO_Add: 26.5k
DISPATCH26.5k
(BinAdd, BinaryOperator);
54
117k
      
case BO_Sub: 17.0k
DISPATCH17.0k
(BinSub, BinaryOperator);
55
117k
      
case BO_Shl: 27
DISPATCH27
(BinShl, BinaryOperator);
56
117k
      
case BO_Shr: 56
DISPATCH56
(BinShr, BinaryOperator);
57
117k
58
117k
      
case BO_LT: 8.28k
DISPATCH8.28k
(BinLT, BinaryOperator);
59
117k
      
case BO_GT: 4.96k
DISPATCH4.96k
(BinGT, BinaryOperator);
60
117k
      
case BO_LE: 4.26k
DISPATCH4.26k
(BinLE, BinaryOperator);
61
117k
      
case BO_GE: 208
DISPATCH208
(BinGE, BinaryOperator);
62
117k
      
case BO_EQ: 143
DISPATCH143
(BinEQ, BinaryOperator);
63
117k
      
case BO_NE: 34
DISPATCH34
(BinNE, BinaryOperator);
64
117k
      
case BO_Cmp: 2
DISPATCH2
(BinCmp, BinaryOperator);
65
117k
66
117k
      
case BO_And: 378
DISPATCH378
(BinAnd, BinaryOperator);
67
117k
      
case BO_Xor: 132
DISPATCH132
(BinXor, BinaryOperator);
68
117k
      
case BO_Or : 303
DISPATCH303
(BinOr, BinaryOperator);
69
117k
      
case BO_LAnd: 213
DISPATCH213
(BinLAnd, BinaryOperator);
70
117k
      
case BO_LOr : 10
DISPATCH10
(BinLOr, BinaryOperator);
71
117k
      
case BO_Assign: 37.2k
DISPATCH37.2k
(BinAssign, BinaryOperator);
72
117k
      
case BO_MulAssign: 58
DISPATCH58
(BinMulAssign, CompoundAssignOperator);
73
117k
      
case BO_DivAssign: 54
DISPATCH54
(BinDivAssign, CompoundAssignOperator);
74
117k
      
case BO_RemAssign: 4
DISPATCH4
(BinRemAssign, CompoundAssignOperator);
75
117k
      
case BO_AddAssign: 4.04k
DISPATCH4.04k
(BinAddAssign, CompoundAssignOperator);
76
117k
      
case BO_SubAssign: 116
DISPATCH116
(BinSubAssign, CompoundAssignOperator);
77
117k
      
case BO_ShlAssign: 4
DISPATCH4
(BinShlAssign, CompoundAssignOperator);
78
117k
      
case BO_ShrAssign: 4
DISPATCH4
(BinShrAssign, CompoundAssignOperator);
79
117k
      
case BO_AndAssign: 4
DISPATCH4
(BinAndAssign, CompoundAssignOperator);
80
117k
      
case BO_OrAssign: 8
DISPATCH8
(BinOrAssign, CompoundAssignOperator);
81
117k
      
case BO_XorAssign: 8
DISPATCH8
(BinXorAssign, CompoundAssignOperator);
82
117k
      
case BO_Comma: 74
DISPATCH74
(BinComma, BinaryOperator);
83
804k
      }
84
804k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
13.1k
      switch (UnOp->getOpcode()) {
86
13.1k
      
case UO_PostInc: 1.83k
DISPATCH1.83k
(UnaryPostInc, UnaryOperator);
87
13.1k
      
case UO_PostDec: 40
DISPATCH40
(UnaryPostDec, UnaryOperator);
88
13.1k
      
case UO_PreInc: 4.26k
DISPATCH4.26k
(UnaryPreInc, UnaryOperator);
89
13.1k
      
case UO_PreDec: 50
DISPATCH50
(UnaryPreDec, UnaryOperator);
90
13.1k
      
case UO_AddrOf: 517
DISPATCH517
(UnaryAddrOf, UnaryOperator);
91
13.1k
      
case UO_Deref: 3.56k
DISPATCH3.56k
(UnaryDeref, UnaryOperator);
92
13.1k
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
93
13.1k
      
case UO_Minus: 2.36k
DISPATCH2.36k
(UnaryMinus, UnaryOperator);
94
13.1k
      
case UO_Not: 218
DISPATCH218
(UnaryNot, UnaryOperator);
95
13.1k
      
case UO_LNot: 20
DISPATCH20
(UnaryLNot, UnaryOperator);
96
13.1k
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
97
13.1k
      
case UO_Imag: 2
DISPATCH2
(UnaryImag, UnaryOperator);
98
13.1k
      
case UO_Extension: 277
DISPATCH277
(UnaryExtension, UnaryOperator);
99
13.1k
      
case UO_Coawait: 5
DISPATCH5
(UnaryCoawait, UnaryOperator);
100
791k
      }
101
791k
    }
102
791k
103
791k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
791k
    switch (S->getStmtClass()) {
105
791k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
791k
#define ABSTRACT_STMT(STMT)
107
791k
#define STMT(CLASS, PARENT)                              \
108
791k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
791k
#include 
"clang/AST/StmtNodes.inc"35
110
791k
    }
111
791k
  }
TransEmptyStatementsAndDealloc.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::EmptyChecker, bool>::Visit(clang::Stmt*)
Line
Count
Source
42
1.07k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
1.07k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
1.07k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
1.07k
    // below.
46
1.07k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
67
      switch (BinOp->getOpcode()) {
48
67
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
49
67
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
50
67
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
51
67
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
52
67
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
53
67
      
case BO_Add: 0
DISPATCH0
(BinAdd, BinaryOperator);
54
67
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
55
67
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
56
67
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
57
67
58
67
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
59
67
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
60
67
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
61
67
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
62
67
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
63
67
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
64
67
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
65
67
66
67
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
67
67
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
68
67
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
69
67
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
70
67
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
71
67
      
case BO_Assign: 64
DISPATCH64
(BinAssign, BinaryOperator);
72
67
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
73
67
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
74
67
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
75
67
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
76
67
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
77
67
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
78
67
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
79
67
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
80
67
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
81
67
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
82
67
      
case BO_Comma: 3
DISPATCH3
(BinComma, BinaryOperator);
83
1.01k
      }
84
1.01k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
12
      switch (UnOp->getOpcode()) {
86
12
      
case UO_PostInc: 2
DISPATCH2
(UnaryPostInc, UnaryOperator);
87
12
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
88
12
      
case UO_PreInc: 10
DISPATCH10
(UnaryPreInc, UnaryOperator);
89
12
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
90
12
      
case UO_AddrOf: 0
DISPATCH0
(UnaryAddrOf, UnaryOperator);
91
12
      
case UO_Deref: 0
DISPATCH0
(UnaryDeref, UnaryOperator);
92
12
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
93
12
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
94
12
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
95
12
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
96
12
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
97
12
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
98
12
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
99
12
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
100
1.00k
      }
101
1.00k
    }
102
1.00k
103
1.00k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
1.00k
    switch (S->getStmtClass()) {
105
1.00k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
1.00k
#define ABSTRACT_STMT(STMT)
107
1.00k
#define STMT(CLASS, PARENT)                              \
108
1.00k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
1.00k
#include 
"clang/AST/StmtNodes.inc"0
110
1.00k
    }
111
1.00k
  }
CStringSyntaxChecker.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::WalkAST, void>::Visit(clang::Stmt*)
Line
Count
Source
42
38.3k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
38.3k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
38.3k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
38.3k
    // below.
46
38.3k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
2.07k
      switch (BinOp->getOpcode()) {
48
2.07k
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
49
2.07k
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
50
2.07k
      
case BO_Mul: 116
DISPATCH116
(BinMul, BinaryOperator);
51
2.07k
      
case BO_Div: 26
DISPATCH26
(BinDiv, BinaryOperator);
52
2.07k
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
53
2.07k
      
case BO_Add: 223
DISPATCH223
(BinAdd, BinaryOperator);
54
2.07k
      
case BO_Sub: 50
DISPATCH50
(BinSub, BinaryOperator);
55
2.07k
      
case BO_Shl: 2
DISPATCH2
(BinShl, BinaryOperator);
56
2.07k
      
case BO_Shr: 2
DISPATCH2
(BinShr, BinaryOperator);
57
2.07k
58
2.07k
      
case BO_LT: 169
DISPATCH169
(BinLT, BinaryOperator);
59
2.07k
      
case BO_GT: 102
DISPATCH102
(BinGT, BinaryOperator);
60
2.07k
      
case BO_LE: 43
DISPATCH43
(BinLE, BinaryOperator);
61
2.07k
      
case BO_GE: 103
DISPATCH103
(BinGE, BinaryOperator);
62
2.07k
      
case BO_EQ: 956
DISPATCH956
(BinEQ, BinaryOperator);
63
2.07k
      
case BO_NE: 86
DISPATCH86
(BinNE, BinaryOperator);
64
2.07k
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
65
2.07k
66
2.07k
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
67
2.07k
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
68
2.07k
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
69
2.07k
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
70
2.07k
      
case BO_LOr : 1
DISPATCH1
(BinLOr, BinaryOperator);
71
2.07k
      
case BO_Assign: 173
DISPATCH173
(BinAssign, BinaryOperator);
72
2.07k
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
73
2.07k
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
74
2.07k
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
75
2.07k
      
case BO_AddAssign: 13
DISPATCH13
(BinAddAssign, CompoundAssignOperator);
76
2.07k
      
case BO_SubAssign: 5
DISPATCH5
(BinSubAssign, CompoundAssignOperator);
77
2.07k
      
case BO_ShlAssign: 4
DISPATCH4
(BinShlAssign, CompoundAssignOperator);
78
2.07k
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
79
2.07k
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
80
2.07k
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
81
2.07k
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
82
2.07k
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
83
36.2k
      }
84
36.2k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
536
      switch (UnOp->getOpcode()) {
86
536
      
case UO_PostInc: 38
DISPATCH38
(UnaryPostInc, UnaryOperator);
87
536
      
case UO_PostDec: 6
DISPATCH6
(UnaryPostDec, UnaryOperator);
88
536
      
case UO_PreInc: 0
DISPATCH0
(UnaryPreInc, UnaryOperator);
89
536
      
case UO_PreDec: 1
DISPATCH1
(UnaryPreDec, UnaryOperator);
90
536
      
case UO_AddrOf: 203
DISPATCH203
(UnaryAddrOf, UnaryOperator);
91
536
      
case UO_Deref: 43
DISPATCH43
(UnaryDeref, UnaryOperator);
92
536
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
93
536
      
case UO_Minus: 233
DISPATCH233
(UnaryMinus, UnaryOperator);
94
536
      
case UO_Not: 4
DISPATCH4
(UnaryNot, UnaryOperator);
95
536
      
case UO_LNot: 8
DISPATCH8
(UnaryLNot, UnaryOperator);
96
536
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
97
536
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
98
536
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
99
536
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
100
35.6k
      }
101
35.6k
    }
102
35.6k
103
35.6k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
35.6k
    switch (S->getStmtClass()) {
105
35.6k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
35.6k
#define ABSTRACT_STMT(STMT)
107
35.6k
#define STMT(CLASS, PARENT)                              \
108
35.6k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
35.6k
#include 
"clang/AST/StmtNodes.inc"0
110
35.6k
    }
111
35.6k
  }
CheckSecuritySyntaxOnly.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::WalkAST, void>::Visit(clang::Stmt*)
Line
Count
Source
42
5.89k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
5.89k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
5.89k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
5.89k
    // below.
46
5.89k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
140
      switch (BinOp->getOpcode()) {
48
140
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
49
140
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
50
140
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
51
140
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
52
140
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
53
140
      
case BO_Add: 8
DISPATCH8
(BinAdd, BinaryOperator);
54
140
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
55
140
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
56
140
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
57
140
58
140
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
59
140
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
60
140
      
case BO_LE: 56
DISPATCH56
(BinLE, BinaryOperator);
61
140
      
case BO_GE: 8
DISPATCH8
(BinGE, BinaryOperator);
62
140
      
case BO_EQ: 6
DISPATCH6
(BinEQ, BinaryOperator);
63
140
      
case BO_NE: 10
DISPATCH10
(BinNE, BinaryOperator);
64
140
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
65
140
66
140
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
67
140
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
68
140
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
69
140
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
70
140
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
71
140
      
case BO_Assign: 28
DISPATCH28
(BinAssign, BinaryOperator);
72
140
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
73
140
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
74
140
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
75
140
      
case BO_AddAssign: 16
DISPATCH16
(BinAddAssign, CompoundAssignOperator);
76
140
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
77
140
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
78
140
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
79
140
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
80
140
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
81
140
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
82
140
      
case BO_Comma: 8
DISPATCH8
(BinComma, BinaryOperator);
83
5.75k
      }
84
5.75k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
105
      switch (UnOp->getOpcode()) {
86
105
      
case UO_PostInc: 40
DISPATCH40
(UnaryPostInc, UnaryOperator);
87
105
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
88
105
      
case UO_PreInc: 8
DISPATCH8
(UnaryPreInc, UnaryOperator);
89
105
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
90
105
      
case UO_AddrOf: 33
DISPATCH33
(UnaryAddrOf, UnaryOperator);
91
105
      
case UO_Deref: 4
DISPATCH4
(UnaryDeref, UnaryOperator);
92
105
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
93
105
      
case UO_Minus: 20
DISPATCH20
(UnaryMinus, UnaryOperator);
94
105
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
95
105
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
96
105
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
97
105
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
98
105
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
99
105
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
100
5.65k
      }
101
5.65k
    }
102
5.65k
103
5.65k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
5.65k
    switch (S->getStmtClass()) {
105
5.65k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
5.65k
#define ABSTRACT_STMT(STMT)
107
5.65k
#define STMT(CLASS, PARENT)                              \
108
5.65k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
5.65k
#include 
"clang/AST/StmtNodes.inc"0
110
5.65k
    }
111
5.65k
  }
CheckSizeofPointer.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::WalkAST, void>::Visit(clang::Stmt*)
Line
Count
Source
42
21.2k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
21.2k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
21.2k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
21.2k
    // below.
46
21.2k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
1.32k
      switch (BinOp->getOpcode()) {
48
1.32k
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
49
1.32k
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
50
1.32k
      
case BO_Mul: 17
DISPATCH17
(BinMul, BinaryOperator);
51
1.32k
      
case BO_Div: 15
DISPATCH15
(BinDiv, BinaryOperator);
52
1.32k
      
case BO_Rem: 6
DISPATCH6
(BinRem, BinaryOperator);
53
1.32k
      
case BO_Add: 44
DISPATCH44
(BinAdd, BinaryOperator);
54
1.32k
      
case BO_Sub: 20
DISPATCH20
(BinSub, BinaryOperator);
55
1.32k
      
case BO_Shl: 14
DISPATCH14
(BinShl, BinaryOperator);
56
1.32k
      
case BO_Shr: 2
DISPATCH2
(BinShr, BinaryOperator);
57
1.32k
58
1.32k
      
case BO_LT: 47
DISPATCH47
(BinLT, BinaryOperator);
59
1.32k
      
case BO_GT: 14
DISPATCH14
(BinGT, BinaryOperator);
60
1.32k
      
case BO_LE: 2
DISPATCH2
(BinLE, BinaryOperator);
61
1.32k
      
case BO_GE: 3
DISPATCH3
(BinGE, BinaryOperator);
62
1.32k
      
case BO_EQ: 406
DISPATCH406
(BinEQ, BinaryOperator);
63
1.32k
      
case BO_NE: 121
DISPATCH121
(BinNE, BinaryOperator);
64
1.32k
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
65
1.32k
66
1.32k
      
case BO_And: 10
DISPATCH10
(BinAnd, BinaryOperator);
67
1.32k
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
68
1.32k
      
case BO_Or : 5
DISPATCH5
(BinOr, BinaryOperator);
69
1.32k
      
case BO_LAnd: 31
DISPATCH31
(BinLAnd, BinaryOperator);
70
1.32k
      
case BO_LOr : 8
DISPATCH8
(BinLOr, BinaryOperator);
71
1.32k
      
case BO_Assign: 502
DISPATCH502
(BinAssign, BinaryOperator);
72
1.32k
      
case BO_MulAssign: 8
DISPATCH8
(BinMulAssign, CompoundAssignOperator);
73
1.32k
      
case BO_DivAssign: 12
DISPATCH12
(BinDivAssign, CompoundAssignOperator);
74
1.32k
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
75
1.32k
      
case BO_AddAssign: 15
DISPATCH15
(BinAddAssign, CompoundAssignOperator);
76
1.32k
      
case BO_SubAssign: 2
DISPATCH2
(BinSubAssign, CompoundAssignOperator);
77
1.32k
      
case BO_ShlAssign: 2
DISPATCH2
(BinShlAssign, CompoundAssignOperator);
78
1.32k
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
79
1.32k
      
case BO_AndAssign: 6
DISPATCH6
(BinAndAssign, CompoundAssignOperator);
80
1.32k
      
case BO_OrAssign: 3
DISPATCH3
(BinOrAssign, CompoundAssignOperator);
81
1.32k
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
82
1.32k
      
case BO_Comma: 7
DISPATCH7
(BinComma, BinaryOperator);
83
19.9k
      }
84
19.9k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
840
      switch (UnOp->getOpcode()) {
86
840
      
case UO_PostInc: 44
DISPATCH44
(UnaryPostInc, UnaryOperator);
87
840
      
case UO_PostDec: 7
DISPATCH7
(UnaryPostDec, UnaryOperator);
88
840
      
case UO_PreInc: 36
DISPATCH36
(UnaryPreInc, UnaryOperator);
89
840
      
case UO_PreDec: 4
DISPATCH4
(UnaryPreDec, UnaryOperator);
90
840
      
case UO_AddrOf: 228
DISPATCH228
(UnaryAddrOf, UnaryOperator);
91
840
      
case UO_Deref: 334
DISPATCH334
(UnaryDeref, UnaryOperator);
92
840
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
93
840
      
case UO_Minus: 18
DISPATCH18
(UnaryMinus, UnaryOperator);
94
840
      
case UO_Not: 10
DISPATCH10
(UnaryNot, UnaryOperator);
95
840
      
case UO_LNot: 145
DISPATCH145
(UnaryLNot, UnaryOperator);
96
840
      
case UO_Real: 6
DISPATCH6
(UnaryReal, UnaryOperator);
97
840
      
case UO_Imag: 4
DISPATCH4
(UnaryImag, UnaryOperator);
98
840
      
case UO_Extension: 4
DISPATCH4
(UnaryExtension, UnaryOperator);
99
840
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
100
19.0k
      }
101
19.0k
    }
102
19.0k
103
19.0k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
19.0k
    switch (S->getStmtClass()) {
105
19.0k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
19.0k
#define ABSTRACT_STMT(STMT)
107
19.0k
#define STMT(CLASS, PARENT)                              \
108
19.0k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
19.0k
#include 
"clang/AST/StmtNodes.inc"0
110
19.0k
    }
111
19.0k
  }
DirectIvarAssignment.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::DirectIvarAssignment::MethodCrawler, void>::Visit(clang::Stmt const*)
Line
Count
Source
42
19
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
19
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
19
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
19
    // below.
46
19
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
14
      switch (BinOp->getOpcode()) {
48
14
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
49
14
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
50
14
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
51
14
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
52
14
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
53
14
      
case BO_Add: 0
DISPATCH0
(BinAdd, BinaryOperator);
54
14
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
55
14
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
56
14
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
57
14
58
14
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
59
14
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
60
14
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
61
14
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
62
14
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
63
14
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
64
14
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
65
14
66
14
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
67
14
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
68
14
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
69
14
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
70
14
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
71
14
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
72
14
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
73
14
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
74
14
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
75
14
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
76
14
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
77
14
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
78
14
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
79
14
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
80
14
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
81
14
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
82
14
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
83
5
      }
84
5
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
0
      switch (UnOp->getOpcode()) {
86
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
87
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
88
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
89
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
90
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
91
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
92
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
93
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
94
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
95
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
96
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
97
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
98
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
99
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
100
5
      }
101
5
    }
102
5
103
5
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
5
    switch (S->getStmtClass()) {
105
5
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
5
#define ABSTRACT_STMT(STMT)
107
5
#define STMT(CLASS, PARENT)                              \
108
5
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
5
#include 
"clang/AST/StmtNodes.inc"0
110
5
    }
111
5
  }
IvarInvalidationChecker.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::IvarInvalidationCheckerImpl::MethodCrawler, void>::Visit(clang::Stmt const*)
Line
Count
Source
42
408
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
408
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
408
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
408
    // below.
46
408
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
19
      switch (BinOp->getOpcode()) {
48
19
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
49
19
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
50
19
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
51
19
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
52
19
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
53
19
      
case BO_Add: 0
DISPATCH0
(BinAdd, BinaryOperator);
54
19
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
55
19
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
56
19
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
57
19
58
19
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
59
19
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
60
19
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
61
19
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
62
19
      
case BO_EQ: 3
DISPATCH3
(BinEQ, BinaryOperator);
63
19
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
64
19
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
65
19
66
19
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
67
19
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
68
19
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
69
19
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
70
19
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
71
19
      
case BO_Assign: 16
DISPATCH16
(BinAssign, BinaryOperator);
72
19
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
73
19
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
74
19
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
75
19
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
76
19
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
77
19
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
78
19
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
79
19
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
80
19
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
81
19
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
82
19
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
83
389
      }
84
389
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
1
      switch (UnOp->getOpcode()) {
86
1
      
case UO_PostInc: 0
DISPATCH0
(UnaryPostInc, UnaryOperator);
87
1
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
88
1
      
case UO_PreInc: 0
DISPATCH0
(UnaryPreInc, UnaryOperator);
89
1
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
90
1
      
case UO_AddrOf: 0
DISPATCH0
(UnaryAddrOf, UnaryOperator);
91
1
      
case UO_Deref: 0
DISPATCH0
(UnaryDeref, UnaryOperator);
92
1
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
93
1
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
94
1
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
95
1
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
96
1
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
97
1
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
98
1
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
99
1
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
100
388
      }
101
388
    }
102
388
103
388
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
388
    switch (S->getStmtClass()) {
105
388
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
388
#define ABSTRACT_STMT(STMT)
107
388
#define STMT(CLASS, PARENT)                              \
108
388
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
388
#include 
"clang/AST/StmtNodes.inc"0
110
388
    }
111
388
  }
LLVMConventionsChecker.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::StringRefCheckerVisitor, void>::Visit(clang::Stmt*)
Line
Count
Source
42
192
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
192
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
192
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
192
    // below.
46
192
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
22
      switch (BinOp->getOpcode()) {
48
22
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
49
22
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
50
22
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
51
22
      
case BO_Div: 3
DISPATCH3
(BinDiv, BinaryOperator);
52
22
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
53
22
      
case BO_Add: 0
DISPATCH0
(BinAdd, BinaryOperator);
54
22
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
55
22
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
56
22
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
57
22
58
22
      
case BO_LT: 3
DISPATCH3
(BinLT, BinaryOperator);
59
22
      
case BO_GT: 2
DISPATCH2
(BinGT, BinaryOperator);
60
22
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
61
22
      
case BO_GE: 1
DISPATCH1
(BinGE, BinaryOperator);
62
22
      
case BO_EQ: 3
DISPATCH3
(BinEQ, BinaryOperator);
63
22
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
64
22
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
65
22
66
22
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
67
22
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
68
22
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
69
22
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
70
22
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
71
22
      
case BO_Assign: 7
DISPATCH7
(BinAssign, BinaryOperator);
72
22
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
73
22
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
74
22
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
75
22
      
case BO_AddAssign: 1
DISPATCH1
(BinAddAssign, CompoundAssignOperator);
76
22
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
77
22
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
78
22
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
79
22
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
80
22
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
81
22
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
82
22
      
case BO_Comma: 2
DISPATCH2
(BinComma, BinaryOperator);
83
170
      }
84
170
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
9
      switch (UnOp->getOpcode()) {
86
9
      
case UO_PostInc: 0
DISPATCH0
(UnaryPostInc, UnaryOperator);
87
9
      
case UO_PostDec: 3
DISPATCH3
(UnaryPostDec, UnaryOperator);
88
9
      
case UO_PreInc: 4
DISPATCH4
(UnaryPreInc, UnaryOperator);
89
9
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
90
9
      
case UO_AddrOf: 0
DISPATCH0
(UnaryAddrOf, UnaryOperator);
91
9
      
case UO_Deref: 2
DISPATCH2
(UnaryDeref, UnaryOperator);
92
9
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
93
9
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
94
9
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
95
9
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
96
9
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
97
9
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
98
9
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
99
9
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
100
161
      }
101
161
    }
102
161
103
161
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
161
    switch (S->getStmtClass()) {
105
161
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
161
#define ABSTRACT_STMT(STMT)
107
161
#define STMT(CLASS, PARENT)                              \
108
161
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
161
#include 
"clang/AST/StmtNodes.inc"0
110
161
    }
111
161
  }
LocalizationChecker.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::EmptyLocalizationContextChecker::MethodCrawler, void>::Visit(clang::Stmt const*)
Line
Count
Source
42
171
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
171
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
171
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
171
    // below.
46
171
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
4
      switch (BinOp->getOpcode()) {
48
4
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
49
4
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
50
4
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
51
4
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
52
4
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
53
4
      
case BO_Add: 0
DISPATCH0
(BinAdd, BinaryOperator);
54
4
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
55
4
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
56
4
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
57
4
58
4
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
59
4
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
60
4
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
61
4
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
62
4
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
63
4
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
64
4
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
65
4
66
4
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
67
4
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
68
4
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
69
4
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
70
4
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
71
4
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
72
4
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
73
4
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
74
4
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
75
4
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
76
4
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
77
4
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
78
4
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
79
4
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
80
4
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
81
4
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
82
4
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
83
167
      }
84
167
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
0
      switch (UnOp->getOpcode()) {
86
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
87
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
88
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
89
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
90
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
91
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
92
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
93
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
94
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
95
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
96
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
97
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
98
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
99
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
100
167
      }
101
167
    }
102
167
103
167
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
167
    switch (S->getStmtClass()) {
105
167
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
167
#define ABSTRACT_STMT(STMT)
107
167
#define STMT(CLASS, PARENT)                              \
108
167
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
167
#include 
"clang/AST/StmtNodes.inc"0
110
167
    }
111
167
  }
MallocOverflowSecurityChecker.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::CheckOverflowOps, void>::Visit(clang::Stmt*)
Line
Count
Source
42
445
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
445
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
445
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
445
    // below.
46
445
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
52
      switch (BinOp->getOpcode()) {
48
52
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
49
52
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
50
52
      
case BO_Mul: 21
DISPATCH21
(BinMul, BinaryOperator);
51
52
      
case BO_Div: 4
DISPATCH4
(BinDiv, BinaryOperator);
52
52
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
53
52
      
case BO_Add: 5
DISPATCH5
(BinAdd, BinaryOperator);
54
52
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
55
52
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
56
52
      
case BO_Shr: 2
DISPATCH2
(BinShr, BinaryOperator);
57
52
58
52
      
case BO_LT: 2
DISPATCH2
(BinLT, BinaryOperator);
59
52
      
case BO_GT: 3
DISPATCH3
(BinGT, BinaryOperator);
60
52
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
61
52
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
62
52
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
63
52
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
64
52
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
65
52
66
52
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
67
52
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
68
52
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
69
52
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
70
52
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
71
52
      
case BO_Assign: 15
DISPATCH15
(BinAssign, BinaryOperator);
72
52
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
73
52
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
74
52
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
75
52
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
76
52
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
77
52
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
78
52
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
79
52
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
80
52
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
81
52
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
82
52
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
83
393
      }
84
393
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
3
      switch (UnOp->getOpcode()) {
86
3
      
case UO_PostInc: 2
DISPATCH2
(UnaryPostInc, UnaryOperator);
87
3
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
88
3
      
case UO_PreInc: 0
DISPATCH0
(UnaryPreInc, UnaryOperator);
89
3
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
90
3
      
case UO_AddrOf: 0
DISPATCH0
(UnaryAddrOf, UnaryOperator);
91
3
      
case UO_Deref: 1
DISPATCH1
(UnaryDeref, UnaryOperator);
92
3
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
93
3
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
94
3
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
95
3
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
96
3
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
97
3
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
98
3
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
99
3
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
100
390
      }
101
390
    }
102
390
103
390
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
390
    switch (S->getStmtClass()) {
105
390
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
390
#define ABSTRACT_STMT(STMT)
107
390
#define STMT(CLASS, PARENT)                              \
108
390
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
390
#include 
"clang/AST/StmtNodes.inc"0
110
390
    }
111
390
  }
MallocSizeofChecker.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::CastedAllocFinder, std::__1::pair<clang::TypeSourceInfo const*, clang::CallExpr const*> >::Visit(clang::Stmt const*)
Line
Count
Source
42
2.42k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
2.42k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
2.42k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
2.42k
    // below.
46
2.42k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
178
      switch (BinOp->getOpcode()) {
48
178
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
49
178
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
50
178
      
case BO_Mul: 19
DISPATCH19
(BinMul, BinaryOperator);
51
178
      
case BO_Div: 12
DISPATCH12
(BinDiv, BinaryOperator);
52
178
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
53
178
      
case BO_Add: 29
DISPATCH29
(BinAdd, BinaryOperator);
54
178
      
case BO_Sub: 4
DISPATCH4
(BinSub, BinaryOperator);
55
178
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
56
178
      
case BO_Shr: 2
DISPATCH2
(BinShr, BinaryOperator);
57
178
58
178
      
case BO_LT: 9
DISPATCH9
(BinLT, BinaryOperator);
59
178
      
case BO_GT: 1
DISPATCH1
(BinGT, BinaryOperator);
60
178
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
61
178
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
62
178
      
case BO_EQ: 11
DISPATCH11
(BinEQ, BinaryOperator);
63
178
      
case BO_NE: 1
DISPATCH1
(BinNE, BinaryOperator);
64
178
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
65
178
66
178
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
67
178
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
68
178
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
69
178
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
70
178
      
case BO_LOr : 1
DISPATCH1
(BinLOr, BinaryOperator);
71
178
      
case BO_Assign: 80
DISPATCH80
(BinAssign, BinaryOperator);
72
178
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
73
178
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
74
178
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
75
178
      
case BO_AddAssign: 4
DISPATCH4
(BinAddAssign, CompoundAssignOperator);
76
178
      
case BO_SubAssign: 5
DISPATCH5
(BinSubAssign, CompoundAssignOperator);
77
178
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
78
178
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
79
178
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
80
178
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
81
178
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
82
178
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
83
2.24k
      }
84
2.24k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
78
      switch (UnOp->getOpcode()) {
86
78
      
case UO_PostInc: 38
DISPATCH38
(UnaryPostInc, UnaryOperator);
87
78
      
case UO_PostDec: 6
DISPATCH6
(UnaryPostDec, UnaryOperator);
88
78
      
case UO_PreInc: 0
DISPATCH0
(UnaryPreInc, UnaryOperator);
89
78
      
case UO_PreDec: 1
DISPATCH1
(UnaryPreDec, UnaryOperator);
90
78
      
case UO_AddrOf: 4
DISPATCH4
(UnaryAddrOf, UnaryOperator);
91
78
      
case UO_Deref: 22
DISPATCH22
(UnaryDeref, UnaryOperator);
92
78
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
93
78
      
case UO_Minus: 5
DISPATCH5
(UnaryMinus, UnaryOperator);
94
78
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
95
78
      
case UO_LNot: 2
DISPATCH2
(UnaryLNot, UnaryOperator);
96
78
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
97
78
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
98
78
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
99
78
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
100
2.17k
      }
101
2.17k
    }
102
2.17k
103
2.17k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
2.17k
    switch (S->getStmtClass()) {
105
2.17k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
2.17k
#define ABSTRACT_STMT(STMT)
107
2.17k
#define STMT(CLASS, PARENT)                              \
108
2.17k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
2.17k
#include 
"clang/AST/StmtNodes.inc"0
110
2.17k
    }
111
2.17k
  }
MallocSizeofChecker.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::SizeofFinder, void>::Visit(clang::Stmt const*)
Line
Count
Source
42
109
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
109
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
109
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
109
    // below.
46
109
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
12
      switch (BinOp->getOpcode()) {
48
12
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
49
12
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
50
12
      
case BO_Mul: 10
DISPATCH10
(BinMul, BinaryOperator);
51
12
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
52
12
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
53
12
      
case BO_Add: 2
DISPATCH2
(BinAdd, BinaryOperator);
54
12
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
55
12
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
56
12
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
57
12
58
12
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
59
12
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
60
12
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
61
12
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
62
12
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
63
12
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
64
12
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
65
12
66
12
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
67
12
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
68
12
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
69
12
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
70
12
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
71
12
      
case BO_Assign: 0
DISPATCH0
(BinAssign, BinaryOperator);
72
12
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
73
12
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
74
12
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
75
12
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
76
12
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
77
12
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
78
12
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
79
12
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
80
12
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
81
12
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
82
12
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
83
97
      }
84
97
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
0
      switch (UnOp->getOpcode()) {
86
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
87
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
88
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
89
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
90
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
91
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
92
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
93
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
94
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
95
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
96
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
97
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
98
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
99
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
100
97
      }
101
97
    }
102
97
103
97
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
97
    switch (S->getStmtClass()) {
105
97
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
97
#define ABSTRACT_STMT(STMT)
107
97
#define STMT(CLASS, PARENT)                              \
108
97
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
97
#include 
"clang/AST/StmtNodes.inc"0
110
97
    }
111
97
  }
ObjCContainersASTChecker.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::WalkAST, void>::Visit(clang::Stmt*)
Line
Count
Source
42
2.68k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
2.68k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
2.68k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
2.68k
    // below.
46
2.68k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
90
      switch (BinOp->getOpcode()) {
48
90
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
49
90
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
50
90
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
51
90
      
case BO_Div: 19
DISPATCH19
(BinDiv, BinaryOperator);
52
90
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
53
90
      
case BO_Add: 8
DISPATCH8
(BinAdd, BinaryOperator);
54
90
      
case BO_Sub: 1
DISPATCH1
(BinSub, BinaryOperator);
55
90
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
56
90
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
57
90
58
90
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
59
90
      
case BO_GT: 1
DISPATCH1
(BinGT, BinaryOperator);
60
90
      
case BO_LE: 1
DISPATCH1
(BinLE, BinaryOperator);
61
90
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
62
90
      
case BO_EQ: 8
DISPATCH8
(BinEQ, BinaryOperator);
63
90
      
case BO_NE: 5
DISPATCH5
(BinNE, BinaryOperator);
64
90
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
65
90
66
90
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
67
90
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
68
90
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
69
90
      
case BO_LAnd: 1
DISPATCH1
(BinLAnd, BinaryOperator);
70
90
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
71
90
      
case BO_Assign: 45
DISPATCH45
(BinAssign, BinaryOperator);
72
90
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
73
90
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
74
90
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
75
90
      
case BO_AddAssign: 1
DISPATCH1
(BinAddAssign, CompoundAssignOperator);
76
90
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
77
90
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
78
90
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
79
90
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
80
90
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
81
90
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
82
90
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
83
2.59k
      }
84
2.59k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
67
      switch (UnOp->getOpcode()) {
86
67
      
case UO_PostInc: 0
DISPATCH0
(UnaryPostInc, UnaryOperator);
87
67
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
88
67
      
case UO_PreInc: 0
DISPATCH0
(UnaryPreInc, UnaryOperator);
89
67
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
90
67
      
case UO_AddrOf: 49
DISPATCH49
(UnaryAddrOf, UnaryOperator);
91
67
      
case UO_Deref: 15
DISPATCH15
(UnaryDeref, UnaryOperator);
92
67
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
93
67
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
94
67
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
95
67
      
case UO_LNot: 3
DISPATCH3
(UnaryLNot, UnaryOperator);
96
67
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
97
67
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
98
67
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
99
67
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
100
2.52k
      }
101
2.52k
    }
102
2.52k
103
2.52k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
2.52k
    switch (S->getStmtClass()) {
105
2.52k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
2.52k
#define ABSTRACT_STMT(STMT)
107
2.52k
#define STMT(CLASS, PARENT)                              \
108
2.52k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
2.52k
#include 
"clang/AST/StmtNodes.inc"0
110
2.52k
    }
111
2.52k
  }
AnalysisBasedWarnings.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::ContainsReference, void>::Visit(clang::Stmt const*)
Line
Count
Source
42
405
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
405
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
405
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
405
    // below.
46
405
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
30
      switch (BinOp->getOpcode()) {
48
30
      
case BO_PtrMemD: 1
DISPATCH1
(BinPtrMemD, BinaryOperator);
49
30
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
50
30
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
51
30
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
52
30
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
53
30
      
case BO_Add: 10
DISPATCH10
(BinAdd, BinaryOperator);
54
30
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
55
30
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
56
30
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
57
30
58
30
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
59
30
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
60
30
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
61
30
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
62
30
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
63
30
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
64
30
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
65
30
66
30
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
67
30
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
68
30
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
69
30
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
70
30
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
71
30
      
case BO_Assign: 0
DISPATCH0
(BinAssign, BinaryOperator);
72
30
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
73
30
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
74
30
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
75
30
      
case BO_AddAssign: 6
DISPATCH6
(BinAddAssign, CompoundAssignOperator);
76
30
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
77
30
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
78
30
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
79
30
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
80
30
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
81
30
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
82
30
      
case BO_Comma: 13
DISPATCH13
(BinComma, BinaryOperator);
83
375
      }
84
375
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
8
      switch (UnOp->getOpcode()) {
86
8
      
case UO_PostInc: 4
DISPATCH4
(UnaryPostInc, UnaryOperator);
87
8
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
88
8
      
case UO_PreInc: 2
DISPATCH2
(UnaryPreInc, UnaryOperator);
89
8
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
90
8
      
case UO_AddrOf: 0
DISPATCH0
(UnaryAddrOf, UnaryOperator);
91
8
      
case UO_Deref: 0
DISPATCH0
(UnaryDeref, UnaryOperator);
92
8
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
93
8
      
case UO_Minus: 2
DISPATCH2
(UnaryMinus, UnaryOperator);
94
8
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
95
8
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
96
8
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
97
8
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
98
8
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
99
8
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
100
367
      }
101
367
    }
102
367
103
367
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
367
    switch (S->getStmtClass()) {
105
367
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
367
#define ABSTRACT_STMT(STMT)
107
367
#define STMT(CLASS, PARENT)                              \
108
367
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
367
#include 
"clang/AST/StmtNodes.inc"0
110
367
    }
111
367
  }
SemaChecking.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::SequenceChecker, void>::Visit(clang::Stmt*)
Line
Count
Source
42
54.3M
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
54.3M
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
54.3M
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
54.3M
    // below.
46
54.3M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
4.62M
      switch (BinOp->getOpcode()) {
48
4.62M
      
case BO_PtrMemD: 291
DISPATCH291
(BinPtrMemD, BinaryOperator);
49
4.62M
      
case BO_PtrMemI: 235
DISPATCH235
(BinPtrMemI, BinaryOperator);
50
4.62M
      
case BO_Mul: 185k
DISPATCH185k
(BinMul, BinaryOperator);
51
4.62M
      
case BO_Div: 226k
DISPATCH226k
(BinDiv, BinaryOperator);
52
4.62M
      
case BO_Rem: 12.6k
DISPATCH12.6k
(BinRem, BinaryOperator);
53
4.62M
      
case BO_Add: 668k
DISPATCH668k
(BinAdd, BinaryOperator);
54
4.62M
      
case BO_Sub: 682k
DISPATCH682k
(BinSub, BinaryOperator);
55
4.62M
      
case BO_Shl: 100k
DISPATCH100k
(BinShl, BinaryOperator);
56
4.62M
      
case BO_Shr: 55.7k
DISPATCH55.7k
(BinShr, BinaryOperator);
57
4.62M
58
4.62M
      
case BO_LT: 224k
DISPATCH224k
(BinLT, BinaryOperator);
59
4.62M
      
case BO_GT: 178k
DISPATCH178k
(BinGT, BinaryOperator);
60
4.62M
      
case BO_LE: 57.2k
DISPATCH57.2k
(BinLE, BinaryOperator);
61
4.62M
      
case BO_GE: 44.6k
DISPATCH44.6k
(BinGE, BinaryOperator);
62
4.62M
      
case BO_EQ: 251k
DISPATCH251k
(BinEQ, BinaryOperator);
63
4.62M
      
case BO_NE: 117k
DISPATCH117k
(BinNE, BinaryOperator);
64
4.62M
      
case BO_Cmp: 181
DISPATCH181
(BinCmp, BinaryOperator);
65
4.62M
66
4.62M
      
case BO_And: 107k
DISPATCH107k
(BinAnd, BinaryOperator);
67
4.62M
      
case BO_Xor: 21.1k
DISPATCH21.1k
(BinXor, BinaryOperator);
68
4.62M
      
case BO_Or : 66.5k
DISPATCH66.5k
(BinOr, BinaryOperator);
69
4.62M
      
case BO_LAnd: 104k
DISPATCH104k
(BinLAnd, BinaryOperator);
70
4.62M
      
case BO_LOr : 53.7k
DISPATCH53.7k
(BinLOr, BinaryOperator);
71
4.62M
      
case BO_Assign: 1.35M
DISPATCH1.35M
(BinAssign, BinaryOperator);
72
4.62M
      
case BO_MulAssign: 3.81k
DISPATCH3.81k
(BinMulAssign, CompoundAssignOperator);
73
4.62M
      
case BO_DivAssign: 1.86k
DISPATCH1.86k
(BinDivAssign, CompoundAssignOperator);
74
4.62M
      
case BO_RemAssign: 256
DISPATCH256
(BinRemAssign, CompoundAssignOperator);
75
4.62M
      
case BO_AddAssign: 52.9k
DISPATCH52.9k
(BinAddAssign, CompoundAssignOperator);
76
4.62M
      
case BO_SubAssign: 8.12k
DISPATCH8.12k
(BinSubAssign, CompoundAssignOperator);
77
4.62M
      
case BO_ShlAssign: 2.25k
DISPATCH2.25k
(BinShlAssign, CompoundAssignOperator);
78
4.62M
      
case BO_ShrAssign: 1.06k
DISPATCH1.06k
(BinShrAssign, CompoundAssignOperator);
79
4.62M
      
case BO_AndAssign: 2.82k
DISPATCH2.82k
(BinAndAssign, CompoundAssignOperator);
80
4.62M
      
case BO_OrAssign: 17.8k
DISPATCH17.8k
(BinOrAssign, CompoundAssignOperator);
81
4.62M
      
case BO_XorAssign: 2.25k
DISPATCH2.25k
(BinXorAssign, CompoundAssignOperator);
82
4.62M
      
case BO_Comma: 22.6k
DISPATCH22.6k
(BinComma, BinaryOperator);
83
49.6M
      }
84
49.6M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
1.36M
      switch (UnOp->getOpcode()) {
86
1.36M
      
case UO_PostInc: 124k
DISPATCH124k
(UnaryPostInc, UnaryOperator);
87
1.36M
      
case UO_PostDec: 8.54k
DISPATCH8.54k
(UnaryPostDec, UnaryOperator);
88
1.36M
      
case UO_PreInc: 105k
DISPATCH105k
(UnaryPreInc, UnaryOperator);
89
1.36M
      
case UO_PreDec: 16.1k
DISPATCH16.1k
(UnaryPreDec, UnaryOperator);
90
1.36M
      
case UO_AddrOf: 164k
DISPATCH164k
(UnaryAddrOf, UnaryOperator);
91
1.36M
      
case UO_Deref: 193k
DISPATCH193k
(UnaryDeref, UnaryOperator);
92
1.36M
      
case UO_Plus: 518
DISPATCH518
(UnaryPlus, UnaryOperator);
93
1.36M
      
case UO_Minus: 215k
DISPATCH215k
(UnaryMinus, UnaryOperator);
94
1.36M
      
case UO_Not: 35.6k
DISPATCH35.6k
(UnaryNot, UnaryOperator);
95
1.36M
      
case UO_LNot: 479k
DISPATCH479k
(UnaryLNot, UnaryOperator);
96
1.36M
      
case UO_Real: 709
DISPATCH709
(UnaryReal, UnaryOperator);
97
1.36M
      
case UO_Imag: 689
DISPATCH689
(UnaryImag, UnaryOperator);
98
1.36M
      
case UO_Extension: 23.2k
DISPATCH23.2k
(UnaryExtension, UnaryOperator);
99
1.36M
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
100
48.3M
      }
101
48.3M
    }
102
48.3M
103
48.3M
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
48.3M
    switch (S->getStmtClass()) {
105
48.3M
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
48.3M
#define ABSTRACT_STMT(STMT)
107
48.3M
#define STMT(CLASS, PARENT)                              \
108
48.3M
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
48.3M
#include 
"clang/AST/StmtNodes.inc"0
110
48.3M
    }
111
48.3M
  }
SemaChecking.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::FindCaptureVisitor, void>::Visit(clang::Stmt*)
Line
Count
Source
42
140
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
140
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
140
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
140
    // below.
46
140
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
2
      switch (BinOp->getOpcode()) {
48
2
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
49
2
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
50
2
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
51
2
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
52
2
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
53
2
      
case BO_Add: 0
DISPATCH0
(BinAdd, BinaryOperator);
54
2
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
55
2
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
56
2
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
57
2
58
2
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
59
2
      
case BO_GT: 1
DISPATCH1
(BinGT, BinaryOperator);
60
2
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
61
2
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
62
2
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
63
2
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
64
2
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
65
2
66
2
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
67
2
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
68
2
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
69
2
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
70
2
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
71
2
      
case BO_Assign: 1
DISPATCH1
(BinAssign, BinaryOperator);
72
2
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
73
2
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
74
2
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
75
2
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
76
2
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
77
2
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
78
2
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
79
2
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
80
2
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
81
2
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
82
2
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
83
138
      }
84
138
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
0
      switch (UnOp->getOpcode()) {
86
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
87
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
88
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
89
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
90
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
91
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
92
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
93
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
94
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
95
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
96
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
97
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
98
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
99
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
100
138
      }
101
138
    }
102
138
103
138
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
138
    switch (S->getStmtClass()) {
105
138
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
138
#define ABSTRACT_STMT(STMT)
107
138
#define STMT(CLASS, PARENT)                              \
108
138
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
138
#include 
"clang/AST/StmtNodes.inc"0
110
138
    }
111
138
  }
SemaDecl.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::SelfReferenceChecker, void>::Visit(clang::Stmt*)
Line
Count
Source
42
3.12M
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
3.12M
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
3.12M
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
3.12M
    // below.
46
3.12M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
186k
      switch (BinOp->getOpcode()) {
48
186k
      
case BO_PtrMemD: 25
DISPATCH25
(BinPtrMemD, BinaryOperator);
49
186k
      
case BO_PtrMemI: 3
DISPATCH3
(BinPtrMemI, BinaryOperator);
50
186k
      
case BO_Mul: 23.7k
DISPATCH23.7k
(BinMul, BinaryOperator);
51
186k
      
case BO_Div: 32.4k
DISPATCH32.4k
(BinDiv, BinaryOperator);
52
186k
      
case BO_Rem: 248
DISPATCH248
(BinRem, BinaryOperator);
53
186k
      
case BO_Add: 17.6k
DISPATCH17.6k
(BinAdd, BinaryOperator);
54
186k
      
case BO_Sub: 19.9k
DISPATCH19.9k
(BinSub, BinaryOperator);
55
186k
      
case BO_Shl: 38.5k
DISPATCH38.5k
(BinShl, BinaryOperator);
56
186k
      
case BO_Shr: 2.57k
DISPATCH2.57k
(BinShr, BinaryOperator);
57
186k
58
186k
      
case BO_LT: 11.1k
DISPATCH11.1k
(BinLT, BinaryOperator);
59
186k
      
case BO_GT: 66
DISPATCH66
(BinGT, BinaryOperator);
60
186k
      
case BO_LE: 9.60k
DISPATCH9.60k
(BinLE, BinaryOperator);
61
186k
      
case BO_GE: 595
DISPATCH595
(BinGE, BinaryOperator);
62
186k
      
case BO_EQ: 8.69k
DISPATCH8.69k
(BinEQ, BinaryOperator);
63
186k
      
case BO_NE: 1.03k
DISPATCH1.03k
(BinNE, BinaryOperator);
64
186k
      
case BO_Cmp: 40
DISPATCH40
(BinCmp, BinaryOperator);
65
186k
66
186k
      
case BO_And: 6.37k
DISPATCH6.37k
(BinAnd, BinaryOperator);
67
186k
      
case BO_Xor: 2.12k
DISPATCH2.12k
(BinXor, BinaryOperator);
68
186k
      
case BO_Or : 6.77k
DISPATCH6.77k
(BinOr, BinaryOperator);
69
186k
      
case BO_LAnd: 4.59k
DISPATCH4.59k
(BinLAnd, BinaryOperator);
70
186k
      
case BO_LOr : 298
DISPATCH298
(BinLOr, BinaryOperator);
71
186k
      
case BO_Assign: 13
DISPATCH13
(BinAssign, BinaryOperator);
72
186k
      
case BO_MulAssign: 7
DISPATCH7
(BinMulAssign, CompoundAssignOperator);
73
186k
      
case BO_DivAssign: 1
DISPATCH1
(BinDivAssign, CompoundAssignOperator);
74
186k
      
case BO_RemAssign: 4
DISPATCH4
(BinRemAssign, CompoundAssignOperator);
75
186k
      
case BO_AddAssign: 14
DISPATCH14
(BinAddAssign, CompoundAssignOperator);
76
186k
      
case BO_SubAssign: 1
DISPATCH1
(BinSubAssign, CompoundAssignOperator);
77
186k
      
case BO_ShlAssign: 4
DISPATCH4
(BinShlAssign, CompoundAssignOperator);
78
186k
      
case BO_ShrAssign: 1
DISPATCH1
(BinShrAssign, CompoundAssignOperator);
79
186k
      
case BO_AndAssign: 1
DISPATCH1
(BinAndAssign, CompoundAssignOperator);
80
186k
      
case BO_OrAssign: 1
DISPATCH1
(BinOrAssign, CompoundAssignOperator);
81
186k
      
case BO_XorAssign: 1
DISPATCH1
(BinXorAssign, CompoundAssignOperator);
82
186k
      
case BO_Comma: 130
DISPATCH130
(BinComma, BinaryOperator);
83
2.93M
      }
84
2.93M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
127k
      switch (UnOp->getOpcode()) {
86
127k
      
case UO_PostInc: 130
DISPATCH130
(UnaryPostInc, UnaryOperator);
87
127k
      
case UO_PostDec: 2
DISPATCH2
(UnaryPostDec, UnaryOperator);
88
127k
      
case UO_PreInc: 39
DISPATCH39
(UnaryPreInc, UnaryOperator);
89
127k
      
case UO_PreDec: 31
DISPATCH31
(UnaryPreDec, UnaryOperator);
90
127k
      
case UO_AddrOf: 21.1k
DISPATCH21.1k
(UnaryAddrOf, UnaryOperator);
91
127k
      
case UO_Deref: 15.1k
DISPATCH15.1k
(UnaryDeref, UnaryOperator);
92
127k
      
case UO_Plus: 76
DISPATCH76
(UnaryPlus, UnaryOperator);
93
127k
      
case UO_Minus: 76.3k
DISPATCH76.3k
(UnaryMinus, UnaryOperator);
94
127k
      
case UO_Not: 9.17k
DISPATCH9.17k
(UnaryNot, UnaryOperator);
95
127k
      
case UO_LNot: 5.13k
DISPATCH5.13k
(UnaryLNot, UnaryOperator);
96
127k
      
case UO_Real: 3
DISPATCH3
(UnaryReal, UnaryOperator);
97
127k
      
case UO_Imag: 3
DISPATCH3
(UnaryImag, UnaryOperator);
98
127k
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
99
127k
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
100
2.81M
      }
101
2.81M
    }
102
2.81M
103
2.81M
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
2.81M
    switch (S->getStmtClass()) {
105
2.81M
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
2.81M
#define ABSTRACT_STMT(STMT)
107
2.81M
#define STMT(CLASS, PARENT)                              \
108
2.81M
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
2.81M
#include 
"clang/AST/StmtNodes.inc"0
110
2.81M
    }
111
2.81M
  }
SemaDeclCXX.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::UninitializedFieldVisitor, void>::Visit(clang::Stmt*)
Line
Count
Source
42
159k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
159k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
159k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
159k
    // below.
46
159k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
1.55k
      switch (BinOp->getOpcode()) {
48
1.55k
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
49
1.55k
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
50
1.55k
      
case BO_Mul: 17
DISPATCH17
(BinMul, BinaryOperator);
51
1.55k
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
52
1.55k
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
53
1.55k
      
case BO_Add: 1.48k
DISPATCH1.48k
(BinAdd, BinaryOperator);
54
1.55k
      
case BO_Sub: 4
DISPATCH4
(BinSub, BinaryOperator);
55
1.55k
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
56
1.55k
      
case BO_Shr: 12
DISPATCH12
(BinShr, BinaryOperator);
57
1.55k
58
1.55k
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
59
1.55k
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
60
1.55k
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
61
1.55k
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
62
1.55k
      
case BO_EQ: 6
DISPATCH6
(BinEQ, BinaryOperator);
63
1.55k
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
64
1.55k
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
65
1.55k
66
1.55k
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
67
1.55k
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
68
1.55k
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
69
1.55k
      
case BO_LAnd: 4
DISPATCH4
(BinLAnd, BinaryOperator);
70
1.55k
      
case BO_LOr : 11
DISPATCH11
(BinLOr, BinaryOperator);
71
1.55k
      
case BO_Assign: 10
DISPATCH10
(BinAssign, BinaryOperator);
72
1.55k
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
73
1.55k
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
74
1.55k
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
75
1.55k
      
case BO_AddAssign: 3
DISPATCH3
(BinAddAssign, CompoundAssignOperator);
76
1.55k
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
77
1.55k
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
78
1.55k
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
79
1.55k
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
80
1.55k
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
81
1.55k
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
82
1.55k
      
case BO_Comma: 7
DISPATCH7
(BinComma, BinaryOperator);
83
157k
      }
84
157k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
670
      switch (UnOp->getOpcode()) {
86
670
      
case UO_PostInc: 17
DISPATCH17
(UnaryPostInc, UnaryOperator);
87
670
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
88
670
      
case UO_PreInc: 12
DISPATCH12
(UnaryPreInc, UnaryOperator);
89
670
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
90
670
      
case UO_AddrOf: 231
DISPATCH231
(UnaryAddrOf, UnaryOperator);
91
670
      
case UO_Deref: 117
DISPATCH117
(UnaryDeref, UnaryOperator);
92
670
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
93
670
      
case UO_Minus: 286
DISPATCH286
(UnaryMinus, UnaryOperator);
94
670
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
95
670
      
case UO_LNot: 7
DISPATCH7
(UnaryLNot, UnaryOperator);
96
670
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
97
670
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
98
670
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
99
670
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
100
156k
      }
101
156k
    }
102
156k
103
156k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
156k
    switch (S->getStmtClass()) {
105
156k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
156k
#define ABSTRACT_STMT(STMT)
107
156k
#define STMT(CLASS, PARENT)                              \
108
156k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
156k
#include 
"clang/AST/StmtNodes.inc"0
110
156k
    }
111
156k
  }
SemaDeclCXX.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::CheckDefaultArgumentVisitor, bool>::Visit(clang::Stmt*)
Line
Count
Source
42
167k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
167k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
167k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
167k
    // below.
46
167k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
5.06k
      switch (BinOp->getOpcode()) {
48
5.06k
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
49
5.06k
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
50
5.06k
      
case BO_Mul: 2
DISPATCH2
(BinMul, BinaryOperator);
51
5.06k
      
case BO_Div: 15
DISPATCH15
(BinDiv, BinaryOperator);
52
5.06k
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
53
5.06k
      
case BO_Add: 22
DISPATCH22
(BinAdd, BinaryOperator);
54
5.06k
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
55
5.06k
      
case BO_Shl: 2.61k
DISPATCH2.61k
(BinShl, BinaryOperator);
56
5.06k
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
57
5.06k
58
5.06k
      
case BO_LT: 14
DISPATCH14
(BinLT, BinaryOperator);
59
5.06k
      
case BO_GT: 4
DISPATCH4
(BinGT, BinaryOperator);
60
5.06k
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
61
5.06k
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
62
5.06k
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
63
5.06k
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
64
5.06k
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
65
5.06k
66
5.06k
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
67
5.06k
      
case BO_Xor: 5
DISPATCH5
(BinXor, BinaryOperator);
68
5.06k
      
case BO_Or : 2.38k
DISPATCH2.38k
(BinOr, BinaryOperator);
69
5.06k
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
70
5.06k
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
71
5.06k
      
case BO_Assign: 0
DISPATCH0
(BinAssign, BinaryOperator);
72
5.06k
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
73
5.06k
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
74
5.06k
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
75
5.06k
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
76
5.06k
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
77
5.06k
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
78
5.06k
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
79
5.06k
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
80
5.06k
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
81
5.06k
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
82
5.06k
      
case BO_Comma: 7
DISPATCH7
(BinComma, BinaryOperator);
83
162k
      }
84
162k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
3.41k
      switch (UnOp->getOpcode()) {
86
3.41k
      
case UO_PostInc: 0
DISPATCH0
(UnaryPostInc, UnaryOperator);
87
3.41k
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
88
3.41k
      
case UO_PreInc: 0
DISPATCH0
(UnaryPreInc, UnaryOperator);
89
3.41k
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
90
3.41k
      
case UO_AddrOf: 2.61k
DISPATCH2.61k
(UnaryAddrOf, UnaryOperator);
91
3.41k
      
case UO_Deref: 0
DISPATCH0
(UnaryDeref, UnaryOperator);
92
3.41k
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
93
3.41k
      
case UO_Minus: 802
DISPATCH802
(UnaryMinus, UnaryOperator);
94
3.41k
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
95
3.41k
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
96
3.41k
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
97
3.41k
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
98
3.41k
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
99
3.41k
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
100
159k
      }
101
159k
    }
102
159k
103
159k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
159k
    switch (S->getStmtClass()) {
105
159k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
159k
#define ABSTRACT_STMT(STMT)
107
159k
#define STMT(CLASS, PARENT)                              \
108
159k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
159k
#include 
"clang/AST/StmtNodes.inc"0
110
159k
    }
111
159k
  }
SemaExpr.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::RebuildUnknownAnyFunction, clang::ActionResult<clang::Expr*, true> >::Visit(clang::Stmt*)
Line
Count
Source
42
5
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
5
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
5
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
5
    // below.
46
5
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
0
      switch (BinOp->getOpcode()) {
48
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
49
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
50
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
51
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
52
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
53
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
54
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
55
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
56
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
57
0
58
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
59
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
60
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
61
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
62
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
63
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
64
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
65
0
66
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
67
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
68
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
69
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
70
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
71
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
72
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
73
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
74
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
75
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
76
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
77
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
78
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
79
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
80
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
81
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
82
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
83
5
      }
84
5
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
0
      switch (UnOp->getOpcode()) {
86
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
87
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
88
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
89
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
90
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
91
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
92
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
93
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
94
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
95
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
96
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
97
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
98
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
99
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
100
5
      }
101
5
    }
102
5
103
5
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
5
    switch (S->getStmtClass()) {
105
5
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
5
#define ABSTRACT_STMT(STMT)
107
5
#define STMT(CLASS, PARENT)                              \
108
5
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
5
#include 
"clang/AST/StmtNodes.inc"0
110
5
    }
111
5
  }
SemaExpr.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::EvaluatedExprMarker, void>::Visit(clang::Stmt*)
Line
Count
Source
42
136k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
136k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
136k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
136k
    // below.
46
136k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
269
      switch (BinOp->getOpcode()) {
48
269
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
49
269
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
50
269
      
case BO_Mul: 5
DISPATCH5
(BinMul, BinaryOperator);
51
269
      
case BO_Div: 1
DISPATCH1
(BinDiv, BinaryOperator);
52
269
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
53
269
      
case BO_Add: 8
DISPATCH8
(BinAdd, BinaryOperator);
54
269
      
case BO_Sub: 20
DISPATCH20
(BinSub, BinaryOperator);
55
269
      
case BO_Shl: 24
DISPATCH24
(BinShl, BinaryOperator);
56
269
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
57
269
58
269
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
59
269
      
case BO_GT: 72
DISPATCH72
(BinGT, BinaryOperator);
60
269
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
61
269
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
62
269
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
63
269
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
64
269
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
65
269
66
269
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
67
269
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
68
269
      
case BO_Or : 129
DISPATCH129
(BinOr, BinaryOperator);
69
269
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
70
269
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
71
269
      
case BO_Assign: 0
DISPATCH0
(BinAssign, BinaryOperator);
72
269
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
73
269
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
74
269
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
75
269
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
76
269
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
77
269
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
78
269
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
79
269
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
80
269
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
81
269
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
82
269
      
case BO_Comma: 10
DISPATCH10
(BinComma, BinaryOperator);
83
136k
      }
84
136k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
527
      switch (UnOp->getOpcode()) {
86
527
      
case UO_PostInc: 0
DISPATCH0
(UnaryPostInc, UnaryOperator);
87
527
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
88
527
      
case UO_PreInc: 0
DISPATCH0
(UnaryPreInc, UnaryOperator);
89
527
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
90
527
      
case UO_AddrOf: 91
DISPATCH91
(UnaryAddrOf, UnaryOperator);
91
527
      
case UO_Deref: 0
DISPATCH0
(UnaryDeref, UnaryOperator);
92
527
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
93
527
      
case UO_Minus: 436
DISPATCH436
(UnaryMinus, UnaryOperator);
94
527
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
95
527
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
96
527
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
97
527
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
98
527
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
99
527
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
100
135k
      }
101
135k
    }
102
135k
103
135k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
135k
    switch (S->getStmtClass()) {
105
135k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
135k
#define ABSTRACT_STMT(STMT)
107
135k
#define STMT(CLASS, PARENT)                              \
108
135k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
135k
#include 
"clang/AST/StmtNodes.inc"0
110
135k
    }
111
135k
  }
SemaExpr.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::RebuildUnknownAnyExpr, clang::ActionResult<clang::Expr*, true> >::Visit(clang::Stmt*)
Line
Count
Source
42
126
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
126
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
126
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
126
    // below.
46
126
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
0
      switch (BinOp->getOpcode()) {
48
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
49
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
50
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
51
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
52
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
53
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
54
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
55
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
56
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
57
0
58
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
59
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
60
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
61
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
62
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
63
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
64
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
65
0
66
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
67
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
68
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
69
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
70
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
71
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
72
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
73
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
74
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
75
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
76
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
77
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
78
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
79
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
80
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
81
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
82
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
83
126
      }
84
126
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
4
      switch (UnOp->getOpcode()) {
86
4
      
case UO_PostInc: 0
DISPATCH0
(UnaryPostInc, UnaryOperator);
87
4
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
88
4
      
case UO_PreInc: 0
DISPATCH0
(UnaryPreInc, UnaryOperator);
89
4
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
90
4
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
91
4
      
case UO_Deref: 0
DISPATCH0
(UnaryDeref, UnaryOperator);
92
4
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
93
4
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
94
4
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
95
4
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
96
4
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
97
4
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
98
4
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
99
4
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
100
122
      }
101
122
    }
102
122
103
122
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
122
    switch (S->getStmtClass()) {
105
122
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
122
#define ABSTRACT_STMT(STMT)
107
122
#define STMT(CLASS, PARENT)                              \
108
122
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
122
#include 
"clang/AST/StmtNodes.inc"0
110
122
    }
111
122
  }
SemaExprObjC.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::ARCCastChecker, (anonymous namespace)::ACCResult>::Visit(clang::Stmt*)
Line
Count
Source
42
1.73k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
1.73k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
1.73k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
1.73k
    // below.
46
1.73k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
3
      switch (BinOp->getOpcode()) {
48
3
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
49
3
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
50
3
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
51
3
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
52
3
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
53
3
      
case BO_Add: 0
DISPATCH0
(BinAdd, BinaryOperator);
54
3
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
55
3
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
56
3
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
57
3
58
3
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
59
3
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
60
3
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
61
3
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
62
3
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
63
3
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
64
3
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
65
3
66
3
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
67
3
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
68
3
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
69
3
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
70
3
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
71
3
      
case BO_Assign: 0
DISPATCH0
(BinAssign, BinaryOperator);
72
3
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
73
3
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
74
3
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
75
3
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
76
3
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
77
3
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
78
3
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
79
3
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
80
3
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
81
3
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
82
3
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
83
1.73k
      }
84
1.73k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
3
      switch (UnOp->getOpcode()) {
86
3
      
case UO_PostInc: 0
DISPATCH0
(UnaryPostInc, UnaryOperator);
87
3
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
88
3
      
case UO_PreInc: 0
DISPATCH0
(UnaryPreInc, UnaryOperator);
89
3
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
90
3
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
91
3
      
case UO_Deref: 0
DISPATCH0
(UnaryDeref, UnaryOperator);
92
3
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
93
3
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
94
3
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
95
3
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
96
3
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
97
3
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
98
3
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
99
3
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
100
1.73k
      }
101
1.73k
    }
102
1.73k
103
1.73k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
1.73k
    switch (S->getStmtClass()) {
105
1.73k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
1.73k
#define ABSTRACT_STMT(STMT)
107
1.73k
#define STMT(CLASS, PARENT)                              \
108
1.73k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
1.73k
#include 
"clang/AST/StmtNodes.inc"0
110
1.73k
    }
111
1.73k
  }
SemaOpenMP.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::DSARefChecker, bool>::Visit(clang::Stmt*)
Line
Count
Source
42
6.60k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
6.60k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
6.60k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
6.60k
    // below.
46
6.60k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
0
      switch (BinOp->getOpcode()) {
48
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
49
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
50
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
51
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
52
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
53
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
54
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
55
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
56
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
57
0
58
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
59
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
60
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
61
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
62
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
63
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
64
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
65
0
66
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
67
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
68
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
69
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
70
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
71
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
72
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
73
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
74
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
75
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
76
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
77
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
78
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
79
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
80
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
81
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
82
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
83
6.60k
      }
84
6.60k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
0
      switch (UnOp->getOpcode()) {
86
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
87
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
88
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
89
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
90
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
91
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
92
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
93
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
94
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
95
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
96
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
97
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
98
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
99
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
100
6.60k
      }
101
6.60k
    }
102
6.60k
103
6.60k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
6.60k
    switch (S->getStmtClass()) {
105
6.60k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
6.60k
#define ABSTRACT_STMT(STMT)
107
6.60k
#define STMT(CLASS, PARENT)                              \
108
6.60k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
6.60k
#include 
"clang/AST/StmtNodes.inc"0
110
6.60k
    }
111
6.60k
  }
SemaOpenMP.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::LocalVarRefChecker, bool>::Visit(clang::Stmt const*)
Line
Count
Source
42
1.52k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
1.52k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
1.52k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
1.52k
    // below.
46
1.52k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
0
      switch (BinOp->getOpcode()) {
48
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
49
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
50
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
51
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
52
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
53
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
54
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
55
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
56
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
57
0
58
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
59
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
60
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
61
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
62
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
63
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
64
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
65
0
66
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
67
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
68
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
69
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
70
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
71
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
72
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
73
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
74
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
75
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
76
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
77
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
78
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
79
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
80
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
81
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
82
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
83
1.52k
      }
84
1.52k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
0
      switch (UnOp->getOpcode()) {
86
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
87
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
88
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
89
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
90
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
91
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
92
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
93
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
94
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
95
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
96
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
97
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
98
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
99
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
100
1.52k
      }
101
1.52k
    }
102
1.52k
103
1.52k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
1.52k
    switch (S->getStmtClass()) {
105
1.52k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
1.52k
#define ABSTRACT_STMT(STMT)
107
1.52k
#define STMT(CLASS, PARENT)                              \
108
1.52k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
1.52k
#include 
"clang/AST/StmtNodes.inc"0
110
1.52k
    }
111
1.52k
  }
SemaOpenMP.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::DSAAttrChecker, void>::Visit(clang::Stmt*)
Line
Count
Source
42
1.26M
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
1.26M
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
1.26M
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
1.26M
    // below.
46
1.26M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
121k
      switch (BinOp->getOpcode()) {
48
121k
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
49
121k
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
50
121k
      
case BO_Mul: 910
DISPATCH910
(BinMul, BinaryOperator);
51
121k
      
case BO_Div: 132
DISPATCH132
(BinDiv, BinaryOperator);
52
121k
      
case BO_Rem: 8
DISPATCH8
(BinRem, BinaryOperator);
53
121k
      
case BO_Add: 4.17k
DISPATCH4.17k
(BinAdd, BinaryOperator);
54
121k
      
case BO_Sub: 16.8k
DISPATCH16.8k
(BinSub, BinaryOperator);
55
121k
      
case BO_Shl: 26
DISPATCH26
(BinShl, BinaryOperator);
56
121k
      
case BO_Shr: 26
DISPATCH26
(BinShr, BinaryOperator);
57
121k
58
121k
      
case BO_LT: 55.4k
DISPATCH55.4k
(BinLT, BinaryOperator);
59
121k
      
case BO_GT: 893
DISPATCH893
(BinGT, BinaryOperator);
60
121k
      
case BO_LE: 226
DISPATCH226
(BinLE, BinaryOperator);
61
121k
      
case BO_GE: 296
DISPATCH296
(BinGE, BinaryOperator);
62
121k
      
case BO_EQ: 196
DISPATCH196
(BinEQ, BinaryOperator);
63
121k
      
case BO_NE: 110
DISPATCH110
(BinNE, BinaryOperator);
64
121k
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
65
121k
66
121k
      
case BO_And: 42
DISPATCH42
(BinAnd, BinaryOperator);
67
121k
      
case BO_Xor: 18
DISPATCH18
(BinXor, BinaryOperator);
68
121k
      
case BO_Or : 26
DISPATCH26
(BinOr, BinaryOperator);
69
121k
      
case BO_LAnd: 94
DISPATCH94
(BinLAnd, BinaryOperator);
70
121k
      
case BO_LOr : 14
DISPATCH14
(BinLOr, BinaryOperator);
71
121k
      
case BO_Assign: 32.1k
DISPATCH32.1k
(BinAssign, BinaryOperator);
72
121k
      
case BO_MulAssign: 81
DISPATCH81
(BinMulAssign, CompoundAssignOperator);
73
121k
      
case BO_DivAssign: 158
DISPATCH158
(BinDivAssign, CompoundAssignOperator);
74
121k
      
case BO_RemAssign: 34
DISPATCH34
(BinRemAssign, CompoundAssignOperator);
75
121k
      
case BO_AddAssign: 8.73k
DISPATCH8.73k
(BinAddAssign, CompoundAssignOperator);
76
121k
      
case BO_SubAssign: 426
DISPATCH426
(BinSubAssign, CompoundAssignOperator);
77
121k
      
case BO_ShlAssign: 26
DISPATCH26
(BinShlAssign, CompoundAssignOperator);
78
121k
      
case BO_ShrAssign: 26
DISPATCH26
(BinShrAssign, CompoundAssignOperator);
79
121k
      
case BO_AndAssign: 26
DISPATCH26
(BinAndAssign, CompoundAssignOperator);
80
121k
      
case BO_OrAssign: 48
DISPATCH48
(BinOrAssign, CompoundAssignOperator);
81
121k
      
case BO_XorAssign: 36
DISPATCH36
(BinXorAssign, CompoundAssignOperator);
82
121k
      
case BO_Comma: 244
DISPATCH244
(BinComma, BinaryOperator);
83
1.14M
      }
84
1.14M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
64.0k
      switch (UnOp->getOpcode()) {
86
64.0k
      
case UO_PostInc: 19.9k
DISPATCH19.9k
(UnaryPostInc, UnaryOperator);
87
64.0k
      
case UO_PostDec: 202
DISPATCH202
(UnaryPostDec, UnaryOperator);
88
64.0k
      
case UO_PreInc: 42.5k
DISPATCH42.5k
(UnaryPreInc, UnaryOperator);
89
64.0k
      
case UO_PreDec: 158
DISPATCH158
(UnaryPreDec, UnaryOperator);
90
64.0k
      
case UO_AddrOf: 128
DISPATCH128
(UnaryAddrOf, UnaryOperator);
91
64.0k
      
case UO_Deref: 520
DISPATCH520
(UnaryDeref, UnaryOperator);
92
64.0k
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
93
64.0k
      
case UO_Minus: 384
DISPATCH384
(UnaryMinus, UnaryOperator);
94
64.0k
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
95
64.0k
      
case UO_LNot: 122
DISPATCH122
(UnaryLNot, UnaryOperator);
96
64.0k
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
97
64.0k
      
case UO_Imag: 4
DISPATCH4
(UnaryImag, UnaryOperator);
98
64.0k
      
case UO_Extension: 24
DISPATCH24
(UnaryExtension, UnaryOperator);
99
64.0k
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
100
1.08M
      }
101
1.08M
    }
102
1.08M
103
1.08M
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
1.08M
    switch (S->getStmtClass()) {
105
1.08M
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
1.08M
#define ABSTRACT_STMT(STMT)
107
1.08M
#define STMT(CLASS, PARENT)                              \
108
1.08M
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
1.08M
#include 
"clang/AST/StmtNodes.inc"0
110
1.08M
    }
111
1.08M
  }
SemaStmt.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::BreakContinueFinder, void>::Visit(clang::Stmt const*)
Line
Count
Source
42
256k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
256k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
256k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
256k
    // below.
46
256k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
37.6k
      switch (BinOp->getOpcode()) {
48
37.6k
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
49
37.6k
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
50
37.6k
      
case BO_Mul: 720
DISPATCH720
(BinMul, BinaryOperator);
51
37.6k
      
case BO_Div: 370
DISPATCH370
(BinDiv, BinaryOperator);
52
37.6k
      
case BO_Rem: 54
DISPATCH54
(BinRem, BinaryOperator);
53
37.6k
      
case BO_Add: 1.40k
DISPATCH1.40k
(BinAdd, BinaryOperator);
54
37.6k
      
case BO_Sub: 833
DISPATCH833
(BinSub, BinaryOperator);
55
37.6k
      
case BO_Shl: 140
DISPATCH140
(BinShl, BinaryOperator);
56
37.6k
      
case BO_Shr: 67
DISPATCH67
(BinShr, BinaryOperator);
57
37.6k
58
37.6k
      
case BO_LT: 18.4k
DISPATCH18.4k
(BinLT, BinaryOperator);
59
37.6k
      
case BO_GT: 1.21k
DISPATCH1.21k
(BinGT, BinaryOperator);
60
37.6k
      
case BO_LE: 2.36k
DISPATCH2.36k
(BinLE, BinaryOperator);
61
37.6k
      
case BO_GE: 723
DISPATCH723
(BinGE, BinaryOperator);
62
37.6k
      
case BO_EQ: 1.49k
DISPATCH1.49k
(BinEQ, BinaryOperator);
63
37.6k
      
case BO_NE: 2.71k
DISPATCH2.71k
(BinNE, BinaryOperator);
64
37.6k
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
65
37.6k
66
37.6k
      
case BO_And: 112
DISPATCH112
(BinAnd, BinaryOperator);
67
37.6k
      
case BO_Xor: 2
DISPATCH2
(BinXor, BinaryOperator);
68
37.6k
      
case BO_Or : 9
DISPATCH9
(BinOr, BinaryOperator);
69
37.6k
      
case BO_LAnd: 1.55k
DISPATCH1.55k
(BinLAnd, BinaryOperator);
70
37.6k
      
case BO_LOr : 238
DISPATCH238
(BinLOr, BinaryOperator);
71
37.6k
      
case BO_Assign: 3.23k
DISPATCH3.23k
(BinAssign, BinaryOperator);
72
37.6k
      
case BO_MulAssign: 14
DISPATCH14
(BinMulAssign, CompoundAssignOperator);
73
37.6k
      
case BO_DivAssign: 7
DISPATCH7
(BinDivAssign, CompoundAssignOperator);
74
37.6k
      
case BO_RemAssign: 4
DISPATCH4
(BinRemAssign, CompoundAssignOperator);
75
37.6k
      
case BO_AddAssign: 859
DISPATCH859
(BinAddAssign, CompoundAssignOperator);
76
37.6k
      
case BO_SubAssign: 46
DISPATCH46
(BinSubAssign, CompoundAssignOperator);
77
37.6k
      
case BO_ShlAssign: 25
DISPATCH25
(BinShlAssign, CompoundAssignOperator);
78
37.6k
      
case BO_ShrAssign: 33
DISPATCH33
(BinShrAssign, CompoundAssignOperator);
79
37.6k
      
case BO_AndAssign: 6
DISPATCH6
(BinAndAssign, CompoundAssignOperator);
80
37.6k
      
case BO_OrAssign: 4
DISPATCH4
(BinOrAssign, CompoundAssignOperator);
81
37.6k
      
case BO_XorAssign: 4
DISPATCH4
(BinXorAssign, CompoundAssignOperator);
82
37.6k
      
case BO_Comma: 933
DISPATCH933
(BinComma, BinaryOperator);
83
219k
      }
84
219k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
25.2k
      switch (UnOp->getOpcode()) {
86
25.2k
      
case UO_PostInc: 16.2k
DISPATCH16.2k
(UnaryPostInc, UnaryOperator);
87
25.2k
      
case UO_PostDec: 932
DISPATCH932
(UnaryPostDec, UnaryOperator);
88
25.2k
      
case UO_PreInc: 4.09k
DISPATCH4.09k
(UnaryPreInc, UnaryOperator);
89
25.2k
      
case UO_PreDec: 470
DISPATCH470
(UnaryPreDec, UnaryOperator);
90
25.2k
      
case UO_AddrOf: 138
DISPATCH138
(UnaryAddrOf, UnaryOperator);
91
25.2k
      
case UO_Deref: 1.39k
DISPATCH1.39k
(UnaryDeref, UnaryOperator);
92
25.2k
      
case UO_Plus: 1
DISPATCH1
(UnaryPlus, UnaryOperator);
93
25.2k
      
case UO_Minus: 337
DISPATCH337
(UnaryMinus, UnaryOperator);
94
25.2k
      
case UO_Not: 1
DISPATCH1
(UnaryNot, UnaryOperator);
95
25.2k
      
case UO_LNot: 1.63k
DISPATCH1.63k
(UnaryLNot, UnaryOperator);
96
25.2k
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
97
25.2k
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
98
25.2k
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
99
25.2k
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
100
193k
      }
101
193k
    }
102
193k
103
193k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
193k
    switch (S->getStmtClass()) {
105
193k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
193k
#define ABSTRACT_STMT(STMT)
107
193k
#define STMT(CLASS, PARENT)                              \
108
193k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
193k
#include 
"clang/AST/StmtNodes.inc"0
110
193k
    }
111
193k
  }
SemaStmt.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::DeclExtractor, void>::Visit(clang::Stmt*)
Line
Count
Source
42
244k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
244k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
244k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
244k
    // below.
46
244k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
53.5k
      switch (BinOp->getOpcode()) {
48
53.5k
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
49
53.5k
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
50
53.5k
      
case BO_Mul: 1.56k
DISPATCH1.56k
(BinMul, BinaryOperator);
51
53.5k
      
case BO_Div: 1.29k
DISPATCH1.29k
(BinDiv, BinaryOperator);
52
53.5k
      
case BO_Rem: 8
DISPATCH8
(BinRem, BinaryOperator);
53
53.5k
      
case BO_Add: 2.35k
DISPATCH2.35k
(BinAdd, BinaryOperator);
54
53.5k
      
case BO_Sub: 56
DISPATCH56
(BinSub, BinaryOperator);
55
53.5k
      
case BO_Shl: 16
DISPATCH16
(BinShl, BinaryOperator);
56
53.5k
      
case BO_Shr: 8
DISPATCH8
(BinShr, BinaryOperator);
57
53.5k
58
53.5k
      
case BO_LT: 40.1k
DISPATCH40.1k
(BinLT, BinaryOperator);
59
53.5k
      
case BO_GT: 3.65k
DISPATCH3.65k
(BinGT, BinaryOperator);
60
53.5k
      
case BO_LE: 1.70k
DISPATCH1.70k
(BinLE, BinaryOperator);
61
53.5k
      
case BO_GE: 1.76k
DISPATCH1.76k
(BinGE, BinaryOperator);
62
53.5k
      
case BO_EQ: 70
DISPATCH70
(BinEQ, BinaryOperator);
63
53.5k
      
case BO_NE: 266
DISPATCH266
(BinNE, BinaryOperator);
64
53.5k
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
65
53.5k
66
53.5k
      
case BO_And: 44
DISPATCH44
(BinAnd, BinaryOperator);
67
53.5k
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
68
53.5k
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
69
53.5k
      
case BO_LAnd: 608
DISPATCH608
(BinLAnd, BinaryOperator);
70
53.5k
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
71
53.5k
      
case BO_Assign: 0
DISPATCH0
(BinAssign, BinaryOperator);
72
53.5k
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
73
53.5k
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
74
53.5k
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
75
53.5k
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
76
53.5k
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
77
53.5k
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
78
53.5k
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
79
53.5k
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
80
53.5k
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
81
53.5k
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
82
53.5k
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
83
191k
      }
84
191k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
116
      switch (UnOp->getOpcode()) {
86
116
      
case UO_PostInc: 0
DISPATCH0
(UnaryPostInc, UnaryOperator);
87
116
      
case UO_PostDec: 4
DISPATCH4
(UnaryPostDec, UnaryOperator);
88
116
      
case UO_PreInc: 0
DISPATCH0
(UnaryPreInc, UnaryOperator);
89
116
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
90
116
      
case UO_AddrOf: 4
DISPATCH4
(UnaryAddrOf, UnaryOperator);
91
116
      
case UO_Deref: 105
DISPATCH105
(UnaryDeref, UnaryOperator);
92
116
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
93
116
      
case UO_Minus: 2
DISPATCH2
(UnaryMinus, UnaryOperator);
94
116
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
95
116
      
case UO_LNot: 1
DISPATCH1
(UnaryLNot, UnaryOperator);
96
116
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
97
116
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
98
116
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
99
116
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
100
190k
      }
101
190k
    }
102
190k
103
190k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
190k
    switch (S->getStmtClass()) {
105
190k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
190k
#define ABSTRACT_STMT(STMT)
107
190k
#define STMT(CLASS, PARENT)                              \
108
190k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
190k
#include 
"clang/AST/StmtNodes.inc"0
110
190k
    }
111
190k
  }
SemaStmt.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::DeclMatcher, void>::Visit(clang::Stmt*)
Line
Count
Source
42
137k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
137k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
137k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
137k
    // below.
46
137k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
34.5k
      switch (BinOp->getOpcode()) {
48
34.5k
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
49
34.5k
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
50
34.5k
      
case BO_Mul: 1.56k
DISPATCH1.56k
(BinMul, BinaryOperator);
51
34.5k
      
case BO_Div: 756
DISPATCH756
(BinDiv, BinaryOperator);
52
34.5k
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
53
34.5k
      
case BO_Add: 2.35k
DISPATCH2.35k
(BinAdd, BinaryOperator);
54
34.5k
      
case BO_Sub: 40
DISPATCH40
(BinSub, BinaryOperator);
55
34.5k
      
case BO_Shl: 96
DISPATCH96
(BinShl, BinaryOperator);
56
34.5k
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
57
34.5k
58
34.5k
      
case BO_LT: 15.9k
DISPATCH15.9k
(BinLT, BinaryOperator);
59
34.5k
      
case BO_GT: 3.66k
DISPATCH3.66k
(BinGT, BinaryOperator);
60
34.5k
      
case BO_LE: 885
DISPATCH885
(BinLE, BinaryOperator);
61
34.5k
      
case BO_GE: 1.68k
DISPATCH1.68k
(BinGE, BinaryOperator);
62
34.5k
      
case BO_EQ: 22
DISPATCH22
(BinEQ, BinaryOperator);
63
34.5k
      
case BO_NE: 84
DISPATCH84
(BinNE, BinaryOperator);
64
34.5k
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
65
34.5k
66
34.5k
      
case BO_And: 44
DISPATCH44
(BinAnd, BinaryOperator);
67
34.5k
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
68
34.5k
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
69
34.5k
      
case BO_LAnd: 136
DISPATCH136
(BinLAnd, BinaryOperator);
70
34.5k
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
71
34.5k
      
case BO_Assign: 2.97k
DISPATCH2.97k
(BinAssign, BinaryOperator);
72
34.5k
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
73
34.5k
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
74
34.5k
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
75
34.5k
      
case BO_AddAssign: 3.21k
DISPATCH3.21k
(BinAddAssign, CompoundAssignOperator);
76
34.5k
      
case BO_SubAssign: 16
DISPATCH16
(BinSubAssign, CompoundAssignOperator);
77
34.5k
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
78
34.5k
      
case BO_ShrAssign: 44
DISPATCH44
(BinShrAssign, CompoundAssignOperator);
79
34.5k
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
80
34.5k
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
81
34.5k
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
82
34.5k
      
case BO_Comma: 1.01k
DISPATCH1.01k
(BinComma, BinaryOperator);
83
102k
      }
84
102k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
17.1k
      switch (UnOp->getOpcode()) {
86
17.1k
      
case UO_PostInc: 12.5k
DISPATCH12.5k
(UnaryPostInc, UnaryOperator);
87
17.1k
      
case UO_PostDec: 3.86k
DISPATCH3.86k
(UnaryPostDec, UnaryOperator);
88
17.1k
      
case UO_PreInc: 655
DISPATCH655
(UnaryPreInc, UnaryOperator);
89
17.1k
      
case UO_PreDec: 79
DISPATCH79
(UnaryPreDec, UnaryOperator);
90
17.1k
      
case UO_AddrOf: 2
DISPATCH2
(UnaryAddrOf, UnaryOperator);
91
17.1k
      
case UO_Deref: 18
DISPATCH18
(UnaryDeref, UnaryOperator);
92
17.1k
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
93
17.1k
      
case UO_Minus: 2
DISPATCH2
(UnaryMinus, UnaryOperator);
94
17.1k
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
95
17.1k
      
case UO_LNot: 24
DISPATCH24
(UnaryLNot, UnaryOperator);
96
17.1k
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
97
17.1k
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
98
17.1k
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
99
17.1k
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
100
85.4k
      }
101
85.4k
    }
102
85.4k
103
85.4k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
85.4k
    switch (S->getStmtClass()) {
105
85.4k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
85.4k
#define ABSTRACT_STMT(STMT)
107
85.4k
#define STMT(CLASS, PARENT)                              \
108
85.4k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
85.4k
#include 
"clang/AST/StmtNodes.inc"0
110
85.4k
    }
111
85.4k
  }
SemaStmt.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::CommaVisitor, void>::Visit(clang::Stmt*)
Line
Count
Source
42
822
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
822
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
822
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
822
    // below.
46
822
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
180
      switch (BinOp->getOpcode()) {
48
180
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
49
180
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
50
180
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
51
180
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
52
180
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
53
180
      
case BO_Add: 0
DISPATCH0
(BinAdd, BinaryOperator);
54
180
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
55
180
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
56
180
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
57
180
58
180
      
case BO_LT: 140
DISPATCH140
(BinLT, BinaryOperator);
59
180
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
60
180
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
61
180
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
62
180
      
case BO_EQ: 5
DISPATCH5
(BinEQ, BinaryOperator);
63
180
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
64
180
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
65
180
66
180
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
67
180
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
68
180
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
69
180
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
70
180
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
71
180
      
case BO_Assign: 0
DISPATCH0
(BinAssign, BinaryOperator);
72
180
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
73
180
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
74
180
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
75
180
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
76
180
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
77
180
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
78
180
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
79
180
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
80
180
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
81
180
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
82
180
      
case BO_Comma: 35
DISPATCH35
(BinComma, BinaryOperator);
83
642
      }
84
642
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
0
      switch (UnOp->getOpcode()) {
86
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
87
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
88
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
89
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
90
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
91
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
92
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
93
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
94
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
95
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
96
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
97
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
98
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
99
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
100
642
      }
101
642
    }
102
642
103
642
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
642
    switch (S->getStmtClass()) {
105
642
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
642
#define ABSTRACT_STMT(STMT)
107
642
#define STMT(CLASS, PARENT)                              \
108
642
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
642
#include 
"clang/AST/StmtNodes.inc"0
110
642
    }
111
642
  }
AnalysisDeclContext.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::FindBlockDeclRefExprsVals, void>::Visit(clang::Stmt*)
Line
Count
Source
42
2.38k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
2.38k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
2.38k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
2.38k
    // below.
46
2.38k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
164
      switch (BinOp->getOpcode()) {
48
164
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
49
164
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
50
164
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
51
164
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
52
164
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
53
164
      
case BO_Add: 22
DISPATCH22
(BinAdd, BinaryOperator);
54
164
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
55
164
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
56
164
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
57
164
58
164
      
case BO_LT: 4
DISPATCH4
(BinLT, BinaryOperator);
59
164
      
case BO_GT: 6
DISPATCH6
(BinGT, BinaryOperator);
60
164
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
61
164
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
62
164
      
case BO_EQ: 12
DISPATCH12
(BinEQ, BinaryOperator);
63
164
      
case BO_NE: 2
DISPATCH2
(BinNE, BinaryOperator);
64
164
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
65
164
66
164
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
67
164
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
68
164
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
69
164
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
70
164
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
71
164
      
case BO_Assign: 118
DISPATCH118
(BinAssign, BinaryOperator);
72
164
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
73
164
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
74
164
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
75
164
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
76
164
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
77
164
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
78
164
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
79
164
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
80
164
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
81
164
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
82
164
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
83
2.21k
      }
84
2.21k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
75
      switch (UnOp->getOpcode()) {
86
75
      
case UO_PostInc: 2
DISPATCH2
(UnaryPostInc, UnaryOperator);
87
75
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
88
75
      
case UO_PreInc: 12
DISPATCH12
(UnaryPreInc, UnaryOperator);
89
75
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
90
75
      
case UO_AddrOf: 9
DISPATCH9
(UnaryAddrOf, UnaryOperator);
91
75
      
case UO_Deref: 52
DISPATCH52
(UnaryDeref, UnaryOperator);
92
75
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
93
75
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
94
75
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
95
75
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
96
75
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
97
75
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
98
75
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
99
75
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
100
2.14k
      }
101
2.14k
    }
102
2.14k
103
2.14k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
2.14k
    switch (S->getStmtClass()) {
105
2.14k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
2.14k
#define ABSTRACT_STMT(STMT)
107
2.14k
#define STMT(CLASS, PARENT)                              \
108
2.14k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
2.14k
#include 
"clang/AST/StmtNodes.inc"0
110
2.14k
    }
111
2.14k
  }
CFG.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::CFGBlockTerminatorPrint, void>::Visit(clang::Stmt*)
Line
Count
Source
42
519
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
519
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
519
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
519
    // below.
46
519
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
36
      switch (BinOp->getOpcode()) {
48
36
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
49
36
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
50
36
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
51
36
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
52
36
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
53
36
      
case BO_Add: 0
DISPATCH0
(BinAdd, BinaryOperator);
54
36
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
55
36
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
56
36
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
57
36
58
36
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
59
36
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
60
36
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
61
36
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
62
36
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
63
36
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
64
36
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
65
36
66
36
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
67
36
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
68
36
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
69
36
      
case BO_LAnd: 8
DISPATCH8
(BinLAnd, BinaryOperator);
70
36
      
case BO_LOr : 28
DISPATCH28
(BinLOr, BinaryOperator);
71
36
      
case BO_Assign: 0
DISPATCH0
(BinAssign, BinaryOperator);
72
36
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
73
36
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
74
36
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
75
36
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
76
36
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
77
36
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
78
36
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
79
36
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
80
36