Coverage Report

Created: 2019-07-24 05:18

/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
230M
  return static_cast<ImplClass*>(this)->Visit ## NAME( \
40
230M
    static_cast<PTR(CLASS)>(S), std::forward<ParamTys>(P)...)
41
42
148M
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
148M
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
148M
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
148M
    // below.
46
148M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
14.7M
      switch (BinOp->getOpcode()) {
48
14.7M
      
case BO_PtrMemD: 86.5k
DISPATCH86.5k
(BinPtrMemD, BinaryOperator);
49
14.7M
      
case BO_PtrMemI: 432
DISPATCH432
(BinPtrMemI, BinaryOperator);
50
14.7M
      
case BO_Mul: 560k
DISPATCH560k
(BinMul, BinaryOperator);
51
14.7M
      
case BO_Div: 495k
DISPATCH495k
(BinDiv, BinaryOperator);
52
14.7M
      
case BO_Rem: 43.4k
DISPATCH43.4k
(BinRem, BinaryOperator);
53
14.7M
      
case BO_Add: 1.53M
DISPATCH1.53M
(BinAdd, BinaryOperator);
54
14.7M
      
case BO_Sub: 1.60M
DISPATCH1.60M
(BinSub, BinaryOperator);
55
14.7M
      
case BO_Shl: 417k
DISPATCH417k
(BinShl, BinaryOperator);
56
14.7M
      
case BO_Shr: 169k
DISPATCH169k
(BinShr, BinaryOperator);
57
14.7M
58
14.7M
      
case BO_LT: 903k
DISPATCH903k
(BinLT, BinaryOperator);
59
14.7M
      
case BO_GT: 628k
DISPATCH628k
(BinGT, BinaryOperator);
60
14.7M
      
case BO_LE: 246k
DISPATCH246k
(BinLE, BinaryOperator);
61
14.7M
      
case BO_GE: 192k
DISPATCH192k
(BinGE, BinaryOperator);
62
14.7M
      
case BO_EQ: 1.11M
DISPATCH1.11M
(BinEQ, BinaryOperator);
63
14.7M
      
case BO_NE: 531k
DISPATCH531k
(BinNE, BinaryOperator);
64
14.7M
      
case BO_Cmp: 477
DISPATCH477
(BinCmp, BinaryOperator);
65
14.7M
66
14.7M
      
case BO_And: 324k
DISPATCH324k
(BinAnd, BinaryOperator);
67
14.7M
      
case BO_Xor: 64.7k
DISPATCH64.7k
(BinXor, BinaryOperator);
68
14.7M
      
case BO_Or : 183k
DISPATCH183k
(BinOr, BinaryOperator);
69
14.7M
      
case BO_LAnd: 1.23M
DISPATCH1.23M
(BinLAnd, BinaryOperator);
70
14.7M
      
case BO_LOr : 473k
DISPATCH473k
(BinLOr, BinaryOperator);
71
14.7M
      
case BO_Assign: 3.40M
DISPATCH3.40M
(BinAssign, BinaryOperator);
72
14.7M
      
case BO_MulAssign: 15.1k
DISPATCH15.1k
(BinMulAssign, CompoundAssignOperator);
73
14.7M
      
case BO_DivAssign: 4.92k
DISPATCH4.92k
(BinDivAssign, CompoundAssignOperator);
74
14.7M
      
case BO_RemAssign: 791
DISPATCH791
(BinRemAssign, CompoundAssignOperator);
75
14.7M
      
case BO_AddAssign: 164k
DISPATCH164k
(BinAddAssign, CompoundAssignOperator);
76
14.7M
      
case BO_SubAssign: 22.0k
DISPATCH22.0k
(BinSubAssign, CompoundAssignOperator);
77
14.7M
      
case BO_ShlAssign: 7.56k
DISPATCH7.56k
(BinShlAssign, CompoundAssignOperator);
78
14.7M
      
case BO_ShrAssign: 3.95k
DISPATCH3.95k
(BinShrAssign, CompoundAssignOperator);
79
14.7M
      
case BO_AndAssign: 9.10k
DISPATCH9.10k
(BinAndAssign, CompoundAssignOperator);
80
14.7M
      
case BO_OrAssign: 57.6k
DISPATCH57.6k
(BinOrAssign, CompoundAssignOperator);
81
14.7M
      
case BO_XorAssign: 6.04k
DISPATCH6.04k
(BinXorAssign, CompoundAssignOperator);
82
14.7M
      
case BO_Comma: 206k
DISPATCH206k
(BinComma, BinaryOperator);
83
133M
      }
84
133M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
4.73M
      switch (UnOp->getOpcode()) {
86
4.73M
      
case UO_PostInc: 284k
DISPATCH284k
(UnaryPostInc, UnaryOperator);
87
4.73M
      
case UO_PostDec: 21.2k
DISPATCH21.2k
(UnaryPostDec, UnaryOperator);
88
4.73M
      
case UO_PreInc: 217k
DISPATCH217k
(UnaryPreInc, UnaryOperator);
89
4.73M
      
case UO_PreDec: 33.8k
DISPATCH33.8k
(UnaryPreDec, UnaryOperator);
90
4.73M
      
case UO_AddrOf: 451k
DISPATCH451k
(UnaryAddrOf, UnaryOperator);
91
4.73M
      
case UO_Deref: 534k
DISPATCH534k
(UnaryDeref, UnaryOperator);
92
4.73M
      
case UO_Plus: 1.19k
DISPATCH1.19k
(UnaryPlus, UnaryOperator);
93
4.73M
      
case UO_Minus: 582k
DISPATCH582k
(UnaryMinus, UnaryOperator);
94
4.73M
      
case UO_Not: 92.7k
DISPATCH92.7k
(UnaryNot, UnaryOperator);
95
4.73M
      
case UO_LNot: 2.47M
DISPATCH2.47M
(UnaryLNot, UnaryOperator);
96
4.73M
      
case UO_Real: 3.42k
DISPATCH3.42k
(UnaryReal, UnaryOperator);
97
4.73M
      
case UO_Imag: 3.37k
DISPATCH3.37k
(UnaryImag, UnaryOperator);
98
4.73M
      
case UO_Extension: 37.6k
DISPATCH37.6k
(UnaryExtension, UnaryOperator);
99
4.73M
      
case UO_Coawait: 10
DISPATCH10
(UnaryCoawait, UnaryOperator);
100
129M
      }
101
129M
    }
102
129M
103
129M
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
129M
    switch (S->getStmtClass()) {
105
129M
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
129M
#define ABSTRACT_STMT(STMT)
107
129M
#define STMT(CLASS, PARENT)                              \
108
129M
    case Stmt::CLASS ## Class: 
DISPATCH129M
(CLASS, CLASS);
109
129M
#include 
"clang/AST/StmtNodes.inc"43.9k
110
129M
    }
111
129M
  }
CGClass.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::DynamicThisUseChecker, void>::Visit(clang::Stmt const*)
Line
Count
Source
42
32.9k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
32.9k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
32.9k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
32.9k
    // below.
46
32.9k
    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
32.9k
      }
84
32.9k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
126
      switch (UnOp->getOpcode()) {
86
126
      
case UO_PostInc: 0
DISPATCH0
(UnaryPostInc, UnaryOperator);
87
126
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
88
126
      
case UO_PreInc: 0
DISPATCH0
(UnaryPreInc, UnaryOperator);
89
126
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
90
126
      
case UO_AddrOf: 121
DISPATCH121
(UnaryAddrOf, UnaryOperator);
91
126
      
case UO_Deref: 5
DISPATCH5
(UnaryDeref, UnaryOperator);
92
126
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
93
126
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
94
126
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
95
126
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
96
126
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
97
126
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
98
126
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
99
126
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
100
32.8k
      }
101
32.8k
    }
102
32.8k
103
32.8k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
32.8k
    switch (S->getStmtClass()) {
105
32.8k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
32.8k
#define ABSTRACT_STMT(STMT)
107
32.8k
#define STMT(CLASS, PARENT)                              \
108
32.8k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
32.8k
#include 
"clang/AST/StmtNodes.inc"0
110
32.8k
    }
111
32.8k
  }
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
216k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
216k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
216k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
216k
    // below.
46
216k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
1.42k
      switch (BinOp->getOpcode()) {
48
1.42k
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
49
1.42k
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
50
1.42k
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
51
1.42k
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
52
1.42k
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
53
1.42k
      
case BO_Add: 0
DISPATCH0
(BinAdd, BinaryOperator);
54
1.42k
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
55
1.42k
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
56
1.42k
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
57
1.42k
58
1.42k
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
59
1.42k
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
60
1.42k
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
61
1.42k
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
62
1.42k
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
63
1.42k
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
64
1.42k
      
case BO_Cmp: 17
DISPATCH17
(BinCmp, BinaryOperator);
65
1.42k
66
1.42k
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
67
1.42k
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
68
1.42k
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
69
1.42k
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
70
1.42k
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
71
1.42k
      
case BO_Assign: 1.35k
DISPATCH1.35k
(BinAssign, BinaryOperator);
72
1.42k
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
73
1.42k
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
74
1.42k
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
75
1.42k
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
76
1.42k
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
77
1.42k
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
78
1.42k
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
79
1.42k
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
80
1.42k
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
81
1.42k
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
82
1.42k
      
case BO_Comma: 52
DISPATCH52
(BinComma, BinaryOperator);
83
214k
      }
84
214k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
1.10k
      switch (UnOp->getOpcode()) {
86
1.10k
      
case UO_PostInc: 0
DISPATCH0
(UnaryPostInc, UnaryOperator);
87
1.10k
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
88
1.10k
      
case UO_PreInc: 0
DISPATCH0
(UnaryPreInc, UnaryOperator);
89
1.10k
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
90
1.10k
      
case UO_AddrOf: 0
DISPATCH0
(UnaryAddrOf, UnaryOperator);
91
1.10k
      
case UO_Deref: 278
DISPATCH278
(UnaryDeref, UnaryOperator);
92
1.10k
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
93
1.10k
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
94
1.10k
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
95
1.10k
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
96
1.10k
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
97
1.10k
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
98
1.10k
      
case UO_Extension: 825
DISPATCH825
(UnaryExtension, UnaryOperator);
99
1.10k
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
100
213k
      }
101
213k
    }
102
213k
103
213k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
213k
    switch (S->getStmtClass()) {
105
213k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
213k
#define ABSTRACT_STMT(STMT)
107
213k
#define STMT(CLASS, PARENT)                              \
108
213k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
213k
#include 
"clang/AST/StmtNodes.inc"0
110
213k
    }
111
213k
  }
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.55k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
4.55k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
4.55k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
4.55k
    // below.
46
4.55k
    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.81k
      }
84
3.81k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
40
      switch (UnOp->getOpcode()) {
86
40
      
case UO_PostInc: 2
DISPATCH2
(UnaryPostInc, UnaryOperator);
87
40
      
case UO_PostDec: 2
DISPATCH2
(UnaryPostDec, UnaryOperator);
88
40
      
case UO_PreInc: 2
DISPATCH2
(UnaryPreInc, UnaryOperator);
89
40
      
case UO_PreDec: 2
DISPATCH2
(UnaryPreDec, UnaryOperator);
90
40
      
case UO_AddrOf: 0
DISPATCH0
(UnaryAddrOf, UnaryOperator);
91
40
      
case UO_Deref: 8
DISPATCH8
(UnaryDeref, UnaryOperator);
92
40
      
case UO_Plus: 5
DISPATCH5
(UnaryPlus, UnaryOperator);
93
40
      
case UO_Minus: 4
DISPATCH4
(UnaryMinus, UnaryOperator);
94
40
      
case UO_Not: 3
DISPATCH3
(UnaryNot, UnaryOperator);
95
40
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
96
40
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
97
40
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
98
40
      
case UO_Extension: 12
DISPATCH12
(UnaryExtension, UnaryOperator);
99
40
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
100
3.77k
      }
