Coverage Report

Created: 2021-01-23 06:44

/Users/buildslave/jenkins/workspace/coverage/llvm-project/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/ExprConcepts.h"
17
#include "clang/AST/ExprCXX.h"
18
#include "clang/AST/ExprObjC.h"
19
#include "clang/AST/ExprOpenMP.h"
20
#include "clang/AST/Stmt.h"
21
#include "clang/AST/StmtCXX.h"
22
#include "clang/AST/StmtObjC.h"
23
#include "clang/AST/StmtOpenMP.h"
24
#include "clang/Basic/LLVM.h"
25
#include "llvm/ADT/STLExtras.h"
26
#include "llvm/Support/Casting.h"
27
#include "llvm/Support/ErrorHandling.h"
28
#include <utility>
29
30
namespace clang {
31
/// StmtVisitorBase - This class implements a simple visitor for Stmt
32
/// subclasses. Since Expr derives from Stmt, this also includes support for
33
/// visiting Exprs.
34
template<template <typename> class Ptr, typename ImplClass, typename RetTy=void,
35
         class... ParamTys>
36
class StmtVisitorBase {
37
public:
38
#define PTR(CLASS) typename Ptr<CLASS>::type
39
#define DISPATCH(NAME, CLASS) \
40
206M
  return static_cast<ImplClass*>(this)->Visit ## NAME( \
41
206M
    static_cast<PTR(CLASS)>(S), std::forward<ParamTys>(P)...)
42
43
141M
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
141M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
13.9M
      switch (BinOp->getOpcode()) {
49
96.1k
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
507
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
417k
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
745k
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
40.5k
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
2.19M
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
1.93M
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
394k
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
32.9k
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
822k
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
562k
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
96.9k
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
66.3k
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
492k
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
201k
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
1.07k
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
186k
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
39.8k
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
155k
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
1.32M
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
325k
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
3.02M
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
39.4k
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
6.02k
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
1.19k
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
137k
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
21.6k
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
1.75k
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
1.07k
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
6.02k
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
28.2k
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
4.27k
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
571k
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
127M
      }
85
127M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
4.10M
      switch (UnOp->getOpcode()) {
87
124k
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
2.16k
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
447k
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
37.8k
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
417k
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
391k
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
792
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
1.44M
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
104k
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
1.08M
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
659
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
560
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
47.5k
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
10
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
123M
      }
102
123M
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
123M
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
123M
    case Stmt::CLASS ## Class: 
DISPATCH123M
(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
123M
    }
112
123M
  }
clang::StmtVisitorBase<llvm::make_const_ptr, clang::JSONDumper, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
2.12k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
2.12k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
140
      switch (BinOp->getOpcode()) {
49
2
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
2
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
17
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
1
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
1
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
25
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
5
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
1
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
1
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
18
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
1
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
1
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
1
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
4
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
4
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
1
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
1
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
1
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
1
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
1
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
48
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
1
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
2
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
1.98k
      }
85
1.98k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
46
      switch (UnOp->getOpcode()) {
87
2
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
21
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
6
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
6
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
1
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
5
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
2
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
3
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
1.93k
      }
102
1.93k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
1.93k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
1.93k
    }
112
1.93k
  }
clang::StmtVisitorBase<llvm::make_const_ptr, clang::ASTDumper, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
26.0k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
26.0k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
1.43k
      switch (BinOp->getOpcode()) {
49
5
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
4
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
32
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
58
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
6
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
285
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
170
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
2
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
2
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
708
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
2
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
2
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
2
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
32
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
12
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
2
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
4
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
2
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
2
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
3
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
74
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
5
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
1
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
10
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
1
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
1
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
1
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
1
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
1
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
8
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
24.6k
      }
85
24.6k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
983
      switch (UnOp->getOpcode()) {
87
713
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
1
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
35
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
8
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
74
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
57
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
14
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
59
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
4
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
10
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
4
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
2
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
2
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
23.6k
      }
102
23.6k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
23.6k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
23.6k
    }
112
23.6k
  }
Expr.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::SideEffectFinder, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
104
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
104
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
0
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
104
      }
85
104
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
5
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
5
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
99
      }
102
99
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
99
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
99
    }
112
99
  }
