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
|
|