101
3.77k
    }
102
3.77k
103
3.77k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
3.77k
    switch (S->getStmtClass()) {
105
3.77k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
3.77k
#define ABSTRACT_STMT(STMT)
107
3.77k
#define STMT(CLASS, PARENT)                              \
108
3.77k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
3.77k
#include 
"clang/AST/StmtNodes.inc"0
110
3.77k
    }
111
3.77k
  }
CGExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::ConstantLValueEmitter, (anonymous namespace)::ConstantLValue>::Visit(clang::Stmt const*)
Line
Count
Source
42
14.6k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
14.6k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
14.6k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
14.6k
    // below.
46
14.6k
    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.6k
      }
84
14.6k
    } 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.6k
      }
101
14.6k
    }
102
14.6k
103
14.6k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
14.6k
    switch (S->getStmtClass()) {
105
14.6k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
14.6k
#define ABSTRACT_STMT(STMT)
107
14.6k
#define STMT(CLASS, PARENT)                              \
108
14.6k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
14.6k
#include 
"clang/AST/StmtNodes.inc"0
110
14.6k
    }
111
14.6k
  }
CGExprConstant.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::ConstExprEmitter, llvm::Constant*, clang::QualType>::Visit(clang::Stmt*, clang::QualType)
Line
Count
Source
42
49.3k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
49.3k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
49.3k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
49.3k
    // below.
46
49.3k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
898
      switch (BinOp->getOpcode()) {
48
898
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
49
898
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
50
898
      
case BO_Mul: 124
DISPATCH124
(BinMul, BinaryOperator);
51
898
      
case BO_Div: 66
DISPATCH66
(BinDiv, BinaryOperator);
52
898
      
case BO_Rem: 11
DISPATCH11
(BinRem, BinaryOperator);
53
898
      
case BO_Add: 179
DISPATCH179
(BinAdd, BinaryOperator);
54
898
      
case BO_Sub: 215
DISPATCH215
(BinSub, BinaryOperator);
55
898
      
case BO_Shl: 1
DISPATCH1
(BinShl, BinaryOperator);
56
898
      
case BO_Shr: 77
DISPATCH77
(BinShr, BinaryOperator);
57
898
58
898
      
case BO_LT: 4
DISPATCH4
(BinLT, BinaryOperator);
59
898
      
case BO_GT: 4
DISPATCH4
(BinGT, BinaryOperator);
60
898
      
case BO_LE: 1
DISPATCH1
(BinLE, BinaryOperator);
61
898
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
62
898
      
case BO_EQ: 24
DISPATCH24
(BinEQ, BinaryOperator);
63
898
      
case BO_NE: 2
DISPATCH2
(BinNE, BinaryOperator);
64
898
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
65
898
66
898
      
case BO_And: 123
DISPATCH123
(BinAnd, BinaryOperator);
67
898
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
68
898
      
case BO_Or : 1
DISPATCH1
(BinOr, BinaryOperator);
69
898
      
case BO_LAnd: 3
DISPATCH3
(BinLAnd, BinaryOperator);
70
898
      
case BO_LOr : 51
DISPATCH51
(BinLOr, BinaryOperator);
71
898
      
case BO_Assign: 5
DISPATCH5
(BinAssign, BinaryOperator);
72
898
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
73
898
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
74
898
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
75
898
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
76
898
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
77
898
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
78
898
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
79
898
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
80
898
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
81
898
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
82
898
      
case BO_Comma: 7
DISPATCH7
(BinComma, BinaryOperator);
83
48.4k
      }
84
48.4k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
69
      switch (UnOp->getOpcode()) {
86
69
      
case UO_PostInc: 1
DISPATCH1
(UnaryPostInc, UnaryOperator);
87
69
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
88
69
      
case UO_PreInc: 2
DISPATCH2
(UnaryPreInc, UnaryOperator);
89
69
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
90
69
      
case UO_AddrOf: 33
DISPATCH33
(UnaryAddrOf, UnaryOperator);
91
69
      
case UO_Deref: 29
DISPATCH29
(UnaryDeref, UnaryOperator);
92
69
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
93
69
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
94
69
      
case UO_Not: 3
DISPATCH3
(UnaryNot, UnaryOperator);
95
69
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
96
69
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
97
69
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
98
69
      
case UO_Extension: 1
DISPATCH1
(UnaryExtension, UnaryOperator);
99
69
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
100
48.4k
      }
101
48.4k
    }
102
48.4k
103
48.4k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
48.4k
    switch (S->getStmtClass()) {
105
48.4k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
48.4k
#define ABSTRACT_STMT(STMT)
107
48.4k
#define STMT(CLASS, PARENT)                              \
108
48.4k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
48.4k
#include 
"clang/AST/StmtNodes.inc"0
110
48.4k
    }
111
48.4k
  }
CGExprScalar.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::ScalarExprEmitter, llvm::Value*>::Visit(clang::Stmt*)
Line
Count
Source
42
9.70M
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
9.70M
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
9.70M
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
9.70M
    // below.
46
9.70M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
1.09M
      switch (BinOp->getOpcode()) {
48
1.09M
      
case BO_PtrMemD: 24
DISPATCH24
(BinPtrMemD, BinaryOperator);
49
1.09M
      
case BO_PtrMemI: 15
DISPATCH15
(BinPtrMemI, BinaryOperator);
50
1.09M
      
case BO_Mul: 72.9k
DISPATCH72.9k
(BinMul, BinaryOperator);
51
1.09M
      
case BO_Div: 47.9k
DISPATCH47.9k
(BinDiv, BinaryOperator);
52
1.09M
      
case BO_Rem: 3.44k
DISPATCH3.44k
(BinRem, BinaryOperator);
53
1.09M
      
case BO_Add: 155k
DISPATCH155k
(BinAdd, BinaryOperator);
54
1.09M
      
case BO_Sub: 160k
DISPATCH160k
(BinSub, BinaryOperator);
55
1.09M
      
case BO_Shl: 28.8k
DISPATCH28.8k
(BinShl, BinaryOperator);
56
1.09M
      
case BO_Shr: 20.6k
DISPATCH20.6k
(BinShr, BinaryOperator);
57
1.09M
58
1.09M
      
case BO_LT: 54.7k
DISPATCH54.7k
(BinLT, BinaryOperator);
59
1.09M
      
case BO_GT: 34.7k
DISPATCH34.7k
(BinGT, BinaryOperator);
60
1.09M
      
case BO_LE: 18.5k
DISPATCH18.5k
(BinLE, BinaryOperator);
61
1.09M
      
case BO_GE: 13.0k
DISPATCH13.0k
(BinGE, BinaryOperator);
62
1.09M
      
case BO_EQ: 79.3k
DISPATCH79.3k
(BinEQ, BinaryOperator);
63
1.09M
      
case BO_NE: 41.4k
DISPATCH41.4k
(BinNE, BinaryOperator);
64
1.09M
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
65
1.09M
66
1.09M
      
case BO_And: 27.0k
DISPATCH27.0k
(BinAnd, BinaryOperator);
67
1.09M
      
case BO_Xor: 7.09k
DISPATCH7.09k
(BinXor, BinaryOperator);
68
1.09M
      
case BO_Or : 11.9k
DISPATCH11.9k
(BinOr, BinaryOperator);
69
1.09M
      
case BO_LAnd: 5.74k
DISPATCH5.74k
(BinLAnd, BinaryOperator);
70
1.09M
      
case BO_LOr : 2.49k
DISPATCH2.49k
(BinLOr, BinaryOperator);
71
1.09M
      
case BO_Assign: 261k
DISPATCH261k
(BinAssign, BinaryOperator);
72
1.09M
      
case BO_MulAssign: 887
DISPATCH887
(BinMulAssign, CompoundAssignOperator);
73
1.09M
      
case BO_DivAssign: 445
DISPATCH445
(BinDivAssign, CompoundAssignOperator);
74
1.09M
      
case BO_RemAssign: 160
DISPATCH160
(BinRemAssign, CompoundAssignOperator);
75
1.09M
      
case BO_AddAssign: 17.3k
DISPATCH17.3k
(BinAddAssign, CompoundAssignOperator);
76
1.09M
      
case BO_SubAssign: 2.83k
DISPATCH2.83k
(BinSubAssign, CompoundAssignOperator);
77
1.09M
      
case BO_ShlAssign: 999
DISPATCH999
(BinShlAssign, CompoundAssignOperator);
78
1.09M
      
case BO_ShrAssign: 888
DISPATCH888
(BinShrAssign, CompoundAssignOperator);
79
1.09M
      
case BO_AndAssign: 778
DISPATCH778
(BinAndAssign, CompoundAssignOperator);
80
1.09M
      
case BO_OrAssign: 2.59k
DISPATCH2.59k
(BinOrAssign, CompoundAssignOperator);
81
1.09M
      
case BO_XorAssign: 878
DISPATCH878
(BinXorAssign, CompoundAssignOperator);
82
1.09M
      
case BO_Comma: 14.4k
DISPATCH14.4k
(BinComma, BinaryOperator);
83
8.61M
      }
84
8.61M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
260k
      switch (UnOp->getOpcode()) {
86
260k
      
case UO_PostInc: 40.6k
DISPATCH40.6k
(UnaryPostInc, UnaryOperator);
87
260k
      
case UO_PostDec: 3.64k
DISPATCH3.64k
(UnaryPostDec, UnaryOperator);
88
260k
      
case UO_PreInc: 3.72k
DISPATCH3.72k
(UnaryPreInc, UnaryOperator);
89
260k
      
case UO_PreDec: 3.04k
DISPATCH3.04k
(UnaryPreDec, UnaryOperator);
90
260k
      
case UO_AddrOf: 61.0k
DISPATCH61.0k
(UnaryAddrOf, UnaryOperator);
91
260k
      
case UO_Deref: 25.3k
DISPATCH25.3k
(UnaryDeref, UnaryOperator);
92
260k
      
case UO_Plus: 156
DISPATCH156
(UnaryPlus, UnaryOperator);
93
260k
      
case UO_Minus: 31.9k
DISPATCH31.9k
(UnaryMinus, UnaryOperator);
94
260k
      
case UO_Not: 6.12k
DISPATCH6.12k
(UnaryNot, UnaryOperator);
95
260k
      
case UO_LNot: 74.6k
DISPATCH74.6k
(UnaryLNot, UnaryOperator);
96
260k
      
case UO_Real: 227
DISPATCH227
(UnaryReal, UnaryOperator);
97
260k
      
case UO_Imag: 214
DISPATCH214
(UnaryImag, UnaryOperator);
98
260k
      
case UO_Extension: 9.48k
DISPATCH9.48k
(UnaryExtension, UnaryOperator);
99
260k
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
100
8.35M
      }
101
8.35M
    }
102
8.35M
103
8.35M
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
8.35M
    switch (S->getStmtClass()) {
105
8.35M
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
8.35M
#define ABSTRACT_STMT(STMT)
107
8.35M
#define STMT(CLASS, PARENT)                              \
108
8.35M
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
8.35M
#include 
"clang/AST/StmtNodes.inc"0
110
8.35M
    }
111
8.35M
  }
CGOpenMPRuntimeNVPTX.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::CheckVarsEscapingDeclContext, void>::Visit(clang::Stmt const*)
Line
Count
Source
42
1.98k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
1.98k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
1.98k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
1.98k
    // below.