Expr.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::NonTrivialCallFinder, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
19.6k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
19.6k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
3.65k
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
413
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
11
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
1.41k
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
27
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
1.76k
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
11
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
15
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
16.0k
      }
85
16.0k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
435
      switch (UnOp->getOpcode()) {
87
192
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
159
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
84
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
15.5k
      }
102
15.5k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
15.5k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
15.5k
    }
112
15.5k
  }
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::LValueExprEvaluator, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
10.3M
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
10.3M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
919k
      switch (BinOp->getOpcode()) {
49
250
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
132
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
857k
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
2.53k
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
935
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
120
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
36.3k
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
3.22k
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
319
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
103
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
584
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
9.16k
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
1.41k
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
6.33k
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
9.39M
      }
85
9.39M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
136k
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
46.0k
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
7.64k
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
82.5k
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
161
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
134
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
199
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
9.25M
      }
102
9.25M
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
9.25M
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
9.25M
    }
112
9.25M
  }
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::PointerExprEvaluator, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
1.86M
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
1.86M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
55.7k
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
40.9k
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
9.67k
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
4.96k
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
80
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
18
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
89
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
1.81M
      }
85
1.81M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
51.1k
      switch (UnOp->getOpcode()) {
87
3.16k
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
18
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
28
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
21
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
47.8k
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
17
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
32
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
1.75M
      }
102
1.75M
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
1.75M
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
1.75M
    }
112
1.75M
  }
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::MemberPointerExprEvaluator, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
3.38k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
3.38k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
0
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
3.38k
      }
85
3.38k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
1.47k
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
1.47k
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
1.90k
      }
102
1.90k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
1.90k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
1.90k
    }
112
1.90k
  }
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::IntExprEvaluator, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
27.2M
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
27.2M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
3.24M
      switch (BinOp->getOpcode()) {
49
2
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
80.7k
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
101k
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
9.27k
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
755k
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
589k
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
295k
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
8.34k
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
318k
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
343k
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
18.2k
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
23.9k
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
190k
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
85.3k
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
51.1k
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
5.96k
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
63.5k
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
151k
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
43.6k
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
95.6k
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
679
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
175
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
137
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
914
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
510
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
128
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
123
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
599
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
527
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
180
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
5.00k
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
24.0M
      }
85
24.0M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
1.32M
      switch (UnOp->getOpcode()) {
87
1.46k
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
117
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
287
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
1.96k
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
98
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
1.14M
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
20.0k
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
149k
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
15
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
8
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
262
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
22.7M
      }
102
22.7M
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
22.7M
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
22.7M
    }
112
22.7M
  }
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::ComplexExprEvaluator, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
5.45k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
5.45k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
1.71k
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
336
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
214
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
647
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
292
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
206
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
1
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
5
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
5
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
4
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
3.74k
      }
85
3.74k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
64
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
4
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
17
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
5
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
38
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
3.67k
      }
102
3.67k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
3.67k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
3.67k
    }
112
3.67k
  }
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::FloatExprEvaluator, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
255k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
255k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
58.2k
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
5.15k
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
5.11k
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
12.7k
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
5.07k
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
25.7k
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
1.10k
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
1.07k
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
1.14k
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
1.08k
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
8
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
197k
      }
85
197k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
2.96k
      switch (UnOp->getOpcode()) {
87
42
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
7
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
7
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
21
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
2.53k
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
42
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
28
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
282
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
194k
      }
102
194k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
194k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
194k
    }
112
194k
  }
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::FixedPointExprEvaluator, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
4.03k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
4.03k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
1.27k
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
117
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
184
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
119
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
160
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
105
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
40
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
496
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
6
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
6
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
28
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
6
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
4
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
2
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
3
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
2.75k
      }
85
2.75k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
282
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
282
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
2.47k
      }
102
2.47k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
2.47k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
2.47k
    }
112
2.47k
  }
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::RecordExprEvaluator, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
114k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
114k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
691
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
650
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
24
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
17
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
113k
      }
85
113k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
0
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
113k
      }
102
113k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
113k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
113k
    }
112
113k
  }
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::TemporaryExprEvaluator, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
2
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
2
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
0
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
2
      }
85
2
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
0
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
2
      }
102
2
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
2
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
2
    }
112
2
  }
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::ArrayExprEvaluator, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
11.7k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
11.7k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
0
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
11.7k
      }
85
11.7k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
0
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
11.7k
      }
102
11.7k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
11.7k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
11.7k
    }
112
11.7k
  }
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::AtomicExprEvaluator, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
467
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
467
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
107
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
37
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
7
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
5
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
1
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
12
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
13
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
3
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
1
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
10
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
9
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
9
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
360
      }
85
360
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
0
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
360
      }
102
360
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
360
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
360
    }
112
360
  }
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::VectorExprEvaluator, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
1.80M
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
1.80M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
514k
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
19.7k
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
3.46k
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
595
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
26.5k
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
22.3k
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
629
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
499
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
3.47k
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
6.41k
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
3.45k
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
3.54k
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
7.08k
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
242
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
30.8k
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
11.4k
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
19.4k
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
55
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
43
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
353k
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
146
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
85
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
60
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
208
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
95
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
161
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
51
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
75
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
71
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
70
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
1
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
1.28M
      }
85
1.28M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
28.0k
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
25
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
2.87k
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
21.7k
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
14
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
3.32k
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
1.26M
      }
102
1.26M
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
1.26M
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
1.26M
    }
112
1.26M
  }
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::VoidExprEvaluator, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
5.58k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
5.58k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
86
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
86
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
5.49k
      }
85
5.49k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
0
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
5.49k
      }
102
5.49k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
5.49k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
5.49k
    }
112
5.49k
  }
clang::StmtVisitorBase<llvm::make_const_ptr, clang::interp::ByteCodeExprGen<clang::interp::ByteCodeEmitter>, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
9
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
9
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
3
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
2
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
1
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
6
      }
85
6
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
0
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
6
      }
102
6
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
6
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
6
    }
112
6
  }
clang::StmtVisitorBase<llvm::make_const_ptr, clang::interp::ByteCodeExprGen<clang::interp::EvalEmitter>, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
19
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
19
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
5
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
2
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
3
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
14
      }
85
14
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
0
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
14
      }
102
14
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
14
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
14
    }
112
14
  }
clang::StmtVisitorBase<llvm::make_const_ptr, clang::JSONNodeDumper, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
2.12k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
2.12k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
140
      switch (BinOp->getOpcode()) {
49
2
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
2
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
17
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
1
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
1
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
25
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
5
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
1
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
1
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
18
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
1
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
1
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
1
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
4
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
4
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
1
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
1
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
1
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
1
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
1
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
48
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
1
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
2
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
1.98k
      }
85
1.98k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
46
      switch (UnOp->getOpcode()) {
87
2
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
21
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
6
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
6
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
1
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
5
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
2
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
3
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
1.93k
      }
102
1.93k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
1.93k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
1.93k
    }
112
1.93k
  }
StmtPrinter.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::StmtPrinter, void>::Visit(clang::Stmt*)
Line
Count
Source
43
258k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
258k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
15.1k
      switch (BinOp->getOpcode()) {
49
8
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
65
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
8
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
5
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
1.57k
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
683
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
42
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
6.79k
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
971
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
8
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
10
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
166
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
261
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
1
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
14
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
8
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
219
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
1.69k
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
2.08k
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
31
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
11
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
7
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
382
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
31
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
7
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
7
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
7
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
7
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
7
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
80
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
243k
      }
85
243k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
23.6k
      switch (UnOp->getOpcode()) {
87
1.58k
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
4
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
7.03k
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
18
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
1.10k
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
637
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
11
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
117
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
13.1k
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
4
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
2
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
2
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
219k
      }
102
219k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
219k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
219k
    }
112
219k
  }
StmtProfile.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::StmtProfiler, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
18.7M
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
18.7M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
1.81M
      switch (BinOp->getOpcode()) {
49
93.8k
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
38
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
16.4k
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
60.8k
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
15.1k
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
38.5k
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
27.5k
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
14.8k
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
2.08k
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
21.4k
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
2.09k
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
20.1k
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
12.3k
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
127k
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
57.0k
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
7
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
7.35k
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
582
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
7.28k
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
969k
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
218k
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
39.2k
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
212
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
247
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
114
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
4.04k
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
1.44k
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
107
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
108
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
355
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
1.50k
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
51
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
50.7k
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
16.9M
      }