46
1.98k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
199
      switch (BinOp->getOpcode()) {
48
199
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
49
199
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
50
199
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
51
199
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
52
199
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
53
199
      
case BO_Add: 29
DISPATCH29
(BinAdd, BinaryOperator);
54
199
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
55
199
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
56
199
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
57
199
58
199
      
case BO_LT: 4
DISPATCH4
(BinLT, BinaryOperator);
59
199
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
60
199
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
61
199
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
62
199
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
63
199
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
64
199
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
65
199
66
199
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
67
199
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
68
199
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
69
199
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
70
199
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
71
199
      
case BO_Assign: 67
DISPATCH67
(BinAssign, BinaryOperator);
72
199
      
case BO_MulAssign: 3
DISPATCH3
(BinMulAssign, CompoundAssignOperator);
73
199
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
74
199
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
75
199
      
case BO_AddAssign: 93
DISPATCH93
(BinAddAssign, CompoundAssignOperator);
76
199
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
77
199
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
78
199
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
79
199
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
80
199
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
81
199
      
case BO_XorAssign: 3
DISPATCH3
(BinXorAssign, CompoundAssignOperator);
82
199
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
83
1.78k
      }
84
1.78k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
24
      switch (UnOp->getOpcode()) {
86
24
      
case UO_PostInc: 5
DISPATCH5
(UnaryPostInc, UnaryOperator);
87
24
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
88
24
      
case UO_PreInc: 12
DISPATCH12
(UnaryPreInc, UnaryOperator);
89
24
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
90
24
      
case UO_AddrOf: 7
DISPATCH7
(UnaryAddrOf, UnaryOperator);
91
24
      
case UO_Deref: 0
DISPATCH0
(UnaryDeref, UnaryOperator);
92
24
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
93
24
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
94
24
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
95
24
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
96
24
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
97
24
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
98
24
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
99
24
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
100
1.76k
      }
101
1.76k
    }
102
1.76k
103
1.76k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
1.76k
    switch (S->getStmtClass()) {
105
1.76k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
1.76k
#define ABSTRACT_STMT(STMT)
107
1.76k
#define STMT(CLASS, PARENT)                              \
108
1.76k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
1.76k
#include 
"clang/AST/StmtNodes.inc"0
110
1.76k
    }
111
1.76k
  }
CodeGenModule.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::FunctionIsDirectlyRecursive, bool>::Visit(clang::Stmt const*)
Line
Count
Source
42
23.3k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
23.3k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
23.3k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
23.3k
    // below.
46
23.3k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
2.23k
      switch (BinOp->getOpcode()) {
48
2.23k
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
49
2.23k
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
50
2.23k
      
case BO_Mul: 75
DISPATCH75
(BinMul, BinaryOperator);
51
2.23k
      
case BO_Div: 8
DISPATCH8
(BinDiv, BinaryOperator);
52
2.23k
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
53
2.23k
      
case BO_Add: 50
DISPATCH50
(BinAdd, BinaryOperator);
54
2.23k
      
case BO_Sub: 59
DISPATCH59
(BinSub, BinaryOperator);
55
2.23k
      
case BO_Shl: 118
DISPATCH118
(BinShl, BinaryOperator);
56
2.23k
      
case BO_Shr: 56
DISPATCH56
(BinShr, BinaryOperator);
57
2.23k
58
2.23k
      
case BO_LT: 96
DISPATCH96
(BinLT, BinaryOperator);
59
2.23k
      
case BO_GT: 12
DISPATCH12
(BinGT, BinaryOperator);
60
2.23k
      
case BO_LE: 20
DISPATCH20
(BinLE, BinaryOperator);
61
2.23k
      
case BO_GE: 64
DISPATCH64
(BinGE, BinaryOperator);
62
2.23k
      
case BO_EQ: 81
DISPATCH81
(BinEQ, BinaryOperator);
63
2.23k
      
case BO_NE: 14
DISPATCH14
(BinNE, BinaryOperator);
64
2.23k
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
65
2.23k
66
2.23k
      
case BO_And: 236
DISPATCH236
(BinAnd, BinaryOperator);
67
2.23k
      
case BO_Xor: 4
DISPATCH4
(BinXor, BinaryOperator);
68
2.23k
      
case BO_Or : 8
DISPATCH8
(BinOr, BinaryOperator);
69
2.23k
      
case BO_LAnd: 10
DISPATCH10
(BinLAnd, BinaryOperator);
70
2.23k
      
case BO_LOr : 50
DISPATCH50
(BinLOr, BinaryOperator);
71
2.23k
      
case BO_Assign: 1.27k
DISPATCH1.27k
(BinAssign, BinaryOperator);
72
2.23k
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
73
2.23k
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
74
2.23k
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
75
2.23k
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
76
2.23k
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
77
2.23k
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
78
2.23k
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
79
2.23k
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
80
2.23k
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
81
2.23k
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
82
2.23k
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
83
21.1k
      }
84
21.1k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
495
      switch (UnOp->getOpcode()) {
86
495
      
case UO_PostInc: 0
DISPATCH0
(UnaryPostInc, UnaryOperator);
87
495
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
88
495
      
case UO_PreInc: 6
DISPATCH6
(UnaryPreInc, UnaryOperator);
89
495
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
90
495
      
case UO_AddrOf: 0
DISPATCH0
(UnaryAddrOf, UnaryOperator);
91
495
      
case UO_Deref: 37
DISPATCH37
(UnaryDeref, UnaryOperator);
92
495
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
93
495
      
case UO_Minus: 8
DISPATCH8
(UnaryMinus, UnaryOperator);
94
495
      
case UO_Not: 68
DISPATCH68
(UnaryNot, UnaryOperator);
95
495
      
case UO_LNot: 332
DISPATCH332
(UnaryLNot, UnaryOperator);
96
495
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
97
495
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
98
495
      
case UO_Extension: 44
DISPATCH44
(UnaryExtension, UnaryOperator);
99
495
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
100
20.6k
      }
101
20.6k
    }
102
20.6k
103
20.6k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
20.6k
    switch (S->getStmtClass()) {
105
20.6k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
20.6k
#define ABSTRACT_STMT(STMT)
107
20.6k
#define STMT(CLASS, PARENT)                              \
108
20.6k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
20.6k
#include 
"clang/AST/StmtNodes.inc"38
110
20.6k
    }
111
20.6k
  }
CodeGenPGO.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::ComputeRegionCounts, void>::Visit(clang::Stmt const*)
Line
Count
Source
42
3.53k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
3.53k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
3.53k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
3.53k
    // below.
46
3.53k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
334
      switch (BinOp->getOpcode()) {
48
334
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
49
334
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
50
334
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
51
334
      
case BO_Div: 4
DISPATCH4
(BinDiv, BinaryOperator);
52
334
      
case BO_Rem: 33
DISPATCH33
(BinRem, BinaryOperator);
53
334
      
case BO_Add: 22
DISPATCH22
(BinAdd, BinaryOperator);
54
334
      
case BO_Sub: 16
DISPATCH16
(BinSub, BinaryOperator);
55
334
      
case BO_Shl: 3
DISPATCH3
(BinShl, BinaryOperator);
56
334
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
57
334
58
334
      
case BO_LT: 89
DISPATCH89
(BinLT, BinaryOperator);
59
334
      
case BO_GT: 22
DISPATCH22
(BinGT, BinaryOperator);
60
334
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
61
334
      
case BO_GE: 1
DISPATCH1
(BinGE, BinaryOperator);
62
334
      
case BO_EQ: 5
DISPATCH5
(BinEQ, BinaryOperator);
63
334
      
case BO_NE: 9
DISPATCH9
(BinNE, BinaryOperator);
64
334
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
65
334
66
334
      
case BO_And: 2
DISPATCH2
(BinAnd, BinaryOperator);
67
334
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
68
334
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
69
334
      
case BO_LAnd: 19
DISPATCH19
(BinLAnd, BinaryOperator);
70
334
      
case BO_LOr : 18
DISPATCH18
(BinLOr, BinaryOperator);
71
334
      
case BO_Assign: 76
DISPATCH76
(BinAssign, BinaryOperator);
72
334
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
73
334
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
74
334
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
75
334
      
case BO_AddAssign: 15
DISPATCH15
(BinAddAssign, CompoundAssignOperator);
76
334
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
77
334
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
78
334
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
79
334
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
80
334
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
81
334
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
82
334
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
83
3.19k
      }
84
3.19k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
148
      switch (UnOp->getOpcode()) {
86
148
      
case UO_PostInc: 33
DISPATCH33
(UnaryPostInc, UnaryOperator);
87
148
      
case UO_PostDec: 9
DISPATCH9
(UnaryPostDec, UnaryOperator);
88
148
      
case UO_PreInc: 82
DISPATCH82
(UnaryPreInc, UnaryOperator);
89
148
      
case UO_PreDec: 8
DISPATCH8
(UnaryPreDec, UnaryOperator);
90
148
      
case UO_AddrOf: 0
DISPATCH0
(UnaryAddrOf, UnaryOperator);
91
148
      
case UO_Deref: 9
DISPATCH9
(UnaryDeref, UnaryOperator);
92
148
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
93
148
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
94
148
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
95
148
      
case UO_LNot: 7
DISPATCH7
(UnaryLNot, UnaryOperator);
96
148
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
97
148
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
98
148
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
99
148
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
100
3.04k
      }
101
3.04k
    }
102
3.04k
103
3.04k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
3.04k
    switch (S->getStmtClass()) {
105
3.04k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
3.04k
#define ABSTRACT_STMT(STMT)
107
3.04k
#define STMT(CLASS, PARENT)                              \
108
3.04k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
3.04k
#include 
"clang/AST/StmtNodes.inc"0
110
3.04k
    }
111
3.04k
  }
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
564k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
564k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
564k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
564k
    // below.
46
564k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
109k
      switch (BinOp->getOpcode()) {
48
109k
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
49
109k
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
50
109k
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
51
109k
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
52
109k
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
53
109k
      
case BO_Add: 0
DISPATCH0
(BinAdd, BinaryOperator);
54
109k
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
55
109k
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
56
109k
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
57
109k
58
109k
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
59
109k
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
60
109k
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
61
109k
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
62
109k
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
63
109k
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
64
109k
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
65
109k
66
109k
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
67
109k
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
68
109k
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
69
109k
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
70
109k
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
71
109k
      
case BO_Assign: 0
DISPATCH0
(BinAssign, BinaryOperator);
72
109k
      
case BO_MulAssign: 4.24k
DISPATCH4.24k
(BinMulAssign, CompoundAssignOperator);
73
109k
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
74
109k
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
75
109k
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
76
109k
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
77
109k
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
78
109k
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
79
109k
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
80
109k
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
81
109k
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
82
109k
      
case BO_Comma: 104k
DISPATCH104k
(BinComma, BinaryOperator);
83
455k
      }
84
455k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
10.0k
      switch (UnOp->getOpcode()) {
86
10.0k
      
case UO_PostInc: 0
DISPATCH0
(UnaryPostInc, UnaryOperator);
87
10.0k
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
88
10.0k
      
case UO_PreInc: 0
DISPATCH0
(UnaryPreInc, UnaryOperator);
89
10.0k
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
90
10.0k
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
91
10.0k
      
case UO_Deref: 0
DISPATCH0
(UnaryDeref, UnaryOperator);
92
10.0k
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
93
10.0k
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
94
10.0k
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
95
10.0k
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
96
10.0k
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
97
10.0k
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
98
10.0k
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
99
10.0k
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
100
445k
      }
101
445k
    }
102
445k
103
445k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
445k
    switch (S->getStmtClass()) {
105
445k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
445k
#define ABSTRACT_STMT(STMT)
107
445k
#define STMT(CLASS, PARENT)                              \
108
445k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
445k
#include 
"clang/AST/StmtNodes.inc"9
110
445k
    }
111
445k
  }
clang::StmtVisitorBase<std::__1::add_pointer, clang::ASTStmtWriter, void>::Visit(clang::Stmt*)
Line
Count
Source
42
1.06M
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
1.06M
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
1.06M
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
1.06M
    // below.
46
1.06M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
118k
      switch (BinOp->getOpcode()) {
48
118k
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
49
118k
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
50
118k
      
case BO_Mul: 7.04k
DISPATCH7.04k
(BinMul, BinaryOperator);
51
118k
      
case BO_Div: 6.14k
DISPATCH6.14k
(BinDiv, BinaryOperator);
52
118k
      
case BO_Rem: 21
DISPATCH21
(BinRem, BinaryOperator);
53
118k
      
case BO_Add: 27.2k
DISPATCH27.2k
(BinAdd, BinaryOperator);
54
118k
      
case BO_Sub: 17.1k
DISPATCH17.1k
(BinSub, BinaryOperator);
55
118k
      
case BO_Shl: 33
DISPATCH33
(BinShl, BinaryOperator);
56
118k
      
case BO_Shr: 38
DISPATCH38
(BinShr, BinaryOperator);
57
118k
58
118k
      
case BO_LT: 8.30k
DISPATCH8.30k
(BinLT, BinaryOperator);
59
118k
      
case BO_GT: 4.98k
DISPATCH4.98k
(BinGT, BinaryOperator);
60
118k
      
case BO_LE: 4.27k
DISPATCH4.27k
(BinLE, BinaryOperator);
61
118k
      
case BO_GE: 208
DISPATCH208
(BinGE, BinaryOperator);
62
118k
      
case BO_EQ: 161
DISPATCH161
(BinEQ, BinaryOperator);
63
118k
      
case BO_NE: 34
DISPATCH34
(BinNE, BinaryOperator);
64
118k
      
case BO_Cmp: 2
DISPATCH2
(BinCmp, BinaryOperator);
65
118k
66
118k
      
case BO_And: 502
DISPATCH502
(BinAnd, BinaryOperator);
67
118k
      
case BO_Xor: 167
DISPATCH167
(BinXor, BinaryOperator);
68
118k
      
case BO_Or : 393
DISPATCH393
(BinOr, BinaryOperator);
69
118k
      
case BO_LAnd: 213
DISPATCH213
(BinLAnd, BinaryOperator);
70
118k
      
case BO_LOr : 10
DISPATCH10
(BinLOr, BinaryOperator);
71
118k
      
case BO_Assign: 37.6k
DISPATCH37.6k
(BinAssign, BinaryOperator);
72
118k
      
case BO_MulAssign: 62
DISPATCH62
(BinMulAssign, CompoundAssignOperator);
73
118k
      
case BO_DivAssign: 58
DISPATCH58
(BinDivAssign, CompoundAssignOperator);
74
118k
      
case BO_RemAssign: 4
DISPATCH4
(BinRemAssign, CompoundAssignOperator);
75
118k
      
case BO_AddAssign: 4.04k
DISPATCH4.04k
(BinAddAssign, CompoundAssignOperator);
76
118k
      
case BO_SubAssign: 120
DISPATCH120
(BinSubAssign, CompoundAssignOperator);
77
118k
      
case BO_ShlAssign: 4
DISPATCH4
(BinShlAssign, CompoundAssignOperator);
78
118k
      
case BO_ShrAssign: 4
DISPATCH4
(BinShrAssign, CompoundAssignOperator);
79
118k
      
case BO_AndAssign: 4
DISPATCH4
(BinAndAssign, CompoundAssignOperator);
80
118k
      
case BO_OrAssign: 8
DISPATCH8
(BinOrAssign, CompoundAssignOperator);
81
118k
      
case BO_XorAssign: 8
DISPATCH8
(BinXorAssign, CompoundAssignOperator);
82
118k
      
case BO_Comma: 80
DISPATCH80
(BinComma, BinaryOperator);
83
950k
      }
84
950k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
14.4k
      switch (UnOp->getOpcode()) {
86
14.4k
      
case UO_PostInc: 1.84k
DISPATCH1.84k
(UnaryPostInc, UnaryOperator);
87
14.4k
      
case UO_PostDec: 40
DISPATCH40
(UnaryPostDec, UnaryOperator);
88
14.4k
      
case UO_PreInc: 4.28k
DISPATCH4.28k
(UnaryPreInc, UnaryOperator);
89
14.4k
      
case UO_PreDec: 50
DISPATCH50
(UnaryPreDec, UnaryOperator);
90
14.4k
      
case UO_AddrOf: 527
DISPATCH527
(UnaryAddrOf, UnaryOperator);
91
14.4k
      
case UO_Deref: 3.66k
DISPATCH3.66k
(UnaryDeref, UnaryOperator);
92
14.4k
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
93
14.4k
      
case UO_Minus: 3.32k
DISPATCH3.32k
(UnaryMinus, UnaryOperator);
94
14.4k
      
case UO_Not: 272
DISPATCH272
(UnaryNot, UnaryOperator);
95
14.4k
      
case UO_LNot: 20
DISPATCH20
(UnaryLNot, UnaryOperator);
96
14.4k
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
97
14.4k
      
case UO_Imag: 2
DISPATCH2
(UnaryImag, UnaryOperator);
98
14.4k
      
case UO_Extension: 405
DISPATCH405
(UnaryExtension, UnaryOperator);
99
14.4k
      
case UO_Coawait: 5
DISPATCH5
(UnaryCoawait, UnaryOperator);
100
935k
      }
101
935k
    }
102
935k
103
935k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
935k
    switch (S->getStmtClass()) {
105
935k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
935k
#define ABSTRACT_STMT(STMT)
107
935k
#define STMT(CLASS, PARENT)                              \
108
935k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
935k
#include 
"clang/AST/StmtNodes.inc"38
110
935k
    }
111
935k
  }
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.5k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
38.5k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
38.5k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
38.5k
    // below.
46
38.5k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
2.08k
      switch (BinOp->getOpcode()) {
48
2.08k
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
49
2.08k
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
50
2.08k
      
case BO_Mul: 116
DISPATCH116
(BinMul, BinaryOperator);
51
2.08k
      
case BO_Div: 26
DISPATCH26
(BinDiv, BinaryOperator);
52
2.08k
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
53
2.08k
      
case BO_Add: 223
DISPATCH223
(BinAdd, BinaryOperator);
54
2.08k
      
case BO_Sub: 50
DISPATCH50
(BinSub, BinaryOperator);
55
2.08k
      
case BO_Shl: 2
DISPATCH2
(BinShl, BinaryOperator);
56
2.08k
      
case BO_Shr: 2
DISPATCH2
(BinShr, BinaryOperator);
57
2.08k
58
2.08k
      
case BO_LT: 169
DISPATCH169
(BinLT, BinaryOperator);
59
2.08k
      
case BO_GT: 102
DISPATCH102
(BinGT, BinaryOperator);
60
2.08k
      
case BO_LE: 43
DISPATCH43
(BinLE, BinaryOperator);
61
2.08k
      
case BO_GE: 103
DISPATCH103
(BinGE, BinaryOperator);
62
2.08k
      
case BO_EQ: 966
DISPATCH966
(BinEQ, BinaryOperator);
63
2.08k
      
case BO_NE: 86
DISPATCH86
(BinNE, BinaryOperator);
64
2.08k
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
65
2.08k
66
2.08k
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
67
2.08k
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
68
2.08k
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
69
2.08k
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
70
2.08k
      
case BO_LOr : 1
DISPATCH1
(BinLOr, BinaryOperator);
71
2.08k
      
case BO_Assign: 173
DISPATCH173
(BinAssign, BinaryOperator);
72
2.08k
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
73
2.08k
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
74
2.08k
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
75
2.08k
      
case BO_AddAssign: 13
DISPATCH13
(BinAddAssign, CompoundAssignOperator);
76
2.08k
      
case BO_SubAssign: 5
DISPATCH5
(BinSubAssign, CompoundAssignOperator);
77
2.08k
      
case BO_ShlAssign: 4
DISPATCH4
(BinShlAssign, CompoundAssignOperator);
78
2.08k
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
79
2.08k
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
80
2.08k
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
81
2.08k
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
82
2.08k
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
83
36.4k
      }
84
36.4k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
551
      switch (UnOp->getOpcode()) {
86
551
      
case UO_PostInc: 38
DISPATCH38
(UnaryPostInc, UnaryOperator);
87
551
      
case UO_PostDec: 6
DISPATCH6
(UnaryPostDec, UnaryOperator);
88
551
      
case UO_PreInc: 0
DISPATCH0
(UnaryPreInc, UnaryOperator);
89
551
      
case UO_PreDec: 1
DISPATCH1
(UnaryPreDec, UnaryOperator);
90
551
      
case UO_AddrOf: 218
DISPATCH218
(UnaryAddrOf, UnaryOperator);
91
551
      
case UO_Deref: 43
DISPATCH43
(UnaryDeref, UnaryOperator);
92
551
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
93
551
      
case UO_Minus: 233
DISPATCH233
(UnaryMinus, UnaryOperator);
94
551
      
case UO_Not: 4
DISPATCH4
(UnaryNot, UnaryOperator);
95
551
      
case UO_LNot: 8
DISPATCH8
(UnaryLNot, UnaryOperator);
96
551
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
97
551
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
98
551
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
99
551
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
100
35.8k
      }
101
35.8k
    }
102
35.8k
103
35.8k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
35.8k
    switch (S->getStmtClass()) {
105
35.8k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
35.8k
#define ABSTRACT_STMT(STMT)
107
35.8k
#define STMT(CLASS, PARENT)                              \
108
35.8k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
35.8k
#include 
"clang/AST/StmtNodes.inc"0
110
35.8k
    }
111
35.8k
  }
CheckSecuritySyntaxOnly.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::WalkAST, void>::Visit(clang::Stmt*)
Line
Count
Source
42
5.99k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
5.99k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
5.99k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
5.99k
    // below.
46
5.99k
    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.85k
      }
84
5.85k
    } 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.74k
      }
101
5.74k
    }
102
5.74k
103
5.74k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
5.74k
    switch (S->getStmtClass()) {
105
5.74k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
5.74k
#define ABSTRACT_STMT(STMT)
107
5.74k
#define STMT(CLASS, PARENT)                              \
108
5.74k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
5.74k
#include 
"clang/AST/StmtNodes.inc"0
110
5.74k
    }