85
16.9M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
848k
      switch (UnOp->getOpcode()) {
87
1.13k
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
21
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
13.5k
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
3.01k
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
5.74k
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
72.2k
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
119
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
36.1k
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
3.16k
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
711k
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
2
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
1.60k
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
5
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
16.0M
      }
102
16.0M
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
16.0M
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
16.0M
    }
112
16.0M
  }
clang::StmtVisitorBase<llvm::make_const_ptr, clang::TextNodeDumper, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
26.0k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
26.0k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
1.43k
      switch (BinOp->getOpcode()) {
49
5
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
4
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
32
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
58
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
6
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
285
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
170
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
2
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
2
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
708
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
2
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
2
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
2
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
32
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
12
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
2
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
4
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
2
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
2
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
3
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
74
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
5
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
1
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
10
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
1
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
1
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
1
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
1
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
1
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
8
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
24.6k
      }
85
24.6k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
983
      switch (UnOp->getOpcode()) {
87
713
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
1
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
35
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
8
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
74
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
57
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
14
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
59
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
4
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
10
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
4
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
2
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
2
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
23.6k
      }
102
23.6k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
23.6k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
23.6k
    }
112
23.6k
  }
clang::StmtVisitorBase<std::__1::add_pointer, clang::ASTStmtReader, void>::Visit(clang::Stmt*)
Line
Count
Source
43
6.83M
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
6.83M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
514k
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
30.1k
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
484k
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
6.31M
      }
85
6.31M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
224k
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
224k
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
6.09M
      }
102
6.09M
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
6.09M
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
6.09M
    }
112
6.09M
  }
clang::StmtVisitorBase<std::__1::add_pointer, clang::ASTStmtWriter, void>::Visit(clang::Stmt*)
Line
Count
Source
43
4.91M
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
4.91M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
345k
      switch (BinOp->getOpcode()) {
49
434
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
38
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
18.6k
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
15.2k
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
1.78k
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
52.6k
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
34.5k
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
15.3k
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
2.24k
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
16.7k
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
9.38k
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
7.77k
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
1.30k
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
7.06k
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
3.68k
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
3
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
6.74k
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
719
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
7.24k
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
29.0k
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
6.82k
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
89.6k
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
429
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
343
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
114
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
9.77k
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
1.80k
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
107
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
108
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
375
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
1.51k
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
189
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
3.83k
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
4.56M
      }
85
4.56M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
128k
      switch (UnOp->getOpcode()) {
87
3.94k
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
93
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
19.5k
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
3.26k
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
5.56k
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
25.4k
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
47
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
34.7k
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
3.35k
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
30.6k
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
2
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
1.62k
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
5
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
4.44M
      }
102
4.44M
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
4.44M
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
4.44M
    }
112
4.44M
  }
AnalysisBasedWarnings.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::ContainsReference, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
450
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
450
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
32
      switch (BinOp->getOpcode()) {
49
1
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
11
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
1
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
6
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
13
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
418
      }
85
418
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
8
      switch (UnOp->getOpcode()) {
87
4
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
2
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
2
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
410
      }
102
410
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
410
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
410
    }
112
410
  }
Sema.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::DeferredDiagnosticsEmitter, void>::Visit(clang::Stmt*)
Line
Count
Source
43
2.71M
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
2.71M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
171k
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
1.88k
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
301
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
8
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
10.3k
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
6.69k
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
65
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
94
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
76.9k
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
1.15k
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
388
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
428
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
495
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
153
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
284
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
86
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
65
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
163
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
98
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
48.8k
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
153
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
188
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
44
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
21.5k
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
488
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
36
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
36
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
36
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
61
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
49
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
350
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
2.54M
      }
85
2.54M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
111k
      switch (UnOp->getOpcode()) {
87
18.0k
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
318
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
69.9k
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
189
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
929
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
20.4k
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
952
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
87
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
44
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
48
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
52
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
40
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
2.43M
      }
102
2.43M
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
2.43M
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
2.43M
    }
112
2.43M
  }
SemaChecking.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::SequenceChecker, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
52.6M
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
52.6M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
5.22M
      switch (BinOp->getOpcode()) {
49
345
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
245
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
196k
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
457k
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
9.45k
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
1.10M
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
1.07M
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
51.3k
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
17.7k
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
209k
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
179k
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
22.2k
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
17.7k
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
112k
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
42.8k
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
328
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
76.7k
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
17.4k
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
49.6k
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
132k
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
44.3k
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
1.33M
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
3.00k
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
2.25k
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
319
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
36.5k
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
4.93k
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
602
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
278
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
1.27k
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
9.76k
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
1.65k
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
12.5k
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
47.4M
      }
85
47.4M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
810k
      switch (UnOp->getOpcode()) {
87
52.9k
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
746
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
166k
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
11.2k
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
79.6k
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
113k
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
356
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
173k
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
39.7k
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
137k
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
208
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
181
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
35.3k
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
46.6M
      }
102
46.6M
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
46.6M
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
46.6M
    }
112
46.6M
  }
SemaChecking.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::FindCaptureVisitor, void>::Visit(clang::Stmt*)
Line
Count
Source
43
140
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
140
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
2
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
1
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
1
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
138
      }
85
138
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
0
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
138
      }
102
138
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
138
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
138
    }
112
138
  }
SemaDecl.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::SelfReferenceChecker, void>::Visit(clang::Stmt*)
Line
Count
Source
43
1.45M
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
1.45M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
164k
      switch (BinOp->getOpcode()) {
49
25
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
3
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
33.5k
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
40.5k
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
80
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
13.5k
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
13.3k
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
11.1k
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
10
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
25.2k
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
47
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
8.68k
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
538
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
6.64k
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
35
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
78
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
852
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
2.33k
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
1.02k
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
6.03k
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
469
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
376
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
7
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
1
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
4
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
19
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
1
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
4
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
1
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
1
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
1
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
1
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
196
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
1.28M
      }
85
1.28M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
45.7k
      switch (UnOp->getOpcode()) {
87
38
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
2
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
35
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
5
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
11.8k
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
5.32k
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
10
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
19.8k
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
4.84k
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
3.74k
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
3
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
3
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
1.23M
      }
102
1.23M
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
1.23M
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
1.23M
    }
112
1.23M
  }
SemaDeclCXX.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::UninitializedFieldVisitor, void>::Visit(clang::Stmt*)
Line
Count
Source
43
54.8k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
54.8k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
1.86k
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
49
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
8
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
1.75k
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
4
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
6
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
3
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
4
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
3
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
16
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
3
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
9
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
53.0k
      }
85
53.0k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
167
      switch (UnOp->getOpcode()) {
87
20
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
16
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
101
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
18
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
11
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
1
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
52.8k
      }
102
52.8k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
52.8k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
52.8k
    }
112
52.8k
  }
SemaDeclCXX.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::CheckDefaultArgumentVisitor, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
113k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
113k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
810
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
3
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
34
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
14
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
4
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
743
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
12
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
112k
      }
85
112k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
65
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
13
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
52
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
112k
      }
102
112k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
112k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
112k
    }
112
112k
  }
SemaExpr.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::RebuildUnknownAnyFunction, clang::ActionResult<clang::Expr*, true> >::Visit(clang::Stmt*)
Line
Count
Source
43
5
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
5
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
0
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
5
      }
85
5
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
0
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
5
      }
102
5
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
5
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
5
    }
112
5
  }
SemaExpr.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::EvaluatedExprMarker, void>::Visit(clang::Stmt*)
Line
Count
Source
43
157k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
157k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
168
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
37
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
13
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
20
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
88
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
10
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
157k
      }
85
157k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
29
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
14
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
15
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
157k
      }
102
157k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
157k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
157k
    }
112
157k
  }
SemaExpr.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::RebuildUnknownAnyExpr, clang::ActionResult<clang::Expr*, true> >::Visit(clang::Stmt*)
Line
Count
Source
43
763
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
763
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
0
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
763
      }
85
763
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
4
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
4
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
759
      }
102
759
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
759
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
759
    }
112
759
  }
SemaExprObjC.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::ARCCastChecker, (anonymous namespace)::ACCResult>::Visit(clang::Stmt*)
Line
Count
Source
43
1.77k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
1.77k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
3
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
3
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
1.77k
      }
85
1.77k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
3
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
3
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
1.76k
      }
102
1.76k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
1.76k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
1.76k
    }
112
1.76k
  }