111
5.74k
  }
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: 503
DISPATCH503
(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
842
      switch (UnOp->getOpcode()) {
86
842
      
case UO_PostInc: 44
DISPATCH44
(UnaryPostInc, UnaryOperator);
87
842
      
case UO_PostDec: 7
DISPATCH7
(UnaryPostDec, UnaryOperator);
88
842
      
case UO_PreInc: 36
DISPATCH36
(UnaryPreInc, UnaryOperator);
89
842
      
case UO_PreDec: 4
DISPATCH4
(UnaryPreDec, UnaryOperator);
90
842
      
case UO_AddrOf: 228
DISPATCH228
(UnaryAddrOf, UnaryOperator);
91
842
      
case UO_Deref: 335
DISPATCH335
(UnaryDeref, UnaryOperator);
92
842
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
93
842
      
case UO_Minus: 18
DISPATCH18
(UnaryMinus, UnaryOperator);
94
842
      
case UO_Not: 10
DISPATCH10
(UnaryNot, UnaryOperator);
95
842
      
case UO_LNot: 146
DISPATCH146
(UnaryLNot, UnaryOperator);
96
842
      
case UO_Real: 6
DISPATCH6
(UnaryReal, UnaryOperator);
97
842
      
case UO_Imag: 4
DISPATCH4
(UnaryImag, UnaryOperator);
98
842
      
case UO_Extension: 4
DISPATCH4
(UnaryExtension, UnaryOperator);
99
842
      
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.82k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
2.82k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
2.82k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
2.82k
    // below.
46
2.82k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
97
      switch (BinOp->getOpcode()) {
48
97
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
49
97
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
50
97
      
case BO_Mul: 0
DISPATCH0
(BinMul, BinaryOperator);
51
97
      
case BO_Div: 19
DISPATCH19
(BinDiv, BinaryOperator);
52
97
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
53
97
      
case BO_Add: 8
DISPATCH8
(BinAdd, BinaryOperator);
54
97
      
case BO_Sub: 1
DISPATCH1
(BinSub, BinaryOperator);
55
97
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
56
97
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
57
97
58
97
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
59
97
      
case BO_GT: 1
DISPATCH1
(BinGT, BinaryOperator);
60
97
      
case BO_LE: 1
DISPATCH1
(BinLE, BinaryOperator);
61
97
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
62
97
      
case BO_EQ: 11
DISPATCH11
(BinEQ, BinaryOperator);
63
97
      
case BO_NE: 6
DISPATCH6
(BinNE, BinaryOperator);
64
97
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
65
97
66
97
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
67
97
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
68
97
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
69
97
      
case BO_LAnd: 1
DISPATCH1
(BinLAnd, BinaryOperator);
70
97
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
71
97
      
case BO_Assign: 48
DISPATCH48
(BinAssign, BinaryOperator);
72
97
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
73
97
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
74
97
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
75
97
      
case BO_AddAssign: 1
DISPATCH1
(BinAddAssign, CompoundAssignOperator);
76
97
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
77
97
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
78
97
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
79
97
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
80
97
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
81
97
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
82
97
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
83
2.73k
      }
84
2.73k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
72
      switch (UnOp->getOpcode()) {
86
72
      
case UO_PostInc: 0
DISPATCH0
(UnaryPostInc, UnaryOperator);
87
72
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
88
72
      
case UO_PreInc: 0
DISPATCH0
(UnaryPreInc, UnaryOperator);
89
72
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
90
72
      
case UO_AddrOf: 50
DISPATCH50
(UnaryAddrOf, UnaryOperator);
91
72
      
case UO_Deref: 17
DISPATCH17
(UnaryDeref, UnaryOperator);
92
72
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
93
72
      
case UO_Minus: 0
DISPATCH0
(UnaryMinus, UnaryOperator);
94
72
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
95
72
      
case UO_LNot: 5
DISPATCH5
(UnaryLNot, UnaryOperator);
96
72
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
97
72
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
98
72
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
99
72
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
100
2.65k
      }
101
2.65k
    }
102
2.65k
103
2.65k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
2.65k
    switch (S->getStmtClass()) {
105
2.65k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
2.65k
#define ABSTRACT_STMT(STMT)
107
2.65k
#define STMT(CLASS, PARENT)                              \
108
2.65k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
2.65k
#include 
"clang/AST/StmtNodes.inc"0
110
2.65k
    }
111
2.65k
  }
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
57.5M
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
57.5M
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
57.5M
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
57.5M
    // below.
46
57.5M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
4.78M
      switch (BinOp->getOpcode()) {
48
4.78M
      
case BO_PtrMemD: 320
DISPATCH320
(BinPtrMemD, BinaryOperator);
49
4.78M
      
case BO_PtrMemI: 245
DISPATCH245
(BinPtrMemI, BinaryOperator);
50
4.78M
      
case BO_Mul: 190k
DISPATCH190k
(BinMul, BinaryOperator);
51
4.78M
      
case BO_Div: 231k
DISPATCH231k
(BinDiv, BinaryOperator);
52
4.78M
      
case BO_Rem: 13.6k
DISPATCH13.6k
(BinRem, BinaryOperator);
53
4.78M
      
case BO_Add: 688k
DISPATCH688k
(BinAdd, BinaryOperator);
54
4.78M
      
case BO_Sub: 694k
DISPATCH694k
(BinSub, BinaryOperator);
55
4.78M
      
case BO_Shl: 102k
DISPATCH102k
(BinShl, BinaryOperator);
56
4.78M
      
case BO_Shr: 57.8k
DISPATCH57.8k
(BinShr, BinaryOperator);
57
4.78M
58
4.78M
      
case BO_LT: 231k
DISPATCH231k
(BinLT, BinaryOperator);
59
4.78M
      
case BO_GT: 182k
DISPATCH182k
(BinGT, BinaryOperator);
60
4.78M
      
case BO_LE: 60.4k
DISPATCH60.4k
(BinLE, BinaryOperator);
61
4.78M
      
case BO_GE: 47.0k
DISPATCH47.0k
(BinGE, BinaryOperator);
62
4.78M
      
case BO_EQ: 265k
DISPATCH265k
(BinEQ, BinaryOperator);
63
4.78M
      
case BO_NE: 123k
DISPATCH123k
(BinNE, BinaryOperator);
64
4.78M
      
case BO_Cmp: 181
DISPATCH181
(BinCmp, BinaryOperator);
65
4.78M
66
4.78M
      
case BO_And: 116k
DISPATCH116k
(BinAnd, BinaryOperator);
67
4.78M
      
case BO_Xor: 22.7k
DISPATCH22.7k
(BinXor, BinaryOperator);
68
4.78M
      
case BO_Or : 71.4k
DISPATCH71.4k
(BinOr, BinaryOperator);
69
4.78M
      
case BO_LAnd: 109k
DISPATCH109k
(BinLAnd, BinaryOperator);
70
4.78M
      
case BO_LOr : 54.7k
DISPATCH54.7k
(BinLOr, BinaryOperator);
71
4.78M
      
case BO_Assign: 1.38M
DISPATCH1.38M
(BinAssign, BinaryOperator);
72
4.78M
      
case BO_MulAssign: 4.00k
DISPATCH4.00k
(BinMulAssign, CompoundAssignOperator);
73
4.78M
      
case BO_DivAssign: 1.91k
DISPATCH1.91k
(BinDivAssign, CompoundAssignOperator);
74
4.78M
      
case BO_RemAssign: 272
DISPATCH272
(BinRemAssign, CompoundAssignOperator);
75
4.78M
      
case BO_AddAssign: 54.6k
DISPATCH54.6k
(BinAddAssign, CompoundAssignOperator);
76
4.78M
      
case BO_SubAssign: 8.19k
DISPATCH8.19k
(BinSubAssign, CompoundAssignOperator);
77
4.78M
      
case BO_ShlAssign: 2.26k
DISPATCH2.26k
(BinShlAssign, CompoundAssignOperator);
78
4.78M
      
case BO_ShrAssign: 1.07k
DISPATCH1.07k
(BinShrAssign, CompoundAssignOperator);
79
4.78M
      
case BO_AndAssign: 2.83k
DISPATCH2.83k
(BinAndAssign, CompoundAssignOperator);
80
4.78M
      
case BO_OrAssign: 25.8k
DISPATCH25.8k
(BinOrAssign, CompoundAssignOperator);
81
4.78M
      
case BO_XorAssign: 2.32k
DISPATCH2.32k
(BinXorAssign, CompoundAssignOperator);
82
4.78M
      
case BO_Comma: 22.8k
DISPATCH22.8k
(BinComma, BinaryOperator);
83
52.7M
      }
84
52.7M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
1.43M
      switch (UnOp->getOpcode()) {
86
1.43M
      
case UO_PostInc: 130k
DISPATCH130k
(UnaryPostInc, UnaryOperator);
87
1.43M
      
case UO_PostDec: 8.92k
DISPATCH8.92k
(UnaryPostDec, UnaryOperator);
88
1.43M
      
case UO_PreInc: 106k
DISPATCH106k
(UnaryPreInc, UnaryOperator);
89
1.43M
      
case UO_PreDec: 16.3k
DISPATCH16.3k
(UnaryPreDec, UnaryOperator);
90
1.43M
      
case UO_AddrOf: 168k
DISPATCH168k
(UnaryAddrOf, UnaryOperator);
91
1.43M
      
case UO_Deref: 201k
DISPATCH201k
(UnaryDeref, UnaryOperator);
92
1.43M
      
case UO_Plus: 524
DISPATCH524
(UnaryPlus, UnaryOperator);
93
1.43M
      
case UO_Minus: 224k
DISPATCH224k
(UnaryMinus, UnaryOperator);
94
1.43M
      
case UO_Not: 40.0k
DISPATCH40.0k
(UnaryNot, UnaryOperator);
95
1.43M
      
case UO_LNot: 508k
DISPATCH508k
(UnaryLNot, UnaryOperator);
96
1.43M
      
case UO_Real: 731
DISPATCH731
(UnaryReal, UnaryOperator);
97
1.43M
      
case UO_Imag: 711
DISPATCH711
(UnaryImag, UnaryOperator);
98
1.43M
      
case UO_Extension: 24.2k
DISPATCH24.2k
(UnaryExtension, UnaryOperator);
99
1.43M
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
100
51.3M
      }
101
51.3M
    }
102
51.3M
103
51.3M
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
51.3M
    switch (S->getStmtClass()) {
105
51.3M
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
51.3M
#define ABSTRACT_STMT(STMT)
107
51.3M
#define STMT(CLASS, PARENT)                              \
108
51.3M
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
51.3M
#include 
"clang/AST/StmtNodes.inc"0
110
51.3M
    }
111
51.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.30M
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
3.30M
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
3.30M
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
3.30M
    // below.
46
3.30M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
208k
      switch (BinOp->getOpcode()) {
48
208k
      
case BO_PtrMemD: 25
DISPATCH25
(BinPtrMemD, BinaryOperator);
49
208k
      
case BO_PtrMemI: 3
DISPATCH3
(BinPtrMemI, BinaryOperator);
50
208k
      
case BO_Mul: 24.8k
DISPATCH24.8k
(BinMul, BinaryOperator);
51
208k
      
case BO_Div: 34.6k
DISPATCH34.6k
(BinDiv, BinaryOperator);
52
208k
      
case BO_Rem: 260
DISPATCH260
(BinRem, BinaryOperator);
53
208k
      
case BO_Add: 19.9k
DISPATCH19.9k
(BinAdd, BinaryOperator);
54
208k
      
case BO_Sub: 23.5k
DISPATCH23.5k
(BinSub, BinaryOperator);
55
208k
      
case BO_Shl: 42.0k
DISPATCH42.0k
(BinShl, BinaryOperator);
56
208k
      
case BO_Shr: 5.51k
DISPATCH5.51k
(BinShr, BinaryOperator);
57
208k
58
208k
      
case BO_LT: 12.1k
DISPATCH12.1k
(BinLT, BinaryOperator);
59
208k
      
case BO_GT: 70
DISPATCH70
(BinGT, BinaryOperator);
60
208k
      
case BO_LE: 11.1k
DISPATCH11.1k
(BinLE, BinaryOperator);
61
208k
      
case BO_GE: 890
DISPATCH890
(BinGE, BinaryOperator);
62
208k
      
case BO_EQ: 9.52k
DISPATCH9.52k
(BinEQ, BinaryOperator);
63
208k
      
case BO_NE: 1.16k
DISPATCH1.16k
(BinNE, BinaryOperator);
64
208k
      
case BO_Cmp: 40
DISPATCH40
(BinCmp, BinaryOperator);
65
208k
66
208k
      
case BO_And: 7.93k
DISPATCH7.93k
(BinAnd, BinaryOperator);
67
208k
      
case BO_Xor: 2.43k
DISPATCH2.43k
(BinXor, BinaryOperator);
68
208k
      
case BO_Or : 6.81k
DISPATCH6.81k
(BinOr, BinaryOperator);
69
208k
      
case BO_LAnd: 4.89k
DISPATCH4.89k
(BinLAnd, BinaryOperator);
70
208k
      
case BO_LOr : 298
DISPATCH298
(BinLOr, BinaryOperator);
71
208k
      
case BO_Assign: 13
DISPATCH13
(BinAssign, BinaryOperator);
72
208k
      
case BO_MulAssign: 7
DISPATCH7
(BinMulAssign, CompoundAssignOperator);
73
208k
      
case BO_DivAssign: 1
DISPATCH1
(BinDivAssign, CompoundAssignOperator);
74
208k
      
case BO_RemAssign: 4
DISPATCH4
(BinRemAssign, CompoundAssignOperator);
75
208k
      
case BO_AddAssign: 14
DISPATCH14
(BinAddAssign, CompoundAssignOperator);
76
208k
      
case BO_SubAssign: 1
DISPATCH1
(BinSubAssign, CompoundAssignOperator);
77
208k
      
case BO_ShlAssign: 4
DISPATCH4
(BinShlAssign, CompoundAssignOperator);
78
208k
      
case BO_ShrAssign: 1
DISPATCH1
(BinShrAssign, CompoundAssignOperator);
79
208k
      
case BO_AndAssign: 1
DISPATCH1
(BinAndAssign, CompoundAssignOperator);
80
208k
      
case BO_OrAssign: 1
DISPATCH1
(BinOrAssign, CompoundAssignOperator);
81
208k
      
case BO_XorAssign: 1
DISPATCH1
(BinXorAssign, CompoundAssignOperator);
82
208k
      
case BO_Comma: 160
DISPATCH160
(BinComma, BinaryOperator);
83
3.10M
      }