SemaOpenMP.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::AllocatorChecker, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
296
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
296
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
0
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
296
      }
85
296
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
0
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
296
      }
102
296
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
296
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
296
    }
112
296
  }
SemaOpenMP.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::(anonymous namespace)::LoopCounterRefChecker, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
347k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
347k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
564
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
90
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
44
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
378
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
52
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
347k
      }
85
347k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
499
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
4
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
144
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
333
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
18
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
346k
      }
102
346k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
346k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
346k
    }
112
346k
  }
SemaOpenMP.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::DSARefChecker, bool>::Visit(clang::Stmt*)
Line
Count
Source
43
14.9k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
14.9k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
0
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
14.9k
      }
85
14.9k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
0
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
14.9k
      }
102
14.9k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
14.9k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
14.9k
    }
112
14.9k
  }
SemaOpenMP.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::MapBaseChecker, bool>::Visit(clang::Stmt*)
Line
Count
Source
43
64.6k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
64.6k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
489
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
486
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
3
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
64.1k
      }
85
64.1k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
631
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
631
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
63.5k
      }
102
63.5k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
63.5k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
63.5k
    }
112
63.5k
  }
SemaOpenMP.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::LocalVarRefChecker, bool>::Visit(clang::Stmt const*)
Line
Count
Source
43
2.17k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
2.17k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
0
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
2.17k
      }
85
2.17k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
0
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
2.17k
      }
102
2.17k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
2.17k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
2.17k
    }
112
2.17k
  }
SemaOpenMP.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::DSAAttrChecker, void>::Visit(clang::Stmt*)
Line
Count
Source
43
2.39M
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
2.39M
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
210k
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
1.39k
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
156
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
7.92k
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
19.9k
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
107k
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
1.59k
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
388
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
624
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
336
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
249
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
80
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
53.0k
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
108
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
138
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
16
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
16.0k
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
820
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
17
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
13
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
404
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
2.17M
      }
85
2.17M
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
121k
      switch (UnOp->getOpcode()) {
87
30.3k
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
380
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
89.0k
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
179
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
225
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
672
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
712
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
296
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
40
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
2.05M
      }
102
2.05M
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
2.05M
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
2.05M
    }
112
2.05M
  }
SemaStmt.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::BreakContinueFinder, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
54.6k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
54.6k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
8.95k
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
48
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
7
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
11
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
32
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
3
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
76
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
8.20k
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
74
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
79
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
23
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
57
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
50
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
30
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
23
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
61
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
4
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
4
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
4
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
22
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
4
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
4
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
15
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
4
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
4
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
4
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
110
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
45.6k
      }
85
45.6k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
8.48k
      switch (UnOp->getOpcode()) {
87
957
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
35
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
7.34k
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
38
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
24
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
63
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
17
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
9
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
37.1k
      }
102
37.1k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
37.1k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
37.1k
    }
112
37.1k
  }
SemaStmt.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::DeclExtractor, void>::Visit(clang::Stmt*)
Line
Count
Source
43
643
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
643
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
141
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
88
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
2
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
40
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
3
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
6
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
2
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
502
      }
85
502
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
4
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
1
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
2
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
1
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
498
      }
102
498
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
498
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
498
    }
112
498
  }
SemaStmt.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::DeclMatcher, void>::Visit(clang::Stmt*)
Line
Count
Source
43
613
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
613
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
157
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
92
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
2
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
33
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
3
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
6
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
2
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
19
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
456
      }
85
456
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
32
      switch (UnOp->getOpcode()) {
87
2
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
23
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
1
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
2
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
2
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
2
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
424
      }
102
424
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
424
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
424
    }
112
424
  }
SemaStmt.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::CommaVisitor, void>::Visit(clang::Stmt*)
Line
Count
Source
43
822
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
822
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
180
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
140
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
5
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
35
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
642
      }
85
642
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
0
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
642
      }
102
642
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
642
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
642
    }
112
642
  }
SemaStmtAttr.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::CallExprFinder, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
23
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
23
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
3
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
2
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
1
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
20
      }
85
20
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
0
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
20
      }
102
20
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
20
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
20
    }
112
20
  }
AnalysisDeclContext.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::FindBlockDeclRefExprsVals, void>::Visit(clang::Stmt*)
Line
Count
Source
43
2.44k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
2.44k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
165
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
22
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
4
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
6
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
12
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
2
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
119
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
2.27k
      }
85
2.27k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
80
      switch (UnOp->getOpcode()) {
87
2
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
12
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
13
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
53
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
2.19k
      }
102
2.19k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
2.19k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
2.19k
    }
112
2.19k
  }
CalledOnceCheck.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::DeclRefFinder, clang::DeclRefExpr const*>::Visit(clang::Stmt const*)
Line
Count
Source
43
665
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
665
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
9
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
5
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
2
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
1
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
1
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
656
      }
85
656
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
6
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
2
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
4
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
650
      }
102
650
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
650
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
650
    }
112
650
  }
CalledOnceCheck.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::CalledOnceChecker, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
953
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
953
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
24
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
1
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
2
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
3
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
5
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
2
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
8
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
2
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
1
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
929
      }
85
929
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
11
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
3
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
2
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
2
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
4
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
918
      }
102
918
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
918
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
918
    }
112
918
  }
CalledOnceCheck.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::NotCalledClarifier, llvm::Optional<(anonymous namespace)::Clarification> >::Visit(clang::Stmt const*)
Line
Count
Source
43
39
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
39
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
2
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
1
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
1
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
37
      }
85
37
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
0
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
37
      }
102
37
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
37
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
37
    }
112
37
  }
CFG.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::CFGBlockTerminatorPrint, void>::Visit(clang::Stmt*)
Line
Count
Source
43
535
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
535
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
37
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
0
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
0
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
9
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
28
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
498
      }
85
498
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
0
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
0
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
498
      }
102
498
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
498
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
498
    }
112
498
  }
clang::StmtVisitorBase<llvm::make_const_ptr, clang::consumed::ConsumedStmtVisitor, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
2.31k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
2.31k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
145
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
4
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
4
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
4
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
4
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
4
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
2
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
2
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
7
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
5
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
4
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
4
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
4
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
4
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
2
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
2
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
2
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
3
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
4
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
65
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
2
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
2
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
2
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
2
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
2
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
1
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
1
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
1
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
1
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
1
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
2.16k
      }
85
2.16k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
23
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
1
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
1
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
3
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
1
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
17
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
2.14k
      }
102
2.14k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
2.14k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
2.14k
    }
112
2.14k
  }
ThreadSafety.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::VarMapBuilder, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
34.2k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
34.2k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
1.89k
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
4
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
4
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
4
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
104
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
4
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
2
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
2
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
10
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
36
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
4
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
4
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
171
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
16
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
2
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
2
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
6
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
9
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
5
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
1.48k
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
2
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
2
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
2
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
7
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
3
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
1
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
1
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
1
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
1
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
1
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
32.3k
      }
85
32.3k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
748
      switch (UnOp->getOpcode()) {
87
8
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
4
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
12
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
4
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
342
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
300
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
1
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
77
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
31.6k
      }
102
31.6k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
31.6k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
31.6k
    }
112
31.6k
  }
ThreadSafety.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::BuildLockset, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
34.0k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
34.0k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
1.89k
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
4
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
4
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
4
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
104
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
4
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
2
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
2
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
10
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
36
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
4
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
4
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
171
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
16
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
2
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
2
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
6
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
9
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
5
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
1.48k
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
2
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
2
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
2
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
7
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
3
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
1
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
1
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
1
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
1
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
1
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
32.1k
      }
85
32.1k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
740
      switch (UnOp->getOpcode()) {
87
8
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
4
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
12
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
4
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
342
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
300
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
1
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
69
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
31.4k
      }
102
31.4k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
31.4k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
31.4k
    }
112
31.4k
  }
UninitializedValues.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::TransferFunctions, void>::Visit(clang::Stmt*)
Line
Count
Source
43
59.5k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
59.5k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
6.08k
      switch (BinOp->getOpcode()) {
49
2
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
89
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
8
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
22
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
203
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
70
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
100
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
11
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
1.77k
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
130
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
65
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
65
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
256
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
278
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
81
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
2
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
14
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
9
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
19
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
2.53k
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
13
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
2
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
2
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
189
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
2
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
19
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
19
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
1
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
29
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
1
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
79
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
53.4k
      }