84
3.10M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
129k
      switch (UnOp->getOpcode()) {
86
129k
      
case UO_PostInc: 130
DISPATCH130
(UnaryPostInc, UnaryOperator);
87
129k
      
case UO_PostDec: 2
DISPATCH2
(UnaryPostDec, UnaryOperator);
88
129k
      
case UO_PreInc: 40
DISPATCH40
(UnaryPreInc, UnaryOperator);
89
129k
      
case UO_PreDec: 31
DISPATCH31
(UnaryPreDec, UnaryOperator);
90
129k
      
case UO_AddrOf: 22.8k
DISPATCH22.8k
(UnaryAddrOf, UnaryOperator);
91
129k
      
case UO_Deref: 15.3k
DISPATCH15.3k
(UnaryDeref, UnaryOperator);
92
129k
      
case UO_Plus: 76
DISPATCH76
(UnaryPlus, UnaryOperator);
93
129k
      
case UO_Minus: 77.7k
DISPATCH77.7k
(UnaryMinus, UnaryOperator);
94
129k
      
case UO_Not: 10.0k
DISPATCH10.0k
(UnaryNot, UnaryOperator);
95
129k
      
case UO_LNot: 3.44k
DISPATCH3.44k
(UnaryLNot, UnaryOperator);
96
129k
      
case UO_Real: 3
DISPATCH3
(UnaryReal, UnaryOperator);
97
129k
      
case UO_Imag: 3
DISPATCH3
(UnaryImag, UnaryOperator);
98
129k
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
99
129k
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
100
2.97M
      }
101
2.97M
    }
102
2.97M
103
2.97M
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
2.97M
    switch (S->getStmtClass()) {
105
2.97M
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
2.97M
#define ABSTRACT_STMT(STMT)
107
2.97M
#define STMT(CLASS, PARENT)                              \
108
2.97M
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
2.97M
#include 
"clang/AST/StmtNodes.inc"0
110
2.97M
    }
111
2.97M
  }
SemaDeclCXX.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::UninitializedFieldVisitor, void>::Visit(clang::Stmt*)
Line
Count
Source
42
161k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
161k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
161k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
161k
    // below.
46
161k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
1.56k
      switch (BinOp->getOpcode()) {
48
1.56k
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
49
1.56k
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
50
1.56k
      
case BO_Mul: 20
DISPATCH20
(BinMul, BinaryOperator);
51
1.56k
      
case BO_Div: 0
DISPATCH0
(BinDiv, BinaryOperator);
52
1.56k
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
53
1.56k
      
case BO_Add: 1.48k
DISPATCH1.48k
(BinAdd, BinaryOperator);
54
1.56k
      
case BO_Sub: 4
DISPATCH4
(BinSub, BinaryOperator);
55
1.56k
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
56
1.56k
      
case BO_Shr: 12
DISPATCH12
(BinShr, BinaryOperator);
57
1.56k
58
1.56k
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
59
1.56k
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
60
1.56k
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
61
1.56k
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
62
1.56k
      
case BO_EQ: 6
DISPATCH6
(BinEQ, BinaryOperator);
63
1.56k
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
64
1.56k
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
65
1.56k
66
1.56k
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
67
1.56k
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
68
1.56k
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
69
1.56k
      
case BO_LAnd: 4
DISPATCH4
(BinLAnd, BinaryOperator);
70
1.56k
      
case BO_LOr : 11
DISPATCH11
(BinLOr, BinaryOperator);
71
1.56k
      
case BO_Assign: 10
DISPATCH10
(BinAssign, BinaryOperator);
72
1.56k
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
73
1.56k
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
74
1.56k
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
75
1.56k
      
case BO_AddAssign: 3
DISPATCH3
(BinAddAssign, CompoundAssignOperator);
76
1.56k
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
77
1.56k
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
78
1.56k
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
79
1.56k
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
80
1.56k
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
81
1.56k
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
82
1.56k
      
case BO_Comma: 7
DISPATCH7
(BinComma, BinaryOperator);
83
159k
      }
84
159k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
669
      switch (UnOp->getOpcode()) {
86
669
      
case UO_PostInc: 17
DISPATCH17
(UnaryPostInc, UnaryOperator);
87
669
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
88
669
      
case UO_PreInc: 13
DISPATCH13
(UnaryPreInc, UnaryOperator);
89
669
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
90
669
      
case UO_AddrOf: 231
DISPATCH231
(UnaryAddrOf, UnaryOperator);
91
669
      
case UO_Deref: 115
DISPATCH115
(UnaryDeref, UnaryOperator);
92
669
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
93
669
      
case UO_Minus: 286
DISPATCH286
(UnaryMinus, UnaryOperator);
94
669
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
95
669
      
case UO_LNot: 7
DISPATCH7
(UnaryLNot, UnaryOperator);
96
669
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
97
669
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
98
669
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
99
669
      
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
  }
SemaDeclCXX.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::CheckDefaultArgumentVisitor, bool>::Visit(clang::Stmt*)
Line
Count
Source
42
171k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
171k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
171k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
171k
    // below.
46
171k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
5.08k
      switch (BinOp->getOpcode()) {
48
5.08k
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
49
5.08k
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
50
5.08k
      
case BO_Mul: 3
DISPATCH3
(BinMul, BinaryOperator);
51
5.08k
      
case BO_Div: 15
DISPATCH15
(BinDiv, BinaryOperator);
52
5.08k
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
53
5.08k
      
case BO_Add: 22
DISPATCH22
(BinAdd, BinaryOperator);
54
5.08k
      
case BO_Sub: 0
DISPATCH0
(BinSub, BinaryOperator);
55
5.08k
      
case BO_Shl: 2.61k
DISPATCH2.61k
(BinShl, BinaryOperator);
56
5.08k
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
57
5.08k
58
5.08k
      
case BO_LT: 14
DISPATCH14
(BinLT, BinaryOperator);
59
5.08k
      
case BO_GT: 4
DISPATCH4
(BinGT, BinaryOperator);
60
5.08k
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
61
5.08k
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
62
5.08k
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
63
5.08k
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
64
5.08k
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
65
5.08k
66
5.08k
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
67
5.08k
      
case BO_Xor: 5
DISPATCH5
(BinXor, BinaryOperator);
68
5.08k
      
case BO_Or : 2.40k
DISPATCH2.40k
(BinOr, BinaryOperator);
69
5.08k
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
70
5.08k
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
71
5.08k
      
case BO_Assign: 0
DISPATCH0
(BinAssign, BinaryOperator);
72
5.08k
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
73
5.08k
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
74
5.08k
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
75
5.08k
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
76
5.08k
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
77
5.08k
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
78
5.08k
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
79
5.08k
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
80
5.08k
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
81
5.08k
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
82
5.08k
      
case BO_Comma: 7
DISPATCH7
(BinComma, BinaryOperator);
83
166k
      }
84
166k
    } 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
163k
      }
101
163k
    }
102
163k
103
163k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
163k
    switch (S->getStmtClass()) {
105
163k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
163k
#define ABSTRACT_STMT(STMT)
107
163k
#define STMT(CLASS, PARENT)                              \
108
163k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
163k
#include 
"clang/AST/StmtNodes.inc"0
110
163k
    }
111
163k
  }
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
144k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
144k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
144k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
144k
    // below.
46
144k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
283
      switch (BinOp->getOpcode()) {
48
283
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
49
283
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
50
283
      
case BO_Mul: 7
DISPATCH7
(BinMul, BinaryOperator);
51
283
      
case BO_Div: 1
DISPATCH1
(BinDiv, BinaryOperator);
52
283
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
53
283
      
case BO_Add: 8
DISPATCH8
(BinAdd, BinaryOperator);
54
283
      
case BO_Sub: 20
DISPATCH20
(BinSub, BinaryOperator);
55
283
      
case BO_Shl: 24
DISPATCH24
(BinShl, BinaryOperator);
56
283
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
57
283
58
283
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
59
283
      
case BO_GT: 72
DISPATCH72
(BinGT, BinaryOperator);
60
283
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
61
283
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
62
283
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
63
283
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
64
283
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
65
283
66
283
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
67
283
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
68
283
      
case BO_Or : 141
DISPATCH141
(BinOr, BinaryOperator);
69
283
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
70
283
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
71
283
      
case BO_Assign: 0
DISPATCH0
(BinAssign, BinaryOperator);
72
283
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
73
283
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
74
283
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
75
283
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
76
283
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
77
283
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
78
283
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
79
283
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
80
283
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
81
283
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
82
283
      
case BO_Comma: 10
DISPATCH10
(BinComma, BinaryOperator);
83
143k
      }
84
143k
    } 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
143k
      }
101
143k
    }
102
143k
103
143k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
143k
    switch (S->getStmtClass()) {
105
143k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
143k
#define ABSTRACT_STMT(STMT)
107
143k
#define STMT(CLASS, PARENT)                              \
108
143k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
143k
#include 
"clang/AST/StmtNodes.inc"0
110
143k
    }
111
143k
  }
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<llvm::make_const_ptr, (anonymous namespace)::(anonymous namespace)::LoopCounterRefChecker, bool>::Visit(clang::Stmt const*)
Line
Count
Source
42
186k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
186k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
186k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
186k
    // below.
46
186k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
252
      switch (BinOp->getOpcode()) {
48
252
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
49
252
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
50
252
      
case BO_Mul: 50
DISPATCH50
(BinMul, BinaryOperator);
51
252
      
case BO_Div: 22
DISPATCH22
(BinDiv, BinaryOperator);
52
252
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
53
252
      
case BO_Add: 158
DISPATCH158
(BinAdd, BinaryOperator);
54
252
      
case BO_Sub: 22
DISPATCH22
(BinSub, BinaryOperator);
55
252
      
case BO_Shl: 0
DISPATCH0
(BinShl, BinaryOperator);
56
252
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
57
252
58
252
      
case BO_LT: 0
DISPATCH0
(BinLT, BinaryOperator);
59
252
      
case BO_GT: 0
DISPATCH0
(BinGT, BinaryOperator);
60
252
      
case BO_LE: 0
DISPATCH0
(BinLE, BinaryOperator);
61
252
      
case BO_GE: 0
DISPATCH0
(BinGE, BinaryOperator);
62
252
      
case BO_EQ: 0
DISPATCH0
(BinEQ, BinaryOperator);
63
252
      
case BO_NE: 0
DISPATCH0
(BinNE, BinaryOperator);
64
252
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
65
252
66
252
      
case BO_And: 0
DISPATCH0
(BinAnd, BinaryOperator);
67
252
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
68
252
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
69
252
      
case BO_LAnd: 0
DISPATCH0
(BinLAnd, BinaryOperator);
70
252
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
71
252
      
case BO_Assign: 0
DISPATCH0
(BinAssign, BinaryOperator);
72
252
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
73
252
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
74
252
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
75
252
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
76
252
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
77
252
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
78
252
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
79
252
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
80
252
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
81
252
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
82
252
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
83
186k
      }
84
186k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
330
      switch (UnOp->getOpcode()) {
86
330
      
case UO_PostInc: 0
DISPATCH0
(UnaryPostInc, UnaryOperator);
87
330
      
case UO_PostDec: 0
DISPATCH0
(UnaryPostDec, UnaryOperator);
88
330
      
case UO_PreInc: 0
DISPATCH0
(UnaryPreInc, UnaryOperator);
89
330
      
case UO_PreDec: 0
DISPATCH0
(UnaryPreDec, UnaryOperator);
90
330
      
case UO_AddrOf: 4
DISPATCH4
(UnaryAddrOf, UnaryOperator);
91
330
      
case UO_Deref: 140
DISPATCH140
(UnaryDeref, UnaryOperator);
92
330
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
93
330
      
case UO_Minus: 174
DISPATCH174
(UnaryMinus, UnaryOperator);
94
330
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
95
330
      
case UO_LNot: 0
DISPATCH0
(UnaryLNot, UnaryOperator);
96
330
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
97
330
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
98
330
      
case UO_Extension: 12
DISPATCH12
(UnaryExtension, UnaryOperator);
99
330
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
100
186k
      }
101
186k
    }
102
186k
103
186k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
186k
    switch (S->getStmtClass()) {
105
186k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
186k
#define ABSTRACT_STMT(STMT)
107
186k
#define STMT(CLASS, PARENT)                              \
108
186k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
186k
#include 
"clang/AST/StmtNodes.inc"0
110
186k
    }
111
186k
  }
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.39M
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
1.39M
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
1.39M
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
1.39M
    // below.
46
1.39M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
122k
      switch (BinOp->getOpcode()) {
48
122k
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
49
122k
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
50
122k
      
case BO_Mul: 934
DISPATCH934
(BinMul, BinaryOperator);
51
122k
      
case BO_Div: 150
DISPATCH150
(BinDiv, BinaryOperator);
52
122k
      
case BO_Rem: 8
DISPATCH8
(BinRem, BinaryOperator);
53
122k
      
case BO_Add: 4.34k
DISPATCH4.34k
(BinAdd, BinaryOperator);
54
122k
      
case BO_Sub: 16.9k
DISPATCH16.9k
(BinSub, BinaryOperator);
55
122k
      
case BO_Shl: 26
DISPATCH26
(BinShl, BinaryOperator);
56
122k
      
case BO_Shr: 26
DISPATCH26
(BinShr, BinaryOperator);
57
122k
58
122k
      
case BO_LT: 55.9k
DISPATCH55.9k
(BinLT, BinaryOperator);
59
122k
      
case BO_GT: 903
DISPATCH903
(BinGT, BinaryOperator);
60
122k
      
case BO_LE: 226
DISPATCH226
(BinLE, BinaryOperator);
61
122k
      
case BO_GE: 300
DISPATCH300
(BinGE, BinaryOperator);
62
122k
      
case BO_EQ: 196
DISPATCH196
(BinEQ, BinaryOperator);
63
122k
      
case BO_NE: 114
DISPATCH114
(BinNE, BinaryOperator);
64
122k
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
65
122k
66
122k
      
case BO_And: 42
DISPATCH42
(BinAnd, BinaryOperator);
67
122k
      
case BO_Xor: 18
DISPATCH18
(BinXor, BinaryOperator);
68
122k
      
case BO_Or : 26
DISPATCH26
(BinOr, BinaryOperator);
69
122k
      
case BO_LAnd: 94
DISPATCH94
(BinLAnd, BinaryOperator);
70
122k
      
case BO_LOr : 14
DISPATCH14
(BinLOr, BinaryOperator);
71
122k
      
case BO_Assign: 32.6k
DISPATCH32.6k
(BinAssign, BinaryOperator);
72
122k
      
case BO_MulAssign: 81
DISPATCH81
(BinMulAssign, CompoundAssignOperator);
73
122k
      
case BO_DivAssign: 158
DISPATCH158
(BinDivAssign, CompoundAssignOperator);
74
122k
      
case BO_RemAssign: 34
DISPATCH34
(BinRemAssign, CompoundAssignOperator);
75
122k
      
case BO_AddAssign: 8.80k
DISPATCH8.80k
(BinAddAssign, CompoundAssignOperator);
76
122k
      
case BO_SubAssign: 434
DISPATCH434
(BinSubAssign, CompoundAssignOperator);
77
122k
      
case BO_ShlAssign: 26
DISPATCH26
(BinShlAssign, CompoundAssignOperator);
78
122k
      
case BO_ShrAssign: 26
DISPATCH26
(BinShrAssign, CompoundAssignOperator);
79
122k
      
case BO_AndAssign: 26
DISPATCH26
(BinAndAssign, CompoundAssignOperator);
80
122k
      
case BO_OrAssign: 48
DISPATCH48
(BinOrAssign, CompoundAssignOperator);
81
122k
      
case BO_XorAssign: 36
DISPATCH36
(BinXorAssign, CompoundAssignOperator);
82
122k
      
case BO_Comma: 244
DISPATCH244
(BinComma, BinaryOperator);
83
1.26M
      }
84
1.26M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
64.4k
      switch (UnOp->getOpcode()) {
86
64.4k
      
case UO_PostInc: 20.0k
DISPATCH20.0k
(UnaryPostInc, UnaryOperator);
87
64.4k
      
case UO_PostDec: 206
DISPATCH206
(UnaryPostDec, UnaryOperator);
88
64.4k
      
case UO_PreInc: 42.8k
DISPATCH42.8k
(UnaryPreInc, UnaryOperator);
89
64.4k
      
case UO_PreDec: 158
DISPATCH158
(UnaryPreDec, UnaryOperator);
90
64.4k
      
case UO_AddrOf: 140
DISPATCH140
(UnaryAddrOf, UnaryOperator);
91
64.4k
      
case UO_Deref: 522
DISPATCH522
(UnaryDeref, UnaryOperator);
92
64.4k
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
93
64.4k
      
case UO_Minus: 384
DISPATCH384
(UnaryMinus, UnaryOperator);
94
64.4k
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
95
64.4k
      
case UO_LNot: 128
DISPATCH128
(UnaryLNot, UnaryOperator);
96
64.4k
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
97
64.4k
      
case UO_Imag: 4
DISPATCH4
(UnaryImag, UnaryOperator);
98
64.4k
      
case UO_Extension: 24
DISPATCH24
(UnaryExtension, UnaryOperator);
99
64.4k
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
100
1.20M
      }
101
1.20M
    }
102
1.20M
103
1.20M
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
1.20M
    switch (S->getStmtClass()) {
105
1.20M
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
1.20M
#define ABSTRACT_STMT(STMT)
107
1.20M
#define STMT(CLASS, PARENT)                              \
108
1.20M
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
1.20M
#include 
"clang/AST/StmtNodes.inc"0
110
1.20M
    }
111
1.20M
  }
SemaStmt.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::BreakContinueFinder, void>::Visit(clang::Stmt const*)
Line
Count
Source
42
258k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
258k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
258k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
258k
    // below.
46
258k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
37.9k
      switch (BinOp->getOpcode()) {
48
37.9k
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
49
37.9k
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
50
37.9k
      
case BO_Mul: 720
DISPATCH720
(BinMul, BinaryOperator);
51
37.9k
      
case BO_Div: 380
DISPATCH380
(BinDiv, BinaryOperator);
52
37.9k
      
case BO_Rem: 54
DISPATCH54
(BinRem, BinaryOperator);
53
37.9k
      
case BO_Add: 1.42k
DISPATCH1.42k
(BinAdd, BinaryOperator);
54
37.9k
      
case BO_Sub: 833
DISPATCH833
(BinSub, BinaryOperator);
55
37.9k
      
case BO_Shl: 140
DISPATCH140
(BinShl, BinaryOperator);
56
37.9k
      
case BO_Shr: 67
DISPATCH67
(BinShr, BinaryOperator);
57
37.9k
58
37.9k
      
case BO_LT: 18.6k
DISPATCH18.6k
(BinLT, BinaryOperator);
59
37.9k
      
case BO_GT: 1.22k
DISPATCH1.22k
(BinGT, BinaryOperator);
60
37.9k
      
case BO_LE: 2.36k
DISPATCH2.36k
(BinLE, BinaryOperator);
61
37.9k
      
case BO_GE: 723
DISPATCH723
(BinGE, BinaryOperator);
62
37.9k
      
case BO_EQ: 1.49k
DISPATCH1.49k
(BinEQ, BinaryOperator);
63
37.9k
      
case BO_NE: 2.72k
DISPATCH2.72k
(BinNE, BinaryOperator);
64
37.9k
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
65
37.9k
66
37.9k
      
case BO_And: 112
DISPATCH112
(BinAnd, BinaryOperator);
67
37.9k
      
case BO_Xor: 7
DISPATCH7
(BinXor, BinaryOperator);
68
37.9k
      
case BO_Or : 9
DISPATCH9
(BinOr, BinaryOperator);
69
37.9k
      
case BO_LAnd: 1.55k
DISPATCH1.55k
(BinLAnd, BinaryOperator);
70
37.9k
      
case BO_LOr : 238
DISPATCH238
(BinLOr, BinaryOperator);
71
37.9k
      
case BO_Assign: 3.23k
DISPATCH3.23k
(BinAssign, BinaryOperator);
72
37.9k
      
case BO_MulAssign: 14
DISPATCH14
(BinMulAssign, CompoundAssignOperator);
73
37.9k
      
case BO_DivAssign: 7
DISPATCH7
(BinDivAssign, CompoundAssignOperator);
74
37.9k
      
case BO_RemAssign: 4
DISPATCH4
(BinRemAssign, CompoundAssignOperator);
75
37.9k
      
case BO_AddAssign: 864
DISPATCH864
(BinAddAssign, CompoundAssignOperator);
76
37.9k
      
case BO_SubAssign: 46
DISPATCH46
(BinSubAssign, CompoundAssignOperator);
77
37.9k
      
case BO_ShlAssign: 25
DISPATCH25
(BinShlAssign, CompoundAssignOperator);
78
37.9k
      
case BO_ShrAssign: 33
DISPATCH33
(BinShrAssign, CompoundAssignOperator);
79
37.9k
      
case BO_AndAssign: 6
DISPATCH6
(BinAndAssign, CompoundAssignOperator);
80
37.9k
      
case BO_OrAssign: 4
DISPATCH4
(BinOrAssign, CompoundAssignOperator);
81
37.9k
      
case BO_XorAssign: 4
DISPATCH4
(BinXorAssign, CompoundAssignOperator);
82
37.9k
      
case BO_Comma: 934
DISPATCH934
(BinComma, BinaryOperator);
83
220k
      }