85
53.4k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
1.52k
      switch (UnOp->getOpcode()) {
87
46
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
948
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
193
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
164
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
153
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
1
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
17
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
51.9k
      }
102
51.9k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
51.9k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
51.9k
    }
112
51.9k
  }
UninitializedValues.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::ClassifyRefs, void>::Visit(clang::Stmt*)
Line
Count
Source
43
43.7k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
43.7k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
4.68k
      switch (BinOp->getOpcode()) {
49
1
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
89
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
6
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
22
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
102
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
68
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
100
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
11
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
950
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
130
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
63
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
65
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
297
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
114
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
81
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
2
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
14
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
7
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
17
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
2.23k
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
20
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
2
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
2
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
166
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
2
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
19
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
19
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
1
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
29
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
1
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
57
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
39.0k
      }
85
39.0k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
1.35k
      switch (UnOp->getOpcode()) {
87
34
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
876
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
178
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
83
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
168
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
1
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
13
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
37.7k
      }
102
37.7k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
37.7k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
37.7k
    }
112
37.7k
  }
CGClass.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::DynamicThisUseChecker, void>::Visit(clang::Stmt const*)
Line
Count
Source
43
32.3k
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
32.3k
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
13
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   BinaryOperator);
50
0
      case BO_PtrMemI:   DISPATCH(BinPtrMemI,   BinaryOperator);
51
3
      case BO_Mul:       DISPATCH(BinMul,       BinaryOperator);
52
0
      case BO_Div:       DISPATCH(BinDiv,       BinaryOperator);
53
0
      case BO_Rem:       DISPATCH(BinRem,       BinaryOperator);
54
10
      case BO_Add:       DISPATCH(BinAdd,       BinaryOperator);
55
0
      case BO_Sub:       DISPATCH(BinSub,       BinaryOperator);
56
0
      case BO_Shl:       DISPATCH(BinShl,       BinaryOperator);
57
0
      case BO_Shr:       DISPATCH(BinShr,       BinaryOperator);
58
59
0
      case BO_LT:        DISPATCH(BinLT,        BinaryOperator);
60
0
      case BO_GT:        DISPATCH(BinGT,        BinaryOperator);
61
0
      case BO_LE:        DISPATCH(BinLE,        BinaryOperator);
62
0
      case BO_GE:        DISPATCH(BinGE,        BinaryOperator);
63
0
      case BO_EQ:        DISPATCH(BinEQ,        BinaryOperator);
64
0
      case BO_NE:        DISPATCH(BinNE,        BinaryOperator);
65
0
      case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
66
67
0
      case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
68
0
      case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
69
0
      case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
70
0
      case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
71
0
      case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
72
0
      case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
73
0
      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
74
0
      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
75
0
      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
76
0
      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
77
0
      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
78
0
      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
79
0
      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
80
0
      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
81
0
      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
82
0
      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
83
0
      case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
84
32.3k
      }
85
32.3k
    } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
86
10
      switch (UnOp->getOpcode()) {
87
0
      case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
88
0
      case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
89
0
      case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
90
0
      case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
91
10
      case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
92
0
      case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
93
0
      case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
94
0
      case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
95
0
      case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
96
0
      case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
97
0
      case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
98
0
      case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
99
0
      case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
100
0
      case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
101
32.3k
      }
102
32.3k
    }
103
104
    // Top switch stmt: dispatch to VisitFooStmt for each FooStmt.
105
32.3k
    switch (S->getStmtClass()) {
106
0
    default: llvm_unreachable("Unknown stmt kind!");
107
0
#define ABSTRACT_STMT(STMT)
108
0
#define STMT(CLASS, PARENT)                              \
109
0
    case Stmt::CLASS ## Class: DISPATCH(CLASS, CLASS);
110
0
#include "clang/AST/StmtNodes.inc"
111
32.3k
    }
112
32.3k
  }
CGCoroutine.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::GetParamRef, void>::Visit(clang::Stmt*)
Line
Count
Source
43
72
  RetTy Visit(PTR(Stmt) S, ParamTys... P) {
44
    // If we have a binary expr, dispatch to the subcode of the binop.  A smart
45
    // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
46
    // below.
47
72
    if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
48
0
      switch (BinOp->getOpcode()) {
49
0
      case BO_PtrMemD:   DISPATCH(BinPtrMemD,   Binary