84
220k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
25.4k
      switch (UnOp->getOpcode()) {
86
25.4k
      
case UO_PostInc: 16.3k
DISPATCH16.3k
(UnaryPostInc, UnaryOperator);
87
25.4k
      
case UO_PostDec: 935
DISPATCH935
(UnaryPostDec, UnaryOperator);
88
25.4k
      
case UO_PreInc: 4.14k
DISPATCH4.14k
(UnaryPreInc, UnaryOperator);
89
25.4k
      
case UO_PreDec: 470
DISPATCH470
(UnaryPreDec, UnaryOperator);
90
25.4k
      
case UO_AddrOf: 144
DISPATCH144
(UnaryAddrOf, UnaryOperator);
91
25.4k
      
case UO_Deref: 1.39k
DISPATCH1.39k
(UnaryDeref, UnaryOperator);
92
25.4k
      
case UO_Plus: 1
DISPATCH1
(UnaryPlus, UnaryOperator);
93
25.4k
      
case UO_Minus: 341
DISPATCH341
(UnaryMinus, UnaryOperator);
94
25.4k
      
case UO_Not: 1
DISPATCH1
(UnaryNot, UnaryOperator);
95
25.4k
      
case UO_LNot: 1.64k
DISPATCH1.64k
(UnaryLNot, UnaryOperator);
96
25.4k
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
97
25.4k
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
98
25.4k
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
99
25.4k
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
100
195k
      }
101
195k
    }
102
195k
103
195k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
195k
    switch (S->getStmtClass()) {
105
195k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
195k
#define ABSTRACT_STMT(STMT)
107
195k
#define STMT(CLASS, PARENT)                              \
108
195k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
195k
#include 
"clang/AST/StmtNodes.inc"0
110
195k
    }
111
195k
  }
SemaStmt.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::DeclExtractor, void>::Visit(clang::Stmt*)
Line
Count
Source
42
271k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
271k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
271k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
271k
    // below.
46
271k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
59.6k
      switch (BinOp->getOpcode()) {
48
59.6k
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
49
59.6k
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
50
59.6k
      
case BO_Mul: 1.79k
DISPATCH1.79k
(BinMul, BinaryOperator);
51
59.6k
      
case BO_Div: 1.40k
DISPATCH1.40k
(BinDiv, BinaryOperator);
52
59.6k
      
case BO_Rem: 8
DISPATCH8
(BinRem, BinaryOperator);
53
59.6k
      
case BO_Add: 2.69k
DISPATCH2.69k
(BinAdd, BinaryOperator);
54
59.6k
      
case BO_Sub: 56
DISPATCH56
(BinSub, BinaryOperator);
55
59.6k
      
case BO_Shl: 16
DISPATCH16
(BinShl, BinaryOperator);
56
59.6k
      
case BO_Shr: 8
DISPATCH8
(BinShr, BinaryOperator);
57
59.6k
58
59.6k
      
case BO_LT: 44.9k
DISPATCH44.9k
(BinLT, BinaryOperator);
59
59.6k
      
case BO_GT: 3.76k
DISPATCH3.76k
(BinGT, BinaryOperator);
60
59.6k
      
case BO_LE: 1.93k
DISPATCH1.93k
(BinLE, BinaryOperator);
61
59.6k
      
case BO_GE: 1.98k
DISPATCH1.98k
(BinGE, BinaryOperator);
62
59.6k
      
case BO_EQ: 70
DISPATCH70
(BinEQ, BinaryOperator);
63
59.6k
      
case BO_NE: 266
DISPATCH266
(BinNE, BinaryOperator);
64
59.6k
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
65
59.6k
66
59.6k
      
case BO_And: 44
DISPATCH44
(BinAnd, BinaryOperator);
67
59.6k
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
68
59.6k
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
69
59.6k
      
case BO_LAnd: 608
DISPATCH608
(BinLAnd, BinaryOperator);
70
59.6k
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
71
59.6k
      
case BO_Assign: 0
DISPATCH0
(BinAssign, BinaryOperator);
72
59.6k
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
73
59.6k
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
74
59.6k
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
75
59.6k
      
case BO_AddAssign: 0
DISPATCH0
(BinAddAssign, CompoundAssignOperator);
76
59.6k
      
case BO_SubAssign: 0
DISPATCH0
(BinSubAssign, CompoundAssignOperator);
77
59.6k
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
78
59.6k
      
case BO_ShrAssign: 0
DISPATCH0
(BinShrAssign, CompoundAssignOperator);
79
59.6k
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
80
59.6k
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
81
59.6k
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
82
59.6k
      
case BO_Comma: 0
DISPATCH0
(BinComma, BinaryOperator);
83
212k
      }
84
212k
    } 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
212k
      }
101
212k
    }
102
212k
103
212k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
212k
    switch (S->getStmtClass()) {
105
212k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
212k
#define ABSTRACT_STMT(STMT)
107
212k
#define STMT(CLASS, PARENT)                              \
108
212k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
212k
#include 
"clang/AST/StmtNodes.inc"0
110
212k
    }
111
212k
  }
SemaStmt.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::DeclMatcher, void>::Visit(clang::Stmt*)
Line
Count
Source
42
150k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
150k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
150k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
150k
    // below.
46
150k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47
37.9k
      switch (BinOp->getOpcode()) {
48
37.9k
      
case BO_PtrMemD: 0
DISPATCH0
(BinPtrMemD, BinaryOperator);
49
37.9k
      
case BO_PtrMemI: 0
DISPATCH0
(BinPtrMemI, BinaryOperator);
50
37.9k
      
case BO_Mul: 1.78k
DISPATCH1.78k
(BinMul, BinaryOperator);
51
37.9k
      
case BO_Div: 868
DISPATCH868
(BinDiv, BinaryOperator);
52
37.9k
      
case BO_Rem: 0
DISPATCH0
(BinRem, BinaryOperator);
53
37.9k
      
case BO_Add: 2.68k
DISPATCH2.68k
(BinAdd, BinaryOperator);
54
37.9k
      
case BO_Sub: 40
DISPATCH40
(BinSub, BinaryOperator);
55
37.9k
      
case BO_Shl: 96
DISPATCH96
(BinShl, BinaryOperator);
56
37.9k
      
case BO_Shr: 0
DISPATCH0
(BinShr, BinaryOperator);
57
37.9k
58
37.9k
      
case BO_LT: 17.7k
DISPATCH17.7k
(BinLT, BinaryOperator);
59
37.9k
      
case BO_GT: 3.78k
DISPATCH3.78k
(BinGT, BinaryOperator);
60
37.9k
      
case BO_LE: 997
DISPATCH997
(BinLE, BinaryOperator);
61
37.9k
      
case BO_GE: 1.90k
DISPATCH1.90k
(BinGE, BinaryOperator);
62
37.9k
      
case BO_EQ: 22
DISPATCH22
(BinEQ, BinaryOperator);
63
37.9k
      
case BO_NE: 84
DISPATCH84
(BinNE, BinaryOperator);
64
37.9k
      
case BO_Cmp: 0
DISPATCH0
(BinCmp, BinaryOperator);
65
37.9k
66
37.9k
      
case BO_And: 44
DISPATCH44
(BinAnd, BinaryOperator);
67
37.9k
      
case BO_Xor: 0
DISPATCH0
(BinXor, BinaryOperator);
68
37.9k
      
case BO_Or : 0
DISPATCH0
(BinOr, BinaryOperator);
69
37.9k
      
case BO_LAnd: 136
DISPATCH136
(BinLAnd, BinaryOperator);
70
37.9k
      
case BO_LOr : 0
DISPATCH0
(BinLOr, BinaryOperator);
71
37.9k
      
case BO_Assign: 2.97k
DISPATCH2.97k
(BinAssign, BinaryOperator);
72
37.9k
      
case BO_MulAssign: 0
DISPATCH0
(BinMulAssign, CompoundAssignOperator);
73
37.9k
      
case BO_DivAssign: 0
DISPATCH0
(BinDivAssign, CompoundAssignOperator);
74
37.9k
      
case BO_RemAssign: 0
DISPATCH0
(BinRemAssign, CompoundAssignOperator);
75
37.9k
      
case BO_AddAssign: 3.66k
DISPATCH3.66k
(BinAddAssign, CompoundAssignOperator);
76
37.9k
      
case BO_SubAssign: 16
DISPATCH16
(BinSubAssign, CompoundAssignOperator);
77
37.9k
      
case BO_ShlAssign: 0
DISPATCH0
(BinShlAssign, CompoundAssignOperator);
78
37.9k
      
case BO_ShrAssign: 44
DISPATCH44
(BinShrAssign, CompoundAssignOperator);
79
37.9k
      
case BO_AndAssign: 0
DISPATCH0
(BinAndAssign, CompoundAssignOperator);
80
37.9k
      
case BO_OrAssign: 0
DISPATCH0
(BinOrAssign, CompoundAssignOperator);
81
37.9k
      
case BO_XorAssign: 0
DISPATCH0
(BinXorAssign, CompoundAssignOperator);
82
37.9k
      
case BO_Comma: 1.12k
DISPATCH1.12k
(BinComma, BinaryOperator);
83
112k
      }
84
112k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
85
19.1k
      switch (UnOp->getOpcode()) {
86
19.1k
      
case UO_PostInc: 14.1k
DISPATCH14.1k
(UnaryPostInc, UnaryOperator);
87
19.1k
      
case UO_PostDec: 4.20k
DISPATCH4.20k
(UnaryPostDec, UnaryOperator);
88
19.1k
      
case UO_PreInc: 655
DISPATCH655
(UnaryPreInc, UnaryOperator);
89
19.1k
      
case UO_PreDec: 79
DISPATCH79
(UnaryPreDec, UnaryOperator);
90
19.1k
      
case UO_AddrOf: 2
DISPATCH2
(UnaryAddrOf, UnaryOperator);
91
19.1k
      
case UO_Deref: 18
DISPATCH18
(UnaryDeref, UnaryOperator);
92
19.1k
      
case UO_Plus: 0
DISPATCH0
(UnaryPlus, UnaryOperator);
93
19.1k
      
case UO_Minus: 2
DISPATCH2
(UnaryMinus, UnaryOperator);
94
19.1k
      
case UO_Not: 0
DISPATCH0
(UnaryNot, UnaryOperator);
95
19.1k
      
case UO_LNot: 24
DISPATCH24
(UnaryLNot, UnaryOperator);
96
19.1k
      
case UO_Real: 0
DISPATCH0
(UnaryReal, UnaryOperator);
97
19.1k
      
case UO_Imag: 0
DISPATCH0
(UnaryImag, UnaryOperator);
98
19.1k
      
case UO_Extension: 0
DISPATCH0
(UnaryExtension, UnaryOperator);
99
19.1k
      
case UO_Coawait: 0
DISPATCH0
(UnaryCoawait, UnaryOperator);
100
93.6k
      }
101
93.6k
    }
102
93.6k
103
93.6k
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
104
93.6k
    switch (S->getStmtClass()) {
105
93.6k
    
default: 0
llvm_unreachable0
("Unknown stmt kind!");
106
93.6k
#define ABSTRACT_STMT(STMT)
107
93.6k
#define STMT(CLASS, PARENT)                              \
108
93.6k
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
109
93.6k
#include 
"clang/AST/StmtNodes.inc"0
110
93.6k
    }
111
93.6k
  }
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.39k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
43
2.39k
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
44
2.39k
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
45
2.39k
    // below.
46
2.39k
    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: